pi-agent-squad 0.8.5 → 0.9.0

package/README.md

@@ -102,7 +102,10 @@ The TUI-only widget is installed above the editor while at least one subagent is
   the hint and hide it when the title itself needs the space.
 - The elapsed time and spinner refresh once per second while work is active, avoiding hot-loop rerenders on very large sessions.
 - Normal completion, failure, timeout, cancellation, crash, and session shutdown all remove the matching activity. The widget itself is removed when no activities remain.
-- JSON/RPC/print modes do not install the widget.
+- JSON/RPC/print modes do not install the widget. In RPC mode the same live runs
+  are instead published as the `cypher.subagents.v1` status snapshot (see
+  `cypher-status.ts`), which is what a GUI host such as Cypher renders in its
+  Subagents panel.
 
 ### Keyboard navigation
 
@@ -245,6 +248,7 @@ subagents/
 |-- message.ts      # generic messaging (file channel + send/reply/read + main-side router)
 |-- session.ts      # common interactive session-handle interface
 |-- session-ui.ts   # focused overlay for live transcript + interactive input
+|-- cypher-status.ts # `cypher.subagents.v1` live run projection for GUI hosts (RPC mode)
 |-- task-state.ts   # durable schema, validation, and branch reconstruction
 |-- task-recovery.ts # stale-run and undelivered-result reconciliation planning
 |-- task-delivery.ts # delivery IDs, durable dedupe, and recovery outbox

package/cypher-status.ts

@@ -0,0 +1,401 @@
+/**
+ * Cypher subagent status protocol (`cypher.subagents.v1`).
+ *
+ * Cypher runs Pi in RPC mode and has no terminal to render the TUI widget
+ * into. Instead it consumes a STRUCTURED live projection published through
+ * `ctx.ui.setStatus`: the one status key Cypher parses instead of treating as
+ * transient TUI furniture. Without it a subagent run shows as an eternal
+ * "starting" row in Cypher's Subagents inspector, because the only other
+ * signal it has is an unresolved tool call.
+ *
+ * Contract (mirrors Cypher's `parse_subagent_status`, which validates every
+ * field strictly and DROPS THE WHOLE SNAPSHOT on any violation):
+ * - key `cypher.subagents.v1`, value `JSON.stringify({version: 1, runs: […]})`;
+ *   blank text is a CLEAR snapshot.
+ * - per run: `runId` + `agent` + `mode` (`sync|async|message`) + `status`
+ *   (`running|done|error`) + `startedAt`/`updatedAt` epoch millis are
+ *   required; `toolCallId`, `model`, `task`, `progress`, `endedAt` optional.
+ * - bounds: ≤32 runs, task ≤500 chars, progress ≤8 lines / 4KiB, snapshot
+ *   ≤64KiB.
+ *
+ * `updatedAt` doubles as the heartbeat: Cypher greys a run out as stale after
+ * 45s of silence, so live runs are republished on a timer.
+ *
+ * RPC mode only — the TUI keeps its own widget and must never be handed this
+ * JSON. A standalone Pi (no Cypher) simply never attaches.
+ */
+
+export const CYPHER_SUBAGENT_STATUS_KEY = "cypher.subagents.v1";
+
+const SNAPSHOT_VERSION = 1;
+/** Snapshot bounds — Cypher re-checks each one and ignores a snapshot that breaks any. */
+const MAX_RUNS = 32;
+const MAX_TASK_CHARS = 500;
+const MAX_PROGRESS_LINES = 8;
+const MAX_PROGRESS_BYTES = 4096;
+const MAX_SNAPSHOT_BYTES = 64 * 1024;
+/** Settled runs kept in the snapshot so the panel can show Done/Error instead of a row that vanishes. */
+const MAX_TERMINAL_RUNS = 8;
+/** Progress tail kept per run (Cypher renders the last line on the row). */
+const MAX_PROGRESS_KEPT = 6;
+const MAX_PROGRESS_LINE_CHARS = 160;
+/** Republish period for live runs; Cypher's staleness window is 45s. */
+const HEARTBEAT_MS = 10_000;
+/**
+ * Floor between progress-driven publishes. Every snapshot Cypher accepts is a
+ * synced session-row write, and a busy child emits tool events several times a
+ * second — lifecycle changes publish immediately, chatter coalesces.
+ */
+const MIN_PUBLISH_INTERVAL_MS = 750;
+
+export type CypherRunMode = "sync" | "async" | "message";
+export type CypherRunStatus = "running" | "done" | "error";
+
+/** One run as published. Field names are the wire format — camelCase, epoch millis. */
+export interface CypherRun {
+	runId: string;
+	toolCallId?: string;
+	agent: string;
+	model?: string;
+	task: string;
+	mode: CypherRunMode;
+	status: CypherRunStatus;
+	progress?: string;
+	startedAt: number;
+	updatedAt: number;
+	endedAt?: number;
+}
+
+export interface CypherStatusSnapshot {
+	version: number;
+	runs: CypherRun[];
+}
+
+export interface StartRunInput {
+	runId: string;
+	agent: string;
+	task: string;
+	mode: CypherRunMode;
+	/** The parent tool call this run answers to (sync/async); absent for message activity. */
+	toolCallId?: string;
+	model?: string;
+	startedAt?: number;
+}
+
+interface StatusUi {
+	setStatus(key: string, text: string | undefined): void;
+}
+
+interface StatusContext {
+	mode?: string;
+	ui?: Partial<StatusUi>;
+}
+
+function boundText(value: string, maxChars: number): string {
+	const text = String(value ?? "").replace(/\s+/g, " ").trim();
+	if (text.length <= maxChars) return text;
+	// Cut on a code point boundary: Cypher counts characters, not UTF-16 units.
+	return `${[...text].slice(0, Math.max(0, maxChars - 1)).join("")}…`;
+}
+
+function boundLine(value: string): string {
+	const stripped = String(value ?? "").replace(/\u001b\[[0-9;]*[A-Za-z]/g, "");
+	return boundText(stripped, MAX_PROGRESS_LINE_CHARS);
+}
+
+/** Join the kept tail within BOTH Cypher's line and byte caps. */
+function renderProgress(lines: string[]): string | undefined {
+	let kept = lines.filter((line) => line.length > 0).slice(-MAX_PROGRESS_LINES);
+	while (kept.length > 0 && Buffer.byteLength(kept.join("\n"), "utf8") > MAX_PROGRESS_BYTES) {
+		kept = kept.slice(1);
+	}
+	const text = kept.join("\n");
+	return text.length > 0 ? text : undefined;
+}
+
+/** A short, human-readable argument for a child tool call ("bash: cargo test"). */
+function summarizeToolArgs(args: unknown): string {
+	if (!args || typeof args !== "object") return "";
+	const record = args as Record<string, unknown>;
+	for (const key of ["command", "path", "file_path", "pattern", "query", "url"]) {
+		const value = record[key];
+		if (typeof value === "string" && value.trim()) return boundText(value, 60);
+	}
+	return "";
+}
+
+/** First meaningful line of an assistant message's text content. */
+function assistantHeadline(message: any): string {
+	const content = message?.content;
+	const parts = Array.isArray(content) ? content : [];
+	for (const part of parts) {
+		const text = typeof part?.text === "string" ? part.text : "";
+		const line = text.split("\n").map((l: string) => l.trim()).find((l: string) => l.length > 0);
+		if (line) return boundLine(line);
+	}
+	if (typeof content === "string") {
+		const line = content.split("\n").map((l) => l.trim()).find((l) => l.length > 0);
+		if (line) return boundLine(line);
+	}
+	return "";
+}
+
+/**
+ * The live run ledger Cypher reads. Deliberately independent of the TUI
+ * widget: the widget is presentation for a terminal, this is a protocol.
+ */
+export class CypherStatusPublisher {
+	private runs = new Map<string, CypherRun>();
+	private progress = new Map<string, string[]>();
+	private ui: StatusUi | undefined;
+	private timer: ReturnType<typeof setInterval> | undefined;
+	private pending: ReturnType<typeof setTimeout> | undefined;
+	private lastPublishAt = 0;
+	/** Last published text — an unchanged snapshot is never re-sent. */
+	private lastPublished: string | undefined;
+
+	/** RPC mode only. Re-attaching (a new session) keeps whatever is live. */
+	attach(ctx: StatusContext | undefined): void {
+		const ui = ctx?.mode === "rpc" ? ctx.ui : undefined;
+		this.ui = typeof ui?.setStatus === "function" ? (ui as StatusUi) : undefined;
+		this.lastPublished = undefined;
+		if (!this.ui) {
+			this.stopHeartbeat();
+			return;
+		}
+		if (this.liveCount() > 0) this.startHeartbeat();
+		this.publish(true);
+	}
+
+	/** Session shutdown: clear the board so Cypher never keeps a ghost runner. */
+	shutdown(): void {
+		this.runs.clear();
+		this.progress.clear();
+		this.stopHeartbeat();
+		this.cancelPending();
+		if (this.ui) {
+			this.ui.setStatus(CYPHER_SUBAGENT_STATUS_KEY, undefined);
+			this.lastPublished = undefined;
+		}
+		this.ui = undefined;
+	}
+
+	get size(): number {
+		return this.runs.size;
+	}
+
+	/** Is this run still published as running? */
+	isLive(runId: string): boolean {
+		return this.runs.get(runId)?.status === "running";
+	}
+
+	/** Snapshot the publisher would send right now (the unit-test surface). */
+	snapshot(): CypherStatusSnapshot {
+		return { version: SNAPSHOT_VERSION, runs: this.orderedRuns() };
+	}
+
+	start(input: StartRunInput): void {
+		const now = Date.now();
+		const startedAt = input.startedAt ?? now;
+		this.runs.set(input.runId, {
+			runId: input.runId,
+			...(input.toolCallId ? { toolCallId: input.toolCallId } : {}),
+			agent: boundText(input.agent, 120) || "subagent",
+			...(input.model ? { model: boundText(input.model, 120) } : {}),
+			task: boundText(input.task, MAX_TASK_CHARS),
+			mode: input.mode,
+			status: "running",
+			startedAt,
+			updatedAt: now,
+		});
+		this.progress.delete(input.runId);
+		this.startHeartbeat();
+		this.publish(true);
+	}
+
+	/** Model discovered mid-run, or a new progress line. No-op for unknown runs. */
+	update(runId: string, patch: { model?: string; progressLine?: string }): void {
+		const run = this.runs.get(runId);
+		if (!run || run.status !== "running") return;
+		let changed = false;
+		if (patch.model && !run.model) {
+			run.model = boundText(patch.model, 120);
+			changed = true;
+		}
+		const line = patch.progressLine ? boundLine(patch.progressLine) : "";
+		if (line) {
+			const lines = this.progress.get(runId) ?? [];
+			// Consecutive duplicates are noise (a tool retried on every chunk).
+			if (lines[lines.length - 1] !== line) {
+				lines.push(line);
+				this.progress.set(runId, lines.slice(-MAX_PROGRESS_KEPT));
+				changed = true;
+			}
+		}
+		if (!changed) return;
+		run.updatedAt = Date.now();
+		this.publish();
+	}
+
+	/**
+	 * Terminalize a run only if it is still live — a teardown path that can run
+	 * after a specific `finish` (or after the owner lost interest) must never
+	 * leave a runner published forever.
+	 */
+	settleIfLive(runId: string, status: Exclude<CypherRunStatus, "running">, detail?: string): void {
+		if (!this.isLive(runId)) return;
+		this.finish(runId, status, detail);
+	}
+
+	finish(runId: string, status: Exclude<CypherRunStatus, "running">, detail?: string): void {
+		const run = this.runs.get(runId);
+		if (!run) return;
+		const now = Date.now();
+		run.status = status;
+		run.updatedAt = now;
+		run.endedAt = now;
+		const line = detail ? boundLine(detail) : "";
+		if (line) {
+			const lines = this.progress.get(runId) ?? [];
+			lines.push(line);
+			this.progress.set(runId, lines.slice(-MAX_PROGRESS_KEPT));
+		}
+		this.trimTerminal();
+		if (this.liveCount() === 0) this.stopHeartbeat();
+		this.publish(true);
+	}
+
+	/**
+	 * Child Pi RPC events → model + a progress tail. Best effort: the run is
+	 * still reported without any of this.
+	 */
+	observeChildEvent(runId: string, event: any): void {
+		if (!this.runs.has(runId)) return;
+		// This runs inside the child's event dispatch, which does NOT guard its
+		// callbacks: a throw here would break the run itself.
+		try {
+			const type = event?.type;
+			if (type === "tool_execution_start") {
+				const name = String(event?.toolName ?? "tool");
+				const args = summarizeToolArgs(event?.args);
+				this.update(runId, { progressLine: args ? `${name}: ${args}` : name });
+				return;
+			}
+			if (type === "message_end" && event?.message?.role === "assistant") {
+				const model = typeof event.message.model === "string" ? event.message.model : undefined;
+				this.update(runId, { model, progressLine: assistantHeadline(event.message) });
+			}
+		} catch {
+			/* a malformed child event is never worth a failed run */
+		}
+	}
+
+	private liveCount(): number {
+		let live = 0;
+		for (const run of this.runs.values()) if (run.status === "running") live++;
+		return live;
+	}
+
+	/** Live first (oldest first), then the most recently settled. */
+	private orderedRuns(): CypherRun[] {
+		const all = [...this.runs.values()];
+		const live = all.filter((run) => run.status === "running").sort((a, b) => a.startedAt - b.startedAt);
+		const settled = all
+			.filter((run) => run.status !== "running")
+			.sort((a, b) => (b.endedAt ?? b.updatedAt) - (a.endedAt ?? a.updatedAt));
+		return [...live, ...settled].slice(0, MAX_RUNS).map((run) => {
+			const progress = renderProgress(this.progress.get(run.runId) ?? []);
+			return progress ? { ...run, progress } : { ...run };
+		});
+	}
+
+	/** Keep the settled tail bounded so a long session never grows the board. */
+	private trimTerminal(): void {
+		const settled = [...this.runs.values()]
+			.filter((run) => run.status !== "running")
+			.sort((a, b) => (b.endedAt ?? b.updatedAt) - (a.endedAt ?? a.updatedAt));
+		for (const run of settled.slice(MAX_TERMINAL_RUNS)) {
+			this.runs.delete(run.runId);
+			this.progress.delete(run.runId);
+		}
+	}
+
+	private startHeartbeat(): void {
+		// Nothing consumes the snapshot outside Cypher, so a standalone TUI must
+		// not even carry the timer.
+		if (!this.ui || this.timer) return;
+		this.timer = setInterval(() => {
+			if (this.liveCount() === 0) {
+				this.stopHeartbeat();
+				return;
+			}
+			const now = Date.now();
+			for (const run of this.runs.values()) if (run.status === "running") run.updatedAt = now;
+			this.publish(true);
+		}, HEARTBEAT_MS);
+		// A heartbeat must never hold the process open.
+		this.timer.unref?.();
+	}
+
+	private stopHeartbeat(): void {
+		if (!this.timer) return;
+		clearInterval(this.timer);
+		this.timer = undefined;
+	}
+
+	/** `immediate` = a lifecycle change; anything else coalesces. */
+	private publish(immediate = false): void {
+		if (!this.ui) return;
+		const waited = Date.now() - this.lastPublishAt;
+		if (!immediate && waited < MIN_PUBLISH_INTERVAL_MS) {
+			if (this.pending) return;
+			this.pending = setTimeout(() => {
+				this.pending = undefined;
+				this.publishNow();
+			}, MIN_PUBLISH_INTERVAL_MS - waited);
+			this.pending.unref?.();
+			return;
+		}
+		this.cancelPending();
+		this.publishNow();
+	}
+
+	private publishNow(): void {
+		if (!this.ui) return;
+		const text = serializeSnapshot(this.orderedRuns());
+		this.lastPublishAt = Date.now();
+		if (text === this.lastPublished) return;
+		this.lastPublished = text;
+		try {
+			this.ui.setStatus(CYPHER_SUBAGENT_STATUS_KEY, text);
+		} catch {
+			/* a status frame must never break a run */
+		}
+	}
+
+	private cancelPending(): void {
+		if (!this.pending) return;
+		clearTimeout(this.pending);
+		this.pending = undefined;
+	}
+}
+
+/**
+ * Serialize within the 64KiB cap. Over budget, progress goes first, then the
+ * settled tail — the live runs are the part Cypher cannot re-derive.
+ */
+export function serializeSnapshot(runs: CypherRun[]): string {
+	const encode = (list: CypherRun[]) => JSON.stringify({ version: SNAPSHOT_VERSION, runs: list });
+	let text = encode(runs);
+	if (Buffer.byteLength(text, "utf8") <= MAX_SNAPSHOT_BYTES) return text;
+	const withoutProgress = runs.map(({ progress: _progress, ...run }) => run as CypherRun);
+	text = encode(withoutProgress);
+	if (Buffer.byteLength(text, "utf8") <= MAX_SNAPSHOT_BYTES) return text;
+	let live = withoutProgress.filter((run) => run.status === "running");
+	text = encode(live);
+	while (live.length > 1 && Buffer.byteLength(text, "utf8") > MAX_SNAPSHOT_BYTES) {
+		live = live.slice(0, Math.floor(live.length / 2));
+		text = encode(live);
+	}
+	return text;
+}

package/index.ts

@@ -36,6 +36,7 @@ import { openSubagentSessionOverlay } from "./session-ui.ts";
 import { getFinalOutput, spawnInteractiveSubagent } from "./spawn.ts";
 import { deadlockMessage, MessageWaitGraph } from "./wait-graph.ts";
 import { ActiveRunRegistry, type ActiveRun } from "./active-runs.ts";
+import { CypherStatusPublisher } from "./cypher-status.ts";
 import {
 	boundTaskText,
 	isTerminalTaskStatus,
@@ -668,6 +669,9 @@ export function createAgentSquadExtension(
 	let poolDisposed = false;
 	const activeRuns = new ActiveRunRegistry();
 	const runningWidget = new RunningSubagentWidgetController();
+	// The same live runs as the TUI widget, published as the structured
+	// `cypher.subagents.v1` projection when Pi runs under Cypher (RPC mode).
+	const cypherStatus = new CypherStatusPublisher();
 	const sessionHandles = new Map<string, SubagentSessionHandle>();
 	const waitGraph = new MessageWaitGraph();
 	const pendingMainReplyEdges = new Map<
@@ -890,6 +894,7 @@ export function createAgentSquadExtension(
 		pool.setIntercomRoot(messageRoot);
 		pool.setWorkingDirectory(cwd);
 		runningWidget.attach(ctx);
+		cypherStatus.attach(ctx);
 		sessionContext = ctx.mode === "tui" ? ctx : undefined;
 		reconcileCurrentBranch();
 		acceptingTasks = true;
@@ -980,6 +985,7 @@ export function createAgentSquadExtension(
 		activeRuns.clear();
 		tasks.clear();
 		runningWidget.shutdown();
+		cypherStatus.shutdown();
 		currentSessionToken = undefined;
 		runtimeContext = undefined;
 		sweepMessageRoots(MESSAGE_ROOT_BASE);
@@ -1180,6 +1186,14 @@ export function createAgentSquadExtension(
 				}
 				const activityId = `message:${msg.id}`;
 				runningWidget.start(activityId, resolvedTargetRun.address, msg.content, "message");
+				// Subagent-to-subagent traffic has no parent tool call; Cypher
+				// renders it as its own `message` row.
+				cypherStatus.start({
+					runId: activityId,
+					agent: resolvedTargetRun.address,
+					task: msg.content,
+					mode: "message",
+				});
 				try {
 					if (resolvedTargetRun.session) {
 						const session = await resolvedTargetRun.session;
@@ -1192,6 +1206,7 @@ export function createAgentSquadExtension(
 					return replyText;
 				} catch (e) {
 					const reply = `Target subagent ${resolvedTargetRun.address} failed to process the message: ${e instanceof Error ? e.message : String(e)}`;
+					cypherStatus.settleIfLive(activityId, "error", e instanceof Error ? e.message : String(e));
 					completeRoutedMessage(msg, reply, routeRoot);
 					if (msg.from === MAIN_AGENT) throw new Error(reply);
 					return reply;
@@ -1200,6 +1215,7 @@ export function createAgentSquadExtension(
 					if (pendingOpenActivityId === activityId) pendingOpenActivityId = undefined;
 					sessionHandles.delete(activityId);
 					runningWidget.finish(activityId);
+					cypherStatus.settleIfLive(activityId, "done");
 				}
 			},
 			onMessageReplied: (msg: MessageRequest) => releaseMainReplyEdge(msg.id),
@@ -1329,6 +1345,7 @@ export function createAgentSquadExtension(
 		requestedAddress?: string,
 		readOnly = agent.readOnly === true,
 		retryOf?: string,
+		toolCallId?: string,
 	): { runId: string; address: string } {
 		if (!acceptingTasks) throw new Error("This Pi session is shutting down and cannot accept new subagent tasks.");
 		validateLaunchText("agent", agent.name);
@@ -1396,6 +1413,17 @@ export function createAgentSquadExtension(
 			sessionGeneration,
 		});
 		runningWidget.start(runId, agent.name, taskText, "background");
+		// Async: the tool call returns a launch ack immediately, so the snapshot
+		// is the ONLY thing that keeps Cypher's row alive until the child ends.
+		cypherStatus.start({
+			runId,
+			toolCallId,
+			agent: agent.name,
+			task: taskText,
+			mode: "async",
+			model: agent.model,
+			startedAt,
+		});
 
 		const start = async () => {
 			return await dependencies.spawnInteractiveSubagent({
@@ -1409,6 +1437,7 @@ export function createAgentSquadExtension(
 				signal: controller.signal,
 				timeoutMs: effectiveTimeoutMs,
 				persistSession: true,
+				onEvent: (event) => cypherStatus.observeChildEvent(runId, event),
 				onStarted: (childSessionFile) => {
 					const now = Date.now();
 					const running = transitionTask(
@@ -1462,6 +1491,12 @@ export function createAgentSquadExtension(
 							? "cancelled"
 							: "failed";
 				const now = Date.now();
+				if (result.model) cypherStatus.update(runId, { model: result.model });
+				cypherStatus.settleIfLive(
+					runId,
+					finalStatus === "completed" ? "done" : "error",
+					finalStatus === "completed" ? undefined : failureReason || finalStatus,
+				);
 				try {
 					if (finalStatus === "completed") {
 						const completed = transitionTask(
@@ -1527,6 +1562,7 @@ export function createAgentSquadExtension(
 				direct.rejectSession(err instanceof Error ? err : new Error(String(err)));
 				const task = tasks.get(runId);
 				const errorText = err instanceof Error ? err.message : String(err);
+				cypherStatus.settleIfLive(runId, "error", errorText);
 				const current = persistedTasks.get(runId);
 				if (!current || isTerminalTaskStatus(current.status)) return;
 				const cancelled =
@@ -1577,6 +1613,9 @@ export function createAgentSquadExtension(
 				if (pendingOpenActivityId === runId) pendingOpenActivityId = undefined;
 				sessionHandles.delete(runId);
 				runningWidget.finish(runId);
+				// Belt and braces: an early return above (a stale session
+				// generation) must never leave a runner published forever.
+				cypherStatus.settleIfLive(runId, "done");
 			});
 
 		return { runId, address };
@@ -1633,7 +1672,7 @@ export function createAgentSquadExtension(
 			),
 		}),
 
-		async execute(_toolCallId, params, signal, onUpdate, ctx) {
+		async execute(toolCallId, params, signal, onUpdate, ctx) {
 			if (!acceptingTasks) {
 				return {
 					content: [{ type: "text", text: "This Pi session is shutting down and cannot accept new subagent tasks." }],
@@ -1658,7 +1697,16 @@ export function createAgentSquadExtension(
 			if (params.async) {
 				try {
 					const readOnly = params.readonly ?? agent.readOnly === true;
-					const launched = launchBackground(agent, params.task, params.cwd, timeoutMs, params.as, readOnly);
+					const launched = launchBackground(
+						agent,
+						params.task,
+						params.cwd,
+						timeoutMs,
+						params.as,
+						readOnly,
+						undefined,
+						toolCallId,
+					);
 					const { runId, address } = launched;
 					return {
 						content: [
@@ -1712,6 +1760,14 @@ export function createAgentSquadExtension(
 				};
 			}
 			runningWidget.start(runId, agent.name, params.task, "task");
+			cypherStatus.start({
+				runId,
+				toolCallId,
+				agent: agent.name,
+				task: params.task,
+				mode: "sync",
+				model: agent.model,
+			});
 			let result: Awaited<ReturnType<typeof spawnInteractiveSubagent>>;
 			try {
 				result = await dependencies.spawnInteractiveSubagent({
@@ -1724,6 +1780,7 @@ export function createAgentSquadExtension(
 					childIndex: 0,
 					signal: runController.signal,
 					timeoutMs,
+					onEvent: (event) => cypherStatus.observeChildEvent(runId, event),
 					onSession: (session) => {
 						direct.resolveSession(session);
 						registerSessionHandle(runId, session);
@@ -1731,6 +1788,11 @@ export function createAgentSquadExtension(
 				});
 			} catch (error) {
 				direct.rejectSession(error instanceof Error ? error : new Error(String(error)));
+				cypherStatus.settleIfLive(
+					runId,
+					"error",
+					error instanceof Error ? error.message : String(error),
+				);
 				throw error;
 			} finally {
 				signal?.removeEventListener("abort", forwardAbort);
@@ -1742,6 +1804,17 @@ export function createAgentSquadExtension(
 				runningWidget.finish(runId);
 			}
 			const output = getFinalOutput(result.messages);
+			// Terminal truth for the panel: the tool result Cypher folds into the
+			// transcript settles the row too, but only the snapshot carries the
+			// model, the reason and the end time.
+			if (result.model) cypherStatus.update(runId, { model: result.model });
+			const failure =
+				result.exitCode !== 0
+					? `exit ${result.exitCode}: ${result.stderr || result.errorMessage || "unknown error"}`
+					: result.stopReason === "error"
+						? result.errorMessage || "subagent reported an error"
+						: "";
+			cypherStatus.settleIfLive(runId, failure ? "error" : "done", failure || undefined);
 
 			if (result.exitCode !== 0) {
 				return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-agent-squad",
-  "version": "0.8.5",
+  "version": "0.9.0",
   "description": "Interactive multi-agent orchestration, messaging, and live sessions for the Pi Coding Agent",
   "type": "module",
   "keywords": [