diff --git a/config/scripts/node-pty-windows-pty-teardown-patch.test.mjs b/config/scripts/node-pty-windows-pty-teardown-patch.test.mjs
index ba3e64bfa2f..d9ee133a70e 100644
--- a/config/scripts/node-pty-windows-pty-teardown-patch.test.mjs
+++ b/config/scripts/node-pty-windows-pty-teardown-patch.test.mjs
@@ -9,9 +9,9 @@
 //
 // Those numbers are the `!useConptyDll` branch, which is the branch a RELAY runs. Every desktop
 // site that opens a terminal pane sets `useConptyDll: true` and takes the other branch, where
-// upstream already destroys the input socket. Two hidden rate-limit probes
-// (`src/main/rate-limits/claude-pty.ts`, `codex-pty-rate-limit-probe.ts`) do omit the option and so
-// do run this hunk, but no user-visible pane does. The divergence pinned below is about which
+// upstream already destroys the input socket. The hidden rate-limit probe
+// (`src/main/rate-limits/claude-pty.ts`) does omit the option and so does run this hunk, but no
+// user-visible pane does. The divergence pinned below is about which
 // branch each host runs for terminals -- not about a regression in the panes users open.
 import { createRequire } from 'node:module'
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
diff --git a/config/tsconfig.cli.json b/config/tsconfig.cli.json
index cd47d038c2a..2d41bdc4412 100644
--- a/config/tsconfig.cli.json
+++ b/config/tsconfig.cli.json
@@ -107,6 +107,7 @@
     "../src/main/claude/hook-settings.ts",
     "../src/main/claude/hook-service.ts",
     "../src/main/claude/statusline-script.ts",
+    "../src/main/claude/windows-hook-files.ts",
     "../src/main/claude-accounts/keychain.ts",
     "../src/main/macos-keychain/generic-password.ts",
     "../src/main/codex/codex-app-server-capability-cache.ts",
diff --git a/docs/reference/windows-edr-posture.md b/docs/reference/windows-edr-posture.md
index f1e63657f76..edb3a296337 100644
--- a/docs/reference/windows-edr-posture.md
+++ b/docs/reference/windows-edr-posture.md
@@ -274,7 +274,7 @@ _shorten the interpreter chain_ rather than to hide a window.
 #18875 is a worked example of that doctrine. The Claude Code lifecycle hook was
 registered as `powershell.exe -NoProfile -EncodedCommand <...>` whose entire
 decoded payload was a `Test-Path` and a call to `~/.orca/agent-hooks/claude-hook.cmd`.
-It now registers the script path itself (`<path> || echo {}`), so `bash ->
+It now registers the bare script path itself, with no shell operators, so `bash ->
 powershell -> cmd -> curl` became `bash -> cmd -> curl` and one
 `powershell.exe -EncodedCommand` per hook event — a first-class Defender alert
 title — leaves the tree. The reporting box fired ~6 900 of them in five days,
@@ -287,24 +287,24 @@ concurrency, invoked as Claude Code invokes it. **No EDR verdict on either tree
 was measured**, so claim the removed `-EncodedCommand` spelling and the shorter
 chain, not a score. `cmd.exe` remains in the tree, spelled by MSYS's own `.cmd`
 spawn rather than by us — the doc's one "unavoidable for `.cmd`/`.bat`" case,
-carrying an absolute path and two literal tokens, with no caret escaping, no
+carrying only an absolute path, with no caret escaping, no
 encoding and no free text. The encoded launcher is still the shape for profile
 paths the shells cannot carry bare (a space, `%`, `^`, `&`, non-ASCII, a UNC
-profile) and for hosts where Git Bash is not resolvable, because PowerShell 5.1
-rejects `||` (measured: parse error, exit 1).
+profile).
 
-That last clause is the standing assumption of this change, and it is worth
-stating plainly because it is **not** measured. `||` parses in Git Bash, cmd.exe
-and pwsh, but not in Windows PowerShell 5.1, so the direct shape is correct for
-any host that is one of the first three. Claude Code itself is a Git Bash host on
-native Windows. What no one here has verified is which host a _compat consumer_
-uses: cursor-agent and Devin import `~/.claude/settings.json` and run `command`
-through their own launcher (the managed `.cmd` carries a `DEVIN_PROJECT_DIR` skip
-for exactly that). If one of them spawns hook strings through Windows PowerShell
-5.1, its imported Claude events become a parse error with empty stdout, which is
-the fail-closed case #14818 exists to prevent. The encoded launcher had no such
-assumption — it was a `powershell.exe` invocation and therefore parsed anywhere.
-Before widening the direct shape to another agent, measure that consumer's host.
+The direct shape first shipped as `<path> || echo {}`, gated on Git Bash being
+resolvable. That gate guessed at a choice Claude Code makes on its own: it runs
+hooks under Windows PowerShell 5.1 when it picks PowerShell, and 5.1 rejects `||`
+(parse error, exit 1), so every hook failed (STA-8913). The registered command is
+now the bare path, which parses in Git Bash, cmd.exe, pwsh and PowerShell 5.1.
+The neutral `{}` for a missing payload lives in the `claude-hook.cmd` entry, which
+hands off to `claude-hook-impl.cmd` in the same `cmd.exe`; a deleted entry is an
+ordinary non-blocking hook error (never exit 2) until the next install rewrites it.
+Compat consumers such as cursor-agent and Devin import `~/.claude/settings.json`
+and run `command` through their own launcher (the payload carries a
+`DEVIN_PROJECT_DIR` skip for that); one that cannot start a `.cmd` at all still
+gets a launch failure. Before widening the direct shape to another agent, measure
+that consumer's host.
 
 ### Computer use: screen capture, synthetic input, runtime-compiled MSIL
 
diff --git a/mobile/src/session/mobile-native-chat-pending-pasted-content.test.ts b/mobile/src/session/mobile-native-chat-pending-pasted-content.test.ts
new file mode 100644
index 00000000000..3ea7171c6bb
--- /dev/null
+++ b/mobile/src/session/mobile-native-chat-pending-pasted-content.test.ts
@@ -0,0 +1,37 @@
+import { expect, it } from 'vitest'
+import type { NativeChatMessage } from '../../../src/shared/native-chat-types'
+import { retireLandedMobileNativeChatPending } from './mobile-native-chat-pending-retirement'
+
+const boundary: NativeChatMessage = {
+  id: 'boundary',
+  role: 'assistant',
+  blocks: [{ type: 'text', text: 'before' }],
+  timestamp: null,
+  source: 'transcript'
+}
+
+// An old host still sends Claude's raw paste envelope; the shared normalizer must match it.
+it('retires an echo against an old-host wrapped row and keeps the second identical send', () => {
+  const text = 'one\ntwo'
+  const echo: NativeChatMessage = {
+    ...boundary,
+    id: 'user',
+    role: 'user',
+    blocks: [{ type: 'text', text: `<pasted_content id="a">\n${text}\n</pasted_content id="a">` }]
+  }
+  const reply: NativeChatMessage = { ...boundary, id: 'reply' }
+  const entry = {
+    id: 'one',
+    text,
+    expectedOccurrence: 1,
+    baselineTailMessageId: 'boundary',
+    baselineResolved: true
+  }
+  expect(
+    retireLandedMobileNativeChatPending(
+      [boundary, echo, reply],
+      [entry, { ...entry, id: 'two', expectedOccurrence: 2 }],
+      new Set()
+    ).map((item) => item.id)
+  ).toEqual(['two'])
+})
diff --git a/mobile/src/terminal/document/document-scope.ts b/mobile/src/terminal/document/document-scope.ts
index 0095a3275ce..e63643d0d41 100644
--- a/mobile/src/terminal/document/document-scope.ts
+++ b/mobile/src/terminal/document/document-scope.ts
@@ -78,6 +78,8 @@ export type TerminalDocumentState = {
   lastEmittedModes: TerminalDocumentModes
   /** `terminal-init`: whether the terminal has ever reached ready. */
   everReady: boolean
+  /** `mouse-mode-decset-scan`: whether the encoding is proven (1006/1016 set or reset, RIS, or a live tracking enable). */
+  mouseEncodingKnown: boolean
   /** `mouse-mode-decset-scan`: the tail of the last chunk, in case a DECSET straddles two writes. */
   mouseModeScanTail: string
   /** `mouse-mode-decset-scan`: the mouse tracking mode the TUI last asked for. */
@@ -262,6 +264,7 @@ function createTerminalDocumentState(): TerminalDocumentState {
       sgrMousePixelsMode: false
     },
     everReady: false,
+    mouseEncodingKnown: false,
     mouseModeScanTail: '',
     trackedMouseTrackingMode: 'none',
     sgrMouseMode: false,
diff --git a/mobile/src/terminal/document/host-message-router.ts b/mobile/src/terminal/document/host-message-router.ts
index 0b155e1b70c..3d5352b3962 100644
--- a/mobile/src/terminal/document/host-message-router.ts
+++ b/mobile/src/terminal/document/host-message-router.ts
@@ -94,6 +94,7 @@ export function handleMsg(scope: TerminalDocumentScope, msg: TerminalHostMessage
     scope.statusDotPendingSelector = false
     scope.afterDrainCallbacks = []
     scope.writesDraining = false
+    scope.mouseEncodingKnown = false
     scope.mouseModeScanTail = ''
     scope.trackedMouseTrackingMode = 'none'
     scope.sgrMouseMode = false
diff --git a/mobile/src/terminal/document/mouse-click-drag.ts b/mobile/src/terminal/document/mouse-click-drag.ts
index 15af53d8646..dbae42668d4 100644
--- a/mobile/src/terminal/document/mouse-click-drag.ts
+++ b/mobile/src/terminal/document/mouse-click-drag.ts
@@ -24,7 +24,7 @@ export type TerminalMouseGesture = {
 // One report per transition, built with the same encoding ladder as
 // buildMouseClickInput: SGR pixels (1016) > SGR (1006) > default. Returns ''
 // when the mode does not report this transition (x10 has no release, only
-// drag/any report motion) or the cell is not encodable.
+// drag/any report motion), the encoding is unproven, or the cell is not encodable.
 export function buildMouseButtonReport(
   scope: TerminalDocumentScope,
   kind: string,
@@ -32,7 +32,7 @@ export function buildMouseButtonReport(
   clientY: number
 ) {
   const mouseTrackingMode = getMouseTrackingMode(scope)
-  if (mouseTrackingMode === 'none') {
+  if (mouseTrackingMode === 'none' || !scope.mouseEncodingKnown) {
     return ''
   }
   if (kind === 'motion' && mouseTrackingMode !== 'drag' && mouseTrackingMode !== 'any') {
@@ -103,7 +103,8 @@ export function abandonMouseGesture(scope: TerminalDocumentScope) {
 
 export function beginMouseDrag(scope: TerminalDocumentScope, gesture: TerminalMouseGesture) {
   gesture.moved = true
-  if (getMouseTrackingMode(scope) !== 'none') {
+  // Why: with no proven encoding the program would get no reports, so select locally instead.
+  if (getMouseTrackingMode(scope) !== 'none' && scope.mouseEncodingKnown) {
     gesture.mode = 'tracking'
     gesture.lastCellKey = mouseReportCellKey(scope, gesture.startX, gesture.startY)
     const press = buildMouseButtonReport(scope, 'press', gesture.startX, gesture.startY)
diff --git a/mobile/src/terminal/document/mouse-input-encoding.ts b/mobile/src/terminal/document/mouse-input-encoding.ts
index 8b6c8665c29..00b8988f903 100644
--- a/mobile/src/terminal/document/mouse-input-encoding.ts
+++ b/mobile/src/terminal/document/mouse-input-encoding.ts
@@ -61,6 +61,9 @@ export function buildMouseWheelSequence(
   clientX: number,
   clientY: number
 ) {
+  if (!scope.mouseEncodingKnown) {
+    return ''
+  }
   const cell = viewportToMouseReportCell(scope, clientX, clientY)
   if (!cell) {
     return ''
@@ -105,7 +108,7 @@ export function buildMouseClickInput(
   clientY: number
 ) {
   const mouseTrackingMode = getMouseTrackingMode(scope)
-  if (!isClickMouseTrackingMode(mouseTrackingMode)) {
+  if (!isClickMouseTrackingMode(mouseTrackingMode) || !scope.mouseEncodingKnown) {
     return ''
   }
   const cell = viewportToMouseReportCell(scope, clientX, clientY)
@@ -168,8 +171,18 @@ export function isWheelMouseTrackingMode(mode: string) {
   return mode !== 'none' && mode !== 'x10'
 }
 
+// Why: a replay can carry tracking without its encoding (?1006h/?1016h); a guessed
+// legacy report would type `ESC[M` bytes into the program, so scroll locally instead.
+export function isWheelEncodingUnproven(scope: TerminalDocumentScope, mode: string) {
+  return isWheelMouseTrackingMode(mode) && !scope.mouseEncodingKnown
+}
+
 export function shouldRouteScrollToTerminalInput(scope: TerminalDocumentScope) {
-  return isWheelMouseTrackingMode(getMouseTrackingMode(scope)) || isAlternateBufferActive(scope)
+  const mode = getMouseTrackingMode(scope)
+  if (isWheelEncodingUnproven(scope, mode)) {
+    return false
+  }
+  return isWheelMouseTrackingMode(mode) || isAlternateBufferActive(scope)
 }
 
 export function buildMouseWheelScrollInput(
@@ -221,6 +234,10 @@ export function routeScrollLines(
   }
   const mouseTrackingMode = getMouseTrackingMode(scope)
   const alternateBufferActive = isAlternateBufferActive(scope)
+  if (isWheelEncodingUnproven(scope, mouseTrackingMode)) {
+    scope.term.scrollLines(lines)
+    return
+  }
   if (isWheelMouseTrackingMode(mouseTrackingMode)) {
     // Why: xterm sends wheel events to mouse-aware TUIs before considering
     // scrollback, even if the app stays on the normal buffer.
diff --git a/mobile/src/terminal/document/mouse-mode-decset-scan.ts b/mobile/src/terminal/document/mouse-mode-decset-scan.ts
index 05490ce0b0f..8850db110c9 100644
--- a/mobile/src/terminal/document/mouse-mode-decset-scan.ts
+++ b/mobile/src/terminal/document/mouse-mode-decset-scan.ts
@@ -22,7 +22,8 @@ export function normalizeInitialData(data: unknown) {
   return on > 0 ? data.slice(on) : data
 }
 
-export function updateMouseModeFromData(scope: TerminalDocumentScope, data: unknown) {
+// `live`: bytes the program just wrote, as opposed to a snapshot replay.
+export function updateMouseModeFromData(scope: TerminalDocumentScope, data: unknown, live = false) {
   if (typeof data !== 'string' || data.length === 0) {
     return
   }
@@ -35,6 +36,7 @@ export function updateMouseModeFromData(scope: TerminalDocumentScope, data: unkn
   let match: RegExpExecArray | null
   while ((match = re.exec(input)) !== null) {
     if (match[0] === ESC + 'c') {
+      scope.mouseEncodingKnown = true
       scope.trackedMouseTrackingMode = 'none'
       scope.sgrMouseMode = false
       scope.sgrMousePixelsMode = false
@@ -50,6 +52,11 @@ export function updateMouseModeFromData(scope: TerminalDocumentScope, data: unkn
       if (!Number.isInteger(param)) {
         continue
       }
+      // Why: a program enabling tracking live states its encoding in that same burst, or
+      // means the default; only a replay can carry tracking without its encoding.
+      if (live && enabled && (param === 9 || param === 1000 || param === 1002 || param === 1003)) {
+        scope.mouseEncodingKnown = true
+      }
       if (param === 9) {
         scope.trackedMouseTrackingMode = enabled ? 'x10' : 'none'
       }
@@ -63,10 +70,12 @@ export function updateMouseModeFromData(scope: TerminalDocumentScope, data: unkn
         scope.trackedMouseTrackingMode = enabled ? 'any' : 'none'
       }
       if (param === 1006) {
+        scope.mouseEncodingKnown = true
         scope.sgrMouseMode = enabled
         scope.sgrMousePixelsMode = false
       }
       if (param === 1016) {
+        scope.mouseEncodingKnown = true
         scope.sgrMouseMode = false
         scope.sgrMousePixelsMode = enabled
       }
diff --git a/mobile/src/terminal/document/surface-tap.ts b/mobile/src/terminal/document/surface-tap.ts
index a271cd97941..8c17eba19ec 100644
--- a/mobile/src/terminal/document/surface-tap.ts
+++ b/mobile/src/terminal/document/surface-tap.ts
@@ -59,7 +59,12 @@ export function notifyTerminalSurfaceTap(
     notify(scope, { type: 'terminal-input', bytes: clickInput })
   }
   // Touch still needs native input focus after the TUI consumes its mouse click.
-  if (focusKeyboard || !isClickMouseTrackingMode(getMouseTrackingMode(scope))) {
+  // A click with an unproven encoding reached no program, so it acts as a plain tap.
+  if (
+    focusKeyboard ||
+    !isClickMouseTrackingMode(getMouseTrackingMode(scope)) ||
+    !scope.mouseEncodingKnown
+  ) {
     notify(scope, { type: 'terminal-tap' })
   }
 }
diff --git a/mobile/src/terminal/document/terminal-init.ts b/mobile/src/terminal/document/terminal-init.ts
index 04e90b4578e..091321503b6 100644
--- a/mobile/src/terminal/document/terminal-init.ts
+++ b/mobile/src/terminal/document/terminal-init.ts
@@ -122,6 +122,7 @@ export function init(
   scope.wheelAccumDeltaY = 0
   scope.mouseModeScanTail = ''
   scope.trackedMouseTrackingMode = 'none'
+  scope.mouseEncodingKnown = false
   scope.sgrMouseMode = false
   scope.sgrMousePixelsMode = false
   scope.lastEmittedModes = {
@@ -208,7 +209,7 @@ export function init(
 }
 
 export function write(scope: TerminalDocumentScope, data: string) {
-  updateMouseModeFromData(scope, data)
+  updateMouseModeFromData(scope, data, true)
   enqueueWrite(scope, data)
   pumpWrites(scope, scope.terminalGeneration)
   // Why: first live data chunk after init may widen the buffer past
diff --git a/mobile/src/terminal/terminal-mouse-authority.test.ts b/mobile/src/terminal/terminal-mouse-authority.test.ts
new file mode 100644
index 00000000000..0ea7df16dd2
--- /dev/null
+++ b/mobile/src/terminal/terminal-mouse-authority.test.ts
@@ -0,0 +1,144 @@
+// @vitest-environment happy-dom
+import { describe, expect, it } from 'vitest'
+import { ESC, useTerminalMouseWebViewHarness } from './terminal-webview-mouse-test-harness'
+
+type DocumentMessage = {
+  type: string
+  data?: string
+  cols?: number
+  rows?: number
+  initialData?: string
+}
+
+function message(data: DocumentMessage) {
+  window.dispatchEvent(new MessageEvent('message', { data: JSON.stringify(data) }))
+}
+
+function wheel(deltaY = 120) {
+  document.getElementById('terminal-surface')!.dispatchEvent(
+    new WheelEvent('wheel', {
+      bubbles: true,
+      cancelable: true,
+      deltaY,
+      clientX: 40,
+      clientY: 60
+    })
+  )
+}
+
+function swipe() {
+  const surface = document.getElementById('terminal-surface')!
+  for (const [type, y] of [
+    ['touchstart', 240],
+    ['touchmove', 120],
+    ['touchend', 120]
+  ] as const) {
+    const event = new Event(type, { bubbles: true, cancelable: true })
+    const touch = { identifier: 1, clientX: 40, clientY: y }
+    Object.defineProperty(event, 'touches', { value: type === 'touchend' ? [] : [touch] })
+    Object.defineProperty(event, 'changedTouches', { value: [touch] })
+    surface.dispatchEvent(event)
+  }
+}
+
+function touchTap() {
+  const surface = document.getElementById('terminal-surface')!
+  for (const type of ['touchstart', 'touchend']) {
+    const event = new Event(type, { bubbles: true, cancelable: true })
+    const touches = type === 'touchend' ? [] : [{ identifier: 0, clientX: 40, clientY: 60 }]
+    Object.defineProperty(event, 'touches', {
+      value: touches.map((touch) => ({ ...touch, target: surface }))
+    })
+    Object.defineProperty(event, 'target', { value: surface })
+    document.dispatchEvent(event)
+  }
+}
+
+// What a desktop pane snapshot looks like: normal-buffer scrollback, the alternate screen, the
+// tracking modes the serializer writes, then the encoding the pane appends at the very end.
+const PANE_PREFIX = `scrollback\r\n${ESC}[?1049h${ESC}[H codex prompt${ESC}[?1003h`
+
+describe('mobile mouse encoding proof', () => {
+  const mouse = useTerminalMouseWebViewHarness()
+
+  function bootAltScreen(initialData: string, mode = 'any') {
+    mouse.boot(initialData)
+    mouse.showAlternateBuffer()
+    mouse.activeTerminal().modes.mouseTrackingMode = mode
+    mouse.clearPostedMessages()
+  }
+
+  it('reports a swipe and a wheel as SGR from a pane snapshot that ends with ?1006h', () => {
+    bootAltScreen(`${PANE_PREFIX}${ESC}[?1006h`)
+    swipe()
+    wheel(-120)
+    const bytes = mouse.terminalInputBytes()
+    expect(bytes).toContain(`${ESC}[<64;`)
+    wheel()
+    expect(mouse.terminalInputBytes()).toContain(`${ESC}[<65;`)
+    expect(mouse.terminalInputBytes()).not.toContain(`${ESC}[M`)
+  })
+
+  it('loses an encoding that sits before the alternate screen the phone replays from', () => {
+    bootAltScreen(`${ESC}[?1006h${PANE_PREFIX}`)
+    wheel()
+    expect(mouse.terminalInputBytes()).toBe('')
+  })
+
+  it('sends nothing for a wheel, a swipe or a tap while tracking has no proven encoding', () => {
+    bootAltScreen(PANE_PREFIX)
+    wheel()
+    swipe()
+    touchTap()
+    expect(mouse.terminalInputBytes()).toBe('')
+    expect(mouse.postedMessages().filter((posted) => posted.type === 'terminal-tap')).toHaveLength(
+      1
+    )
+  })
+
+  it.each([
+    ['SGR', '?1006h', '[<65;'],
+    ['pixel', '?1016h', '[<65;'],
+    ['explicit legacy', '?1006l', '[Ma']
+  ])('keeps %s encoding proven by a live write', (_name, mode, prefix) => {
+    mouse.boot()
+    mouse.activeTerminal().modes.mouseTrackingMode = 'any'
+    message({ type: 'write', data: `${ESC}[${mode}${ESC}[?1003h` })
+    wheel()
+    expect(mouse.terminalInputBytes()).toContain(`${ESC}${prefix}`)
+  })
+
+  it('reports legacy wheel input from a pane snapshot that states the default encoding', () => {
+    bootAltScreen(`${PANE_PREFIX}${ESC}[?1006l`)
+    wheel()
+    expect(mouse.terminalInputBytes()).toContain(`${ESC}[Ma`)
+  })
+
+  it('reports legacy wheel input for a program that enables tracking live without an encoding', () => {
+    mouse.boot()
+    message({ type: 'write', data: `${ESC}[?1049h${ESC}[?1000h` })
+    mouse.showAlternateBuffer()
+    mouse.activeTerminal().modes.mouseTrackingMode = 'vt200'
+    wheel()
+    expect(mouse.terminalInputBytes()).toContain(`${ESC}[Ma`)
+  })
+
+  it('forgets encoding proof on the next snapshot', () => {
+    mouse.boot()
+    message({ type: 'write', data: `${ESC}[?1006l` })
+    message({ type: 'init', cols: 40, rows: 24, initialData: `${ESC}[?1003h` })
+    mouse.activeTerminal().modes.mouseTrackingMode = 'any'
+    wheel()
+    expect(mouse.terminalInputBytes()).toBe('')
+  })
+
+  it('keeps arrow-key scrolling for a click-only (x10) program on the alternate screen', () => {
+    bootAltScreen(`${ESC}[?1049h${ESC}[?9h`, 'x10')
+    wheel(-120)
+    swipe()
+    const bytes = mouse.terminalInputBytes()
+    expect(bytes).toContain(`${ESC}[B`)
+    expect(bytes).toContain(`${ESC}[A`)
+    expect(bytes).not.toContain(`${ESC}[M`)
+  })
+})
diff --git a/mobile/src/terminal/terminal-webview-mouse-click.test.ts b/mobile/src/terminal/terminal-webview-mouse-click.test.ts
index 4c519deeef1..97056437468 100644
--- a/mobile/src/terminal/terminal-webview-mouse-click.test.ts
+++ b/mobile/src/terminal/terminal-webview-mouse-click.test.ts
@@ -7,6 +7,7 @@ describe('terminal WebView external mouse click', () => {
 
   it('reports a mouse click to a click-tracking TUI the way a touch tap does (#8818)', () => {
     mouse.boot()
+    mouse.writeLegacyMouseEncoding()
     mouse.activeTerminal().modes.mouseTrackingMode = 'vt200'
 
     mouse.mouseClick(40, 60)
@@ -21,6 +22,18 @@ describe('terminal WebView external mouse click', () => {
     expect(mouse.postedMessages().filter((message) => message.type === 'terminal-tap')).toEqual([])
   })
 
+  it('sends no click report and focuses the keyboard while the encoding is unproven', () => {
+    mouse.boot()
+    mouse.activeTerminal().modes.mouseTrackingMode = 'vt200'
+
+    mouse.mouseClick(40, 60)
+
+    expect(mouse.terminalInputBytes()).toBe('')
+    expect(
+      mouse.postedMessages().filter((message) => message.type === 'terminal-tap')
+    ).toHaveLength(1)
+  })
+
   it('dismisses an existing selection with a click without focusing the keyboard', () => {
     mouse.boot()
     mouse.mouseDrag(40, 60, 160, 90)
diff --git a/mobile/src/terminal/terminal-webview-mouse-drag.test.ts b/mobile/src/terminal/terminal-webview-mouse-drag.test.ts
index e4fac512873..aefbd3df325 100644
--- a/mobile/src/terminal/terminal-webview-mouse-drag.test.ts
+++ b/mobile/src/terminal/terminal-webview-mouse-drag.test.ts
@@ -11,6 +11,7 @@ describe('terminal WebView external mouse drag', () => {
 
   it('sends press, per-cell motion, and release for a drag-tracking mouse drag', () => {
     mouse.boot()
+    mouse.writeLegacyMouseEncoding()
     mouse.activeTerminal().modes.mouseTrackingMode = 'drag'
 
     mouse.mouseDrag(40, 60, 160, 60)
@@ -29,6 +30,7 @@ describe('terminal WebView external mouse drag', () => {
 
   it('does not report motion or release for an x10 click-only TUI drag', () => {
     mouse.boot()
+    mouse.writeLegacyMouseEncoding()
     mouse.activeTerminal().modes.mouseTrackingMode = 'x10'
 
     mouse.mouseDrag(40, 60, 160, 60)
@@ -53,8 +55,20 @@ describe('terminal WebView external mouse drag', () => {
     expect(modes).toEqual([{ type: 'set-select-mode', enabled: true }])
   })
 
+  it('selects text instead of reporting a drag while the encoding is unproven', () => {
+    mouse.boot(`${ESC}[?1002h`)
+    mouse.activeTerminal().modes.mouseTrackingMode = 'drag'
+    mouse.clearPostedMessages()
+
+    mouse.mouseDrag(40, 60, 160, 90)
+
+    expect(mouse.terminalInputBytes()).toBe('')
+    expect(mouse.selectionSpy()).toHaveBeenCalled()
+  })
+
   it('releases a tracked drag when the button state shows the pointerup was lost', () => {
     mouse.boot()
+    mouse.writeLegacyMouseEncoding()
     mouse.activeTerminal().modes.mouseTrackingMode = 'drag'
 
     mouse.dispatchPointer('pointerdown', { x: 40, y: 60, button: 0, buttons: 1 })
@@ -74,6 +88,7 @@ describe('terminal WebView external mouse drag', () => {
 
   it('releases a tracked drag when the pointer is cancelled mid-gesture', () => {
     mouse.boot()
+    mouse.writeLegacyMouseEncoding()
     mouse.activeTerminal().modes.mouseTrackingMode = 'drag'
 
     mouse.dispatchPointer('pointerdown', { x: 40, y: 60, button: 0, buttons: 1 })
diff --git a/mobile/src/terminal/terminal-webview-mouse-test-harness.ts b/mobile/src/terminal/terminal-webview-mouse-test-harness.ts
index 41a6b2b7a62..6342b88d1f8 100644
--- a/mobile/src/terminal/terminal-webview-mouse-test-harness.ts
+++ b/mobile/src/terminal/terminal-webview-mouse-test-harness.ts
@@ -150,12 +150,12 @@ export function useTerminalMouseWebViewHarness() {
   let select: Select
   let terminals: TerminalStub[]
 
-  function boot(): void {
+  function boot(initialData = ''): void {
     document.body.innerHTML = bodyMarkup()
     runInThisContext(TERMINAL_DOCUMENT_SCRIPT)
     window.dispatchEvent(
       new MessageEvent('message', {
-        data: JSON.stringify({ type: 'init', cols: 40, rows: 24, initialData: '' })
+        data: JSON.stringify({ type: 'init', cols: 40, rows: 24, initialData })
       })
     )
     // Why: init commits the replacement surface on the next animation frame.
@@ -164,6 +164,15 @@ export function useTerminalMouseWebViewHarness() {
     }
   }
 
+  // Why: the document sends no mouse report until replayed bytes prove the encoding.
+  function writeLegacyMouseEncoding(): void {
+    window.dispatchEvent(
+      new MessageEvent('message', {
+        data: JSON.stringify({ type: 'write', data: `${ESC}[?1006l` })
+      })
+    )
+  }
+
   function activeTerminal(): TerminalStub {
     const terminal = terminals.at(-1)
     if (!terminal) {
@@ -231,6 +240,9 @@ export function useTerminalMouseWebViewHarness() {
   return {
     activeTerminal,
     boot,
+    showAlternateBuffer: () => {
+      buffer.type = 'alternate'
+    },
     clearPostedMessages: () => postMessage.mockClear(),
     dispatchPointer,
     mouseClick,
@@ -238,6 +250,7 @@ export function useTerminalMouseWebViewHarness() {
     postedMessages: () => postedMessages(postMessage),
     selectionSpy: () => select,
     terminalInputBytes: () => terminalInputBytes(postMessage),
-    terminalSurface
+    terminalSurface,
+    writeLegacyMouseEncoding
   }
 }
diff --git a/mobile/src/terminal/terminal-webview-tap-routing.test.ts b/mobile/src/terminal/terminal-webview-tap-routing.test.ts
index 0db190b738b..bc70b7ae52f 100644
--- a/mobile/src/terminal/terminal-webview-tap-routing.test.ts
+++ b/mobile/src/terminal/terminal-webview-tap-routing.test.ts
@@ -148,6 +148,11 @@ describe('terminal WebView tap routing', () => {
   it('focuses native input after reporting a touch tap to a mouse-tracking TUI', async () => {
     const { posted } = boot('interactive prompt', undefined, 'drag')
     await settle()
+    window.dispatchEvent(
+      new MessageEvent('message', {
+        data: JSON.stringify({ type: 'write', data: '\u001b[?1006l' })
+      })
+    )
 
     fireTouch('touchstart', [{ x: 20, y: tapY }])
     fireTouch('touchend', [])
@@ -159,6 +164,17 @@ describe('terminal WebView tap routing', () => {
     ).toEqual(['terminal-input', 'terminal-tap'])
   })
 
+  it('focuses native input without mouse bytes while the tracking encoding is unproven', async () => {
+    const { posted } = boot('interactive prompt', undefined, 'drag')
+    await settle()
+
+    fireTouch('touchstart', [{ x: 20, y: tapY }])
+    fireTouch('touchend', [])
+
+    expect(posted.find((message) => message.type === 'terminal-input')).toBeUndefined()
+    expect(posted.filter((message) => message.type === 'terminal-tap')).toHaveLength(1)
+  })
+
   it('reports a non-mouse touch tap without terminal mouse bytes', async () => {
     const { posted } = boot('plain prompt')
     await settle()
diff --git a/mobile/src/terminal/terminal-webview-wheel-scroll.test.ts b/mobile/src/terminal/terminal-webview-wheel-scroll.test.ts
index decbc170720..f5e6be8fdb5 100644
--- a/mobile/src/terminal/terminal-webview-wheel-scroll.test.ts
+++ b/mobile/src/terminal/terminal-webview-wheel-scroll.test.ts
@@ -218,6 +218,11 @@ describe('terminal WebView external pointer wheel scrolling', () => {
       throw new Error('terminal missing')
     }
     terminal.modes.mouseTrackingMode = 'any'
+    window.dispatchEvent(
+      new MessageEvent('message', {
+        data: JSON.stringify({ type: 'write', data: `${ESC}[?1006l` })
+      })
+    )
 
     dispatchWheel(CELL_HEIGHT)
 
diff --git a/src/main/agent-hooks/managed-hook-command-contract.test.ts b/src/main/agent-hooks/managed-hook-command-contract.test.ts
index ebb1412ec58..04eb500c218 100644
--- a/src/main/agent-hooks/managed-hook-command-contract.test.ts
+++ b/src/main/agent-hooks/managed-hook-command-contract.test.ts
@@ -67,11 +67,7 @@ const buildersByAgent = new Map<string, CommandBuilders>([
   [
     'claude',
     {
-      local: (path) =>
-        [true, false].map(
-          (gitBashAvailable) =>
-            getManagedLifecycleHook(path, CLAUDE_HOOK_SETTINGS, { gitBashAvailable }).command
-        ),
+      local: (path) => [getManagedLifecycleHook(path, CLAUDE_HOOK_SETTINGS).command],
       remote: (path) => [getClaudeRemoteCommand(path)]
     }
   ],
diff --git a/src/main/agent-hooks/managed-hook-script-refresh-main-thread.test.ts b/src/main/agent-hooks/managed-hook-script-refresh-main-thread.test.ts
index dabbb93374c..ff21f8519bb 100644
--- a/src/main/agent-hooks/managed-hook-script-refresh-main-thread.test.ts
+++ b/src/main/agent-hooks/managed-hook-script-refresh-main-thread.test.ts
@@ -69,4 +69,21 @@ describe('managed hook script refresh stays off the main thread', () => {
 
     expect(syncCallsUnderHome()).toEqual([])
   })
+
+  it('keeps the Windows Claude entry and payload refresh off the main thread', async () => {
+    const platform = Object.getOwnPropertyDescriptor(process, 'platform')!
+    Object.defineProperty(process, 'platform', { configurable: true, value: 'win32' })
+    try {
+      const hooksDir = join(state.home, '.orca', 'agent-hooks')
+      await mkdir(hooksDir, { recursive: true })
+      await writeFile(join(hooksDir, 'claude-hook.cmd'), 'stale', 'utf-8')
+      state.syncCalls = []
+
+      await MANAGED_AGENT_HOOK_SCRIPT_REFRESHERS.find(([agent]) => agent === 'claude')![1]()
+
+      expect(syncCallsUnderHome()).toEqual([])
+    } finally {
+      Object.defineProperty(process, 'platform', platform)
+    }
+  })
 })
diff --git a/src/main/agent-hooks/managed-hook-script-refresh.test.ts b/src/main/agent-hooks/managed-hook-script-refresh.test.ts
index 799f8acf58c..4cd1905d8aa 100644
--- a/src/main/agent-hooks/managed-hook-script-refresh.test.ts
+++ b/src/main/agent-hooks/managed-hook-script-refresh.test.ts
@@ -40,6 +40,10 @@ const { homedirMock } = vi.hoisted(() => ({
   homedirMock: vi.fn<() => string>()
 }))
 
+vi.mock('../codex/codex-hook-trust-grant', () => ({
+  grantManagedCodexHookTrust: async () => ({ lane: 'fallback', reason: 'unsupported' })
+}))
+
 vi.mock('electron', () => ({
   app: {
     getPath: () => '/tmp/orca-user-data'
diff --git a/src/main/agent-hooks/managed-hook-script-refresh.ts b/src/main/agent-hooks/managed-hook-script-refresh.ts
index 5842a9dfbfe..4de9f3ab24c 100644
--- a/src/main/agent-hooks/managed-hook-script-refresh.ts
+++ b/src/main/agent-hooks/managed-hook-script-refresh.ts
@@ -1,5 +1,5 @@
 import { randomUUID } from 'node:crypto'
-import { chmod, readFile, rename, rm, stat, writeFile } from 'node:fs/promises'
+import { chmod, mkdir, readFile, rename, rm, stat, writeFile } from 'node:fs/promises'
 import { dirname, join } from 'node:path'
 import { grantDirAclAsync, isPermissionError } from '../win32-utils'
 
@@ -28,7 +28,7 @@ async function readExistingScript(scriptPath: string): Promise<ExistingScript> {
   }
 }
 
-async function scriptStillExists(scriptPath: string): Promise<boolean> {
+export async function scriptStillExists(scriptPath: string): Promise<boolean> {
   try {
     await stat(scriptPath)
     return true
@@ -61,12 +61,26 @@ async function writeScriptWithAclRetry(scriptPath: string, content: string): Pro
 export async function refreshManagedScriptIfPresent(
   scriptPath: string,
   content: string
+): Promise<boolean> {
+  return writeManagedScriptAtomically(scriptPath, content, false)
+}
+
+// Callers must establish ownership from a surviving managed script or registration first.
+export async function restoreManagedScript(scriptPath: string, content: string): Promise<void> {
+  await mkdir(dirname(scriptPath), { recursive: true })
+  await writeManagedScriptAtomically(scriptPath, content, true)
+}
+
+async function writeManagedScriptAtomically(
+  scriptPath: string,
+  content: string,
+  allowMissing: boolean
 ): Promise<boolean> {
   const existing = await readExistingScript(scriptPath)
-  if (!existing.exists) {
+  if (!existing.exists && !allowMissing) {
     return false
   }
-  if (existing.content === content) {
+  if (existing.exists && existing.content === content) {
     if (process.platform !== 'win32') {
       await chmod(scriptPath, 0o755)
     }
@@ -79,7 +93,7 @@ export async function refreshManagedScriptIfPresent(
     if (process.platform !== 'win32') {
       await chmod(tmpPath, 0o755)
     }
-    if (!(await scriptStillExists(scriptPath))) {
+    if (!allowMissing && !(await scriptStillExists(scriptPath))) {
       return false
     }
     await rename(tmpPath, scriptPath)
diff --git a/src/main/agent-hooks/managed-hook-stdin-lifecycle.test.ts b/src/main/agent-hooks/managed-hook-stdin-lifecycle.test.ts
index cd6c336e751..ff7602b0689 100644
--- a/src/main/agent-hooks/managed-hook-stdin-lifecycle.test.ts
+++ b/src/main/agent-hooks/managed-hook-stdin-lifecycle.test.ts
@@ -34,6 +34,10 @@ const { homedirMock } = vi.hoisted(() => ({
   homedirMock: vi.fn<() => string>()
 }))
 
+vi.mock('../codex/codex-hook-trust-grant', () => ({
+  grantManagedCodexHookTrust: async () => ({ lane: 'fallback', reason: 'unsupported' })
+}))
+
 vi.mock('electron', () => ({
   app: {
     getPath: () => '/tmp/orca-user-data'
@@ -296,7 +300,7 @@ describe('Windows managed hook stdin structure', () => {
         expect(script, `${fileName} no ORCA_* guard may route to the more.com drain`).not.toMatch(
           /ORCA_[A-Z_]+.*goto :?orca_agent_hook_drain_stdin/
         )
-        // Why: the epilogue stays shared — claude-hook.cmd still jumps to it from the
+        // Why: the epilogue stays shared — claude-hook-impl.cmd still jumps to it from the
         // Devin-imports-.claude skip, which now sits below these guards.
         expect(script, `${fileName} drain epilogue`).toContain(
           [
@@ -310,7 +314,7 @@ describe('Windows managed hook stdin structure', () => {
       // Why (#11549): the Devin skip is the only remaining in-script jump to more.com, so it
       // must sit below the env guards — otherwise a Devin session outside an Orca pane still
       // parks there and strands the hook exactly like the pre-fix guards did.
-      const claude = readFileSync(join(hooksDir, 'claude-hook.cmd'), 'utf8')
+      const claude = readFileSync(join(hooksDir, 'claude-hook-impl.cmd'), 'utf8')
       expect(claude, 'claude devin guard present').toContain(
         'if not "%DEVIN_PROJECT_DIR%"=="" goto :orca_agent_hook_drain_stdin'
       )
@@ -524,7 +528,7 @@ describe('Windows managed hook stdin structure', () => {
             // Why: the encoded launcher resolves %USERPROFILE% at run time, so redirecting it is
             // what makes the script vanish for that shape. The direct launcher (#18875) carries
             // an absolute path, so here it asserts only that a bogus profile changes nothing; its
-            // missing-script fallback is covered live in windows-direct-cmd-hook-command.test.ts.
+            // missing-entry failure (never exit 2) is covered live in windows-direct-cmd-hook-command.test.ts.
             name: 'missing managed script',
             env: hookEnvironment({ USERPROFILE: absentProfile })
           }
diff --git a/src/main/agent-hooks/windows-direct-cmd-hook-command.test.ts b/src/main/agent-hooks/windows-direct-cmd-hook-command.test.ts
index acb4bf2d46d..d2acdb09acd 100644
--- a/src/main/agent-hooks/windows-direct-cmd-hook-command.test.ts
+++ b/src/main/agent-hooks/windows-direct-cmd-hook-command.test.ts
@@ -1,23 +1,23 @@
-// Why (#18875): the registered Windows Claude hook is now the script path itself, so this file
-// pins the two things that make that safe — the shape carries nothing MSYS or cmd.exe rewrites,
-// and it still answers with neutral JSON when the script is gone. The live legs run the string
-// through BOTH hosts Claude Code can pick, because the shape has to parse in either.
+// The registered command must not depend on the shell Claude selects.
 import { describe, expect, it } from 'vitest'
-import { execFileSync } from 'node:child_process'
+import { runProcess } from '../../shared/child-process/run-process'
 import { existsSync, mkdtempSync, readdirSync, writeFileSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { removeTreeSync } from '../../shared/windows-transient-lock-removal'
 import { WINDOWS_CMD_SAFE_PATH } from './installer-utils'
 import { wrapWindowsDirectCmdHookCommand } from './windows-direct-cmd-hook-command'
+import { getWindowsClaudeHookEntry } from '../claude/windows-hook-files'
+import { getManagedScript } from '../claude/hook-script'
+import { getWindowsPowerShellExecutablePath } from './windows-powershell-hook-launcher'
 import { findGitBash } from './windows-git-bash-path.test-fixture'
 
 const SAFE_PATH = 'C:\\Users\\alice\\.orca\\agent-hooks\\claude-hook.cmd'
 
 describe('wrapWindowsDirectCmdHookCommand', () => {
-  it('emits the script path with forward slashes and a neutral-JSON fallback', () => {
+  it('emits an operator-free path that PowerShell 5.1 can parse', () => {
     expect(wrapWindowsDirectCmdHookCommand(SAFE_PATH)).toBe(
-      'C:/Users/alice/.orca/agent-hooks/claude-hook.cmd || echo {}'
+      'C:/Users/alice/.orca/agent-hooks/claude-hook.cmd'
     )
   })
 
@@ -33,6 +33,7 @@ describe('wrapWindowsDirectCmdHookCommand', () => {
     // Why: `2>nul` writes a literal file named `nul` into the cwd under MSYS (measured), and no
     // stderr sink parses in both hosts. The missing-script line is left on stderr deliberately.
     expect(command).not.toContain('2>')
+    expect(command).not.toMatch(/[|&;]/)
   })
 
   it('declines any path the shells cannot carry bare', () => {
@@ -53,91 +54,142 @@ describe('wrapWindowsDirectCmdHookCommand', () => {
   })
 })
 
-describe.skipIf(process.platform !== 'win32')('direct hook command, run by both hook hosts', () => {
-  // Why: the fixture throws when Git Bash is absent, and that is a skip here, not a failure —
-  // a box without it never gets this command shape in the first place.
-  const gitBash = ((): string | null => {
-    try {
-      return findGitBash()
-    } catch {
-      return null
-    }
-  })()
-
-  function runInCmd(command: string, cwd: string): { stdout: string; status: number } {
-    return runCapture('cmd.exe', ['/d', '/c', command], cwd)
-  }
-
-  function runInBash(command: string, cwd: string): { stdout: string; status: number } {
-    return runCapture(gitBash!, ['-c', command], cwd)
-  }
-
-  function runCapture(file: string, args: string[], cwd: string) {
-    try {
-      const stdout = execFileSync(file, args, {
-        cwd,
-        input: '{"hook_event_name":"PreToolUse"}',
-        encoding: 'utf8',
-        stdio: ['pipe', 'pipe', 'pipe']
-      })
-      return { stdout, status: 0 }
-    } catch (error) {
-      const failure = error as { stdout?: string; status?: number }
-      return { stdout: failure.stdout ?? '', status: failure.status ?? 1 }
-    }
-  }
-
-  // Why: a runner whose TEMP sits under a profile with a space is the encoded-launcher case,
-  // so these legs skip rather than assert a contract that shape never claimed.
-  const tempIsCmdSafe = WINDOWS_CMD_SAFE_PATH.test(join(tmpdir(), 'orca-direct-hook-x', 'x.cmd'))
-  const canRunLive = Boolean(gitBash) && tempIsCmdSafe
-
-  function withTempDir(run: (dir: string, scriptPath: string, command: string) => void): void {
-    const dir = mkdtempSync(join(tmpdir(), 'orca-direct-hook-'))
-    try {
-      const scriptPath = join(dir, 'claude-hook.cmd')
-      const command = wrapWindowsDirectCmdHookCommand(scriptPath)
-      expect(command, 'precondition: temp path must be cmd-safe').not.toBeNull()
-      run(dir, scriptPath, command!)
-    } finally {
-      // Why: cmd.exe/bash have just exited in this tree; a raw recursive rm throws EPERM on
-      // Windows while their handles drain.
-      removeTreeSync(dir)
-    }
-  }
-
-  it.skipIf(!canRunLive)('answers {} and exit 0 in both hosts when the script exists', () => {
-    withTempDir((dir, scriptPath, command) => {
-      writeFileSync(scriptPath, '@echo off\r\necho {}\r\nexit /b 0\r\n', 'utf8')
-      for (const result of [runInCmd(command, dir), runInBash(command, dir)]) {
-        expect(result.stdout.trim()).toBe('{}')
-        expect(result.status).toBe(0)
+describe.skipIf(process.platform !== 'win32')(
+  'direct hook command, run by Windows hook hosts',
+  () => {
+    // Git Bash is optional; cmd.exe and Windows PowerShell still exercise the command without it.
+    const gitBash = ((): string | null => {
+      try {
+        return findGitBash()
+      } catch {
+        return null
       }
-    })
-  })
+    })()
 
-  it.skipIf(!canRunLive)(
-    'still answers {} and exit 0 in both hosts when the script is gone',
-    () => {
-      // Why: compat consumers require neutral JSON even with no managed script (#14818). The
-      // encoded launcher did this with a Test-Path; `|| echo {}` does it with no interpreter.
-      withTempDir((dir, scriptPath, command) => {
-        expect(existsSync(scriptPath)).toBe(false)
-        for (const result of [runInCmd(command, dir), runInBash(command, dir)]) {
-          expect(result.stdout.trim()).toBe('{}')
-          expect(result.status).toBe(0)
-        }
-      })
+    async function runInHosts(command: string, cwd: string) {
+      const hosts: [string, string[]][] = [
+        ['cmd.exe', ['/d', '/c', command]],
+        [getWindowsPowerShellExecutablePath(), ['-NoProfile', '-Command', command]]
+      ]
+      if (gitBash) {
+        hosts.push([gitBash, ['-c', command]])
+      }
+      const pwsh = join(
+        process.env.ProgramFiles ?? 'C:\\Program Files',
+        'PowerShell',
+        '7',
+        'pwsh.exe'
+      )
+      if (existsSync(pwsh)) {
+        hosts.push([pwsh, ['-NoProfile', '-Command', command]])
+      }
+      const results: Awaited<ReturnType<typeof runCapture>>[] = []
+      for (const [file, args] of hosts) {
+        results.push(await runCapture(file, args, cwd))
+      }
+      return results
     }
-  )
 
-  it.skipIf(!canRunLive)('leaves no stray `nul` file behind in the working directory', () => {
-    // Why this is worth a test: adding `2>nul` to silence the missing-script line looks like
-    // tidy-up, but under MSYS it creates a real file named `nul` in the cwd — which is the
-    // user's repo. Measured on Windows 11. Keep stderr unredirected.
-    withTempDir((dir, _scriptPath, command) => {
-      runInBash(command, dir)
-      expect(readdirSync(dir)).not.toContain('nul')
-    })
-  })
-})
+    // Why async runProcess: runProcessSync cannot take a string stdin (it forces encoding 'buffer').
+    async function runCapture(file: string, args: string[], cwd: string) {
+      const result = await runProcess({
+        program: file,
+        args,
+        cwd,
+        // Why PATHEXT: without it Windows PowerShell 5.1 prints nothing and exits 0 for a .cmd path
+        // (measured); every real hook host inherits it.
+        env: {
+          SystemRoot: process.env.SystemRoot,
+          PATH: process.env.PATH,
+          PATHEXT: process.env.PATHEXT,
+          ComSpec: process.env.ComSpec,
+          HOME: cwd,
+          USERPROFILE: cwd
+        },
+        input: '{"hook_event_name":"PreToolUse"}',
+        timeoutMs: 5_000
+      })
+      expect(result.timedOut, result.stderr).toBe(false)
+      return { stdout: result.stdout, status: result.code, label: `${file}: ${result.stderr}` }
+    }
+
+    // Why: a runner whose TEMP sits under a profile with a space is the encoded-launcher case,
+    // so these legs skip rather than assert a contract that shape never claimed.
+    const tempIsCmdSafe = WINDOWS_CMD_SAFE_PATH.test(join(tmpdir(), 'orca-direct-hook-x', 'x.cmd'))
+    const canRunLive = tempIsCmdSafe
+
+    async function withTempDir(
+      run: (dir: string, scriptPath: string, command: string) => Promise<void>
+    ): Promise<void> {
+      const dir = mkdtempSync(join(tmpdir(), 'orca-direct-hook-'))
+      try {
+        const scriptPath = join(dir, 'claude-hook.cmd')
+        const command = wrapWindowsDirectCmdHookCommand(scriptPath)
+        expect(command, 'precondition: temp path must be cmd-safe').not.toBeNull()
+        await run(dir, scriptPath, command!)
+      } finally {
+        // Why: cmd.exe/bash have just exited in this tree; a raw recursive rm throws EPERM on
+        // Windows while their handles drain.
+        removeTreeSync(dir)
+      }
+    }
+
+    it.skipIf(!canRunLive)(
+      'answers {} and exit 0 in both hosts when the script exists',
+      async () => {
+        await withTempDir(async (dir, scriptPath, command) => {
+          writeFileSync(scriptPath, '@echo off\r\necho {}\r\nexit /b 0\r\n', 'utf8')
+          for (const result of await runInHosts(command, dir)) {
+            expect(result.stdout.trim(), result.label).toBe('{}')
+            expect(result.status, result.label).toBe(0)
+          }
+        })
+      }
+    )
+
+    it.skipIf(!canRunLive)(
+      'runs the generated pair and answers when its payload is missing',
+      async () => {
+        await withTempDir(async (dir, scriptPath, command) => {
+          writeFileSync(scriptPath, getWindowsClaudeHookEntry(), 'utf8')
+          for (const result of await runInHosts(command, dir)) {
+            expect(result.stdout.trim(), result.label).toBe('{}')
+            expect(result.status, result.label).toBe(0)
+          }
+          writeFileSync(join(dir, 'claude-hook-impl.cmd'), getManagedScript(), 'utf8')
+          for (const result of await runInHosts(command, dir)) {
+            expect(result.stdout.trim(), result.label).toBe('{}')
+            expect(result.status, result.label).toBe(0)
+          }
+        })
+      }
+    )
+
+    it.skipIf(!canRunLive)(
+      'reports a non-blocking failure, never exit 2, when the entry is gone',
+      async () => {
+        await withTempDir(async (dir, scriptPath, command) => {
+          expect(existsSync(scriptPath)).toBe(false)
+          for (const result of await runInHosts(command, dir)) {
+            expect(result.stdout.trim(), result.label).toBe('')
+            expect(result.status, result.label).toBeGreaterThan(0)
+            expect(result.status, result.label).not.toBe(2)
+          }
+        })
+      }
+    )
+
+    it.skipIf(!canRunLive)(
+      'leaves no stray `nul` file behind in the working directory',
+      async () => {
+        // Why this is worth a test: adding `2>nul` to silence the missing-script line looks like
+        // tidy-up, but under MSYS it creates a real file named `nul` in the cwd — which is the
+        // user's repo. Measured on Windows 11. Keep stderr unredirected.
+        await withTempDir(async (dir, _scriptPath, command) => {
+          await runInHosts(command, dir)
+          expect(readdirSync(dir)).not.toContain('nul')
+        })
+      }
+    )
+  }
+)
diff --git a/src/main/agent-hooks/windows-direct-cmd-hook-command.ts b/src/main/agent-hooks/windows-direct-cmd-hook-command.ts
index f7646f19578..e4fbc4d2ffc 100644
--- a/src/main/agent-hooks/windows-direct-cmd-hook-command.ts
+++ b/src/main/agent-hooks/windows-direct-cmd-hook-command.ts
@@ -1,30 +1,13 @@
 import { WINDOWS_CMD_SAFE_PATH } from './installer-utils'
 
-// Why: a drive-letter path only. WINDOWS_CMD_SAFE_PATH also admits a UNC profile, and
-// `//server/share/...` is not a command cmd.exe reliably starts.
+// UNC paths cannot be started consistently by all Windows hook hosts.
 const WINDOWS_DRIVE_LETTER_PATH = /^[A-Za-z]:\\/
 
-/**
- * Shortest launcher for a managed Windows `.cmd` hook: the script path itself (#18875).
- *
- * The encoded PowerShell launcher spent a full interpreter start-up per hook event to reach a
- * script that exits at its first `ORCA_PANE_KEY` guard, and left a stdout-holding orphan behind
- * when the hook's timeout kill landed. Measurements and the EDR trade are in
- * `docs/reference/windows-edr-posture.md`.
- *
- * Returns null when the caller must keep the encoded launcher: a path either shell would mangle.
- */
+/** A bare path works without guessing whether Claude selected Bash or PowerShell. */
 export function wrapWindowsDirectCmdHookCommand(scriptPath: string): string | null {
   if (!WINDOWS_CMD_SAFE_PATH.test(scriptPath) || !WINDOWS_DRIVE_LETTER_PATH.test(scriptPath)) {
     return null
   }
-  // Why: forward slashes are the one separator both hosts read, and no token here is a switch
-  // MSYS can rewrite — a literal `cmd.exe /d /c <path>` does not survive Git Bash (measured).
-  const invocation = scriptPath.replaceAll('\\', '/')
-  // Why: neutral JSON when the script is missing (#14818), with no interpreter to Test-Path with.
-  // Valid in bash and cmd.exe; PowerShell 5.1 rejects `||`, which is what gates this on Git Bash.
-  // It also fires when cmd.exe itself exits non-zero (a failing AutoRun), printing `{}` twice —
-  // on that same box the encoded launcher exited 1 instead, so neither shape is clean there.
-  // Stderr stays unredirected: `2>nul` writes a literal `nul` file into the cwd under MSYS.
-  return `${invocation} || echo {}`
+  // The script owns failure handling; PowerShell 5.1 cannot parse a shell-level `||`.
+  return scriptPath.replaceAll('\\', '/')
 }
diff --git a/src/main/agent-hooks/windows-hook-command-hosts.test.ts b/src/main/agent-hooks/windows-hook-command-hosts.test.ts
new file mode 100644
index 00000000000..8707dd251a9
--- /dev/null
+++ b/src/main/agent-hooks/windows-hook-command-hosts.test.ts
@@ -0,0 +1,53 @@
+import { describe, expect, it } from 'vitest'
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { runProcess } from '../../shared/child-process/run-process'
+import { getWindowsManagedLifecycleHook } from '../claude/hook-settings'
+
+const command = getWindowsManagedLifecycleHook(
+  'C:\\Users\\alice\\.orca\\agent-hooks\\claude-hook.cmd'
+).command
+const input = '{"message":"café 日本語 & %PATH%", "hook_event_name":"Stop"}'
+
+// A POSIX fixture at the exact registered spelling exercises tokenization, not Windows batch execution.
+describe.skipIf(process.platform === 'win32')('Windows command under available POSIX hosts', () => {
+  // PowerShell parsing is covered by the Windows-only host legs in windows-direct-cmd-hook-command.test.ts.
+  for (const shell of ['/bin/bash', '/bin/zsh']) {
+    it.skipIf(!existsSync(shell))(
+      `preserves invocation and reports a missing entry without exit 2: ${shell}`,
+      async () => {
+        const root = mkdtempSync(join(tmpdir(), 'claude-command-host-'))
+        const fixture = join(root, 'C:/Users/alice/.orca/agent-hooks/claude-hook.cmd')
+        const run = () =>
+          runProcess({
+            program: '/usr/bin/env',
+            args: ['-i', `HOME=${root}`, 'PATH=/usr/bin:/bin', shell, '-c', command],
+            cwd: root,
+            env: {},
+            input,
+            timeoutMs: 5_000
+          })
+        try {
+          mkdirSync(dirname(fixture), { recursive: true })
+          writeFileSync(fixture, '#!/bin/sh\nprintf "{}\\n"\ncat > payload.txt\nexit 0\n', {
+            mode: 0o755
+          })
+          const present = await run()
+          expect(present.code, present.stderr).toBe(0)
+          expect(present.stdout.trim()).toBe('{}')
+          expect(readFileSync(join(root, 'payload.txt'), 'utf8')).toBe(input)
+          rmSync(fixture)
+          const missing = await run()
+          expect(missing.timedOut).toBe(false)
+          expect(missing.code).toBeGreaterThan(0)
+          expect(missing.code).not.toBe(2)
+          expect(missing.stdout.trim()).toBe('')
+          expect(missing.stderr).not.toBe('')
+        } finally {
+          rmSync(root, { recursive: true, force: true })
+        }
+      }
+    )
+  }
+})
diff --git a/src/main/agent-hooks/windows-hook-post-interpreter.test.ts b/src/main/agent-hooks/windows-hook-post-interpreter.test.ts
index 09377f3adf5..59a409f82d9 100644
--- a/src/main/agent-hooks/windows-hook-post-interpreter.test.ts
+++ b/src/main/agent-hooks/windows-hook-post-interpreter.test.ts
@@ -15,6 +15,10 @@ const { homedirMock } = vi.hoisted(() => ({
   homedirMock: vi.fn<() => string>()
 }))
 
+vi.mock('../codex/codex-hook-trust-grant', () => ({
+  grantManagedCodexHookTrust: async () => ({ lane: 'fallback', reason: 'unsupported' })
+}))
+
 vi.mock('electron', () => ({
   app: {
     getPath: () => '/tmp/orca-user-data'
diff --git a/src/main/agent-hooks/windows-powershell-hook-launcher.ts b/src/main/agent-hooks/windows-powershell-hook-launcher.ts
index 2cdb8c0f3fa..42487ec7efa 100644
--- a/src/main/agent-hooks/windows-powershell-hook-launcher.ts
+++ b/src/main/agent-hooks/windows-powershell-hook-launcher.ts
@@ -42,8 +42,7 @@ export function getWindowsPowerShellExecutablePath(): string {
  *
  * #18875 took that answer for the Claude lifecycle hook, which now registers the
  * managed `.cmd` path directly (`windows-direct-cmd-hook-command.ts`) and reaches
- * this launcher only when the profile path is not cmd-safe or Git Bash is not
- * resolvable. Every other caller still comes through here on every event.
+ * this launcher only when the profile path is not cmd-safe. Every other caller still comes through here on every event.
  */
 export const WINDOWS_POWERSHELL_HOOK_SWITCHES = '-NoProfile'
 
diff --git a/src/main/claude/hook-script.ts b/src/main/claude/hook-script.ts
index e02fe374701..475d79273b4 100644
--- a/src/main/claude/hook-script.ts
+++ b/src/main/claude/hook-script.ts
@@ -16,6 +16,12 @@ import {
   buildWindowsHookStdinDrainEpilogue
 } from '../agent-hooks/hook-stdin-contract'
 
+// Why: a backgrounded session runs in a daemon worker that inherited the dispatching
+// pane's env, so ORCA_PANE_KEY names a pane this session does not run in (#9236).
+// Why exit, not the drain label: the drain parks in more.com and a worker is outside
+// an Orca pane — the abandoned-stdin hang #11549 guards against.
+export const WINDOWS_CLAUDE_BACKGROUND_JOB_GUARD = 'if not "%CLAUDE_JOB_DIR%"=="" exit /b 0'
+
 export function getManagedScript(
   target: 'local' | 'posix' = 'local',
   options: {
@@ -36,11 +42,7 @@ export function getManagedScript(
       // Why (#11549): the env guards must outrank the Devin skip — the Devin skip parks in more.com,
       // and outside an Orca pane the caller can abandon stdin, so more.com never returns.
       ...buildWindowsHookEnvironmentGuardLines(),
-      // Why: a backgrounded session runs in a daemon worker that inherited the dispatching
-      // pane's env, so ORCA_PANE_KEY names a pane this session does not run in (#9236).
-      // Why exit, not the drain label: the drain parks in more.com and a worker is outside
-      // an Orca pane — the abandoned-stdin hang #11549 guards against.
-      'if not "%CLAUDE_JOB_DIR%"=="" exit /b 0',
+      WINDOWS_CLAUDE_BACKGROUND_JOB_GUARD,
       ...(options.skipWhenGrokImportsClaude ? buildWindowsGrokReplayGuardLines() : []),
       ...(options.skipWhenDevinImportsClaude
         ? [
diff --git a/src/main/claude/hook-service.test.ts b/src/main/claude/hook-service.test.ts
index c9191d42dbd..0f7e0a0707f 100644
--- a/src/main/claude/hook-service.test.ts
+++ b/src/main/claude/hook-service.test.ts
@@ -15,8 +15,7 @@ vi.mock('electron', () => ({
   }
 }))
 
-// Why: the installed hook shape depends on whether Git Bash is resolvable on the host, so the
-// install assertions below have to state which host they describe rather than inherit the box's.
+// Mock discovery so registration can be checked with Git Bash both present and absent.
 const { gitBashAvailableMock } = vi.hoisted(() => ({ gitBashAvailableMock: { value: true } }))
 vi.mock('../git-bash', async (importOriginal) => ({
   ...(await importOriginal<typeof GitBashModule>()),
@@ -55,10 +54,10 @@ describe('getWindowsManagedLifecycleHook', () => {
     // Why this is the whole point: the encoded launcher spent a PowerShell start-up per hook
     // event (471ms vs 201ms measured) before the .cmd could reach its ORCA_PANE_KEY guard, and
     // its orphan outlived the hook's timeout kill still holding the stdout the agent reads.
-    const hook = getWindowsManagedLifecycleHook(SAFE_SCRIPT_PATH, { gitBashAvailable: true })
+    const hook = getWindowsManagedLifecycleHook(SAFE_SCRIPT_PATH)
 
     expect(hook.args).toBeUndefined()
-    expect(hook.command).toBe('C:/Users/alice/.orca/agent-hooks/claude-hook.cmd || echo {}')
+    expect(hook.command).toBe('C:/Users/alice/.orca/agent-hooks/claude-hook.cmd')
     expect(hook.command).not.toMatch(/powershell|-EncodedCommand|conhost/i)
     // Why: Git Bash/MSYS mangles backslash paths and rewrites slash-prefixed switches.
     expect(hook.command).not.toMatch(/\\/)
@@ -66,7 +65,7 @@ describe('getWindowsManagedLifecycleHook', () => {
   })
 
   it('falls back to the encoded launcher when the profile path is not cmd-safe', () => {
-    const hook = getWindowsManagedLifecycleHook(UNSAFE_SCRIPT_PATH, { gitBashAvailable: true })
+    const hook = getWindowsManagedLifecycleHook(UNSAFE_SCRIPT_PATH)
 
     expect(hook.args).toBeUndefined()
     expect(hook.command).toMatch(/\/powershell\.exe -NoProfile -EncodedCommand /)
@@ -79,18 +78,21 @@ describe('getWindowsManagedLifecycleHook', () => {
     expect(decoded).toContain('.orca\\agent-hooks\\claude-hook.cmd')
   })
 
-  it('falls back to the encoded launcher when Git Bash is not resolvable', () => {
-    // Why: without Git Bash, Claude Code hosts the hook in PowerShell, and PowerShell 5.1
-    // rejects `||` as a statement separator (measured) — every event would be a parse error.
-    const hook = getWindowsManagedLifecycleHook(SAFE_SCRIPT_PATH, { gitBashAvailable: false })
-
-    expect(hook.command).toMatch(/\/powershell\.exe -NoProfile -EncodedCommand /)
+  it('does not consult Git Bash availability', () => {
+    gitBashAvailableMock.value = false
+    try {
+      expect(getWindowsManagedLifecycleHook(SAFE_SCRIPT_PATH).command).toBe(
+        'C:/Users/alice/.orca/agent-hooks/claude-hook.cmd'
+      )
+    } finally {
+      gitBashAvailableMock.value = true
+    }
   })
 
   it('is still recognized as managed by createManagedCommandMatcher (#14825)', () => {
     for (const hook of [
-      getWindowsManagedLifecycleHook(SAFE_SCRIPT_PATH, { gitBashAvailable: true }),
-      getWindowsManagedLifecycleHook(SAFE_SCRIPT_PATH, { gitBashAvailable: false })
+      getWindowsManagedLifecycleHook(SAFE_SCRIPT_PATH),
+      getWindowsManagedLifecycleHook(UNSAFE_SCRIPT_PATH)
     ]) {
       expect(isClaudeManagedCommand(hook.command)).toBe(true)
     }
@@ -242,7 +244,7 @@ describe('ClaudeHookService.install', () => {
       // Why: POSIX resolves the profile at runtime (`${HOME-}`, STA-3348). Windows cannot —
       // no single token expands in both Git Bash and cmd.exe — so it registers the absolute
       // path, as Codex/Grok/Devin/Antigravity already do (#18875). A moved profile is caught
-      // by getStatus's exact match and rewritten, and `|| echo {}` keeps a stale entry neutral.
+      // by getStatus's exact match and rewritten; a deleted entry reports an ordinary hook error.
       if (process.platform !== 'win32') {
         expect(JSON.stringify(managedHook)).not.toContain(tmpHome.replaceAll('\\', '/'))
       }
@@ -258,7 +260,12 @@ describe('ClaudeHookService.install', () => {
         true
       )
       const managedScript = readFileSync(
-        join(tmpHome, '.orca', 'agent-hooks', CLAUDE_SCRIPT_FILE_NAME),
+        join(
+          tmpHome,
+          '.orca',
+          'agent-hooks',
+          process.platform === 'win32' ? 'claude-hook-impl.cmd' : CLAUDE_SCRIPT_FILE_NAME
+        ),
         'utf-8'
       )
       expect(managedScript).toContain('DEVIN_PROJECT_DIR')
@@ -506,7 +513,7 @@ describe('ClaudeHookService.install', () => {
           readFileSync(join(tmpHome, '.claude', 'settings.json'), 'utf-8')
         ) as { hooks: Record<string, { hooks: TestHook[] }[]> }
 
-        const expected = `${scriptPath.replaceAll('\\', '/')} || echo {}`
+        const expected = scriptPath.replaceAll('\\', '/')
         for (const { eventName } of CLAUDE_EVENTS) {
           const hook = settings.hooks[eventName]?.[0]?.hooks?.[0]
           expect(hook?.args, eventName).toBeUndefined()
@@ -537,7 +544,9 @@ describe('ClaudeHookService.install', () => {
       try {
         const settingsPath = join(tmpHome, '.claude', 'settings.json')
         mkdirSync(join(tmpHome, '.claude'), { recursive: true })
-        const stale = getWindowsManagedLifecycleHook(scriptPath, { gitBashAvailable: false })
+        const stale = getWindowsManagedLifecycleHook(
+          'C:\\Users\\%name%\\.orca\\agent-hooks\\claude-hook.cmd'
+        )
         writeFileSync(
           settingsPath,
           JSON.stringify({
@@ -605,9 +614,7 @@ describe('ClaudeHookService.install', () => {
           hooks: Record<string, { hooks: TestHook[] }[]>
         }
         expect(JSON.stringify(settings.hooks)).not.toContain('someone-else')
-        expect(settings.hooks.PreToolUse[0].hooks[0].command).toBe(
-          `${scriptPath.replaceAll('\\', '/')} || echo {}`
-        )
+        expect(settings.hooks.PreToolUse[0].hooks[0].command).toBe(scriptPath.replaceAll('\\', '/'))
         expect(new ClaudeHookService().getStatus().state).toBe('installed')
       } finally {
         vi.unstubAllEnvs()
@@ -625,7 +632,7 @@ describe('ClaudeHookService.install', () => {
       try {
         expect(new ClaudeHookService().install().state).toBe('installed')
         const script = readFileSync(
-          join(tmpHome, '.orca', 'agent-hooks', CLAUDE_SCRIPT_FILE_NAME),
+          join(tmpHome, '.orca', 'agent-hooks', 'claude-hook-impl.cmd'),
           'utf-8'
         )
         expect(script).toContain('%SystemRoot%\\System32\\curl.exe')
@@ -705,7 +712,10 @@ describe('backgrounded-session pane guard (#9236)', () => {
     vi.stubEnv('USERPROFILE', tmpHome)
     try {
       expect(new ClaudeHookService().install().state).toBe('installed')
-      const script = readFileSync(join(tmpHome, '.orca', 'agent-hooks', 'claude-hook.cmd'), 'utf-8')
+      const script = readFileSync(
+        join(tmpHome, '.orca', 'agent-hooks', 'claude-hook-impl.cmd'),
+        'utf-8'
+      )
       const guard = script.split('\r\n').find((line) => line.includes('CLAUDE_JOB_DIR'))
       expect(guard).toBe('if not "%CLAUDE_JOB_DIR%"=="" exit /b 0')
       // Why: the drain parks in more.com, and a daemon worker is exactly the
diff --git a/src/main/claude/hook-service.ts b/src/main/claude/hook-service.ts
index bc27b56075e..0031d8413f9 100644
--- a/src/main/claude/hook-service.ts
+++ b/src/main/claude/hook-service.ts
@@ -16,6 +16,11 @@ import {
 } from '../agent-hooks/installer-utils-remote'
 import { refreshManagedScriptIfPresent } from '../agent-hooks/managed-hook-script-refresh'
 import { getManagedScript } from './hook-script'
+import {
+  getWindowsClaudeHookFileStatus,
+  installWindowsClaudeHookFiles,
+  refreshWindowsClaudeHookFiles
+} from './windows-hook-files'
 
 export { getManagedScript }
 import { getManagedStatusLineScript } from './statusline-script'
@@ -72,6 +77,18 @@ export class ClaudeHookService {
     this.options = options
   }
 
+  private get usesWindowsEntry(): boolean {
+    return process.platform === 'win32' && this.options.agent === 'claude'
+  }
+
+  private managedScript(target: 'local' | 'posix' = 'local'): string {
+    return getManagedScript(target, {
+      source: this.options.source,
+      skipWhenDevinImportsClaude: this.options.agent === 'claude',
+      skipWhenGrokImportsClaude: this.options.agent === 'claude'
+    })
+  }
+
   // Why: Claude's settings loader rejects events newer than the running CLI, so its plan follows the
   // resolved version; OpenClaude and Qoder read their own settings files.
   private managedHookPlan(options: ClaudeHookInstallOptions): ClaudeManagedHookPlan {
@@ -124,18 +141,16 @@ export class ClaudeHookService {
       state = 'partial'
       detail = `Managed hook missing for events: ${missing.join(', ')}`
     }
-    return { agent: this.options.agent, state, configPath, managedHooksPresent, detail }
+    const status = { agent: this.options.agent, state, configPath, managedHooksPresent, detail }
+    return this.usesWindowsEntry ? getWindowsClaudeHookFileStatus(status, scriptPath) : status
   }
 
   async refreshManagedScripts(): Promise<void> {
-    await refreshManagedScriptIfPresent(
-      getManagedScriptPath(this.options.settings),
-      getManagedScript('local', {
-        source: this.options.source,
-        skipWhenDevinImportsClaude: this.options.agent === 'claude',
-        skipWhenGrokImportsClaude: this.options.agent === 'claude'
-      })
-    )
+    const scriptPath = getManagedScriptPath(this.options.settings)
+    const payload = this.managedScript()
+    await (this.usesWindowsEntry
+      ? refreshWindowsClaudeHookFiles(scriptPath, payload)
+      : refreshManagedScriptIfPresent(scriptPath, payload))
     // Why: no agent gate — the statusline script only ever exists for claude, so presence is the gate.
     await refreshManagedScriptIfPresent(
       getStatusLineScriptPath(this.options.settings),
@@ -165,14 +180,12 @@ export class ClaudeHookService {
       getManagedScriptFileName(this.options.settings),
       plan
     )
-    writeManagedScript(
-      scriptPath,
-      getManagedScript('local', {
-        source: this.options.source,
-        skipWhenDevinImportsClaude: this.options.agent === 'claude',
-        skipWhenGrokImportsClaude: this.options.agent === 'claude'
-      })
-    )
+    const payload = this.managedScript()
+    if (this.usesWindowsEntry) {
+      installWindowsClaudeHookFiles(scriptPath, payload)
+    } else {
+      writeManagedScript(scriptPath, payload)
+    }
     if (plan.statusLine === 'install') {
       nextConfig = this.installManagedStatusLine(nextConfig)
     } else if (plan.statusLine === 'retire') {
@@ -257,15 +270,7 @@ export class ClaudeHookService {
 
       // Why: write scripts before settings to avoid settings pointing to missing scripts.
       // Why: SSH scripts always use POSIX .sh paths, regardless of the local OS.
-      await writeManagedScriptRemote(
-        sftp,
-        remoteScriptPath,
-        getManagedScript('posix', {
-          source: this.options.source,
-          skipWhenDevinImportsClaude: this.options.agent === 'claude',
-          skipWhenGrokImportsClaude: this.options.agent === 'claude'
-        })
-      )
+      await writeManagedScriptRemote(sftp, remoteScriptPath, this.managedScript('posix'))
       // Why: no statusline install here — this path serves SSH remotes and WSL guests, whose relay hook
       // listener doesn't route /statusline/claude, and an SSH box's Claude login can be a different
       // account than the locally selected one, so its usage must not feed the local bar (live feed is host-local only).
diff --git a/src/main/claude/hook-settings.ts b/src/main/claude/hook-settings.ts
index 381e4d26b6f..bb89cf38820 100644
--- a/src/main/claude/hook-settings.ts
+++ b/src/main/claude/hook-settings.ts
@@ -15,7 +15,6 @@ import {
 import { quotePowerShellLiteral } from '../../shared/powershell-native-argument'
 import { wrapRuntimeHomeHookCommand } from '../agent-hooks/runtime-home-hook-command'
 import { wrapWindowsDirectCmdHookCommand } from '../agent-hooks/windows-direct-cmd-hook-command'
-import { isGitBashAvailable } from '../git-bash'
 import type { ClaudeManagedHookPlan } from './claude-managed-hook-events'
 
 export type ClaudeCompatibleHookSettings = {
@@ -91,8 +90,7 @@ export function getManagedCommand(
 
 export function getManagedLifecycleHook(
   scriptPath: string,
-  settings = CLAUDE_HOOK_SETTINGS,
-  options: WindowsManagedLifecycleHookOptions = {}
+  settings = CLAUDE_HOOK_SETTINGS
 ): HookCommandConfig {
   if (process.platform !== 'win32' || !settings.usesWindowsCompatLauncher) {
     return buildManagedCommandHook(getManagedCommand(scriptPath, { neutralJsonWhenMissing: true }))
@@ -105,22 +103,12 @@ export function getManagedLifecycleHook(
       timeout: MANAGED_HOOK_TIMEOUT_SECONDS
     }
   }
-  return getWindowsManagedLifecycleHook(scriptPath, options)
+  return getWindowsManagedLifecycleHook(scriptPath)
 }
 
-export type WindowsManagedLifecycleHookOptions = { gitBashAvailable?: boolean }
-
-// Why: some Claude-compatible consumers ignore `args`, so the invocation must be self-contained.
-export function getWindowsManagedLifecycleHook(
-  scriptPath: string,
-  options: WindowsManagedLifecycleHookOptions = {}
-): HookCommandConfig {
-  // Why (#18875): the encoded launcher cost a PowerShell start-up per hook event. Take the direct
-  // path only where the host can parse `||` — Git Bash can, Windows PowerShell 5.1 cannot.
-  const directCommand =
-    (options.gitBashAvailable ?? isGitBashAvailable())
-      ? wrapWindowsDirectCmdHookCommand(scriptPath)
-      : null
+// Some compatible consumers ignore args, so keep the invocation self-contained.
+export function getWindowsManagedLifecycleHook(scriptPath: string): HookCommandConfig {
+  const directCommand = wrapWindowsDirectCmdHookCommand(scriptPath)
   if (directCommand) {
     return { type: 'command', command: directCommand, timeout: MANAGED_HOOK_TIMEOUT_SECONDS }
   }
diff --git a/src/main/claude/windows-hook-files.test.ts b/src/main/claude/windows-hook-files.test.ts
new file mode 100644
index 00000000000..a3d369e75ec
--- /dev/null
+++ b/src/main/claude/windows-hook-files.test.ts
@@ -0,0 +1,161 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import type * as osModule from 'node:os'
+import { join } from 'node:path'
+import * as refresh from '../agent-hooks/managed-hook-script-refresh'
+import { readHooksJson, writeHooksJson } from '../agent-hooks/installer-utils'
+import { ClaudeHookService } from './hook-service'
+import { getWindowsManagedLifecycleHook } from './hook-settings'
+import { getWindowsClaudeHookEntry, getWindowsClaudeHookPayloadPath } from './windows-hook-files'
+import { codebuddyHookService } from '../codebuddy/hook-service'
+import { qoderHookService } from '../qoder/hook-service'
+import { openClaudeHookService } from '../openclaude/hook-service'
+
+const { home } = vi.hoisted(() => ({ home: { path: '' } }))
+vi.mock('node:os', async (original) => ({
+  ...(await original<typeof osModule>()),
+  homedir: () => home.path
+}))
+vi.mock('electron', () => ({ app: { getPath: () => home.path } }))
+
+const platform = Object.getOwnPropertyDescriptor(process, 'platform')!
+let entry: string
+let payload: string
+let settings: string
+const service = new ClaudeHookService()
+
+beforeEach(() => {
+  home.path = mkdtempSync(join(tmpdir(), 'claude-windows-files-'))
+  entry = join(home.path, '.orca', 'agent-hooks', 'claude-hook.cmd')
+  payload = getWindowsClaudeHookPayloadPath(entry)
+  settings = join(home.path, '.claude', 'settings.json')
+  Object.defineProperty(process, 'platform', { configurable: true, value: 'win32' })
+})
+
+afterEach(() => {
+  Object.defineProperty(process, 'platform', platform)
+  vi.restoreAllMocks()
+  rmSync(home.path, { recursive: true, force: true })
+})
+
+describe('Windows Claude hook files', () => {
+  it('installs a delegating entry and a payload that answers before bounded delivery', () => {
+    expect(service.install().state).toBe('installed')
+    expect(readFileSync(entry, 'utf8')).toBe(getWindowsClaudeHookEntry())
+    const body = readFileSync(payload, 'utf8')
+    expect(body.indexOf('echo {}')).toBeLessThan(body.indexOf('curl.exe'))
+    expect(body).toContain('--connect-timeout 0.5 --max-time 1.5')
+    expect(body).toContain('--data-urlencode "payload@-" >nul 2>&1\r\nexit /b 0')
+    expect(body).toContain('DEVIN_PROJECT_DIR')
+  })
+
+  it('repairs a missing payload from the surviving entry without touching settings', async () => {
+    service.install()
+    rmSync(payload)
+    expect(service.getStatus().state).toBe('partial')
+    const configBefore = readFileSync(settings, 'utf8')
+    await service.refreshManagedScripts()
+    expect(service.getStatus().state).toBe('installed')
+    expect(readFileSync(entry, 'utf8')).toBe(getWindowsClaudeHookEntry())
+    expect(readFileSync(payload, 'utf8')).toContain('/hook/claude')
+    expect(readFileSync(settings, 'utf8')).toBe(configBefore)
+  })
+
+  it.each(['entry', 'both'])('leaves a missing %s to install()', async (missing) => {
+    service.install()
+    rmSync(entry)
+    if (missing === 'both') {
+      rmSync(payload)
+    }
+    await service.refreshManagedScripts()
+    expect(existsSync(entry)).toBe(false)
+    expect(service.getStatus().state).toBe('partial')
+    expect(service.install().state).toBe('installed')
+    expect(readFileSync(entry, 'utf8')).toBe(getWindowsClaudeHookEntry())
+    expect(readFileSync(payload, 'utf8')).toContain('/hook/claude')
+  })
+
+  it('leaves the old single-file entry intact when payload publication fails', async () => {
+    mkdirSync(join(home.path, '.orca', 'agent-hooks'), { recursive: true })
+    const oldEntry = '@echo off\r\necho {}\r\nexit /b 0\r\n'
+    writeFileSync(entry, oldEntry)
+    vi.spyOn(refresh, 'restoreManagedScript').mockRejectedValueOnce(new Error('disk full'))
+    await expect(service.refreshManagedScripts()).rejects.toThrow('disk full')
+    expect(readFileSync(entry, 'utf8')).toBe(oldEntry)
+    expect(existsSync(payload)).toBe(false)
+  })
+
+  it('publishes the payload before replacing a legacy entry', async () => {
+    mkdirSync(join(home.path, '.orca', 'agent-hooks'), { recursive: true })
+    writeFileSync(entry, 'legacy payload')
+    const restore = refresh.restoreManagedScript
+    const writes: string[] = []
+    vi.spyOn(refresh, 'restoreManagedScript').mockImplementation(async (path, content) => {
+      if (path === entry) {
+        expect(readFileSync(payload, 'utf8')).toContain('/hook/claude')
+      }
+      writes.push(path)
+      await restore(path, content)
+    })
+    await service.refreshManagedScripts()
+    expect(writes).toEqual([payload, entry])
+    expect(existsSync(settings)).toBe(false)
+  })
+
+  it('keeps inert scripts on uninstall and never creates an entry from an orphan payload', async () => {
+    service.install()
+    service.remove()
+    expect(JSON.stringify(readHooksJson(settings))).not.toContain('claude-hook.cmd')
+    // Like every other agent's script: a session still holding the old settings keeps answering.
+    expect(readFileSync(entry, 'utf8')).toBe(getWindowsClaudeHookEntry())
+    rmSync(entry)
+    writeFileSync(payload, 'orphan payload')
+    await service.refreshManagedScripts()
+    expect(existsSync(entry)).toBe(false)
+    expect(readFileSync(payload, 'utf8')).toBe('orphan payload')
+  })
+
+  it('migrates old command forms while preserving user hooks', () => {
+    const encoded = getWindowsManagedLifecycleHook(
+      'C:\\Users\\%name%\\.orca\\agent-hooks\\claude-hook.cmd'
+    )
+    writeHooksJson(settings, {
+      hooks: {
+        Stop: [{ hooks: [encoded, { type: 'command', command: 'echo user-hook' }] }],
+        PreToolUse: [
+          {
+            hooks: [
+              { type: 'command', command: 'C:/old/.orca/agent-hooks/claude-hook.cmd || echo {}' }
+            ]
+          }
+        ]
+      }
+    })
+    service.install()
+    const config = JSON.stringify(readHooksJson(settings))
+    expect(config).not.toContain('|| echo {}')
+    expect(config).not.toContain('C:/old/')
+    expect(config).toContain('echo user-hook')
+    expect(service.getStatus().state).toBe('installed')
+  })
+
+  it('keeps compatible agents on their existing single-file scripts', async () => {
+    for (const [name, compatible] of [
+      ['qoder', qoderHookService],
+      ['codebuddy', codebuddyHookService],
+      ['openclaude', openClaudeHookService]
+    ] as const) {
+      expect(compatible.install().state).toBe('installed')
+      await compatible.refreshManagedScripts()
+      const path = join(home.path, '.orca', 'agent-hooks', `${name}-hook.cmd`)
+      expect(readFileSync(path, 'utf8')).toContain(
+        `/hook/${name === 'openclaude' ? 'claude' : name}`
+      )
+      expect(readFileSync(path, 'utf8')).not.toContain('claude-hook-impl.cmd')
+      expect(existsSync(join(home.path, '.orca', 'agent-hooks', `${name}-hook-impl.cmd`))).toBe(
+        false
+      )
+    }
+  })
+})
diff --git a/src/main/claude/windows-hook-files.ts b/src/main/claude/windows-hook-files.ts
new file mode 100644
index 00000000000..13ef168f520
--- /dev/null
+++ b/src/main/claude/windows-hook-files.ts
@@ -0,0 +1,66 @@
+import { existsSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import type { AgentHookInstallStatus } from '../../shared/agent-hook-types'
+import { writeManagedScript } from '../agent-hooks/installer-utils'
+import { restoreManagedScript, scriptStillExists } from '../agent-hooks/managed-hook-script-refresh'
+import {
+  buildWindowsHookEnvironmentGuardLines,
+  buildWindowsHookStdinDrainEpilogue
+} from '../agent-hooks/hook-stdin-contract'
+import { WINDOWS_CLAUDE_BACKGROUND_JOB_GUARD } from './hook-script'
+
+const PAYLOAD_FILE_NAME = 'claude-hook-impl.cmd'
+
+export function getWindowsClaudeHookPayloadPath(entryPath: string): string {
+  return join(dirname(entryPath), PAYLOAD_FILE_NAME)
+}
+
+export function getWindowsClaudeHookFileStatus(
+  status: AgentHookInstallStatus,
+  entryPath: string
+): AgentHookInstallStatus {
+  if (
+    status.state === 'installed' &&
+    (!existsSync(entryPath) || !existsSync(getWindowsClaudeHookPayloadPath(entryPath)))
+  ) {
+    return { ...status, state: 'partial', detail: 'Managed Claude hook script is missing' }
+  }
+  return status
+}
+
+export function installWindowsClaudeHookFiles(entryPath: string, payload: string): void {
+  writeManagedScript(getWindowsClaudeHookPayloadPath(entryPath), payload)
+  writeManagedScript(entryPath, getWindowsClaudeHookEntry())
+}
+
+export function getWindowsClaudeHookEntry(): string {
+  return [
+    '@echo off',
+    // Inherited delayed expansion would eat exclamation marks in the profile path.
+    'setlocal DisableDelayedExpansion',
+    `set "ORCA_CLAUDE_HOOK_IMPL=%~dp0${PAYLOAD_FILE_NAME}"`,
+    'if not exist "%ORCA_CLAUDE_HOOK_IMPL%" goto :missing_impl',
+    // Transfer control without CALL's second expansion of percent signs in the path.
+    // A payload that exists but cannot start (locked, quarantined) falls through to the neutral reply.
+    '"%ORCA_CLAUDE_HOOK_IMPL%"',
+    ':missing_impl',
+    'echo {}',
+    ...buildWindowsHookEnvironmentGuardLines(),
+    WINDOWS_CLAUDE_BACKGROUND_JOB_GUARD,
+    ...buildWindowsHookStdinDrainEpilogue(),
+    ''
+  ].join('\r\n')
+}
+
+export async function refreshWindowsClaudeHookFiles(
+  entryPath: string,
+  payload: string
+): Promise<void> {
+  // A surviving entry is Orca-owned; creating a missing one stays install()'s presence-gated job.
+  if (!(await scriptStillExists(entryPath))) {
+    return
+  }
+  // Publish the payload first so a failed migration leaves the previous single-file hook intact.
+  await restoreManagedScript(getWindowsClaudeHookPayloadPath(entryPath), payload)
+  await restoreManagedScript(entryPath, getWindowsClaudeHookEntry())
+}
diff --git a/src/main/codex-accounts/codex-account-registration.ts b/src/main/codex-accounts/codex-account-registration.ts
index fbdf0db1a68..6abab873563 100644
--- a/src/main/codex-accounts/codex-account-registration.ts
+++ b/src/main/codex-accounts/codex-account-registration.ts
@@ -219,7 +219,7 @@ export class CodexAccountRegistration {
     target: CodexAccountSelectionTarget | undefined
   ): void {
     // Why: quota probes against a cold per-account CODEX_HOME can take 10–25s
-    // (RPC + PTY fallback) and queue behind an in-flight global usage refresh.
+    // (RPC + HTTP fallback) and queue behind an in-flight global usage refresh.
     // The refresh synchronously flips usage to "fetching" before its first await,
     // so the switcher updates immediately; the probe itself must never block or
     // fail the already-durable account mutation.
diff --git a/src/main/codex-accounts/service-quota-refresh-decoupling.test.ts b/src/main/codex-accounts/service-quota-refresh-decoupling.test.ts
index b8e74b1cce5..925c5be81ed 100644
--- a/src/main/codex-accounts/service-quota-refresh-decoupling.test.ts
+++ b/src/main/codex-accounts/service-quota-refresh-decoupling.test.ts
@@ -32,7 +32,7 @@ describe('CodexAccountService config sync', () => {
   registerCodexAccountsTestHomes()
 
   // Why: quota probes against a cold per-account CODEX_HOME can take 10–25s
-  // (RPC + PTY fallback) and queue behind an in-flight global usage refresh;
+  // (RPC + HTTP fallback) and queue behind an in-flight global usage refresh;
   // account mutations must never block on — or fail because of — that probe.
   describe('quota refresh decoupling', () => {
     function createAccountOneSettings(): GlobalSettings {
diff --git a/src/main/daemon/headless-emulator.test.ts b/src/main/daemon/headless-emulator.test.ts
index 326bba56fb5..62fe4e68e11 100644
--- a/src/main/daemon/headless-emulator.test.ts
+++ b/src/main/daemon/headless-emulator.test.ts
@@ -565,6 +565,16 @@ describe('HeadlessEmulator', () => {
       expect(snapshot.modes.sgrMouseMode).toBe(false)
       expect(snapshot.rehydrateSequences).toContain('\x1b[?1002h')
       expect(snapshot.rehydrateSequences).not.toContain('\x1b[?1006h')
+      // Replay readers must not guess the encoding of an active tracking mode.
+      expect(snapshot.rehydrateSequences).toContain('\x1b[?1006l')
+    })
+
+    it('states no mouse encoding while nothing tracks the mouse', async () => {
+      emulator = new HeadlessEmulator({ cols: 80, rows: 24 })
+
+      await emulator.write('\x1b[?1002h\x1b[?1002l')
+
+      expect(emulator.getSnapshot().rehydrateSequences).not.toContain('\x1b[?1006')
     })
 
     it('tracks SGR-pixels mouse reporting as a separate active encoding', async () => {
diff --git a/src/main/daemon/serialize-grid-transcript-replay.test.ts b/src/main/daemon/serialize-grid-transcript-replay.test.ts
index 27863c82ec9..e404ccb04e2 100644
--- a/src/main/daemon/serialize-grid-transcript-replay.test.ts
+++ b/src/main/daemon/serialize-grid-transcript-replay.test.ts
@@ -66,7 +66,9 @@ const KNOWN_PREEXISTING_I2_FAILURES: Record<string, number> = {
   // background that the round trip does not restore to default. Verified as upstream, not a
   // regression, by replaying it against the previous build
   // (`build-serialize-addon-at-ref.mjs --ref origin/main`): I1 and I3 both hold.
-  'dsh-tui-ready-no-key': 10
+  'dsh-tui-ready-no-key': 10,
+  // Hermes banner cells restore with an extra bold bit under the jitter schedule.
+  'hermes-tui-ready': 2
 }
 
 // Exact resize checkpoints and full GridDiff hashes from base 6835b9b4e3ea, not this branch.
@@ -204,6 +206,12 @@ describe('serialize round trip over captured PTY transcripts', () => {
         console.log(`${transcript.name} ${JSON.stringify(counts)}`)
       }
       expect(blocking).toEqual([])
+      if (SEEDS === 2 && transcript.name === 'hermes-tui-ready') {
+        expect(failureSignatures).toEqual([
+          'jitter/false/2/34:0db2561506ff28d2e83276b07bc8684541957f61e488b6f8081627e8cad80c63',
+          'jitter/true/2/34:0db2561506ff28d2e83276b07bc8684541957f61e488b6f8081627e8cad80c63'
+        ])
+      }
       if (SEEDS === 2 && transcript.name.startsWith('freebuff-')) {
         expect(failureSignatures).toEqual(FREEBUFF_BASELINE[transcript.name] ?? [])
       } else if (!OLD_ADDON_PATH && SEEDS === 2) {
diff --git a/src/main/daemon/terminal-mode-rehydrate-sequences.ts b/src/main/daemon/terminal-mode-rehydrate-sequences.ts
index 8537de08961..b00145bacc8 100644
--- a/src/main/daemon/terminal-mode-rehydrate-sequences.ts
+++ b/src/main/daemon/terminal-mode-rehydrate-sequences.ts
@@ -19,7 +19,8 @@ export function buildRehydrateSequences(modes: TerminalModes): string {
   }
   // Why: mobile alt-screen scroll gestures need xterm's mouse mode restored
   // from cold snapshots; OpenCode/OpenTUI enables scrollable panes this way.
-  switch (modes.mouseTracking ? (modes.mouseTrackingMode ?? 'vt200') : 'none') {
+  const trackingMode = modes.mouseTracking ? (modes.mouseTrackingMode ?? 'vt200') : 'none'
+  switch (trackingMode) {
     case 'x10':
       seqs.push('\x1b[?9h')
       break
@@ -41,6 +42,9 @@ export function buildRehydrateSequences(modes: TerminalModes): string {
     seqs.push('\x1b[?1016h')
   } else if (modes.sgrMouseMode) {
     seqs.push('\x1b[?1006h')
+  } else if (trackingMode !== 'none') {
+    // Why: states the default encoding, so a replay reader never has to guess it.
+    seqs.push('\x1b[?1006l')
   }
   return seqs.join('')
 }
diff --git a/src/main/native-chat/transcript-line-decoders-claude-pasted-content.test.ts b/src/main/native-chat/transcript-line-decoders-claude-pasted-content.test.ts
new file mode 100644
index 00000000000..3711bdf038c
--- /dev/null
+++ b/src/main/native-chat/transcript-line-decoders-claude-pasted-content.test.ts
@@ -0,0 +1,53 @@
+import { describe, expect, it } from 'vitest'
+import { decodeClaudeTranscriptLine } from './transcript-line-decoders-claude'
+import { normalizeNativeChatUserText } from '../../shared/native-chat-image-transcript-markers'
+
+const prompt = 'Summarize the failing tests.\n\nThen propose a fix for each one.'
+const wrapped = `\n\n<pasted_content id="7e64">\n${prompt}\n</pasted_content id="7e64">\n`
+function decode(text: string, role = 'user', array = false) {
+  return decodeClaudeTranscriptLine(
+    JSON.stringify({
+      type: role,
+      uuid: 'user',
+      message: { content: array ? [{ type: 'text', text }] : text }
+    }),
+    'fallback'
+  )!
+}
+
+describe('Claude whole-block paste envelope', () => {
+  it.each([false, true])('decodes host user content (array=%s)', (array) => {
+    expect(decode(wrapped, 'user', array).blocks).toEqual([{ type: 'text', text: prompt }])
+  })
+  it('accepts CRLF and a wrapper without ids', () => {
+    expect(decode(`<pasted_content>\r\n${prompt}\r\n</pasted_content>`).blocks).toEqual([
+      { type: 'text', text: prompt }
+    ])
+  })
+  it('decodes a paste whose own text quotes differently identified or bare tags', () => {
+    const quoted = `<pasted_content id="aa">\nx\n</pasted_content id="aa">\n</pasted_content>`
+    expect(
+      decode(`<pasted_content id="7e64">\n${quoted}\n</pasted_content id="7e64">`).blocks
+    ).toEqual([{ type: 'text', text: quoted }])
+  })
+  it.each([
+    `Explain this:\n${wrapped}`,
+    `<pasted_content id="7e64">\n<pasted_content id="7e64">\nx\n</pasted_content id="7e64">`,
+    `<pasted_content>\n<pasted_content id="aa">\nx\n</pasted_content id="aa">\n</pasted_content>`,
+    wrapped.replace('id="7e64">\n', 'id="other">\n'),
+    wrapped.replace('</pasted_content id="7e64">', '</pasted_content>'),
+    wrapped.replace('<pasted_content id="7e64">', '<pasted_content>'),
+    `${wrapped}\n${wrapped}`
+  ])('preserves prose and nonmatching envelopes', (text) => {
+    expect(decode(text).blocks).toEqual([{ type: 'text', text }])
+  })
+  it('leaves assistant text untouched', () => {
+    expect(decode(wrapped, 'assistant').blocks).toEqual([{ type: 'text', text: wrapped }])
+  })
+  it('handles a large prompt in linear passes', () => {
+    const text = 'line\n'.repeat(50_000)
+    expect(
+      normalizeNativeChatUserText(`<pasted_content id="a">\n${text}\n</pasted_content id="a">`)
+    ).toBe(text.trim().replace(/\s+/g, ' '))
+  })
+})
diff --git a/src/main/native-chat/transcript-line-decoders-claude.ts b/src/main/native-chat/transcript-line-decoders-claude.ts
index 5202035bbc6..bc7a988e79e 100644
--- a/src/main/native-chat/transcript-line-decoders-claude.ts
+++ b/src/main/native-chat/transcript-line-decoders-claude.ts
@@ -15,6 +15,7 @@ import {
 } from '../ai-vault/session-scanner-values'
 import { imageSourcePathFromText } from '../../shared/native-chat-image-transcript-markers'
 import { claudeContentBlocks } from './transcript-record-blocks'
+import { unwrapClaudePastedContentBlock } from '../../shared/claude-pasted-content'
 import { claudeInterruptedMessageId } from './transcript-turn-markers'
 
 const MAX_EDIT_PATCH_HUNKS = 40
@@ -124,7 +125,7 @@ export function decodeClaudeTranscriptLine(
   return {
     id: messageId ?? fallbackId,
     role: claudeMessageRole(role, blocks),
-    blocks,
+    blocks: role === 'user' ? blocks.map(unwrapClaudePastedContentBlock) : blocks,
     timestamp,
     source: 'transcript'
   }
diff --git a/src/main/qoder/hook-service.test.ts b/src/main/qoder/hook-service.test.ts
index 954a545c2b9..fbb7d4058c0 100644
--- a/src/main/qoder/hook-service.test.ts
+++ b/src/main/qoder/hook-service.test.ts
@@ -80,16 +80,12 @@ describe('Qoder Windows hook shell', () => {
   it('uses the documented explicit shell without relying on Git Bash or another PowerShell hop', () => {
     vi.spyOn(process, 'platform', 'get').mockReturnValue('win32')
     try {
-      const hook = getManagedLifecycleHook(
-        'C:\\Users\\a b\\.orca\\agent-hooks\\qoder-hook.cmd',
-        {
-          configDirName: '.qoder',
-          scriptBaseName: 'qoder-hook',
-          usesWindowsCompatLauncher: true,
-          windowsHookShell: 'powershell'
-        },
-        { gitBashAvailable: true }
-      )
+      const hook = getManagedLifecycleHook('C:\\Users\\a b\\.orca\\agent-hooks\\qoder-hook.cmd', {
+        configDirName: '.qoder',
+        scriptBaseName: 'qoder-hook',
+        usesWindowsCompatLauncher: true,
+        windowsHookShell: 'powershell'
+      })
       expect(hook.shell).toBe('powershell')
       expect(hook.command).toContain('$env:USERPROFILE')
       expect(hook.command).not.toMatch(/EncodedCommand|ExecutionPolicy|\|\|/)
diff --git a/src/main/rate-limits/codex-fetcher-auth-errors.test.ts b/src/main/rate-limits/codex-fetcher-auth-errors.test.ts
index f482d2594b3..5ce9df8675e 100644
--- a/src/main/rate-limits/codex-fetcher-auth-errors.test.ts
+++ b/src/main/rate-limits/codex-fetcher-auth-errors.test.ts
@@ -1,5 +1,5 @@
 import { EventEmitter } from 'node:events'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
 const { childSpawnMock, resolveCodexCommandMock, ptySpawnMock } = vi.hoisted(() => ({
   childSpawnMock: vi.fn(),
@@ -26,10 +26,6 @@ vi.mock('./codex-auth-presence', () => ({
 
 import { fetchCodexRateLimits } from './codex-fetcher'
 
-function makeDisposable() {
-  return { dispose: vi.fn() }
-}
-
 function makeRpcChild() {
   const child = new EventEmitter() as EventEmitter & {
     stdout: EventEmitter
@@ -60,9 +56,14 @@ describe('fetchCodexRateLimits auth errors', () => {
     vi.useFakeTimers()
     vi.clearAllMocks()
     resolveCodexCommandMock.mockReturnValue('codex')
+    vi.stubGlobal('fetch', vi.fn())
   })
 
-  it('returns Codex RPC auth refresh errors without masking them behind PTY fallback', async () => {
+  afterEach(() => {
+    vi.unstubAllGlobals()
+  })
+
+  it('returns Codex RPC auth refresh errors without masking them behind a fallback', async () => {
     const rpcChild = makeRpcChild()
     const authError =
       'Your access token could not be refreshed because your refresh token was already used. Please log out and sign in again.'
@@ -105,10 +106,11 @@ describe('fetchCodexRateLimits auth errors', () => {
       status: 'error',
       error: authError
     })
+    expect(fetch).not.toHaveBeenCalled()
     expect(ptySpawnMock).not.toHaveBeenCalled()
   })
 
-  it('returns the app-server chatgpt-auth-required error without spawning the PTY probe', async () => {
+  it('returns the app-server chatgpt-auth-required error without falling back', async () => {
     const rpcChild = makeRpcChild()
     const authError = 'chatgpt authentication required to read rate limits'
 
@@ -150,75 +152,7 @@ describe('fetchCodexRateLimits auth errors', () => {
       status: 'error',
       error: authError
     })
+    expect(fetch).not.toHaveBeenCalled()
     expect(ptySpawnMock).not.toHaveBeenCalled()
   })
-
-  it('preserves Codex PTY auth errors when the CLI exits before status is available', async () => {
-    const ptyHandlers: { onData?: (data: string) => void; onExit?: () => void } = {}
-    const authError =
-      'Error loading configuration: Your authentication session could not be refreshed automatically.'
-
-    childSpawnMock.mockImplementation(() => {
-      throw new Error('rpc unavailable')
-    })
-    ptySpawnMock.mockReturnValue({
-      onData: vi.fn((callback) => {
-        ptyHandlers.onData = callback
-        return makeDisposable()
-      }),
-      onExit: vi.fn((callback) => {
-        ptyHandlers.onExit = callback
-        return makeDisposable()
-      }),
-      write: vi.fn(),
-      kill: vi.fn()
-    })
-
-    const resultPromise = fetchCodexRateLimits()
-    await vi.advanceTimersByTimeAsync(0)
-
-    ptyHandlers.onData?.(`${authError}\n`)
-    ptyHandlers.onExit?.()
-
-    await expect(resultPromise).resolves.toMatchObject({
-      provider: 'codex',
-      session: null,
-      weekly: null,
-      status: 'error',
-      error: authError
-    })
-  })
-
-  it('stops a PTY probe when Codex renders its sign-in screen', async () => {
-    const ptyHandlers: { onData?: (data: string) => void } = {}
-    const ptyWrite = vi.fn()
-    const ptyKill = vi.fn()
-
-    childSpawnMock.mockImplementation(() => {
-      throw new Error('rpc unavailable')
-    })
-    ptySpawnMock.mockReturnValue({
-      onData: vi.fn((callback) => {
-        ptyHandlers.onData = callback
-        return makeDisposable()
-      }),
-      onExit: vi.fn(() => makeDisposable()),
-      write: ptyWrite,
-      kill: ptyKill
-    })
-
-    const resultPromise = fetchCodexRateLimits()
-    await vi.advanceTimersByTimeAsync(0)
-    ptyHandlers.onData?.('\u001b[2JSign in with ChatGPT\r\n')
-
-    await expect(resultPromise).resolves.toMatchObject({
-      provider: 'codex',
-      session: null,
-      weekly: null,
-      status: 'error',
-      error: 'Sign in with ChatGPT'
-    })
-    expect(ptyWrite).not.toHaveBeenCalled()
-    expect(ptyKill).toHaveBeenCalledOnce()
-  })
 })
diff --git a/src/main/rate-limits/codex-fetcher-probe-shutdown.test.ts b/src/main/rate-limits/codex-fetcher-probe-shutdown.test.ts
index db0c4a7f5ed..d5b2d56b681 100644
--- a/src/main/rate-limits/codex-fetcher-probe-shutdown.test.ts
+++ b/src/main/rate-limits/codex-fetcher-probe-shutdown.test.ts
@@ -129,7 +129,7 @@ describe('fetchCodexRateLimits probe shutdown', () => {
       }
     })
 
-    const resultPromise = fetchCodexRateLimits({ allowPtyFallback: false })
+    const resultPromise = fetchCodexRateLimits()
     await vi.advanceTimersByTimeAsync(19_999)
     expect(rpcChild.kill).not.toHaveBeenCalled()
 
@@ -169,7 +169,7 @@ describe('fetchCodexRateLimits probe shutdown', () => {
     })
 
     try {
-      const resultPromise = fetchCodexRateLimits({ allowPtyFallback: false })
+      const resultPromise = fetchCodexRateLimits()
       await vi.advanceTimersByTimeAsync(0)
       await vi.advanceTimersByTimeAsync(9_999)
       expect(rpcChild.kill).not.toHaveBeenCalled()
@@ -200,12 +200,10 @@ describe('fetchCodexRateLimits probe shutdown', () => {
     })
 
     const first = fetchCodexRateLimits({
-      allowPtyFallback: false,
       codexHomePath: '/managed/home-a'
     })
     await vi.advanceTimersByTimeAsync(0)
     const second = fetchCodexRateLimits({
-      allowPtyFallback: false,
       codexHomePath: '/managed/home-a'
     })
     await vi.advanceTimersByTimeAsync(0)
@@ -241,13 +239,11 @@ describe('fetchCodexRateLimits probe shutdown', () => {
 
     try {
       const first = fetchCodexRateLimits({
-        allowPtyFallback: false,
         codexHomePath: '/managed/home-error'
       })
       await vi.advanceTimersByTimeAsync(0)
       firstChild.emit('error', new Error('stdio failed'))
       const second = fetchCodexRateLimits({
-        allowPtyFallback: false,
         codexHomePath: '/managed/home-error'
       })
       await vi.advanceTimersByTimeAsync(0)
@@ -308,14 +304,12 @@ describe('fetchCodexRateLimits probe shutdown', () => {
 
     try {
       const first = fetchCodexRateLimits({
-        allowPtyFallback: false,
         codexHomePath: home
       })
       await vi.advanceTimersByTimeAsync(0)
       expect(firstChild.kill).toHaveBeenCalledWith('SIGTERM')
 
       const second = fetchCodexRateLimits({
-        allowPtyFallback: false,
         codexHomePath: home
       })
       await vi.advanceTimersByTimeAsync(4_999)
@@ -357,13 +351,11 @@ describe('fetchCodexRateLimits probe shutdown', () => {
 
     try {
       const first = fetchCodexRateLimits({
-        allowPtyFallback: false,
         codexHomePath: '/managed/home-async-stdin-error'
       })
       await vi.advanceTimersByTimeAsync(0)
       firstChild.stdin.emit('error', Object.assign(new Error('write EPIPE'), { code: 'EPIPE' }))
       const second = fetchCodexRateLimits({
-        allowPtyFallback: false,
         codexHomePath: '/managed/home-async-stdin-error'
       })
 
diff --git a/src/main/rate-limits/codex-fetcher-process-contract.test.ts b/src/main/rate-limits/codex-fetcher-process-contract.test.ts
index b698c706c6a..0fd1f5f2c1e 100644
--- a/src/main/rate-limits/codex-fetcher-process-contract.test.ts
+++ b/src/main/rate-limits/codex-fetcher-process-contract.test.ts
@@ -130,8 +130,7 @@ describe('Codex rate-limit process contract', () => {
   it('starts a read-only non-interactive app-server with the managed home', async () => {
     await expect(
       fetchCodexRateLimits({
-        codexHomePath: process.env.ORCA_EXPECTED_CODEX_HOME,
-        allowPtyFallback: false
+        codexHomePath: process.env.ORCA_EXPECTED_CODEX_HOME
       })
     ).resolves.toMatchObject({
       provider: 'codex',
diff --git a/src/main/rate-limits/codex-fetcher-pty-settle.test.ts b/src/main/rate-limits/codex-fetcher-pty-settle.test.ts
deleted file mode 100644
index 15c338aad89..00000000000
--- a/src/main/rate-limits/codex-fetcher-pty-settle.test.ts
+++ /dev/null
@@ -1,300 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-const { childSpawnMock, resolveCodexCommandMock, ptySpawnMock } = vi.hoisted(() => ({
-  childSpawnMock: vi.fn(),
-  resolveCodexCommandMock: vi.fn(),
-  ptySpawnMock: vi.fn()
-}))
-
-vi.mock('node:child_process', () => ({
-  spawn: childSpawnMock
-}))
-
-vi.mock('../codex-cli/command', () => ({
-  resolveCodexCommand: resolveCodexCommandMock
-}))
-
-vi.mock('node-pty', () => ({
-  spawn: ptySpawnMock
-}))
-
-// Auth gate is covered separately; these tests assume a signed-in Codex.
-vi.mock('./codex-auth-presence', () => ({
-  probeCodexAuthPresence: vi.fn(() => 'present')
-}))
-
-import { fetchCodexRateLimits } from './codex-fetcher'
-
-function makeDisposable() {
-  return { dispose: vi.fn() }
-}
-
-describe('fetchCodexRateLimits PTY settle timers', () => {
-  beforeEach(() => {
-    vi.useFakeTimers()
-    vi.clearAllMocks()
-    resolveCodexCommandMock.mockReturnValue('codex')
-  })
-
-  it('coalesces the PTY fallback status settle timer while output keeps streaming', async () => {
-    const ptyHandlers: { onData?: (data: string) => void } = {}
-
-    childSpawnMock.mockImplementation(() => {
-      throw new Error('rpc unavailable')
-    })
-    ptySpawnMock.mockReturnValue({
-      onData: vi.fn((callback) => {
-        ptyHandlers.onData = callback
-        return makeDisposable()
-      }),
-      onExit: vi.fn(() => makeDisposable()),
-      write: vi.fn(),
-      kill: vi.fn()
-    })
-
-    const resultPromise = fetchCodexRateLimits()
-    await vi.advanceTimersByTimeAsync(0)
-
-    const onPtyData = ptyHandlers.onData
-    if (!onPtyData) {
-      throw new Error('PTY data handler was not registered')
-    }
-
-    onPtyData('>')
-    // Pending: PTY timeout + the delayed /status Enter keypress.
-    expect(vi.getTimerCount()).toBe(2)
-
-    onPtyData('5h limit: 17%\n')
-    onPtyData('Weekly limit: 23%\n')
-    onPtyData('still rendering\n')
-    // One settle timer armed — not one per data chunk.
-    expect(vi.getTimerCount()).toBe(3)
-
-    await vi.advanceTimersByTimeAsync(500)
-
-    await expect(resultPromise).resolves.toMatchObject({
-      session: { usedPercent: 17 },
-      weekly: { usedPercent: 23 },
-      status: 'ok'
-    })
-  })
-
-  it('keeps the reset text on the weekly window for weekly-only plans', async () => {
-    const ptyHandlers: { onData?: (data: string) => void } = {}
-
-    childSpawnMock.mockImplementation(() => {
-      throw new Error('rpc unavailable')
-    })
-    ptySpawnMock.mockReturnValue({
-      onData: vi.fn((callback) => {
-        ptyHandlers.onData = callback
-        return makeDisposable()
-      }),
-      onExit: vi.fn(() => makeDisposable()),
-      write: vi.fn(),
-      kill: vi.fn()
-    })
-
-    const resultPromise = fetchCodexRateLimits()
-    await vi.advanceTimersByTimeAsync(0)
-
-    const onPtyData = ptyHandlers.onData
-    if (!onPtyData) {
-      throw new Error('PTY data handler was not registered')
-    }
-
-    onPtyData('>')
-    onPtyData('Weekly limit: 76%\nResets in 5d 23h\n')
-
-    await vi.advanceTimersByTimeAsync(500)
-
-    const fiveDays23h = (5 * 24 + 23) * 60 * 60 * 1000
-    await expect(resultPromise).resolves.toMatchObject({
-      session: null,
-      weekly: {
-        usedPercent: 76,
-        resetDescription: '5d 23h',
-        resetsAt: Date.now() + fiveDays23h
-      },
-      status: 'ok'
-    })
-  })
-
-  it('keeps each window reset text on its own window for dual-window plans', async () => {
-    const ptyHandlers: { onData?: (data: string) => void } = {}
-
-    childSpawnMock.mockImplementation(() => {
-      throw new Error('rpc unavailable')
-    })
-    ptySpawnMock.mockReturnValue({
-      onData: vi.fn((callback) => {
-        ptyHandlers.onData = callback
-        return makeDisposable()
-      }),
-      onExit: vi.fn(() => makeDisposable()),
-      write: vi.fn(),
-      kill: vi.fn()
-    })
-
-    const resultPromise = fetchCodexRateLimits()
-    await vi.advanceTimersByTimeAsync(0)
-
-    const onPtyData = ptyHandlers.onData
-    if (!onPtyData) {
-      throw new Error('PTY data handler was not registered')
-    }
-
-    onPtyData('>')
-    onPtyData('5h limit: 17% (resets in 2h 30m)\nWeekly limit: 23% (resets in 5d 3h)\n')
-
-    await vi.advanceTimersByTimeAsync(500)
-
-    await expect(resultPromise).resolves.toMatchObject({
-      session: {
-        usedPercent: 17,
-        resetDescription: '2h 30m',
-        resetsAt: Date.now() + (2 * 60 + 30) * 60 * 1000
-      },
-      weekly: {
-        usedPercent: 23,
-        resetDescription: '5d 3h',
-        resetsAt: Date.now() + (5 * 24 + 3) * 60 * 60 * 1000
-      },
-      status: 'ok'
-    })
-  })
-
-  it('parses the framed codex 0.145 status panel via the /status nudge', async () => {
-    const ptyHandlers: { onData?: (data: string) => void } = {}
-    const write = vi.fn()
-
-    childSpawnMock.mockImplementation(() => {
-      throw new Error('rpc unavailable')
-    })
-    ptySpawnMock.mockReturnValue({
-      onData: vi.fn((callback) => {
-        ptyHandlers.onData = callback
-        return makeDisposable()
-      }),
-      onExit: vi.fn(() => makeDisposable()),
-      write,
-      kill: vi.fn()
-    })
-
-    const resultPromise = fetchCodexRateLimits()
-    await vi.advanceTimersByTimeAsync(0)
-
-    const onPtyData = ptyHandlers.onData
-    if (!onPtyData) {
-      throw new Error('PTY data handler was not registered')
-    }
-
-    // codex ≥0.145 shows a '›' composer with placeholder text, never a bare '>' prompt.
-    onPtyData('›Summarize recent commits')
-    expect(write).not.toHaveBeenCalled()
-    await vi.advanceTimersByTimeAsync(2500)
-    expect(write).toHaveBeenCalledWith('/status')
-    await vi.advanceTimersByTimeAsync(350)
-    expect(write).toHaveBeenCalledWith('\r')
-
-    onPtyData(
-      '│  Weekly limit:                       \x1b[?2026h\x1b[0 q[█████████░░░░░░░░░░░] 43% left\x1b[?2026l (resets 10:21 on 28 Jul)  │\n' +
-        '│  GPT-5.3-Codex-Spark Weekly limit:   [████████████████████] 100% left (resets 17:40 on 29 Jul) │\n'
-    )
-    await vi.advanceTimersByTimeAsync(500)
-
-    const expectedReset = new Date(new Date().getFullYear(), 6, 28, 10, 21)
-    if (expectedReset.getTime() <= Date.now()) {
-      expectedReset.setFullYear(expectedReset.getFullYear() + 1)
-    }
-    await expect(resultPromise).resolves.toMatchObject({
-      session: null,
-      weekly: {
-        usedPercent: 57,
-        resetDescription: '10:21 on 28 Jul',
-        resetsAt: expectedReset.getTime()
-      },
-      status: 'ok'
-    })
-  })
-
-  it('never selects a model-scoped weekly row even when it renders first', async () => {
-    const ptyHandlers: { onData?: (data: string) => void } = {}
-
-    childSpawnMock.mockImplementation(() => {
-      throw new Error('rpc unavailable')
-    })
-    ptySpawnMock.mockReturnValue({
-      onData: vi.fn((callback) => {
-        ptyHandlers.onData = callback
-        return makeDisposable()
-      }),
-      onExit: vi.fn(() => makeDisposable()),
-      write: vi.fn(),
-      kill: vi.fn()
-    })
-
-    const resultPromise = fetchCodexRateLimits()
-    await vi.advanceTimersByTimeAsync(0)
-
-    const onPtyData = ptyHandlers.onData
-    if (!onPtyData) {
-      throw new Error('PTY data handler was not registered')
-    }
-
-    onPtyData('>')
-    onPtyData(
-      '│  GPT-5.3-Codex-Spark Weekly limit:   [████████████████████] 100% left (resets 17:40 on 29 Jul) │\n' +
-        '│  Weekly limit:                       [█████████░░░░░░░░░░░] 43% left (resets 10:21 on 28 Jul)  │\n'
-    )
-    await vi.advanceTimersByTimeAsync(500)
-
-    await expect(resultPromise).resolves.toMatchObject({
-      session: null,
-      weekly: { usedPercent: 57, resetDescription: '10:21 on 28 Jul' },
-      status: 'ok'
-    })
-  })
-
-  it('re-sends Enter once when the panel does not render after the first submit', async () => {
-    const ptyHandlers: { onData?: (data: string) => void } = {}
-    const write = vi.fn()
-
-    childSpawnMock.mockImplementation(() => {
-      throw new Error('rpc unavailable')
-    })
-    ptySpawnMock.mockReturnValue({
-      onData: vi.fn((callback) => {
-        ptyHandlers.onData = callback
-        return makeDisposable()
-      }),
-      onExit: vi.fn(() => makeDisposable()),
-      write,
-      kill: vi.fn()
-    })
-
-    const resultPromise = fetchCodexRateLimits()
-    await vi.advanceTimersByTimeAsync(0)
-
-    const onPtyData = ptyHandlers.onData
-    if (!onPtyData) {
-      throw new Error('PTY data handler was not registered')
-    }
-
-    onPtyData('>')
-    await vi.advanceTimersByTimeAsync(350)
-    expect(write.mock.calls.filter((call) => call[0] === '\r')).toHaveLength(1)
-
-    await vi.advanceTimersByTimeAsync(3000)
-    expect(write.mock.calls.filter((call) => call[0] === '\r')).toHaveLength(2)
-
-    onPtyData('Weekly limit: 76%\nResets in 5d 23h\n')
-    await vi.advanceTimersByTimeAsync(500)
-
-    await expect(resultPromise).resolves.toMatchObject({
-      session: null,
-      weekly: { usedPercent: 76 },
-      status: 'ok'
-    })
-  })
-})
diff --git a/src/main/rate-limits/codex-fetcher-rpc-exit-diagnostics.test.ts b/src/main/rate-limits/codex-fetcher-rpc-exit-diagnostics.test.ts
index 441be8d836d..3231d71876d 100644
--- a/src/main/rate-limits/codex-fetcher-rpc-exit-diagnostics.test.ts
+++ b/src/main/rate-limits/codex-fetcher-rpc-exit-diagnostics.test.ts
@@ -62,7 +62,8 @@ let stubPath: string
 function runStub(stderr: string, exitCode: number): Promise<{ error: string | null }> {
   process.env.ORCA_STUB_CODEX_STDERR = stderr
   process.env.ORCA_STUB_CODEX_EXIT_CODE = String(exitCode)
-  return fetchCodexRateLimits({ allowPtyFallback: false })
+  // Why: a temp home with no auth.json keeps the HTTP fallback off the developer's real login.
+  return fetchCodexRateLimits({ codexHomePath: tempRoot })
 }
 
 describe('Codex RPC exit diagnostics', () => {
diff --git a/src/main/rate-limits/codex-fetcher-runtime-pairing.test.ts b/src/main/rate-limits/codex-fetcher-runtime-pairing.test.ts
index d825bb65fd8..ee23ead1966 100644
--- a/src/main/rate-limits/codex-fetcher-runtime-pairing.test.ts
+++ b/src/main/rate-limits/codex-fetcher-runtime-pairing.test.ts
@@ -82,7 +82,7 @@ describe('codex rate-limit spawn runtime pairing', () => {
     const rpcChild = makeRpcChild()
     childSpawnMock.mockReturnValue(rpcChild)
 
-    const resultPromise = fetchCodexRateLimits({ allowPtyFallback: false })
+    const resultPromise = fetchCodexRateLimits()
     await vi.advanceTimersByTimeAsync(0)
 
     const spawnEnv = childSpawnMock.mock.calls[0]?.[2]?.env as NodeJS.ProcessEnv
@@ -105,7 +105,7 @@ describe('codex rate-limit spawn runtime pairing', () => {
       const rpcChild = makeRpcChild()
       childSpawnMock.mockReturnValue(rpcChild)
 
-      const resultPromise = fetchCodexRateLimits({ allowPtyFallback: false })
+      const resultPromise = fetchCodexRateLimits()
       await vi.advanceTimersByTimeAsync(0)
 
       const spawnCommand = childSpawnMock.mock.calls[0]?.[0] as string
@@ -127,7 +127,7 @@ describe('codex rate-limit spawn runtime pairing', () => {
     const rpcChild = makeRpcChild()
     childSpawnMock.mockReturnValue(rpcChild)
 
-    const resultPromise = fetchCodexRateLimits({ allowPtyFallback: false })
+    const resultPromise = fetchCodexRateLimits()
     await vi.advanceTimersByTimeAsync(0)
 
     const spawnEnv = childSpawnMock.mock.calls[0]?.[2]?.env as NodeJS.ProcessEnv
diff --git a/src/main/rate-limits/codex-fetcher.test.ts b/src/main/rate-limits/codex-fetcher.test.ts
index 7d5b7423f7c..ec22103901b 100644
--- a/src/main/rate-limits/codex-fetcher.test.ts
+++ b/src/main/rate-limits/codex-fetcher.test.ts
@@ -58,13 +58,8 @@ vi.mock('./codex-auth-presence', () => ({
 
 import { fetchCodexRateLimits } from './codex-fetcher'
 import { probeCodexAuthPresence } from './codex-auth-presence'
-import { getActiveHiddenRateLimitPtyCount } from './hidden-pty-cleanup'
 import { CODEX_SHORT_LIVED_PROBE_APP_SERVER_ARGS } from '../codex-cli/codex-read-only-app-server-args'
 
-function makeDisposable() {
-  return { dispose: vi.fn() }
-}
-
 function makeRpcChild() {
   const child = new EventEmitter() as EventEmitter & {
     stdout: EventEmitter
@@ -116,23 +111,24 @@ function respondToRpcRateLimitRead(
   })
 }
 
-function makePtyTerm() {
-  let dataHandler: ((data: string) => void) | null = null
-  let exitHandler: (() => void) | null = null
-  return {
-    onData: vi.fn((callback: (data: string) => void) => {
-      dataHandler = callback
-      return makeDisposable()
-    }),
-    onExit: vi.fn((callback: () => void) => {
-      exitHandler = callback
-      return makeDisposable()
-    }),
-    write: vi.fn(),
-    kill: vi.fn(),
-    emitData: (data: string) => dataHandler?.(data),
-    emitExit: () => exitHandler?.()
-  }
+function mockBackendUsage(): void {
+  readFileMock.mockResolvedValue(
+    JSON.stringify({ tokens: { access_token: 'access-token', account_id: 'account-id' } })
+  )
+  // A Response body reads once; usage and reset credits each fetch.
+  vi.mocked(fetch).mockImplementation(
+    async () =>
+      new Response(
+        JSON.stringify({
+          plan_type: 'plus',
+          rate_limit: {
+            primary_window: { used_percent: 7, limit_window_seconds: 5 * 60 * 60 },
+            secondary_window: { used_percent: 12, limit_window_seconds: 7 * 24 * 60 * 60 }
+          },
+          rate_limit_reset_credits: { available_count: 0, credits: [] }
+        })
+      )
+  )
 }
 
 describe('fetchCodexRateLimits', () => {
@@ -168,9 +164,7 @@ describe('fetchCodexRateLimits', () => {
   it('does not let a quota probe steal an incomplete state-DB backfill lease', async () => {
     isBackfillPendingMock.mockReturnValue(true)
 
-    await expect(
-      fetchCodexRateLimits({ codexHomePath: '/managed-home', allowPtyFallback: false })
-    ).resolves.toMatchObject({
+    await expect(fetchCodexRateLimits({ codexHomePath: '/managed-home' })).resolves.toMatchObject({
       status: 'error',
       error: expect.stringContaining('session index')
     })
@@ -219,38 +213,11 @@ describe('fetchCodexRateLimits', () => {
     }
   )
 
-  it('disposes node-pty listeners before killing the PTY fallback on timeout', async () => {
-    const onDataDisposable = makeDisposable()
-    const onExitDisposable = makeDisposable()
-    const killMock = vi.fn()
-
-    childSpawnMock.mockImplementation(() => {
-      throw new Error('rpc unavailable')
-    })
-    ptySpawnMock.mockReturnValue({
-      onData: vi.fn(() => onDataDisposable),
-      onExit: vi.fn(() => onExitDisposable),
-      write: vi.fn(),
-      kill: killMock
-    })
-
-    const resultPromise = fetchCodexRateLimits()
-    await vi.advanceTimersByTimeAsync(15_000)
-    await resultPromise
-
-    expect(onDataDisposable.dispose.mock.invocationCallOrder[0]).toBeLessThan(
-      killMock.mock.invocationCallOrder[0]
-    )
-    expect(onExitDisposable.dispose.mock.invocationCallOrder[0]).toBeLessThan(
-      killMock.mock.invocationCallOrder[0]
-    )
-  })
-
   it('spawns the RPC rate-limit reader in a bounded non-root cwd', async () => {
     const rpcChild = makeRpcChild()
     childSpawnMock.mockReturnValue(rpcChild)
 
-    const resultPromise = fetchCodexRateLimits({ allowPtyFallback: false })
+    const resultPromise = fetchCodexRateLimits()
     await vi.advanceTimersByTimeAsync(0)
 
     const spawnCwd = childSpawnMock.mock.calls[0]?.[2]?.cwd as string
@@ -262,26 +229,7 @@ describe('fetchCodexRateLimits', () => {
     await resultPromise
   })
 
-  it('spawns the PTY fallback in a bounded non-root cwd', async () => {
-    const term = makePtyTerm()
-    childSpawnMock.mockImplementation(() => {
-      throw new Error('rpc unavailable')
-    })
-    ptySpawnMock.mockReturnValue(term)
-
-    const resultPromise = fetchCodexRateLimits()
-    await vi.advanceTimersByTimeAsync(0)
-
-    const spawnCwd = ptySpawnMock.mock.calls[0]?.[2]?.cwd as string
-    expect(spawnCwd).toContain('rate-limit-pty-cwd')
-    expect(spawnCwd).not.toBe('/')
-    expect(spawnCwd).not.toMatch(/^[A-Za-z]:\\?$/)
-
-    term.emitExit()
-    await resultPromise
-  })
-
-  it('kills the RPC child and skips PTY fallback when the fetch signal aborts', async () => {
+  it('kills the RPC child and skips the HTTP fallback when the fetch signal aborts', async () => {
     const rpcChild = makeRpcChild()
     childSpawnMock.mockReturnValue(rpcChild)
     const controller = new AbortController()
@@ -297,77 +245,40 @@ describe('fetchCodexRateLimits', () => {
       error: 'Rate-limit fetch aborted'
     })
     expect(rpcChild.kill).toHaveBeenCalledTimes(1)
+    expect(fetch).not.toHaveBeenCalled()
     expect(ptySpawnMock).not.toHaveBeenCalled()
   })
 
-  it('kills and unregisters the PTY fallback when the fetch signal aborts', async () => {
-    const term = makePtyTerm()
-    childSpawnMock.mockImplementation(() => {
-      throw new Error('rpc unavailable')
-    })
-    ptySpawnMock.mockReturnValue(term)
-    const controller = new AbortController()
-    const killMock = term.kill
-
-    const resultPromise = fetchCodexRateLimits({ signal: controller.signal })
-    await vi.advanceTimersByTimeAsync(0)
-
-    expect(getActiveHiddenRateLimitPtyCount()).toBe(1)
-
-    controller.abort()
-
-    await expect(resultPromise).resolves.toMatchObject({
-      provider: 'codex',
-      status: 'error',
-      error: 'Rate-limit fetch aborted'
-    })
-    expect(killMock).toHaveBeenCalledTimes(1)
-    expect(getActiveHiddenRateLimitPtyCount()).toBe(0)
-  })
-
-  it('falls back to the PTY status reader when RPC exits before returning usage', async () => {
+  it('reads usage over HTTP, never through the Codex TUI, when RPC exits before returning usage', async () => {
     const rpcChild = makeRpcChild()
-    const ptyHandlers: { onData?: (data: string) => void } = {}
-
     childSpawnMock.mockReturnValue(rpcChild)
-    ptySpawnMock.mockReturnValue({
-      onData: vi.fn((callback) => {
-        ptyHandlers.onData = callback
-        return makeDisposable()
-      }),
-      onExit: vi.fn(() => makeDisposable()),
-      write: vi.fn(),
-      kill: vi.fn()
-    })
+    mockBackendUsage()
 
     const resultPromise = fetchCodexRateLimits()
     await vi.advanceTimersByTimeAsync(0)
     rpcChild.emit('close')
-    await vi.advanceTimersByTimeAsync(0)
-
-    expect(ptySpawnMock).toHaveBeenCalled()
-    const onPtyData = ptyHandlers.onData
-    if (!onPtyData) {
-      throw new Error('PTY data handler was not registered')
-    }
-    onPtyData('>')
-    onPtyData('5h limit: 7%\nWeekly limit: 12%\n')
-    await vi.advanceTimersByTimeAsync(500)
 
     await expect(resultPromise).resolves.toMatchObject({
       provider: 'codex',
-      session: { usedPercent: 7 },
-      weekly: { usedPercent: 12 },
+      session: { usedPercent: 7, windowMinutes: 300 },
+      weekly: { usedPercent: 12, windowMinutes: 10080 },
       status: 'ok',
       error: null
     })
+    expect(fetch).toHaveBeenCalledWith(
+      'https://chatgpt.com/backend-api/wham/usage',
+      expect.objectContaining({
+        headers: expect.objectContaining({ Authorization: 'Bearer access-token' })
+      })
+    )
+    expect(ptySpawnMock).not.toHaveBeenCalled()
   })
 
-  it('does not start the PTY fallback when disabled for background account previews', async () => {
+  it('keeps the RPC error when the HTTP fallback has no usage to offer', async () => {
     const rpcChild = makeRpcChild()
     childSpawnMock.mockReturnValue(rpcChild)
 
-    const resultPromise = fetchCodexRateLimits({ allowPtyFallback: false })
+    const resultPromise = fetchCodexRateLimits()
     await vi.advanceTimersByTimeAsync(0)
     rpcChild.emit('close')
     await vi.advanceTimersByTimeAsync(0)
@@ -379,6 +290,28 @@ describe('fetchCodexRateLimits', () => {
       status: 'error'
     })
     expect(rpcChild.stdin.listenerCount('error')).toBe(0)
+    expect(fetch).not.toHaveBeenCalled()
+    expect(ptySpawnMock).not.toHaveBeenCalled()
+  })
+
+  it('shows the RPC exit reason when the HTTP fallback is rejected', async () => {
+    const rpcChild = makeRpcChild()
+    childSpawnMock.mockReturnValue(rpcChild)
+    mockBackendUsage()
+    vi.mocked(fetch).mockResolvedValue(new Response(null, { status: 401 }))
+
+    const resultPromise = fetchCodexRateLimits()
+    await vi.advanceTimersByTimeAsync(0)
+    rpcChild.emit('close', 1, null)
+
+    await expect(resultPromise).resolves.toMatchObject({
+      provider: 'codex',
+      session: null,
+      weekly: null,
+      status: 'error',
+      error: expect.stringContaining('exit code 1')
+    })
+    expect(fetch).toHaveBeenCalledTimes(1)
     expect(ptySpawnMock).not.toHaveBeenCalled()
   })
 
@@ -386,7 +319,7 @@ describe('fetchCodexRateLimits', () => {
     const rpcChild = makeRpcChild()
     childSpawnMock.mockReturnValue(rpcChild)
 
-    const resultPromise = fetchCodexRateLimits({ allowPtyFallback: false })
+    const resultPromise = fetchCodexRateLimits()
     // Why: without an initialize response only the 30s boot deadline fires.
     await vi.advanceTimersByTimeAsync(30_000)
 
@@ -810,27 +743,18 @@ describe('fetchCodexRateLimits', () => {
     }
   })
 
-  it('runs rate-limit PTY fallback through WSL when RPC cannot read usage', async () => {
+  it('does not retry HTTP after RPC fails for a WSL home, since WSL already tried HTTP first', async () => {
     const originalPlatform = process.platform
-    const originalCodexHome = process.env.CODEX_HOME
     Object.defineProperty(process, 'platform', {
       configurable: true,
       value: 'win32'
     })
-    process.env.CODEX_HOME = 'C:\\Users\\alice\\.codex'
-
     const rpcChild = makeRpcChild()
-    const ptyHandlers: { onData?: (data: string) => void } = {}
     childSpawnMock.mockReturnValue(rpcChild)
-    ptySpawnMock.mockReturnValue({
-      onData: vi.fn((callback) => {
-        ptyHandlers.onData = callback
-        return makeDisposable()
-      }),
-      onExit: vi.fn(() => makeDisposable()),
-      write: vi.fn(),
-      kill: vi.fn()
-    })
+    readFileMock.mockResolvedValue(
+      JSON.stringify({ tokens: { access_token: 'access-token', account_id: 'account-id' } })
+    )
+    vi.mocked(fetch).mockResolvedValue(new Response(null, { status: 503 }))
 
     try {
       const resultPromise = fetchCodexRateLimits({
@@ -838,53 +762,12 @@ describe('fetchCodexRateLimits', () => {
       })
       await vi.advanceTimersByTimeAsync(0)
       rpcChild.emit('close')
-      await vi.advanceTimersByTimeAsync(0)
 
-      const [spawnFile, spawnArgs, spawnOptions] = ptySpawnMock.mock.calls[0]
-      expect(spawnFile).toBe('wsl.exe')
-      expect(spawnArgs.slice(0, 5)).toEqual(['-d', 'Ubuntu', '--exec', 'sh', '-c'])
-      const shellCommand = spawnArgs.at(-1) as string
-      expect(shellCommand).toContain('_orca_wsl_shell=$(getent passwd')
-      expect(shellCommand).toContain('bash|zsh|ksh|mksh|ash) exec "$_orca_wsl_shell" -ilc')
-      expect(shellCommand).not.toContain('exec 3<&0')
-      expect(shellCommand).not.toContain('exec </dev/null')
-      expect(shellCommand).not.toContain('exec >/dev/null')
-      expect(shellCommand).not.toContain('<&3 >&4 3<&- 4>&-')
-      expect(shellCommand).toContain('mkdir -p "$orca_rate_limit_cwd"')
-      expect(shellCommand).toContain('cd "$orca_rate_limit_cwd"')
-      expect(shellCommand).toContain(
-        "export CODEX_HOME='\\''/home/alice/.local/share/orca/account/home'\\''"
-      )
-      expect(shellCommand).toContain('exec codex ')
-      expect(shellCommand).toContain('features.plugins=false')
-      expect(shellCommand).not.toContain('_orca_codex')
-      expect(shellCommand).not.toContain('wsl-codex-path')
-      expect(spawnOptions).toEqual(
-        expect.objectContaining({
-          cwd: expect.stringContaining('rate-limit-pty-cwd'),
-          env: expect.not.objectContaining({ CODEX_HOME: expect.anything() })
-        })
-      )
-
-      const onPtyData = ptyHandlers.onData
-      if (!onPtyData) {
-        throw new Error('PTY data handler was not registered')
-      }
-      onPtyData('>')
-      onPtyData('5h limit: 17%\nWeekly limit: 23%\n')
-      await vi.advanceTimersByTimeAsync(500)
-
-      await expect(resultPromise).resolves.toMatchObject({
-        session: { usedPercent: 17 },
-        weekly: { usedPercent: 23 },
-        status: 'ok'
-      })
+      await expect(resultPromise).resolves.toMatchObject({ status: 'error' })
+      expect(fetch).toHaveBeenCalledTimes(1)
+      expect(childSpawnMock).toHaveBeenCalledTimes(1)
+      expect(ptySpawnMock).not.toHaveBeenCalled()
     } finally {
-      if (originalCodexHome === undefined) {
-        delete process.env.CODEX_HOME
-      } else {
-        process.env.CODEX_HOME = originalCodexHome
-      }
       Object.defineProperty(process, 'platform', {
         configurable: true,
         value: originalPlatform
diff --git a/src/main/rate-limits/codex-fetcher.ts b/src/main/rate-limits/codex-fetcher.ts
index 804cd22c660..e10202fd430 100644
--- a/src/main/rate-limits/codex-fetcher.ts
+++ b/src/main/rate-limits/codex-fetcher.ts
@@ -2,10 +2,7 @@ import type { CodexRateLimitResetOutcome, ProviderRateLimits } from '../../share
 import { isCodexAuthError } from '../../shared/codex-auth-errors'
 import { buildWslExecArgs, buildWslLoginShellCommand } from '../../shared/wsl-login-shell-command'
 import { parseWslUncPath } from '../../shared/wsl-paths'
-import {
-  CODEX_DISABLE_PLUGINS_ARGS,
-  CODEX_SHORT_LIVED_PROBE_APP_SERVER_ARGS
-} from '../codex-cli/codex-read-only-app-server-args'
+import { CODEX_SHORT_LIVED_PROBE_APP_SERVER_ARGS } from '../codex-cli/codex-read-only-app-server-args'
 import { resolveCodexCommand } from '../codex-cli/command'
 // Why: import from the shared module, not the codex-cli re-export, so a test that
 // mocks '../codex-cli/command' does not have to restate this pure helper.
@@ -16,9 +13,7 @@ import {
 } from '../codex-cli/codex-home-process-lock'
 import { isCodexStateDbBackfillPending } from '../codex/codex-state-db'
 import { startCodexStateDbBackfillRecoveryInBackground } from '../codex/codex-state-db-backfill-recovery'
-import { withMacTailscaleDnsHint } from '../network/macos-tailscale-dns-diagnostic'
 import { spawnProcess } from '../../shared/child-process/run-process'
-import { getCmdExePath } from '../win32-utils'
 import { probeCodexAuthPresence } from './codex-auth-presence'
 import {
   fetchCodexRateLimitsViaBackend,
@@ -26,7 +21,6 @@ import {
 } from './codex-backend-usage-client'
 import type { CodexRateLimitFetchOptions } from './codex-rate-limit-fetch-options'
 import { abortedCodexRateLimitResult } from './codex-rate-limit-fetch-result'
-import { fetchCodexRateLimitsViaPty } from './codex-pty-rate-limit-probe'
 import { terminateCodexProbeChild } from './codex-probe-termination'
 import {
   consumeCodexRateLimitResetCreditFromBackend,
@@ -47,17 +41,11 @@ const WSL_RPC_TIMEOUT_MS = 25_000
 const RPC_INIT_TIMEOUT_MS = 30_000
 const WSL_RPC_INIT_TIMEOUT_MS = 40_000
 
-// Keep the PTY fallback aligned with the RPC probe: rate-limit collection does
-// not need marketplace/plugin startup, and those background clones can outlive
-// the short-lived probe process.
-const CODEX_RATE_LIMIT_PLUGIN_ARGS = CODEX_DISABLE_PLUGINS_ARGS
-
 export type FetchCodexRateLimitsOptions = CodexRateLimitFetchOptions
 
 function buildWslCodexCommand(
   codexHomePath: string,
-  args: string[],
-  isolateRpcStdio: boolean
+  args: string[]
 ): { command: string; args: string[] } | null {
   const wslInfo = parseWslUncPath(codexHomePath)
   if (process.platform !== 'win32' || !wslInfo) {
@@ -67,15 +55,17 @@ function buildWslCodexCommand(
     ...getHiddenRateLimitWslCwdSetupCommands(),
     `export CODEX_HOME=${quoteHiddenRateLimitShellValue(wslInfo.linuxPath)}`
   ].join(' && ')
-  const execSuffix = `${args.map(quoteHiddenRateLimitShellValue).join(' ')}${
-    isolateRpcStdio ? ' <&3 >&4 3<&- 4>&-' : ''
-  }`
+  const execSuffix = `${args.map(quoteHiddenRateLimitShellValue).join(' ')} <&3 >&4 3<&- 4>&-`
   const loginShellCommand = buildWslLoginShellCommand(
     [setupCommands, `exec codex ${execSuffix}`].join(' && ')
   )
-  const command = isolateRpcStdio
-    ? ['exec 3<&0', 'exec 4>&1', 'exec </dev/null', 'exec >/dev/null', loginShellCommand].join('\n')
-    : loginShellCommand
+  const command = [
+    'exec 3<&0',
+    'exec 4>&1',
+    'exec </dev/null',
+    'exec >/dev/null',
+    loginShellCommand
+  ].join('\n')
   return {
     command: 'wsl.exe',
     args: buildWslExecArgs(wslInfo.distro, ['sh', '-c', command])
@@ -106,7 +96,7 @@ async function fetchViaRpc(options?: CodexRateLimitFetchOptions): Promise<Provid
   }
   const codexArgs = [...CODEX_SHORT_LIVED_PROBE_APP_SERVER_ARGS]
   const wslCodex = options?.codexHomePath
-    ? buildWslCodexCommand(options.codexHomePath, codexArgs, true)
+    ? buildWslCodexCommand(options.codexHomePath, codexArgs)
     : null
   const codexCommand = wslCodex ? 'codex' : resolveCodexCommand()
   // Why the bare CLI: spawnProcess resolves an npm `codex.cmd` shim past cmd.exe itself.
@@ -130,28 +120,6 @@ async function fetchViaRpc(options?: CodexRateLimitFetchOptions): Promise<Provid
   })
 }
 
-function resolvePtyCommand(options?: CodexRateLimitFetchOptions) {
-  const wslCodex = options?.codexHomePath
-    ? buildWslCodexCommand(options.codexHomePath, [...CODEX_RATE_LIMIT_PLUGIN_ARGS], false)
-    : null
-  const codexCommand = wslCodex ? 'codex' : resolveCodexCommand()
-  const isWin32 = process.platform === 'win32'
-  return {
-    command: wslCodex ? wslCodex.command : isWin32 ? getCmdExePath() : codexCommand,
-    args: wslCodex
-      ? wslCodex.args
-      : isWin32
-        ? ['/d', '/c', codexCommand, ...CODEX_RATE_LIMIT_PLUGIN_ARGS]
-        : [...CODEX_RATE_LIMIT_PLUGIN_ARGS],
-    cwd: resolveHiddenRateLimitPtyCwd(),
-    env: withCliRuntimeOnPath(codexCommand, {
-      ...(wslCodex ? processEnvWithoutCodexHome() : process.env),
-      TERM: 'xterm-256color',
-      ...(options?.codexHomePath && !wslCodex ? { CODEX_HOME: options.codexHomePath } : {})
-    })
-  }
-}
-
 export function consumeCodexRateLimitResetCredit(options: {
   codexHomePath?: string | null
   idempotencyKey: string
@@ -178,19 +146,19 @@ function codexUnavailable(error: string, status: 'error' | 'unavailable'): Provi
   }
 }
 
-async function fetchWslBackend(
-  options: CodexRateLimitFetchOptions
+async function fetchBackendUsage(
+  options: CodexRateLimitFetchOptions | undefined
 ): Promise<ProviderRateLimits | null> {
   try {
     const result = await fetchCodexRateLimitsViaBackend(fetchCodexUsage, options)
-    if (options.signal?.aborted) {
+    if (options?.signal?.aborted) {
       return abortedCodexRateLimitResult()
     }
     return result
       ? supplementCodexRateLimitResetCredits(result, fetchCodexResetCredits, options)
       : null
   } catch {
-    return options.signal?.aborted ? abortedCodexRateLimitResult() : null
+    return options?.signal?.aborted ? abortedCodexRateLimitResult() : null
   }
 }
 
@@ -218,10 +186,11 @@ export async function fetchCodexRateLimits(
     )
   }
 
-  if (options?.codexHomePath && parseWslUncPath(options.codexHomePath)) {
-    const backendResult = await fetchWslBackend(options)
+  const isWslHome = Boolean(options?.codexHomePath && parseWslUncPath(options.codexHomePath))
+  if (isWslHome) {
+    const backendResult = await fetchBackendUsage(options)
     if (backendResult) {
-      return options.signal?.aborted ? abortedCodexRateLimitResult() : backendResult
+      return options?.signal?.aborted ? abortedCodexRateLimitResult() : backendResult
     }
   }
 
@@ -233,9 +202,12 @@ export async function fetchCodexRateLimits(
     )
   }
 
-  const homeLockKey = resolveCodexHomeProcessLockKey(options?.codexHomePath)
+  let rpcFailure: ProviderRateLimits
   try {
-    const rpcResult = await withCodexHomeProcessLock(homeLockKey, () => fetchViaRpc(options))
+    const rpcResult = await withCodexHomeProcessLock(
+      resolveCodexHomeProcessLockKey(options?.codexHomePath),
+      () => fetchViaRpc(options)
+    )
     if (options?.signal?.aborted) {
       return abortedCodexRateLimitResult()
     }
@@ -243,39 +215,24 @@ export async function fetchCodexRateLimits(
       const supplemented = await supplementBackendMetadata(rpcResult, options)
       return options?.signal?.aborted ? abortedCodexRateLimitResult() : supplemented
     }
-    if (isCodexAuthError(rpcResult.error) || options?.allowPtyFallback === false) {
+    if (isCodexAuthError(rpcResult.error)) {
       return rpcResult
     }
+    rpcFailure = rpcResult
   } catch {
     if (options?.signal?.aborted) {
       return abortedCodexRateLimitResult()
     }
-    if (options?.allowPtyFallback === false) {
-      return codexUnavailable('RPC failed', 'error')
-    }
+    rpcFailure = codexUnavailable('RPC failed', 'error')
   }
 
-  try {
-    if (options?.signal?.aborted) {
-      return abortedCodexRateLimitResult()
-    }
-    const ptyResult = await withCodexHomeProcessLock(homeLockKey, () =>
-      fetchCodexRateLimitsViaPty(() => resolvePtyCommand(options), options)
-    )
-    if (options?.signal?.aborted) {
-      return abortedCodexRateLimitResult()
-    }
-    const supplemented = await supplementBackendMetadata(ptyResult, options)
-    return options?.signal?.aborted ? abortedCodexRateLimitResult() : supplemented
-  } catch (error) {
-    if (options?.signal?.aborted) {
-      return abortedCodexRateLimitResult()
-    }
-    const message = error instanceof Error ? error.message : 'Unknown error'
-    const isNotInstalled = message.includes('ENOENT')
-    return codexUnavailable(
-      isNotInstalled ? 'Codex CLI not found' : withMacTailscaleDnsHint(message),
-      isNotInstalled ? 'unavailable' : 'error'
-    )
+  if (isWslHome) {
+    return rpcFailure
   }
+  // Why: read usage over HTTP, never by driving the interactive Codex TUI — keystrokes sent there can accept startup dialogs such as "Update now" (#17415).
+  const backendResult = await fetchBackendUsage(options)
+  if (options?.signal?.aborted) {
+    return abortedCodexRateLimitResult()
+  }
+  return backendResult ?? rpcFailure
 }
diff --git a/src/main/rate-limits/codex-pty-rate-limit-probe.test.ts b/src/main/rate-limits/codex-pty-rate-limit-probe.test.ts
deleted file mode 100644
index de3c6631dcc..00000000000
--- a/src/main/rate-limits/codex-pty-rate-limit-probe.test.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-import { fetchCodexRateLimitsViaPty } from './codex-pty-rate-limit-probe'
-
-describe('Codex PTY rate-limit probe cancellation', () => {
-  it('does not resolve the process command after cancellation', async () => {
-    const controller = new AbortController()
-    const resolveCommand = vi.fn(() => ({
-      command: 'codex',
-      args: [],
-      cwd: '.',
-      env: {}
-    }))
-    controller.abort()
-
-    await expect(
-      fetchCodexRateLimitsViaPty(resolveCommand, { signal: controller.signal })
-    ).resolves.toMatchObject({
-      provider: 'codex',
-      status: 'error',
-      error: 'Rate-limit fetch aborted'
-    })
-    expect(resolveCommand).not.toHaveBeenCalled()
-  })
-})
diff --git a/src/main/rate-limits/codex-pty-rate-limit-probe.ts b/src/main/rate-limits/codex-pty-rate-limit-probe.ts
deleted file mode 100644
index 194e7d19fd6..00000000000
--- a/src/main/rate-limits/codex-pty-rate-limit-probe.ts
+++ /dev/null
@@ -1,236 +0,0 @@
-import type { ProviderRateLimits } from '../../shared/rate-limit-types'
-import { extractCodexAuthError } from '../../shared/codex-auth-errors'
-import { withMacTailscaleDnsHint } from '../network/macos-tailscale-dns-diagnostic'
-import { cleanupHiddenRateLimitPty, registerHiddenRateLimitPty } from './hidden-pty-cleanup'
-import type { CodexRateLimitFetchOptions } from './codex-rate-limit-fetch-options'
-import { abortedCodexRateLimitResult } from './codex-rate-limit-fetch-result'
-import {
-  hasCodexPtyRateLimit,
-  parseCodexPtyStatus,
-  stripCodexPtyControlSequences
-} from './codex-pty-status-parser'
-
-const PTY_TIMEOUT_MS = 15_000
-const PTY_STATUS_NUDGE_MS = 2_500
-const PTY_STATUS_ENTER_DELAY_MS = 350
-const PTY_STATUS_ENTER_RETRY_MS = 3_000
-const MAX_DIAGNOSTIC_OUTPUT_LENGTH = 100_000
-
-export type CodexPtyRateLimitCommand = {
-  command: string
-  args: string[]
-  cwd: string
-  env: NodeJS.ProcessEnv
-}
-
-export async function fetchCodexRateLimitsViaPty(
-  resolveCommand: () => CodexPtyRateLimitCommand,
-  options?: CodexRateLimitFetchOptions
-): Promise<ProviderRateLimits> {
-  if (options?.signal?.aborted) {
-    return abortedCodexRateLimitResult()
-  }
-  const pty = await import('node-pty')
-  if (options?.signal?.aborted) {
-    return abortedCodexRateLimitResult()
-  }
-  const command = resolveCommand()
-
-  return new Promise<ProviderRateLimits>((resolve) => {
-    let output = ''
-    let resolved = false
-    let sentStatus = false
-    let settleTimer: ReturnType<typeof setTimeout> | null = null
-    let timeout: ReturnType<typeof setTimeout> | null = null
-
-    const term = pty.spawn(command.command, command.args, {
-      name: 'xterm-256color',
-      cols: 120,
-      rows: 40,
-      cwd: command.cwd,
-      env: command.env
-    })
-    const termDisposables: { dispose: () => void }[] = [registerHiddenRateLimitPty(term)]
-
-    let statusEnter: ReturnType<typeof setTimeout> | null = null
-    let statusNudge: ReturnType<typeof setTimeout> | null = null
-    function sendStatusCommand(): void {
-      sentStatus = true
-      if (statusNudge) {
-        clearTimeout(statusNudge)
-        statusNudge = null
-      }
-      term.write('/status')
-      statusEnter = setTimeout(() => {
-        statusEnter = null
-        term.write('\r')
-        statusEnter = setTimeout(() => {
-          statusEnter = null
-          if (!resolved && !settleTimer) {
-            term.write('\r')
-          }
-        }, PTY_STATUS_ENTER_RETRY_MS)
-      }, PTY_STATUS_ENTER_DELAY_MS)
-    }
-
-    function armStatusNudge(): void {
-      if (statusNudge || sentStatus || resolved) {
-        return
-      }
-      statusNudge = setTimeout(() => {
-        statusNudge = null
-        if (!resolved && !sentStatus) {
-          sendStatusCommand()
-        }
-      }, PTY_STATUS_NUDGE_MS)
-    }
-    termDisposables.push({
-      dispose: () => {
-        if (statusNudge) {
-          clearTimeout(statusNudge)
-          statusNudge = null
-        }
-        if (statusEnter) {
-          clearTimeout(statusEnter)
-          statusEnter = null
-        }
-      }
-    })
-
-    function clearSettleTimers(): void {
-      if (timeout) {
-        clearTimeout(timeout)
-        timeout = null
-      }
-      if (settleTimer) {
-        clearTimeout(settleTimer)
-        settleTimer = null
-      }
-    }
-
-    function settleAborted(): void {
-      if (resolved) {
-        return
-      }
-      resolved = true
-      clearSettleTimers()
-      cleanupHiddenRateLimitPty(term, termDisposables, { kill: true })
-      resolve(abortedCodexRateLimitResult())
-    }
-
-    if (options?.signal) {
-      if (options.signal.aborted) {
-        settleAborted()
-        return
-      }
-      options.signal.addEventListener('abort', settleAborted, { once: true })
-      termDisposables.push({
-        dispose: () => options.signal?.removeEventListener('abort', settleAborted)
-      })
-    }
-
-    timeout = setTimeout(() => {
-      if (!resolved) {
-        resolved = true
-        clearSettleTimers()
-        cleanupHiddenRateLimitPty(term, termDisposables, { kill: true })
-        resolve({
-          provider: 'codex',
-          session: null,
-          weekly: null,
-          updatedAt: Date.now(),
-          error: extractCodexAuthError(output) ?? withMacTailscaleDnsHint('PTY timeout', output),
-          status: 'error'
-        })
-      }
-    }, PTY_TIMEOUT_MS)
-
-    const onDataDisposable = term.onData((data) => {
-      output += data
-      if (output.length > MAX_DIAGNOSTIC_OUTPUT_LENGTH) {
-        output = output.slice(-MAX_DIAGNOSTIC_OUTPUT_LENGTH)
-      }
-
-      const authError = extractCodexAuthError(output)
-      if (authError) {
-        resolved = true
-        clearSettleTimers()
-        cleanupHiddenRateLimitPty(term, termDisposables, { kill: true })
-        resolve({
-          provider: 'codex',
-          session: null,
-          weekly: null,
-          updatedAt: Date.now(),
-          error: authError,
-          status: 'error'
-        })
-        return
-      }
-
-      armStatusNudge()
-      if (!sentStatus && /[>›]\s*$/.test(data)) {
-        sendStatusCommand()
-        return
-      }
-      const probe = sentStatus && !settleTimer ? stripCodexPtyControlSequences(output) : null
-      if (probe !== null && hasCodexPtyRateLimit(probe)) {
-        settleTimer = setTimeout(() => {
-          settleTimer = null
-          if (resolved) {
-            return
-          }
-          resolved = true
-          clearSettleTimers()
-          cleanupHiddenRateLimitPty(term, termDisposables, { kill: true })
-          const clean = stripCodexPtyControlSequences(output)
-          const { session, weekly } = parseCodexPtyStatus(clean)
-          resolve({
-            provider: 'codex',
-            session,
-            weekly,
-            updatedAt: Date.now(),
-            error:
-              session || weekly
-                ? null
-                : withMacTailscaleDnsHint('Failed to parse CLI output', clean),
-            status: session || weekly ? 'ok' : 'error'
-          })
-        }, 500)
-      }
-    })
-    if (onDataDisposable) {
-      termDisposables.push(onDataDisposable)
-    }
-
-    const onExitDisposable = term.onExit(() => {
-      cleanupHiddenRateLimitPty(term, termDisposables, { kill: false })
-      if (settleTimer) {
-        clearTimeout(settleTimer)
-        settleTimer = null
-      }
-      if (!resolved) {
-        resolved = true
-        if (timeout) {
-          clearTimeout(timeout)
-        }
-        const clean = stripCodexPtyControlSequences(output)
-        const { session, weekly } = parseCodexPtyStatus(clean)
-        resolve({
-          provider: 'codex',
-          session,
-          weekly,
-          updatedAt: Date.now(),
-          error:
-            session || weekly
-              ? null
-              : (extractCodexAuthError(clean) ??
-                withMacTailscaleDnsHint('CLI exited before status was available', clean)),
-          status: session || weekly ? 'ok' : 'error'
-        })
-      }
-    })
-    if (onExitDisposable) {
-      termDisposables.push(onExitDisposable)
-    }
-  })
-}
diff --git a/src/main/rate-limits/codex-pty-status-parser.test.ts b/src/main/rate-limits/codex-pty-status-parser.test.ts
deleted file mode 100644
index 602c67600ca..00000000000
--- a/src/main/rate-limits/codex-pty-status-parser.test.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { parseCodexPtyStatus } from './codex-pty-status-parser'
-
-describe('Codex PTY status parser', () => {
-  it('uses the account row orientation and reset when a model-scoped weekly row renders first', () => {
-    const result = parseCodexPtyStatus(
-      'GPT-5.3-Codex-Spark Weekly limit: 100% left (resets in 1d 2h)\n' +
-        'Weekly limit: 43% left (resets in 5d 3h)\n'
-    )
-
-    expect(result).toMatchObject({
-      session: null,
-      weekly: {
-        usedPercent: 57,
-        resetDescription: '5d 3h'
-      }
-    })
-  })
-})
diff --git a/src/main/rate-limits/codex-pty-status-parser.ts b/src/main/rate-limits/codex-pty-status-parser.ts
deleted file mode 100644
index d298d3503c3..00000000000
--- a/src/main/rate-limits/codex-pty-status-parser.ts
+++ /dev/null
@@ -1,62 +0,0 @@
-import type { RateLimitWindow } from '../../shared/rate-limit-types'
-import { extractClaudePtyResetMetadata } from './claude-pty-reset-parser'
-
-// Why: reject model-scoped rows regardless of row order in cursor-positioned output.
-const FIVE_HOUR_RE = /(?<![\w-][^\S\r\n]{0,4})5h\s+limit[^\d%\r\n]*(\d+)%(?:\s*(used|left))?/i
-const WEEKLY_RE = /(?<![\w-][^\S\r\n]{0,4})weekly\s+limit[^\d%\r\n]*(\d+)%(?:\s*(used|left))?/i
-const ANY_LIMIT_LABEL_RE = /(?:5h|weekly)\s+limit/i
-// eslint-disable-next-line no-control-regex
-const PTY_CONTROL_SEQUENCE_RE = /\x1b\[[0-?]*[ -/]*[@-~]/g
-
-export function stripCodexPtyControlSequences(output: string): string {
-  return output.replace(PTY_CONTROL_SEQUENCE_RE, '')
-}
-
-export function hasCodexPtyRateLimit(output: string): boolean {
-  return FIVE_HOUR_RE.test(output) || WEEKLY_RE.test(output)
-}
-
-function ptyUsedPercent(match: RegExpExecArray): number {
-  const pct = Number.parseInt(match[1], 10)
-  const oriented = match[2]?.toLowerCase() === 'left' ? 100 - pct : pct
-  return Math.min(100, Math.max(0, oriented))
-}
-
-export function parseCodexPtyStatus(output: string): {
-  session: RateLimitWindow | null
-  weekly: RateLimitWindow | null
-} {
-  const fiveMatch = FIVE_HOUR_RE.exec(output)
-  const weeklyMatch = WEEKLY_RE.exec(output)
-  const lines = output.split(/\r\n|\n|\r/)
-  const isLimitLabel = (line: string): boolean => ANY_LIMIT_LABEL_RE.test(line)
-  const sessionReset = extractClaudePtyResetMetadata(
-    lines,
-    (line) => FIVE_HOUR_RE.test(line),
-    isLimitLabel
-  )
-  const weeklyReset = extractClaudePtyResetMetadata(
-    lines,
-    (line) => WEEKLY_RE.test(line),
-    isLimitLabel
-  )
-
-  return {
-    session: fiveMatch
-      ? {
-          usedPercent: ptyUsedPercent(fiveMatch),
-          windowMinutes: 300,
-          resetsAt: sessionReset.resetsAt,
-          resetDescription: sessionReset.resetDescription
-        }
-      : null,
-    weekly: weeklyMatch
-      ? {
-          usedPercent: ptyUsedPercent(weeklyMatch),
-          windowMinutes: 10080,
-          resetsAt: weeklyReset.resetsAt,
-          resetDescription: weeklyReset.resetDescription
-        }
-      : null
-  }
-}
diff --git a/src/main/rate-limits/codex-rate-limit-fetch-options.ts b/src/main/rate-limits/codex-rate-limit-fetch-options.ts
index 1c13496644c..a130dfe8289 100644
--- a/src/main/rate-limits/codex-rate-limit-fetch-options.ts
+++ b/src/main/rate-limits/codex-rate-limit-fetch-options.ts
@@ -1,5 +1,4 @@
 export type CodexRateLimitFetchOptions = {
   codexHomePath?: string | null
-  allowPtyFallback?: boolean
   signal?: AbortSignal
 }
diff --git a/src/main/rate-limits/service-inactive-account-previews.test.ts b/src/main/rate-limits/service-inactive-account-previews.test.ts
index 23f0a0e6bba..7db0a60d661 100644
--- a/src/main/rate-limits/service-inactive-account-previews.test.ts
+++ b/src/main/rate-limits/service-inactive-account-previews.test.ts
@@ -144,7 +144,6 @@ describe('RateLimitService', () => {
     expect(fetchCodexRateLimits).toHaveBeenCalledWith(
       expect.objectContaining({
         codexHomePath: wslCodexHome,
-        allowPtyFallback: false,
         signal: expect.any(AbortSignal)
       })
     )
diff --git a/src/main/rate-limits/service/service-fetch-targets.ts b/src/main/rate-limits/service/service-fetch-targets.ts
index 51ce2db3d0b..a24322a5471 100644
--- a/src/main/rate-limits/service/service-fetch-targets.ts
+++ b/src/main/rate-limits/service/service-fetch-targets.ts
@@ -127,7 +127,6 @@ export abstract class RateLimitServiceFetchTargets extends RateLimitServiceResul
       try {
         fresh = await fetchCodexRateLimits({
           codexHomePath,
-          allowPtyFallback: this.shouldAllowCodexPtyFallback(),
           signal: controller.signal
         })
       } catch (error) {
@@ -172,11 +171,6 @@ export abstract class RateLimitServiceFetchTargets extends RateLimitServiceResul
     return { ...stateBeforeReset, codex: scopedCodex, codexTarget: target }
   }
 
-  protected shouldAllowCodexPtyFallback(): boolean {
-    // Why: hidden PTY fallback can crash inside ConPTY on Windows; prefer RPC-only degradation there for background quota refresh.
-    return process.platform !== 'win32'
-  }
-
   protected shouldAllowClaudePtyFallback(
     authPreparation: ClaudeRuntimeAuthPreparation | undefined
   ): boolean {
diff --git a/src/main/rate-limits/service/service-full-cycle-preparation.ts b/src/main/rate-limits/service/service-full-cycle-preparation.ts
index 55a2cc2a062..96faa82eb34 100644
--- a/src/main/rate-limits/service/service-full-cycle-preparation.ts
+++ b/src/main/rate-limits/service/service-full-cycle-preparation.ts
@@ -183,7 +183,6 @@ export abstract class RateLimitServiceFullCyclePreparation extends RateLimitServ
           : (missingWslCodexHome ??
             fetchCodexRateLimits({
               codexHomePath,
-              allowPtyFallback: this.shouldAllowCodexPtyFallback(),
               signal
             })),
         fetchGeminiRateLimits(geminiCliOAuthEnabled),
diff --git a/src/main/rate-limits/service/service-inactive-accounts.ts b/src/main/rate-limits/service/service-inactive-accounts.ts
index 5d977991af4..e59d1eeb3a9 100644
--- a/src/main/rate-limits/service/service-inactive-accounts.ts
+++ b/src/main/rate-limits/service/service-inactive-accounts.ts
@@ -97,7 +97,7 @@ export abstract class RateLimitServiceInactiveAccounts extends RateLimitServiceP
     if (accounts.length === 0) {
       return
     }
-    // Why: account switching can activate a previewed account while its RPC-only fetch is still in flight; ignore stale results.
+    // Why: account switching can activate a previewed account while its usage fetch is still in flight; ignore stale results.
     const fetchGeneration = this.inactiveCodexAccountsGeneration
     const controller = this.beginFetchCycle()
     const signal = controller.signal
@@ -143,10 +143,8 @@ export abstract class RateLimitServiceInactiveAccounts extends RateLimitServiceP
         this.pushToRenderer()
         try {
           // Why: point fetchCodexRateLimits at the managed home directly, avoiding materializing credentials into the shared runtime location.
-          // Why: no PTY fallback — the switcher preview shouldn't spawn hidden PTYs per account (can crash ConPTY on Windows); RPC-only is enough.
           const fresh = await fetchCodexRateLimits({
             codexHomePath: home.managedHomePath,
-            allowPtyFallback: false,
             signal
           })
           if (
diff --git a/src/main/rate-limits/service/service-provider-cycles.ts b/src/main/rate-limits/service/service-provider-cycles.ts
index 75c56d96e67..fdb7040b58a 100644
--- a/src/main/rate-limits/service/service-provider-cycles.ts
+++ b/src/main/rate-limits/service/service-provider-cycles.ts
@@ -40,7 +40,6 @@ export abstract class RateLimitServiceProviderCycles extends RateLimitServiceFul
         ? Promise.resolve(missingWslCodexHome)
         : fetchCodexRateLimits({
             codexHomePath,
-            allowPtyFallback: this.shouldAllowCodexPtyFallback(),
             signal
           })
     ).catch((err): ProviderRateLimits => ({
diff --git a/src/main/runtime/__fixtures__/hermes-tui-ready.meta.json b/src/main/runtime/__fixtures__/hermes-tui-ready.meta.json
new file mode 100644
index 00000000000..46a4b35910c
--- /dev/null
+++ b/src/main/runtime/__fixtures__/hermes-tui-ready.meta.json
@@ -0,0 +1,9 @@
+{
+  "capturedAt": "2026-09-23T21:11:11.946Z",
+  "platform": "linux",
+  "command": ["hermes", "--yolo", "--tui"],
+  "cols": 120,
+  "rows": 31,
+  "note": "Hermes Agent v0.21.4 on headless Linux, ready without a submitted prompt; command path, model label, tool inventory, and session marker anonymized.",
+  "exitCode": 0
+}
diff --git a/src/main/runtime/__fixtures__/hermes-tui-ready.txt b/src/main/runtime/__fixtures__/hermes-tui-ready.txt
new file mode 100644
index 00000000000..45aaab96a8a
--- /dev/null
+++ b/src/main/runtime/__fixtures__/hermes-tui-ready.txt
@@ -0,0 +1 @@
+[?1003l[?1002l[?1001l[?1000l[?9l[?1006l[?1005l[?1015l[?1016l[?2029l[0'z[0'{[?2029l[?1016l[?1015l[?1006l[?1005l[?1003l[?1002l[?1001l[?1000l[?9l[?1004l[?2004l[?1049l[<u[>4m[?25h[?1049h[?1006l[?1003l[?1002l[?1000l[?1000h[?1002h[?1003h[?1006h[?2004h[?1004h[?25l[?2004h]0;Hermes
██╗  ██╗███████╗██████╗ ███╗   ███╗███████╗███████╗       █████╗  ██████╗ ███████╗███╗   ██╗████████╗
██║  ██║██╔════╝██╔══██╗████╗ ████║██╔════╝██╔════╝      ██╔══██╗██╔════╝ ██╔════╝████╗  ██║╚══██╔══╝
███████║█████╗  ██████╔╝██╔████╔██║█████╗  ███████╗█████╗███████║██║  ███╗█████╗  ██╔██╗ ██║   ██║   
██╔══██║██╔══╝  ██╔══██╗██║╚██╔╝██║██╔══╝  ╚════██║╚════╝██╔══██║██║   ██║██╔══╝  ██║╚██╗██║   ██║   
██║  ██║███████╗██║  ██║██║ ╚═╝ ██║███████╗███████║      ██║  ██║╚██████╔╝███████╗██║ ╚████║   ██║   
╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝╚═╝     ╚═╝╚══════╝╚══════╝      ╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚═╝  ╚═══╝   ╚═╝   
☤ Nous Research · Messenger of the Digital Gods
─ summoning hermes… │  │ voice off ─ …ktrees/XXXXXXXXXXXXXXXXXXXX
❯Try "/help" for commands[>0q]11;?]10;?[?1006l[?1003l[?1002l[?1000l[?1000h[?1002h[?1003h[?1006h
t-c-bom (…n/XXXXXXXXXXXXX)
forgig session… │ │ voice of [?1000$p]1;✓]2;✓ example-modelxx · ~]1;✓]2;✓ example-modelxx · ~██║  ██║███████╗██║  ██║██║ ╚═╝ ██║███████╗███████║      ██║  ██║╚██████╔╝███████╗██║ ╚████║   ██║   
╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝╚═╝     ╚═╝╚══════╝╚══════╝      ╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚═╝  ╚═══╝   ╚═╝   
☤ Nous Research · Messenger of the Digital Gods                                                      
                                                                                                     
╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│                                                                                                    │
│  ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⡀⠀⣀⣀⠀⢀⣀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀                                   Hermes Agent                     │
│  ⠀⠀⠀⠀⠀⠀⢀⣠⣴⣾⣿⣿⣇⠸⣿⣿⠇⣸⣿⣿⣷⣦⣄⡀⠀⠀⠀⠀⠀⠀              │
│⠀⢀⣠⣴⣶⠿⠋⣩⡿⣿⡿⠻⣿⡇⢠⡄⢸⣿⠟⢿⣿⢿⣍⠙⠿⣶⣦⣄⡀⠀│
│⠀⠀⠉⠉⠁⠶⠟⠋⠀⠉⠀⢀⣈⣁⡈⢁⣈⣁⡀⠀⠉⠀⠙⠻⠶⠈⠉⠉⠀⠀▾ Available Tools│
│⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣴⣿⡿⠛⢁⡈⠛⢿⣿⣦⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁│
│⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠿⣿⣦⣤⣈⠁⢠⣴⣿⠿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁│
│⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⠻⢿⣿⣦⡉⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁│
│⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⢷⣦⣈⠛⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁│
│⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⣴⠦⠈⠙⠿⣦⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀▁▁▁▁▁▁▁▁▁▁▁▁▁▁│
│⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⣿⣤⡈⠁⢤⣿⠇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁│
│⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠛⠷⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀│
│⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⠑⢶⣄⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀▸ Available Skills (0)│
│⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⠁⢰⡆⠈⡿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀… tools · … skills · /help for commands│
│⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠳⠈⣡⠞⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀│
│⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀│
│example-modelxx · Nous Research│
│workspace00│
│Session: 00000000│
││
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
starting agent… │ gpt6 luna 900k │ 0s │ voice off         ─ ~]1;✓]2;✓ example-modelxx · ~│
│
│
│
┃
┃
┃
┃
┃
┃
┃
┃
┃
┃
┃
┃
┃
┃
┃
┃
┃
┃
┃
┃
┃
┃
┃
 │ 1 session]1;✓]2;✓ example-modelxx · ~
                    ─ ~
▁▁
▁▁▁
▁▁
▁▁
▁▁
▁▁▁
▁▁
▁▁▁
▁▁
▁▁
▁▁
▁▁▁
▁▁
▁▁
▁▁
▁▁
▁▁
▁▁▁
▁▁
▁▁
▁▁
▁▁
▁▁
▁▁
▁▁
▁▁
▁▁
▁▁
▁▁
▁▁
▁▁
▁▁
▁▁
▁▁
▁▁
▁▁
▁▁
▁▁
▁▁▁
▁▁▁
▁▁
▁▁
▁▁
▁▁
▁▁▁
▁▁▁
▁▁
▁▁▁
▁▁
▁▁
▁▁▁
▁▁▁
▁▁
▁▁▁
▁▁
▁▁
▁▁▁
▁▁▁
▁▁
▁▁▁
▁▁
▁▁
▁▁▁
▁▁▁
▁▁
▁▁▁
1
▁▁
▁▁
▁▁▁
▁▁
▁▁
▁▁▁
▁▁
▁▁
▁▁▁
▁▁
▁▁
▁▁▁
▁▁
▁▁
▁▁▁
▁▁▁
▁▁
▁▁
▁▁▁
▁▁
▁▁▁
▁▁▁
▁▁
▁▁
▁▁▁
▁▁
▁▁▁
▁▁▁
▁▁
▁▁
▁▁▁
▁▁▁
▁▁▁
▁▁▁
▁▁
▁▁
▁▁▁
▁▁▁
▁▁▁
▁▁▁
▁▁
▁▁▁
▁▁▁
▁▁
▁▁
▁▁
▁▁
▁▁▁
▁▁▁
▁▁
▁▁
▁▁
▁▁
▁▁▁
▁▁▁
▁▁
▁▁
▁▁
▁▁
▁▁
▁▁▁
▁▁
▁▁
▁▁
▁▁
▁▁
2
▁▁▁
▁▁
▁▁
▁▁
▁▁
▁▁
▁▁▁
▁▁
▁▁
▁▁
▁▁
▁▁
▁▁▁
▁▁
▁▁
▁▁
▁▁
▁▁
▁▁▁
▁▁
▁▁▁
▁▁▁
▁▁
▁▁
▁▁▁
▁▁
▁▁▁
▁▁▁
▁▁
▁▁
▁▁▁
▁▁
▁▁▁
▁▁▁
▁▁
▁▁▁
▁▁▁
▁▁
▁▁▁
▁▁▁
▁▁
▁▁▁
▁▁▁
▁▁
▁▁▁
▁▁▁
▁▁
▁▁▁
▁▁▁
▁▁
▁▁
▁▁
▁▁
▁▁▁
▁▁▁
▁▁
▁▁
▁▁
▁▁
▁▁▁
▁▁▁
▁▁▁
▁▁▁
▁▁▁
▁▁
▁▁▁
3
▁▁▁
▁▁▁
▁▁▁
▁▁▁
▁▁
▁▁
▁▁▁
▁▁
▁▁▁
▁▁▁
▁▁
▁▁▁
▁▁▁
▁▁
▁▁▁
▁▁▁
▁▁
▁▁▁
▁▁▁
▁▁
▁▁▁
▁▁▁
▁▁
▁▁▁
▁▁
▁▁
▁▁▁
▁▁
▁▁
▁▁]1;✓]2;✓ example-modelxx · ~]1;✓]2;✓ example-modelxx · ~
Hermes Agent v0.21.4 (2026.9.21)
browser: browser_vault_enter_code, browser_vault_fill, …+3
browser-use: browser_exec
clarify: clarify           
code_execution: execute_code
delegation: delegate_task
file: patch, read_file, search_files, write_file
exampletools0: sample_action, sample_state, sample_entities_12, …+1
kanban: kanban_attach, kanban_attach_url, kanban_attachments, …+11
(and X more toolsets…)                 
▸ Available Skills (XXX) in XX categories
▸ MCP Servers (X) connected
XX tools · XXX skills · X MCP · /help for commands
ready │ example modelxxmax │ 3s │ voiceoff │ 1 session      
4
5
6
7
8
9
10s │ voice of │ 1 sesion
1
2
3
4
5
6
7
8
9
20
\ No newline at end of file
diff --git a/src/main/runtime/hermes-readiness-transcript.test.ts b/src/main/runtime/hermes-readiness-transcript.test.ts
new file mode 100644
index 00000000000..5605f69f91e
--- /dev/null
+++ b/src/main/runtime/hermes-readiness-transcript.test.ts
@@ -0,0 +1,128 @@
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { describe, expect, it, vi } from 'vitest'
+import { createTranscriptPane, TRANSCRIPT_PANE_PTY_ID } from './agent-transcript-pane-test-harness'
+import { createHookListenerState } from '../../shared/agent-hook-listener/listener-state'
+import { normalizeHermesEvent } from '../../shared/agent-hook-listener/providers/hermes-events'
+
+vi.mock('electron', () => ({
+  BrowserWindow: { fromId: vi.fn(() => null) },
+  webContents: { fromId: vi.fn(() => null) },
+  ipcMain: { on: vi.fn(), removeListener: vi.fn() },
+  app: { getPath: vi.fn(() => '/tmp') }
+}))
+
+const captured = readFileSync(join(__dirname, '__fixtures__', 'hermes-tui-ready.txt'), 'utf8')
+
+/** The real payload Orca's managed Hermes plugin produces for `eventName`, wired through the
+ *  same normalizer the hook relay uses — so a regression in the event mapping fails here too,
+ *  not only in the provider's own unit test. */
+const status = (eventName: string, payload: Record<string, unknown> = {}): string => {
+  const parsed = normalizeHermesEvent(createHookListenerState(), eventName, '', 'pane-1', payload)
+  expect(parsed, `hermes plugin event ${eventName} must normalize to a status`).not.toBeNull()
+  return `\x1b]9999;${JSON.stringify(parsed)}\x07`
+}
+
+const readyPane = async () =>
+  createTranscriptPane({
+    paneTitle: 'Hermes Agent',
+    foregroundProcess: 'hermes',
+    launchAgent: 'hermes',
+    size: { cols: 120, rows: 31 },
+    data: captured
+  })
+
+describe('Hermes TUI readiness from a captured PTY', () => {
+  it('settles tui-idle on the session-boundary row a freshly launched Hermes emits', async () => {
+    const { runtime, handle } = await readyPane()
+    // What Orca's own managed plugin sends for `on_session_start`.
+    runtime.onPtyData(
+      TRANSCRIPT_PANE_PTY_ID,
+      status('on_session_start', { session_id: 's1' }),
+      Date.now()
+    )
+
+    const read = vi.spyOn(runtime, 'readTerminal')
+    await expect(
+      runtime.waitForTerminal(handle, { condition: 'tui-idle', timeoutMs: 2_000 })
+    ).resolves.toMatchObject({ satisfied: true })
+    // The boundary row is tier-1 evidence, so no pane's screen is serialized to settle it.
+    expect(read.mock.calls.filter(([, options]) => options?.screen === true)).toEqual([])
+  }, 5_000)
+
+  it('settles through a leaf handle whose retained tail never showed the ready screen', async () => {
+    const { runtime } = await readyPane()
+    // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: Access the real synced leaf and handle issuer for this route regression.
+    const internals = runtime as unknown as {
+      leaves: Map<string, { tailBuffer: string[]; tailPartialLine: string }>
+      issueHandle: (leaf: unknown) => string
+    }
+    const leaf = internals.leaves.values().next().value
+    expect(leaf).toBeDefined()
+    expect([...leaf!.tailBuffer, leaf!.tailPartialLine].join('\n')).not.toMatch(/\bready\b/i)
+    runtime.onPtyData(
+      TRANSCRIPT_PANE_PTY_ID,
+      status('on_session_start', { session_id: 's1' }),
+      Date.now()
+    )
+
+    await expect(
+      runtime.waitForTerminal(internals.issueHandle(leaf), {
+        condition: 'tui-idle',
+        timeoutMs: 2_000
+      })
+    ).resolves.toMatchObject({ satisfied: true })
+  }, 5_000)
+
+  it('does not settle while a turn the user started is still running', async () => {
+    const { runtime, handle } = await readyPane()
+    runtime.onPtyData(
+      TRANSCRIPT_PANE_PTY_ID,
+      status('on_session_start', { session_id: 's1' }),
+      Date.now()
+    )
+    // `pre_llm_call` — the first event that means a turn actually began.
+    runtime.onPtyData(
+      TRANSCRIPT_PANE_PTY_ID,
+      status('pre_llm_call', { user_message: 'hi' }),
+      Date.now()
+    )
+
+    await expect(
+      runtime.waitForTerminal(handle, { condition: 'tui-idle', timeoutMs: 550 })
+    ).rejects.toThrow('timeout')
+  }, 3_000)
+
+  it('does not settle on a turn-end done row, only on a session boundary', async () => {
+    const { runtime, handle } = await readyPane()
+    // `post_llm_call` lands `done` without the boundary flag; the #6011 rule still applies.
+    runtime.onPtyData(
+      TRANSCRIPT_PANE_PTY_ID,
+      status('post_llm_call', { session_id: 's1' }),
+      Date.now()
+    )
+
+    await expect(
+      runtime.waitForTerminal(handle, { condition: 'tui-idle', timeoutMs: 550 })
+    ).rejects.toThrow('timeout')
+  }, 3_000)
+
+  it('reports a visible blocker instead of readiness when Hermes asks for approval', async () => {
+    const { runtime, handle } = await readyPane()
+    runtime.onPtyData(
+      TRANSCRIPT_PANE_PTY_ID,
+      status('on_session_start', { session_id: 's1' }),
+      Date.now()
+    )
+    // `pre_approval_request` supersedes the boundary row the session opened with.
+    runtime.onPtyData(
+      TRANSCRIPT_PANE_PTY_ID,
+      status('pre_approval_request', { command: 'rm -rf build' }),
+      Date.now()
+    )
+
+    await expect(
+      runtime.waitForTerminal(handle, { condition: 'tui-idle', timeoutMs: 550 })
+    ).rejects.toThrow('timeout')
+  }, 3_000)
+})
diff --git a/src/main/runtime/orca-runtime-maybe-hydrate-headless-from-renderer.ts b/src/main/runtime/orca-runtime-maybe-hydrate-headless-from-renderer.ts
index 3e8d618e8a4..665a5ef2253 100644
--- a/src/main/runtime/orca-runtime-maybe-hydrate-headless-from-renderer.ts
+++ b/src/main/runtime/orca-runtime-maybe-hydrate-headless-from-renderer.ts
@@ -184,7 +184,11 @@ export class OrcaRuntimeWithMaybeHydrateHeadlessFromRenderer extends OrcaRuntime
             pty.launchAgent
           )
           if (payload) {
-            pty.lastExplicitAgentStatus = { state: payload.state, updatedAt: Date.now() }
+            pty.lastExplicitAgentStatus = {
+              state: payload.state,
+              updatedAt: Date.now(),
+              sessionBoundary: payload.sessionBoundary
+            }
             this.emitTerminalAgentStatusEvents(ptyId, {
               cleanData: '',
               payloads: [payload],
diff --git a/src/main/runtime/orca-runtime-on-pty-data.ts b/src/main/runtime/orca-runtime-on-pty-data.ts
index 52c1fb32551..c3dfd7b2cac 100644
--- a/src/main/runtime/orca-runtime-on-pty-data.ts
+++ b/src/main/runtime/orca-runtime-on-pty-data.ts
@@ -232,7 +232,8 @@ export class OrcaRuntimeWithOnPtyData extends OrcaRuntimeWithPreparePtyExecution
         if (ptyRecord) {
           ptyRecord.lastExplicitAgentStatus = {
             state: latestAgentStatus.state,
-            updatedAt: Date.now()
+            updatedAt: Date.now(),
+            sessionBoundary: latestAgentStatus.sessionBoundary
           }
         }
       }
diff --git a/src/main/runtime/runtime-terminal-state-records.ts b/src/main/runtime/runtime-terminal-state-records.ts
index d030b896da9..32ebf1a423b 100644
--- a/src/main/runtime/runtime-terminal-state-records.ts
+++ b/src/main/runtime/runtime-terminal-state-records.ts
@@ -76,7 +76,12 @@ export type RuntimePtyWorktreeRecord = RuntimeTerminalTailState & {
   /** Latest first-party state from the agent's own OSC 9999 status stream — what the
    *  agent SAYS it is doing, as opposed to `lastAgentStatus`, which is inferred from its
    *  OSC title. Optional: absent until a payload lands. */
-  lastExplicitAgentStatus?: { state: AgentStatusState; updatedAt: number } | null
+  lastExplicitAgentStatus?: {
+    state: AgentStatusState
+    updatedAt: number
+    /** A `done` row that marks a new session owning the pane, not the end of a turn. */
+    sessionBoundary?: boolean
+  } | null
   lastAgentStatusStartedAtEpochMs: number | null
   lastAgentStatusRichInvalidatedAtEpochMs: number | null
   lastOscTitle: string | null
diff --git a/src/main/runtime/tui-idle-evidence.ts b/src/main/runtime/tui-idle-evidence.ts
index 064477ae71c..3df42c82166 100644
--- a/src/main/runtime/tui-idle-evidence.ts
+++ b/src/main/runtime/tui-idle-evidence.ts
@@ -53,7 +53,11 @@ export type TuiIdleEvidenceRecord = {
   lastOscTitle?: string | null
 }
 
-export type FirstPartyAgentStatus = { state: AgentStatusState; updatedAt: number } | null
+export type FirstPartyAgentStatus = {
+  state: AgentStatusState
+  updatedAt: number
+  sessionBoundary?: boolean
+} | null
 
 /** Tier 1: an idle marker the agent put in a title itself. */
 export function hasExplicitIdleTitle(
@@ -88,13 +92,18 @@ export function hasExplicitIdleTitle(
  * Scoped rather than general: for agents whose hooks do report child turns, a `done` row
  * can arrive mid-turn, and settling on it is exactly the #6011 class this file exists to
  * prevent.
+ *
+ * The second lane is narrower and agent-agnostic: a `sessionBoundary` row does not claim a
+ * turn ended, it claims a NEW SESSION owns the pane and is waiting for its first input. That
+ * cannot arrive mid-turn by construction — the producers only set it for a startup/resume/
+ * reset boundary — so it carries no #6011 risk for any agent that emits it.
  */
 export function hasFreshDoneFirstPartyStatus(
   agent: TuiAgent | null | undefined,
   status: FirstPartyAgentStatus,
   staleAfterMs = AGENT_STATUS_STALE_AFTER_MS
 ): boolean {
-  if (agent !== 'dsh' || status?.state !== 'done') {
+  if (status?.state !== 'done' || (agent !== 'dsh' && status.sessionBoundary !== true)) {
     return false
   }
   return Date.now() - status.updatedAt <= staleAfterMs
diff --git a/src/main/window/clipboard-copied-file-paths.test.ts b/src/main/window/clipboard-copied-file-paths.test.ts
new file mode 100644
index 00000000000..2282ecfca9c
--- /dev/null
+++ b/src/main/window/clipboard-copied-file-paths.test.ts
@@ -0,0 +1,90 @@
+import { describe, expect, it } from 'vitest'
+import { readClipboardCopiedFilePaths } from './clipboard-copied-file-paths'
+
+function clipboardWith(formats: Record<string, Buffer | string>) {
+  return {
+    readBuffer: (format: string): Buffer => {
+      const value = formats[format]
+      return typeof value === 'string' ? Buffer.from(value, 'utf8') : (value ?? Buffer.alloc(0))
+    }
+  }
+}
+
+function filenamesPlist(paths: string[]): string {
+  const entries = paths.map((path) => `<string>${path}</string>`).join('')
+  return `<?xml version="1.0" encoding="UTF-8"?><plist version="1.0"><array>${entries}</array></plist>`
+}
+
+describe('readClipboardCopiedFilePaths', () => {
+  it('lists every file Finder copied, decoding XML entities', () => {
+    const clipboard = clipboardWith({
+      NSFilenamesPboardType: filenamesPlist(['/Users/me/Q&amp;A shot.png', '/Users/me/b.pdf']),
+      'public.file-url': 'file:///Users/me/Q&A%20shot.png'
+    })
+    expect(readClipboardCopiedFilePaths(clipboard, 'darwin')).toEqual([
+      '/Users/me/Q&A shot.png',
+      '/Users/me/b.pdf'
+    ])
+  })
+
+  it('falls back to the first file URL on macOS, but not a file-reference URL', () => {
+    expect(
+      readClipboardCopiedFilePaths(
+        clipboardWith({ 'public.file-url': 'file:///Users/me/my%20shot.png' }),
+        'darwin'
+      )
+    ).toEqual(['/Users/me/my shot.png'])
+    expect(
+      readClipboardCopiedFilePaths(
+        clipboardWith({ 'public.file-url': 'file:///.file/id=6571367.2773272' }),
+        'darwin'
+      )
+    ).toEqual([])
+  })
+
+  it('reads a Linux file manager uri-list and rejects non-file entries', () => {
+    expect(
+      readClipboardCopiedFilePaths(
+        clipboardWith({
+          'text/uri-list': '# copied\r\nfile:///home/me/a.png\r\nfile:///home/me/b%20c.txt\r\n'
+        }),
+        'linux'
+      )
+    ).toEqual(['/home/me/a.png', '/home/me/b c.txt'])
+    expect(
+      readClipboardCopiedFilePaths(
+        clipboardWith({ 'text/uri-list': 'file:///home/me/a.png\nhttps://example.com/x' }),
+        'linux'
+      )
+    ).toEqual([])
+  })
+
+  it('reads the single file Explorer copied and nothing when it copied several', () => {
+    const shellItems = (count: number): Buffer => {
+      const cida = Buffer.alloc(4 + 4 * (count + 1))
+      cida.writeUInt32LE(count)
+      return cida
+    }
+    const explorer = (count: number) =>
+      clipboardWith({
+        FileNameW: Buffer.from('C:\\Users\\me\\shot.png\0', 'utf16le'),
+        'Shell IDList Array': shellItems(count)
+      })
+    expect(readClipboardCopiedFilePaths(explorer(1), 'win32')).toEqual(['C:\\Users\\me\\shot.png'])
+    expect(readClipboardCopiedFilePaths(explorer(2), 'win32')).toEqual([])
+  })
+
+  it('returns nothing for plain text, oversized lists, or a failing clipboard', () => {
+    expect(readClipboardCopiedFilePaths(clipboardWith({}), 'darwin')).toEqual([])
+    const huge = filenamesPlist(['/a'.padEnd(300 * 1024, 'a')])
+    expect(
+      readClipboardCopiedFilePaths(clipboardWith({ NSFilenamesPboardType: huge }), 'darwin')
+    ).toEqual([])
+    const failing = {
+      readBuffer: (): Buffer => {
+        throw new Error('format unavailable')
+      }
+    }
+    expect(readClipboardCopiedFilePaths(failing, 'linux')).toEqual([])
+  })
+})
diff --git a/src/main/window/clipboard-copied-file-paths.ts b/src/main/window/clipboard-copied-file-paths.ts
new file mode 100644
index 00000000000..77f74e5e34c
--- /dev/null
+++ b/src/main/window/clipboard-copied-file-paths.ts
@@ -0,0 +1,89 @@
+import { fileURLToPath } from 'node:url'
+import { readWindowsCopiedFilePath } from './clipboard-windows-image-file'
+
+type ClipboardFormatReader = { readBuffer: (format: string) => Buffer }
+
+const FILE_LIST_MAX_BYTES = 256 * 1024
+const XML_ENTITIES: Record<string, string> = {
+  amp: '&',
+  apos: "'",
+  gt: '>',
+  lt: '<',
+  quot: '"'
+}
+
+function readBoundedText(clipboard: ClipboardFormatReader, format: string): string {
+  const buffer = clipboard.readBuffer(format)
+  return buffer.byteLength <= FILE_LIST_MAX_BYTES ? buffer.toString('utf8') : ''
+}
+
+function decodeXmlText(value: string): string {
+  return value.replace(
+    /&(?:#(\d+)|#x([0-9a-fA-F]+)|(amp|apos|gt|lt|quot));/g,
+    (_entity, decimal: string | undefined, hex: string | undefined, name: string | undefined) =>
+      decimal
+        ? String.fromCodePoint(Number(decimal))
+        : hex
+          ? String.fromCodePoint(Number.parseInt(hex, 16))
+          : XML_ENTITIES[name ?? '']
+  )
+}
+
+/** macOS/Linux file URLs; any other entry means this is not a file copy. */
+function filePathsFromUrls(urls: readonly string[]): string[] {
+  const paths: string[] = []
+  for (const url of urls) {
+    // Finder can hand out file-reference URLs (/.file/id=…), which name no file.
+    if (!url.startsWith('file://') || url.startsWith('file:///.file/id=')) {
+      return []
+    }
+    paths.push(fileURLToPath(url, { windows: false }))
+  }
+  return paths
+}
+
+function readMacCopiedFilePaths(clipboard: ClipboardFormatReader): string[] {
+  // Finder's legacy filenames plist lists every copied file; public.file-url holds only the first.
+  const plist = readBoundedText(clipboard, 'NSFilenamesPboardType')
+  const listed = Array.from(plist.matchAll(/<string>([^<]*)<\/string>/g), (match) =>
+    decodeXmlText(match[1])
+  )
+  if (listed.length > 0) {
+    return listed
+  }
+  const url = readBoundedText(clipboard, 'public.file-url').trim()
+  return url ? filePathsFromUrls([url]) : []
+}
+
+function readLinuxCopiedFilePaths(clipboard: ClipboardFormatReader): string[] {
+  const urls = readBoundedText(clipboard, 'text/uri-list')
+    .split(/\r\n|\r|\n/)
+    .map((line) => line.trim())
+    .filter((line) => line && !line.startsWith('#'))
+  return filePathsFromUrls(urls)
+}
+
+/**
+ * Paths of the files a file manager copied, so a paste can tell the text that
+ * labels them from prompt text. A list it cannot read in full comes back empty.
+ */
+export function readClipboardCopiedFilePaths(
+  clipboard: ClipboardFormatReader,
+  platform: NodeJS.Platform = process.platform
+): string[] {
+  try {
+    if (platform === 'darwin') {
+      return readMacCopiedFilePaths(clipboard)
+    }
+    if (platform === 'win32') {
+      const filePath = readWindowsCopiedFilePath({
+        fileNameW: clipboard.readBuffer('FileNameW'),
+        shellIdListArray: clipboard.readBuffer('Shell IDList Array')
+      })
+      return filePath ? [filePath] : []
+    }
+    return readLinuxCopiedFilePaths(clipboard)
+  } catch {
+    return []
+  }
+}
diff --git a/src/main/window/clipboard-dashboard-popout-access.test.ts b/src/main/window/clipboard-dashboard-popout-access.test.ts
index df91e29a2ed..9a9c50bd3af 100644
--- a/src/main/window/clipboard-dashboard-popout-access.test.ts
+++ b/src/main/window/clipboard-dashboard-popout-access.test.ts
@@ -106,6 +106,9 @@ describe('dashboard popout clipboard access', () => {
     await expect(handlers.get('clipboard:saveImageAsTempFile')?.(popoutEvent)).rejects.toThrow(
       'Unauthorized clipboard IPC sender'
     )
+    expect(() => handlers.get('clipboard:readFilePaths')?.(popoutEvent)).toThrow(
+      'Unauthorized clipboard IPC sender'
+    )
     expect(() =>
       handlers.get('clipboard:writeFile')?.(popoutEvent, {
         filePath: '/tmp/copied-file.txt',
diff --git a/src/main/window/clipboard-ipc-handlers.test.ts b/src/main/window/clipboard-ipc-handlers.test.ts
index ea337747421..1bcf1749c30 100644
--- a/src/main/window/clipboard-ipc-handlers.test.ts
+++ b/src/main/window/clipboard-ipc-handlers.test.ts
@@ -26,6 +26,7 @@ const {
   clipboardReadBufferMock,
   clipboardWriteTextMock,
   clipboardReadImageMock,
+  clipboardAvailableFormatsMock,
   clipboardWriteImageMock,
   clipboardWriteBufferMock,
   nativeImageCreateFromBufferMock,
@@ -62,6 +63,7 @@ const {
   clipboardReadBufferMock: vi.fn(),
   clipboardWriteTextMock: vi.fn(),
   clipboardReadImageMock: vi.fn(),
+  clipboardAvailableFormatsMock: vi.fn(),
   clipboardWriteImageMock: vi.fn(),
   clipboardWriteBufferMock: vi.fn(),
   nativeImageCreateFromBufferMock: vi.fn(),
@@ -109,6 +111,7 @@ vi.mock('electron', () => ({
     readBuffer: clipboardReadBufferMock,
     writeText: clipboardWriteTextMock,
     readImage: clipboardReadImageMock,
+    availableFormats: clipboardAvailableFormatsMock,
     writeImage: clipboardWriteImageMock,
     writeBuffer: clipboardWriteBufferMock
   },
@@ -552,6 +555,8 @@ describe('registerClipboardHandlers', () => {
     expect(removeHandlerMock).toHaveBeenCalledWith('clipboard:writeFile')
     expect(removeHandlerMock).toHaveBeenCalledWith('clipboard:saveImageAsTempFile')
     expect(removeHandlerMock).toHaveBeenCalledWith('clipboard:readImageThumbnail')
+    expect(removeHandlerMock).toHaveBeenCalledWith('clipboard:hasImage')
+    expect(removeHandlerMock).toHaveBeenCalledWith('clipboard:readFilePaths')
   })
 
   it('does not inspect FileNameW when an empty image clipboard is read outside Windows', async () => {
@@ -874,4 +879,18 @@ describe('registerClipboardHandlers', () => {
     expect(nativeImageCreateFromBufferMock).toHaveBeenCalled()
     expect(clipboardWriteImageMock).not.toHaveBeenCalled()
   })
+
+  it.each([
+    [['text/plain'], false],
+    [['text/plain', 'image/png'], true]
+  ])('reports image presence for %j from the format list without decoding', (formats, expected) => {
+    setTrustedClipboardRendererWebContentsId(17)
+    clipboardAvailableFormatsMock.mockReturnValue(formats)
+    // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: registering handlers never reads the store for clipboard image presence.
+    registerClipboardHandlers({} as never)
+    const probe = getRegisteredHandlers().get('clipboard:hasImage')
+    expect(probe?.(makeClipboardEvent())).toBe(expected)
+    expect(clipboardReadImageMock).not.toHaveBeenCalled()
+    expect(() => probe?.(makeClipboardEvent({ id: 42 }))).toThrow()
+  })
 })
diff --git a/src/main/window/clipboard-ipc-handlers.ts b/src/main/window/clipboard-ipc-handlers.ts
index f6a688ea3d3..e81140d734a 100644
--- a/src/main/window/clipboard-ipc-handlers.ts
+++ b/src/main/window/clipboard-ipc-handlers.ts
@@ -24,6 +24,7 @@ import {
   assertClipboardImageBase64LengthWithinLimit,
   assertClipboardImageByteLengthWithinLimit,
   assertClipboardImageDimensionsWithinLimit,
+  clipboardFormatsIncludeImage,
   type ClipboardImageThumbnail
 } from '../../shared/clipboard-image'
 import {
@@ -38,6 +39,7 @@ import {
 } from './clipboard-remote-file-copy'
 import { saveClipboardImageBufferInRuntime } from './clipboard-runtime-image-upload'
 import { readWindowsClipboardImageFileAsPng } from './clipboard-windows-image-file'
+import { readClipboardCopiedFilePaths } from './clipboard-copied-file-paths'
 import { buildClipboardImageThumbnail } from './clipboard-image-thumbnail'
 import { writeClipboardTextAndVerify } from './clipboard-text-write-verify'
 import { isDashboardPopoutRenderer } from './dashboard-popout-window'
@@ -96,6 +98,8 @@ export function registerClipboardHandlers(store: Store): void {
   ipcMain.removeHandler('clipboard:writeFile')
   ipcMain.removeHandler('clipboard:saveImageAsTempFile')
   ipcMain.removeHandler('clipboard:readImageThumbnail')
+  ipcMain.removeHandler('clipboard:hasImage')
+  ipcMain.removeHandler('clipboard:readFilePaths')
 
   void cleanupExpiredRemoteClipboardFiles()
   scheduleLegacyRemoteClipboardFileCleanup()
@@ -117,6 +121,15 @@ export function registerClipboardHandlers(store: Store): void {
     assertTrustedClipboardSender(event)
     return buildClipboardImageThumbnail(clipboard.readImage())
   })
+  ipcMain.handle('clipboard:hasImage', (event): boolean => {
+    assertTrustedClipboardSender(event)
+    return clipboardFormatsIncludeImage(clipboard.availableFormats())
+  })
+  // Why: a file-manager copy also carries the files' names as text, which a paste must not type.
+  ipcMain.handle('clipboard:readFilePaths', (event): string[] => {
+    assertTrustedClipboardSender(event)
+    return readClipboardCopiedFilePaths(clipboard)
+  })
   // Why: terminals need to detect clipboard images to support tools like Claude
   // Code that accept image input via paste. Writes the clipboard image to a
   // temp file and returns the path, or null if the clipboard has no image.
diff --git a/src/main/window/clipboard-windows-image-file.ts b/src/main/window/clipboard-windows-image-file.ts
index 3c26bb70c4f..39099332958 100644
--- a/src/main/window/clipboard-windows-image-file.ts
+++ b/src/main/window/clipboard-windows-image-file.ts
@@ -13,7 +13,7 @@ type WindowsClipboardImageFileDeps = {
   openFile: (filePath: string) => Promise<ClipboardImageFileHandle>
 }
 
-type WindowsClipboardImageFileFormats = {
+export type WindowsClipboardFileFormats = {
   fileNameW: Buffer
   shellIdListArray: Buffer
 }
@@ -65,7 +65,7 @@ function decodeFileNameW(value: Buffer): string | null {
   if (!filePath || filePath.includes('\0') || !isFullyQualifiedWindowsPath(filePath)) {
     return null
   }
-  return IMAGE_FILE_EXTENSION_SET.has(win32.extname(filePath).toLowerCase()) ? filePath : null
+  return filePath
 }
 
 function hasAtMostOneShellItem(value: Buffer): boolean {
@@ -76,6 +76,14 @@ function hasAtMostOneShellItem(value: Buffer): boolean {
   return value.byteLength >= 12 && value.readUInt32LE(0) === 1
 }
 
+/** The one file Explorer copied; null when it copied none or several. */
+export function readWindowsCopiedFilePath({
+  fileNameW,
+  shellIdListArray
+}: WindowsClipboardFileFormats): string | null {
+  return hasAtMostOneShellItem(shellIdListArray) ? decodeFileNameW(fileNameW) : null
+}
+
 function readPngDimensions(source: Buffer): { height: number; width: number } | null {
   if (
     source.byteLength < 24 ||
@@ -153,14 +161,11 @@ async function readStableFile(
 }
 
 export async function readWindowsClipboardImageFileAsPng(
-  { fileNameW, shellIdListArray }: WindowsClipboardImageFileFormats,
+  formats: WindowsClipboardFileFormats,
   { createImageFromBuffer, openFile }: WindowsClipboardImageFileDeps
 ): Promise<Buffer | null> {
-  if (!hasAtMostOneShellItem(shellIdListArray)) {
-    return null
-  }
-  const filePath = decodeFileNameW(fileNameW)
-  if (!filePath) {
+  const filePath = readWindowsCopiedFilePath(formats)
+  if (!filePath || !IMAGE_FILE_EXTENSION_SET.has(win32.extname(filePath).toLowerCase())) {
     return null
   }
 
diff --git a/src/preload/api/ui-bridge-clipboard-and-window-controls.ts b/src/preload/api/ui-bridge-clipboard-and-window-controls.ts
index 80f2c2dd383..456adfef27a 100644
--- a/src/preload/api/ui-bridge-clipboard-and-window-controls.ts
+++ b/src/preload/api/ui-bridge-clipboard-and-window-controls.ts
@@ -91,6 +91,8 @@ export const uiClipboardAndWindowControlsApi = {
     connectionId?: string | null
     runtimeEnvironmentId?: string | null
   }): Promise<string | null> => ipcRenderer.invoke('clipboard:saveImageAsTempFile', args),
+  clipboardHasImage: (): Promise<boolean> => ipcRenderer.invoke('clipboard:hasImage'),
+  readClipboardFilePaths: (): Promise<string[]> => ipcRenderer.invoke('clipboard:readFilePaths'),
   readClipboardImageThumbnail: (): Promise<ClipboardImageThumbnail | null> =>
     ipcRenderer.invoke('clipboard:readImageThumbnail'),
   writeClipboardText: (text: string): Promise<void> =>
diff --git a/src/preload/api/ui-window-api.ts b/src/preload/api/ui-window-api.ts
index b0fa905efa7..c36896a2481 100644
--- a/src/preload/api/ui-window-api.ts
+++ b/src/preload/api/ui-window-api.ts
@@ -13,6 +13,9 @@ export type UiWindowApi = {
     connectionId?: string | null
     runtimeEnvironmentId?: string | null
   }) => Promise<string | null>
+  clipboardHasImage: () => Promise<boolean | null>
+  /** Paths of files a file manager copied; empty when there are none or the host cannot list them. */
+  readClipboardFilePaths: () => Promise<string[]>
   readClipboardImageThumbnail: () => Promise<ClipboardImageThumbnail | null>
   writeClipboardText: (text: string) => Promise<void>
   writeTerminalClipboardText: (text: string) => Promise<void>
diff --git a/src/renderer/src/components/browser-pane/host-guest/browser-guest-page-id-identity.test.ts b/src/renderer/src/components/browser-pane/host-guest/browser-guest-page-id-identity.test.ts
index 386be8b8220..f66096f5345 100644
--- a/src/renderer/src/components/browser-pane/host-guest/browser-guest-page-id-identity.test.ts
+++ b/src/renderer/src/components/browser-pane/host-guest/browser-guest-page-id-identity.test.ts
@@ -11,20 +11,4 @@ describe('collectBrowserPageIds identity', () => {
     expect(collectBrowserPageIds([])).toBe(fromUndefined)
     expect(fromUndefined).toEqual([])
   })
-
-  it('still collects page ids, preferring pageIds over the active page', () => {
-    const ids = collectBrowserPageIds([
-      { id: 'tab-1', pageIds: ['page-a', 'page-b'] },
-      { id: 'tab-2', activePageId: 'page-c' },
-      { id: 'tab-3' }
-    ])
-
-    expect(ids).toEqual(['page-a', 'page-b', 'page-c', 'tab-3'])
-  })
-
-  it('falls back to the active page when pageIds is present but empty', () => {
-    expect(collectBrowserPageIds([{ id: 'tab-1', pageIds: [], activePageId: 'page-a' }])).toEqual([
-      'page-a'
-    ])
-  })
 })
diff --git a/src/renderer/src/components/browser-pane/host-guest/browser-keyboard.test.ts b/src/renderer/src/components/browser-pane/host-guest/browser-keyboard.test.ts
index 1719d82f244..5aee1227bc0 100644
--- a/src/renderer/src/components/browser-pane/host-guest/browser-keyboard.test.ts
+++ b/src/renderer/src/components/browser-pane/host-guest/browser-keyboard.test.ts
@@ -1,6 +1,6 @@
 // @vitest-environment happy-dom
 
-import { afterEach, describe, expect, it, vi } from 'vitest'
+import { afterEach, describe, expect, it } from 'vitest'
 import { isEditableKeyboardTarget } from './browser-keyboard'
 
 // Why: the old fakes passed a single joined selector to `closest`, so any
@@ -35,25 +35,6 @@ describe('isEditableKeyboardTarget', () => {
     expect(isEditableKeyboardTarget(targetInside(html))).toBe(true)
   })
 
-  it('queries every editable host in one selector', () => {
-    const closest = vi.fn((_selector: string) => null)
-    isEditableKeyboardTarget({ isContentEditable: false, closest })
-
-    const selector = closest.mock.calls[0][0]
-    const tokens = selector.split(',').map((part) => part.trim())
-    expect(tokens).toEqual([
-      'input',
-      'textarea',
-      'select',
-      '[contenteditable=""]',
-      '[contenteditable="true"]',
-      '.monaco-editor',
-      '.diff-editor',
-      '.rich-markdown-editor',
-      '.rich-markdown-editor-shell'
-    ])
-  })
-
   it('falls back to isContentEditable when no host selector matches', () => {
     expect(isEditableKeyboardTarget({ isContentEditable: true, closest: () => null })).toBe(true)
   })
diff --git a/src/renderer/src/components/browser-pane/stream-remote/remote-browser-frame-style.test.ts b/src/renderer/src/components/browser-pane/stream-remote/remote-browser-frame-style.test.ts
index ad4b00739f0..e348439cb3c 100644
--- a/src/renderer/src/components/browser-pane/stream-remote/remote-browser-frame-style.test.ts
+++ b/src/renderer/src/components/browser-pane/stream-remote/remote-browser-frame-style.test.ts
@@ -17,68 +17,4 @@ describe('getRemoteBrowserFrameStyle', () => {
       objectPosition: 'top left'
     })
   })
-
-  it('keeps correctly sized frames filling the viewport', () => {
-    expect(
-      getRemoteBrowserFrameStyle({
-        imageWidth: 958,
-        imageHeight: 609,
-        deviceWidth: 958,
-        deviceHeight: 609
-      })
-    ).toEqual({
-      width: '100%',
-      height: '100%',
-      objectFit: 'fill',
-      objectPosition: 'top left'
-    })
-  })
-
-  it('does not crop high-DPI frames with a uniform device scale', () => {
-    expect(
-      getRemoteBrowserFrameStyle({
-        imageWidth: 1998,
-        imageHeight: 1218,
-        deviceWidth: 999,
-        deviceHeight: 609
-      })
-    ).toEqual({
-      width: '100%',
-      height: '100%',
-      objectFit: 'fill',
-      objectPosition: 'top left'
-    })
-  })
-
-  it('does not crop slightly uneven high-DPI frames after navigation', () => {
-    expect(
-      getRemoteBrowserFrameStyle({
-        imageWidth: 3278,
-        imageHeight: 2070,
-        deviceWidth: 999,
-        deviceHeight: 609
-      })
-    ).toEqual({
-      width: '100%',
-      height: '100%',
-      objectFit: 'fill',
-      objectPosition: 'top left'
-    })
-  })
-
-  it('does not shrink malformed frame metadata below the viewport', () => {
-    expect(
-      getRemoteBrowserFrameStyle({
-        imageWidth: 10,
-        imageHeight: 10,
-        deviceWidth: 958,
-        deviceHeight: 609
-      })
-    ).toEqual({
-      width: '100%',
-      height: '100%',
-      objectFit: 'fill',
-      objectPosition: 'top left'
-    })
-  })
 })
diff --git a/src/renderer/src/components/editor/markdown-dirty-state.test.ts b/src/renderer/src/components/editor/markdown-dirty-state.test.ts
index c423cbedf82..b2180dcf70f 100644
--- a/src/renderer/src/components/editor/markdown-dirty-state.test.ts
+++ b/src/renderer/src/components/editor/markdown-dirty-state.test.ts
@@ -34,20 +34,6 @@ function trimEnd(s: string): string {
   return s.trimEnd()
 }
 
-function shouldSyncPropIntoEditor(
-  currentMarkdown: string,
-  propContent: string,
-  lastCommittedMarkdown: string
-): boolean {
-  if (propContent === lastCommittedMarkdown) {
-    return false
-  }
-  if (currentMarkdown === propContent) {
-    return false
-  }
-  return true
-}
-
 /**
  * Simulates the onCreate flow: empty-list repair then getMarkdown().
  */
@@ -134,27 +120,6 @@ describe('document soft-break round-trip', () => {
   })
 })
 
-// -----------------------------------------------------------------------
-// 3. Rich editor content sync must ignore its own mount-time round-trip
-//    differences, but still accept genuine external file changes.
-// -----------------------------------------------------------------------
-describe('content sync gating', () => {
-  it('does not re-sync on mount when only the normalized markdown differs', () => {
-    const disk = 'Line one\nLine two'
-    const normalizedMarkdown = simulateOnCreate(disk)
-
-    expect(shouldSyncPropIntoEditor(normalizedMarkdown, disk, disk)).toBe(false)
-  })
-
-  it('does re-sync when disk content actually changes externally', () => {
-    const oldDisk = 'Line one\nLine two'
-    const newDisk = 'Line one\nLine two\nLine three'
-    const normalizedCurrentMarkdown = simulateOnCreate(oldDisk)
-
-    expect(shouldSyncPropIntoEditor(normalizedCurrentMarkdown, newDisk, oldDisk)).toBe(true)
-  })
-})
-
 // -----------------------------------------------------------------------
 // 4. Actual user edits must still be detected as dirty.
 // -----------------------------------------------------------------------
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 a9618baedf1..ae7cc67d06b 100644
--- a/src/renderer/src/components/editor/monaco-programmatic-sync.test.ts
+++ b/src/renderer/src/components/editor/monaco-programmatic-sync.test.ts
@@ -44,13 +44,4 @@ describe('shouldIgnoreMonacoContentChange', () => {
       })
     ).toBe(false)
   })
-
-  it('does not ignore a user edit that happens to match the saved prop content', () => {
-    expect(
-      shouldIgnoreMonacoContentChange({
-        filePath: '/repo/seed.spec.ts',
-        isApplyingProgrammaticContent: false
-      })
-    ).toBe(false)
-  })
 })
diff --git a/src/renderer/src/components/editor/useEditorPanelFileLoadRetry.test.tsx b/src/renderer/src/components/editor/useEditorPanelFileLoadRetry.test.tsx
index 59a586e9ce8..5c608537303 100644
--- a/src/renderer/src/components/editor/useEditorPanelFileLoadRetry.test.tsx
+++ b/src/renderer/src/components/editor/useEditorPanelFileLoadRetry.test.tsx
@@ -169,7 +169,7 @@ describe('useEditorPanelFileLoadRetry — owner-not-ready bounding (#6648)', ()
     expect(attemptsRef.current[file.id]).toBe(1)
   })
 
-  it('stops after the budget and shows a truthful terminal message, then Retry re-arms', () => {
+  it('stops after the budget and shows a truthful terminal message', () => {
     const file = makeFile()
     const attemptsRef = { current: {} as Record<string, number> }
     // The owner never hydrates: every retry re-fails with owner-not-ready.
@@ -227,10 +227,6 @@ describe('useEditorPanelFileLoadRetry — owner-not-ready bounding (#6648)', ()
       )
     })
     expect(loadFileContent.mock.calls.length).toBe(callsAfterTerminal)
-
-    // Retry (reloadContent) clears the attempt budget for a fresh start.
-    delete attemptsRef.current[file.id]
-    expect(attemptsRef.current[file.id]).toBeUndefined()
   })
 
   it('stops immediately once the read succeeds (no terminal message)', () => {
diff --git a/src/renderer/src/components/native-chat/NativeChatComposer.tsx b/src/renderer/src/components/native-chat/NativeChatComposer.tsx
index f6120d50861..d9fb9f1ec2d 100644
--- a/src/renderer/src/components/native-chat/NativeChatComposer.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatComposer.tsx
@@ -1,5 +1,5 @@
 import type { NativeChatComposerInput } from './native-chat-composer-input'
-import { forwardRef, useCallback, useImperativeHandle, useState } from 'react'
+import { forwardRef, useCallback, useState } from 'react'
 import { useAppStore } from '../../store'
 import { useNativeChatComposerInterrupt } from './use-native-chat-composer-interrupt'
 import { useNativeChatContextUsageSummary } from './use-native-chat-context-usage-summary'
@@ -14,7 +14,7 @@ import { useNativeChatLaunchDraftAdoption } from './use-native-chat-launch-draft
 import { NativeChatComposerField } from './NativeChatComposerField'
 import type { NativeChatResolvedTarget } from './native-chat-composer-target'
 import { useNativeChatComposerAttachments } from './use-native-chat-composer-attachments'
-import { useNativeChatComposerPaste } from './use-native-chat-composer-paste'
+import { useNativeChatComposerHandle } from './use-native-chat-composer-handle'
 import { useNativeChatExternalAttachments } from './use-native-chat-external-attachments'
 import { useNativeChatComposerKeyDown } from './use-native-chat-composer-keydown'
 import { useNativeChatSendLifecycle } from './use-native-chat-send-lifecycle'
@@ -25,7 +25,6 @@ import { useNativeChatSessionOptionCommand } from './use-native-chat-session-opt
 import { useNativeChatComposerCatalog } from './use-native-chat-composer-catalog'
 import { useNativeChatPickerState } from './use-native-chat-picker-state'
 import { useNativeChatPickerCommandDispatch } from './use-native-chat-picker-command-dispatch'
-import { useNativeChatTypedInsertion } from './use-native-chat-typed-insertion'
 import type {
   NativeChatComposerHandle,
   NativeChatComposerProps
@@ -61,6 +60,7 @@ const NativeChatComposerPane = forwardRef<NativeChatComposerHandle, NativeChatCo
       isWorking = false,
       onStop,
       onOptimisticSend,
+      optimisticSendOutcome,
       onOptimisticSendCanceled,
       onSlashCommand,
       onSwitchToTerminal,
@@ -189,16 +189,6 @@ const NativeChatComposerPane = forwardRef<NativeChatComposerHandle, NativeChatCo
       ? !hasPty || !onStop
       : disabled || hasPendingAttachment || (draft.trim() === '' && imageAttachments.length === 0)
 
-    const { insertTypedText, focus } = useNativeChatTypedInsertion({
-      textareaRef,
-      caret,
-      draft,
-      setDraft,
-      setCaret,
-      setHistory,
-      setActiveSuggestion
-    })
-
     const { attachExternalPaths, resolveAttachmentOwner } = useNativeChatExternalAttachments({
       terminalTabId,
       structuredWorktreeId: structuredTransport?.worktreeId,
@@ -207,26 +197,31 @@ const NativeChatComposerPane = forwardRef<NativeChatComposerHandle, NativeChatCo
       setNotice
     })
 
-    const { handlePaste, pasteFromClipboard } = useNativeChatComposerPaste({
+    const handlePasteEvent = useNativeChatComposerHandle(ref, {
+      textareaRef,
+      caret,
+      draft,
+      setDraft,
+      setCaret,
+      setHistory,
+      setActiveSuggestion,
+      targetKey: JSON.stringify([
+        paneKey,
+        targetPtyId,
+        structuredTransport?.sessionId,
+        structuredTransport?.worktreeId,
+        structuredTransport?.runtimeEnvironmentId
+      ]),
       agent,
       disabled,
-      caret,
       resolveAttachmentOwner,
       attachResolvedPaths,
       beginPendingImageAttachment,
       resolvePendingImageAttachment,
       dropPendingImageAttachment,
-      insertTypedText,
-      setCaret,
       setNotice
     })
 
-    useImperativeHandle(
-      ref,
-      () => ({ focus, insertTypedText, handlePasteEvent: handlePaste, pasteFromClipboard }),
-      [focus, insertTypedText, handlePaste, pasteFromClipboard]
-    )
-
     const { pickAttachment } = useNativeChatFileAttachmentActions(paneKey, attachExternalPaths)
     const { toggleDictation, startHoldDictation, stopHoldDictation } =
       useNativeChatDictationActions({ textareaRef, setDictationPressed })
@@ -277,6 +272,7 @@ const NativeChatComposerPane = forwardRef<NativeChatComposerHandle, NativeChatCo
       resolveTarget,
       classifySend,
       onOptimisticSend,
+      optimisticSendOutcome,
       onSlashCommand,
       sessionOptionsSurface: ptySessionOptionsSurface,
       terminalTabId,
@@ -395,7 +391,7 @@ const NativeChatComposerPane = forwardRef<NativeChatComposerHandle, NativeChatCo
           flushDraftAppends()
           attachments.flushPendingAttachments()
         }}
-        onPaste={handlePaste}
+        onPaste={handlePasteEvent}
         pickerListboxId={picker.listboxId}
         onChoosePickerItem={goalMode.interceptPick(completeItem)}
         goalMode={goalMode}
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageRow.tsx b/src/renderer/src/components/native-chat/NativeChatMessageRow.tsx
index 9275552605d..234934664f4 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageRow.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageRow.tsx
@@ -30,7 +30,11 @@ 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 }
+export type NativeChatDeliveryNotice = {
+  text: string
+  onRetry?: () => void
+  onDismiss?: () => void
+}
 
 /** One message: its prose first, then a collapsible run folding all of the
  *  turn's tool activity. Monochrome per STYLEGUIDE: user prompts read as a
@@ -185,6 +189,11 @@ export const MessageRow = memo(function MessageRow({
         {deliveryNotice ? (
           <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 ? (
+              <Button type="button" variant="ghost" size="xs" onClick={deliveryNotice.onDismiss}>
+                {translate('components.native-chat.dismissDeliveryNotice', 'Dismiss')}
+              </Button>
+            ) : null}
             {deliveryNotice.onRetry ? (
               <Button type="button" variant="ghost" size="xs" onClick={deliveryNotice.onRetry}>
                 <RotateCcw className="size-3" />
diff --git a/src/renderer/src/components/native-chat/NativeChatPromptEditor.test.tsx b/src/renderer/src/components/native-chat/NativeChatPromptEditor.test.tsx
index bb5e1d9ede6..652086366c0 100644
--- a/src/renderer/src/components/native-chat/NativeChatPromptEditor.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatPromptEditor.test.tsx
@@ -4,7 +4,10 @@ import { createRef } from 'react'
 import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import { NativeChatPromptEditor } from './NativeChatPromptEditor'
-import type { NativeChatComposerInput } from './native-chat-composer-input'
+import {
+  insertNativeChatPastedText,
+  type NativeChatComposerInput
+} from './native-chat-composer-input'
 import { promptEditor } from './native-chat-prompt-editor.test-support'
 
 afterEach(cleanup)
@@ -143,3 +146,28 @@ describe('native chat skill editor', () => {
     expect(container.querySelector('[data-native-chat-skill]')).toBeNull()
   })
 })
+
+it('replaces the selection with literal pasted text as one undoable edit', async () => {
+  const { input, editor } = setup('hello world')
+  act(() => input.setSelectionRange(6, 11))
+  await act(async () => input.insertText?.('안녕\n$literal'))
+  expect(input.value).toBe('hello 안녕\n$literal')
+  await act(async () => {
+    editor.commands.undo()
+  })
+  expect(input.value).toBe('hello world')
+})
+
+it('moves focus into the composer when a paste is routed from elsewhere', async () => {
+  const { input, editor } = setup('hi')
+  act(() => input.setSelectionRange(2, 2))
+  const hiddenTerminal = document.createElement('textarea')
+  document.body.append(hiddenTerminal)
+  hiddenTerminal.focus()
+  await act(async () => {
+    insertNativeChatPastedText(input, ' there')
+  })
+  expect(input.value).toBe('hi there')
+  expect(editor.view.dom.contains(document.activeElement)).toBe(true)
+  hiddenTerminal.remove()
+})
diff --git a/src/renderer/src/components/native-chat/NativeChatPromptEditor.tsx b/src/renderer/src/components/native-chat/NativeChatPromptEditor.tsx
index efe0bf5de93..ceb812e6291 100644
--- a/src/renderer/src/components/native-chat/NativeChatPromptEditor.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatPromptEditor.tsx
@@ -134,6 +134,12 @@ export function NativeChatPromptEditor({
     () =>
       editor
         ? {
+            insertText: (text) => {
+              const content = editor.schema.nodeFromJSON(promptTextContent(text))
+              editor.view.dispatch(
+                editor.state.tr.replaceSelection(new Slice(content.content, 1, 1))
+              )
+            },
             get value() {
               return promptTextMap(editor.state.doc).text
             },
diff --git a/src/renderer/src/components/native-chat/NativeChatResolvedView.tsx b/src/renderer/src/components/native-chat/NativeChatResolvedView.tsx
index 786ade25ebc..7c9c3f8337e 100644
--- a/src/renderer/src/components/native-chat/NativeChatResolvedView.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatResolvedView.tsx
@@ -18,16 +18,11 @@ import { shouldClearNativeChatWorkingSuppression } from './native-chat-working-s
 import { resolveNativeChatTerminalTurn } from './native-chat-terminal-turn'
 import { useNativeChatTerminalTurnTiming } from './use-native-chat-terminal-turn-timing'
 import {
-  appendPendingSendCache,
   launchPromptAsMessage,
   pendingSendsAsMessages,
-  nextNativeChatPendingSendId,
-  prunePendingSends,
-  readPendingSendCache,
-  shouldPruneLaunchPrompt,
-  writePendingSendCache,
-  type NativeChatPendingSend
+  shouldPruneLaunchPrompt
 } from './native-chat-pending'
+import { useNativeChatPendingDelivery } from './use-native-chat-pending-delivery'
 import {
   appendCommandMarkerCache,
   applyCommandMarkerBoundaries,
@@ -39,11 +34,8 @@ import {
   deriveNativeChatStreamingText,
   nativeChatStreamingMessage
 } from '../../../../shared/native-chat-streaming'
-import {
-  shouldFocusNativeChatComposerFromEditingKey,
-  shouldFocusNativeChatPaneFromPointerTarget,
-  shouldRedirectNativeChatTyping
-} from './native-chat-typing-redirect'
+import { shouldFocusNativeChatPaneFromPointerTarget } from './native-chat-typing-redirect'
+import { routeNativeChatRootKeyToInput } from './native-chat-root-key-routing'
 import {
   emptyNativeChatContextMenuActions,
   useNativeChatContextMenu
@@ -161,35 +153,19 @@ export function NativeChatResolvedView({
     () => ({ paneKey, agent, sessionId }),
     [paneKey, agent, sessionId]
   )
-  const pendingScope = useMemo(() => ({ paneKey, agent }), [paneKey, agent])
-  const [pending, setPending] = useState<NativeChatPendingSend[]>(() =>
-    readPendingSendCache(pendingScope)
-  )
+  const delivery = useNativeChatPendingDelivery({ paneKey, agent, messages: session.messages })
+  const { pending, record, clear } = delivery
   // Slash commands aren't chat turns, so they get a small local "Ran /clear"
   // system line instead of a user bubble. Capped + cached per conversation.
   const [commandMarkers, setCommandMarkers] = useState<NativeChatCommandMarker[]>(() =>
     readCommandMarkerCache(commandMarkerScope)
   )
-  // Reset the optimistic queue only when the pane/agent changes. A fresh launch
-  // often learns its provider session id after the first send; clearing pending
-  // on that transition briefly flashes the empty state before the transcript
-  // user turn lands.
-  useEffect(() => {
-    setPending(readPendingSendCache(pendingScope))
-    setWorkingInterrupted(false)
-  }, [pendingScope])
   // Command markers are session-scoped because slash commands like /clear are
   // local feedback for a specific transcript boundary.
   useEffect(() => {
     setCommandMarkers(readCommandMarkerCache(commandMarkerScope))
     setWorkingInterrupted(false)
   }, [commandMarkerScope])
-  // Prune echoes whose real user turn is now in the transcript.
-  useEffect(() => {
-    setPending((prev) =>
-      writePendingSendCache(pendingScope, prunePendingSends(prev, session.messages))
-    )
-  }, [session.messages, pendingScope])
   useEffect(() => {
     if (!paneLaunchPrompt || !shouldPruneLaunchPrompt(paneLaunchPrompt, session.messages)) {
       return
@@ -199,29 +175,9 @@ export function NativeChatResolvedView({
   const onOptimisticSend = useCallback(
     (text: string, imagePaths?: string[]) => {
       setWorkingInterrupted(false)
-      const sentAt = Date.now()
-      const boundary = session.messages.at(-1)
-      const entry: NativeChatPendingSend = {
-        id: nextNativeChatPendingSendId(sentAt),
-        text,
-        sentAt,
-        afterMessageId: boundary?.id ?? null,
-        afterMessageTimestamp: boundary?.timestamp ?? null,
-        ...(imagePaths ? { imagePaths } : {})
-      }
-      setPending(appendPendingSendCache(pendingScope, entry))
-      return entry.id
+      return record(text, imagePaths)
     },
-    [pendingScope, session.messages]
-  )
-  const onOptimisticSendCanceled = useCallback(
-    (pendingId: string) => {
-      // Why: detach/interrupt cancels the delayed Enter, so its optimistic echo
-      // must not come back from the pane cache as a prompt that was delivered.
-      const next = readPendingSendCache(pendingScope).filter((entry) => entry.id !== pendingId)
-      setPending(writePendingSendCache(pendingScope, next))
-    },
-    [pendingScope]
+    [record]
   )
   const onSlashCommand = useCallback(
     (command: string) => {
@@ -251,6 +207,14 @@ export function NativeChatResolvedView({
     paneLaunchPrompt?.failed ? launchPromptMessage?.id : null,
     sessionAfterCommandBoundaries.messages
   )
+  // Why memoized: a fresh map each render would re-render every memoized transcript row.
+  const deliveryNotices = useMemo(
+    () =>
+      delivery.notices.size === 0
+        ? launchPromptDeliveryNotices
+        : new Map([...(launchPromptDeliveryNotices ?? []), ...delivery.notices]),
+    [launchPromptDeliveryNotices, delivery.notices]
+  )
   const promptCard = useNativeChatInteractivePromptCard({
     paneKey,
     messages: sessionAfterCommandBoundaries.messages,
@@ -332,9 +296,9 @@ export function NativeChatResolvedView({
     // Why: Stop after a submitted turn drops the delayed-write handle once it
     // settles, so cancelPendingSends no longer sees the optimistic id. Clear
     // the echo cache here so a cancelled prompt cannot stick as a ghost bubble.
-    setPending(writePendingSendCache(pendingScope, []))
+    clear()
     interactiveSend.cancel()
-  }, [interactiveSend, pendingScope])
+  }, [interactiveSend, clear])
   const { onLinkClick, linkActionRequest, closeLinkActions } = useNativeChatLinkActions(
     fileLinkContext,
     rootRef,
@@ -376,20 +340,7 @@ export function NativeChatResolvedView({
           }
           return
         }
-        // Backspace/Delete outside an input focuses the composer (like typing)
-        // but inserts nothing — let the now-focused field handle the keystroke.
-        if (shouldFocusNativeChatComposerFromEditingKey(event)) {
-          composerRef.current?.focus()
-          return
-        }
-        if (!shouldRedirectNativeChatTyping(event)) {
-          return
-        }
-        if (!composerRef.current?.insertTypedText(event.key)) {
-          return
-        }
-        event.preventDefault()
-        event.stopPropagation()
+        routeNativeChatRootKeyToInput(event, composerRef.current, questionAnswerInputRef.current)
       }}
       onMouseUpCapture={contextMenu.onSelectionCapture}
       onKeyUpCapture={contextMenu.onSelectionCapture}
@@ -414,7 +365,7 @@ export function NativeChatResolvedView({
             awaitingInput={awaitingInput}
             onLinkClick={onLinkClick}
             allowFileUriLinks={fileLinkContext !== null}
-            deliveryNotices={launchPromptDeliveryNotices}
+            deliveryNotices={deliveryNotices}
           />
         )}
       </div>
@@ -442,7 +393,8 @@ export function NativeChatResolvedView({
           isWorking={isWorking}
           onStop={stopAgent}
           onOptimisticSend={onOptimisticSend}
-          onOptimisticSendCanceled={onOptimisticSendCanceled}
+          onOptimisticSendCanceled={delivery.cancel}
+          optimisticSendOutcome={delivery}
           onSlashCommand={onSlashCommand}
           onSwitchToTerminal={onSwitchToTerminal}
           readTerminalScreen={readTerminalScreen}
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 29dd7f4bdf0..dd43358c30d 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.test-harness.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.test-harness.tsx
@@ -268,7 +268,8 @@ export function createStructuredSessionMocks() {
           },
           insertTypedText: () => true,
           handlePasteEvent: mocks.handlePasteEvent,
-          pasteFromClipboard: mocks.pasteFromClipboard
+          pasteFromClipboard: mocks.pasteFromClipboard,
+          contains: (node: Node | null) => fieldRef.current?.contains(node) === true
         }))
         return <textarea ref={fieldRef} data-testid="structured-composer" />
       })
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSessionDelivery.test.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSessionDelivery.test.tsx
index 3f778fbd8ce..d20dda5a169 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSessionDelivery.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSessionDelivery.test.tsx
@@ -167,7 +167,8 @@ vi.mock('./NativeChatComposer', () => ({
       },
       insertTypedText: () => true,
       handlePasteEvent: mocks.handlePasteEvent,
-      pasteFromClipboard: mocks.pasteFromClipboard
+      pasteFromClipboard: mocks.pasteFromClipboard,
+      contains: (node: Node | null) => fieldRef.current?.contains(node) === true
     }))
     return <textarea ref={fieldRef} data-testid="structured-composer" />
   })
diff --git a/src/renderer/src/components/native-chat/native-chat-clipboard-payload.ts b/src/renderer/src/components/native-chat/native-chat-clipboard-payload.ts
new file mode 100644
index 00000000000..6c3ed75c377
--- /dev/null
+++ b/src/renderer/src/components/native-chat/native-chat-clipboard-payload.ts
@@ -0,0 +1,75 @@
+/** Minimal shape shared by React's synthetic ClipboardEvent and the native DOM
+ *  ClipboardEvent — the pane-level listener delivers the native one. */
+export type ClipboardEventLike = {
+  clipboardData: DataTransfer | null
+  preventDefault: () => void
+  defaultPrevented: boolean
+}
+
+export function clipboardEventImageFile(event: ClipboardEventLike): File | null {
+  const data = event.clipboardData
+  if (!data) {
+    return null
+  }
+  const item = Array.from(data.items).find((candidate) => candidate.type.startsWith('image/'))
+  return item?.getAsFile() ?? null
+}
+
+function lastPathSegment(path: string): string {
+  return path.split(/[\\/]/).pop() ?? path
+}
+
+/** A label names its file directly (Finder), or by path or file URL (Linux file managers). */
+function labelledFileName(line: string): string {
+  if (line.startsWith('file://')) {
+    try {
+      return lastPathSegment(decodeURIComponent(line.replace(/^file:\/\/[^/]*/, '')))
+    } catch {
+      return line
+    }
+  }
+  return /^(?:\/|[A-Za-z]:[\\/])/.test(line) ? lastPathSegment(line) : line
+}
+
+/**
+ * True when the text only labels the copied files, one line per file: a file
+ * manager puts that label beside the files, and it is not prompt text.
+ * `files` are the copied files' names or paths.
+ */
+export function textOnlyLabelsCopiedFiles(text: string, files: readonly string[]): boolean {
+  if (files.length === 0) {
+    return false
+  }
+  const names = files.map(lastPathSegment).sort()
+  const labels = text
+    .trim()
+    .split(/\r\n|\r|\n/)
+    .map((line) => labelledFileName(line.trim()))
+    .sort()
+  return labels.length === names.length && labels.every((label, i) => label === names[i])
+}
+
+/** The event's text/plain, unless it only labels the files being attached. */
+export function clipboardEventPromptText(
+  event: ClipboardEventLike,
+  attachingFile: boolean
+): string {
+  const text = event.clipboardData?.getData('text/plain') ?? ''
+  if (!attachingFile || !text) {
+    return text
+  }
+  const names = Array.from(event.clipboardData?.files ?? [], (file) => file.name)
+  return textOnlyLabelsCopiedFiles(text, names) ? '' : text
+}
+
+/** The clipboard's text for a paste with no event, and whether it only labels copied files. */
+export async function readClipboardPasteText(
+  maxBytes: number
+): Promise<{ text: string; labelsFiles: boolean }> {
+  const [text, filePaths] = await Promise.all([
+    window.api.ui.readClipboardText({ maxBytes }),
+    // Bookkeeping only: without the file list the text is typed as-is.
+    window.api.ui.readClipboardFilePaths().catch(() => [])
+  ])
+  return { text, labelsFiles: text !== '' && textOnlyLabelsCopiedFiles(text, filePaths) }
+}
diff --git a/src/renderer/src/components/native-chat/native-chat-command-marker.ts b/src/renderer/src/components/native-chat/native-chat-command-marker.ts
index 94634256e80..9625cee5166 100644
--- a/src/renderer/src/components/native-chat/native-chat-command-marker.ts
+++ b/src/renderer/src/components/native-chat/native-chat-command-marker.ts
@@ -104,8 +104,3 @@ export function commandMarkersAsMessages(
     source: 'scrape' as const
   }))
 }
-
-/** True when a message id was minted for a slash-command marker. */
-export function isCommandMarkerId(id: string): boolean {
-  return id.startsWith('command:')
-}
diff --git a/src/renderer/src/components/native-chat/native-chat-composer-input.ts b/src/renderer/src/components/native-chat/native-chat-composer-input.ts
index 9a0c6b0ba97..91d9be943d7 100644
--- a/src/renderer/src/components/native-chat/native-chat-composer-input.ts
+++ b/src/renderer/src/components/native-chat/native-chat-composer-input.ts
@@ -10,5 +10,19 @@ export type NativeChatComposerInput = Pick<
   | 'setSelectionRange'
 > & {
   contains?: (node: Node | null) => boolean
+  insertText?: (text: string) => void
   insertSkill?: (from: number, to: number, token: string) => void
 }
+
+export function insertNativeChatPastedText(
+  input: NativeChatComposerInput | null,
+  text: string
+): boolean {
+  if (!input || input.disabled || !input.insertText) {
+    return false
+  }
+  // A paste routed from a hidden terminal or a transcript click must leave the caret in the composer.
+  input.focus()
+  input.insertText(text)
+  return true
+}
diff --git a/src/renderer/src/components/native-chat/native-chat-composer-reveal-focus.test.tsx b/src/renderer/src/components/native-chat/native-chat-composer-reveal-focus.test.tsx
index b83f1df97e6..c52bf701ab0 100644
--- a/src/renderer/src/components/native-chat/native-chat-composer-reveal-focus.test.tsx
+++ b/src/renderer/src/components/native-chat/native-chat-composer-reveal-focus.test.tsx
@@ -52,8 +52,9 @@ function Harness(props: HarnessProps): React.JSX.Element {
     },
     insertTypedText: () => true,
     handlePasteEvent: () => {},
-    pasteFromClipboard: () => {}
-  } as NativeChatComposerHandle
+    pasteFromClipboard: () => {},
+    contains: () => false
+  }
   useNativeChatComposerRevealFocus({
     rootRef,
     composerRef,
diff --git a/src/renderer/src/components/native-chat/native-chat-composer-types.ts b/src/renderer/src/components/native-chat/native-chat-composer-types.ts
index ec90f81fe08..922d16924f3 100644
--- a/src/renderer/src/components/native-chat/native-chat-composer-types.ts
+++ b/src/renderer/src/components/native-chat/native-chat-composer-types.ts
@@ -38,6 +38,13 @@ export type NativeChatStructuredComposerTransport = {
   runtimeEnvironmentId: string | null
 }
 
+export type NativeChatOptimisticSendOutcome = {
+  /** The host refused the write: mark the echo "Message not sent". */
+  reject: (pendingId: string) => void
+  /** The write acknowledgment was lost: hold the echo, then flag it unconfirmed. */
+  holdUnconfirmed: (pendingId: string) => void
+}
+
 export type NativeChatComposerProps = {
   /** Tab hosting the agent; used to resolve the live ptyId + runtime settings. */
   terminalTabId: string
@@ -54,6 +61,8 @@ export type NativeChatComposerProps = {
   onStop?: () => void
   /** Render an optimistic echo until the real transcript turn lands. */
   onOptimisticSend?: (text: string, imagePaths?: string[]) => string | undefined
+  /** Settle an optimistic echo whose write was refused or never acknowledged. */
+  optimisticSendOutcome?: NativeChatOptimisticSendOutcome
   /** Remove an optimistic echo when its delayed submit is canceled. */
   onOptimisticSendCanceled?: (pendingId: string) => void
   /** Record a dispatched slash command that does not create a chat turn. */
@@ -92,4 +101,6 @@ export type NativeChatComposerHandle = {
   }) => void
   /** Pastes clipboard content when no DOM paste event is available. */
   pasteFromClipboard: () => void
+  /** Whether a node is inside the composer's own input, not merely the chat pane. */
+  contains: (node: Node | null) => boolean
 }
diff --git a/src/renderer/src/components/native-chat/native-chat-input-clear.ts b/src/renderer/src/components/native-chat/native-chat-input-clear.ts
new file mode 100644
index 00000000000..0f15c98b54e
--- /dev/null
+++ b/src/renderer/src/components/native-chat/native-chat-input-clear.ts
@@ -0,0 +1,89 @@
+// Clearing the agent's unsubmitted input line before a chat send writes its body.
+import { sendRuntimePtyInput } from '@/runtime/runtime-terminal-inspection'
+import type { getSettingsForAgentTabRuntimeOwner } from '@/lib/agent-paste-draft'
+import { AGENT_TUI_CLEAR_INPUT_MAX } from '../../../../shared/agent-tui-input-clear'
+
+// Why: agent TUI composers treat Ctrl+U as kill-to-start-of-line. Chat sends
+// start from an empty line so a prior cancelled paste cannot glue onto the next
+// prompt. Not used on verified option commands — model-switch confirmation
+// observes the PTY and Ctrl+U can miss confirmation markers.
+//
+// One Ctrl+U only ever clears ONE logical line. When the line may hold an
+// injected multi-line launch draft, callers pass `clearInput` built by
+// buildAgentTuiClearInputForText — see agent-tui-input-clear.ts for the measured
+// 2N-1 law and the sequences that do NOT work.
+export const NATIVE_CHAT_CLEAR_UNSUBMITTED_INPUT = '\x15'
+
+/** Gap before re-reading the agent's input line to confirm a clear landed. */
+export const NATIVE_CHAT_CLEAR_CONFIRM_MS = 140
+
+export type NativeChatSendOptions = {
+  /** The host refused a write; nothing after it was sent. */
+  onWriteRejected?: () => void
+  /** A write's acknowledgment was lost; it may or may not have landed. */
+  onWriteUnconfirmed?: () => void
+  /** Bytes that empty the agent's input line. Defaults to a single Ctrl+U. */
+  clearInput?: string
+  /**
+   * Observed check that the input line is now empty.
+   * Supplied only for launch-draft replacement; when it reports "not cleared"
+   * the send widens to a maximal burst before writing the body rather than
+   * pasting on top of residue.
+   */
+  confirmCleared?: () => boolean
+}
+
+type RuntimeSettings = ReturnType<typeof getSettingsForAgentTabRuntimeOwner>
+
+export function clearUnsubmittedAgentInput(
+  settings: RuntimeSettings,
+  ptyId: string,
+  options?: NativeChatSendOptions
+): void {
+  sendRuntimePtyInput(
+    settings,
+    ptyId,
+    options?.clearInput ?? NATIVE_CHAT_CLEAR_UNSUBMITTED_INPUT,
+    'driving'
+  )
+}
+
+/**
+ * Run `writeBody` once the input line is clear. With no `confirmCleared` the
+ * clear is a plain in-order write on the same byte stream, so the TUI consumes
+ * it before the body and the body follows immediately. With one, we pause to
+ * actually look at the agent's input line, and widen to a maximal burst when the
+ * draft is still visible — the injected line count is only a lower bound on what
+ * the buffer holds, since the user can type into the TUI directly.
+ */
+export function clearThenWrite(
+  settings: RuntimeSettings,
+  ptyId: string,
+  options: NativeChatSendOptions | undefined,
+  delay: (ms: number, fn: () => void) => void,
+  writeBody: () => void
+): void {
+  clearUnsubmittedAgentInput(settings, ptyId, options)
+  const confirmCleared = options?.confirmCleared
+  if (!confirmCleared) {
+    writeBody()
+    return
+  }
+  delay(NATIVE_CHAT_CLEAR_CONFIRM_MS, () => {
+    let cleared = false
+    try {
+      cleared = confirmCleared()
+    } catch {
+      // An unreadable terminal is unconfirmed; the maximal clear remains safe.
+    }
+    if (!cleared) {
+      sendRuntimePtyInput(settings, ptyId, AGENT_TUI_CLEAR_INPUT_MAX, 'driving')
+    }
+    writeBody()
+  })
+}
+
+/** Extra time a send needs when it stops to confirm the clear before the body. */
+export function clearConfirmDurationMs(options?: NativeChatSendOptions): number {
+  return options?.confirmCleared ? NATIVE_CHAT_CLEAR_CONFIRM_MS : 0
+}
diff --git a/src/renderer/src/components/native-chat/native-chat-message-grouping.test.ts b/src/renderer/src/components/native-chat/native-chat-message-grouping.test.ts
index 7df292d5ed9..3b436dc11c9 100644
--- a/src/renderer/src/components/native-chat/native-chat-message-grouping.test.ts
+++ b/src/renderer/src/components/native-chat/native-chat-message-grouping.test.ts
@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest'
 import type { NativeChatMessage } from '../../../../shared/native-chat-types'
-import { buildNativeChatRenderItems, orderNativeChatMessages } from './native-chat-message-grouping'
+import { orderNativeChatMessages } from './native-chat-message-grouping'
 import { NATIVE_CHAT_STREAMING_ID } from '../../../../shared/native-chat-streaming'
 
 function msg(
@@ -42,75 +42,3 @@ describe('orderNativeChatMessages', () => {
     expect(ordered.map((m) => m.id)).toEqual(['real-user', 'streaming', 'pending:abc'])
   })
 })
-
-describe('buildNativeChatRenderItems', () => {
-  it('renders messages in order', () => {
-    const items = buildNativeChatRenderItems([
-      msg({ id: 'u', role: 'user', timestamp: 1, blocks: [{ type: 'text', text: 'hi' }] }),
-      msg({ id: 'a', role: 'assistant', timestamp: 2, blocks: [{ type: 'text', text: 'hello' }] })
-    ])
-    expect(items.map((i) => i.id)).toEqual(['u', 'a'])
-    expect(items[0]?.kind).toBe('message')
-  })
-
-  it('pairs a tool-call with its tool-result into one step', () => {
-    const items = buildNativeChatRenderItems([
-      msg({
-        id: 'a',
-        role: 'assistant',
-        timestamp: 1,
-        blocks: [{ type: 'tool-call', name: 'Bash', input: { cmd: 'ls' } }]
-      }),
-      msg({
-        id: 't',
-        role: 'tool',
-        timestamp: 2,
-        blocks: [{ type: 'tool-result', output: 'file.txt' }]
-      })
-    ])
-    const steps = items.filter((i) => i.kind === 'tool-step')
-    expect(steps).toHaveLength(1)
-    const step = steps[0]
-    if (step?.kind !== 'tool-step') {
-      throw new Error('expected tool-step')
-    }
-    expect(step.step.call.name).toBe('Bash')
-    expect(step.step.result?.output).toBe('file.txt')
-  })
-
-  it('leaves an unanswered tool-call in flight (result null)', () => {
-    const items = buildNativeChatRenderItems([
-      msg({
-        id: 'a',
-        role: 'assistant',
-        timestamp: 1,
-        blocks: [{ type: 'tool-call', name: 'Read', input: {} }]
-      })
-    ])
-    const step = items.find((i) => i.kind === 'tool-step')
-    if (step?.kind !== 'tool-step') {
-      throw new Error('expected tool-step')
-    }
-    expect(step.step.result).toBeNull()
-  })
-
-  it('separates prose blocks from tool blocks in the same message', () => {
-    const items = buildNativeChatRenderItems([
-      msg({
-        id: 'a',
-        role: 'assistant',
-        timestamp: 1,
-        blocks: [
-          { type: 'text', text: 'running it' },
-          { type: 'tool-call', name: 'Bash', input: {} }
-        ]
-      })
-    ])
-    expect(items.map((i) => i.kind)).toEqual(['message', 'tool-step'])
-    const message = items[0]
-    if (message?.kind !== 'message') {
-      throw new Error('expected message')
-    }
-    expect(message.blocks).toEqual([{ type: 'text', text: 'running it' }])
-  })
-})
diff --git a/src/renderer/src/components/native-chat/native-chat-message-grouping.ts b/src/renderer/src/components/native-chat/native-chat-message-grouping.ts
index 6d9ff9bf71e..a36ea2f8d2e 100644
--- a/src/renderer/src/components/native-chat/native-chat-message-grouping.ts
+++ b/src/renderer/src/components/native-chat/native-chat-message-grouping.ts
@@ -1,118 +1,12 @@
-// Pure grouping logic for the native chat message list. Kept out of the .tsx so
-// the pairing/ordering rules are unit-testable without rendering. Two jobs:
-//   1. Order messages stably (timestamp then id; null timestamps sort first as
-//      the shared model documents) — the assembler already sorts, but the list
-//      re-sorts defensively so a caller passing unordered fixtures still reads
-//      correctly.
-//   2. Within an assistant turn, pair each tool-call block with the tool-result
-//      that answers it so the view can render one collapsible step instead of
-//      two disconnected rows.
+// Stable message ordering for the native chat message list: timestamp then id,
+// null timestamps first as the shared model documents.
 
-import {
-  isToolCallBlock,
-  isToolResultBlock,
-  type NativeChatBlock,
-  type NativeChatMessage,
-  type NativeChatToolCallBlock,
-  type NativeChatToolResultBlock
-} from '../../../../shared/native-chat-types'
+import type { NativeChatMessage } from '../../../../shared/native-chat-types'
 import { compareMessages } from './native-chat-session-assembler'
 
-/** A tool-call block paired with the result that answered it, when one exists.
- *  `result` is null while the call is still in flight (no result yet). */
-export type NativeChatToolStep = {
-  call: NativeChatToolCallBlock
-  result: NativeChatToolResultBlock | null
-}
-
-/** One renderable item in the list: either a prose/role message carrying its
- *  non-tool blocks, or a tool step (call + optional result). The view renders
- *  each variant differently. */
-export type NativeChatRenderItem =
-  | {
-      kind: 'message'
-      id: string
-      message: NativeChatMessage
-      /** The message's blocks minus tool-call/tool-result (those become steps). */
-      blocks: NativeChatBlock[]
-    }
-  | {
-      kind: 'tool-step'
-      id: string
-      /** Role of the message the call originated from (assistant/tool). */
-      role: NativeChatMessage['role']
-      timestamp: number | null
-      step: NativeChatToolStep
-    }
-
 /** Order messages stably: null timestamps first (model rule), then ascending
  *  timestamp, ties broken by id. Shares the assembler's comparator so both
  *  paths order identically. */
 export function orderNativeChatMessages(messages: NativeChatMessage[]): NativeChatMessage[] {
   return [...messages].sort(compareMessages)
 }
-
-/** Collect every tool-result across the whole conversation in document order so
- *  a call can find its answer even when the result lands in a later message (the
- *  common transcript shape: assistant emits the call, a following tool message
- *  carries the result). Results carry no originating name in our model, so they
- *  are handed out FIFO to calls. */
-function collectToolResults(messages: NativeChatMessage[]): NativeChatToolResultBlock[] {
-  const results: NativeChatToolResultBlock[] = []
-  for (const message of messages) {
-    for (const block of message.blocks) {
-      if (isToolResultBlock(block)) {
-        results.push(block)
-      }
-    }
-  }
-  return results
-}
-
-/**
- * Flatten ordered messages into render items, pairing tool calls with results.
- * Result pairing is FIFO across the conversation: tool results in our model
- * carry no back-reference to a call id, so we match the Nth call to the Nth
- * result in document order — the order both providers emit them. A call with no
- * remaining result renders as in-flight (`result: null`).
- */
-export function buildNativeChatRenderItems(messages: NativeChatMessage[]): NativeChatRenderItem[] {
-  const ordered = orderNativeChatMessages(messages)
-  const resultQueue = collectToolResults(ordered)
-  let resultCursor = 0
-
-  const items: NativeChatRenderItem[] = []
-  for (const message of ordered) {
-    const nonToolBlocks: NativeChatBlock[] = []
-    const steps: NativeChatToolStep[] = []
-
-    for (const block of message.blocks) {
-      if (isToolCallBlock(block)) {
-        const result = resultQueue[resultCursor] ?? null
-        if (result) {
-          resultCursor += 1
-        }
-        steps.push({ call: block, result })
-      } else if (isToolResultBlock(block)) {
-        // Results are emitted as steps from the call side; skip standalone ones.
-        continue
-      } else {
-        nonToolBlocks.push(block)
-      }
-    }
-
-    if (nonToolBlocks.length > 0) {
-      items.push({ kind: 'message', id: message.id, message, blocks: nonToolBlocks })
-    }
-    for (const [index, step] of steps.entries()) {
-      items.push({
-        kind: 'tool-step',
-        id: `${message.id}:tool:${index}`,
-        role: message.role,
-        timestamp: message.timestamp,
-        step
-      })
-    }
-  }
-  return items
-}
diff --git a/src/renderer/src/components/native-chat/native-chat-observed-send.test.ts b/src/renderer/src/components/native-chat/native-chat-observed-send.test.ts
new file mode 100644
index 00000000000..666e695ac4c
--- /dev/null
+++ b/src/renderer/src/components/native-chat/native-chat-observed-send.test.ts
@@ -0,0 +1,69 @@
+import { afterEach, beforeEach, expect, it, vi } from 'vitest'
+const io = vi.hoisted(() => ({ write: vi.fn(), verified: vi.fn() }))
+vi.mock('@/runtime/runtime-terminal-inspection', () => ({
+  sendRuntimePtyInput: io.write,
+  sendRuntimePtyInputVerified: io.verified
+}))
+import {
+  sendNativeChatMessage,
+  resetNativeChatPtySendQueuesForTests
+} from './native-chat-runtime-send'
+import { buildNativeChatPasteBytes, NATIVE_CHAT_SUBMIT } from './native-chat-send'
+beforeEach(() => {
+  vi.useFakeTimers()
+  resetNativeChatPtySendQueuesForTests()
+  io.write.mockReset().mockReturnValue(true)
+  io.verified.mockReset().mockResolvedValue(true)
+})
+afterEach(() => {
+  resetNativeChatPtySendQueuesForTests()
+  vi.useRealTimers()
+})
+it('observes a refused write, skips Enter, and releases the queue for the next user action', async () => {
+  const rejected = vi.fn()
+  io.verified.mockResolvedValueOnce(false)
+  sendNativeChatMessage(null, 'pane', 'refused', { onWriteRejected: rejected })
+  await vi.advanceTimersByTimeAsync(1000)
+  expect(rejected).toHaveBeenCalledOnce()
+  expect(io.verified.mock.calls.map((call) => call[2])).toEqual([
+    buildNativeChatPasteBytes('refused')
+  ])
+  sendNativeChatMessage(null, 'pane', 'next', { onWriteRejected: rejected })
+  await vi.advanceTimersByTimeAsync(1000)
+  expect(io.verified.mock.calls.map((call) => call[2])).toEqual([
+    buildNativeChatPasteBytes('refused'),
+    buildNativeChatPasteBytes('next'),
+    NATIVE_CHAT_SUBMIT
+  ])
+})
+it('reports a lost acknowledgment once as unconfirmed, never as rejection, and still submits', async () => {
+  const rejected = vi.fn()
+  const unconfirmed = vi.fn()
+  io.verified.mockRejectedValueOnce(new Error('lost acknowledgment'))
+  io.verified.mockRejectedValueOnce(new Error('lost acknowledgment'))
+  sendNativeChatMessage(null, 'pane', 'uncertain', {
+    onWriteRejected: rejected,
+    onWriteUnconfirmed: unconfirmed
+  })
+  await vi.advanceTimersByTimeAsync(120000)
+  expect(rejected).not.toHaveBeenCalled()
+  expect(unconfirmed).toHaveBeenCalledOnce()
+  expect(io.verified.mock.calls.map((call) => call[2])).toEqual([
+    buildNativeChatPasteBytes('uncertain'),
+    NATIVE_CHAT_SUBMIT
+  ])
+})
+it('serializes rapid sends through their acknowledged Enter and preserves the paste delay', async () => {
+  const rejected = vi.fn()
+  sendNativeChatMessage(null, 'pane', 'one', { onWriteRejected: rejected })
+  sendNativeChatMessage(null, 'pane', 'two', { onWriteRejected: rejected })
+  await vi.advanceTimersByTimeAsync(499)
+  expect(io.verified).toHaveBeenCalledOnce()
+  await vi.advanceTimersByTimeAsync(501)
+  expect(io.verified.mock.calls.map((call) => call[2])).toEqual([
+    buildNativeChatPasteBytes('one'),
+    NATIVE_CHAT_SUBMIT,
+    buildNativeChatPasteBytes('two'),
+    NATIVE_CHAT_SUBMIT
+  ])
+})
diff --git a/src/renderer/src/components/native-chat/native-chat-observed-send.ts b/src/renderer/src/components/native-chat/native-chat-observed-send.ts
new file mode 100644
index 00000000000..2de4b557c80
--- /dev/null
+++ b/src/renderer/src/components/native-chat/native-chat-observed-send.ts
@@ -0,0 +1,69 @@
+import { sendRuntimePtyInputVerified } from '@/runtime/runtime-terminal-inspection'
+import type { getSettingsForAgentTabRuntimeOwner } from '@/lib/agent-paste-draft'
+import { enqueueNativeChatPtySend } from './native-chat-pty-send-queue'
+import {
+  clearConfirmDurationMs,
+  clearThenWrite,
+  clearUnsubmittedAgentInput,
+  type NativeChatSendOptions
+} from './native-chat-input-clear'
+
+/** Observe write refusals without mistaking transport success for provider acceptance. */
+export function sendNativeChatObservedWrites(
+  settings: ReturnType<typeof getSettingsForAgentTabRuntimeOwner>,
+  ptyId: string,
+  writes: readonly { data: string; delayBeforeMs: number }[],
+  options: NativeChatSendOptions
+) {
+  return enqueueNativeChatPtySend(
+    ptyId,
+    writes.reduce((total, write) => total + write.delayBeforeMs, 0) +
+      clearConfirmDurationMs(options),
+    ({ isCancelled, delay, markSubmitted }) => {
+      let reportedUnconfirmed = false
+      const writeAt = (index: number): void => {
+        if (isCancelled()) {
+          return
+        }
+        const write = writes[index]
+        if (!write) {
+          markSubmitted()
+          return
+        }
+        const send = (): void => {
+          if (isCancelled()) {
+            return
+          }
+          void sendRuntimePtyInputVerified(settings, ptyId, write.data, 'driving')
+            .then((accepted) => {
+              if (isCancelled()) {
+                return
+              }
+              if (!accepted) {
+                options.onWriteRejected?.()
+                markSubmitted()
+                return
+              }
+              writeAt(index + 1)
+            })
+            // A lost acknowledgment is not a refusal: never re-send these bytes, but still submit
+            // a body that may have landed, as the unobserved path does.
+            .catch(() => {
+              if (!reportedUnconfirmed) {
+                reportedUnconfirmed = true
+                options.onWriteUnconfirmed?.()
+              }
+              writeAt(index + 1)
+            })
+        }
+        if (write.delayBeforeMs > 0) {
+          delay(write.delayBeforeMs, send)
+        } else {
+          send()
+        }
+      }
+      clearThenWrite(settings, ptyId, options, delay, () => writeAt(0))
+    },
+    { onCancelUnsubmitted: () => clearUnsubmittedAgentInput(settings, ptyId, options) }
+  )
+}
diff --git a/src/renderer/src/components/native-chat/native-chat-paste-routing.test.tsx b/src/renderer/src/components/native-chat/native-chat-paste-routing.test.tsx
new file mode 100644
index 00000000000..67276c32d33
--- /dev/null
+++ b/src/renderer/src/components/native-chat/native-chat-paste-routing.test.tsx
@@ -0,0 +1,416 @@
+// @vitest-environment happy-dom
+import { act, cleanup, render } from '@testing-library/react'
+import { useRef, type ReactNode } from 'react'
+import { createPortal } from 'react-dom'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { APP_MENU_PASTE_EVENT } from '@/lib/app-menu-paste'
+import { useNativeChatPasteBridge } from './use-native-chat-paste-bridge'
+import type { NativeChatComposerHandle } from './NativeChatComposer'
+import { NativeChatPaneCover } from '../terminal-pane/NativeChatPaneCover'
+import { registerTerminalPanePasteListeners } from '../terminal-pane/terminal-pane-paste-listeners'
+import type { TerminalPaneCloseController } from '../terminal-pane/use-terminal-pane-close-actions'
+import type { TerminalPanePasteExecution } from '../terminal-pane/terminal-pane-paste-execution'
+import {
+  pasteTerminalPaneMenuClipboard,
+  type TerminalPaneMenuPasteContext
+} from '../terminal-pane/terminal-pane-menu-paste'
+import type { ManagedPane } from '@/lib/pane-manager/pane-manager'
+
+const mocks = vi.hoisted(() => ({
+  readClipboardText: vi.fn(),
+  terminalClipboard: vi.fn(),
+  error: vi.fn()
+}))
+vi.mock('sonner', () => ({ toast: { error: mocks.error } }))
+vi.mock('@/i18n/i18n', () => ({ translate: (_key: string, fallback: string) => fallback }))
+vi.mock('../terminal-pane/terminal-clipboard-paste', () => ({
+  pasteTerminalClipboard: mocks.terminalClipboard
+}))
+vi.mock('../terminal-pane/terminal-clipboard-event-paste', () => ({
+  isClipboardEventPasteRequired: () => false,
+  firesNativePasteEvent: () => true,
+  getClipboardEventText: (event: ClipboardEvent) => event.clipboardData?.getData('text/plain') ?? ''
+}))
+
+const REFUSAL = "Can't paste — this chat isn't accepting input right now."
+
+let dispose: (() => void) | undefined
+beforeEach(() => {
+  mocks.readClipboardText.mockResolvedValue('menu text')
+  mocks.terminalClipboard.mockResolvedValue({ status: 'empty' })
+  Object.defineProperty(window, 'api', {
+    configurable: true,
+    value: { ui: { readClipboardText: mocks.readClipboardText } }
+  })
+})
+afterEach(() => {
+  cleanup()
+  dispose?.()
+  dispose = undefined
+  document.body.replaceChildren()
+  vi.clearAllMocks()
+})
+
+type FakePane = Pick<ManagedPane, 'id' | 'container' | 'terminal'> & {
+  helper: HTMLTextAreaElement
+}
+
+function terminalPane(id: number): FakePane {
+  const container = document.createElement('div')
+  container.className = 'pane'
+  container.dataset.leafId = `leaf-${id}`
+  const element = document.createElement('div')
+  element.className = 'xterm'
+  const helper = document.createElement('textarea')
+  helper.className = 'xterm-helper-textarea'
+  element.append(helper)
+  container.append(element)
+  // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: cover code reads only element and focus.
+  const terminal = { element, focus: () => helper.focus() } as unknown as ManagedPane['terminal']
+  return { id, container, terminal, helper }
+}
+
+function composerHandle(): NativeChatComposerHandle & { element: HTMLElement } {
+  const element = document.createElement('div')
+  element.contentEditable = 'true'
+  // Production marks the composer field box and the pane-wide drop surface alike.
+  element.dataset.composerScopeKey = 'pane'
+  return {
+    element,
+    focus: vi.fn(() => {
+      element.focus()
+      return true
+    }),
+    insertTypedText: vi.fn(() => true),
+    handlePasteEvent: vi.fn(),
+    pasteFromClipboard: vi.fn(),
+    contains: (node) => element.contains(node)
+  }
+}
+
+type ChatOptions = {
+  composer?: NativeChatComposerHandle & { element: HTMLElement }
+  answer?: HTMLInputElement
+  answerRef?: { current: HTMLInputElement | null }
+}
+
+function ChatRoot({
+  composer,
+  answer,
+  answerRef: sharedAnswerRef
+}: ChatOptions): React.JSX.Element {
+  const rootRef = useRef<HTMLDivElement>(null)
+  const composerRef = useRef<NativeChatComposerHandle | null>(composer ?? null)
+  const ownAnswerRef = useRef<HTMLInputElement | null>(answer ?? null)
+  const answerRef = sharedAnswerRef ?? ownAnswerRef
+  useNativeChatPasteBridge({ rootRef, composerRef, questionAnswerInputRef: answerRef })
+  return (
+    // Mirrors NativeChatPaneFileDropSurface, which publishes the composer scope pane-wide.
+    <div data-composer-scope-key="pane" data-native-file-drop-target="composer">
+      <div
+        ref={(node) => {
+          rootRef.current = node
+          if (node && composer && !node.contains(composer.element)) {
+            node.append(composer.element)
+          }
+          if (node && answer && !node.contains(answer)) {
+            node.append(answer)
+          }
+        }}
+        data-native-chat-root="true"
+        tabIndex={-1}
+      >
+        <p data-testid="transcript">transcript</p>
+        <input data-testid="search" />
+      </div>
+    </div>
+  )
+}
+
+function Cover({
+  pane,
+  covered,
+  children
+}: {
+  pane: FakePane
+  covered: boolean
+  children?: ReactNode
+}): React.JSX.Element | null {
+  return covered
+    ? createPortal(
+        <NativeChatPaneCover pane={pane}>{children}</NativeChatPaneCover>,
+        pane.container
+      )
+    : null
+}
+
+function fixture(options: { platform?: NodeJS.Platform } = {}) {
+  const container = document.createElement('div')
+  const pane = terminalPane(1)
+  const sibling = terminalPane(2)
+  container.append(pane.container, sibling.container)
+  const outside = document.createElement('input')
+  document.body.append(container, outside)
+  const pasteFromClipboard = vi.fn()
+  const executePanePasteText = vi.fn()
+  // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the listeners use only these controller fields.
+  const controller = {
+    forceBracketedMultilineTextPaste: false,
+    keybindings: {},
+    worktreeId: 'workspace',
+    managerRef: { current: { getActivePane: () => pane, getPanes: () => [pane, sibling] } },
+    setTerminalError: vi.fn()
+  } as unknown as TerminalPaneCloseController
+  // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: these are the two execution callbacks read by the listener.
+  const execution = {
+    pasteFromClipboard,
+    executePanePasteText
+  } as unknown as TerminalPanePasteExecution
+  dispose = registerTerminalPanePasteListeners({
+    container,
+    controller,
+    execution,
+    isMac: options.platform === 'darwin',
+    shortcutPlatform: options.platform ?? 'win32'
+  })
+  pane.helper.focus()
+  const view = render(<Cover pane={pane} covered={false} />)
+  const cover = (chat: ReactNode = null): void =>
+    view.rerender(
+      <Cover pane={pane} covered>
+        {chat}
+      </Cover>
+    )
+  const uncover = (): void => view.rerender(<Cover pane={pane} covered={false} />)
+  const shell = (): HTMLElement => {
+    const element = pane.container.querySelector<HTMLElement>('.native-chat-pane-shell')
+    if (!element) {
+      throw new Error('cover not mounted')
+    }
+    return element
+  }
+  return { pane, sibling, outside, pasteFromClipboard, cover, uncover, shell }
+}
+
+function paste(target: Element, text = 'event text'): ClipboardEvent {
+  const data = new DataTransfer()
+  data.setData('text/plain', text)
+  const event = new ClipboardEvent('paste', {
+    clipboardData: data,
+    bubbles: true,
+    cancelable: true
+  })
+  target.dispatchEvent(event)
+  return event
+}
+
+function menuPane(pane: FakePane): ManagedPane {
+  // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: a covered pane's menu paste reads only container and terminal.
+  return pane as unknown as ManagedPane
+}
+
+function menuContext(): TerminalPaneMenuPasteContext {
+  return {
+    managerRef: { current: null },
+    paneTransportsRef: { current: new Map() },
+    tabId: 'tab',
+    worktreeId: 'workspace',
+    forceBracketedMultilineTextPaste: false,
+    onPasteError: vi.fn()
+  }
+}
+
+describe('a chat cover owns focus over its terminal', () => {
+  it('moves focus off the covered xterm and keeps it off', () => {
+    const f = fixture()
+    expect(document.activeElement).toBe(f.pane.helper)
+    f.cover()
+    expect(document.activeElement).toBe(f.shell())
+    expect(f.pane.terminal.element?.inert).toBe(true)
+    // Any of the unguarded terminal.focus() paths (focus-follows-mouse, pane menus) now no-ops.
+    f.pane.terminal.focus()
+    expect(document.activeElement).toBe(f.shell())
+  })
+
+  it('leaves a split sibling focusable', () => {
+    const f = fixture()
+    f.cover()
+    expect(f.sibling.terminal.element?.inert).toBe(false)
+    f.sibling.terminal.focus()
+    expect(document.activeElement).toBe(f.sibling.helper)
+  })
+
+  it('does not pull focus from elsewhere when a chat opens', () => {
+    const f = fixture()
+    f.outside.focus()
+    f.cover()
+    expect(document.activeElement).toBe(f.outside)
+    expect(f.pane.terminal.element?.inert).toBe(true)
+  })
+
+  it('returns focus to the terminal when the chat that held it goes away', () => {
+    const f = fixture()
+    f.cover()
+    f.uncover()
+    expect(f.pane.terminal.element?.inert).toBe(false)
+    expect(document.activeElement).toBe(f.pane.helper)
+  })
+
+  it.each(['another control', 'nothing'] as const)(
+    'does not pull focus into the terminal when %s had focus',
+    (holder) => {
+      const f = fixture()
+      f.cover()
+      if (holder === 'another control') {
+        f.outside.focus()
+      } else {
+        f.shell().blur()
+      }
+      const focusedBefore = document.activeElement
+      f.uncover()
+      expect(f.pane.terminal.element?.inert).toBe(false)
+      expect(document.activeElement).toBe(focusedBefore)
+    }
+  )
+})
+
+describe('paste inside a chat cover never reaches the terminal', () => {
+  it.each(['darwin', 'win32', 'linux'] as const)(
+    'refuses a %s paste before the chat has mounted any input',
+    (platform) => {
+      const f = fixture({ platform })
+      f.cover()
+      f.shell().dispatchEvent(
+        new KeyboardEvent('keydown', {
+          key: 'v',
+          metaKey: platform === 'darwin',
+          ctrlKey: platform !== 'darwin',
+          bubbles: true,
+          cancelable: true
+        })
+      )
+      expect(paste(f.shell()).defaultPrevented).toBe(true)
+      expect(f.pasteFromClipboard).not.toHaveBeenCalled()
+      expect(mocks.error).toHaveBeenCalledExactlyOnceWith(REFUSAL)
+    }
+  )
+
+  it('leaves the app-menu paste to the cover instead of the hidden terminal', () => {
+    const f = fixture({ platform: 'darwin' })
+    f.cover()
+    const event = new Event(APP_MENU_PASTE_EVENT, { cancelable: true })
+    window.dispatchEvent(event)
+    expect(event.defaultPrevented).toBe(false)
+    expect(mocks.terminalClipboard).not.toHaveBeenCalled()
+  })
+
+  it('refuses when the chat shows no input, such as an approval card', () => {
+    const f = fixture()
+    f.cover(<ChatRoot />)
+    const transcript = f.pane.container.querySelector('[data-testid="transcript"]')!
+    expect(paste(transcript).defaultPrevented).toBe(true)
+    expect(mocks.error).toHaveBeenCalledExactlyOnceWith(REFUSAL)
+    expect(f.pasteFromClipboard).not.toHaveBeenCalled()
+  })
+
+  it('hands a paste on the cover itself to the composer once the chat mounts', () => {
+    const f = fixture()
+    const composer = composerHandle()
+    f.cover(<ChatRoot composer={composer} />)
+    paste(f.shell())
+    expect(composer.pasteFromClipboard).toHaveBeenCalledTimes(1)
+    expect(mocks.error).not.toHaveBeenCalled()
+    expect(f.pasteFromClipboard).not.toHaveBeenCalled()
+  })
+
+  it('delivers transcript paste with its payload to the composer', () => {
+    const f = fixture()
+    const composer = composerHandle()
+    f.cover(<ChatRoot composer={composer} />)
+    const transcript = f.pane.container.querySelector('[data-testid="transcript"]')!
+    const event = paste(transcript, '원문')
+    expect(composer.handlePasteEvent).toHaveBeenCalledExactlyOnceWith(event)
+    expect(mocks.readClipboardText).not.toHaveBeenCalled()
+    expect(mocks.error).not.toHaveBeenCalled()
+  })
+
+  it('keeps native paste in a text field inside the chat despite the pane-wide scope marker', () => {
+    const f = fixture()
+    const composer = composerHandle()
+    f.cover(<ChatRoot composer={composer} />)
+    const search = f.pane.container.querySelector<HTMLInputElement>('[data-testid="search"]')!
+    expect(paste(search).defaultPrevented).toBe(false)
+    search.focus()
+    window.dispatchEvent(new Event(APP_MENU_PASTE_EVENT, { cancelable: true }))
+    expect(composer.handlePasteEvent).not.toHaveBeenCalled()
+    expect(composer.pasteFromClipboard).not.toHaveBeenCalled()
+    expect(mocks.error).not.toHaveBeenCalled()
+  })
+
+  it('claims the app-menu paste while the composer input has focus', () => {
+    const f = fixture({ platform: 'darwin' })
+    const composer = composerHandle()
+    f.cover(<ChatRoot composer={composer} />)
+    composer.element.focus()
+    window.dispatchEvent(new Event(APP_MENU_PASTE_EVENT, { cancelable: true }))
+    expect(composer.pasteFromClipboard).toHaveBeenCalledTimes(1)
+    expect(mocks.terminalClipboard).not.toHaveBeenCalled()
+  })
+
+  it('hands transcript paste to the question answer when the composer is absent', async () => {
+    const f = fixture()
+    const answer = document.createElement('input')
+    f.cover(<ChatRoot answer={answer} />)
+    const transcript = f.pane.container.querySelector('[data-testid="transcript"]')!
+    await act(async () => {
+      paste(transcript, 'answer')
+    })
+    expect(answer.value).toBe('answer')
+    expect(mocks.error).not.toHaveBeenCalled()
+  })
+
+  it('keeps terminal-only paste unchanged', () => {
+    const f = fixture()
+    paste(f.pane.helper)
+    expect(f.pasteFromClipboard).toHaveBeenCalledExactlyOnceWith(f.pane, 'paste-event')
+    window.dispatchEvent(new Event(APP_MENU_PASTE_EVENT, { cancelable: true }))
+    expect(mocks.terminalClipboard).toHaveBeenCalledTimes(1)
+  })
+})
+
+describe('terminal context-menu paste on a covered pane', () => {
+  it('routes by its named pane to that pane’s chat', async () => {
+    const f = fixture()
+    const composer = composerHandle()
+    f.cover(<ChatRoot composer={composer} />)
+    await pasteTerminalPaneMenuClipboard(menuContext(), menuPane(f.pane), 'context-menu')
+    expect(composer.pasteFromClipboard).toHaveBeenCalledTimes(1)
+    expect(mocks.terminalClipboard).not.toHaveBeenCalled()
+  })
+
+  it('refuses instead of pasting into the terminal when the chat has no input', async () => {
+    const f = fixture()
+    f.cover()
+    await pasteTerminalPaneMenuClipboard(menuContext(), menuPane(f.pane), 'right-click')
+    expect(mocks.error).toHaveBeenCalledExactlyOnceWith(REFUSAL)
+    expect(mocks.terminalClipboard).not.toHaveBeenCalled()
+  })
+
+  it('does not put a late read into a replacement question input', async () => {
+    const f = fixture()
+    const answer = document.createElement('input')
+    const answerRef = { current: answer }
+    f.cover(<ChatRoot answer={answer} answerRef={answerRef} />)
+    let finish = (_text: string): void => {}
+    mocks.readClipboardText.mockReturnValue(
+      new Promise<string>((resolve) => {
+        finish = resolve
+      })
+    )
+    await pasteTerminalPaneMenuClipboard(menuContext(), menuPane(f.pane), 'context-menu')
+    answerRef.current = document.createElement('input')
+    await act(async () => finish('old answer'))
+    expect(answer.value).toBe('')
+    expect(answerRef.current.value).toBe('')
+  })
+})
diff --git a/src/renderer/src/components/native-chat/native-chat-pending-pasted-content.test.ts b/src/renderer/src/components/native-chat/native-chat-pending-pasted-content.test.ts
new file mode 100644
index 00000000000..a1b1bbe5f5d
--- /dev/null
+++ b/src/renderer/src/components/native-chat/native-chat-pending-pasted-content.test.ts
@@ -0,0 +1,29 @@
+import { describe, expect, it } from 'vitest'
+import type { NativeChatMessage } from '../../../../shared/native-chat-types'
+import { pendingSendsAsMessages, prunePendingSends } from './native-chat-pending'
+
+const prompt = 'Summarize the failing tests.\n\nThen propose a fix for each one.'
+const wrapped = `\n\n<pasted_content id="7e64">\n${prompt}\n</pasted_content id="7e64">\n`
+function message(id: string, role: NativeChatMessage['role'], text: string): NativeChatMessage {
+  return { id, role, source: 'transcript', timestamp: null, blocks: [{ type: 'text', text }] }
+}
+
+describe('pending echoes against Claude pasted-content rows', () => {
+  // A new host delivers the decoded prompt; an old host still delivers the raw envelope.
+  it.each([
+    ['new host', prompt],
+    ['old host', wrapped]
+  ])('retires the echo with %s rows and keeps a second identical send', (_host, row) => {
+    const history = [
+      message('boundary', 'assistant', 'earlier'),
+      message('user', 'user', row),
+      message('reply', 'assistant', 'answer')
+    ]
+    const pending = [{ id: 'p1', text: prompt, sentAt: 999_000, afterMessageId: 'boundary' }]
+    expect(pendingSendsAsMessages(pending, history)).toEqual([])
+    expect(prunePendingSends(pending, history)).toEqual([])
+    expect(
+      prunePendingSends([...pending, { ...pending[0]!, id: 'p2', matchingOccurrence: 2 }], history)
+    ).toHaveLength(1)
+  })
+})
diff --git a/src/renderer/src/components/native-chat/native-chat-pending.test.ts b/src/renderer/src/components/native-chat/native-chat-pending.test.ts
index 1773fb10e61..8a6d57f4604 100644
--- a/src/renderer/src/components/native-chat/native-chat-pending.test.ts
+++ b/src/renderer/src/components/native-chat/native-chat-pending.test.ts
@@ -19,7 +19,6 @@ import {
   applyCommandMarkerBoundaries,
   clearCommandMarkerCacheForTests,
   commandMarkersAsMessages,
-  isCommandMarkerId,
   readCommandMarkerCache
 } from './native-chat-command-marker'
 import { stripNoiseMessages } from './native-chat-noise'
@@ -694,11 +693,6 @@ describe('commandMarkersAsMessages', () => {
     const markers = commandMarkersAsMessages([{ id: 'c1', command: '/compact', sentAt: 1 }])
     expect(stripNoiseMessages(markers)).toEqual(markers)
   })
-
-  it('isCommandMarkerId recognizes the prefix', () => {
-    expect(isCommandMarkerId('command:c1')).toBe(true)
-    expect(isCommandMarkerId('pending:p1')).toBe(false)
-  })
 })
 
 describe('command marker cache', () => {
diff --git a/src/renderer/src/components/native-chat/native-chat-pending.ts b/src/renderer/src/components/native-chat/native-chat-pending.ts
index 406fee3b579..680ca687e77 100644
--- a/src/renderer/src/components/native-chat/native-chat-pending.ts
+++ b/src/renderer/src/components/native-chat/native-chat-pending.ts
@@ -25,6 +25,10 @@ import {
 export type NativeChatPendingSend = {
   /** Renderer-minted id, unique per send, used as the list key. */
   id: string
+  /** Definite send outcome; absent while the send is simply awaiting its transcript row. */
+  delivery?: 'unconfirmed' | 'rejected'
+  /** When a write's acknowledgment was lost, so a remount keeps the original hold deadline. */
+  writeUnconfirmedAt?: number
   /** The exact draft text the user submitted. */
   text: string
   /** Image paths that were sent through the TUI image attachment paste path. */
@@ -80,7 +84,11 @@ export function appendPendingSendCache(
   scope: NativeChatPendingSendScope,
   entry: NativeChatPendingSend
 ): NativeChatPendingSend[] {
-  const existing = readPendingSendCache(scope)
+  const contentKey = nativeChatPendingContentKey(entry)
+  // Why: a resend replaces its failed copy; kept, that copy would claim the resend's row and pin it.
+  const existing = readPendingSendCache(scope).filter(
+    (candidate) => !candidate.delivery || nativeChatPendingContentKey(candidate) !== contentKey
+  )
   const next = assignNativeChatPendingOccurrence(existing, entry)
   return writePendingSendCache(scope, [...existing, next])
 }
diff --git a/src/renderer/src/components/native-chat/native-chat-root-key-routing.ts b/src/renderer/src/components/native-chat/native-chat-root-key-routing.ts
new file mode 100644
index 00000000000..8b4ba6e9925
--- /dev/null
+++ b/src/renderer/src/components/native-chat/native-chat-root-key-routing.ts
@@ -0,0 +1,42 @@
+import { getShortcutPlatform } from '@/lib/shortcut-platform'
+import type { NativeChatComposerHandle } from './native-chat-composer-types'
+import {
+  shouldFocusNativeChatComposerFromEditingKey,
+  shouldFocusNativeChatInputForPaste,
+  shouldRedirectNativeChatTyping,
+  type KeyboardRedirectEvent
+} from './native-chat-typing-redirect'
+
+type NativeChatRootKeyEvent = KeyboardRedirectEvent & {
+  preventDefault: () => void
+  stopPropagation: () => void
+}
+
+/** Routes a key pressed in the chat pane outside any input to the chat's input. */
+export function routeNativeChatRootKeyToInput(
+  event: NativeChatRootKeyEvent,
+  composer: NativeChatComposerHandle | null,
+  questionAnswerInput: HTMLInputElement | null
+): void {
+  // Backspace/Delete outside an input focuses the composer (like typing)
+  // but inserts nothing — let the now-focused field handle the keystroke.
+  if (shouldFocusNativeChatComposerFromEditingKey(event)) {
+    composer?.focus()
+    return
+  }
+  // The question card replaces the composer, so at most one input exists. If it
+  // cannot take focus (disabled), the paste reaches the bridge, which explains why.
+  if (shouldFocusNativeChatInputForPaste(event, getShortcutPlatform() === 'darwin')) {
+    const input = composer ?? questionAnswerInput
+    input?.focus()
+    return
+  }
+  if (!shouldRedirectNativeChatTyping(event)) {
+    return
+  }
+  if (!composer?.insertTypedText(event.key)) {
+    return
+  }
+  event.preventDefault()
+  event.stopPropagation()
+}
diff --git a/src/renderer/src/components/native-chat/native-chat-runtime-image-send.ts b/src/renderer/src/components/native-chat/native-chat-runtime-image-send.ts
index aba65acf8db..283a437e449 100644
--- a/src/renderer/src/components/native-chat/native-chat-runtime-image-send.ts
+++ b/src/renderer/src/components/native-chat/native-chat-runtime-image-send.ts
@@ -1,3 +1,4 @@
+import { sendNativeChatObservedWrites } from './native-chat-observed-send'
 import { agentImagePasteWrites, formatAgentImagePath } from '../../../../shared/agent-image-paste'
 import type { AgentType } from '../../../../shared/agent-status-types'
 import { sendRuntimePtyInput } from '@/runtime/runtime-terminal-inspection'
@@ -13,10 +14,9 @@ import {
   clearConfirmDurationMs,
   clearThenWrite,
   clearUnsubmittedAgentInput,
-  sendNativeChatMessage,
-  type NativeChatSendHandle,
   type NativeChatSendOptions
-} from './native-chat-runtime-send'
+} from './native-chat-input-clear'
+import { sendNativeChatMessage, type NativeChatSendHandle } from './native-chat-runtime-send'
 
 export const NATIVE_CHAT_IMAGE_ATTACHMENT_SETTLE_MS = 300
 
@@ -34,6 +34,21 @@ export function sendNativeChatMessageWithImageAttachments(
     return sendNativeChatMessage(settings, ptyId, text, options)
   }
   const trimmedText = text.trim()
+  if (options?.onWriteRejected) {
+    const writes = agentImagePasteWrites(
+      agent,
+      imagePaths.map((path) => buildNativeChatImagePasteBytes(formatAgentImagePath(agent, path))),
+      trimmedText.length > 0
+    ).map((data) => ({ data, delayBeforeMs: 0 }))
+    if (trimmedText) {
+      writes.push({
+        data: buildNativeChatPasteBytes(text),
+        delayBeforeMs: NATIVE_CHAT_IMAGE_ATTACHMENT_SETTLE_MS
+      })
+    }
+    writes.push({ data: NATIVE_CHAT_SUBMIT, delayBeforeMs: NATIVE_CHAT_SUBMIT_DELAY_MS })
+    return sendNativeChatObservedWrites(settings, ptyId, writes, options)
+  }
   const durationMs =
     (trimmedText.length > 0
       ? NATIVE_CHAT_IMAGE_ATTACHMENT_SETTLE_MS + NATIVE_CHAT_SUBMIT_DELAY_MS
diff --git a/src/renderer/src/components/native-chat/native-chat-runtime-send-launch-draft.test.ts b/src/renderer/src/components/native-chat/native-chat-runtime-send-launch-draft.test.ts
index 1016b466ccb..a10bb87cd3b 100644
--- a/src/renderer/src/components/native-chat/native-chat-runtime-send-launch-draft.test.ts
+++ b/src/renderer/src/components/native-chat/native-chat-runtime-send-launch-draft.test.ts
@@ -11,12 +11,14 @@ vi.mock('@/runtime/runtime-terminal-inspection', () => ({
 }))
 
 import {
-  NATIVE_CHAT_CLEAR_CONFIRM_MS,
-  NATIVE_CHAT_CLEAR_UNSUBMITTED_INPUT,
   NATIVE_CHAT_SUBMIT_DELAY_MS,
   resetNativeChatPtySendQueuesForTests,
   sendNativeChatMessage
 } from './native-chat-runtime-send'
+import {
+  NATIVE_CHAT_CLEAR_CONFIRM_MS,
+  NATIVE_CHAT_CLEAR_UNSUBMITTED_INPUT
+} from './native-chat-input-clear'
 import {
   NATIVE_CHAT_IMAGE_ATTACHMENT_SETTLE_MS,
   sendNativeChatMessageWithImageAttachments
diff --git a/src/renderer/src/components/native-chat/native-chat-runtime-send.test.ts b/src/renderer/src/components/native-chat/native-chat-runtime-send.test.ts
index 79c28599858..9e6a8ff2b0f 100644
--- a/src/renderer/src/components/native-chat/native-chat-runtime-send.test.ts
+++ b/src/renderer/src/components/native-chat/native-chat-runtime-send.test.ts
@@ -19,9 +19,9 @@ import {
   resetNativeChatPtySendQueuesForTests,
   NATIVE_CHAT_SUBMIT_DELAY_MS,
   NATIVE_CHAT_QUESTION_STEP_MS,
-  NATIVE_CHAT_ADVANCE_BUFFER_MS,
-  NATIVE_CHAT_CLEAR_UNSUBMITTED_INPUT
+  NATIVE_CHAT_ADVANCE_BUFFER_MS
 } from './native-chat-runtime-send'
+import { NATIVE_CHAT_CLEAR_UNSUBMITTED_INPUT } from './native-chat-input-clear'
 import {
   NATIVE_CHAT_IMAGE_ATTACHMENT_SETTLE_MS,
   sendNativeChatMessageWithImageAttachments
diff --git a/src/renderer/src/components/native-chat/native-chat-runtime-send.ts b/src/renderer/src/components/native-chat/native-chat-runtime-send.ts
index 1eb7a676103..7187148ed41 100644
--- a/src/renderer/src/components/native-chat/native-chat-runtime-send.ts
+++ b/src/renderer/src/components/native-chat/native-chat-runtime-send.ts
@@ -2,13 +2,19 @@
 // body, then Enter as a SEPARATE delayed pty write. Kept apart from the pure
 // byte builders in native-chat-send.ts so those stay IO-free and unit-testable.
 
+import { sendNativeChatObservedWrites } from './native-chat-observed-send'
 import {
   sendRuntimePtyInput,
   sendRuntimePtyInputVerified
 } from '@/runtime/runtime-terminal-inspection'
 import type { getSettingsForAgentTabRuntimeOwner } from '@/lib/agent-paste-draft'
 import type { AskAnswerKeyGroup } from './native-chat-interactive-prompt'
-import { AGENT_TUI_CLEAR_INPUT_MAX } from '../../../../shared/agent-tui-input-clear'
+import {
+  clearConfirmDurationMs,
+  clearThenWrite,
+  clearUnsubmittedAgentInput,
+  type NativeChatSendOptions
+} from './native-chat-input-clear'
 import {
   NATIVE_CHAT_ADVANCE_BUFFER_MS,
   NATIVE_CHAT_QUESTION_STEP_MS,
@@ -29,32 +35,6 @@ import {
 export { NATIVE_CHAT_ADVANCE_BUFFER_MS, NATIVE_CHAT_QUESTION_STEP_MS, NATIVE_CHAT_SUBMIT_DELAY_MS }
 export { resetNativeChatPtySendQueuesForTests }
 
-// Why: agent TUI composers treat Ctrl+U as kill-to-start-of-line. Chat sends
-// start from an empty line so a prior cancelled paste cannot glue onto the next
-// prompt. Not used on verified option commands — model-switch confirmation
-// observes the PTY and Ctrl+U can miss confirmation markers.
-//
-// One Ctrl+U only ever clears ONE logical line. When the line may hold an
-// injected multi-line launch draft, callers pass `clearInput` built by
-// buildAgentTuiClearInputForText — see agent-tui-input-clear.ts for the measured
-// 2N-1 law and the sequences that do NOT work.
-export const NATIVE_CHAT_CLEAR_UNSUBMITTED_INPUT = '\x15'
-
-/** Gap before re-reading the agent's input line to confirm a clear landed. */
-export const NATIVE_CHAT_CLEAR_CONFIRM_MS = 140
-
-export type NativeChatSendOptions = {
-  /** Bytes that empty the agent's input line. Defaults to a single Ctrl+U. */
-  clearInput?: string
-  /**
-   * Observed check that the input line is now empty.
-   * Supplied only for launch-draft replacement; when it reports "not cleared"
-   * the send widens to a maximal burst before writing the body rather than
-   * pasting on top of residue.
-   */
-  confirmCleared?: () => boolean
-}
-
 /** Cancels an in-flight send's pending pty writes (the delayed Enter, and any
  *  later question bodies/Enters). Safe to call after the send completes. */
 export type NativeChatSendHandle = {
@@ -67,59 +47,6 @@ export type NativeChatSendHandle = {
 
 type RuntimeSettings = ReturnType<typeof getSettingsForAgentTabRuntimeOwner>
 
-export function clearUnsubmittedAgentInput(
-  settings: RuntimeSettings,
-  ptyId: string,
-  options?: NativeChatSendOptions
-): void {
-  sendRuntimePtyInput(
-    settings,
-    ptyId,
-    options?.clearInput ?? NATIVE_CHAT_CLEAR_UNSUBMITTED_INPUT,
-    'driving'
-  )
-}
-
-/**
- * Run `writeBody` once the input line is clear. With no `confirmCleared` the
- * clear is a plain in-order write on the same byte stream, so the TUI consumes
- * it before the body and the body follows immediately. With one, we pause to
- * actually look at the agent's input line, and widen to a maximal burst when the
- * draft is still visible — the injected line count is only a lower bound on what
- * the buffer holds, since the user can type into the TUI directly.
- */
-export function clearThenWrite(
-  settings: RuntimeSettings,
-  ptyId: string,
-  options: NativeChatSendOptions | undefined,
-  delay: (ms: number, fn: () => void) => void,
-  writeBody: () => void
-): void {
-  clearUnsubmittedAgentInput(settings, ptyId, options)
-  const confirmCleared = options?.confirmCleared
-  if (!confirmCleared) {
-    writeBody()
-    return
-  }
-  delay(NATIVE_CHAT_CLEAR_CONFIRM_MS, () => {
-    let cleared = false
-    try {
-      cleared = confirmCleared()
-    } catch {
-      // An unreadable terminal is unconfirmed; the maximal clear remains safe.
-    }
-    if (!cleared) {
-      sendRuntimePtyInput(settings, ptyId, AGENT_TUI_CLEAR_INPUT_MAX, 'driving')
-    }
-    writeBody()
-  })
-}
-
-/** Extra time a send needs when it stops to confirm the clear before the body. */
-export function clearConfirmDurationMs(options?: NativeChatSendOptions): number {
-  return options?.confirmCleared ? NATIVE_CHAT_CLEAR_CONFIRM_MS : 0
-}
-
 /**
  * Chat message path:
  *   1. clear any unsubmitted TUI line
@@ -134,6 +61,17 @@ export function sendNativeChatMessage(
   text: string,
   options?: NativeChatSendOptions
 ): NativeChatSendHandle {
+  if (options?.onWriteRejected) {
+    return sendNativeChatObservedWrites(
+      settings,
+      ptyId,
+      [
+        { data: buildNativeChatPasteBytes(text), delayBeforeMs: 0 },
+        { data: NATIVE_CHAT_SUBMIT, delayBeforeMs: NATIVE_CHAT_SUBMIT_DELAY_MS }
+      ],
+      options
+    )
+  }
   return enqueueNativeChatPtySend(
     ptyId,
     NATIVE_CHAT_SUBMIT_DELAY_MS + clearConfirmDurationMs(options),
diff --git a/src/renderer/src/components/native-chat/native-chat-scrape-fallback.test.ts b/src/renderer/src/components/native-chat/native-chat-scrape-fallback.test.ts
index 60f3d03e963..7cefec22707 100644
--- a/src/renderer/src/components/native-chat/native-chat-scrape-fallback.test.ts
+++ b/src/renderer/src/components/native-chat/native-chat-scrape-fallback.test.ts
@@ -1,9 +1,5 @@
 import { describe, it, expect } from 'vitest'
-import {
-  scrapeScrollbackToMessages,
-  scrapeNativeChatSession,
-  stripScrollbackAnsi
-} from './native-chat-scrape-fallback'
+import { scrapeScrollbackToMessages, stripScrollbackAnsi } from './native-chat-scrape-fallback'
 
 const ESC = String.fromCharCode(27)
 
@@ -71,24 +67,3 @@ describe('stripScrollbackAnsi', () => {
     expect(stripScrollbackAnsi(raw)).toBe('red\nnext')
   })
 })
-
-describe('scrapeNativeChatSession', () => {
-  it('builds a ready, approximate session from non-empty scrollback', () => {
-    const { session, isApproximate } = scrapeNativeChatSession('$ ls\n\noutput here', 'claude')
-
-    expect(isApproximate).toBe(true)
-    expect(session.status).toBe('ready')
-    expect(session.sessionId).toBeNull()
-    expect(session.agent).toBe('claude')
-    expect(session.messages.length).toBeGreaterThan(0)
-    expect(session.messages.every((message) => message.source === 'scrape')).toBe(true)
-  })
-
-  it('builds an empty session from blank scrollback', () => {
-    const { session, isApproximate } = scrapeNativeChatSession('   \n  ', 'claude')
-
-    expect(isApproximate).toBe(true)
-    expect(session.status).toBe('empty')
-    expect(session.messages).toEqual([])
-  })
-})
diff --git a/src/renderer/src/components/native-chat/native-chat-scrape-fallback.ts b/src/renderer/src/components/native-chat/native-chat-scrape-fallback.ts
index c7c3825f424..ee2a5d233c7 100644
--- a/src/renderer/src/components/native-chat/native-chat-scrape-fallback.ts
+++ b/src/renderer/src/components/native-chat/native-chat-scrape-fallback.ts
@@ -6,12 +6,7 @@
 // so the assembler ranks it below transcript/hook copies of the same turn. See
 // docs/plans/2026-06-17-001-feat-native-chat-view-plan.md (U6).
 
-import type {
-  AgentType,
-  NativeChatMessage,
-  NativeChatSession
-} from '../../../../shared/native-chat-types'
-import { assembleNativeChatSession } from './native-chat-session-assembler'
+import type { NativeChatMessage } from '../../../../shared/native-chat-types'
 
 // Why: replicate (not import) the minimal ANSI/control-sequence strip used by
 // agent-session-fork-context.ts so we don't modify that file. Same three
@@ -90,36 +85,3 @@ export function scrapeScrollbackToMessages(rawScrollback: string): NativeChatMes
     source: 'scrape'
   }))
 }
-
-/** A scrape-derived session plus the always-true `isApproximate` flag the UI
- *  uses to render an "approximate view" banner. Scrape sessions can never be
- *  authoritative, so the flag is structural, not conditional. */
-export type ScrapeNativeChatSession = {
-  session: NativeChatSession
-  isApproximate: true
-}
-
-/**
- * Convenience that assembles a `NativeChatSession` from scrollback scrape.
- * Status is the assembler's derived value: 'empty' for blank scrollback,
- * 'ready' otherwise. `sessionId` is null because scrape has no provider id.
- * Reuses `assembleNativeChatSession` read-only (no edits to the assembler).
- *
- * Remote/SSH: this entry takes an already-serialized scrollback string and is
- * transport-agnostic. The caller obtains it via the runtime-appropriate API —
- * `getMainBufferSnapshot`/serializer for local panes, or the remote serialize
- * RPC (remote-runtime-terminal-multiplexer) for remote panes — so no remote
- * branch is needed inside this fallback.
- */
-export function scrapeNativeChatSession(
-  rawScrollback: string,
-  agent: AgentType
-): ScrapeNativeChatSession {
-  const messages = scrapeScrollbackToMessages(rawScrollback)
-  const session = assembleNativeChatSession({
-    sources: { scrape: messages },
-    sessionId: null,
-    agent
-  })
-  return { session, isApproximate: true }
-}
diff --git a/src/renderer/src/components/native-chat/native-chat-send.test.ts b/src/renderer/src/components/native-chat/native-chat-send.test.ts
index 98a83f123d3..747f2bb110f 100644
--- a/src/renderer/src/components/native-chat/native-chat-send.test.ts
+++ b/src/renderer/src/components/native-chat/native-chat-send.test.ts
@@ -2,7 +2,6 @@ import { describe, expect, it } from 'vitest'
 import {
   buildNativeChatImagePasteBytes,
   buildNativeChatPasteBytes,
-  buildNativeChatSendBytes,
   isMultilineDraft,
   NATIVE_CHAT_SUBMIT
 } from './native-chat-send'
@@ -60,44 +59,6 @@ describe('buildNativeChatImagePasteBytes', () => {
   })
 })
 
-describe('buildNativeChatSendBytes', () => {
-  it('single-line text sends as text + carriage return', () => {
-    expect(buildNativeChatSendBytes('hello world')).toBe('hello world\r')
-  })
-
-  it('multi-line text is bracketed-paste wrapped then submitted', () => {
-    const text = 'line one\nline two'
-    expect(buildNativeChatSendBytes(text)).toBe(`${BEGIN}line one\rline two${END}\r`)
-  })
-
-  it('treats a trailing newline as multi-line', () => {
-    expect(buildNativeChatSendBytes('a\n')).toBe(`${BEGIN}a\r${END}\r`)
-  })
-
-  it('handles CR-style line breaks as multi-line', () => {
-    expect(buildNativeChatSendBytes('a\rb')).toBe(`${BEGIN}a\rb${END}\r`)
-  })
-
-  it('sanitizes an embedded bracketed-paste end and bare ESC before framing', () => {
-    // A pasted scrollback line could carry its own `\x1b[201~` which would
-    // otherwise close the frame early and run the tail as keystrokes.
-    const malicious = 'before\nmid\x1b[201~ rm -rf /\x1b tail'
-    const bytes = buildNativeChatSendBytes(malicious)
-    // No raw ESC survives the sanitize, so the only `\x1b` bytes are the frame.
-    expect(bytes.startsWith(BEGIN)).toBe(true)
-    expect(bytes.endsWith(`${END}\r`)).toBe(true)
-    const inner = bytes.slice(BEGIN.length, bytes.length - END.length - 1)
-    expect(inner).not.toContain('\x1b')
-    expect(inner).toContain('␛[201~')
-  })
-
-  it('neutralizes a stray ESC in the single-line branch', () => {
-    const bytes = buildNativeChatSendBytes('hi\x1b there')
-    expect(bytes).toBe('hi␛ there\r')
-    expect(bytes).not.toContain('\x1b')
-  })
-})
-
 describe('isMultilineDraft', () => {
   it('is false for single-line', () => {
     expect(isMultilineDraft('one line')).toBe(false)
diff --git a/src/renderer/src/components/native-chat/native-chat-send.ts b/src/renderer/src/components/native-chat/native-chat-send.ts
index bcb1be8238a..b121e430222 100644
--- a/src/renderer/src/components/native-chat/native-chat-send.ts
+++ b/src/renderer/src/components/native-chat/native-chat-send.ts
@@ -45,16 +45,3 @@ export function buildNativeChatPasteBytes(text: string): string {
 export function buildNativeChatImagePasteBytes(filePath: string): string {
   return wrapTerminalBracketedPasteText(filePath)
 }
-
-/**
- * Compute the bytes to write for `text` + Enter in ONE write:
- *  - single-line → `text\r`
- *  - multi-line  → `\x1b[200~…\x1b[201~\r` (bracketed-paste wrapped, then submit)
- *
- * Prefer `buildNativeChatPasteBytes` + a separate `NATIVE_CHAT_SUBMIT` write for
- * live sends; this combined form is kept for callers/tests that need the framed
- * body and submit as a single string.
- */
-export function buildNativeChatSendBytes(text: string): string {
-  return `${buildNativeChatPasteBytes(text)}${SUBMIT}`
-}
diff --git a/src/renderer/src/components/native-chat/native-chat-typing-redirect.test.ts b/src/renderer/src/components/native-chat/native-chat-typing-redirect.test.ts
index aee70c07380..b2e7f80b726 100644
--- a/src/renderer/src/components/native-chat/native-chat-typing-redirect.test.ts
+++ b/src/renderer/src/components/native-chat/native-chat-typing-redirect.test.ts
@@ -1,6 +1,7 @@
 import { describe, expect, it } from 'vitest'
 import {
   shouldFocusNativeChatComposerFromEditingKey,
+  shouldFocusNativeChatInputForPaste,
   shouldFocusNativeChatPaneFromPointerTarget,
   shouldRedirectNativeChatTyping
 } from './native-chat-typing-redirect'
@@ -96,3 +97,44 @@ describe('shouldFocusNativeChatPaneFromPointerTarget', () => {
     expect(shouldFocusNativeChatPaneFromPointerTarget(interactiveTarget())).toBe(false)
   })
 })
+
+describe('shouldFocusNativeChatInputForPaste', () => {
+  it.each([
+    [true, { key: 'v', metaKey: true }],
+    [false, { key: 'v', ctrlKey: true }],
+    [false, { key: 'V', ctrlKey: true, shiftKey: true }],
+    [false, { key: 'Insert', shiftKey: true }]
+  ])('takes the platform paste chord (mac=%s) outside an input', (isMac, keys) => {
+    expect(shouldFocusNativeChatInputForPaste(keyEvent(keys), isMac)).toBe(true)
+  })
+
+  it('ignores the other platform chord, Alt chords, IME, handled events and inputs', () => {
+    expect(shouldFocusNativeChatInputForPaste(keyEvent({ key: 'v', ctrlKey: true }), true)).toBe(
+      false
+    )
+    expect(shouldFocusNativeChatInputForPaste(keyEvent({ key: 'v', metaKey: true }), false)).toBe(
+      false
+    )
+    expect(
+      shouldFocusNativeChatInputForPaste(keyEvent({ key: 'v', ctrlKey: true, altKey: true }), false)
+    ).toBe(false)
+    expect(
+      shouldFocusNativeChatInputForPaste(
+        keyEvent({ key: 'v', ctrlKey: true, isComposing: true }),
+        false
+      )
+    ).toBe(false)
+    expect(
+      shouldFocusNativeChatInputForPaste(
+        keyEvent({ key: 'v', ctrlKey: true, defaultPrevented: true }),
+        false
+      )
+    ).toBe(false)
+    expect(
+      shouldFocusNativeChatInputForPaste(
+        keyEvent({ key: 'v', ctrlKey: true, target: interactiveTarget() }),
+        false
+      )
+    ).toBe(false)
+  })
+})
diff --git a/src/renderer/src/components/native-chat/native-chat-typing-redirect.ts b/src/renderer/src/components/native-chat/native-chat-typing-redirect.ts
index 4e4eaaedf2e..2a47c1669a7 100644
--- a/src/renderer/src/components/native-chat/native-chat-typing-redirect.ts
+++ b/src/renderer/src/components/native-chat/native-chat-typing-redirect.ts
@@ -1,4 +1,4 @@
-type KeyboardRedirectEvent = {
+export type KeyboardRedirectEvent = {
   key: string
   ctrlKey: boolean
   metaKey: boolean
@@ -65,6 +65,22 @@ export function shouldFocusNativeChatComposerFromEditingKey(event: KeyboardRedir
   return !isNativeChatInteractiveTarget(event.target)
 }
 
+/** The platform paste chord pressed outside any input: the caller focuses an
+ *  input first so the native paste that follows lands in it. */
+export function shouldFocusNativeChatInputForPaste(
+  event: KeyboardRedirectEvent,
+  isMac: boolean
+): boolean {
+  if (event.defaultPrevented || event.isComposing || event.altKey) {
+    return false
+  }
+  const chord = isMac
+    ? event.metaKey && !event.ctrlKey && event.key.toLowerCase() === 'v'
+    : (event.ctrlKey && !event.metaKey && event.key.toLowerCase() === 'v') ||
+      (event.shiftKey === true && !event.ctrlKey && !event.metaKey && event.key === 'Insert')
+  return chord && !isNativeChatInteractiveTarget(event.target)
+}
+
 function isNativeChatInteractiveTarget(target: EventTarget | null): boolean {
   const element = eventTargetElement(target)
   if (!element) {
diff --git a/src/renderer/src/components/native-chat/use-native-chat-composer-handle.ts b/src/renderer/src/components/native-chat/use-native-chat-composer-handle.ts
new file mode 100644
index 00000000000..fb7a704d655
--- /dev/null
+++ b/src/renderer/src/components/native-chat/use-native-chat-composer-handle.ts
@@ -0,0 +1,41 @@
+import { useImperativeHandle, type ForwardedRef } from 'react'
+import type { ClipboardEventLike } from './native-chat-clipboard-payload'
+import type { NativeChatComposerHandle } from './native-chat-composer-types'
+import {
+  useNativeChatComposerPaste,
+  type UseNativeChatComposerPasteArgs
+} from './use-native-chat-composer-paste'
+import { useNativeChatTypedInsertion } from './use-native-chat-typed-insertion'
+
+type UseNativeChatComposerHandleArgs = Parameters<typeof useNativeChatTypedInsertion>[0] &
+  Omit<UseNativeChatComposerPasteArgs, 'insertTypedText'>
+
+/** Typed and pasted insertion for the composer, exposed on the handle the chat
+ *  root uses to route keystrokes and pastes into it. Returns the paste handler. */
+export function useNativeChatComposerHandle(
+  ref: ForwardedRef<NativeChatComposerHandle>,
+  args: UseNativeChatComposerHandleArgs
+): (event: ClipboardEventLike) => void {
+  const { textareaRef, draft, setDraft, setHistory, setActiveSuggestion, ...pasteArgs } = args
+  const { insertTypedText, insertPastedText, focus, contains } = useNativeChatTypedInsertion({
+    textareaRef,
+    caret: args.caret,
+    draft,
+    setDraft,
+    setCaret: args.setCaret,
+    setHistory,
+    setActiveSuggestion
+  })
+
+  const { handlePaste: handlePasteEvent, pasteFromClipboard } = useNativeChatComposerPaste({
+    ...pasteArgs,
+    insertTypedText: insertPastedText
+  })
+
+  useImperativeHandle(
+    ref,
+    () => ({ focus, insertTypedText, handlePasteEvent, pasteFromClipboard, contains }),
+    [focus, insertTypedText, handlePasteEvent, pasteFromClipboard, contains]
+  )
+  return handlePasteEvent
+}
diff --git a/src/renderer/src/components/native-chat/use-native-chat-composer-paste.test.tsx b/src/renderer/src/components/native-chat/use-native-chat-composer-paste.test.tsx
index c08ba191f4e..44c1f59c3c3 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-composer-paste.test.tsx
+++ b/src/renderer/src/components/native-chat/use-native-chat-composer-paste.test.tsx
@@ -1,5 +1,5 @@
 // @vitest-environment happy-dom
-import { afterEach, describe, expect, it, vi } from 'vitest'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { act, createElement } from 'react'
 import { createRoot, type Root } from 'react-dom/client'
 import type { NativeChatAttachmentOwner } from './native-chat-attachment-upload'
@@ -7,7 +7,9 @@ import type { NativeChatAttachmentOwner } from './native-chat-attachment-upload'
 const mocks = vi.hoisted(() => ({
   saveClipboardImageAsTempFile: vi.fn(),
   readClipboardText: vi.fn(),
-  readClipboardImageThumbnail: vi.fn()
+  readClipboardImageThumbnail: vi.fn(),
+  clipboardHasImage: vi.fn(),
+  readClipboardFilePaths: vi.fn()
 }))
 
 vi.mock('@/i18n/i18n', () => ({
@@ -29,7 +31,9 @@ vi.stubGlobal('window', {
     ui: {
       saveClipboardImageAsTempFile: mocks.saveClipboardImageAsTempFile,
       readClipboardText: mocks.readClipboardText,
-      readClipboardImageThumbnail: mocks.readClipboardImageThumbnail
+      readClipboardImageThumbnail: mocks.readClipboardImageThumbnail,
+      clipboardHasImage: mocks.clipboardHasImage,
+      readClipboardFilePaths: mocks.readClipboardFilePaths
     }
   }
 })
@@ -82,6 +86,7 @@ function createChipStore(): {
 }
 
 type ProbeArgs = {
+  targetKey?: string
   agent?: 'claude' | 'omp'
   disabled: boolean
   resolveAttachmentOwner: () => NativeChatAttachmentOwner
@@ -109,16 +114,22 @@ async function renderProbe(args: {
   store?: ReturnType<typeof createChipStore>
   insertTypedText?: (text: string) => boolean
   setNotice?: (notice: string | null) => void
-}): Promise<{ latest: () => HookApi; setDisabled: (disabled: boolean) => Promise<void> }> {
+}): Promise<{
+  latest: () => HookApi
+  setDisabled: (disabled: boolean) => Promise<void>
+  setTarget: (key: string) => Promise<void>
+}> {
   const container = document.createElement('div')
   document.body.append(container)
   const store = args.store ?? createChipStore()
   let api: HookApi | null = null
   root = createRoot(container)
+  let targetKey = 'session-1'
   const render = async (disabled: boolean): Promise<void> => {
     await act(async () => {
       root?.render(
         createElement(Probe, {
+          targetKey,
           agent: args.agent ?? 'claude',
           disabled,
           resolveAttachmentOwner: args.resolveAttachmentOwner,
@@ -143,24 +154,32 @@ async function renderProbe(args: {
       }
       return api
     },
-    setDisabled: render
+    setDisabled: render,
+    setTarget: async (key) => {
+      targetKey = key
+      await render(false)
+    }
   }
 }
 
-function imagePasteEvent(): {
-  clipboardData: DataTransfer
-  preventDefault: () => void
-  defaultPrevented: boolean
-} {
-  return {
-    clipboardData: {
-      items: [{ type: 'image/png', getAsFile: () => new Blob([], { type: 'image/png' }) }]
-    } as unknown as DataTransfer,
-    preventDefault: vi.fn(),
-    defaultPrevented: false
+function imagePasteEvent(text = ''): ClipboardEvent {
+  const data = new DataTransfer()
+  data.items.add(new File(['image'], 'image.png', { type: 'image/png' }))
+  if (text) {
+    data.setData('text/plain', text)
   }
+  return new ClipboardEvent('paste', { clipboardData: data, cancelable: true })
 }
 
+beforeEach(() => {
+  vi.resetAllMocks()
+  mocks.readClipboardText.mockResolvedValue('')
+  mocks.readClipboardImageThumbnail.mockResolvedValue(null)
+  mocks.clipboardHasImage.mockResolvedValue(false)
+  mocks.readClipboardFilePaths.mockResolvedValue([])
+  mocks.saveClipboardImageAsTempFile.mockResolvedValue(null)
+})
+
 const sshOwner: NativeChatAttachmentOwner = {
   kind: 'ssh',
   connectionId: 'conn-1',
@@ -178,6 +197,7 @@ afterEach(() => {
 
 describe('useNativeChatComposerPaste', () => {
   it('does not save a clipboard image locally for a remote runtime', async () => {
+    mocks.clipboardHasImage.mockResolvedValue(true)
     const setNotice = vi.fn()
     const store = createChipStore()
     const probe = await renderProbe({
@@ -375,9 +395,10 @@ describe('useNativeChatComposerPaste', () => {
     expect(attachResolvedPaths).toHaveBeenCalledWith(['C:\\Temp\\orca-paste-3.png'], null)
   })
 
-  it('stops pasteFromClipboard on a failed save instead of falling through to text', async () => {
+  it('inserts text independently of a failed image save', async () => {
     mocks.readClipboardImageThumbnail.mockResolvedValue(null)
     mocks.saveClipboardImageAsTempFile.mockRejectedValue(new Error('sftp down'))
+    mocks.readClipboardText.mockResolvedValue('안녕하세요')
     const insertTypedText = vi.fn()
     const setNotice = vi.fn()
     const probe = await renderProbe({
@@ -389,8 +410,7 @@ describe('useNativeChatComposerPaste', () => {
       probe.latest().pasteFromClipboard()
     })
     expect(setNotice).toHaveBeenCalledWith('sftp down')
-    expect(mocks.readClipboardText).not.toHaveBeenCalled()
-    expect(insertTypedText).not.toHaveBeenCalled()
+    expect(insertTypedText).toHaveBeenCalledWith('안녕하세요')
   })
 
   it('still falls through to text when the clipboard holds no image', async () => {
@@ -452,3 +472,370 @@ describe('useNativeChatComposerPaste', () => {
     expect(setNotice.mock.calls.every(([notice]) => notice === null)).toBe(true)
   })
 })
+
+describe('composer paste intake regressions', () => {
+  it.each(['local', 'ssh', 'runtime', 'not-ready'] as const)(
+    'inserts text without waiting for an image operation on %s',
+    async (kind) => {
+      mocks.readClipboardText.mockResolvedValue('안녕하세요\nhello')
+      mocks.saveClipboardImageAsTempFile.mockReturnValue(new Promise(() => {}))
+      mocks.clipboardHasImage.mockReturnValue(new Promise(() => {}))
+      const insertTypedText = vi.fn(() => true)
+      const setNotice = vi.fn()
+      const probe = await renderProbe({
+        resolveAttachmentOwner: () => (kind === 'ssh' ? sshOwner : { kind }),
+        insertTypedText,
+        setNotice
+      })
+      await act(async () => probe.latest().pasteFromClipboard())
+      expect(insertTypedText).toHaveBeenCalledExactlyOnceWith('안녕하세요\nhello')
+      expect(setNotice.mock.calls.filter(([notice]) => notice !== null)).toHaveLength(0)
+      if (kind === 'runtime' || kind === 'not-ready') {
+        expect(mocks.saveClipboardImageAsTempFile).not.toHaveBeenCalled()
+      }
+    }
+  )
+
+  it.each([false, true, null, 'error'] as const)(
+    'preserves remote text when image presence is %s',
+    async (presence) => {
+      if (presence === 'error') {
+        mocks.clipboardHasImage.mockRejectedValue(new Error('denied'))
+      } else {
+        mocks.clipboardHasImage.mockResolvedValue(presence)
+      }
+      mocks.readClipboardText.mockResolvedValue('hello')
+      const insertTypedText = vi.fn(() => true)
+      const setNotice = vi.fn()
+      const probe = await renderProbe({
+        resolveAttachmentOwner: () => ({ kind: 'runtime' }),
+        insertTypedText,
+        setNotice
+      })
+      await act(async () => probe.latest().pasteFromClipboard())
+      expect(insertTypedText).toHaveBeenCalledExactlyOnceWith('hello')
+      // Text wins: no second (browser-prompting) clipboard read and no refusal beside the text.
+      expect(mocks.clipboardHasImage).not.toHaveBeenCalled()
+      expect(setNotice.mock.calls.filter(([notice]) => notice !== null)).toHaveLength(0)
+    }
+  )
+
+  it.each(['runtime', 'not-ready'] as const)(
+    'still explains an image-only menu paste on %s',
+    async (kind) => {
+      mocks.clipboardHasImage.mockResolvedValue(true)
+      const setNotice = vi.fn()
+      const probe = await renderProbe({ resolveAttachmentOwner: () => ({ kind }), setNotice })
+      await act(async () => probe.latest().pasteFromClipboard())
+      expect(mocks.clipboardHasImage).toHaveBeenCalledTimes(1)
+      expect(setNotice.mock.calls.filter(([notice]) => notice !== null)).toHaveLength(1)
+    }
+  )
+
+  it.each(['local', 'ssh', 'runtime', 'not-ready'] as const)(
+    'preserves mixed event text with %s attachments and deduplicates capture',
+    async (kind) => {
+      const insertTypedText = vi.fn(() => true)
+      const setNotice = vi.fn()
+      const probe = await renderProbe({
+        resolveAttachmentOwner: () => (kind === 'ssh' ? sshOwner : { kind }),
+        insertTypedText,
+        setNotice
+      })
+      const event = imagePasteEvent('caption')
+      await act(async () => {
+        probe.latest().handlePaste(event)
+        probe.latest().handlePaste(event)
+      })
+      expect(insertTypedText).toHaveBeenCalledExactlyOnceWith('caption')
+      expect(mocks.readClipboardText).not.toHaveBeenCalled()
+      expect(setNotice.mock.calls.filter(([notice]) => notice !== null)).toHaveLength(0)
+    }
+  )
+
+  it.each(['unmount', 'replace', 'disable'] as const)(
+    'drops late text and pending images after target %s',
+    async (change) => {
+      let finishText = (_text: string): void => {}
+      let finishImage = (_path: string): void => {}
+      mocks.readClipboardText.mockReturnValue(
+        new Promise<string>((resolve) => {
+          finishText = resolve
+        })
+      )
+      mocks.saveClipboardImageAsTempFile.mockReturnValue(
+        new Promise<string>((resolve) => {
+          finishImage = resolve
+        })
+      )
+      mocks.readClipboardImageThumbnail.mockResolvedValue({
+        dataUrl: 'data:image/png;base64,AA',
+        width: 1,
+        height: 1
+      })
+      const store = createChipStore()
+      const insertTypedText = vi.fn(() => true)
+      const probe = await renderProbe({
+        resolveAttachmentOwner: () => ({ kind: 'local' }),
+        insertTypedText,
+        store
+      })
+      await act(async () => probe.latest().pasteFromClipboard())
+      expect(store.chips).toHaveLength(1)
+      if (change === 'unmount') {
+        await act(async () => {
+          root?.unmount()
+          root = null
+        })
+      } else if (change === 'replace') {
+        await probe.setTarget('session-2')
+      } else {
+        await probe.setDisabled(true)
+      }
+      await act(async () => {
+        finishText('stale')
+        finishImage('/tmp/stale.png')
+      })
+      expect(insertTypedText).not.toHaveBeenCalled()
+      expect(store.chips).toHaveLength(0)
+    }
+  )
+
+  it('rejects an image saved across SSH connection replacement', async () => {
+    let owner = sshOwner
+    let finish = (_path: string): void => {}
+    mocks.saveClipboardImageAsTempFile.mockReturnValue(
+      new Promise<string>((resolve) => {
+        finish = resolve
+      })
+    )
+    const store = createChipStore()
+    const probe = await renderProbe({ resolveAttachmentOwner: () => owner, store })
+    await act(async () => probe.latest().handlePaste(imagePasteEvent()))
+    owner = { ...sshOwner, expectedSshConnectionGeneration: 5 }
+    await act(async () => finish('/tmp/old-host.png'))
+    expect(store.chips).toHaveLength(0)
+  })
+})
+
+it('inserts event text locally without any clipboard API access', async () => {
+  const insertTypedText = vi.fn(() => true)
+  const probe = await renderProbe({
+    resolveAttachmentOwner: () => ({ kind: 'runtime' }),
+    insertTypedText
+  })
+  const data = new DataTransfer()
+  data.setData('text/plain', '한글\nplain')
+  const event = new ClipboardEvent('paste', { clipboardData: data, cancelable: true })
+  await act(async () => probe.latest().handlePaste(event))
+  expect(insertTypedText).toHaveBeenCalledExactlyOnceWith('한글\nplain')
+  expect(event.defaultPrevented).toBe(true)
+  expect(mocks.readClipboardText).not.toHaveBeenCalled()
+  expect(mocks.clipboardHasImage).not.toHaveBeenCalled()
+  expect(mocks.saveClipboardImageAsTempFile).not.toHaveBeenCalled()
+})
+
+it('refuses oversized event text without inserting it', async () => {
+  const insertTypedText = vi.fn(() => true)
+  const setNotice = vi.fn()
+  const probe = await renderProbe({
+    resolveAttachmentOwner: () => ({ kind: 'runtime' }),
+    insertTypedText,
+    setNotice
+  })
+  const data = new DataTransfer()
+  data.setData('text/plain', 'x'.repeat(1025))
+  await act(async () =>
+    probe
+      .latest()
+      .handlePaste(new ClipboardEvent('paste', { clipboardData: data, cancelable: true }))
+  )
+  expect(insertTypedText).not.toHaveBeenCalled()
+  expect(setNotice).toHaveBeenCalledWith(expect.stringContaining('too large'))
+})
+
+describe('pastes the composer cannot take', () => {
+  const REFUSAL = "Can't paste — this chat isn't accepting input right now."
+
+  it.each(['event', 'menu'] as const)(
+    'explains a %s paste into a disabled composer',
+    async (source) => {
+      const insertTypedText = vi.fn(() => true)
+      const setNotice = vi.fn()
+      mocks.readClipboardText.mockResolvedValue('hello')
+      const probe = await renderProbe({
+        disabled: true,
+        resolveAttachmentOwner: () => ({ kind: 'local' }),
+        insertTypedText,
+        setNotice
+      })
+      await act(async () => {
+        if (source === 'event') {
+          const data = new DataTransfer()
+          data.setData('text/plain', 'hello')
+          probe
+            .latest()
+            .handlePaste(new ClipboardEvent('paste', { clipboardData: data, cancelable: true }))
+        } else {
+          probe.latest().pasteFromClipboard()
+        }
+      })
+      expect(insertTypedText).not.toHaveBeenCalled()
+      expect(mocks.readClipboardText).not.toHaveBeenCalled()
+      expect(setNotice).toHaveBeenCalledWith(REFUSAL)
+    }
+  )
+
+  it('explains text the composer input could not accept', async () => {
+    const setNotice = vi.fn()
+    mocks.readClipboardText.mockResolvedValue('hello')
+    const probe = await renderProbe({
+      resolveAttachmentOwner: () => ({ kind: 'local' }),
+      insertTypedText: () => false,
+      setNotice
+    })
+    await act(async () => probe.latest().pasteFromClipboard())
+    expect(setNotice).toHaveBeenLastCalledWith(REFUSAL)
+  })
+})
+
+describe('file-manager copies', () => {
+  function fileCopyEvent(files: File[], text: string): ClipboardEvent {
+    const data = new DataTransfer()
+    for (const file of files) {
+      data.items.add(file)
+    }
+    data.setData('text/plain', text)
+    return new ClipboardEvent('paste', { clipboardData: data, cancelable: true })
+  }
+  const png = (name: string): File => new File(['image'], name, { type: 'image/png' })
+
+  it.each([
+    ['a single file', [png('shot.png')], 'shot.png'],
+    [
+      'several files',
+      [png('a.png'), new File(['pdf'], 'b.pdf', { type: 'application/pdf' })],
+      'a.png\nb.pdf'
+    ],
+    ['a file label with a trailing newline', [png('shot.png')], 'shot.png\r\n']
+  ])('attaches %s without inserting its name', async (_label, files, text) => {
+    mocks.saveClipboardImageAsTempFile.mockResolvedValue('/tmp/shot.png')
+    const insertTypedText = vi.fn(() => true)
+    const store = createChipStore()
+    const probe = await renderProbe({
+      resolveAttachmentOwner: () => ({ kind: 'local' }),
+      insertTypedText,
+      store
+    })
+    await act(async () => probe.latest().handlePaste(fileCopyEvent(files, text)))
+    expect(insertTypedText).not.toHaveBeenCalled()
+    expect(store.chips).toEqual([
+      expect.objectContaining({ path: '/tmp/shot.png', pending: false })
+    ])
+  })
+
+  it.each([
+    ['rich text with an image rendition', [png('image.png')], 'Quarterly numbers'],
+    [
+      'a non-image file, which is not attached',
+      [new File(['pdf'], 'b.pdf', { type: 'application/pdf' })],
+      'b.pdf'
+    ]
+  ])('still inserts the text of %s', async (_label, files, text) => {
+    const insertTypedText = vi.fn(() => true)
+    const probe = await renderProbe({
+      resolveAttachmentOwner: () => ({ kind: 'local' }),
+      insertTypedText
+    })
+    await act(async () => probe.latest().handlePaste(fileCopyEvent(files, text)))
+    expect(insertTypedText).toHaveBeenCalledExactlyOnceWith(text)
+  })
+
+  it.each([
+    ['a path', '/home/me/shot.png'],
+    ['a file URL', 'file:///home/me/my%20shot.png']
+  ])('attaches a Linux file manager copy labelled by %s without typing it', async (_l, text) => {
+    mocks.saveClipboardImageAsTempFile.mockResolvedValue('/tmp/shot.png')
+    const insertTypedText = vi.fn(() => true)
+    const probe = await renderProbe({
+      resolveAttachmentOwner: () => ({ kind: 'local' }),
+      insertTypedText
+    })
+    const name = text.includes('my%20') ? 'my shot.png' : 'shot.png'
+    await act(async () => probe.latest().handlePaste(fileCopyEvent([png(name)], text)))
+    expect(insertTypedText).not.toHaveBeenCalled()
+  })
+
+  describe('from the app menu (macOS Cmd+V)', () => {
+    it.each([
+      ['a single file', 'shot.png', ['/Users/me/Desktop/shot.png']],
+      ['several files', 'a.png\rb.pdf', ['/Users/me/a.png', '/Users/me/b.pdf']]
+    ])('attaches %s without typing the Finder label', async (_label, text, paths) => {
+      mocks.readClipboardText.mockResolvedValue(text)
+      mocks.readClipboardFilePaths.mockResolvedValue(paths)
+      mocks.saveClipboardImageAsTempFile.mockResolvedValue('/tmp/shot.png')
+      const insertTypedText = vi.fn(() => true)
+      const attachResolvedPaths = vi.fn()
+      const probe = await renderProbe({
+        resolveAttachmentOwner: () => ({ kind: 'local' }),
+        insertTypedText,
+        attachResolvedPaths
+      })
+      await act(async () => probe.latest().pasteFromClipboard())
+      expect(insertTypedText).not.toHaveBeenCalled()
+      expect(attachResolvedPaths).toHaveBeenCalledExactlyOnceWith(['/tmp/shot.png'], null)
+    })
+
+    it('types the label when no image came with the files', async () => {
+      mocks.readClipboardText.mockResolvedValue('notes.txt')
+      mocks.readClipboardFilePaths.mockResolvedValue(['/Users/me/notes.txt'])
+      const insertTypedText = vi.fn(() => true)
+      const probe = await renderProbe({
+        resolveAttachmentOwner: () => sshOwner,
+        insertTypedText
+      })
+      await act(async () => probe.latest().pasteFromClipboard())
+      expect(insertTypedText).toHaveBeenCalledExactlyOnceWith('notes.txt')
+    })
+
+    it('types unrelated text at once, and when the file list cannot be read', async () => {
+      mocks.readClipboardText.mockResolvedValue('see attached')
+      mocks.readClipboardFilePaths.mockResolvedValue(['/Users/me/shot.png'])
+      mocks.saveClipboardImageAsTempFile.mockReturnValue(new Promise(() => {}))
+      const insertTypedText = vi.fn(() => true)
+      const probe = await renderProbe({
+        resolveAttachmentOwner: () => ({ kind: 'local' }),
+        insertTypedText
+      })
+      await act(async () => probe.latest().pasteFromClipboard())
+      expect(insertTypedText).toHaveBeenCalledExactlyOnceWith('see attached')
+
+      mocks.readClipboardText.mockResolvedValue('shot.png')
+      mocks.readClipboardFilePaths.mockRejectedValue(new Error('unavailable'))
+      await act(async () => probe.latest().pasteFromClipboard())
+      expect(insertTypedText).toHaveBeenLastCalledWith('shot.png')
+    })
+
+    it.each([
+      [true, 0, 1],
+      [false, 1, 0]
+    ])(
+      'on a remote runtime, image presence %s decides between the refusal and the label',
+      async (hasImage, inserts, notices) => {
+        mocks.readClipboardText.mockResolvedValue('shot.png')
+        mocks.readClipboardFilePaths.mockResolvedValue(['/Users/me/shot.png'])
+        mocks.clipboardHasImage.mockResolvedValue(hasImage)
+        const insertTypedText = vi.fn(() => true)
+        const setNotice = vi.fn()
+        const probe = await renderProbe({
+          resolveAttachmentOwner: () => ({ kind: 'runtime' }),
+          insertTypedText,
+          setNotice
+        })
+        await act(async () => probe.latest().pasteFromClipboard())
+        expect(insertTypedText).toHaveBeenCalledTimes(inserts)
+        expect(setNotice.mock.calls.filter(([notice]) => notice !== null)).toHaveLength(notices)
+      }
+    )
+  })
+})
diff --git a/src/renderer/src/components/native-chat/use-native-chat-composer-paste.ts b/src/renderer/src/components/native-chat/use-native-chat-composer-paste.ts
index 09b0004334c..6899ee76905 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-composer-paste.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-composer-paste.ts
@@ -1,8 +1,17 @@
-import { useCallback, useRef } from 'react'
+import { useCallback, useLayoutEffect, useMemo, useRef } from 'react'
+import { nativeChatAttachmentOwnerUnchanged } from './native-chat-resolved-path-ownership'
+import { assertClipboardTextWithinLimit } from '../../../../shared/clipboard-text'
 import { translate } from '@/i18n/i18n'
 import { extractIpcErrorMessage } from '@/lib/ipc-error'
 import type { AgentType } from '../../../../shared/agent-status-types'
 import { NATIVE_CHAT_CONTEXT_PASTE_MAX_BYTES } from './native-chat-composer-target'
+import { nativeChatPasteUnavailableNotice } from '@/lib/native-chat-paste-request'
+import {
+  clipboardEventImageFile,
+  clipboardEventPromptText,
+  readClipboardPasteText,
+  type ClipboardEventLike
+} from './native-chat-clipboard-payload'
 import {
   nativeChatLocalAttachmentUnsupportedNotice,
   nativeChatWorktreeNotReadyNotice,
@@ -10,6 +19,7 @@ import {
 } from './native-chat-attachment-upload'
 
 export type UseNativeChatComposerPasteArgs = {
+  targetKey?: string
   agent: AgentType
   /** Live composer-disabled state (no pty / presence-lock); read at await-resume
    *  via a ref so a flip mid-paste doesn't write into a guarded composer. */
@@ -27,23 +37,6 @@ export type UseNativeChatComposerPasteArgs = {
   setNotice: (notice: string | null) => void
 }
 
-/** Minimal shape shared by React's synthetic ClipboardEvent and the native DOM
- *  ClipboardEvent — the pane-level listener delivers the native one. */
-type ClipboardEventLike = {
-  clipboardData: DataTransfer | null
-  preventDefault: () => void
-  defaultPrevented: boolean
-}
-
-function clipboardEventImageFile(event: ClipboardEventLike): File | null {
-  const data = event.clipboardData
-  if (!data) {
-    return null
-  }
-  const item = Array.from(data.items).find((candidate) => candidate.type.startsWith('image/'))
-  return item?.getAsFile() ?? null
-}
-
 /** Owners whose attachment path is a file this client can write right now. */
 function ownerAcceptsClipboardImage(
   owner: NativeChatAttachmentOwner
@@ -51,39 +44,8 @@ function ownerAcceptsClipboardImage(
   return owner.kind === 'local' || owner.kind === 'ssh'
 }
 
-function ownerConnectionId(owner: NativeChatAttachmentOwner): string | null {
-  return owner.kind === 'ssh' ? owner.connectionId : null
-}
-
-/** A save can outlive a worktree/connection switch; never settle its path into
- * a composer whose backing host changed while the clipboard was in flight. */
-function attachmentOwnerStillMatches(
-  original: NativeChatAttachmentOwner,
-  current: NativeChatAttachmentOwner
-): boolean {
-  if (original.kind !== current.kind) {
-    return false
-  }
-  if (original.kind !== 'ssh') {
-    return true
-  }
-  return current.kind === 'ssh' && original.connectionId === current.connectionId
-}
-
-/**
- * Clipboard-paste behavior for the native chat composer: a clipboard image
- * becomes an attachment (TUI parity), otherwise text is inserted at the caret.
- * `handlePaste` consumes a paste event (the textarea's onPaste *or* the
- * pane-level capture listener — the OS often retargets the event off the
- * focused textarea, so the pane listener is the reliable path);
- * `pasteFromClipboard` is the menu-driven path with no event in hand (on macOS
- * Cmd+V is routed here, so it must feel just as immediate).
- *
- * Both paths show a pending attachment chip before the image is saved: writing
- * the file (or uploading it over SFTP) takes long enough that silence reads as
- * a dropped paste and invites duplicate pastes.
- */
 export function useNativeChatComposerPaste({
+  targetKey,
   disabled,
   caret,
   resolveAttachmentOwner,
@@ -98,14 +60,38 @@ export function useNativeChatComposerPaste({
   handlePaste: (event: ClipboardEventLike) => void
   pasteFromClipboard: () => void
 } {
-  // Re-read the live disabled state after the async clipboard round-trip:
-  // `canSend` can flip (mobile presence-lock) or the pty drop out mid-await, and
-  // the captured closure would otherwise attach/insert into a guarded composer.
   const disabledRef = useRef(disabled)
-  disabledRef.current = disabled
+  const dropPendingRef = useRef(dropPendingImageAttachment)
+  useLayoutEffect(() => {
+    disabledRef.current = disabled
+    dropPendingRef.current = dropPendingImageAttachment
+  }, [disabled, dropPendingImageAttachment])
+  const lifetime = useMemo(
+    () => ({ targetKey, active: false, pending: new Map<string, string>() }),
+    [targetKey]
+  )
+  useLayoutEffect(() => {
+    lifetime.active = true
+    return () => {
+      lifetime.active = false
+      for (const [id, preview] of lifetime.pending) {
+        if (preview.startsWith('blob:')) {
+          URL.revokeObjectURL(preview)
+        }
+        dropPendingRef.current(id)
+      }
+      lifetime.pending.clear()
+    }
+  }, [lifetime])
+  const canPaste = useCallback(() => lifetime.active && !disabledRef.current, [lifetime])
+  // A disabled composer still answers a paste, so it never vanishes silently.
+  const showPasteUnavailable = useCallback(() => {
+    if (lifetime.active) {
+      setNotice(nativeChatPasteUnavailableNotice())
+    }
+  }, [lifetime, setNotice])
 
-  // Distinguishes 'empty' (no image on the clipboard — text may fall through)
-  // from 'failed' (save errored — the flow must stop and say why).
+  // Image failures do not decide whether text can be inserted.
   const saveClipboardImageForOwner = useCallback(
     async (
       owner: NativeChatAttachmentOwner
@@ -124,7 +110,7 @@ export function useNativeChatComposerPaste({
       } catch (error) {
         // A failed save must be visible: over SSH it fails whenever the
         // connection drops, and a silent no-op reads as a broken paste.
-        if (!disabledRef.current) {
+        if (canPaste()) {
           setNotice(
             extractIpcErrorMessage(
               error,
@@ -135,34 +121,32 @@ export function useNativeChatComposerPaste({
         return { status: 'failed' }
       }
     },
-    [setNotice]
+    [canPaste, setNotice]
   )
 
   /** Settle the chip started at paste time, or attach directly when the paste
    *  produced no placeholder (no clipboard preview was available). */
   const settleImagePaste = useCallback(
-    (
-      pendingId: string | null,
-      path: string,
-      connectionId: string | null,
-      originalOwner: NativeChatAttachmentOwner
-    ) => {
-      if (!attachmentOwnerStillMatches(originalOwner, resolveAttachmentOwner())) {
+    (pendingId: string | null, path: string, originalOwner: NativeChatAttachmentOwner) => {
+      if (!nativeChatAttachmentOwnerUnchanged(originalOwner, resolveAttachmentOwner())) {
         if (pendingId) {
+          lifetime.pending.delete(pendingId)
           dropPendingImageAttachment(pendingId)
         }
         setNotice(nativeChatWorktreeNotReadyNotice())
         return
       }
+      const connectionId = originalOwner.kind === 'ssh' ? originalOwner.connectionId : null
       if (pendingId) {
+        lifetime.pending.delete(pendingId)
         resolvePendingImageAttachment(pendingId, path, connectionId)
       } else {
         attachResolvedPaths([path], connectionId)
       }
-      setNotice(null)
     },
     [
       attachResolvedPaths,
+      lifetime,
       dropPendingImageAttachment,
       resolveAttachmentOwner,
       resolvePendingImageAttachment,
@@ -177,16 +161,35 @@ export function useNativeChatComposerPaste({
       if (event.defaultPrevented) {
         return
       }
-      // Only an image needs interception; plain text falls through so the
-      // textarea's native paste keeps its caret/undo behavior when it is the
-      // event target. (When the OS retargets the paste off the textarea the
-      // pane listener still routes text via pasteFromClipboard.)
       const imageFile = clipboardEventImageFile(event)
-      if (!imageFile) {
+      const text = clipboardEventPromptText(event, imageFile !== null)
+      if (!imageFile && !text) {
         return
       }
       event.preventDefault()
+      if (!canPaste()) {
+        showPasteUnavailable()
+        return
+      }
+      setNotice(null)
+      if (text) {
+        try {
+          assertClipboardTextWithinLimit(text, { maxBytes: NATIVE_CHAT_CONTEXT_PASTE_MAX_BYTES })
+          if (!insertTypedText(text)) {
+            showPasteUnavailable()
+          }
+        } catch (error) {
+          setNotice(extractIpcErrorMessage(error, 'Paste failed.'))
+        }
+      }
+      if (!imageFile) {
+        return
+      }
       const owner = resolveAttachmentOwner()
+      // Rich-text copies often carry an image rendition; a refusal notice beside pasted text reads as a failed paste.
+      if (text && !ownerAcceptsClipboardImage(owner)) {
+        return
+      }
       if (owner.kind === 'not-ready') {
         setNotice(nativeChatWorktreeNotReadyNotice())
         return
@@ -203,22 +206,32 @@ export function useNativeChatComposerPaste({
       if (previewUrl && !pendingId) {
         URL.revokeObjectURL(previewUrl)
       }
+      if (pendingId) {
+        lifetime.pending.set(pendingId, previewUrl ?? '')
+      }
       void (async () => {
         const saved = await saveClipboardImageForOwner(owner)
-        if (saved.status !== 'saved' || disabledRef.current) {
+        if (saved.status !== 'saved' || !canPaste()) {
           if (pendingId) {
+            lifetime.pending.delete(pendingId)
             dropPendingImageAttachment(pendingId)
           }
           return
         }
-        settleImagePaste(pendingId, saved.tempPath, ownerConnectionId(owner), owner)
-        setCaret(caretAtPaste)
+        settleImagePaste(pendingId, saved.tempPath, owner)
+        if (!text) {
+          setCaret(caretAtPaste)
+        }
       })()
     },
     [
       beginPendingImageAttachment,
+      canPaste,
+      lifetime,
       caret,
       dropPendingImageAttachment,
+      insertTypedText,
+      showPasteUnavailable,
       resolveAttachmentOwner,
       saveClipboardImageForOwner,
       setCaret,
@@ -228,57 +241,81 @@ export function useNativeChatComposerPaste({
   )
 
   const pasteFromClipboard = useCallback(() => {
+    if (!canPaste()) {
+      showPasteUnavailable()
+      return
+    }
+    setNotice(null)
+    const insertText = (text: string): void => {
+      if (text && !(canPaste() && insertTypedText(text))) {
+        showPasteUnavailable()
+      }
+    }
+    // Text belongs to the editor even when the attachment host is unavailable.
+    // Text that only labels copied files waits for the image outcome instead.
+    const textRead = readClipboardPasteText(NATIVE_CHAT_CONTEXT_PASTE_MAX_BYTES)
+      .then((read) => {
+        if (!read.labelsFiles) {
+          insertText(read.text)
+        }
+        return read
+      })
+      .catch((error) => {
+        if (canPaste()) {
+          setNotice(extractIpcErrorMessage(error, 'Paste failed.'))
+        }
+        return null
+      })
     void (async () => {
       const owner = resolveAttachmentOwner()
-      // not-ready still saves locally: with no event in hand this is the only
-      // way to LEARN whether the clipboard holds an image. An image then gets
-      // the not-ready notice (never a local-path attach for a possibly-remote
-      // worktree); plain text falls through unaffected.
-      //
-      // The in-memory thumbnail probe runs alongside the save rather than before
-      // it: it answers first (it never touches disk or the network), so the chip
-      // appears while the save is still in flight and text paste stays as fast.
-      const wantsPlaceholder = ownerAcceptsClipboardImage(owner)
-      const thumbnailPromise = wantsPlaceholder
-        ? window.api.ui.readClipboardImageThumbnail().catch(() => null)
-        : Promise.resolve(null)
+      if (!ownerAcceptsClipboardImage(owner)) {
+        const read = await textRead
+        // Probe only when no text was typed: in a browser each clipboard read can prompt the user.
+        if (!read || (read.text !== '' && !read.labelsFiles)) {
+          return
+        }
+        const hasImage = await window.api.ui.clipboardHasImage().catch(() => null)
+        if (!hasImage) {
+          insertText(read.text)
+        } else if (canPaste()) {
+          setNotice(
+            owner.kind === 'runtime'
+              ? nativeChatLocalAttachmentUnsupportedNotice()
+              : nativeChatWorktreeNotReadyNotice()
+          )
+        }
+        return
+      }
+      const thumbnailPromise = window.api.ui.readClipboardImageThumbnail().catch(() => null)
       const savePromise = saveClipboardImageForOwner(owner)
       const thumbnail = await thumbnailPromise
       const pendingId =
-        thumbnail && !disabledRef.current ? beginPendingImageAttachment(thumbnail.dataUrl) : null
+        thumbnail && canPaste() ? beginPendingImageAttachment(thumbnail.dataUrl) : null
+      if (pendingId) {
+        lifetime.pending.set(pendingId, thumbnail?.dataUrl ?? '')
+      }
       const saved = await savePromise
-      if (disabledRef.current || saved.status === 'failed') {
+      if (!canPaste() || saved.status !== 'saved') {
         if (pendingId) {
+          lifetime.pending.delete(pendingId)
           dropPendingImageAttachment(pendingId)
         }
-        return
-      }
-      if (saved.status === 'saved') {
-        if (owner.kind === 'not-ready') {
-          setNotice(nativeChatWorktreeNotReadyNotice())
-          return
+        // A file's label is typed only when no image came with it.
+        const read = saved.status === 'empty' ? await textRead : null
+        if (read?.labelsFiles) {
+          insertText(read.text)
         }
-        settleImagePaste(pendingId, saved.tempPath, ownerConnectionId(owner), owner)
         return
       }
-      // Clipboard changed between the probe and the save: no image to attach.
-      if (pendingId) {
-        dropPendingImageAttachment(pendingId)
-      }
-      const text = await window.api.ui
-        .readClipboardText({ maxBytes: NATIVE_CHAT_CONTEXT_PASTE_MAX_BYTES })
-        .catch(() => '')
-      if (disabledRef.current) {
-        return
-      }
-      if (text.length > 0) {
-        insertTypedText(text)
-      }
+      settleImagePaste(pendingId, saved.tempPath, owner)
     })()
   }, [
     beginPendingImageAttachment,
+    canPaste,
+    lifetime,
     dropPendingImageAttachment,
     insertTypedText,
+    showPasteUnavailable,
     resolveAttachmentOwner,
     saveClipboardImageForOwner,
     setNotice,
diff --git a/src/renderer/src/components/native-chat/use-native-chat-paste-bridge.ts b/src/renderer/src/components/native-chat/use-native-chat-paste-bridge.ts
index e3dcc9a10c8..4ca7a3e6e97 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-paste-bridge.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-paste-bridge.ts
@@ -1,5 +1,7 @@
 import { useCallback, useEffect } from 'react'
 import type { RefObject } from 'react'
+import { isEditableTarget } from '@/lib/editable-target'
+import { NATIVE_CHAT_PASTE_REQUEST_EVENT } from '@/lib/native-chat-paste-request'
 import { APP_MENU_PASTE_EVENT } from '@/lib/app-menu-paste'
 import { pasteTextIntoTextControl, TEXT_CONTROL_PASTE_MAX_BYTES } from '@/lib/text-control-paste'
 import type { NativeChatComposerHandle } from './NativeChatComposer'
@@ -31,8 +33,11 @@ export function useNativeChatPasteBridge({
       const text = await window.api.ui
         .readClipboardText({ maxBytes: TEXT_CONTROL_PASTE_MAX_BYTES })
         .catch(() => '')
-      if (text.length > 0) {
-        await pasteTextIntoTextControl(answerInput, text, { source: 'programmatic' })
+      if (text.length > 0 && questionAnswerInputRef?.current === answerInput) {
+        await pasteTextIntoTextControl(answerInput, text, {
+          source: 'programmatic',
+          canContinue: () => questionAnswerInputRef?.current === answerInput
+        })
       }
     })()
   }, [composerRef, questionAnswerInputRef])
@@ -44,16 +49,56 @@ export function useNativeChatPasteBridge({
       return
     }
     const onPaste = (event: ClipboardEvent): void => {
-      composerRef.current?.handlePasteEvent(event)
+      if (event.defaultPrevented) {
+        return
+      }
+      if (isEditableTarget(event.target)) {
+        // Other text fields (search, answer) keep their native paste.
+        if (event.target instanceof Node && composerRef.current?.contains(event.target)) {
+          composerRef.current.handlePasteEvent(event)
+        }
+        return
+      }
+      const composer = composerRef.current
+      if (composer) {
+        composer.handlePasteEvent(event)
+        event.preventDefault()
+        return
+      }
+      const answerInput = questionAnswerInputRef?.current
+      if (answerInput) {
+        const text = event.clipboardData?.getData('text/plain')
+        event.preventDefault()
+        if (text) {
+          void pasteTextIntoTextControl(answerInput, text, {
+            source: 'programmatic',
+            canContinue: () => questionAnswerInputRef?.current === answerInput
+          })
+        }
+      }
+      // Neither input mounted: left unclaimed so the pane's chat cover refuses it visibly.
+    }
+    // Named-pane pastes (terminal context menu, a paste on the cover itself) carry no event data.
+    const onPasteRequest = (event: Event): void => {
+      if (!composerRef.current && !questionAnswerInputRef?.current) {
+        return
+      }
+      event.preventDefault()
+      pasteClipboardIntoComposer()
     }
     root.addEventListener('paste', onPaste, { capture: true })
+    root.addEventListener(NATIVE_CHAT_PASTE_REQUEST_EVENT, onPasteRequest)
     return () => {
       root.removeEventListener('paste', onPaste, { capture: true })
+      root.removeEventListener(NATIVE_CHAT_PASTE_REQUEST_EVENT, onPasteRequest)
     }
-  }, [composerRef, rootRef])
+  }, [composerRef, rootRef, questionAnswerInputRef, pasteClipboardIntoComposer])
 
   useEffect(() => {
     const onAppMenuPaste = (event: Event): void => {
+      if (event.defaultPrevented) {
+        return
+      }
       const root = rootRef.current
       const activeElement = document.activeElement
       // The app-menu paste event is window-scoped; only claim it when focus is
@@ -61,8 +106,15 @@ export function useNativeChatPasteBridge({
       if (!root || !(activeElement instanceof Element) || !root.contains(activeElement)) {
         return
       }
-      // No paste target mounted: leave the event unclaimed so the shared
-      // app-menu handler can resolve the focused text control itself.
+      if (
+        isEditableTarget(activeElement) &&
+        !composerRef.current?.contains(activeElement) &&
+        activeElement !== questionAnswerInputRef?.current
+      ) {
+        return
+      }
+      // No paste target mounted: leave the event unclaimed. The shared handler
+      // then pastes natively, which the pane's chat cover turns into a refusal.
       if (!composerRef.current && !questionAnswerInputRef?.current) {
         return
       }
diff --git a/src/renderer/src/components/native-chat/use-native-chat-pending-delivery.test.tsx b/src/renderer/src/components/native-chat/use-native-chat-pending-delivery.test.tsx
new file mode 100644
index 00000000000..fa601e93835
--- /dev/null
+++ b/src/renderer/src/components/native-chat/use-native-chat-pending-delivery.test.tsx
@@ -0,0 +1,137 @@
+// @vitest-environment happy-dom
+import { act, renderHook, cleanup } from '@testing-library/react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import type { NativeChatMessage } from '../../../../shared/native-chat-types'
+import {
+  NATIVE_CHAT_UNCONFIRMED_SEND_HOLD_MS,
+  useNativeChatPendingDelivery
+} from './use-native-chat-pending-delivery'
+import { clearPendingSendCacheForTests } from './native-chat-pending'
+
+const boundary: NativeChatMessage = {
+  id: 'boundary',
+  role: 'assistant',
+  blocks: [{ type: 'text', text: 'before' }],
+  timestamp: null,
+  source: 'transcript'
+}
+const args = { paneKey: 'pane', agent: 'claude' as const, messages: [boundary] }
+function userRow(text: string): NativeChatMessage {
+  return { ...boundary, id: `user:${text}`, role: 'user', blocks: [{ type: 'text', text }] }
+}
+function render() {
+  return renderHook(({ messages }) => useNativeChatPendingDelivery({ ...args, messages }), {
+    initialProps: { messages: [boundary] }
+  })
+}
+async function tick(ms: number) {
+  await act(async () => {
+    await vi.advanceTimersByTimeAsync(ms)
+  })
+}
+beforeEach(() => {
+  vi.useFakeTimers()
+  clearPendingSendCacheForTests()
+})
+afterEach(() => {
+  cleanup()
+  vi.useRealTimers()
+})
+
+describe('terminal Chat pending delivery', () => {
+  it('never flags an ordinary send, such as one Claude queues mid-turn', async () => {
+    const { result } = render()
+    act(() => result.current.record('queued follow up'))
+    await tick(10 * 60_000)
+    expect(result.current.notices.size).toBe(0)
+    expect(result.current.pending[0]?.delivery).toBeUndefined()
+  })
+  it('marks a refused write as not sent, keeps its text, and dismisses it', () => {
+    const { result } = render()
+    act(() => {
+      result.current.reject(result.current.record('refused'))
+    })
+    expect(result.current.pending[0]?.text).toBe('refused')
+    expect([...result.current.notices.values()][0]?.text).toBe('Message not sent')
+    act(() => [...result.current.notices.values()][0]?.onDismiss?.())
+    expect(result.current.pending).toEqual([])
+  })
+  it('reports a lost acknowledgment as unconfirmed only after the hold passes with no row', async () => {
+    const { result } = render()
+    act(() => {
+      result.current.holdUnconfirmed(result.current.record('lost ack'))
+    })
+    await tick(NATIVE_CHAT_UNCONFIRMED_SEND_HOLD_MS - 1)
+    expect(result.current.notices.size).toBe(0)
+    await tick(1)
+    expect([...result.current.notices.values()][0]?.text).toMatch(/Delivery unconfirmed/)
+    expect(result.current.pending[0]?.text).toBe('lost ack')
+  })
+  it('clears a held send whose echo lands, before or after the hold ends', async () => {
+    const { result, rerender } = render()
+    act(() => {
+      result.current.holdUnconfirmed(result.current.record('early'))
+      result.current.holdUnconfirmed(result.current.record('late'))
+    })
+    rerender({ messages: [boundary, userRow('early')] })
+    await tick(NATIVE_CHAT_UNCONFIRMED_SEND_HOLD_MS)
+    expect(result.current.pending.map((entry) => [entry.text, entry.delivery])).toEqual([
+      ['early', undefined],
+      ['late', 'unconfirmed']
+    ])
+    rerender({
+      messages: [boundary, userRow('early'), userRow('late'), { ...boundary, id: 'answer' }]
+    })
+    expect(result.current.pending).toEqual([])
+  })
+  it.each(['rejected', 'unconfirmed'] as const)(
+    'retires a resend of a %s message once its row lands',
+    async (outcome) => {
+      const { result, rerender } = render()
+      act(() => {
+        const id = result.current.record('try again')
+        if (outcome === 'rejected') {
+          result.current.reject(id)
+        } else {
+          result.current.holdUnconfirmed(id)
+        }
+      })
+      await tick(NATIVE_CHAT_UNCONFIRMED_SEND_HOLD_MS)
+      expect(result.current.pending[0]?.delivery).toBe(outcome)
+      act(() => result.current.record('try again'))
+      expect(result.current.pending.map((entry) => entry.delivery)).toEqual([undefined])
+      rerender({ messages: [boundary, userRow('try again'), { ...boundary, id: 'answer' }] })
+      expect(result.current.pending).toEqual([])
+    }
+  )
+  it('keeps a failed send through Stop while dropping sends Stop may have cancelled', () => {
+    const { result } = render()
+    act(() => {
+      result.current.reject(result.current.record('refused'))
+      result.current.record('in flight')
+    })
+    act(() => result.current.clear())
+    expect(result.current.pending.map((entry) => [entry.text, entry.delivery])).toEqual([
+      ['refused', 'rejected']
+    ])
+  })
+  it('keeps the hold deadline across a remount', async () => {
+    const first = render()
+    act(() => {
+      first.result.current.holdUnconfirmed(first.result.current.record('remounted'))
+    })
+    await tick(NATIVE_CHAT_UNCONFIRMED_SEND_HOLD_MS / 2)
+    first.unmount()
+    const next = render()
+    await tick(NATIVE_CHAT_UNCONFIRMED_SEND_HOLD_MS / 2)
+    expect(next.result.current.pending[0]?.delivery).toBe('unconfirmed')
+  })
+  it('keeps pending and notices referentially stable across stream updates', () => {
+    const { result, rerender } = render()
+    act(() => result.current.record('stable'))
+    const { pending, notices } = result.current
+    rerender({ messages: [boundary, { ...boundary, id: 'streamed' }] })
+    expect(result.current.pending).toBe(pending)
+    expect(result.current.notices).toBe(notices)
+  })
+})
diff --git a/src/renderer/src/components/native-chat/use-native-chat-pending-delivery.ts b/src/renderer/src/components/native-chat/use-native-chat-pending-delivery.ts
new file mode 100644
index 00000000000..a15a05fcb4d
--- /dev/null
+++ b/src/renderer/src/components/native-chat/use-native-chat-pending-delivery.ts
@@ -0,0 +1,157 @@
+import { useCallback, useEffect, useMemo, useState } from 'react'
+import { translate } from '@/i18n/i18n'
+import type { AgentType, NativeChatMessage } from '../../../../shared/native-chat-types'
+import {
+  appendPendingSendCache,
+  nextNativeChatPendingSendId,
+  pendingSendsAsMessages,
+  prunePendingSends,
+  readPendingSendCache,
+  writePendingSendCache,
+  type NativeChatPendingSend
+} from './native-chat-pending'
+import type { NativeChatDeliveryNotice } from './NativeChatMessageRow'
+
+/** How long a send whose write acknowledgment was lost waits for its row; the phone's hold matches. */
+export const NATIVE_CHAT_UNCONFIRMED_SEND_HOLD_MS = 20_000
+
+const NO_NOTICES: ReadonlyMap<string, NativeChatDeliveryNotice> = new Map()
+
+/** Optimistic terminal-Chat echoes plus the definite send outcomes the transport reports. */
+export function useNativeChatPendingDelivery(args: {
+  paneKey: string
+  agent: AgentType
+  messages: NativeChatMessage[]
+}) {
+  const { paneKey, agent, messages } = args
+  const scope = useMemo(() => ({ paneKey, agent }), [paneKey, agent])
+  const [pending, setPending] = useState(() => readPendingSendCache(scope))
+  useEffect(() => setPending(readPendingSendCache(scope)), [scope])
+  const save = useCallback(
+    (update: (entries: NativeChatPendingSend[]) => NativeChatPendingSend[]) => {
+      const current = readPendingSendCache(scope)
+      const next = update(current)
+      // Why: pruning runs on every stream update; a no-op must not re-render the list.
+      if (next !== current) {
+        setPending(writePendingSendCache(scope, next))
+      }
+    },
+    [scope]
+  )
+  useEffect(() => {
+    save((entries) => prunePendingSends(entries, messages))
+  }, [messages, save])
+  const record = useCallback(
+    (text: string, imagePaths?: string[]) => {
+      const sentAt = Date.now()
+      const boundary = messages.at(-1)
+      const entry: NativeChatPendingSend = {
+        id: nextNativeChatPendingSendId(sentAt),
+        text,
+        sentAt,
+        afterMessageId: boundary?.id ?? null,
+        afterMessageTimestamp: boundary?.timestamp ?? null,
+        ...(imagePaths ? { imagePaths } : {})
+      }
+      setPending(appendPendingSendCache(scope, entry))
+      return entry.id
+    },
+    [messages, scope]
+  )
+  const cancel = useCallback(
+    (id: string) => save((entries) => entries.filter((entry) => entry.id !== id)),
+    [save]
+  )
+  const reject = useCallback(
+    (id: string) =>
+      save((entries) =>
+        entries.map((entry) => (entry.id === id ? { ...entry, delivery: 'rejected' } : entry))
+      ),
+    [save]
+  )
+  const holdUnconfirmed = useCallback(
+    (id: string) =>
+      save((entries) =>
+        entries.map((entry) =>
+          entry.id === id && !entry.delivery && entry.writeUnconfirmedAt === undefined
+            ? { ...entry, writeUnconfirmedAt: Date.now() }
+            : entry
+        )
+      ),
+    [save]
+  )
+  // Why keep outcomes: Stop cannot affect a settled failure, and its bubble holds the only copy.
+  const clear = useCallback(
+    () => save((entries) => entries.filter((entry) => entry.delivery)),
+    [save]
+  )
+
+  // A lost acknowledgment is the only unconfirmed trigger: an ordinary send, including one Claude
+  // queues mid-turn, has no transport doubt and stays pending until its row lands.
+  const nextHoldDeadline = useMemo(() => {
+    const deadlines = pending.flatMap((entry) =>
+      entry.writeUnconfirmedAt !== undefined && !entry.delivery
+        ? [entry.writeUnconfirmedAt + NATIVE_CHAT_UNCONFIRMED_SEND_HOLD_MS]
+        : []
+    )
+    return deadlines.length > 0 ? Math.min(...deadlines) : null
+  }, [pending])
+  useEffect(() => {
+    if (nextHoldDeadline === null) {
+      return
+    }
+    const timer = setTimeout(
+      () => {
+        const now = Date.now()
+        save((entries) => {
+          const due = entries.filter(
+            (entry) =>
+              entry.writeUnconfirmedAt !== undefined &&
+              !entry.delivery &&
+              entry.writeUnconfirmedAt + NATIVE_CHAT_UNCONFIRMED_SEND_HOLD_MS <= now
+          )
+          if (due.length === 0) {
+            return entries
+          }
+          const unmatched = new Set(
+            pendingSendsAsMessages(due, messages).map((message) => message.id)
+          )
+          if (unmatched.size === 0) {
+            return entries
+          }
+          return entries.map((entry) =>
+            due.includes(entry) && unmatched.has(`pending:${entry.id}`)
+              ? { ...entry, delivery: 'unconfirmed' as const }
+              : entry
+          )
+        })
+      },
+      Math.max(0, nextHoldDeadline - Date.now())
+    )
+    return () => clearTimeout(timer)
+  }, [nextHoldDeadline, messages, save])
+
+  const notices = useMemo(() => {
+    if (!pending.some((entry) => entry.delivery)) {
+      return NO_NOTICES
+    }
+    const result = new Map<string, NativeChatDeliveryNotice>()
+    for (const entry of pending) {
+      if (!entry.delivery) {
+        continue
+      }
+      result.set(`pending:${entry.id}`, {
+        text:
+          entry.delivery === 'rejected'
+            ? translate('components.native-chat.messageNotSent', 'Message not sent')
+            : translate(
+                'components.native-chat.deliveryUnconfirmed',
+                'Delivery unconfirmed — check chat before retrying'
+              ),
+        onDismiss: () => cancel(entry.id)
+      })
+    }
+    return result
+  }, [pending, cancel])
+  return { pending, record, cancel, reject, holdUnconfirmed, clear, notices }
+}
diff --git a/src/renderer/src/components/native-chat/use-native-chat-pty-composer-send.test.tsx b/src/renderer/src/components/native-chat/use-native-chat-pty-composer-send.test.tsx
new file mode 100644
index 00000000000..b480c065e91
--- /dev/null
+++ b/src/renderer/src/components/native-chat/use-native-chat-pty-composer-send.test.tsx
@@ -0,0 +1,84 @@
+// @vitest-environment happy-dom
+import { renderHook } from '@testing-library/react'
+import { beforeEach, expect, it, vi } from 'vitest'
+import type { AgentType } from '../../../../shared/agent-status-types'
+import type { NativeChatSendClassification } from '../../../../shared/native-chat-slash-commands'
+import { useNativeChatPtyComposerSend } from './use-native-chat-pty-composer-send'
+import { sendNativeChatMessage } from './native-chat-runtime-send'
+import { sendNativeChatMessageWithImageAttachments } from './native-chat-runtime-image-send'
+
+const handle = vi.hoisted(() => ({ cancel: () => {}, settleAfterMs: 0 }))
+vi.mock('./native-chat-runtime-send', () => ({
+  sendNativeChatMessage: vi.fn(() => handle),
+  sendNativeChatTypedCommand: vi.fn(() => handle),
+  submitNativeChatPrompt: vi.fn()
+}))
+vi.mock('./native-chat-runtime-image-send', () => ({
+  sendNativeChatMessageWithImageAttachments: vi.fn(() => handle)
+}))
+vi.mock('../../store', () => ({
+  useAppStore: { getState: () => ({ clearNativeChatLaunchDraft: vi.fn() }) }
+}))
+vi.mock('@/lib/native-chat-telemetry', () => ({ emitNativeChatMessageSent: vi.fn() }))
+
+function send(
+  agent: AgentType,
+  classification: NativeChatSendClassification,
+  draft: string,
+  imagePaths: string[] = []
+) {
+  const callbacks = { rejected: vi.fn(), unconfirmed: vi.fn() }
+  const { result } = renderHook(() =>
+    useNativeChatPtyComposerSend({
+      agent,
+      draft,
+      imageAttachments: imagePaths.map((path) => ({ path })),
+      disabled: false,
+      isDispatchingSessionOption: false,
+      launchDraftResolved: true,
+      resolveTarget: () => ({ ptyId: 'pty', settings: null }),
+      classifySend: () => classification,
+      onOptimisticSend: () => 'pending-1',
+      optimisticSendOutcome: { reject: callbacks.rejected, holdUnconfirmed: callbacks.unconfirmed },
+      sessionOptionsSurface: null,
+      terminalTabId: 'tab',
+      trackPendingSend: vi.fn(),
+      setHistory: vi.fn(),
+      setDraft: vi.fn(),
+      setCaret: vi.fn(),
+      clearSkillOrigin: vi.fn(),
+      clearImageAttachments: vi.fn(),
+      setNotice: vi.fn()
+    })
+  )
+  result.current()
+  return callbacks
+}
+
+beforeEach(() => {
+  vi.mocked(sendNativeChatMessage).mockClear()
+  vi.mocked(sendNativeChatMessageWithImageAttachments).mockClear()
+})
+
+it('routes a Claude chat send outcome to its own pending echo', () => {
+  const callbacks = send('claude', 'chat', 'hello')
+  const options = vi.mocked(sendNativeChatMessage).mock.calls[0]?.[3]
+  options?.onWriteRejected?.()
+  options?.onWriteUnconfirmed?.()
+  expect(callbacks.rejected).toHaveBeenCalledWith('pending-1')
+  expect(callbacks.unconfirmed).toHaveBeenCalledWith('pending-1')
+})
+
+it('routes a Claude image send outcome to its own pending echo', () => {
+  const callbacks = send('claude', 'chat', 'look', ['/tmp/shot.png'])
+  vi.mocked(sendNativeChatMessageWithImageAttachments).mock.calls[0]?.[5]?.onWriteRejected?.()
+  expect(callbacks.rejected).toHaveBeenCalledWith('pending-1')
+})
+
+it.each([
+  ['codex', 'chat', 'hello'],
+  ['claude', 'command', '/compact']
+] as const)('leaves a %s %s send on the unobserved write path', (agent, classification, draft) => {
+  send(agent, classification, draft)
+  expect(vi.mocked(sendNativeChatMessage).mock.calls[0]?.[3]?.onWriteRejected).toBeUndefined()
+})
diff --git a/src/renderer/src/components/native-chat/use-native-chat-pty-composer-send.ts b/src/renderer/src/components/native-chat/use-native-chat-pty-composer-send.ts
index 1cc912f4250..385396190e4 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-pty-composer-send.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-pty-composer-send.ts
@@ -18,6 +18,7 @@ import { isSlashCommandDraft } from '../../../../shared/native-chat-slash-comman
 import type { NativeChatPickerState } from './use-native-chat-picker-state'
 import type { NativeChatSendLifecycle } from './use-native-chat-send-lifecycle'
 import type { NativeChatPtySessionOptionsSurface } from './native-chat-pty-session-options'
+import type { NativeChatOptimisticSendOutcome } from './native-chat-composer-types'
 
 export function useNativeChatPtyComposerSend(args: {
   agent: AgentType
@@ -31,6 +32,7 @@ export function useNativeChatPtyComposerSend(args: {
   resolveTarget: () => NativeChatResolvedTarget | null
   classifySend: NativeChatPickerState['classifySend']
   onOptimisticSend?: (text: string, imagePaths?: string[]) => string | undefined
+  optimisticSendOutcome?: NativeChatOptimisticSendOutcome
   onSlashCommand?: (command: string) => void
   sessionOptionsSurface: NativeChatPtySessionOptionsSurface | null
   terminalTabId: string
@@ -57,12 +59,29 @@ export function useNativeChatPtyComposerSend(args: {
       return
     }
     const classification = args.classifySend(text)
-    const { sendOptions } = resolveNativeChatLaunchDraftSend({
+    const { sendOptions: launchSendOptions } = resolveNativeChatLaunchDraftSend({
       launchDraft: args.launchDraft,
       launchDraftResolved: args.launchDraftResolved,
       agent: args.agent,
       readScreen: () => args.readTerminalScreen?.()
     })
+    let pendingId: string | undefined
+    const sendOptions =
+      args.agent === 'claude' && classification === 'chat'
+        ? {
+            ...launchSendOptions,
+            onWriteRejected: () => {
+              if (pendingId) {
+                args.optimisticSendOutcome?.reject(pendingId)
+              }
+            },
+            onWriteUnconfirmed: () => {
+              if (pendingId) {
+                args.optimisticSendOutcome?.holdUnconfirmed(pendingId)
+              }
+            }
+          }
+        : launchSendOptions
     let pendingHandle: NativeChatSendHandle | null = null
     // Why: slash-like text must not silently drop its attached images.
     if (classification !== 'chat' && imagePaths.length === 0) {
@@ -93,7 +112,7 @@ export function useNativeChatPtyComposerSend(args: {
         args.sessionOptionsSurface?.recordOutgoingCommand(text.trim())
       }
     } else {
-      const pendingId = args.onOptimisticSend?.(text, imagePaths)
+      pendingId = args.onOptimisticSend?.(text, imagePaths)
       if (pendingHandle) {
         args.trackPendingSend(pendingHandle, pendingId)
       }
diff --git a/src/renderer/src/components/native-chat/use-native-chat-typed-insertion.ts b/src/renderer/src/components/native-chat/use-native-chat-typed-insertion.ts
index a3e07b6256d..483ee6f5aa8 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-typed-insertion.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-typed-insertion.ts
@@ -1,4 +1,7 @@
-import type { NativeChatComposerInput } from './native-chat-composer-input'
+import {
+  insertNativeChatPastedText,
+  type NativeChatComposerInput
+} from './native-chat-composer-input'
 import { useCallback, type Dispatch, type RefObject, type SetStateAction } from 'react'
 import type { HistoryState } from './native-chat-composer-state'
 
@@ -12,7 +15,12 @@ export function useNativeChatTypedInsertion(args: {
   setCaret: Dispatch<SetStateAction<number>>
   setHistory: Dispatch<SetStateAction<HistoryState>>
   setActiveSuggestion: Dispatch<SetStateAction<number>>
-}): { insertTypedText: (text: string) => boolean; focus: () => boolean } {
+}): {
+  insertTypedText: (text: string) => boolean
+  insertPastedText: (text: string) => boolean
+  focus: () => boolean
+  contains: (node: Node | null) => boolean
+} {
   const { textareaRef, caret, draft, setDraft, setCaret, setHistory, setActiveSuggestion } = args
 
   const insertTypedText = useCallback(
@@ -38,6 +46,12 @@ export function useNativeChatTypedInsertion(args: {
     [caret, draft, setActiveSuggestion, setCaret, setDraft, setHistory, textareaRef]
   )
 
+  // Reads the live input when a delayed clipboard read settles.
+  const insertPastedText = useCallback(
+    (text: string): boolean => insertNativeChatPastedText(textareaRef.current, text),
+    [textareaRef]
+  )
+
   const focus = useCallback((): boolean => {
     const textarea = textareaRef.current
     if (!textarea || textarea.disabled) {
@@ -47,5 +61,10 @@ export function useNativeChatTypedInsertion(args: {
     return true
   }, [textareaRef])
 
-  return { insertTypedText, focus }
+  const contains = useCallback(
+    (node: Node | null): boolean => textareaRef.current?.contains?.(node) === true,
+    [textareaRef]
+  )
+
+  return { insertTypedText, insertPastedText, focus, contains }
 }
diff --git a/src/renderer/src/components/right-sidebar/ai-vault-view-defaults.test.ts b/src/renderer/src/components/right-sidebar/ai-vault-view-defaults.test.ts
index 9b9f3ca1906..fae603d3189 100644
--- a/src/renderer/src/components/right-sidebar/ai-vault-view-defaults.test.ts
+++ b/src/renderer/src/components/right-sidebar/ai-vault-view-defaults.test.ts
@@ -34,17 +34,6 @@ describe('ai-vault-view-defaults', () => {
     ).toBe(1)
   })
 
-  it('does not count showing empty sessions as an adjustment', () => {
-    expect(
-      countAiVaultViewAdjustments({
-        agents: [...AI_VAULT_AGENTS],
-        group: DEFAULT_AI_VAULT_GROUP,
-        hideEmptySessions: false,
-        sessionLimit: DEFAULT_AI_VAULT_SESSION_LIMIT
-      })
-    ).toBe(0)
-  })
-
   it('counts an equal-length agent swap as an adjustment', () => {
     // A swap keeps the array length but drops a default agent (here the first) for a duplicate.
     const swapped = [...AI_VAULT_AGENTS.slice(1), AI_VAULT_AGENTS[1]]
diff --git a/src/renderer/src/components/right-sidebar/right-sidebar-primary-action-layout.test.ts b/src/renderer/src/components/right-sidebar/right-sidebar-primary-action-layout.test.ts
index 8cf54832c58..b23fe2f0125 100644
--- a/src/renderer/src/components/right-sidebar/right-sidebar-primary-action-layout.test.ts
+++ b/src/renderer/src/components/right-sidebar/right-sidebar-primary-action-layout.test.ts
@@ -1,6 +1,5 @@
 import { describe, expect, it } from 'vitest'
 import {
-  REVIEW_ACTION_MERGE_BUTTON_CLASS,
   RIGHT_SIDEBAR_MERGE_PRIMARY_BUTTON_CLASS,
   RIGHT_SIDEBAR_MORPHING_PRIMARY_BUTTON_CLASS,
   RIGHT_SIDEBAR_SPLIT_ACTION_ROW_CLASS
@@ -27,8 +26,4 @@ describe('right sidebar primary action layout classes', () => {
     expect(RIGHT_SIDEBAR_MERGE_PRIMARY_BUTTON_CLASS).toContain('w-[11.5rem]')
     expect(RIGHT_SIDEBAR_MERGE_PRIMARY_BUTTON_CLASS).not.toContain('min-w-[11.5rem]')
   })
-
-  it('shares the shrinkable merge sizing with full-page review actions', () => {
-    expect(REVIEW_ACTION_MERGE_BUTTON_CLASS).toBe(RIGHT_SIDEBAR_MERGE_PRIMARY_BUTTON_CLASS)
-  })
 })
diff --git a/src/renderer/src/components/right-sidebar/source-control-header-toolbar-identity.test.tsx b/src/renderer/src/components/right-sidebar/source-control-header-toolbar-identity.test.tsx
index 36aac5d4ab5..432aae41b96 100644
--- a/src/renderer/src/components/right-sidebar/source-control-header-toolbar-identity.test.tsx
+++ b/src/renderer/src/components/right-sidebar/source-control-header-toolbar-identity.test.tsx
@@ -174,7 +174,6 @@ describe('SourceControlHeaderToolbar branch identity', () => {
   })
 
   it('renders exactly as before when no branch line total is supplied', () => {
-    expect(renderToolbar({ branchLineTotal: undefined })).toBe(renderToolbar())
     expect(renderToolbar()).not.toContain('data-testid="source-control-branch-line-total"')
   })
 })
diff --git a/src/renderer/src/components/settings/agent-skill-installed-command-callers.test.ts b/src/renderer/src/components/settings/agent-skill-installed-command-callers.test.ts
deleted file mode 100644
index 8b7e5d5bb5d..00000000000
--- a/src/renderer/src/components/settings/agent-skill-installed-command-callers.test.ts
+++ /dev/null
@@ -1,84 +0,0 @@
-import { readdirSync, readFileSync, statSync } from 'node:fs'
-import path from 'node:path'
-import { fileURLToPath } from 'node:url'
-import { describe, expect, it } from 'vitest'
-
-const repoRoot = path.resolve(fileURLToPath(new URL('../../../../../', import.meta.url)))
-const componentsRoot = path.join(repoRoot, 'src/renderer/src/components')
-
-const updateCapableCallers: readonly string[] = [
-  'src/renderer/src/components/settings/OrchestrationPane.tsx',
-  'src/renderer/src/components/settings/OrchestrationSetupCard.tsx',
-  'src/renderer/src/components/floating-terminal/FloatingTerminalOrchestrationDialog.tsx',
-  'src/renderer/src/components/settings/ComputerUseSkillSetupPanel.tsx',
-  'src/renderer/src/components/settings/use-linear-agent-skill-setup.ts',
-  'src/renderer/src/components/settings/LinearAgentSkillPane.tsx',
-  'src/renderer/src/components/settings/TaskSourceLinearSetup.tsx',
-  'src/renderer/src/components/settings/EphemeralVmsPane.tsx',
-  'src/renderer/src/components/settings/CliSection.tsx',
-  'src/renderer/src/components/settings/BrowserUsePane.tsx',
-  'src/renderer/src/components/settings/BrowserUseSkillStep.tsx',
-  'src/renderer/src/components/feature-wall/BrowserUseSkillSetupCard.tsx',
-  'src/renderer/src/components/sidebar/LinearAgentSkillSetupPrompt.tsx',
-  'src/renderer/src/components/sidebar/LinearAgentSkillSetupDialog.tsx',
-  'src/renderer/src/components/settings/MobileEmulatorAgentControlRow.tsx'
-]
-
-const installOnlyCallers: readonly string[] = [
-  'src/renderer/src/components/emulator-pane/MobileEmulatorAgentSetupGuideSteps.tsx'
-]
-
-const directPanelCallers = new Set([
-  // BrowserUsePane and LinearAgentSkillSetupPrompt render the panel through child
-  // components; use-linear-agent-skill-setup is a resolver, not a panel host.
-  ...updateCapableCallers.filter(
-    (relativePath) =>
-      relativePath !== 'src/renderer/src/components/settings/BrowserUsePane.tsx' &&
-      relativePath !== 'src/renderer/src/components/sidebar/LinearAgentSkillSetupPrompt.tsx' &&
-      relativePath !== 'src/renderer/src/components/settings/use-linear-agent-skill-setup.ts'
-  ),
-  ...installOnlyCallers
-])
-
-function relativeRepoPath(filePath: string): string {
-  return path.relative(repoRoot, filePath).split(path.sep).join('/')
-}
-
-function readRepoFile(relativePath: string): string {
-  return readFileSync(path.join(repoRoot, relativePath), 'utf8')
-}
-
-function findProductionPanelCallers(dir: string): string[] {
-  const found: string[] = []
-  for (const entry of readdirSync(dir)) {
-    const entryPath = path.join(dir, entry)
-    const stat = statSync(entryPath)
-    if (stat.isDirectory()) {
-      found.push(...findProductionPanelCallers(entryPath))
-      continue
-    }
-    if (!entryPath.endsWith('.tsx') || entryPath.includes('.test.')) {
-      continue
-    }
-    const source = readFileSync(entryPath, 'utf8')
-    if (source.includes('<AgentSkillSetupPanel')) {
-      found.push(relativeRepoPath(entryPath))
-    }
-  }
-  return found.sort()
-}
-
-describe('AgentSkillSetupPanel installed-command call sites', () => {
-  it('fails when a production caller can show the default Update action without installedCommand', () => {
-    const productionCallers = findProductionPanelCallers(componentsRoot)
-
-    expect(productionCallers).toEqual([...directPanelCallers].sort())
-
-    for (const relativePath of installOnlyCallers) {
-      expect(
-        readRepoFile(relativePath),
-        `${relativePath} intentionally hides the installed action`
-      ).not.toContain('installedCommand=')
-    }
-  })
-})
diff --git a/src/renderer/src/components/sidebar/sidebar-workspace-option-items.test.ts b/src/renderer/src/components/sidebar/sidebar-workspace-option-items.test.ts
index 1e09b53a2d8..b48528fb74a 100644
--- a/src/renderer/src/components/sidebar/sidebar-workspace-option-items.test.ts
+++ b/src/renderer/src/components/sidebar/sidebar-workspace-option-items.test.ts
@@ -1,15 +1,11 @@
 import { describe, expect, it } from 'vitest'
 import { TASK_WORKTREE_CARD_PROPERTIES } from '../../../../shared/constants'
-import {
-  WORKTREE_CARD_PROPERTY_OPTIONS,
-  getWorktreeCardPropertyOptions
-} from './sidebar-workspace-option-items'
+import { getWorktreeCardPropertyOptions } from './sidebar-workspace-option-items'
 
 describe('worktree card property options', () => {
   it('keeps the combined Tasks option by default', () => {
     const options = getWorktreeCardPropertyOptions()
 
-    expect(WORKTREE_CARD_PROPERTY_OPTIONS).toEqual(options)
     expect(options.map((option) => option.id)).toContain('tasks')
     expect(options.map((option) => option.id)).toContain('automation')
     expect(options.find((option) => option.id === 'tasks')?.properties).toEqual(
diff --git a/src/renderer/src/components/sidebar/sidebar-workspace-option-items.ts b/src/renderer/src/components/sidebar/sidebar-workspace-option-items.ts
index 717dd2302d3..576b9bbf080 100644
--- a/src/renderer/src/components/sidebar/sidebar-workspace-option-items.ts
+++ b/src/renderer/src/components/sidebar/sidebar-workspace-option-items.ts
@@ -213,8 +213,6 @@ export function getWorktreeCardPropertyOptions({
   ]
 }
 
-export const WORKTREE_CARD_PROPERTY_OPTIONS = getWorktreeCardPropertyOptions()
-
 export const SORT_OPTIONS = [
   {
     id: 'name',
diff --git a/src/renderer/src/components/sidebar/worktree-list/grouping/host-labels.test.ts b/src/renderer/src/components/sidebar/worktree-list/grouping/host-labels.test.ts
index 7411dc00d6a..cc2f63daca2 100644
--- a/src/renderer/src/components/sidebar/worktree-list/grouping/host-labels.test.ts
+++ b/src/renderer/src/components/sidebar/worktree-list/grouping/host-labels.test.ts
@@ -20,28 +20,6 @@ function makeWorktrees(rows: { id: string; repoId: string }[]): Worktree[] {
 }
 
 describe('host worktree counts and ids', () => {
-  it('reports a count equal to the length of each host id list', () => {
-    const repoMap = makeRepos({
-      'repo-local': undefined,
-      'repo-remote': 'ssh:other' as ExecutionHostId
-    })
-    const worktrees = makeWorktrees([
-      { id: 'a', repoId: 'repo-local' },
-      { id: 'b', repoId: 'repo-local' },
-      { id: 'c', repoId: 'repo-remote' }
-    ])
-
-    const counts = getHostWorktreeCounts(worktrees, repoMap, LOCAL)
-    const ids = getHostWorktreeIds(worktrees, repoMap, LOCAL)
-
-    expect(ids).toBeDefined()
-    expect(counts).toBeDefined()
-    for (const [hostId, hostIds] of ids ?? []) {
-      expect(counts?.get(hostId), `count for ${hostId}`).toBe(hostIds.length)
-    }
-    expect([...(counts?.keys() ?? [])].sort()).toEqual([...(ids?.keys() ?? [])].sort())
-  })
-
   it('counts a repeated host identity once', () => {
     const repoMap = makeRepos({ 'repo-local': undefined })
     const worktrees = makeWorktrees([
diff --git a/src/renderer/src/components/sidebar/worktree-list/rows/indentation.test.ts b/src/renderer/src/components/sidebar/worktree-list/rows/indentation.test.ts
index 4382330f038..c8dce7593bb 100644
--- a/src/renderer/src/components/sidebar/worktree-list/rows/indentation.test.ts
+++ b/src/renderer/src/components/sidebar/worktree-list/rows/indentation.test.ts
@@ -4,7 +4,6 @@ import {
   FLUSH_CARD_MIN_CONTENT_INSET,
   NEW_CARD_STYLE_STATUS_LANE_EXTRA_PULLBACK,
   LINEAGE_CHILDREN_INLINE_OFFSET,
-  LINEAGE_IMMEDIATE_PARENT_STEP,
   LINEAGE_NESTED_ROW_SURFACE_INSET,
   WORKTREE_CARD_SURFACE_MARGIN,
   WORKTREE_SECTION_HEADER_PADDING_LEFT,
@@ -233,12 +232,6 @@ describe('worktree list indentation', () => {
     expect(getFlushWorktreeCardPaddingLeft(0, true)).toBe('2px')
   })
 
-  it('derives the lineage parent-child step from the pre-refactor grouped-card anchor', () => {
-    expect(LINEAGE_CHILDREN_INLINE_OFFSET).toBe(
-      LINEAGE_IMMEDIATE_PARENT_STEP - WORKTREE_CARD_SURFACE_MARGIN - FLUSH_CARD_MIN_CONTENT_INSET
-    )
-  })
-
   it('keeps experimental lineage nested rows from accumulating global depth', () => {
     const child = getLineageNestedRowGeometry({
       experimentalNewWorktreeCardStyle: true,
diff --git a/src/renderer/src/components/terminal-pane/NativeChatPaneCover.tsx b/src/renderer/src/components/terminal-pane/NativeChatPaneCover.tsx
new file mode 100644
index 00000000000..2cb2cd00ed9
--- /dev/null
+++ b/src/renderer/src/components/terminal-pane/NativeChatPaneCover.tsx
@@ -0,0 +1,34 @@
+import { useRef, type ReactNode } from 'react'
+import { isEditableTarget } from '@/lib/editable-target'
+import type { ManagedPane } from '@/lib/pane-manager/pane-manager'
+import { useCoveredTerminalFocusHandoff } from './use-covered-terminal-focus-handoff'
+import { requestNativeChatCoverPaste } from './native-chat-cover-paste'
+
+/** The cover owns focus and paste for its pane until a chat input can take them. */
+export function NativeChatPaneCover({
+  pane,
+  children
+}: {
+  pane: Pick<ManagedPane, 'container' | 'terminal'>
+  children: ReactNode
+}): React.JSX.Element {
+  const coverRef = useRef<HTMLDivElement>(null)
+  useCoveredTerminalFocusHandoff(coverRef, pane.terminal)
+  return (
+    <div
+      ref={coverRef}
+      tabIndex={-1}
+      className="native-chat-pane-shell absolute inset-0 z-10 flex min-h-0 min-w-0 bg-background focus:outline-none"
+      onPaste={(event) => {
+        // Chat inputs claim their pastes first; one that reaches here found no chat input.
+        if (event.defaultPrevented || isEditableTarget(event.target)) {
+          return
+        }
+        event.preventDefault()
+        requestNativeChatCoverPaste(pane)
+      }}
+    >
+      {children}
+    </div>
+  )
+}
diff --git a/src/renderer/src/components/terminal-pane/TerminalPaneNativeChatPortal.test.tsx b/src/renderer/src/components/terminal-pane/TerminalPaneNativeChatPortal.test.tsx
index 292aa0449e7..9817eaf9768 100644
--- a/src/renderer/src/components/terminal-pane/TerminalPaneNativeChatPortal.test.tsx
+++ b/src/renderer/src/components/terminal-pane/TerminalPaneNativeChatPortal.test.tsx
@@ -91,7 +91,8 @@ function makeController(
   const chatPane = {
     id: 1,
     leafId: '11111111-1111-4111-8111-111111111111',
-    container: portalContainer
+    container: portalContainer,
+    terminal: { element: document.createElement('div'), focus: vi.fn() }
   }
   return {
     chatPane,
diff --git a/src/renderer/src/components/terminal-pane/TerminalPaneNativeChatPortal.tsx b/src/renderer/src/components/terminal-pane/TerminalPaneNativeChatPortal.tsx
index 7c8a00460c8..5ddd5d1a78d 100644
--- a/src/renderer/src/components/terminal-pane/TerminalPaneNativeChatPortal.tsx
+++ b/src/renderer/src/components/terminal-pane/TerminalPaneNativeChatPortal.tsx
@@ -5,6 +5,7 @@ import { canContinueAgentSessionInNewSession } from './terminal-agent-session-co
 import type { TerminalPaneController } from './use-terminal-pane-controller'
 import { useAppStore } from '@/store'
 import { resolvePaneAgentSessionId } from './pane-agent-session-id'
+import { NativeChatPaneCover } from './NativeChatPaneCover'
 
 export function TerminalPaneNativeChatPortal({
   controller
@@ -64,7 +65,7 @@ export function TerminalPaneNativeChatPortal({
   }
 
   return createPortal(
-    <div className="native-chat-pane-shell absolute inset-0 z-10 flex min-h-0 min-w-0 bg-background">
+    <NativeChatPaneCover pane={chatPane}>
       <NativeChatView
         terminalTabId={tabId}
         isVisible={isRendererVisible}
@@ -78,7 +79,7 @@ export function TerminalPaneNativeChatPortal({
         readTerminalScreen={readNativeChatTerminalScreen}
         contextMenuActions={contextMenuActions}
       />
-    </div>,
+    </NativeChatPaneCover>,
     chatPane.container,
     `native-chat-${tabId}-${chatPane.leafId}`
   )
diff --git a/src/renderer/src/components/terminal-pane/native-chat-cover-paste.ts b/src/renderer/src/components/terminal-pane/native-chat-cover-paste.ts
new file mode 100644
index 00000000000..3ddd300d554
--- /dev/null
+++ b/src/renderer/src/components/terminal-pane/native-chat-cover-paste.ts
@@ -0,0 +1,24 @@
+import { toast } from 'sonner'
+import {
+  NativeChatPasteRequest,
+  NATIVE_CHAT_ROOT_SELECTOR,
+  nativeChatPasteUnavailableNotice
+} from '@/lib/native-chat-paste-request'
+import { paneIsCoveredByNativeChat } from './native-chat-covered-pane'
+
+/**
+ * Hands a paste aimed at a chat-covered pane to that pane's chat. Returns false
+ * only when no chat covers the pane; a chat with no input ready refuses visibly
+ * so the paste never falls through to the hidden terminal.
+ */
+export function requestNativeChatCoverPaste(pane: { container: Element }): boolean {
+  if (!paneIsCoveredByNativeChat(pane)) {
+    return false
+  }
+  const request = new NativeChatPasteRequest()
+  pane.container.querySelector(NATIVE_CHAT_ROOT_SELECTOR)?.dispatchEvent(request)
+  if (!request.defaultPrevented) {
+    toast.error(nativeChatPasteUnavailableNotice())
+  }
+  return true
+}
diff --git a/src/renderer/src/components/terminal-pane/native-chat-covered-pane.ts b/src/renderer/src/components/terminal-pane/native-chat-covered-pane.ts
index f7d6534a70a..859fc82b7e8 100644
--- a/src/renderer/src/components/terminal-pane/native-chat-covered-pane.ts
+++ b/src/renderer/src/components/terminal-pane/native-chat-covered-pane.ts
@@ -15,6 +15,28 @@ export function paneIsCoveredByNativeChat(
   return pane?.container.querySelector(NATIVE_CHAT_COVER_SELECTOR) != null
 }
 
+/**
+ * Pane focus aimed at a covered pane lands on its chat cover (the chat then hands
+ * it to its composer), never on the hidden terminal or the pane the user left.
+ * Returns false when no chat covers the pane.
+ */
+export function focusNativeChatCover(pane: { container: Pick<Element, 'querySelector'> }): boolean {
+  const cover = pane.container.querySelector<HTMLElement>(NATIVE_CHAT_COVER_SELECTOR)
+  if (!cover) {
+    return false
+  }
+  // Focus already in the chat (a click, the composer) stays where it is.
+  if (!cover.contains(cover.ownerDocument.activeElement)) {
+    cover.focus({ preventScroll: true })
+  }
+  return true
+}
+
+/** True for anything inside a chat cover, including the shell before a chat root mounts. */
+export function isInsideNativeChatCover(target: EventTarget | null): boolean {
+  return target instanceof Element && target.closest(NATIVE_CHAT_COVER_SELECTOR) !== null
+}
+
 /** Mirrors focusActivePane's target so the guard tracks exactly the pane that would take focus. */
 export function activePaneIsCoveredByNativeChat(manager: PaneManager): boolean {
   return paneIsCoveredByNativeChat(manager.getActivePane() ?? manager.getPanes()[0])
diff --git a/src/renderer/src/components/terminal-pane/pane-helpers.test.ts b/src/renderer/src/components/terminal-pane/pane-helpers.test.ts
index 909be3c41a5..247ff5df14d 100644
--- a/src/renderer/src/components/terminal-pane/pane-helpers.test.ts
+++ b/src/renderer/src/components/terminal-pane/pane-helpers.test.ts
@@ -80,10 +80,12 @@ describe('fitAndFocusPanes', () => {
 
   function makeManager(): { manager: PaneManager; terminal: { focus: ReturnType<typeof vi.fn> } } {
     const terminal = { focus: vi.fn() }
+    const pane = { terminal, container: { querySelector: () => null } }
+    // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: fitAndFocusPanes reads only these members, and the focus path reads only a pane's terminal and container.
     const manager = {
       fitAllPanes: vi.fn(),
-      getActivePane: () => ({ terminal }),
-      getPanes: () => [{ terminal }]
+      getActivePane: () => pane,
+      getPanes: () => [pane]
     } as unknown as PaneManager
     return { manager, terminal }
   }
diff --git a/src/renderer/src/components/terminal-pane/pty-connection/pane-pty-layout-binding.test.ts b/src/renderer/src/components/terminal-pane/pty-connection/pane-pty-layout-binding.test.ts
index 2eff30c3233..a064d49d826 100644
--- a/src/renderer/src/components/terminal-pane/pty-connection/pane-pty-layout-binding.test.ts
+++ b/src/renderer/src/components/terminal-pane/pty-connection/pane-pty-layout-binding.test.ts
@@ -23,16 +23,6 @@ describe('shouldIgnoreStalePanePtyLayoutBinding', () => {
     ).toBe(false)
   })
 
-  it('rejects a stale callback after the pane already adopted the replacement', () => {
-    expect(
-      shouldIgnoreStalePanePtyLayoutBinding({
-        existingPtyId: 'pty-new',
-        nextPtyId: 'pty-old',
-        tabPtyId: 'pty-new'
-      })
-    ).toBe(true)
-  })
-
   it('allows a callback while the tab still owns the callback PTY', () => {
     expect(
       shouldIgnoreStalePanePtyLayoutBinding({
diff --git a/src/renderer/src/components/terminal-pane/pty-connection/pane-serializer-register.test.ts b/src/renderer/src/components/terminal-pane/pty-connection/pane-serializer-register.test.ts
new file mode 100644
index 00000000000..3bccfe67655
--- /dev/null
+++ b/src/renderer/src/components/terminal-pane/pty-connection/pane-serializer-register.test.ts
@@ -0,0 +1,69 @@
+import { describe, expect, it, vi } from 'vitest'
+import { SerializeAddon } from '@xterm/addon-serialize'
+import { Terminal } from '@xterm/headless'
+import { installTerminalMouseEncodingTracker } from '@/lib/pane-manager/terminal-mouse-encoding-tracker'
+import type { SerializeFn } from '../pty-buffer-serializer'
+import type { ConnectPanePtySession } from './connect-pane-pty-session'
+import { bindRegisterPaneSerializer } from './pane-serializer-register'
+
+const serializers = vi.hoisted(() => new Map<string, SerializeFn>())
+
+vi.mock('../pty-buffer-serializer', () => ({
+  registerPtySerializer: (ptyId: string, fn: SerializeFn) => {
+    serializers.set(ptyId, fn)
+    return () => serializers.delete(ptyId)
+  },
+  registerPtyTitleSource: () => () => {}
+}))
+
+const ESC = '\x1b'
+const CODEX_MOUSE_START = `${ESC}[?1049h${ESC}[?1000h${ESC}[?1002h${ESC}[?1003h${ESC}[?1015h${ESC}[?1006h`
+
+async function serializePaneAfter(output: string): Promise<string> {
+  const terminal = new Terminal({ cols: 40, rows: 10, allowProposedApi: true })
+  installTerminalMouseEncodingTracker(terminal)
+  const serializeAddon = new SerializeAddon()
+  terminal.loadAddon(serializeAddon)
+  await new Promise<void>((resolve) => terminal.write(output, resolve))
+  // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the serializer reads only these members of the session bag.
+  const session = {
+    disposed: false,
+    pane: { terminal, serializeAddon },
+    rendererOrderedPtyId: null,
+    kittyKeyboardModes: { hasProvenBaseline: false },
+    transport: {},
+    onDataDisposable: { dispose: () => {} }
+  } as unknown as ConnectPanePtySession
+  bindRegisterPaneSerializer(session)
+  session.registerPaneSerializerFor('pty-1')
+  const result = await serializers.get('pty-1')?.()
+  if (!result) {
+    throw new Error('serializer returned nothing')
+  }
+  return result.data
+}
+
+describe('pane serializer mouse encoding', () => {
+  it('carries the SGR encoding after the alternate screen a reader replays from', async () => {
+    const data = await serializePaneAfter(`shell prompt\r\n${CODEX_MOUSE_START}codex`)
+    expect(data).toContain(`${ESC}[?1003h`)
+    expect(data.endsWith(`${ESC}[?1006h`)).toBe(true)
+    expect(data.lastIndexOf(`${ESC}[?1006h`)).toBeGreaterThan(data.lastIndexOf(`${ESC}[?1049h`))
+  })
+
+  it('states the default encoding while a program tracks the mouse', async () => {
+    const data = await serializePaneAfter(`${ESC}[?1049h${ESC}[?1003hlegacy`)
+    expect(data).not.toContain(`${ESC}[?1006h`)
+    expect(data.endsWith(`${ESC}[?1006l`)).toBe(true)
+  })
+
+  it('adds nothing when no program tracks the mouse', async () => {
+    const data = await serializePaneAfter('plain shell')
+    expect(data).not.toContain(`${ESC}[?1006`)
+    expect(data).not.toContain(`${ESC}[?1016`)
+  })
+
+  it('keeps an empty snapshot empty', async () => {
+    expect(await serializePaneAfter(`${ESC}[?1006h`)).toBe('')
+  })
+})
diff --git a/src/renderer/src/components/terminal-pane/pty-connection/pane-serializer-register.ts b/src/renderer/src/components/terminal-pane/pty-connection/pane-serializer-register.ts
index 2b75548ec39..35d95b7f2e4 100644
--- a/src/renderer/src/components/terminal-pane/pty-connection/pane-serializer-register.ts
+++ b/src/renderer/src/components/terminal-pane/pty-connection/pane-serializer-register.ts
@@ -7,6 +7,7 @@ import {
   waitForTerminalOutputParsed
 } from '@/lib/pane-manager/pane-terminal-output-scheduler'
 import { clearTerminalScrollbackAndFollowOutput } from '@/lib/pane-manager/terminal-scrollback-clear'
+import { terminalMouseEncodingRestoreAnsi } from '@/lib/pane-manager/terminal-mouse-encoding-tracker'
 
 import type { ConnectPanePtySession } from './connect-pane-pty-session'
 
@@ -44,11 +45,17 @@ export function bindRegisterPaneSerializer(session: ConnectPanePtySession): void
           // while an alt-screen TUI was up therefore dropped the pre-TUI shell
           // output from the seed instead of the transient TUI bytes, and every
           // later restore painted only the TUI screen (#6106).
-          const data = serializeWithAbsoluteCursor(
+          // Why appended last: SerializeAddon writes mouse tracking but not its
+          // encoding, and readers keep only what follows the final `?1049h`.
+          const serialized = serializeWithAbsoluteCursor(
             session.pane.serializeAddon,
             session.pane.terminal,
             { scrollback: opts?.scrollbackRows }
           )
+          // Why non-empty only: '' means nothing to restore to its readers.
+          const data = serialized
+            ? serialized + terminalMouseEncodingRestoreAnsi(session.pane.terminal)
+            : serialized
           const orderedSeq =
             session.rendererOrderedPtyId === ptyId ? session.rendererOrderedSeq : null
           // Why snapshotFlags and not `flags`: this pane may itself have
diff --git a/src/renderer/src/components/terminal-pane/terminal-context-menu-dismiss.test.ts b/src/renderer/src/components/terminal-pane/terminal-context-menu-dismiss.test.ts
index 8d039c2e867..5e2ff5e5977 100644
--- a/src/renderer/src/components/terminal-pane/terminal-context-menu-dismiss.test.ts
+++ b/src/renderer/src/components/terminal-pane/terminal-context-menu-dismiss.test.ts
@@ -11,24 +11,6 @@ describe('shouldIgnoreTerminalMenuPointerDownOutside', () => {
     ).toBe(true)
   })
 
-  it('allows secondary-button pointerdowns after the menu is open', () => {
-    expect(
-      shouldIgnoreTerminalMenuPointerDownOutside({
-        openedAtMs: 1_000,
-        nowMs: 1_250
-      })
-    ).toBe(false)
-  })
-
-  it('allows macOS control-click after the opening-gesture window', () => {
-    expect(
-      shouldIgnoreTerminalMenuPointerDownOutside({
-        openedAtMs: 1_000,
-        nowMs: 1_250
-      })
-    ).toBe(false)
-  })
-
   it('allows ordinary outside left-click dismissals', () => {
     expect(
       shouldIgnoreTerminalMenuPointerDownOutside({
diff --git a/src/renderer/src/components/terminal-pane/terminal-layout-overlay-focus.test.tsx b/src/renderer/src/components/terminal-pane/terminal-layout-overlay-focus.test.tsx
index d8684dd5df1..a1d4cb730b1 100644
--- a/src/renderer/src/components/terminal-pane/terminal-layout-overlay-focus.test.tsx
+++ b/src/renderer/src/components/terminal-pane/terminal-layout-overlay-focus.test.tsx
@@ -9,10 +9,12 @@ function createLayoutFixture() {
   document.body.append(textarea)
   textarea.focus()
   const terminal = { focus: vi.fn(() => textarea.focus()) }
+  const pane = { terminal, container: document.createElement('div') }
+  // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: fitAndFocusPanes reads only these members, and the focus path reads only a pane's terminal and container.
   const manager = {
     fitAllPanes: vi.fn(),
-    getActivePane: () => ({ terminal }),
-    getPanes: () => [{ terminal }]
+    getActivePane: () => pane,
+    getPanes: () => [pane]
   } as unknown as PaneManager
   return { manager, terminal, textarea }
 }
diff --git a/src/renderer/src/components/terminal-pane/terminal-pane-menu-paste.ts b/src/renderer/src/components/terminal-pane/terminal-pane-menu-paste.ts
index b27900d2097..0e172dca2a2 100644
--- a/src/renderer/src/components/terminal-pane/terminal-pane-menu-paste.ts
+++ b/src/renderer/src/components/terminal-pane/terminal-pane-menu-paste.ts
@@ -1,5 +1,6 @@
 import type { ManagedPane, PaneManager } from '@/lib/pane-manager/pane-manager'
 import type { PtyTransport } from './pty-transport'
+import { requestNativeChatCoverPaste } from './native-chat-cover-paste'
 import { getConnectionId } from '@/lib/connection-context'
 import { getRuntimeEnvironmentIdForWorktree } from '@/lib/worktree-runtime-owner'
 import { pasteTerminalText } from './terminal-bracketed-paste'
@@ -114,6 +115,9 @@ export const pasteTerminalPaneMenuClipboard = async (
   if (!pane) {
     return
   }
+  if (requestNativeChatCoverPaste(pane)) {
+    return
+  }
   const { tabId, worktreeId, forceBracketedMultilineTextPaste, onPasteError } = context
   const connectionId = getConnectionId(worktreeId) ?? null
   const state = useAppStore.getState()
diff --git a/src/renderer/src/components/terminal-pane/terminal-pane-paste-listeners.ts b/src/renderer/src/components/terminal-pane/terminal-pane-paste-listeners.ts
index 85e5385571b..77cf5bb020a 100644
--- a/src/renderer/src/components/terminal-pane/terminal-pane-paste-listeners.ts
+++ b/src/renderer/src/components/terminal-pane/terminal-pane-paste-listeners.ts
@@ -16,18 +16,13 @@ import {
 } from '@/lib/app-menu-selection-actions'
 import { isEditableTarget } from '@/lib/editable-target'
 import { copyTerminalSelection } from './terminal-selection-copy'
+import { isInsideNativeChatCover } from './native-chat-covered-pane'
 import type { TerminalPaneCloseController } from './use-terminal-pane-close-actions'
 import {
   formatClipboardImagePasteError,
   type TerminalPanePasteExecution
 } from './terminal-pane-paste-execution'
 
-const NATIVE_CHAT_ROOT_SELECTOR = '[data-native-chat-root="true"]'
-
-function isInsideNativeChatRoot(target: EventTarget | null): boolean {
-  return target instanceof Element && target.closest(NATIVE_CHAT_ROOT_SELECTOR) !== null
-}
-
 export function registerTerminalPanePasteListeners({
   container,
   controller,
@@ -73,7 +68,7 @@ export function registerTerminalPanePasteListeners({
     const target = event.target
     if (
       (target instanceof Element && target.closest('[data-terminal-search-root]')) ||
-      isInsideNativeChatRoot(target)
+      isInsideNativeChatCover(target)
     ) {
       return
     }
@@ -125,7 +120,7 @@ export function registerTerminalPanePasteListeners({
     const target = event.target
     if (
       (target instanceof Element && target.closest('[data-terminal-search-root]')) ||
-      isInsideNativeChatRoot(target)
+      isInsideNativeChatCover(target)
     ) {
       return
     }
@@ -160,12 +155,15 @@ export function registerTerminalPanePasteListeners({
   }
 
   const onAppMenuPaste = (event: Event): void => {
+    if (event.defaultPrevented) {
+      return
+    }
     const activeElementAtDispatch = document.activeElement
     if (
       !(activeElementAtDispatch instanceof Element) ||
       !container.contains(activeElementAtDispatch) ||
       activeElementAtDispatch.closest('[data-terminal-search-root]') ||
-      isInsideNativeChatRoot(activeElementAtDispatch)
+      isInsideNativeChatCover(activeElementAtDispatch)
     ) {
       return
     }
@@ -205,7 +203,7 @@ export function registerTerminalPanePasteListeners({
       !container.contains(activeElement) ||
       isEditableTarget(activeElement) ||
       activeElement.closest('[data-terminal-search-root]') ||
-      isInsideNativeChatRoot(activeElement)
+      isInsideNativeChatCover(activeElement)
     ) {
       return
     }
diff --git a/src/renderer/src/components/terminal-pane/use-covered-terminal-focus-handoff.ts b/src/renderer/src/components/terminal-pane/use-covered-terminal-focus-handoff.ts
new file mode 100644
index 00000000000..7c58cfe63f4
--- /dev/null
+++ b/src/renderer/src/components/terminal-pane/use-covered-terminal-focus-handoff.ts
@@ -0,0 +1,33 @@
+import { useLayoutEffect, type RefObject } from 'react'
+import type { Terminal } from '@xterm/xterm'
+
+/**
+ * A terminal under a chat cover must never hold focus: its keys would reach an
+ * agent the user cannot see. Hands focus to the cover in the commit that mounts
+ * it, then marks the xterm inert so no later terminal.focus() can take it back.
+ */
+export function useCoveredTerminalFocusHandoff(
+  coverRef: RefObject<HTMLElement | null>,
+  terminal: Pick<Terminal, 'element' | 'focus'>
+): void {
+  useLayoutEffect(() => {
+    const cover = coverRef.current
+    const terminalElement = terminal.element
+    if (!cover || !terminalElement) {
+      return
+    }
+    const ownerDocument = cover.ownerDocument
+    // Focus first: making a focused element inert drops focus to <body>.
+    if (terminalElement.contains(ownerDocument.activeElement)) {
+      cover.focus({ preventScroll: true })
+    }
+    terminalElement.inert = true
+    return () => {
+      terminalElement.inert = false
+      // Unmount cleanup runs before React detaches the cover, so this still sees chat focus.
+      if (cover.contains(ownerDocument.activeElement)) {
+        terminal.focus()
+      }
+    }
+  }, [coverRef, terminal])
+}
diff --git a/src/renderer/src/i18n/locales/en.json b/src/renderer/src/i18n/locales/en.json
index 8fe2d7fd7fe..1859cb84d74 100644
--- a/src/renderer/src/i18n/locales/en.json
+++ b/src/renderer/src/i18n/locales/en.json
@@ -17575,6 +17575,7 @@
         "imagePasteFailed": "Image paste failed.",
         "imageSaving": "Saving pasted image…",
         "worktreeNotReady": "Worktree not ready — try again in a moment.",
+        "pasteUnavailable": "Can't paste — this chat isn't accepting input right now.",
         "uploadingAttachments": "Uploading {{value0}} file(s) to remote…",
         "model": "Model",
         "effort": "Effort",
@@ -17855,6 +17856,9 @@
         "title": "Context",
         "estimated": "Estimated from the last response."
       },
+      "dismissDeliveryNotice": "Dismiss",
+      "messageNotSent": "Message not sent",
+      "deliveryUnconfirmed": "Delivery unconfirmed — check chat before retrying",
       "queuedMessages": {
         "behindReturnedHold": "Waiting — a message ahead needs attention",
         "awaitingAnswerHold": "Waiting for your answer",
diff --git a/src/renderer/src/i18n/locales/es.json b/src/renderer/src/i18n/locales/es.json
index cff8a942dc5..731806faa3b 100644
--- a/src/renderer/src/i18n/locales/es.json
+++ b/src/renderer/src/i18n/locales/es.json
@@ -14972,6 +14972,7 @@
         "pastedImageLabel": "Imagen pegada",
         "imagePasteFailed": "Error al pegar imagen.",
         "worktreeNotReady": "Worktree no está listo — intenta de nuevo en un momento.",
+        "pasteUnavailable": "No se puede pegar — este chat no acepta entradas en este momento.",
         "uploadingAttachments": "Subiendo {{value0}} archivo(s) al remoto…",
         "model": "Modelo",
         "effort": "Esfuerzo",
@@ -15082,6 +15083,9 @@
         "title": "Contexto",
         "estimated": "Estimado a partir de la última respuesta."
       },
+      "dismissDeliveryNotice": "Descartar",
+      "messageNotSent": "Mensaje no enviado",
+      "deliveryUnconfirmed": "Entrega sin confirmar — revisa el chat antes de reintentar",
       "subagents": {
         "unnamed": "Subagente"
       },
diff --git a/src/renderer/src/i18n/locales/fr.json b/src/renderer/src/i18n/locales/fr.json
index 3620dbb83cc..65acfdf49e9 100644
--- a/src/renderer/src/i18n/locales/fr.json
+++ b/src/renderer/src/i18n/locales/fr.json
@@ -17461,6 +17461,7 @@
         "pastedImageLabel": "Image collée",
         "imagePasteFailed": "Échec du collage de l'image.",
         "worktreeNotReady": "Worktree pas encore prêt — réessayez dans un instant.",
+        "pasteUnavailable": "Impossible de coller — ce chat n'accepte pas de saisie pour le moment.",
         "uploadingAttachments": "Envoi de {{value0}} fichier(s) vers le distant…",
         "model": "Modèle",
         "effort": "Effort",
@@ -17776,6 +17777,9 @@
         "title": "Contexte",
         "estimated": "Estimation basée sur la dernière réponse."
       },
+      "dismissDeliveryNotice": "Ignorer",
+      "messageNotSent": "Message non envoyé",
+      "deliveryUnconfirmed": "Livraison non confirmée — vérifiez le chat avant de réessayer",
       "queuedMessages": {
         "alreadySent": "Ce message a déjà été envoyé.",
         "editAlreadySent": "Déjà envoyé — votre texte reste dans la zone de saisie.",
diff --git a/src/renderer/src/i18n/locales/ja.json b/src/renderer/src/i18n/locales/ja.json
index d3ccaa3cd93..85491478e07 100644
--- a/src/renderer/src/i18n/locales/ja.json
+++ b/src/renderer/src/i18n/locales/ja.json
@@ -17382,6 +17382,7 @@
         "pastedImageLabel": "貼り付けた画像",
         "imagePasteFailed": "画像の貼り付けに失敗しました。",
         "worktreeNotReady": "ワークツリーが準備できていません — しばらくしてから再試行してください。",
+        "pasteUnavailable": "貼り付けできません — このチャットは現在入力を受け付けていません。",
         "uploadingAttachments": "{{value0}}個のファイルをリモートにアップロード中…",
         "model": "モデル",
         "effort": "推論レベル",
@@ -17712,6 +17713,9 @@
         "title": "コンテキスト",
         "estimated": "最後の応答から推定。"
       },
+      "dismissDeliveryNotice": "閉じる",
+      "messageNotSent": "メッセージは送信されませんでした",
+      "deliveryUnconfirmed": "配信を確認できません — 再試行する前にチャットを確認してください",
       "queuedMessages": {
         "alreadySent": "このメッセージはすでに送信されています。",
         "editAlreadySent": "すでに送信されています — テキストは入力欄に残っています。",
diff --git a/src/renderer/src/i18n/locales/ko.json b/src/renderer/src/i18n/locales/ko.json
index 8d05184f6f9..180ed46c24f 100644
--- a/src/renderer/src/i18n/locales/ko.json
+++ b/src/renderer/src/i18n/locales/ko.json
@@ -17382,6 +17382,7 @@
         "pastedImageLabel": "붙여넣은 이미지",
         "imagePasteFailed": "이미지 붙여넣기 실패.",
         "worktreeNotReady": "워크트리가 준비되지 않았습니다 — 잠시 후 다시 시도하세요.",
+        "pasteUnavailable": "붙여넣을 수 없습니다 — 이 채팅은 지금 입력을 받을 수 없습니다.",
         "uploadingAttachments": "{{value0}}개 파일을 원격으로 업로드 중…",
         "model": "모델",
         "effort": "추론 수준",
@@ -17712,6 +17713,9 @@
         "title": "컨텍스트",
         "estimated": "마지막 응답 기준 추정치입니다."
       },
+      "dismissDeliveryNotice": "닫기",
+      "messageNotSent": "메시지가 전송되지 않음",
+      "deliveryUnconfirmed": "전달 확인 안 됨 — 다시 시도하기 전에 채팅을 확인하세요",
       "queuedMessages": {
         "alreadySent": "이 메시지는 이미 전송되었습니다.",
         "editAlreadySent": "이미 전송되었습니다 — 텍스트는 입력창에 남아 있습니다.",
diff --git a/src/renderer/src/i18n/locales/zh.json b/src/renderer/src/i18n/locales/zh.json
index f2d1533f235..42d4d19309b 100644
--- a/src/renderer/src/i18n/locales/zh.json
+++ b/src/renderer/src/i18n/locales/zh.json
@@ -17347,6 +17347,7 @@
         "pastedImageLabel": "粘贴的图片",
         "imagePasteFailed": "图片粘贴失败。",
         "worktreeNotReady": "工作树未就绪 — 请稍后重试。",
+        "pasteUnavailable": "无法粘贴 — 此聊天当前不接受输入。",
         "uploadingAttachments": "正在将 {{value0}} 个文件上传到远端…",
         "model": "模型",
         "effort": "推理强度",
@@ -17677,6 +17678,9 @@
         "title": "上下文",
         "estimated": "根据上一次响应的估算值。"
       },
+      "dismissDeliveryNotice": "关闭",
+      "messageNotSent": "消息未发送",
+      "deliveryUnconfirmed": "无法确认送达 — 重试前请检查聊天",
       "queuedMessages": {
         "alreadySent": "此消息已发送。",
         "editAlreadySent": "已发送 — 你的文本仍在输入框中。",
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 3b15ba33e17..375620b9311 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
@@ -598,17 +598,6 @@ describe('launchAgentInNewTab', () => {
     )
   })
 
-  it('does not track prompt-sent for argv prompt launches', async () => {
-    const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
-
-    launchAgentInNewTab({
-      agent: 'codex',
-      worktreeId: 'wt-1',
-      prompt: 'fix the spinner',
-      launchSource: 'onboarding'
-    })
-  })
-
   it('does not track prompt-sent for draft launches', async () => {
     const { launchAgentInNewTab } = await import('./launch-agent-in-new-tab')
 
diff --git a/src/renderer/src/lib/native-chat-paste-request.ts b/src/renderer/src/lib/native-chat-paste-request.ts
new file mode 100644
index 00000000000..9f13a180a14
--- /dev/null
+++ b/src/renderer/src/lib/native-chat-paste-request.ts
@@ -0,0 +1,18 @@
+import { translate } from '@/i18n/i18n'
+
+export const NATIVE_CHAT_PASTE_REQUEST_EVENT = 'orca-native-chat-paste-request'
+export const NATIVE_CHAT_ROOT_SELECTOR = '[data-native-chat-root="true"]'
+
+/** Asks a mounted chat root to paste the clipboard; left unclaimed when no chat input can take it. */
+export class NativeChatPasteRequest extends Event {
+  constructor() {
+    super(NATIVE_CHAT_PASTE_REQUEST_EVENT, { cancelable: true })
+  }
+}
+
+export function nativeChatPasteUnavailableNotice(): string {
+  return translate(
+    'components.native-chat.composer.pasteUnavailable',
+    "Can't paste — this chat isn't accepting input right now."
+  )
+}
diff --git a/src/renderer/src/lib/pane-manager/pane-dom-creation.test.ts b/src/renderer/src/lib/pane-manager/pane-dom-creation.test.ts
index fd0ff5e88ec..b9b969bfb0f 100644
--- a/src/renderer/src/lib/pane-manager/pane-dom-creation.test.ts
+++ b/src/renderer/src/lib/pane-manager/pane-dom-creation.test.ts
@@ -2,6 +2,9 @@
 import { describe, expect, it, vi } from 'vitest'
 import type { TerminalLeafId } from '../../../../shared/stable-pane-id'
 import { createPaneDOM } from './pane-dom-creation'
+import { terminalMouseEncodingRestoreAnsi } from './terminal-mouse-encoding-tracker'
+
+const csiHandlers = vi.hoisted(() => new Map<string, (params: (number | number[])[]) => boolean>())
 
 const webLinksAddonMock = vi.hoisted(() => ({
   handler: null as ((event: MouseEvent, uri: string) => void) | null,
@@ -45,7 +48,16 @@ vi.mock('@xterm/xterm', () => ({
     return {
       options: {},
       loadAddon: vi.fn(),
-      open: vi.fn()
+      open: vi.fn(),
+      parser: {
+        registerCsiHandler: vi.fn(
+          (id: { final: string }, handler: (params: (number | number[])[]) => boolean) => {
+            csiHandlers.set(id.final, handler)
+            return { dispose: vi.fn() }
+          }
+        ),
+        registerEscHandler: vi.fn(() => ({ dispose: vi.fn() }))
+      }
     }
   })
 }))
@@ -157,3 +169,21 @@ describe('createPaneDOM link tooltips', () => {
     expect(onLinkClick).toHaveBeenCalledWith(7, event, 'https://example.com')
   })
 })
+
+describe('createPaneDOM mouse encoding', () => {
+  it('tracks the encoding the pane terminal parses so its snapshot can carry it', () => {
+    const leafId = '11111111-1111-4111-8111-111111111111' as TerminalLeafId
+    const pane = createPaneDOM(
+      1,
+      leafId,
+      { linkOpenHint: () => 'open hint' },
+      { active: null } as never,
+      {} as never,
+      vi.fn(),
+      vi.fn()
+    )
+
+    expect(csiHandlers.get('h')?.([1003, 1006])).toBe(false)
+    expect(terminalMouseEncodingRestoreAnsi(pane.terminal)).toBe('\x1b[?1006h')
+  })
+})
diff --git a/src/renderer/src/lib/pane-manager/pane-dom-creation.ts b/src/renderer/src/lib/pane-manager/pane-dom-creation.ts
index 8b66f2c39d9..6313a81cca7 100644
--- a/src/renderer/src/lib/pane-manager/pane-dom-creation.ts
+++ b/src/renderer/src/lib/pane-manager/pane-dom-creation.ts
@@ -14,6 +14,7 @@ import { shouldFocusTerminalFromPanePointerDown } from './pane-pointer-focus'
 import { ENABLE_WEBGL_RENDERER } from './pane-webgl-renderer'
 import { installGuardedLinkProviderRegistration } from './terminal-link-provider-guard'
 import { installWindowsCtrlAltChordRepair } from './terminal-windows-ctrl-alt-chord-classification'
+import { installTerminalMouseEncodingTracker } from './terminal-mouse-encoding-tracker'
 
 function defaultLinkTooltipText(uri: string, openLinkHint: string): string {
   return `${uri} (${openLinkHint})`
@@ -51,6 +52,8 @@ export function createPaneDOM(
   // provider registered after this point — addon-internal and Orca's own.
   installGuardedLinkProviderRegistration(terminal)
   installWindowsCtrlAltChordRepair(terminal)
+  // Why here: the tracker must see every byte, including the first snapshot replay.
+  const mouseEncodingTrackerDisposable = installTerminalMouseEncodingTracker(terminal)
   const fitAddon = new FitAddon()
   const searchAddon = new SearchAddon()
   const unicode11Addon = new Unicode11Addon()
@@ -142,6 +145,7 @@ export function createPaneDOM(
     compositionHandler: null,
     focusClassSyncCleanup: null,
     terminalScrollIntentDisposable: null,
+    mouseEncodingTrackerDisposable,
     linkifierMouseLeaveResetDisposable: null,
     arabicShapingJoinerCleanup: null,
     pendingSplitScrollState: null,
diff --git a/src/renderer/src/lib/pane-manager/pane-lifecycle.ts b/src/renderer/src/lib/pane-manager/pane-lifecycle.ts
index 58e552e244e..4f9ac4a0be9 100644
--- a/src/renderer/src/lib/pane-manager/pane-lifecycle.ts
+++ b/src/renderer/src/lib/pane-manager/pane-lifecycle.ts
@@ -203,6 +203,8 @@ export function disposePane(
   pane.focusClassSyncCleanup = null
   pane.terminalScrollIntentDisposable?.dispose()
   pane.terminalScrollIntentDisposable = null
+  pane.mouseEncodingTrackerDisposable?.dispose()
+  pane.mouseEncodingTrackerDisposable = null
   pane.linkifierHoverResetDisposable?.dispose()
   pane.linkifierHoverResetDisposable = null
   pane.linkifierMouseLeaveResetDisposable?.dispose()
diff --git a/src/renderer/src/lib/pane-manager/pane-manager-types.ts b/src/renderer/src/lib/pane-manager/pane-manager-types.ts
index 6a5089ff7d7..fe4fcb5bc6f 100644
--- a/src/renderer/src/lib/pane-manager/pane-manager-types.ts
+++ b/src/renderer/src/lib/pane-manager/pane-manager-types.ts
@@ -202,6 +202,8 @@ export type ManagedPaneInternal = {
   focusClassSyncCleanup?: (() => void) | null
   // Stored so disposePane() can remove user-scroll intent listeners.
   terminalScrollIntentDisposable?: IDisposable | null
+  // Stored so disposePane() can drop the mouse-encoding parser handlers.
+  mouseEncodingTrackerDisposable?: IDisposable | null
   // Stored so disposePane() can detach the streamed-output hover-cache reset
   // that keeps freshly printed links linkifiable without a scroll.
   linkifierHoverResetDisposable?: IDisposable | null
diff --git a/src/renderer/src/lib/pane-manager/pane-overlay-focus.test.ts b/src/renderer/src/lib/pane-manager/pane-overlay-focus.test.ts
index 1f8d603c89f..93c4a67f97b 100644
--- a/src/renderer/src/lib/pane-manager/pane-overlay-focus.test.ts
+++ b/src/renderer/src/lib/pane-manager/pane-overlay-focus.test.ts
@@ -2,6 +2,7 @@
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import { PaneManager } from './pane-manager'
 import { createInitialManagedPane } from './pane-manager-pane-creation'
+import { focusPanePreservingOverlays } from './pane-overlay-focus'
 import type { PaneManagerHost } from './pane-manager-host'
 import type { ManagedPaneInternal } from './pane-manager-types'
 
@@ -59,6 +60,14 @@ function overlay(role: string) {
   return element
 }
 
+function coverPane(f: ReturnType<typeof fixture>): HTMLElement {
+  const cover = document.createElement('div')
+  cover.className = 'native-chat-pane-shell'
+  cover.tabIndex = -1
+  f.container.append(cover)
+  return cover
+}
+
 describe.each(['initial', 'active'] as const)('%s pane focus', (operation) => {
   function focus(f: ReturnType<typeof fixture>, requested = true) {
     if (operation === 'initial') {
@@ -143,9 +152,29 @@ describe.each(['initial', 'active'] as const)('%s pane focus', (operation) => {
     expect(document.activeElement).toBe(popup)
   })
 
+  it('lands on the chat covering the pane, never its hidden terminal', () => {
+    const f = fixture()
+    f.root.append(f.container)
+    const cover = coverPane(f)
+    focus(f)
+    expect(document.activeElement).toBe(cover)
+    expect(f.pane.terminal.focus).not.toHaveBeenCalled()
+  })
+
   it('honors an explicit no-focus request', () => {
     const f = fixture()
     focus(f, false)
     expect(f.pane.terminal.focus).not.toHaveBeenCalled()
   })
 })
+
+it('keeps focus that is already inside the chat covering the pane', () => {
+  const f = fixture()
+  f.root.append(f.container)
+  const composer = document.createElement('button')
+  coverPane(f).append(composer)
+  composer.focus()
+  focusPanePreservingOverlays(f.pane)
+  expect(document.activeElement).toBe(composer)
+  expect(f.pane.terminal.focus).not.toHaveBeenCalled()
+})
diff --git a/src/renderer/src/lib/pane-manager/pane-overlay-focus.ts b/src/renderer/src/lib/pane-manager/pane-overlay-focus.ts
index bb53245df41..ed9230d9da9 100644
--- a/src/renderer/src/lib/pane-manager/pane-overlay-focus.ts
+++ b/src/renderer/src/lib/pane-manager/pane-overlay-focus.ts
@@ -1,3 +1,4 @@
+import { focusNativeChatCover } from '@/components/terminal-pane/native-chat-covered-pane'
 import { hasVisibleOverlay } from '../visible-overlay'
 import type { ManagedPane } from './pane-manager-types'
 
@@ -15,5 +16,8 @@ export function focusPanePreservingOverlays(
   ) {
     return
   }
+  if (focusNativeChatCover(pane)) {
+    return
+  }
   pane.terminal.focus()
 }
diff --git a/src/renderer/src/lib/pane-manager/terminal-mouse-encoding-tracker.test.ts b/src/renderer/src/lib/pane-manager/terminal-mouse-encoding-tracker.test.ts
new file mode 100644
index 00000000000..21fbf36b54e
--- /dev/null
+++ b/src/renderer/src/lib/pane-manager/terminal-mouse-encoding-tracker.test.ts
@@ -0,0 +1,68 @@
+import { describe, expect, it } from 'vitest'
+import { Terminal } from '@xterm/headless'
+import {
+  installTerminalMouseEncodingTracker,
+  terminalMouseEncodingRestoreAnsi
+} from './terminal-mouse-encoding-tracker'
+
+const ESC = '\x1b'
+
+function write(terminal: Terminal, data: string): Promise<void> {
+  return new Promise((resolve) => terminal.write(data, resolve))
+}
+
+type XtermMouseStateAccess = { _core?: { mouseStateService?: { activeEncoding?: string } } }
+
+// xterm's own (private) encoding, so each case also proves the mirror agrees with xterm.
+function xtermEncoding(terminal: Terminal): string | undefined {
+  // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: test-only read of xterm's private mouse state; every level is optional.
+  return (terminal as unknown as XtermMouseStateAccess)._core?.mouseStateService?.activeEncoding
+}
+
+async function trackedAfter(...chunks: string[]) {
+  const terminal = new Terminal({ cols: 40, rows: 10, allowProposedApi: true })
+  installTerminalMouseEncodingTracker(terminal)
+  for (const chunk of chunks) {
+    await write(terminal, chunk)
+  }
+  return { restore: terminalMouseEncodingRestoreAnsi(terminal), xterm: xtermEncoding(terminal) }
+}
+
+describe('terminal mouse encoding tracker', () => {
+  it.each([
+    ['nothing', [], '', 'DEFAULT'],
+    ['SGR (1006h)', [`${ESC}[?1006h`], `${ESC}[?1006h`, 'SGR'],
+    ['SGR pixels (1016h)', [`${ESC}[?1016h`], `${ESC}[?1016h`, 'SGR_PIXELS'],
+    ['a combined ?1003;1006h', [`${ESC}[?1003;1006h`], `${ESC}[?1006h`, 'SGR'],
+    [
+      'the Codex start-up sequence',
+      [`${ESC}[?1049h${ESC}[?1000h${ESC}[?1002h${ESC}[?1003h${ESC}[?1015h${ESC}[?1006h`],
+      `${ESC}[?1006h`,
+      'SGR'
+    ],
+    ['the last of ?1006;1016h', [`${ESC}[?1006;1016h`], `${ESC}[?1016h`, 'SGR_PIXELS'],
+    ['1006l after 1006h', [`${ESC}[?1006h`, `${ESC}[?1006l`], '', 'DEFAULT'],
+    // xterm resets to the default on either reset, not only the active one.
+    ['1006l after 1016h', [`${ESC}[?1016h`, `${ESC}[?1006l`], '', 'DEFAULT'],
+    ['1016l after 1006h', [`${ESC}[?1006h`, `${ESC}[?1016l`], '', 'DEFAULT'],
+    ['RIS after 1006h', [`${ESC}[?1006h`, `${ESC}c`], '', 'DEFAULT'],
+    ['a DECSET split across writes', [`${ESC}[?10`, '06h'], `${ESC}[?1006h`, 'SGR'],
+    ['a non-mouse private mode', [`${ESC}[?1006h`, `${ESC}[?25l`], `${ESC}[?1006h`, 'SGR']
+  ])('mirrors %s', async (_name, chunks, restore, xterm) => {
+    expect(await trackedAfter(...chunks)).toEqual({ restore, xterm })
+  })
+
+  it('stops tracking once disposed', async () => {
+    const terminal = new Terminal({ cols: 40, rows: 10, allowProposedApi: true })
+    const tracker = installTerminalMouseEncodingTracker(terminal)
+    await write(terminal, `${ESC}[?1006h`)
+    tracker.dispose()
+    expect(terminalMouseEncodingRestoreAnsi(terminal)).toBe('')
+  })
+
+  it('tolerates a terminal without a parser', () => {
+    const terminal = {}
+    installTerminalMouseEncodingTracker(terminal).dispose()
+    expect(terminalMouseEncodingRestoreAnsi(terminal)).toBe('')
+  })
+})
diff --git a/src/renderer/src/lib/pane-manager/terminal-mouse-encoding-tracker.ts b/src/renderer/src/lib/pane-manager/terminal-mouse-encoding-tracker.ts
new file mode 100644
index 00000000000..f07c94f20ce
--- /dev/null
+++ b/src/renderer/src/lib/pane-manager/terminal-mouse-encoding-tracker.ts
@@ -0,0 +1,103 @@
+import type { IDisposable } from '@xterm/xterm'
+import { guardParserHandler } from '@/components/terminal-pane/terminal-parser-handler-guard'
+
+// Why this module exists: xterm keeps the mouse report encoding (DECSET 1006 /
+// 1016) private, and SerializeAddon writes the tracking modes without it. A
+// replayed pane snapshot therefore reads as "legacy `ESC[M` reports", which a
+// phone then types into an SGR-only TUI. Mirroring the encoding from the
+// parser lets the pane snapshot carry it in-band.
+
+type TerminalMouseEncoding = 'default' | 'sgr' | 'sgr-pixels'
+
+type PrivateModeParams = (number | number[])[]
+
+export type TerminalMouseEncodingTrackerTarget = {
+  parser?: {
+    registerCsiHandler?: (
+      id: { prefix?: string; final: string },
+      handler: (params: PrivateModeParams) => boolean
+    ) => IDisposable
+    registerEscHandler?: (id: { final: string }, handler: () => boolean) => IDisposable
+  }
+}
+
+const SGR_MOUSE_MODE = 1006
+const SGR_PIXELS_MOUSE_MODE = 1016
+
+const encodingByTerminal = new WeakMap<object, TerminalMouseEncoding>()
+
+// Mirrors xterm's InputHandler.setModePrivate / resetModePrivate: params apply
+// in order, and a reset of either mode returns to the default encoding.
+function applyPrivateModes(
+  terminal: TerminalMouseEncodingTrackerTarget,
+  params: PrivateModeParams,
+  set: boolean
+): boolean {
+  let encoding = encodingByTerminal.get(terminal) ?? 'default'
+  for (const param of params) {
+    if (param === SGR_MOUSE_MODE) {
+      encoding = set ? 'sgr' : 'default'
+    } else if (param === SGR_PIXELS_MOUSE_MODE) {
+      encoding = set ? 'sgr-pixels' : 'default'
+    }
+  }
+  encodingByTerminal.set(terminal, encoding)
+  // Why false: this observes the mode change; xterm's own handler still applies it.
+  return false
+}
+
+/** Mirror the terminal's mouse encoding from every parsed byte, snapshot replays included. */
+export function installTerminalMouseEncodingTracker(
+  terminal: TerminalMouseEncodingTrackerTarget
+): IDisposable {
+  encodingByTerminal.set(terminal, 'default')
+  const parser = terminal.parser
+  const registrations = [
+    parser?.registerCsiHandler?.(
+      { prefix: '?', final: 'h' },
+      guardParserHandler('mouse-encoding-decset', (params: PrivateModeParams) =>
+        applyPrivateModes(terminal, params, true)
+      )
+    ),
+    parser?.registerCsiHandler?.(
+      { prefix: '?', final: 'l' },
+      guardParserHandler('mouse-encoding-decrst', (params: PrivateModeParams) =>
+        applyPrivateModes(terminal, params, false)
+      )
+    ),
+    // RIS (ESC c) resets xterm's mouse service to the default encoding.
+    parser?.registerEscHandler?.(
+      { final: 'c' },
+      guardParserHandler('mouse-encoding-ris', () => {
+        encodingByTerminal.set(terminal, 'default')
+        return false
+      })
+    )
+  ]
+  return {
+    dispose(): void {
+      for (const registration of registrations) {
+        registration?.dispose()
+      }
+      encodingByTerminal.delete(terminal)
+    }
+  }
+}
+
+const RESTORE_ANSI_BY_ENCODING: Record<TerminalMouseEncoding, string> = {
+  default: '',
+  sgr: `\x1b[?${SGR_MOUSE_MODE}h`,
+  'sgr-pixels': `\x1b[?${SGR_PIXELS_MOUSE_MODE}h`
+}
+
+/** The DECSET that restores this terminal's mouse encoding on replay. */
+export function terminalMouseEncodingRestoreAnsi(terminal: {
+  modes?: { mouseTrackingMode?: string }
+}): string {
+  const encoding = encodingByTerminal.get(terminal) ?? 'default'
+  if (encoding === 'default' && (terminal.modes?.mouseTrackingMode ?? 'none') !== 'none') {
+    // Why: states the default while tracking, so a replay reader never has to guess it.
+    return `\x1b[?${SGR_MOUSE_MODE}l`
+  }
+  return RESTORE_ANSI_BY_ENCODING[encoding]
+}
diff --git a/src/renderer/src/lib/react-commit-cascade-install-order.test.ts b/src/renderer/src/lib/react-commit-cascade-install-order.test.ts
index 2f5a1227e89..92f6447d3e3 100644
--- a/src/renderer/src/lib/react-commit-cascade-install-order.test.ts
+++ b/src/renderer/src/lib/react-commit-cascade-install-order.test.ts
@@ -126,12 +126,4 @@ describe('react commit cascade shim install order', () => {
       /^\s*(?:import|export)\b[\s\S]*?\bfrom\s*(?:\/\*[\s\S]*?\*\/\s*)*['"]|^\s*import\s*['"]|\bimport\s*\(/m
     )
   })
-
-  it('follows local hops when checking a graph for react-dom', () => {
-    const observerFile = join(RENDERER_ROOT, 'lib', 'react-commit-cascade-observer.ts')
-
-    // The observer's own graph is allowed to be wide; this only proves the walker
-    // above sees past the first hop, so an empty shim graph means something.
-    expect(transitiveSpecifiers(observerFile).size).toBeGreaterThan(3)
-  })
 })
diff --git a/src/renderer/src/lib/scroll-cache.test.ts b/src/renderer/src/lib/scroll-cache.test.ts
index 18ecd33bfdc..fdb1fe52edd 100644
--- a/src/renderer/src/lib/scroll-cache.test.ts
+++ b/src/renderer/src/lib/scroll-cache.test.ts
@@ -1,18 +1,5 @@
-import { describe, expect, it, beforeEach } from 'vitest'
-import {
-  editorSelectionCache,
-  diffViewStateCache,
-  pdfViewPositionCache,
-  setWithLRU,
-  scrollTopCache
-} from './scroll-cache'
-
-beforeEach(() => {
-  scrollTopCache.clear()
-  editorSelectionCache.clear()
-  diffViewStateCache.clear()
-  pdfViewPositionCache.clear()
-})
+import { describe, expect, it } from 'vitest'
+import { setWithLRU } from './scroll-cache'
 
 describe('setWithLRU', () => {
   it('inserts a new entry into the map', () => {
@@ -102,111 +89,3 @@ describe('setWithLRU', () => {
     expect(map.has('new')).toBe(true)
   })
 })
-
-describe('scrollTopCache', () => {
-  it('is an empty Map on import', () => {
-    expect(scrollTopCache).toBeInstanceOf(Map)
-    expect(scrollTopCache.size).toBe(0)
-  })
-
-  it('works with setWithLRU for mode-scoped keys', () => {
-    setWithLRU(scrollTopCache, '/path/to/file.ts', 100)
-    setWithLRU(scrollTopCache, '/path/to/file.ts:preview', 200)
-    setWithLRU(scrollTopCache, '/path/to/file.ts:rich', 300)
-    expect(scrollTopCache.get('/path/to/file.ts')).toBe(100)
-    expect(scrollTopCache.get('/path/to/file.ts:preview')).toBe(200)
-    expect(scrollTopCache.get('/path/to/file.ts:rich')).toBe(300)
-    expect(scrollTopCache.size).toBe(3)
-  })
-})
-
-describe('editorSelectionCache', () => {
-  it('keeps each pane selection independent', () => {
-    const firstSelection = {
-      selectionStartLineNumber: 2,
-      selectionStartColumn: 3,
-      positionLineNumber: 4,
-      positionColumn: 5
-    }
-    const secondSelection = {
-      selectionStartLineNumber: 8,
-      selectionStartColumn: 2,
-      positionLineNumber: 6,
-      positionColumn: 1
-    }
-
-    setWithLRU(editorSelectionCache, '/path/to/file.ts', [firstSelection])
-    setWithLRU(editorSelectionCache, '/path/to/file.ts::tab-2', [secondSelection])
-
-    expect(editorSelectionCache.get('/path/to/file.ts')).toEqual([firstSelection])
-    expect(editorSelectionCache.get('/path/to/file.ts::tab-2')).toEqual([secondSelection])
-  })
-})
-
-describe('pdfViewPositionCache', () => {
-  it('is an empty Map on import', () => {
-    expect(pdfViewPositionCache).toBeInstanceOf(Map)
-    expect(pdfViewPositionCache.size).toBe(0)
-  })
-
-  it('round-trips pageNumber, top, and left intact', () => {
-    setWithLRU(pdfViewPositionCache, '/doc.pdf:pdf', { pageNumber: 12, top: 431.5, left: 62 })
-    expect(pdfViewPositionCache.get('/doc.pdf:pdf')).toEqual({
-      pageNumber: 12,
-      top: 431.5,
-      left: 62
-    })
-  })
-
-  it('keeps pane-scoped keys for the same file independent', () => {
-    setWithLRU(pdfViewPositionCache, '/doc.pdf:pdf', { pageNumber: 3, top: 700, left: 0 })
-    setWithLRU(pdfViewPositionCache, '/doc.pdf::tab-2:pdf', { pageNumber: 40, top: 120, left: 0 })
-    expect(pdfViewPositionCache.get('/doc.pdf:pdf')?.pageNumber).toBe(3)
-    expect(pdfViewPositionCache.get('/doc.pdf::tab-2:pdf')?.pageNumber).toBe(40)
-  })
-
-  it('evicts the oldest entry at the default cap of 20', () => {
-    for (let i = 0; i <= 20; i++) {
-      setWithLRU(pdfViewPositionCache, `/doc-${i}.pdf:pdf`, { pageNumber: i, top: 0, left: 0 })
-    }
-    expect(pdfViewPositionCache.size).toBe(20)
-    expect(pdfViewPositionCache.has('/doc-0.pdf:pdf')).toBe(false)
-    expect(pdfViewPositionCache.has('/doc-20.pdf:pdf')).toBe(true)
-  })
-
-  it('refreshes recency when an existing PDF key is re-set', () => {
-    for (let i = 0; i < 20; i++) {
-      setWithLRU(pdfViewPositionCache, `/doc-${i}.pdf:pdf`, { pageNumber: i, top: 0, left: 0 })
-    }
-    setWithLRU(pdfViewPositionCache, '/doc-0.pdf:pdf', { pageNumber: 99, top: 0, left: 0 })
-    setWithLRU(pdfViewPositionCache, '/doc-new.pdf:pdf', { pageNumber: 1, top: 0, left: 0 })
-    expect(pdfViewPositionCache.get('/doc-0.pdf:pdf')?.pageNumber).toBe(99)
-    expect(pdfViewPositionCache.has('/doc-1.pdf:pdf')).toBe(false)
-  })
-})
-
-describe('diffViewStateCache', () => {
-  it('is an empty Map on import', () => {
-    expect(diffViewStateCache).toBeInstanceOf(Map)
-    expect(diffViewStateCache.size).toBe(0)
-  })
-
-  it('works with setWithLRU for diff-tab keys', () => {
-    const diffState = {
-      original: {
-        cursorState: [],
-        viewState: { scrollTop: 10, scrollTopWithoutViewZones: 10, scrollLeft: 0 }
-      },
-      modified: {
-        cursorState: [],
-        viewState: { scrollTop: 20, scrollTopWithoutViewZones: 20, scrollLeft: 0 }
-      },
-      modelState: { unchangedRegions: [] }
-    } as unknown as typeof diffViewStateCache extends Map<string, infer T> ? T : never
-
-    setWithLRU(diffViewStateCache, 'diff-tab', diffState)
-
-    expect(diffViewStateCache.get('diff-tab')).toBe(diffState)
-    expect(diffViewStateCache.size).toBe(1)
-  })
-})
diff --git a/src/renderer/src/lib/workspace-activation-path-gate.test.ts b/src/renderer/src/lib/workspace-activation-path-gate.test.ts
index b4b8e2de049..3ce3b73c22d 100644
--- a/src/renderer/src/lib/workspace-activation-path-gate.test.ts
+++ b/src/renderer/src/lib/workspace-activation-path-gate.test.ts
@@ -4,7 +4,6 @@ import type { FolderWorkspace } from '../../../shared/folder-workspace-types'
 import type { ProjectGroup } from '../../../shared/project-group-types'
 import type { FolderWorkspacePathStatusReason } from '../../../shared/folder-workspace-path-status'
 import { folderWorkspaceKey } from '../../../shared/workspace-scope'
-import { resolveWindowShortcutAction } from '../../../shared/window-shortcut-policy'
 
 // Why: drives the real activation module against a real store, so a regression in
 // the workspace dispatch or in the path-status guard itself both surface here.
@@ -112,26 +111,6 @@ describe('Cmd/Ctrl+1-9 folder-workspace path gate (#10716)', () => {
     expect(mocks.toastError).not.toHaveBeenCalled()
   })
 
-  // Why per AGENTS.md: the gate must hold on Windows/Linux Ctrl too, not just Cmd.
-  // The digit chord resolves to the same jumpToWorktreeIndex action on every platform,
-  // so all three land on the guarded activator this suite pins above.
-  it.each([
-    ['darwin' as const, { key: '1', code: 'Digit1', metaKey: true }],
-    ['win32' as const, { key: '1', code: 'Digit1', ctrlKey: true }],
-    ['linux' as const, { key: '1', code: 'Digit1', ctrlKey: true }]
-  ])('routes the %s number chord to jumpToWorktreeIndex', (platform, input) => {
-    expect(resolveWindowShortcutAction(input, platform)).toEqual({
-      type: 'jumpToWorktreeIndex',
-      index: 0
-    })
-  })
-
-  it('does not fire the macOS chord on Windows/Linux, so Ctrl is the only path there', () => {
-    expect(
-      resolveWindowShortcutAction({ key: '1', code: 'Digit1', metaKey: true }, 'win32')
-    ).not.toEqual({ type: 'jumpToWorktreeIndex', index: 0 })
-  })
-
   // Why: the guard only helps if the IPC handler actually calls it. Pin the source
   // so re-pointing the handler back at the unguarded activateAndRevealWorktree fails.
   it('wires onJumpToWorktreeIndex to the guarded workspace activator', async () => {
diff --git a/src/renderer/src/lib/worktree-display-name-order.test.ts b/src/renderer/src/lib/worktree-display-name-order.test.ts
index 70477ca8454..7a522f22958 100644
--- a/src/renderer/src/lib/worktree-display-name-order.test.ts
+++ b/src/renderer/src/lib/worktree-display-name-order.test.ts
@@ -45,16 +45,4 @@ describe('compareWorktreeDisplayName', () => {
       compareWorktreeDisplayName(worktree('a', 'Apple'), worktree('b', 'Banana'))
     ).toBeLessThan(0)
   })
-
-  it('keeps Array.sort safe when the list contains an undefined-name worktree', () => {
-    const worktrees = [worktree('a', 'Charlie'), worktree('b', undefined), worktree('c', 'Alpha')]
-    expect(() =>
-      [...worktrees].sort((x, y) => {
-        if (x.lastActivityAt !== y.lastActivityAt) {
-          return y.lastActivityAt - x.lastActivityAt
-        }
-        return compareWorktreeDisplayName(x, y)
-      })
-    ).not.toThrow()
-  })
 })
diff --git a/src/renderer/src/lib/worktree-runtime-owner-index.detected-perf.test.ts b/src/renderer/src/lib/worktree-runtime-owner-index.detected-perf.test.ts
index 7b574cd27f5..4ac0c6ff836 100644
--- a/src/renderer/src/lib/worktree-runtime-owner-index.detected-perf.test.ts
+++ b/src/renderer/src/lib/worktree-runtime-owner-index.detected-perf.test.ts
@@ -1,16 +1,11 @@
-import { writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
 import { describe, expect, it } from 'vitest'
 import type { ExecutionHostId } from '../../../shared/execution-host'
-import { hasIndexedDetectedWorktree } from './worktree-runtime-owner-index'
 import { getExplicitRuntimeEnvironmentIdForWorktree } from './worktree-runtime-owner'
 import type { WorktreeRuntimeOwnerState } from './worktree-runtime-owner-state'
 
 const REPO_COUNT = 20
 const WORKTREES_PER_REPO = 100
 const LOOKUPS_PER_SWEEP = 200
-const SWEEPS = 40
 
 type OwnerRecord = {
   id: string
@@ -84,29 +79,6 @@ const PROBE_IDS = Array.from(
   (_unused, index) => `repo-${index % REPO_COUNT}::worktree-${index % WORKTREES_PER_REPO}`
 )
 
-const WARMUP_SWEEPS = 5
-const warmCatalog = buildDetectedCatalog(-1)
-
-// Each fresh leg needs its own never-indexed catalogs; a shared pool would leave the index warm
-// for whichever leg runs second and silently erase the rebuild it is supposed to measure.
-let catalogGeneration = 0
-function freshCatalogPool(): DetectedByRepo[] {
-  return Array.from({ length: SWEEPS + WARMUP_SWEEPS }, () =>
-    buildDetectedCatalog((catalogGeneration += 1))
-  )
-}
-
-function measureSweeps(run: (sweep: number) => void): number {
-  for (let warmup = 0; warmup < WARMUP_SWEEPS; warmup += 1) {
-    run(warmup)
-  }
-  const started = performance.now()
-  for (let sweep = 0; sweep < SWEEPS; sweep += 1) {
-    run(WARMUP_SWEEPS + sweep)
-  }
-  return (performance.now() - started) / SWEEPS
-}
-
 describe('detected worktree index performance', () => {
   it('answers repeated owner lookups without rescanning the detected catalog', () => {
     const counter = { reads: 0 }
@@ -129,72 +101,4 @@ describe('detected worktree index performance', () => {
     expect(indexedReads).toBe(0)
     expect(walkedReads).toBeGreaterThan(100_000)
   })
-
-  it('records lookup-path timing without making wall clock a CI gate', () => {
-    const walkPool = freshCatalogPool()
-    const walkMs = measureSweeps((sweep) => {
-      const catalog = walkPool[sweep]!
-      for (const probeId of PROBE_IDS) {
-        walkHasDetected(catalog, probeId)
-      }
-    })
-    const walkWarmMs = measureSweeps(() => {
-      for (const probeId of PROBE_IDS) {
-        walkHasDetected(warmCatalog, probeId)
-      }
-    })
-    // Unrelated store writes leave the detected catalog identical, so the index stays warm.
-    const warmMs = measureSweeps(() => {
-      for (const probeId of PROBE_IDS) {
-        hasIndexedDetectedWorktree(warmCatalog, probeId)
-      }
-    })
-    // A landed worktree scan republishes the catalog: one rebuild amortized over the sweep.
-    const freshPool = freshCatalogPool()
-    const freshMs = measureSweeps((sweep) => {
-      const catalog = freshPool[sweep]!
-      for (const probeId of PROBE_IDS) {
-        hasIndexedDetectedWorktree(catalog, probeId)
-      }
-    })
-
-    const statePool = freshCatalogPool().map(buildOwnerState)
-    const warmState = buildOwnerState(warmCatalog)
-    const explicitOwnerFreshMs = measureSweeps((sweep) => {
-      const state = statePool[sweep]!
-      for (const probeId of PROBE_IDS) {
-        getExplicitRuntimeEnvironmentIdForWorktree(state, probeId)
-      }
-    })
-    const explicitOwnerWarmMs = measureSweeps(() => {
-      for (const probeId of PROBE_IDS) {
-        getExplicitRuntimeEnvironmentIdForWorktree(warmState, probeId)
-      }
-    })
-
-    const round = (value: number): number => Number(value.toFixed(4))
-    const report = {
-      entries: REPO_COUNT * WORKTREES_PER_REPO,
-      lookupsPerSweep: LOOKUPS_PER_SWEEP,
-      sweeps: SWEEPS,
-      lookupPath: {
-        walkFreshMsPerSweep: round(walkMs),
-        walkWarmMsPerSweep: round(walkWarmMs),
-        indexedWarmMsPerSweep: round(warmMs),
-        indexedFreshMsPerSweep: round(freshMs),
-        warmSpeedup: round(walkWarmMs / warmMs),
-        freshSpeedup: round(walkMs / freshMs)
-      },
-      getExplicitRuntimeEnvironmentIdForWorktree: {
-        warmMsPerSweep: round(explicitOwnerWarmMs),
-        freshMsPerSweep: round(explicitOwnerFreshMs)
-      }
-    }
-    writeFileSync(
-      join(tmpdir(), 'orca-detected-worktree-index-bench.json'),
-      `${JSON.stringify(report, null, 2)}\n`
-    )
-
-    // Why: shared-runner timing is noisy; the read-count test above is the deterministic CI gate.
-  })
 })
diff --git a/src/renderer/src/runtime/agent-resume-host-authority-capability.test.ts b/src/renderer/src/runtime/agent-resume-host-authority-capability.test.ts
index e5b6d8327ae..39e3abb6e0a 100644
--- a/src/renderer/src/runtime/agent-resume-host-authority-capability.test.ts
+++ b/src/renderer/src/runtime/agent-resume-host-authority-capability.test.ts
@@ -26,17 +26,6 @@ describe('agentResumeHostAuthorityCapability', () => {
     )
     expect(RUNTIME_CAPABILITIES).toContain(AGENT_SESSION_OPENCODE2_RESUME_RUNTIME_CAPABILITY)
   })
-  it('gates Kimi resume behind its own capability', () => {
-    expect(agentResumeHostAuthorityCapability('kimi')).toBe(
-      AGENT_SESSION_KIMI_RESUME_RUNTIME_CAPABILITY
-    )
-  })
-
-  it('keeps the OMP resume-path gate', () => {
-    expect(agentResumeHostAuthorityCapability('omp')).toBe(
-      AGENT_SESSION_OMP_RESUME_PATH_RUNTIME_CAPABILITY
-    )
-  })
 
   it('leaves agents shipped with host authority on the generic probe', () => {
     expect(agentResumeHostAuthorityCapability('codex')).toBeUndefined()
@@ -44,10 +33,6 @@ describe('agentResumeHostAuthorityCapability', () => {
     expect(agentResumeHostAuthorityCapability(undefined)).toBeUndefined()
   })
 
-  it('advertises the Kimi resume capability from the host', () => {
-    expect(RUNTIME_CAPABILITIES).toContain(AGENT_SESSION_KIMI_RESUME_RUNTIME_CAPABILITY)
-  })
-
   it('pins the gate for every resumable agent so a new member is a deliberate decision', () => {
     // Why: silently defaulting a newly resumable agent to the generic probe is the exact skew
     // failure this module exists to prevent — the mapping must be reviewed, not inherited.
diff --git a/src/renderer/src/runtime/runtime-git-client-api-contract.test.ts b/src/renderer/src/runtime/runtime-git-client-api-contract.test.ts
deleted file mode 100644
index 1d40de41e96..00000000000
--- a/src/renderer/src/runtime/runtime-git-client-api-contract.test.ts
+++ /dev/null
@@ -1,50 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import * as runtimeGitClient from './runtime-git-client'
-
-const PUBLIC_RUNTIME_GIT_CLIENT_FUNCTIONS = [
-  'abortRuntimeGitMerge',
-  'abortRuntimeGitRebase',
-  'bulkDiscardRuntimeGitPaths',
-  'bulkStageRuntimeGitPaths',
-  'bulkUnstageRuntimeGitPaths',
-  'cancelRuntimeGenerateCommitMessage',
-  'cancelRuntimeGeneratePullRequestFields',
-  'commitRuntimeGit',
-  'discardRuntimeGitPath',
-  'discoverRuntimeCommitMessageModels',
-  'fastForwardRuntimeGit',
-  'fetchRuntimeGit',
-  'generateRuntimeCommitMessage',
-  'generateRuntimePullRequestFields',
-  'getRuntimeGitBranchCompare',
-  'getRuntimeGitBranchDiff',
-  'getRuntimeGitCommitCompare',
-  'getRuntimeGitCommitDiff',
-  'getRuntimeGitConflictOperation',
-  'getRuntimeGitDiff',
-  'getRuntimeGitHistory',
-  'getRuntimeGitIgnoredPaths',
-  'getRuntimeGitRemoteCommitUrl',
-  'getRuntimeGitRemoteFileUrl',
-  'getRuntimeGitScope',
-  'getRuntimeGitStatus',
-  'getRuntimeGitSubmoduleStatus',
-  'getRuntimeGitUpstreamStatus',
-  'pullRuntimeGit',
-  'pushRuntimeGit',
-  'rebaseRuntimeGitFromBase',
-  'setRuntimeGitStatusUpstreamRefWatch',
-  'stageRuntimeGitPath',
-  'syncRuntimeGitForkDefaultBranch',
-  'unstageRuntimeGitPath'
-] as const
-
-describe('runtime Git client API contract', () => {
-  it('keeps the stable renderer facade exact and callable', () => {
-    const exported: Record<string, unknown> = { ...runtimeGitClient }
-    expect(Object.keys(exported).sort()).toEqual([...PUBLIC_RUNTIME_GIT_CLIENT_FUNCTIONS])
-    for (const functionName of PUBLIC_RUNTIME_GIT_CLIENT_FUNCTIONS) {
-      expect(exported[functionName]).toBeTypeOf('function')
-    }
-  })
-})
diff --git a/src/renderer/src/store/slices/rate-limits.test.ts b/src/renderer/src/store/slices/rate-limits.test.ts
deleted file mode 100644
index 9772483f9e4..00000000000
--- a/src/renderer/src/store/slices/rate-limits.test.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-import { createStore, type StoreApi } from 'zustand/vanilla'
-import { describe, expect, it } from 'vitest'
-import { createRateLimitSlice } from './rate-limits'
-import type { AppState } from '../types'
-
-function createRateLimitStore(): StoreApi<AppState> {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  return createStore<any>()((...args: any[]) =>
-    createRateLimitSlice(...(args as Parameters<typeof createRateLimitSlice>))
-  ) as unknown as StoreApi<AppState>
-}
-
-describe('createRateLimitSlice', () => {
-  it('initializes Antigravity usage with a stable pending key', () => {
-    const store = createRateLimitStore()
-
-    expect(store.getState().rateLimits.antigravity).toBeNull()
-  })
-})
diff --git a/src/renderer/src/store/slices/runtime-status-restored-browser-host-attach.test.ts b/src/renderer/src/store/slices/runtime-status-restored-browser-host-attach.test.ts
index d4b788cd49a..64965021b95 100644
--- a/src/renderer/src/store/slices/runtime-status-restored-browser-host-attach.test.ts
+++ b/src/renderer/src/store/slices/runtime-status-restored-browser-host-attach.test.ts
@@ -60,19 +60,6 @@ describe('restored client-hosted browser host attach on reachability', () => {
     vi.unstubAllGlobals()
   })
 
-  // Why: after a relaunch this desktop hosts nothing, so a page it used to host only comes back
-  // once it attaches again. Hydration alone can ask before the environment is reachable.
-  it('starts the browser client host for restored client-hosted pages once reachable', async () => {
-    stubApi(vi.fn().mockResolvedValue(createCompatibleRuntimeStatusResponse('runtime-a')))
-
-    await storeWithRestoredHandles(true).getState().refreshRuntimeEnvironmentStatus('env-a')
-
-    expect(prepareBrowserClientHostPlacement).toHaveBeenCalledWith({
-      selector: 'env-a',
-      preference: 'auto'
-    })
-  })
-
   it('runs both recovery follow-ups after a successful refresh', async () => {
     stubApi(vi.fn().mockResolvedValue(createCompatibleRuntimeStatusResponse('runtime-a')))
 
diff --git a/src/renderer/src/store/slices/terminal-helpers.test.ts b/src/renderer/src/store/slices/terminal-helpers.test.ts
index ee84ad2faf7..769e2622855 100644
--- a/src/renderer/src/store/slices/terminal-helpers.test.ts
+++ b/src/renderer/src/store/slices/terminal-helpers.test.ts
@@ -79,12 +79,6 @@ describe('clearTransientTerminalState', () => {
     expect(result.title).toBe('Terminal 1')
   })
 
-  it('index-based fallback numbering: index 0 → "Terminal 1"', () => {
-    const tab = makeTab({ title: '. claude', customTitle: null })
-    const result = clearTransientTerminalState(tab, 0)
-    expect(result.title).toBe('Terminal 1')
-  })
-
   it('index-based fallback numbering: index 2 → "Terminal 3"', () => {
     const tab = makeTab({ title: '. claude', customTitle: null })
     const result = clearTransientTerminalState(tab, 2)
diff --git a/src/renderer/src/store/slices/usage-web-client-fallback.test.ts b/src/renderer/src/store/slices/usage-web-client-fallback.test.ts
index b192bcd4bac..2db627b0bea 100644
--- a/src/renderer/src/store/slices/usage-web-client-fallback.test.ts
+++ b/src/renderer/src/store/slices/usage-web-client-fallback.test.ts
@@ -1,12 +1,7 @@
 import { create } from 'zustand'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import type { AppState } from '../types'
-import {
-  createClaudeUsageSlice,
-  createCodexUsageSlice,
-  createMuseUsageSlice,
-  createOpenCodeUsageSlice
-} from './usage-provider-slices'
+import { createClaudeUsageSlice } from './usage-provider-slices'
 
 // Paired web clients resolve unbridged desktop usage calls to undefined.
 
@@ -46,32 +41,4 @@ describe('usage slices in the web client (preload fallback -> undefined)', () =>
     expect(store.getState().claudeUsageScanState).toBeNull()
     expect(store.getState().claudeUsageSummary).toBeNull()
   })
-
-  it('codex: fetch and enable no-op without throwing', async () => {
-    stubWebClientFallback()
-    const store = create<AppState>()((...args) => createCodexUsageSlice(...args) as AppState)
-    await expect(store.getState().fetchCodexUsage()).resolves.toBeUndefined()
-    await expect(store.getState().enableCodexUsage()).resolves.toBeUndefined()
-    expect(store.getState().codexUsageScanState).toBeNull()
-    expect(store.getState().codexUsageSummary).toBeNull()
-  })
-
-  it('opencode: fetch and enable no-op without throwing', async () => {
-    stubWebClientFallback()
-    const store = create<AppState>()((...args) => createOpenCodeUsageSlice(...args) as AppState)
-    await expect(store.getState().fetchOpenCodeUsage()).resolves.toBeUndefined()
-    await expect(store.getState().enableOpenCodeUsage()).resolves.toBeUndefined()
-    expect(store.getState().openCodeUsageScanState).toBeNull()
-    expect(store.getState().openCodeUsageSummary).toBeNull()
-  })
-
-  it('muse: fetch and enable no-op without throwing', async () => {
-    stubWebClientFallback()
-    // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the test reads only this slice's own fields and actions.
-    const store = create<AppState>()((...args) => createMuseUsageSlice(...args) as AppState)
-    await expect(store.getState().fetchMuseUsage()).resolves.toBeUndefined()
-    await expect(store.getState().enableMuseUsage()).resolves.toBeUndefined()
-    expect(store.getState().museUsageScanState).toBeNull()
-    expect(store.getState().museUsageSummary).toBeNull()
-  })
 })
diff --git a/src/renderer/src/store/terminals/structured-chat-tab-rename.test.ts b/src/renderer/src/store/terminals/structured-chat-tab-rename.test.ts
index 5d1e6343f74..ade01274659 100644
--- a/src/renderer/src/store/terminals/structured-chat-tab-rename.test.ts
+++ b/src/renderer/src/store/terminals/structured-chat-tab-rename.test.ts
@@ -96,12 +96,6 @@ describe('recoloring a structured chat tab', () => {
 })
 
 describe('renaming a structured chat tab', () => {
-  it('writes the custom label onto the agent-session tab', () => {
-    const store = storeWithStructuredTab()
-    store.getState().setTabCustomTitle(STRUCTURED_TAB_ID, 'Flaky retry test')
-    expect(labelOf(store)).toBe('Flaky retry test')
-  })
-
   it('clears the custom label when the rename is emptied', () => {
     const store = storeWithStructuredTab()
     store.getState().setTabCustomTitle(STRUCTURED_TAB_ID, 'Flaky retry test')
diff --git a/src/renderer/src/web/preload-api/web-clipboard-api.ts b/src/renderer/src/web/preload-api/web-clipboard-api.ts
index ffd955c2d0b..d94bc63ec05 100644
--- a/src/renderer/src/web/preload-api/web-clipboard-api.ts
+++ b/src/renderer/src/web/preload-api/web-clipboard-api.ts
@@ -5,6 +5,7 @@ import {
   CLIPBOARD_IMAGE_TOO_LARGE_ERROR,
   assertClipboardImageByteLengthWithinLimit,
   assertClipboardImageDimensionsWithinLimit,
+  clipboardFormatsIncludeImage,
   clipboardImageThumbnailSize,
   type ClipboardImageThumbnail
 } from '../../../../shared/clipboard-image'
@@ -221,3 +222,11 @@ export async function saveClipboardImageAsTempFileInRuntime(
     throw error
   }
 }
+
+export async function clipboardHasImage(): Promise<boolean | null> {
+  if (!navigator.clipboard?.read) {
+    return null
+  }
+  const items = await navigator.clipboard.read()
+  return items.some((item) => clipboardFormatsIncludeImage(item.types))
+}
diff --git a/src/renderer/src/web/preload-api/web-ui-api.ts b/src/renderer/src/web/preload-api/web-ui-api.ts
index f24d6f1079c..c92f741ba38 100644
--- a/src/renderer/src/web/preload-api/web-ui-api.ts
+++ b/src/renderer/src/web/preload-api/web-ui-api.ts
@@ -7,6 +7,7 @@ import type { FeatureInteractionId } from '../../../../shared/feature-interactio
 import { omitPairingLocalUiFields } from '../../../../shared/pairing-local-ui-fields'
 import type { PairedUiState } from '../../../../shared/pairing-local-ui-fields'
 import {
+  clipboardHasImage,
   readClipboardImagePngBase64,
   readClipboardImageThumbnail,
   saveClipboardImageAsTempFileInRuntime,
@@ -158,6 +159,9 @@ export function createWebUiApi(): NonNullable<Partial<PreloadApi>['ui']> {
       }
       return saveClipboardImageAsTempFileInRuntime(contentBase64, args)
     },
+    clipboardHasImage,
+    // Browsers expose copied files only inside a paste event.
+    readClipboardFilePaths: async () => [],
     readClipboardImageThumbnail: () => readClipboardImageThumbnail().catch(() => null),
     writeClipboardText: writeWebClipboardText,
     writeTerminalClipboardText: writeWebClipboardText,
diff --git a/src/renderer/src/web/web-clipboard-image-presence.test.ts b/src/renderer/src/web/web-clipboard-image-presence.test.ts
new file mode 100644
index 00000000000..77d56d379d8
--- /dev/null
+++ b/src/renderer/src/web/web-clipboard-image-presence.test.ts
@@ -0,0 +1,33 @@
+// @vitest-environment happy-dom
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { clipboardHasImage } from './preload-api/web-clipboard-api'
+
+afterEach(() => vi.unstubAllGlobals())
+
+describe('browser clipboard image presence', () => {
+  it.each([
+    ['text/plain', false],
+    ['image/png', true]
+  ] as const)('detects %s without reading image bytes', async (type, expected) => {
+    const getType = vi.fn()
+    vi.stubGlobal('navigator', { clipboard: { read: async () => [{ types: [type], getType }] } })
+    expect(await clipboardHasImage()).toBe(expected)
+    expect(getType).not.toHaveBeenCalled()
+  })
+
+  it('reports unknown when the browser has no clipboard reader', async () => {
+    vi.stubGlobal('navigator', {})
+    expect(await clipboardHasImage()).toBeNull()
+  })
+
+  it('preserves permission errors for the caller to handle independently of text', async () => {
+    vi.stubGlobal('navigator', {
+      clipboard: {
+        read: async () => {
+          throw new Error('denied')
+        }
+      }
+    })
+    await expect(clipboardHasImage()).rejects.toThrow('denied')
+  })
+})
diff --git a/src/shared/agent-hook-listener/providers/hermes-events.test.ts b/src/shared/agent-hook-listener/providers/hermes-events.test.ts
new file mode 100644
index 00000000000..9c661b1ff3e
--- /dev/null
+++ b/src/shared/agent-hook-listener/providers/hermes-events.test.ts
@@ -0,0 +1,42 @@
+import { describe, expect, it } from 'vitest'
+import { createHookListenerState } from '../listener-state'
+import { normalizeHermesEvent } from './hermes-events'
+
+const normalize = (eventName: string, payload: Record<string, unknown> = {}) =>
+  normalizeHermesEvent(createHookListenerState(), eventName, '', 'pane-1', payload)
+
+describe('normalizeHermesEvent', () => {
+  // Hermes fires `on_session_start` when a session is opened, switched or reset — never for a
+  // turn (`pre_llm_call` carries the user message). Mapping it to `working` parked a freshly
+  // launched pane in a fresh `working` row for the whole 30-minute staleness window, so
+  // `terminal wait --for tui-idle` timed out against an idle composer.
+  it('lands session start as an idle session boundary, not a running turn', () => {
+    expect(normalize('on_session_start', { session_id: 's1' })).toMatchObject({
+      state: 'done',
+      sessionBoundary: true
+    })
+  })
+
+  it('flags only session start as a boundary, so a turn-end done cannot claim one', () => {
+    for (const eventName of ['post_llm_call', 'on_session_end', 'on_session_finalize']) {
+      const parsed = normalize(eventName, { session_id: 's1' })
+      expect(parsed).toMatchObject({ state: 'done' })
+      expect(parsed?.sessionBoundary).toBeUndefined()
+    }
+  })
+
+  it('keeps the turn and approval states the plugin reports', () => {
+    expect(normalize('pre_llm_call', { user_message: 'hi' })).toMatchObject({ state: 'working' })
+    expect(normalize('pre_tool_call', { tool_name: 'terminal' })).toMatchObject({
+      state: 'working'
+    })
+    expect(normalize('pre_approval_request', { command: 'rm' })).toMatchObject({
+      state: 'waiting'
+    })
+  })
+
+  it('ignores events Orca does not subscribe to', () => {
+    expect(normalize('subagent_stop')).toBeNull()
+    expect(normalize('post_api_request')).toBeNull()
+  })
+})
diff --git a/src/shared/agent-hook-listener/providers/hermes-events.ts b/src/shared/agent-hook-listener/providers/hermes-events.ts
index 710cde415d2..d350d6a5c09 100644
--- a/src/shared/agent-hook-listener/providers/hermes-events.ts
+++ b/src/shared/agent-hook-listener/providers/hermes-events.ts
@@ -6,6 +6,25 @@ import type { HookListenerState } from '../listener-state'
 import { resolvePrompt, resolveToolState } from '../prompt-fields'
 import { extractToolFields, isNewTurnEvent } from '../provider-event-routing'
 
+/** `on_session_start` is a session boundary, not a turn: Hermes fires it when a session is
+ *  opened, switched or reset, and the TUI then sits on its composer awaiting input. Landing it
+ *  as `working` showed a phantom spinner on an idle pane and left `terminal wait --for tui-idle`
+ *  with a fresh `working` row to veto against until the 30-minute staleness window expired.
+ *  `done` + `sessionBoundary` is the same shape Claude and the compatible-lifecycle providers
+ *  already use for their own SessionStart. */
+const HERMES_EVENT_STATES: Record<string, 'working' | 'waiting' | 'done'> = {
+  on_session_start: 'done',
+  on_session_end: 'done',
+  on_session_finalize: 'done',
+  on_session_reset: 'done',
+  post_llm_call: 'done',
+  pre_approval_request: 'waiting',
+  pre_llm_call: 'working',
+  pre_tool_call: 'working',
+  post_tool_call: 'working',
+  post_approval_response: 'working'
+}
+
 export function normalizeHermesEvent(
   state: HookListenerState,
   eventName: unknown,
@@ -13,21 +32,7 @@ export function normalizeHermesEvent(
   paneKey: string,
   hookPayload: Record<string, unknown>
 ): ParsedAgentStatusPayload | null {
-  const stateName =
-    eventName === 'pre_approval_request'
-      ? 'waiting'
-      : eventName === 'post_llm_call' ||
-          eventName === 'on_session_end' ||
-          eventName === 'on_session_finalize' ||
-          eventName === 'on_session_reset'
-        ? 'done'
-        : eventName === 'on_session_start' ||
-            eventName === 'pre_llm_call' ||
-            eventName === 'pre_tool_call' ||
-            eventName === 'post_tool_call' ||
-            eventName === 'post_approval_response'
-          ? 'working'
-          : null
+  const stateName = typeof eventName === 'string' ? HERMES_EVENT_STATES[eventName] : undefined
 
   if (!stateName) {
     return null
@@ -50,6 +55,9 @@ export function normalizeHermesEvent(
     toolInput: snapshot.toolInput,
     interactivePrompt: snapshot.interactivePrompt,
     lastAssistantMessage: snapshot.lastAssistantMessage,
-    lastAssistantMessageIsToolOutput: snapshot.lastAssistantMessageIsToolOutput
+    lastAssistantMessageIsToolOutput: snapshot.lastAssistantMessageIsToolOutput,
+    // Why only this event: a boundary row means "a new session owns the pane and is awaiting
+    // input", which cannot arrive mid-turn. A turn-end `done` must not claim the same.
+    ...(eventName === 'on_session_start' ? { sessionBoundary: true } : {})
   })
 }
diff --git a/src/shared/claude-pasted-content.ts b/src/shared/claude-pasted-content.ts
new file mode 100644
index 00000000000..5f9f074a340
--- /dev/null
+++ b/src/shared/claude-pasted-content.ts
@@ -0,0 +1,31 @@
+import type { NativeChatBlock } from './native-chat-types'
+
+// Claude wraps a whole pasted text block; prose around it is still literal user text.
+export function unwrapClaudePastedContent(text: string): string {
+  const trimmed = text.trim()
+  const open = /^<pasted_content(?: id="([^"<>\r\n]{1,64})")?>\r?\n/.exec(trimmed)
+  if (!open) {
+    return text
+  }
+  const close = open[1] ? `</pasted_content id="${open[1]}">` : '</pasted_content>'
+  if (!trimmed.endsWith(close)) {
+    return text
+  }
+  const body = trimmed.slice(open[0].length, -close.length)
+  // Why: the id is what lets pasted text carry literal tags; only a same-id tag is ambiguous.
+  const ambiguous = open[1]
+    ? body.includes(close) || body.includes(`<pasted_content id="${open[1]}">`)
+    : body.includes('<pasted_content') || body.includes('</pasted_content')
+  if (!body.endsWith('\n') || ambiguous) {
+    return text
+  }
+  return body.slice(0, body.endsWith('\r\n') ? -2 : -1)
+}
+
+export function unwrapClaudePastedContentBlock(block: NativeChatBlock): NativeChatBlock {
+  if (block.type !== 'text') {
+    return block
+  }
+  const text = unwrapClaudePastedContent(block.text)
+  return text === block.text ? block : { ...block, text }
+}
diff --git a/src/shared/clipboard-image.ts b/src/shared/clipboard-image.ts
index 28c1a276e46..436ba8eecc4 100644
--- a/src/shared/clipboard-image.ts
+++ b/src/shared/clipboard-image.ts
@@ -62,3 +62,9 @@ export function clipboardImageThumbnailSize({
     width: Math.max(1, Math.round(width * scale))
   }
 }
+
+/** Clipboard format lists (Electron `availableFormats`, browser `ClipboardItem.types`)
+ *  name image data by MIME type, so presence needs no decode. */
+export function clipboardFormatsIncludeImage(formats: readonly string[]): boolean {
+  return formats.some((format) => format.startsWith('image/'))
+}
diff --git a/src/shared/codex-auth-errors.ts b/src/shared/codex-auth-errors.ts
index ba18b5704fe..2fad48b559a 100644
--- a/src/shared/codex-auth-errors.ts
+++ b/src/shared/codex-auth-errors.ts
@@ -16,8 +16,7 @@ const CODEX_AUTH_ERROR_PATTERNS = [
   /token data is not available/i,
   /auth (?:is missing|tokens are missing|does not expose)/i,
   // Why: app-server rejects account/rateLimits/read with this when auth.json
-  // holds only an API key; without classification the fetcher falls through to
-  // a hidden PTY probe that can only time out (15s) on every refresh.
+  // holds only an API key; that home has no ChatGPT token, so a fallback read cannot succeed.
   /chatgpt authentication required/i
 ]
 const ANSI_ESCAPE_RE = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*[a-zA-Z]`, 'g')
diff --git a/src/shared/native-chat-image-transcript-markers.ts b/src/shared/native-chat-image-transcript-markers.ts
index 2a87bce6568..ded152bb557 100644
--- a/src/shared/native-chat-image-transcript-markers.ts
+++ b/src/shared/native-chat-image-transcript-markers.ts
@@ -1,3 +1,4 @@
+import { unwrapClaudePastedContent } from './claude-pasted-content'
 import {
   stripAnsiEscapeSequences,
   TERMINAL_CONTROL_CHARACTER_PATTERN
@@ -63,7 +64,10 @@ export function stripImagePromptMarker(text: string): string {
 export function normalizeNativeChatUserText(text: string): string {
   // Strip sequences first so their printable tails cannot survive a lone-control pass.
   return stripImagePromptMarker(
-    stripAnsiEscapeSequences(text).replace(TERMINAL_CONTROL_CHARACTER_PATTERN, '')
+    stripAnsiEscapeSequences(unwrapClaudePastedContent(text)).replace(
+      TERMINAL_CONTROL_CHARACTER_PATTERN,
+      ''
+    )
   )
     .trim()
     .replace(/\s+/g, ' ')
@@ -76,7 +80,7 @@ export function normalizedNativeChatUserMessageText(message: NativeChatMessage):
   const normalized = normalizeNativeChatUserText(
     message.blocks
       .filter(isTextBlock)
-      .map((block) => block.text)
+      .map((block) => unwrapClaudePastedContent(block.text))
       .join(' ')
   )
   return normalized || null