omegon 0.8.3 → 0.9.0

package/extensions/cleave/dispatcher.ts

@@ -21,8 +21,9 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import type { ExtensionAPI } from "@styrene-lab/pi-coding-agent";
 import { DASHBOARD_UPDATE_EVENT, sharedState } from "../lib/shared-state.ts";
-import type { ChildState, CleaveState, ModelTier } from "./types.ts";
+import type { ChildState, CleaveState, ModelTier, RpcChildEvent, RpcProgressUpdate } from "./types.ts";
 import { computeDispatchWaves } from "./planner.ts";
+import { sendRpcCommand, buildPromptCommand, parseRpcEventStream, mapEventToProgress } from "./rpc-child.ts";
 import { executeWithReview, type ReviewConfig, type ReviewExecutor, DEFAULT_REVIEW_CONFIG } from "./review.ts";
 import { saveState } from "./workspace.ts";
 import { resolveTier, getDefaultPolicy, getViableModels, type ProviderRoutingPolicy, type RegistryModel } from "../lib/model-routing.ts";
@@ -83,7 +84,7 @@ export function resolveModelIdForTier(
 export function emitCleaveChildProgress(
 	pi: Pick<ExtensionAPI, "events">,
 	childId: number,
-	patch: { status?: "pending" | "running" | "done" | "failed"; elapsed?: number; startedAt?: number; lastLine?: string; worktreePath?: string },
+	patch: { status?: "pending" | "running" | "done" | "failed"; elapsed?: number; startedAt?: number; lastLine?: string; worktreePath?: string; rpcProgress?: RpcProgressUpdate },
 ): void {
 	const cleaveState = (sharedState as any).cleave;
 	if (!cleaveState?.children?.[childId]) return;
@@ -99,8 +100,16 @@ export function emitCleaveChildProgress(
 	if (patch.worktreePath !== undefined) {
 		cleaveState.children[childId].worktreePath = patch.worktreePath;
 	}
-	if (patch.lastLine !== undefined) {
-		// Update lastLine for backward compat
+	if (patch.rpcProgress !== undefined) {
+		// Structured RPC progress — use summary as lastLine for backward compat
+		const summary = patch.rpcProgress.summary;
+		cleaveState.children[childId].lastLine = summary;
+		const child = cleaveState.children[childId];
+		if (!child.recentLines) child.recentLines = [];
+		child.recentLines.push(summary);
+		if (child.recentLines.length > 30) child.recentLines.splice(0, child.recentLines.length - 30);
+	} else if (patch.lastLine !== undefined) {
+		// Update lastLine for backward compat (pipe mode)
 		cleaveState.children[childId].lastLine = patch.lastLine;
 		// Append to ring buffer (cap at 30)
 		const child = cleaveState.children[childId];
@@ -364,7 +373,11 @@ function stripAnsiForStatus(s: string): string {
 	return s.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "").trim();
 }
 
-async function spawnChild(
+/**
+ * Spawn a child in pipe mode (legacy).
+ * Uses `pi -p --no-session`, writes prompt to stdin, closes stdin.
+ */
+async function spawnChildPipe(
 	prompt: string,
 	cwd: string,
 	timeoutMs: number,
@@ -389,15 +402,13 @@ async function spawnChild(
 			detached: true,
 			env: {
 				...process.env,
-				// Prevent nested detection issues
 				PI_CHILD: "1",
-				// https://warhammer40k.fandom.com/wiki/Alpha_Legion
 				I_AM: "alpharius",
 			},
 		});
 		registerCleaveProc(proc);
 
-		// Write prompt to stdin
+		// Write prompt to stdin and close (pipe mode)
 		if (proc.stdin) {
 			proc.stdin.write(prompt);
 			proc.stdin.end();
@@ -408,7 +419,6 @@ async function spawnChild(
 			const chunk = data.toString();
 			stdout += chunk;
 			if (onLine) {
-				// Parse line by line and forward meaningful lines
 				lineBuf += chunk;
 				const parts = lineBuf.split("\n");
 				lineBuf = parts.pop() ?? "";
@@ -420,7 +430,6 @@ async function spawnChild(
 		});
 		proc.stderr?.on("data", (data) => { stderr += data.toString(); });
 
-		// SIGKILL escalation helper — sends SIGKILL by process group with fallback
 		let escalationTimer: ReturnType<typeof setTimeout> | undefined;
 		const scheduleEscalation = () => {
 			escalationTimer = setTimeout(() => {
@@ -434,15 +443,12 @@ async function spawnChild(
 			}, 5_000);
 		};
 
-		// Timeout enforcement
 		const timer = setTimeout(() => {
 			killed = true;
 			killCleaveProc(proc);
 			scheduleEscalation();
 		}, timeoutMs);
 
-		// Abort signal support (with SIGKILL escalation — detached processes
-		// won't receive SIGHUP on parent exit, so SIGTERM alone is insufficient)
 		const onAbort = () => {
 			killed = true;
 			killCleaveProc(proc);
@@ -481,6 +487,168 @@ async function spawnChild(
 	});
 }
 
+/** Events collected during an RPC child session. */
+interface RpcChildResult extends ChildResult {
+	events: RpcChildEvent[];
+	pipeBroken: boolean;
+}
+
+/**
+ * Spawn a child in RPC mode.
+ * Uses `--mode rpc --no-session`, sends prompt via sendRpcCommand on stdin,
+ * parses stdout as a JSON event stream. Stdin stays open for the session lifetime.
+ */
+async function spawnChildRpc(
+	prompt: string,
+	cwd: string,
+	timeoutMs: number,
+	signal?: AbortSignal,
+	localModel?: string,
+	onEvent?: (event: RpcChildEvent) => void,
+): Promise<RpcChildResult> {
+	const omegon = resolveOmegonSubprocess();
+	const args = [...omegon.argvPrefix, "--mode", "rpc", "--no-session"];
+	if (localModel) {
+		args.push("--model", localModel);
+	}
+
+	return new Promise<RpcChildResult>((resolve) => {
+		let stderr = "";
+		let killed = false;
+		const events: RpcChildEvent[] = [];
+		let pipeBroken = false;
+
+		const proc = spawn(omegon.command, args, {
+			cwd,
+			stdio: ["pipe", "pipe", "pipe"],
+			detached: true,
+			env: {
+				...process.env,
+				PI_CHILD: "1",
+				I_AM: "alpharius",
+			},
+		});
+		registerCleaveProc(proc);
+
+		// Send prompt via RPC command on stdin — keep stdin open
+		if (proc.stdin) {
+			const cmd = buildPromptCommand(prompt);
+			sendRpcCommand(proc.stdin, cmd);
+			// Do NOT close stdin — child may need it for the session lifetime
+		}
+
+		// Collect stderr
+		proc.stderr?.on("data", (data) => { stderr += data.toString(); });
+
+		// Parse stdout exclusively via RPC event stream (no competing data listener)
+		let eventsFinished: Promise<void> = Promise.resolve();
+		if (proc.stdout) {
+			eventsFinished = (async () => {
+				try {
+					for await (const event of parseRpcEventStream(proc.stdout!)) {
+						events.push(event);
+						if (event.type === "pipe_closed") {
+							pipeBroken = true;
+						}
+						onEvent?.(event);
+					}
+				} catch {
+					// Stream parsing error — treat as pipe break
+					pipeBroken = true;
+				}
+			})();
+		}
+
+		let escalationTimer: ReturnType<typeof setTimeout> | undefined;
+		const scheduleEscalation = () => {
+			escalationTimer = setTimeout(() => {
+				if (!proc.killed) {
+					try {
+						if (proc.pid) process.kill(-proc.pid, "SIGKILL");
+					} catch {
+						try { proc.kill("SIGKILL"); } catch { /* already dead */ }
+					}
+				}
+			}, 5_000);
+		};
+
+		const timer = setTimeout(() => {
+			killed = true;
+			killCleaveProc(proc);
+			scheduleEscalation();
+		}, timeoutMs);
+
+		const onAbort = () => {
+			killed = true;
+			killCleaveProc(proc);
+			scheduleEscalation();
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+
+		let settled = false;
+		proc.on("close", async (code) => {
+			if (settled) return;
+			settled = true;
+			deregisterCleaveProc(proc);
+			clearTimeout(timer);
+			clearTimeout(escalationTimer);
+			signal?.removeEventListener("abort", onAbort);
+
+			// Close stdin if still open (child has exited)
+			try { proc.stdin?.end(); } catch { /* already closed */ }
+
+			// Wait for all RPC events to be consumed before resolving
+			await eventsFinished;
+
+			resolve({
+				exitCode: killed ? -1 : (code ?? 1),
+				stdout: "",
+				stderr: killed ? `Killed (timeout or abort)\n${stderr}` : stderr,
+				events,
+				pipeBroken,
+			});
+		});
+
+		proc.on("error", (err) => {
+			if (settled) return;
+			settled = true;
+			deregisterCleaveProc(proc);
+			clearTimeout(timer);
+			clearTimeout(escalationTimer);
+			signal?.removeEventListener("abort", onAbort);
+			resolve({
+				exitCode: 1,
+				stdout: "",
+				stderr: `Failed to spawn pi: ${err.message}`,
+				events,
+				pipeBroken: true,
+			});
+		});
+	});
+}
+
+/**
+ * Spawn a child process — dispatches to RPC or pipe mode.
+ *
+ * @param useRpc  When true (default), uses RPC mode with structured events.
+ *                When false, uses legacy pipe mode.
+ */
+async function spawnChild(
+	prompt: string,
+	cwd: string,
+	timeoutMs: number,
+	signal?: AbortSignal,
+	localModel?: string,
+	onLine?: (line: string) => void,
+	useRpc?: boolean,
+	onEvent?: (event: RpcChildEvent) => void,
+): Promise<ChildResult> {
+	if (useRpc) {
+		return spawnChildRpc(prompt, cwd, timeoutMs, signal, localModel, onEvent);
+	}
+	return spawnChildPipe(prompt, cwd, timeoutMs, signal, localModel, onLine);
+}
+
 // ─── Concurrency control ────────────────────────────────────────────────────
 
 /**
@@ -674,8 +842,20 @@ async function dispatchSingleChild(
 	// Mirror to sharedState for live dashboard updates (include startedAt for elapsed ticker)
 	emitCleaveChildProgress(pi, child.childId, { status: "running", startedAt: startedAtMs, worktreePath: child.worktreePath });
 
-	// Debounced last-line emitter: buffers stdout lines and pushes to shared
-	// state at most once per 500ms to avoid flooding the event bus.
+	// ── Progress callbacks ──────────────────────────────────────────────────
+	// RPC mode: direct event forwarding (no debounce)
+	// Pipe mode: debounced line emitter (legacy)
+	const useRpc = true;
+
+	// RPC event handler — forward structured progress directly
+	const onRpcEvent = (event: RpcChildEvent) => {
+		const progress = mapEventToProgress(event);
+		if (progress) {
+			emitCleaveChildProgress(pi, child.childId, { rpcProgress: progress });
+		}
+	};
+
+	// Pipe mode fallback: debounced last-line emitter
 	let pendingLine: string | undefined;
 	let debounceTimer: ReturnType<typeof setTimeout> | undefined;
 	const flushLine = () => {
@@ -738,14 +918,15 @@ async function dispatchSingleChild(
 	// Build executor adapter for the review loop
 	const executor: ReviewExecutor = {
 		execute: async (execPrompt: string, execCwd: string, execModelFlag?: string) => {
-			return spawnChild(execPrompt, execCwd, timeoutMs, signal, execModelFlag, onChildLine);
+			// Execution uses RPC mode for structured events
+			return spawnChild(execPrompt, execCwd, timeoutMs, signal, execModelFlag,
+				useRpc ? undefined : onChildLine, useRpc, useRpc ? onRpcEvent : undefined);
 		},
 		review: async (reviewPrompt: string, reviewCwd: string) => {
-			// Reviews always use gloriana (D4: highest available tier) — resolve to explicit ID
+			// Reviews always use pipe mode (Phase 1) + gloriana tier
 			const reviewModelId = resolveModelIdForTier("gloriana", registryModels, activePolicy, localModel);
-			// Review runs don't stream lastLine — they're short and we don't want
-			// review commentary to overwrite the last execution status line.
-			return spawnChild(reviewPrompt, reviewCwd, timeoutMs, signal, reviewModelId);
+			return spawnChild(reviewPrompt, reviewCwd, timeoutMs, signal, reviewModelId,
+				undefined, false /* pipe mode for review */);
 		},
 		readFile: (path: string) => readFileSync(path, "utf-8"),
 	};
@@ -799,6 +980,18 @@ async function dispatchSingleChild(
 		child.error = result.stderr.slice(0, 2000) || `Exit code ${result.exitCode}`;
 	}
 
+	// RPC pipe-break handling: if stdout closed unexpectedly, mark failed
+	// but preserve worktree and branch for recovery
+	if (useRpc && "pipeBroken" in result && (result as RpcChildResult).pipeBroken) {
+		// Only override status if it wasn't already set to completed (child may
+		// have finished before the pipe break was detected)
+		if (child.status !== "completed") {
+			child.status = "failed";
+			child.error = "RPC pipe break: stdout closed unexpectedly — worktree preserved for recovery";
+			// Do NOT clean up worktree — preserve for manual recovery
+		}
+	}
+
 	// If review escalated, mark the child as failed
 	if (reviewResult.finalDecision === "escalated") {
 		child.status = "failed";

package/extensions/cleave/index.ts

@@ -352,7 +352,7 @@ async function checkpointRelatedChanges(
  * Prevents infinite loops when the agent repeatedly picks actions
  * that don't resolve the dirty tree.
  */
-const MAX_PREFLIGHT_ATTEMPTS = 3;
+export const MAX_PREFLIGHT_ATTEMPTS = 3;
 
 /**
  * Verify the tree is clean after an action. If only volatile files remain,
@@ -435,12 +435,23 @@ export async function runDirtyTreePreflight(pi: ExtensionAPI, options: DirtyTree
 		throw new Error(summary + "\n\nInteractive input is unavailable, so cleave cannot resolve the dirty tree automatically.");
 	}
 
-	// Mutable classification — refreshed after each action attempt.
+	// Mutable classification — refreshed after each resolution action.
 	let currentClassification = classification;
-	let attempts = 0;
-
-	while (attempts < MAX_PREFLIGHT_ATTEMPTS) {
-		attempts++;
+	// Only resolution actions (checkpoint, stash) increment this counter.
+	// Invalid input, empty guards, cancel, and proceed-without-cleave do NOT
+	// consume attempts — they are navigational, not resolution attempts.
+	let resolutionAttempts = 0;
+
+	// Outer safety cap: total loop iterations including non-resolution turns.
+	// Prevents truly pathological loops (e.g. select always returning garbage).
+	const MAX_TOTAL_ITERATIONS = MAX_PREFLIGHT_ATTEMPTS * 3;
+	let totalIterations = 0;
+
+	while (resolutionAttempts < MAX_PREFLIGHT_ATTEMPTS) {
+		totalIterations++;
+		if (totalIterations > MAX_TOTAL_ITERATIONS) {
+			break; // Fall through to the exhaustion error below
+		}
 
 		let answer: string | undefined;
 		if (hasSelect) {
@@ -458,6 +469,7 @@ export async function runDirtyTreePreflight(pi: ExtensionAPI, options: DirtyTree
 		try {
 			switch (answer) {
 				case "checkpoint": {
+					resolutionAttempts++;
 					const currentCheckpointPlan = buildCheckpointPlan(currentClassification, { changeName, openspecContext });
 					await checkpointRelatedChanges(pi, options.repoPath, currentClassification, currentCheckpointPlan.message, options.ui);
 
@@ -493,6 +505,7 @@ export async function runDirtyTreePreflight(pi: ExtensionAPI, options: DirtyTree
 						});
 						break;
 					}
+					resolutionAttempts++;
 					await stashPaths(pi, options.repoPath, "cleave-preflight-unrelated", toStash);
 					const { clean, classification: postClassification } = await verifyCleanAfterAction(
 						pi, options.repoPath, changeName, openspecContext, options.onUpdate,
@@ -509,6 +522,7 @@ export async function runDirtyTreePreflight(pi: ExtensionAPI, options: DirtyTree
 						});
 						break;
 					}
+					resolutionAttempts++;
 					await stashPaths(pi, options.repoPath, "cleave-preflight-volatile", currentClassification.volatile);
 					const { clean, classification: postClassification } = await verifyCleanAfterAction(
 						pi, options.repoPath, changeName, openspecContext, options.onUpdate,
@@ -529,6 +543,8 @@ export async function runDirtyTreePreflight(pi: ExtensionAPI, options: DirtyTree
 					});
 			}
 		} catch (error) {
+			// Resolution action threw (e.g. git commit failed) — still counts
+			// as a resolution attempt since work was attempted.
 			const message = error instanceof Error ? error.message : String(error);
 			options.onUpdate?.({
 				content: [{ type: "text", text: `Preflight action failed: ${message}` }],
@@ -537,7 +553,7 @@ export async function runDirtyTreePreflight(pi: ExtensionAPI, options: DirtyTree
 		}
 	}
 
-	// Exhausted attempts — report remaining dirty files and bail.
+	// Exhausted resolution attempts — report remaining dirty files and bail.
 	const remaining = [
 		...currentClassification.related,
 		...currentClassification.unrelated,
@@ -545,7 +561,7 @@ export async function runDirtyTreePreflight(pi: ExtensionAPI, options: DirtyTree
 		...currentClassification.volatile,
 	];
 	throw new Error(
-		`Dirty tree not resolved after ${MAX_PREFLIGHT_ATTEMPTS} attempts. Remaining files:\n` +
+		`Dirty tree not resolved after ${resolutionAttempts} resolution attempt(s). Remaining files:\n` +
 		remaining.map((f) => `  • ${f.path}`).join("\n") +
 		"\n\nResolve manually (git commit/stash/checkout) and retry /cleave.",
 	);

package/extensions/cleave/rpc-child.ts

@@ -0,0 +1,269 @@
+/**
+ * cleave/rpc-child — RPC child communication module.
+ *
+ * Provides JSON line framing for stdin commands, stdout event stream parsing,
+ * event-to-progress mapping, and pipe-break handling for cleave child processes
+ * running in `--mode rpc`.
+ *
+ * This module is a building block for the dispatcher to use when spawning
+ * children in RPC mode instead of pipe mode.
+ */
+
+import type { Writable, Readable } from "node:stream";
+import { StringDecoder } from "node:string_decoder";
+import type { RpcChildEvent, RpcProgressUpdate } from "./types.ts";
+
+// ─── JSON Line Framing (stdin commands) ─────────────────────────────────────
+
+/**
+ * Serialize and write a JSON command to a child's stdin.
+ * Uses strict LF-only JSONL framing (matching pi-mono's serializeJsonLine).
+ *
+ * @returns true if the write succeeded, false if stdin is not writable
+ */
+export function sendRpcCommand(
+	stdin: Writable,
+	command: Record<string, unknown>,
+): boolean {
+	if (!stdin.writable) return false;
+	try {
+		stdin.write(`${JSON.stringify(command)}\n`);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Build a prompt command for a cleave child task.
+ */
+export function buildPromptCommand(
+	message: string,
+	id?: string,
+): Record<string, unknown> {
+	const cmd: Record<string, unknown> = { type: "prompt", message };
+	if (id !== undefined) cmd.id = id;
+	return cmd;
+}
+
+/**
+ * Build an abort command.
+ */
+export function buildAbortCommand(id?: string): Record<string, unknown> {
+	const cmd: Record<string, unknown> = { type: "abort" };
+	if (id !== undefined) cmd.id = id;
+	return cmd;
+}
+
+// ─── Stdout Event Stream Parser ─────────────────────────────────────────────
+
+/**
+ * Parse an RPC event stream from a child's stdout as an async iterator.
+ *
+ * Yields typed RpcChildEvent objects for each valid JSON line received.
+ * Non-JSON lines are silently skipped (child may emit debug output to stdout).
+ *
+ * When stdout closes (end event), the iterator emits a synthetic
+ * `{ type: "pipe_closed" }` event and completes — it does NOT throw.
+ * This enables graceful degradation: the caller decides how to handle
+ * pipe breaks vs normal completion.
+ */
+export async function* parseRpcEventStream(
+	stdout: Readable,
+): AsyncGenerator<RpcChildEvent, void, undefined> {
+	// We implement a manual async iteration over the stream data,
+	// using LF-only splitting (matching pi-mono's jsonl.ts approach).
+	const decoder = new StringDecoder("utf8");
+	let buffer = "";
+	let done = false;
+
+	// Queue for parsed events, with a resolver for the consumer
+	const queue: RpcChildEvent[] = [];
+	let waitResolve: (() => void) | null = null;
+
+	function enqueue(event: RpcChildEvent) {
+		queue.push(event);
+		if (waitResolve) {
+			const r = waitResolve;
+			waitResolve = null;
+			r();
+		}
+	}
+
+	function processBuffer() {
+		while (true) {
+			const idx = buffer.indexOf("\n");
+			if (idx === -1) break;
+			const line = buffer.slice(0, idx);
+			buffer = buffer.slice(idx + 1);
+			// Strip optional CR
+			const clean = line.endsWith("\r") ? line.slice(0, -1) : line;
+			if (clean.length === 0) continue;
+			try {
+				const parsed = JSON.parse(clean);
+				if (parsed && typeof parsed === "object" && typeof parsed.type === "string") {
+					enqueue(parsed as RpcChildEvent);
+				}
+			} catch {
+				// Non-JSON line — skip silently
+			}
+		}
+	}
+
+	const onData = (chunk: Buffer | string) => {
+		buffer += typeof chunk === "string" ? chunk : decoder.write(chunk);
+		processBuffer();
+	};
+
+	const onEnd = () => {
+		buffer += decoder.end();
+		processBuffer();
+		// Emit synthetic pipe_closed event
+		enqueue({ type: "pipe_closed" });
+		done = true;
+		// Wake up consumer if waiting
+		if (waitResolve) {
+			const r = waitResolve;
+			waitResolve = null;
+			r();
+		}
+	};
+
+	const onError = (_err: Error) => {
+		enqueue({ type: "pipe_closed" });
+		done = true;
+		if (waitResolve) {
+			const r = waitResolve;
+			waitResolve = null;
+			r();
+		}
+	};
+
+	stdout.on("data", onData);
+	stdout.on("end", onEnd);
+	stdout.on("error", onError);
+
+	try {
+		while (true) {
+			if (queue.length > 0) {
+				const event = queue.shift()!;
+				yield event;
+				if (event.type === "pipe_closed") return;
+			} else if (done) {
+				return;
+			} else {
+				// Wait for next event
+				await new Promise<void>((resolve) => {
+					waitResolve = resolve;
+				});
+			}
+		}
+	} finally {
+		stdout.off("data", onData);
+		stdout.off("end", onEnd);
+		stdout.off("error", onError);
+	}
+}
+
+// ─── Event-to-Progress Mapping ──────────────────────────────────────────────
+
+/**
+ * Map an RpcChildEvent to a structured progress update for the dashboard.
+ *
+ * Returns null for events that don't produce meaningful progress (e.g. turn_start).
+ */
+export function mapEventToProgress(event: RpcChildEvent): RpcProgressUpdate | null {
+	switch (event.type) {
+		case "agent_start":
+			return { kind: "lifecycle", summary: "Agent started" };
+
+		case "agent_end":
+			return { kind: "lifecycle", summary: "Agent completed" };
+
+		case "turn_start":
+			return null; // No meaningful progress
+
+		case "turn_end":
+			return { kind: "lifecycle", summary: "Turn completed" };
+
+		case "message_start":
+			return null; // Wait for content
+
+		case "message_update":
+			return null; // Too noisy for dashboard
+
+		case "message_end":
+			return { kind: "lifecycle", summary: "Message completed" };
+
+		case "tool_execution_start":
+			return {
+				kind: "tool",
+				summary: `tool: ${event.toolName}${formatToolArgs(event.toolName, event.args)}`,
+				toolName: event.toolName,
+			};
+
+		case "tool_execution_update":
+			return null; // Partial results too noisy
+
+		case "tool_execution_end":
+			return {
+				kind: "tool",
+				summary: `tool: ${event.toolName} ${event.isError ? "✗" : "✓"}`,
+				toolName: event.toolName,
+			};
+
+		case "auto_compaction_start":
+			return { kind: "lifecycle", summary: "Compacting context…" };
+
+		case "auto_compaction_end":
+			return { kind: "lifecycle", summary: event.aborted ? "Compaction aborted" : "Compaction done" };
+
+		case "auto_retry_start":
+			return { kind: "lifecycle", summary: `Retry ${event.attempt}/${event.maxAttempts}` };
+
+		case "auto_retry_end":
+			return { kind: "lifecycle", summary: event.success ? "Retry succeeded" : "Retry failed" };
+
+		case "response":
+			// RPC response to our command — not progress-relevant
+			return null;
+
+		case "pipe_closed":
+			return { kind: "error", summary: "Pipe closed" };
+
+		case "extension_ui_request":
+			// UI requests from child extensions — not progress-relevant
+			return null;
+
+		default: {
+			// Exhaustiveness check: if a new event type is added to RpcChildEvent
+			// but not handled here, TypeScript will report an error on this line.
+			const _exhaustive: never = event;
+			return null;
+		}
+	}
+}
+
+/**
+ * Format tool arguments for display in a concise summary line.
+ */
+function formatToolArgs(toolName: string, args: unknown): string {
+	if (!args || typeof args !== "object") return "";
+	const a = args as Record<string, unknown>;
+	switch (toolName) {
+		case "read":
+		case "write":
+		case "view":
+			return a.path ? ` ${a.path}` : "";
+		case "edit":
+			return a.path ? ` ${a.path}` : "";
+		case "bash":
+			if (typeof a.command === "string") {
+				const cmd = a.command.length > 60 ? a.command.slice(0, 57) + "…" : a.command;
+				return ` ${cmd}`;
+			}
+			return "";
+		default:
+			return "";
+	}
+}