diff --git a/config/scripts/command-code-transcript-scan-benchmark.mjs b/config/scripts/command-code-transcript-scan-benchmark.mjs
new file mode 100644
index 000000000..02ea0d09e
--- /dev/null
+++ b/config/scripts/command-code-transcript-scan-benchmark.mjs
@@ -0,0 +1,427 @@
+#!/usr/bin/env node
+// Benchmark: cost of resolving a Command Code turn prompt from the transcript,
+// paid on EVERY command-code hook event (PreToolUse/PostToolUse fire once per
+// tool call, so many per second during an active agent turn).
+//
+// Before the fix, readLastCommandCodeUserPromptEntryFromTranscript() read up to
+// TRANSCRIPT_MAX_SCAN_BYTES (4 MB) synchronously, decoded it all to a JS string,
+// and JSON-parsed EVERY line to the end of the buffer to find the LAST user
+// entry — so cost grew with the transcript, which only grows as a session runs.
+//
+// The fix scans backward from EOF in TRANSCRIPT_CHUNK_BYTES blocks and returns
+// on the first user line, the shape the sibling readLastTextFromTranscriptOnce
+// already used. The answer sits near EOF in a real session (the current turn's
+// prompt precedes only this turn's output), so the scan reads one or two blocks
+// instead of the whole file.
+//
+// Both implementations are mirrored here: node cannot import the .ts source,
+// matching the other benchmarks in this directory. Constants are re-read from
+// the real module so a drifted cap fails loudly instead of measuring dead code.
+import {
+  closeSync,
+  mkdtempSync,
+  openSync,
+  readFileSync,
+  readSync,
+  rmSync,
+  statSync,
+  writeFileSync
+} from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { performance } from 'node:perf_hooks'
+import { fileURLToPath } from 'node:url'
+
+const LISTENER_SOURCE = readFileSync(
+  fileURLToPath(new URL('../../src/shared/agent-hook-listener.ts', import.meta.url)),
+  'utf8'
+)
+
+function readMirroredConstant(name) {
+  const match = LISTENER_SOURCE.match(new RegExp(`const ${name} = ([^\\n]+)`))
+  if (!match) {
+    throw new Error(`agent-hook-listener.ts no longer defines ${name}; re-sync this benchmark.`)
+  }
+  const value = Number(new Function(`return (${match[1]})`)())
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new Error(`${name} did not resolve to a positive integer`)
+  }
+  return value
+}
+
+const TRANSCRIPT_CHUNK_BYTES = readMirroredConstant('TRANSCRIPT_CHUNK_BYTES')
+const TRANSCRIPT_MAX_SCAN_BYTES = readMirroredConstant('TRANSCRIPT_MAX_SCAN_BYTES')
+const EMPTY_REGION = Buffer.alloc(0)
+const ITERATIONS = Number.parseInt(process.env.ORCA_CC_SCAN_BENCH_ITERATIONS ?? '150', 10)
+const WARMUP = Number.parseInt(process.env.ORCA_CC_SCAN_BENCH_WARMUP ?? '20', 10)
+
+for (const [name, value] of [
+  ['ORCA_CC_SCAN_BENCH_ITERATIONS', ITERATIONS],
+  ['ORCA_CC_SCAN_BENCH_WARMUP', WARMUP]
+]) {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new Error(`${name} must be a positive integer, received ${value}`)
+  }
+}
+
+// Mirror of parseAgentHookJson: the real reader scans a line's structure before
+// parsing it, on BOTH sides of this comparison. Omitting it made the pre-fix
+// column ~9x too fast and invented a regression that does not exist.
+const HOOK_STRUCTURAL_TOKENS = 128 * 1024
+const HOOK_NESTING_DEPTH = 64
+
+function assertJsonStructure(content) {
+  let structuralTokens = 0
+  let depth = 0
+  let inString = false
+  let escaped = false
+  for (let index = 0; index < content.length; index += 1) {
+    const character = content[index]
+    if (inString) {
+      if (escaped) {
+        escaped = false
+      } else if (character === '\\') {
+        escaped = true
+      } else if (character === '"') {
+        inString = false
+      }
+      continue
+    }
+    if (character === '"') {
+      inString = true
+      continue
+    }
+    if (
+      character !== '{' &&
+      character !== '}' &&
+      character !== '[' &&
+      character !== ']' &&
+      character !== ',' &&
+      character !== ':'
+    ) {
+      continue
+    }
+    structuralTokens += 1
+    if (structuralTokens > HOOK_STRUCTURAL_TOKENS) {
+      throw new Error('structuralTokens')
+    }
+    if (character === '{' || character === '[') {
+      depth += 1
+      if (depth > HOOK_NESTING_DEPTH) {
+        throw new Error('nestingDepth')
+      }
+    } else if (character === '}' || character === ']') {
+      depth = Math.max(0, depth - 1)
+    }
+  }
+}
+
+function extractUserPrompt(line) {
+  let entry
+  try {
+    assertJsonStructure(line)
+    entry = JSON.parse(line)
+  } catch {
+    return undefined
+  }
+  if (typeof entry !== 'object' || entry === null || entry.role !== 'user') {
+    return undefined
+  }
+  const content = entry.content
+  if (typeof content === 'string' && content.trim().length > 0) {
+    return content
+  }
+  if (Array.isArray(content)) {
+    for (const part of content) {
+      if (typeof part === 'object' && part !== null) {
+        const text = part.text
+        if (typeof text === 'string' && text.trim().length > 0) {
+          return text
+        }
+      }
+    }
+  }
+  return undefined
+}
+
+// Pre-fix: read the capped window, then parse every line to the end.
+function readForward(path) {
+  const size = statSync(path).size
+  if (size <= 0) {
+    return undefined
+  }
+  const bytesToRead = Math.min(size, TRANSCRIPT_MAX_SCAN_BYTES)
+  const position = size - bytesToRead
+  const fd = openSync(path, 'r')
+  try {
+    const buffer = Buffer.alloc(bytesToRead)
+    let filled = 0
+    while (filled < bytesToRead) {
+      const n = readSync(fd, buffer, filled, bytesToRead - filled, position + filled)
+      if (n === 0) {
+        break
+      }
+      filled += n
+    }
+    let text = buffer.subarray(0, filled).toString('utf8')
+    if (position > 0) {
+      const firstNewline = text.indexOf('\n')
+      text = firstNewline === -1 ? '' : text.slice(firstNewline + 1)
+    }
+    let last
+    for (const line of text.split('\n')) {
+      const prompt = extractUserPrompt(line.trim())
+      if (prompt !== undefined) {
+        last = prompt
+      }
+    }
+    return last
+  } finally {
+    closeSync(fd)
+  }
+}
+
+function findLastPromptInRegion(region) {
+  let lineEnd = region.length
+  for (let index = region.length - 1; index >= -1; index--) {
+    if (index >= 0 && region[index] !== 0x0a) {
+      continue
+    }
+    const lineStart = index + 1
+    if (lineEnd > lineStart) {
+      const prompt = extractUserPrompt(region.subarray(lineStart, lineEnd).toString('utf8').trim())
+      if (prompt !== undefined) {
+        return prompt
+      }
+    }
+    lineEnd = index
+  }
+  return undefined
+}
+
+// Post-fix: walk backward from EOF, return on the first user line. The carry is
+// a chunk list, not a re-joined buffer, so one oversized line stays linear.
+function readBackward(path) {
+  const size = statSync(path).size
+  if (size <= 0) {
+    return undefined
+  }
+  const fd = openSync(path, 'r')
+  try {
+    let carryChunks = []
+    let bytesRead = 0
+    let scanEnd = size
+    while (scanEnd > 0 && bytesRead < TRANSCRIPT_MAX_SCAN_BYTES) {
+      const chunkSize = Math.min(
+        scanEnd,
+        TRANSCRIPT_CHUNK_BYTES,
+        TRANSCRIPT_MAX_SCAN_BYTES - bytesRead
+      )
+      const position = scanEnd - chunkSize
+      const buffer = Buffer.alloc(chunkSize)
+      let filled = 0
+      while (filled < chunkSize) {
+        const n = readSync(fd, buffer, filled, chunkSize - filled, position + filled)
+        if (n === 0) {
+          break
+        }
+        filled += n
+      }
+      if (filled < chunkSize) {
+        break
+      }
+      bytesRead += filled
+      scanEnd = position
+      const firstNewline = buffer.indexOf(0x0a)
+      const atStart = position === 0
+      let completeRegion
+      if (atStart) {
+        completeRegion = carryChunks.length === 0 ? buffer : Buffer.concat([buffer, ...carryChunks])
+        carryChunks = []
+      } else if (firstNewline === -1) {
+        completeRegion = EMPTY_REGION
+        carryChunks.unshift(buffer)
+      } else {
+        const afterNewline = buffer.subarray(firstNewline + 1)
+        completeRegion =
+          carryChunks.length === 0 ? afterNewline : Buffer.concat([afterNewline, ...carryChunks])
+        carryChunks = [buffer.subarray(0, firstNewline)]
+      }
+      if (completeRegion.length > 0) {
+        const found = findLastPromptInRegion(completeRegion)
+        if (found !== undefined) {
+          return found
+        }
+      }
+    }
+    return undefined
+  } finally {
+    closeSync(fd)
+  }
+}
+
+// A real session: many completed turns, then THIS turn's prompt, then the tool
+// output produced since. The prompt therefore sits near EOF.
+function writeTranscript(path, priorTurns) {
+  const lines = []
+  for (let index = 0; index < priorTurns; index += 1) {
+    lines.push(
+      JSON.stringify({ role: 'user', content: [{ type: 'text', text: `older turn ${index}` }] })
+    )
+    lines.push(
+      JSON.stringify({
+        role: 'assistant',
+        content: [{ type: 'text', text: `${'assistant output '.repeat(30)}${index}` }]
+      })
+    )
+  }
+  lines.push(
+    JSON.stringify({ role: 'user', content: [{ type: 'text', text: 'the current prompt' }] })
+  )
+  for (let index = 0; index < 40; index += 1) {
+    lines.push(
+      JSON.stringify({
+        role: 'assistant',
+        content: [{ type: 'text', text: `${'current turn output '.repeat(30)}${index}` }]
+      })
+    )
+  }
+  writeFileSync(path, `${lines.join('\n')}\n`)
+}
+
+// A turn already in progress: `trailingBytes` of tool output sits between the
+// prompt and EOF, which is what the backward scan has to read past.
+function writeTranscriptWithTrailing(path, priorTurns, trailingBytes) {
+  const lines = []
+  for (let index = 0; index < priorTurns; index += 1) {
+    lines.push(
+      JSON.stringify({ role: 'user', content: [{ type: 'text', text: `older turn ${index}` }] })
+    )
+    lines.push(
+      JSON.stringify({
+        role: 'assistant',
+        content: [{ type: 'text', text: `${'assistant output '.repeat(30)}${index}` }]
+      })
+    )
+  }
+  lines.push(
+    JSON.stringify({ role: 'user', content: [{ type: 'text', text: 'the current prompt' }] })
+  )
+  let written = 0
+  let index = 0
+  while (written < trailingBytes) {
+    const line = JSON.stringify({
+      role: 'assistant',
+      content: [{ type: 'text', text: `${'current turn output '.repeat(30)}${index}` }]
+    })
+    lines.push(line)
+    written += line.length + 1
+    index += 1
+  }
+  writeFileSync(path, `${lines.join('\n')}\n`)
+}
+
+// One tool result larger than many read blocks — the shape with no newline for
+// the backward scan to stop on.
+function writeTranscriptWithHugeLine(path, lineBytes) {
+  const lines = [
+    JSON.stringify({ role: 'user', content: [{ type: 'text', text: 'the current prompt' }] }),
+    JSON.stringify({ role: 'assistant', content: [{ type: 'text', text: 'x'.repeat(lineBytes) }] })
+  ]
+  writeFileSync(path, `${lines.join('\n')}\n`)
+}
+
+function measure(fn, path) {
+  for (let index = 0; index < WARMUP; index += 1) {
+    fn(path)
+  }
+  const samples = []
+  for (let round = 0; round < 3; round += 1) {
+    const start = performance.now()
+    for (let index = 0; index < ITERATIONS; index += 1) {
+      fn(path)
+    }
+    samples.push((performance.now() - start) / ITERATIONS)
+  }
+  samples.sort((a, b) => a - b)
+  return samples[1]
+}
+
+const dir = mkdtempSync(join(tmpdir(), 'orca-cc-transcript-bench-'))
+try {
+  const rows = []
+  for (const priorTurns of [250, 1000, 3000, 6000]) {
+    const path = join(dir, `transcript-${priorTurns}.jsonl`)
+    writeTranscript(path, priorTurns)
+    const forward = readForward(path)
+    const backward = readBackward(path)
+    if (forward !== backward) {
+      throw new Error(`prompt mismatch at ${priorTurns} prior turns: ${forward} vs ${backward}`)
+    }
+    if (backward !== 'the current prompt') {
+      throw new Error(`benchmark fixture resolved the wrong prompt: ${backward}`)
+    }
+    rows.push({
+      sizeMb: statSync(path).size / (1024 * 1024),
+      beforeMs: measure(readForward, path),
+      afterMs: measure(readBackward, path)
+    })
+  }
+
+  const pad = (value, width) => String(value).padStart(width)
+  console.log('Command Code transcript prompt read, per hook event')
+  console.log(`iterations=${ITERATIONS} warmup=${WARMUP} (median of 3 rounds)`)
+  console.log(
+    `${pad('size', 9)} ${pad('before ms', 11)} ${pad('after ms', 10)} ${pad('speedup', 9)}`
+  )
+  for (const row of rows) {
+    console.log(
+      `${pad(`${row.sizeMb.toFixed(2)} MB`, 9)} ${pad(row.beforeMs.toFixed(3), 11)} ${pad(row.afterMs.toFixed(3), 10)} ${pad(`${(row.beforeMs / row.afterMs).toFixed(0)}x`, 9)}`
+    )
+  }
+  console.log(
+    '\nThe old cost grows with the transcript; the new cost is flat because the\ncurrent turn’s prompt sits near EOF and the scan stops at the first hit.'
+  )
+
+  // Worst cases, reported even where the ratio is below 1x. The new cost scales
+  // with bytes-AFTER the prompt, so a long turn (many tool calls since the ask)
+  // and a single oversized tool result are where the win decays or inverts.
+  const worst = []
+  for (const trailingKb of [32, 256, 1024, 3072]) {
+    const path = join(dir, `trailing-${trailingKb}.jsonl`)
+    writeTranscriptWithTrailing(path, 1500, trailingKb * 1024)
+    if (readForward(path) !== readBackward(path)) {
+      throw new Error(`prompt mismatch at trailing ${trailingKb} KB`)
+    }
+    worst.push({
+      label: `${(trailingKb / 1024).toFixed(2)} MB after prompt`,
+      beforeMs: measure(readForward, path),
+      afterMs: measure(readBackward, path)
+    })
+  }
+  const hugePath = join(dir, 'huge-line.jsonl')
+  writeTranscriptWithHugeLine(hugePath, 3 * 1024 * 1024)
+  if (readForward(hugePath) !== readBackward(hugePath)) {
+    throw new Error('prompt mismatch on the oversized-line fixture')
+  }
+  worst.push({
+    label: '3 MB single line',
+    beforeMs: measure(readForward, hugePath),
+    afterMs: measure(readBackward, hugePath)
+  })
+
+  console.log('\nWorst cases (win decays as a turn progresses; <1x means slower):')
+  console.log(
+    `${pad('case', 22)} ${pad('before ms', 11)} ${pad('after ms', 10)} ${pad('ratio', 9)}`
+  )
+  for (const row of worst) {
+    console.log(
+      `${pad(row.label, 22)} ${pad(row.beforeMs.toFixed(3), 11)} ${pad(row.afterMs.toFixed(3), 10)} ${pad(`${(row.beforeMs / row.afterMs).toFixed(2)}x`, 9)}`
+    )
+  }
+  console.log(
+    '\nThe win shrinks toward parity as output accumulates after the prompt, since\nthe backward scan has to read past all of it. The single-line row is the floor:\nno newline to stop on, so the scan reads the line in blocks and joins once where\nthe old code issued one flat read. Both sides pay the same per-line structure\nscan, and the carry is a chunk list, so cost stays linear either way.'
+  )
+} finally {
+  rmSync(dir, { recursive: true, force: true })
+}
diff --git a/src/shared/agent-hook-listener.test.ts b/src/shared/agent-hook-listener.test.ts
index 1047c8282..f5a3e470c 100644
--- a/src/shared/agent-hook-listener.test.ts
+++ b/src/shared/agent-hook-listener.test.ts
@@ -971,6 +971,292 @@ describe('shared agent-hook-listener', () => {
     }
   })
 
+  // Why these three: the prompt read scans backward from EOF and stops at the
+  // first user line, so the cases that can break are a prompt spanning a chunk
+  // boundary, a later prompt that must win over an earlier one, and the byte
+  // offset in interactionKey, which the old forward pass computed absolutely.
+  it('reads a Command Code prompt that straddles the backward-scan chunk boundary', () => {
+    const tmpDir = mkdtempSync(join(tmpdir(), 'orca-command-code-chunk-straddle-'))
+    const transcriptPath = join(tmpDir, 'transcript.jsonl')
+    try {
+      const promptLine = JSON.stringify({
+        role: 'user',
+        content: [{ type: 'text', text: 'straddling prompt' }]
+      })
+      // Place the prompt so it spans the 64 KiB read boundary counted back from
+      // EOF: the scan must stitch the two reads together to see the whole line.
+      const chunkBytes = 64 * 1024
+      const bytesAfterPrompt = chunkBytes - Math.floor(Buffer.byteLength(promptLine) / 2)
+      const tail = Array.from({ length: 271 }, (_value, index) =>
+        JSON.stringify({
+          role: 'assistant',
+          content: [{ type: 'text', text: `${'t'.repeat(180)}${index}` }]
+        })
+      )
+      let tailText = `${tail.join('\n')}\n`
+      const padBytes = bytesAfterPrompt - Buffer.byteLength(tailText)
+      expect(padBytes).toBeGreaterThan(0)
+      tailText = `${'x'.repeat(padBytes - 1)}\n${tailText}`
+      expect(Buffer.byteLength(tailText)).toBe(bytesAfterPrompt)
+      const head = Array.from({ length: 200 }, (_value, index) =>
+        JSON.stringify({
+          role: 'assistant',
+          content: [{ type: 'text', text: `${'h'.repeat(180)}${index}` }]
+        })
+      )
+      writeFileSync(transcriptPath, `${head.join('\n')}\n${promptLine}\n${tailText}`)
+
+      const tool = normalizeHookPayload(
+        state,
+        'command-code',
+        {
+          paneKey: PANE_KEY,
+          tabId: 'tab-1',
+          worktreeId: 'wt',
+          env: 'production',
+          version: '1',
+          payload: {
+            hook_event_name: 'PreToolUse',
+            transcript_path: transcriptPath,
+            tool_name: 'shell_command',
+            tool_input: { command: 'pwd' }
+          }
+        },
+        'production'
+      )
+      expect(tool?.payload.prompt).toBe('straddling prompt')
+    } finally {
+      rmSync(tmpDir, { recursive: true, force: true })
+    }
+  })
+
+  it('reads a prompt behind one oversized line without quadratic carry copying', () => {
+    const tmpDir = mkdtempSync(join(tmpdir(), 'orca-command-code-huge-line-'))
+    const transcriptPath = join(tmpDir, 'transcript.jsonl')
+    const originalConcat = Buffer.concat
+    let concatenatedBytes = 0
+    try {
+      // A single tool result spanning many 64 KiB read blocks. Re-joining the
+      // accumulated carry per block copies O(line^2) bytes; the chunk list defers
+      // to one join, so total copied bytes stay proportional to the line.
+      const lineBytes = 2 * 1024 * 1024
+      const hugeLine = JSON.stringify({
+        role: 'assistant',
+        content: [{ type: 'text', text: 'x'.repeat(lineBytes) }]
+      })
+      const promptLine = JSON.stringify({
+        role: 'user',
+        content: [{ type: 'text', text: 'prompt behind a huge tool result' }]
+      })
+      writeFileSync(transcriptPath, `${promptLine}\n${hugeLine}\n`)
+
+      Buffer.concat = ((list: readonly Uint8Array[], totalLength?: number) => {
+        const joined = originalConcat(list as Uint8Array[], totalLength)
+        concatenatedBytes += joined.length
+        return joined
+      }) as typeof Buffer.concat
+
+      const tool = normalizeHookPayload(
+        state,
+        'command-code',
+        {
+          paneKey: PANE_KEY,
+          tabId: 'tab-1',
+          worktreeId: 'wt',
+          env: 'production',
+          version: '1',
+          payload: {
+            hook_event_name: 'PreToolUse',
+            transcript_path: transcriptPath,
+            tool_name: 'shell_command',
+            tool_input: { command: 'pwd' }
+          }
+        },
+        'production'
+      )
+
+      expect(tool?.payload.prompt).toBe('prompt behind a huge tool result')
+      // Linear copies once (~lineBytes). The quadratic form copied ~16x that at
+      // this size and grows with the square, so 4x separates them decisively.
+      expect(concatenatedBytes).toBeLessThan(lineBytes * 4)
+    } finally {
+      Buffer.concat = originalConcat
+      rmSync(tmpDir, { recursive: true, force: true })
+    }
+  })
+
+  it('reads a Command Code prompt line that spans several read blocks', () => {
+    const tmpDir = mkdtempSync(join(tmpdir(), 'orca-command-code-long-line-'))
+    const transcriptPath = join(tmpDir, 'transcript.jsonl')
+    try {
+      // A prompt longer than one 64 KiB block: the scan sees consecutive blocks
+      // with no newline at all and must stitch them before parsing.
+      const promptText = `pasted prompt ${'W'.repeat(150 * 1024)}`
+      writeFileSync(
+        transcriptPath,
+        `${JSON.stringify({ role: 'assistant', content: [{ type: 'text', text: 'earlier' }] })}\n${JSON.stringify(
+          { role: 'user', content: [{ type: 'text', text: promptText }] }
+        )}\n${JSON.stringify({ role: 'assistant', content: [{ type: 'text', text: 'tail' }] })}\n`
+      )
+
+      const tool = normalizeHookPayload(
+        state,
+        'command-code',
+        {
+          paneKey: PANE_KEY,
+          tabId: 'tab-1',
+          worktreeId: 'wt',
+          env: 'production',
+          version: '1',
+          payload: {
+            hook_event_name: 'PreToolUse',
+            transcript_path: transcriptPath,
+            tool_name: 'shell_command',
+            tool_input: { command: 'pwd' }
+          }
+        },
+        'production'
+      )
+
+      expect(tool?.payload.prompt.startsWith('pasted prompt WWW')).toBe(true)
+    } finally {
+      rmSync(tmpDir, { recursive: true, force: true })
+    }
+  })
+
+  it('ignores a Command Code prompt older than the transcript scan cap', () => {
+    const tmpDir = mkdtempSync(join(tmpdir(), 'orca-command-code-over-cap-'))
+    const transcriptPath = join(tmpDir, 'transcript.jsonl')
+    try {
+      // The only user line sits beyond the 4 MB cap, so the bounded scan must not
+      // reach it — dropping the cap would restore the unbounded read this avoids.
+      const filler = JSON.stringify({
+        role: 'assistant',
+        content: [{ type: 'text', text: 'f'.repeat(64 * 1024) }]
+      })
+      const lines = [
+        JSON.stringify({ role: 'user', content: [{ type: 'text', text: 'ancient prompt' }] })
+      ]
+      for (let index = 0; index < 80; index += 1) {
+        lines.push(filler)
+      }
+      writeFileSync(transcriptPath, `${lines.join('\n')}\n`)
+      expect(statSync(transcriptPath).size).toBeGreaterThan(4 * 1024 * 1024)
+
+      const tool = normalizeHookPayload(
+        state,
+        'command-code',
+        {
+          paneKey: PANE_KEY,
+          tabId: 'tab-1',
+          worktreeId: 'wt',
+          env: 'production',
+          version: '1',
+          payload: {
+            hook_event_name: 'PreToolUse',
+            transcript_path: transcriptPath,
+            tool_name: 'shell_command',
+            tool_input: { command: 'pwd' }
+          }
+        },
+        'production'
+      )
+
+      expect(tool?.payload.prompt ?? '').toBe('')
+    } finally {
+      rmSync(tmpDir, { recursive: true, force: true })
+    }
+  })
+
+  it('resolves the last Command Code prompt, not an earlier one', () => {
+    const tmpDir = mkdtempSync(join(tmpdir(), 'orca-command-code-last-prompt-'))
+    const transcriptPath = join(tmpDir, 'transcript.jsonl')
+    try {
+      writeFileSync(
+        transcriptPath,
+        `${[
+          JSON.stringify({ role: 'user', content: [{ type: 'text', text: 'first ask' }] }),
+          JSON.stringify({ role: 'assistant', content: [{ type: 'text', text: 'first answer' }] }),
+          JSON.stringify({ role: 'user', content: [{ type: 'text', text: 'second ask' }] }),
+          JSON.stringify({ role: 'assistant', content: [{ type: 'text', text: 'second answer' }] })
+        ].join('\n')}\n`
+      )
+
+      const tool = normalizeHookPayload(
+        state,
+        'command-code',
+        {
+          paneKey: PANE_KEY,
+          tabId: 'tab-1',
+          worktreeId: 'wt',
+          env: 'production',
+          version: '1',
+          payload: {
+            hook_event_name: 'PreToolUse',
+            transcript_path: transcriptPath,
+            tool_name: 'shell_command',
+            tool_input: { command: 'pwd' }
+          }
+        },
+        'production'
+      )
+      expect(tool?.payload.prompt).toBe('second ask')
+    } finally {
+      rmSync(tmpDir, { recursive: true, force: true })
+    }
+  })
+
+  it('keys the Command Code interaction by the absolute prompt line offset', () => {
+    const tmpDir = mkdtempSync(join(tmpdir(), 'orca-command-code-offset-'))
+    const transcriptPath = join(tmpDir, 'transcript.jsonl')
+    try {
+      const prompt = JSON.stringify({
+        role: 'user',
+        content: [{ type: 'text', text: 'same text' }]
+      })
+      const answer = JSON.stringify({ role: 'assistant', content: [{ type: 'text', text: 'a' }] })
+      // Why past one chunk: the offset is absolute over the whole file, so the
+      // prompt must sit beyond a single backward-scan read for a chunk-relative
+      // offset to be distinguishable from the correct one.
+      const filler = Array.from({ length: 900 }, (_value, index) =>
+        JSON.stringify({
+          role: 'assistant',
+          content: [{ type: 'text', text: `${'f'.repeat(200)}${index}` }]
+        })
+      )
+      const head = `${filler.join('\n')}\n`
+      writeFileSync(transcriptPath, `${head}${prompt}\n${answer}\n`)
+      const promptOffset = Buffer.byteLength(head)
+      expect(promptOffset).toBeGreaterThan(64 * 1024)
+
+      const key = normalizeHookPayload(
+        createHookListenerState(),
+        'command-code',
+        {
+          paneKey: PANE_KEY,
+          tabId: 'tab-1',
+          worktreeId: 'wt',
+          env: 'production',
+          version: '1',
+          payload: {
+            hook_event_name: 'PreToolUse',
+            transcript_path: transcriptPath,
+            tool_name: 'shell_command',
+            tool_input: { command: 'pwd' }
+          }
+        },
+        'production'
+      )?.promptInteractionKey
+
+      // The offset segment must be the prompt line's real position in the file;
+      // a chunk-relative value would make two turns collide across reads.
+      // Key shape: command-code-transcript-<pathHash>-<offset>-<textHash>.
+      expect(key?.split('-')[4]).toBe(String(promptOffset))
+    } finally {
+      rmSync(tmpDir, { recursive: true, force: true })
+    }
+  })
+
   it('trims surrounding whitespace from extracted prompt text', () => {
     const event = normalizeHookPayload(
       state,
diff --git a/src/shared/agent-hook-listener.ts b/src/shared/agent-hook-listener.ts
index 4e6432a74..e2413f8fb 100644
--- a/src/shared/agent-hook-listener.ts
+++ b/src/shared/agent-hook-listener.ts
@@ -835,6 +835,7 @@ function extractToolResponseText(toolResponse: unknown): string | undefined {
 
 const TRANSCRIPT_CHUNK_BYTES = 64 * 1024
 const TRANSCRIPT_MAX_SCAN_BYTES = 4 * 1024 * 1024
+const EMPTY_TRANSCRIPT_REGION = Buffer.alloc(0)
 const AMP_THREAD_ID_MAX_LENGTH = 256
 const AMP_MAX_SCOPED_THREAD_CACHE_KEYS = 32
 const GROK_SESSION_CWD_MAX_LENGTH = 4096
@@ -959,7 +960,32 @@ function hashInteractionKeyPart(value: string): string {
   return createHash('sha256').update(value).digest('hex').slice(0, 12)
 }
 
-function readLastCommandCodeUserPromptEntryFromTranscript(
+// Why byte offsets: the caller's interactionKey embeds the prompt's absolute
+// position, so the backward scan has to report the same offset the old
+// read-everything-then-take-the-last-match pass produced.
+function findLastCommandCodePromptInRegion(
+  region: Buffer
+): { prompt: string; byteOffset: number } | undefined {
+  let lineEnd = region.length
+  for (let index = region.length - 1; index >= -1; index--) {
+    if (index >= 0 && region[index] !== 0x0a) {
+      continue
+    }
+    const lineStart = index + 1
+    if (lineEnd > lineStart) {
+      const prompt = extractCommandCodeUserPromptFromLine(
+        region.subarray(lineStart, lineEnd).toString('utf8').trim()
+      )
+      if (prompt !== undefined) {
+        return { prompt, byteOffset: lineStart }
+      }
+    }
+    lineEnd = index
+  }
+  return undefined
+}
+
+export function readLastCommandCodeUserPromptEntryFromTranscript(
   transcriptPath: unknown
 ): { text: string; interactionKey: string } | undefined {
   if (typeof transcriptPath !== 'string' || transcriptPath.length === 0) {
@@ -971,46 +997,79 @@ function readLastCommandCodeUserPromptEntryFromTranscript(
     if (size <= 0) {
       return undefined
     }
-    const bytesToRead = Math.min(size, TRANSCRIPT_MAX_SCAN_BYTES)
-    const position = size - bytesToRead
     const fd = openSync(transcriptPath, 'r')
     try {
-      const buffer = Buffer.alloc(bytesToRead)
-      let filled = 0
-      while (filled < bytesToRead) {
-        const n = readSync(fd, buffer, filled, bytesToRead - filled, position + filled)
-        if (n === 0) {
+      // Why scan backward: the answer is the LAST user line, so walking up from
+      // EOF returns on the first hit instead of parsing every line of a
+      // multi-megabyte transcript on every hook event.
+      // Why a chunk list: carry holds a partial line, and re-concatenating it per
+      // block made one oversized line (a big tool result) cost O(line^2).
+      let carryChunks: Buffer[] = []
+      let bytesRead = 0
+      let scanEnd = size
+      while (scanEnd > 0 && bytesRead < TRANSCRIPT_MAX_SCAN_BYTES) {
+        const chunkSize = Math.min(
+          scanEnd,
+          TRANSCRIPT_CHUNK_BYTES,
+          TRANSCRIPT_MAX_SCAN_BYTES - bytesRead
+        )
+        const position = scanEnd - chunkSize
+        const buffer = Buffer.alloc(chunkSize)
+        let filled = 0
+        while (filled < chunkSize) {
+          const n = readSync(fd, buffer, filled, chunkSize - filled, position + filled)
+          if (n === 0) {
+            break
+          }
+          filled += n
+        }
+        // Why bail on a short read: the file shrank under us, so the bytes above
+        // this block no longer line up and any stitched offset would be wrong.
+        if (filled < chunkSize) {
           break
         }
-        filled += n
-      }
-      let text = buffer.subarray(0, filled).toString('utf8')
-      let textBasePosition = position
-      if (position > 0) {
-        const firstNewline = text.indexOf('\n')
-        textBasePosition += firstNewline + 1
-        text = firstNewline === -1 ? '' : text.slice(firstNewline + 1)
-      }
-      let lastPrompt: string | undefined
-      let lastPromptOffset = 0
-      for (const { line, byteOffset } of iterateTranscriptLinesWithByteOffsets(text)) {
-        const prompt = extractCommandCodeUserPromptFromLine(line.trim())
-        if (prompt !== undefined) {
-          lastPrompt = prompt
-          lastPromptOffset = textBasePosition + byteOffset
+        bytesRead += filled
+        scanEnd = position
+        // Why search only the new block: carry is always the run before a newline,
+        // so it holds none of its own.
+        const firstNewline = buffer.indexOf(0x0a)
+        // Why only at a true file start: a scan that stops on the size cap must
+        // discard its leading partial line, exactly as the capped read did.
+        const atStart = position === 0
+        let completeRegion: Buffer
+        let regionPosition: number
+        if (atStart) {
+          completeRegion =
+            carryChunks.length === 0 ? buffer : Buffer.concat([buffer, ...carryChunks])
+          regionPosition = position
+          carryChunks = []
+        } else if (firstNewline === -1) {
+          completeRegion = EMPTY_TRANSCRIPT_REGION
+          regionPosition = position
+          carryChunks.unshift(buffer)
+        } else {
+          const afterNewline = buffer.subarray(firstNewline + 1)
+          completeRegion =
+            carryChunks.length === 0 ? afterNewline : Buffer.concat([afterNewline, ...carryChunks])
+          regionPosition = position + firstNewline + 1
+          carryChunks = [buffer.subarray(0, firstNewline)]
+        }
+        if (completeRegion.length > 0) {
+          const found = findLastCommandCodePromptInRegion(completeRegion)
+          if (found) {
+            return {
+              text: found.prompt,
+              interactionKey: [
+                'command-code-transcript',
+                hashInteractionKeyPart(transcriptPath),
+                String(regionPosition + found.byteOffset),
+                hashInteractionKeyPart(found.prompt)
+              ].join('-')
+            }
+          }
         }
       }
-      return lastPrompt
-        ? {
-            text: lastPrompt,
-            interactionKey: [
-              'command-code-transcript',
-              hashInteractionKeyPart(transcriptPath),
-              String(lastPromptOffset),
-              hashInteractionKeyPart(lastPrompt)
-            ].join('-')
-          }
-        : undefined
+      return undefined
     } finally {
       closeSync(fd)
     }
@@ -1019,24 +1078,6 @@ function readLastCommandCodeUserPromptEntryFromTranscript(
   }
 }
 
-function* iterateTranscriptLinesWithByteOffsets(
-  text: string
-): Generator<{ line: string; byteOffset: number }> {
-  let lineStart = 0
-  let byteOffset = 0
-
-  for (let index = 0; index <= text.length; index++) {
-    if (index < text.length && text.charCodeAt(index) !== 10) {
-      continue
-    }
-
-    const line = text.slice(lineStart, index)
-    yield { line, byteOffset }
-    byteOffset += Buffer.byteLength(line, 'utf8') + (index < text.length ? 1 : 0)
-    lineStart = index + 1
-  }
-}
-
 function extractCommandCodeAssistantTextFromLine(line: string): string | undefined {
   let entry: unknown
   try {