pi-code 1.0.2 → 1.0.4

package/extensions/memory.ts

@@ -93,7 +93,7 @@ export function saveMemory(dir: string, indexPath: string, name: string | undefi
   }
   fs.mkdirSync(dir, { recursive: true })
   fs.writeFileSync(path.join(dir, `${name}.md`), content)
-  fs.writeFileSync(indexPath, upsertIndexLine(index, name, description))
+  writeIndex(indexPath, upsertIndexLine(index, name, description))
   return { content: [{ type: 'text', text: `Saved memory ${name}.` }], details: {} }
 }
 
@@ -150,25 +150,45 @@ const MemoryParams = Type.Object({
 function readIndex(dir: string): string {
   try {
     return fs.readFileSync(path.join(dir, INDEX_FILE), 'utf-8')
+  } catch (error) {
+    // Only a missing file means an empty index. Treating any other failure as empty
+    // lets the next read-modify-write clobber every existing entry.
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return ''
+    throw error
+  }
+}
+
+/** For display paths, where a transiently unreadable index should not break the
+ * session; the mutating paths go through readIndex and refuse instead. */
+function readIndexQuietly(dir: string): string {
+  try {
+    return readIndex(dir)
   } catch {
     return ''
   }
 }
 
+/** Replace the index through a rename so a crash mid-write cannot truncate it. */
+function writeIndex(indexPath: string, content: string): void {
+  const tmp = `${indexPath}.${process.pid}.tmp`
+  fs.writeFileSync(tmp, content)
+  fs.renameSync(tmp, indexPath)
+}
+
 export default function memoryExtension(pi: ExtensionAPI) {
   let dir = memoryDir(process.cwd())
 
   pi.on('session_start', async (_event, ctx) => {
     migrateLegacyStore(ctx.cwd)
     dir = memoryDir(ctx.cwd)
-    const count = readIndex(dir)
+    const count = readIndexQuietly(dir)
       .split('\n')
       .filter((l) => l.startsWith('- ')).length
     if (count > 0) ctx.ui.notify(`Memory: ${count} memories loaded`, 'info')
   })
 
   pi.on('before_agent_start', async (event) => {
-    const index = readIndex(dir)
+    const index = readIndexQuietly(dir)
     if (!index.trim()) return
     return {
       systemPrompt: `${event.systemPrompt}\n\n## Memory\n\nPersistent memories from earlier sessions (index):\n\n${capIndexForPrompt(index)}\nUse the memory tool with action "read" to load a memory's full content when relevant.`,
@@ -185,7 +205,11 @@ export default function memoryExtension(pi: ExtensionAPI) {
       const indexPath = path.join(dir, INDEX_FILE)
 
       if (params.action === 'save') {
-        return saveMemory(dir, indexPath, name, params.description, params.content)
+        try {
+          return saveMemory(dir, indexPath, name, params.description, params.content)
+        } catch (error) {
+          return { content: [{ type: 'text' as const, text: `Memory save failed: ${error instanceof Error ? error.message : String(error)}. The index was left untouched.` }], details: {} }
+        }
       }
 
       if (params.action === 'read') {
@@ -200,14 +224,22 @@ export default function memoryExtension(pi: ExtensionAPI) {
 
       if (params.action === 'delete') {
         if (!name) return { content: [{ type: 'text' as const, text: 'delete requires name.' }], details: {} }
+        // The index is read before anything is removed: refusing on a failed read
+        // must leave both the memory file and the index as they were.
+        let index: string
+        try {
+          index = readIndex(dir)
+        } catch (error) {
+          return { content: [{ type: 'text' as const, text: `Memory delete failed: ${error instanceof Error ? error.message : String(error)}. Nothing was deleted.` }], details: {} }
+        }
         fs.rmSync(path.join(dir, `${name}.md`), { force: true })
-        const remaining = removeIndexLine(readIndex(dir), name)
-        if (remaining) fs.writeFileSync(indexPath, remaining)
+        const remaining = removeIndexLine(index, name)
+        if (remaining) writeIndex(indexPath, remaining)
         else fs.rmSync(indexPath, { force: true })
         return { content: [{ type: 'text' as const, text: `Deleted memory ${name}.` }], details: {} }
       }
 
-      const index = readIndex(dir)
+      const index = readIndexQuietly(dir)
       return { content: [{ type: 'text' as const, text: index.trim() || 'No memories saved for this project yet.' }], details: {} }
     },
   })

package/extensions/notify.ts

@@ -8,6 +8,7 @@
  * - Windows toast: Windows Terminal (WSL)
  */
 
+import { execFile } from 'node:child_process'
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
 
 function windowsToastScript(title: string, body: string): string {
@@ -29,7 +30,6 @@ function notifyOSC99(title: string, body: string): void {
 }
 
 function notifyWindows(title: string, body: string): void {
-  const { execFile } = require('node:child_process')
   // Resolve powershell from a fixed system path rather than through PATH, and let the callback
   // capture a spawn failure instead of an unhandled 'error' event crashing the host.
   const root = process.env.SystemRoot ?? String.raw`C:\Windows`

package/extensions/plan-mode/index.ts

@@ -24,6 +24,10 @@ import { extractTodoItems, isSafeCommand, markCompletedSteps, planToTodos, type
 // Tools
 const PLAN_MODE_TOOLS = ['read', 'bash', 'grep', 'find', 'ls', 'question', 'plan_mode_complete']
 
+/** Agent runs in execution mode with no [DONE:n] progress before execution ends on
+ * its own. Kept small: each stalled run re-injects the stale plan into the turn. */
+const STALLED_RUN_LIMIT = 2
+
 // Type guard for assistant messages
 function isAssistantMessage(m: AgentMessage): m is AssistantMessage {
   return m.role === 'assistant' && Array.isArray(m.content)
@@ -60,6 +64,8 @@ export default function planModeExtension(pi: ExtensionAPI): void {
   let todoItems: TodoItem[] = []
   let planFromTool = false
   let savedTools: string[] = []
+  let stalledRuns = 0
+  let runProgress = false
 
   function enterPlanTools(): void {
     savedTools = pi.getActiveTools()
@@ -113,6 +119,8 @@ export default function planModeExtension(pi: ExtensionAPI): void {
     executionMode = false
     todoItems = []
     planFromTool = false
+    stalledRuns = 0
+    runProgress = false
 
     if (planModeEnabled) {
       enterPlanTools()
@@ -132,14 +140,16 @@ export default function planModeExtension(pi: ExtensionAPI): void {
       enabled: planModeEnabled,
       todos: todoItems,
       executing: executionMode,
+      // The pre-plan tool set has to survive with the state that caused it to shrink.
+      // /reload rebuilds this extension with an empty snapshot while pi carries the
+      // restricted tools into the new runtime, so a restore has no way to work out
+      // what was active before plan mode unless it was written down here.
+      savedTools,
     })
   }
 
-  // Announce completion and reset once every step is done
-  function finalizeCompletedExecution(ctx: ExtensionContext): void {
-    if (!todoItems.every((t) => t.completed)) return
-    const completedList = todoItems.map((t) => `~~${t.text}~~`).join('\n')
-    pi.sendMessage({ customType: 'plan-complete', content: `**Plan Complete!** ✓\n\n${completedList}`, display: true }, { triggerTurn: false })
+  function endExecution(ctx: ExtensionContext, content: string): void {
+    pi.sendMessage({ customType: 'plan-complete', content, display: true }, { triggerTurn: false })
     executionMode = false
     todoItems = []
     restoreTools()
@@ -147,6 +157,23 @@ export default function planModeExtension(pi: ExtensionAPI): void {
     persistState() // Save cleared state so resume doesn't restore old execution mode
   }
 
+  // Announce completion and reset once every step is done
+  function finalizeCompletedExecution(ctx: ExtensionContext): void {
+    if (!todoItems.every((t) => t.completed)) return
+    const completedList = todoItems.map((t) => `~~${t.text}~~`).join('\n')
+    endExecution(ctx, `**Plan Complete!** ✓\n\n${completedList}`)
+  }
+
+  /** Models regularly drop or renumber a [DONE:n] marker; without a bounded exit the
+   * stale plan would be injected into every later turn until the user finds /plan. */
+  function endStalledExecution(ctx: ExtensionContext): void {
+    const remaining = todoItems
+      .filter((t) => !t.completed)
+      .map((t) => `${t.step}. ${t.text}`)
+      .join('\n')
+    endExecution(ctx, `**Plan execution ended** after ${STALLED_RUN_LIMIT} turns without step progress. Unfinished steps:\n\n${remaining}`)
+  }
+
   // Fall back to extracting a plan from the last assistant message's prose
   function deriveTodosFromProse(messages: AgentMessage[]): void {
     const lastAssistant = [...messages].reverse().find(isAssistantMessage)
@@ -165,6 +192,8 @@ export default function planModeExtension(pi: ExtensionAPI): void {
       planModeEnabled = false
       executionMode = todoItems.length > 0
       planFromTool = false
+      stalledRuns = 0
+      runProgress = false
       restoreTools()
       publishPlanState()
       updateStatus(ctx)
@@ -236,9 +265,19 @@ export default function planModeExtension(pi: ExtensionAPI): void {
     handler: async (ctx) => togglePlanMode(ctx),
   })
 
-  // Block destructive bash commands in plan mode
+  // Enforce plan mode at call time, not only through the active-tool set: pi
+  // activates tools registered after the restriction was applied (an MCP server
+  // connecting during session_start, or a mid-session list_changed refresh), so the
+  // set alone leaks write-capable tools into plan mode.
   pi.on('tool_call', async (event) => {
-    if (!planModeEnabled || event.toolName !== 'bash') return
+    if (!planModeEnabled) return
+    if (!PLAN_MODE_TOOLS.includes(event.toolName)) {
+      return {
+        block: true,
+        reason: `Plan mode: tool blocked (read-only mode). Use /plan to disable plan mode first.\nTool: ${event.toolName}`,
+      }
+    }
+    if (event.toolName !== 'bash') return
 
     const command = event.input.command as string
     if (!isSafeCommand(command)) {
@@ -327,6 +366,7 @@ After completing a step, include a [DONE:n] tag in your response.`,
 
     const text = getTextContent(event.message)
     if (markCompletedSteps(text, todoItems) > 0) {
+      runProgress = true
       updateStatus(ctx)
     }
     persistState()
@@ -334,9 +374,18 @@ After completing a step, include a [DONE:n] tag in your response.`,
 
   // Handle plan completion and plan mode UI
   pi.on('agent_end', async (event, ctx) => {
-    // Check if execution is complete
+    // Check if execution is complete, or has stalled without marker progress
     if (executionMode && todoItems.length > 0) {
-      finalizeCompletedExecution(ctx)
+      if (todoItems.every((t) => t.completed)) {
+        finalizeCompletedExecution(ctx)
+        stalledRuns = 0
+      } else if (runProgress) {
+        stalledRuns = 0
+      } else {
+        stalledRuns++
+        if (stalledRuns >= STALLED_RUN_LIMIT) endStalledExecution(ctx)
+      }
+      runProgress = false
       return
     }
 
@@ -371,6 +420,8 @@ After completing a step, include a [DONE:n] tag in your response.`,
     executionMode = false
     todoItems = []
     planFromTool = false
+    stalledRuns = 0
+    runProgress = false
 
     if (pi.getFlag('plan') === true) {
       planModeEnabled = true
@@ -379,7 +430,7 @@ After completing a step, include a [DONE:n] tag in your response.`,
     const entries = ctx.sessionManager.getEntries()
 
     // Restore persisted state
-    const planModeEntry = findLast(entries, (e: { type: string; customType?: string }) => e.type === 'custom' && e.customType === 'plan-mode') as { data?: { enabled: boolean; todos?: TodoItem[]; executing?: boolean } } | undefined
+    const planModeEntry = findLast(entries, (e: { type: string; customType?: string }) => e.type === 'custom' && e.customType === 'plan-mode') as { data?: { enabled: boolean; todos?: TodoItem[]; executing?: boolean; savedTools?: string[] } } | undefined
 
     if (planModeEntry?.data) {
       planModeEnabled = planModeEntry.data.enabled ?? planModeEnabled
@@ -396,7 +447,23 @@ After completing a step, include a [DONE:n] tag in your response.`,
     }
 
     if (planModeEnabled) {
-      enterPlanTools()
+      // Restoring into plan mode is the only case the recorded snapshot is for.
+      // Re-reading the active set here would capture the restriction pi carried
+      // across /reload and cost the session edit and write for good; applying the
+      // snapshot when plan mode is off would instead push a stale set over whatever
+      // pi has registered since, so it stays scoped to this branch.
+      savedTools = planModeEntry?.data?.savedTools ?? pi.getActiveTools()
+      pi.setActiveTools(PLAN_MODE_TOOLS.filter((t) => savedTools.includes(t)))
+      // --plan enters plan mode without ever toggling, so nothing has persisted yet
+      // and a /reload would find no snapshot to restore from. Record it now, while
+      // the active set still says what was there before the restriction.
+      //
+      // Only with no entry at all: an entry written before this field existed means
+      // the active set has already been through a restore and may be the restriction
+      // itself. Those tools are lost for this process either way, but persisting a
+      // guess would write the loss into the session file, where a later resume would
+      // inherit it instead of starting over.
+      if (!planModeEntry) persistState()
     } else {
       // A prior session in this instance may have shrunk the tool set; undo that when
       // the restored/fresh state is not plan mode.

package/extensions/status-line.ts

@@ -104,6 +104,7 @@ export default function statusLine(pi: ExtensionAPI) {
   /** The stdin payload per Claude's documented statusline contract. */
   function buildPayload(ctx: ExtensionContext): Record<string, unknown> {
     const usage = ctx.getContextUsage() ?? { tokens: null, contextWindow: 0, percent: null }
+    const model = ctx.model as { id?: string; name?: string } | undefined
     // Same gate as the config read above: an unapproved project's style is not applied,
     // so reporting it here would describe a style the session is not using.
     const styleName = readActiveStyleName(settingsFiles(ctx.cwd, os.homedir(), projectApproved))
@@ -111,7 +112,9 @@ export default function statusLine(pi: ExtensionAPI) {
       session_id: ctx.sessionManager.getSessionId(),
       cwd: ctx.cwd,
       workspace: { current_dir: ctx.cwd, project_dir: ctx.cwd },
-      model: { id: (ctx.model as { id?: string } | undefined)?.id ?? '' },
+      // Both fields, per Claude's documented contract: published statusline scripts
+      // read .model.display_name and render the literal "null" when it is missing.
+      model: { id: model?.id ?? '', display_name: model?.name ?? model?.id ?? '' },
       cost: { total_cost_usd: sessionCost(ctx) },
       context_window: { context_window_size: usage.contextWindow, used_percentage: usage.percent, total_input_tokens: usage.tokens },
       permission_mode: permissionMode,

package/extensions/subagent/agents.ts

@@ -7,21 +7,10 @@ import * as os from 'node:os'
 import * as path from 'node:path'
 import { getAgentDir, parseFrontmatter, stripFrontmatter } from '@earendil-works/pi-coding-agent'
 
-// Claude Code tool names -> pi tool names; unmapped names pass through lowercased
-const CLAUDE_TOOL_MAP: Record<string, string> = {
-  read: 'read',
-  write: 'write',
-  edit: 'edit',
-  bash: 'bash',
-  grep: 'grep',
-  glob: 'find',
-  ls: 'ls',
-}
-
-function normalizeToolName(tool: string): string {
-  const lower = tool.toLowerCase()
-  return CLAUDE_TOOL_MAP[lower] ?? lower
-}
+// The same mapping a command's `allowed-tools` gets: an agent's `tools:` is the same
+// Claude field, and `--tools` is an exact-name allowlist, so a name pi has no tool for
+// is not merely ignored, it narrows the child's registry.
+import { parseToolList } from '../internal/command-file.js'
 
 /**
  * `tools:` may be a comma-separated string (the Claude Code format) or a YAML block
@@ -30,12 +19,12 @@ function normalizeToolName(tool: string): string {
  */
 function parseToolsField(raw: unknown): string[] | undefined | null {
   if (raw === undefined) return undefined
-  let items: unknown[]
-  if (Array.isArray(raw)) items = raw
-  else if (typeof raw === 'string') items = raw.split(',')
-  else return null
-  if (items.some((item) => typeof item !== 'string')) return null
-  const tools = (items as string[]).map((item) => normalizeToolName(item.trim())).filter(Boolean)
+  // Shares the command parser's splitting, so a comma inside an argument scope stays
+  // inside it here too: `Bash(mv, write, cp)` used to hand the child pi's real `write`.
+  if (raw !== null && !Array.isArray(raw) && typeof raw !== 'string') return null
+  if (Array.isArray(raw) && raw.some((item) => typeof item !== 'string')) return null
+  const tools = parseToolList(raw)
+  if (!tools) return null
   return tools.length > 0 ? tools : undefined
 }
 

package/extensions/subagent/background.ts

@@ -19,8 +19,13 @@ export interface BackgroundRun {
   exitCode?: number
   output?: string
   turns: number
+  /** Last stderr bytes of a failed child; the only diagnostics a boot failure leaves. */
+  stderr?: string
   /** Set while running so the run can be cancelled; cleared on completion. */
   kill?: () => void
+  /** True until the child process actually closes: a cancelled child that ignores
+   * SIGTERM is still alive and must keep holding its concurrency slot. */
+  live?: boolean
   /** pi session the child ran under, so a follow-up can continue its context. */
   sessionId: string
   /** How the child was spawned, so a follow-up can repeat it with a new task. */
@@ -42,30 +47,66 @@ const runs = new Map<string, BackgroundRun>()
 /** Cap on simultaneously running background children. */
 export const MAX_BACKGROUND_RUNS = 8
 
+/** Finished runs kept for status listings and resume; older ones are evicted so a
+ * long session's registry (each entry holds its final output) cannot grow forever. */
+export const MAX_FINISHED_RUNS = 20
+
+/** Grace between the cancel SIGTERM and the SIGKILL that ends a child ignoring it. */
+const CANCEL_KILL_GRACE_MS = 5000
+
+/** Bytes of stderr kept per run, enough for the boot error without buffering logs. */
+const STDERR_TAIL_CHARS = 2048
+
 export function activeBackgroundRuns(): number {
-  return [...runs.values()].filter((run) => run.state === 'running').length
+  return [...runs.values()].filter((run) => run.live || run.state === 'running').length
 }
 
-/** Extract the final assistant text and turn count from a pi --mode json stdout stream. */
-export function parseFinalOutputFromJsonl(jsonl: string): { text: string; turns: number } {
+function evictFinishedRuns(): void {
+  const finished = [...runs.values()].filter((run) => !run.live && run.state !== 'running')
+  for (const stale of finished.slice(0, Math.max(0, finished.length - MAX_FINISHED_RUNS))) runs.delete(stale.id)
+}
+
+/** Line-by-line parser keeping only the last assistant text and a turn count, so a
+ * long run's JSONL stdout never accumulates whole in the parent's memory. */
+export function createJsonlOutputParser(): { push: (chunk: string) => void; flush: () => { text: string; turns: number } } {
+  let buffer = ''
   let text = ''
   let turns = 0
-  for (const line of jsonl.split('\n')) {
-    if (!line.trim()) continue
+  const takeLine = (raw: string): void => {
+    if (!raw.trim()) return
     let event: { type?: string; message?: { role?: string; content?: Array<{ type: string; text?: string }> } }
     try {
-      event = JSON.parse(line)
+      event = JSON.parse(raw)
     } catch {
-      continue
+      return
     }
-    if (event.type !== 'message_end' || event.message?.role !== 'assistant') continue
+    if (event.type !== 'message_end' || event.message?.role !== 'assistant') return
     turns++
     // The complete text of the last assistant message, matching getFinalOutput on the
     // foreground path so a multi-part message reads the same in both.
     const parts = (event.message.content ?? []).filter((p) => p.type === 'text' && p.text).map((p) => p.text as string)
     if (parts.length > 0) text = parts.join('\n')
   }
-  return { text, turns }
+  return {
+    push(chunk) {
+      buffer += chunk
+      const lines = buffer.split('\n')
+      buffer = lines.pop() ?? ''
+      for (const line of lines) takeLine(line)
+    },
+    flush() {
+      takeLine(buffer)
+      buffer = ''
+      return { text, turns }
+    },
+  }
+}
+
+/** Extract the final assistant text and turn count from a pi --mode json stdout stream. */
+export function parseFinalOutputFromJsonl(jsonl: string): { text: string; turns: number } {
+  const parser = createJsonlOutputParser()
+  parser.push(jsonl)
+  return parser.flush()
 }
 
 export function formatStatus(all: Iterable<Pick<BackgroundRun, 'id' | 'agent' | 'task' | 'state' | 'turns' | 'exitCode'>>): string {
@@ -100,15 +141,22 @@ export function backgroundRun(id: string): BackgroundRun | undefined {
 /** Re-spawn a finished run's session with a new task. The child is started with the
  * same --session-id, so it continues with everything it already saw rather than
  * re-deriving context the parent would have to repeat. */
-export function resumeBackgroundRun(id: string, task: string, onComplete: (run: BackgroundRun) => void): 'resumed' | 'still-running' | 'unknown' {
+export function resumeBackgroundRun(id: string, task: string, onComplete: (run: BackgroundRun) => void): 'resumed' | 'still-running' | 'at-capacity' | 'unknown' {
   const run = runs.get(id)
   if (!run) return 'unknown'
-  if (run.state === 'running') return 'still-running'
-  const args = withRebuiltPrompt(run.spawn).map((arg) => (arg.startsWith('Task: ') ? `Task: ${task}` : arg))
+  if (run.state === 'running' || run.live) return 'still-running'
+  // A resume spawns a child like a fresh start does, so it counts against the cap.
+  if (activeBackgroundRuns() >= MAX_BACKGROUND_RUNS) return 'at-capacity'
+  // Persisted so the rebuild happens once: rebuilding per resume leaked one temp
+  // prompt dir every follow-up.
+  const rebuilt = withRebuiltPrompt(run.spawn)
+  run.spawn = { ...run.spawn, args: rebuilt }
+  const args = rebuilt.map((arg) => (arg.startsWith('Task: ') ? `Task: ${task}` : arg))
   run.state = 'running'
   run.task = task
   run.output = undefined
   run.exitCode = undefined
+  run.stderr = undefined
   driveRun(run, { ...run.spawn, args }, onComplete)
   return 'resumed'
 }
@@ -156,44 +204,80 @@ function driveRun(run: BackgroundRun, invocation: BackgroundSpawn, onComplete: (
   const proc = spawn(invocation.command, invocation.args, {
     cwd: invocation.cwd,
     shell: false,
-    stdio: ['ignore', 'pipe', 'ignore'],
+    stdio: ['ignore', 'pipe', 'pipe'],
     // Its own group, so cancelling reaches any grandchild the agent spawned.
     detached: true,
     // The marker lets the child's subagent tool refuse to nest further.
     env: { ...process.env, PI_CODE_SUBAGENT: '1' },
   })
-  run.kill = () => {
+  run.live = true
+  const killGroup = (signal: NodeJS.Signals): void => {
     try {
-      process.kill(-proc.pid!, 'SIGTERM')
+      process.kill(-proc.pid!, signal)
     } catch {
-      proc.kill('SIGTERM')
+      try {
+        proc.kill(signal)
+      } catch {
+        // already gone
+      }
     }
   }
-  let stdout = ''
+  run.kill = () => {
+    killGroup('SIGTERM')
+    // A child ignoring SIGTERM would hold its cap slot and process forever.
+    const escalate = setTimeout(() => killGroup('SIGKILL'), CANCEL_KILL_GRACE_MS)
+    escalate.unref()
+    proc.once('close', () => clearTimeout(escalate))
+  }
+  // Parsed as it streams: buffering the whole JSONL replays every tool result echoed
+  // by the child through the parent's memory for the life of the run.
+  const parser = createJsonlOutputParser()
+  let stderrTail = ''
   // Node fires both 'error' and 'close' on a spawn failure (ENOENT); complete once.
   let completed = false
   const complete = (): void => {
     if (completed) return
     completed = true
-    onComplete(run)
+    evictFinishedRuns()
+    // A run outlives the session that started it, and pi's loader wires assertActive()
+    // into every runtime call, so notifying a disposed session throws. This fires from
+    // the child's 'close'/'error' listener, where nothing upstream catches: an escaping
+    // error reaches Node as an uncaughtException and takes pi down with it. The run
+    // state is already recorded by this point, so there is nothing to do but drop the
+    // notification for a session that is no longer there to receive it.
+    try {
+      onComplete(run)
+    } catch {
+      // the session that asked for this run is gone
+    }
   }
-  proc.stdout.on('data', (data) => {
-    stdout += data.toString()
+  proc.stdout.on('data', (data) => parser.push(data.toString()))
+  // An 'error' on a stream with no listener is rethrown by EventEmitter, and this one
+  // belongs to a detached child, so a pipe read failure would exit pi the same way an
+  // unguarded completion would. The foreground runner guards its streams the same way.
+  proc.stdout.on('error', () => {})
+  proc.stderr?.on('data', (data) => {
+    stderrTail = (stderrTail + data.toString()).slice(-STDERR_TAIL_CHARS)
   })
+  proc.stderr?.on('error', () => {})
   proc.on('close', (code) => {
-    const { text, turns } = parseFinalOutputFromJsonl(stdout)
+    const { text, turns } = parser.flush()
     run.kill = undefined
+    run.live = false
     // A cancelled run keeps that state: its non-zero exit is the cancellation.
     if (run.state !== 'cancelled') run.state = code === 0 ? 'done' : 'failed'
     run.exitCode = code ?? 0
     run.output = text
     run.turns = turns
+    run.stderr = stderrTail.trim() || undefined
     complete()
   })
-  proc.on('error', () => {
+  proc.on('error', (error) => {
     run.kill = undefined
+    run.live = false
     run.state = 'failed'
     run.exitCode = 1
+    run.stderr = stderrTail.trim() || error.message
     complete()
   })
 }