@yusukeshib/pi-babysit 0.3.8 → 0.3.11

package/README.md

@@ -40,6 +40,13 @@ The **profile is a tool parameter, not a separate tool set**: domain knowledge
 message delivery, spawn validation) lives in code, while the LLM sees one small
 generic surface.
 
+Subagent recursion is **disabled by default**: a top-level pi may create workers
+(depth 1), but those workers cannot create more workers. A top-level caller can
+explicitly opt in for a specific tree with `maxDepth: 2` (or higher) when it
+creates the first worker. Descendants inherit that ceiling and cannot raise it.
+Normal `babysit_run { command }` process execution remains available at every
+depth.
+
 Because sessions are real PTYs, the agent can also **drive interactive
 programs** (installers, wizards, REPLs): type with `babysit_send`
 (text or named keys) and read the rendered screen with
@@ -49,7 +56,7 @@ programs** (installers, wizards, REPLs): type with `babysit_send`
 
 | Tool | What it does |
 | ---- | ------------ |
-| `babysit_run` | Run any command (`command`, optional `name`/`pty`/`timeout`/`idleTimeout`/`retryOnWorkerDeath`) or start a subagent (`profile: "subagent"`, `task`, optional `agent`/`model`/`tools`). Quick commands return inline; longer ones continue in the background |
+| `babysit_run` | Run any command (`command`, optional `name`/`pty`/`timeout`/`idleTimeout`/`retryOnWorkerDeath`) or start a subagent (`profile: "subagent"`, `task`, optional `agent`/`model`/`tools`/`maxDepth`). `maxDepth` defaults to 1 and can only be set by the top-level caller. Quick commands return inline; longer ones continue in the background |
 | `babysit_check` | List all sessions, inspect one, tail its bounded recent output, or search its raw log with `pattern`; `screen: true` captures TUIs and subagents otherwise show structured live progress |
 | `babysit_send` | Process: type `text` / press `keys` into the PTY. Subagent: steer mid-run, or send a follow-up task when idle (`mode: auto/steer/task`) |
 | `babysit_wait` | Block until done: process exit (or `expect: "regex"` readiness marker), subagent task completion. Multi-wait: `ids` + `mode: "any"\|"all"` |
@@ -88,6 +95,14 @@ Tail and search results are capped at 200 lines and clipped to 8 KB. Pattern
 search returns the latest matching lines with line numbers. Do not read a
 potentially large log file in full.
 
+Subagent logs also compact Pi's streaming `message_update` events before they
+are recorded. Pi repeats the complete growing assistant message and partial
+snapshot on every token; pi-babysit retains only the incremental delta while
+leaving authoritative `message_end`, tool, lifecycle, response, and error
+events untouched. This keeps long RPC sessions approximately linear in emitted
+content without changing final answers, completion detection, or follow-up
+behavior. Live `/babysit` and attach views render the retained deltas.
+
 All shell commands, including `pwd` and Git, are redirected to `babysit_run`.
 Set `PI_BABYSIT_ALLOW_BASH=1` only as an explicit emergency escape hatch.
 

package/format-stream.mjs

@@ -1,12 +1,11 @@
 #!/usr/bin/env node
 /**
- * format-stream.mjs — human-readable view for a `pi --mode json` event stream.
+ * format-stream.mjs — human-readable view for a `pi --mode rpc` event stream.
  *
- * babysit records the raw JSONL to its log (machine scrapers + `babysit log`
- * stay untouched); this filter only sits on the interactive attach path via
- * `babysit run --view-cmd`. It reads the JSONL on stdin and prints a colored,
- * incrementally-streamed transcript on stdout so a human attaching the tmux
- * pane sees turns, thinking, tool calls and answers instead of a JSON firehose.
+ * This filter sits on the interactive attach path via `babysit run --view-cmd`.
+ * It accepts both Pi's raw cumulative updates and pi-babysit's compact deltas,
+ * then prints a colored, incrementally streamed transcript so a human sees
+ * turns, thinking, tool calls and answers instead of a JSON firehose.
  */
 import * as readline from "node:readline";
 
@@ -52,8 +51,8 @@ function summarizeTool(name, a = {}) {
 }
 
 // Join the text of a given block kind ("text" or "thinking") in a message's
-// content array. message_update re-emits the whole (growing) message, so we
-// compare lengths against what we've already printed to append only the delta.
+// content array. Unfiltered RPC streams repeat the whole growing message;
+// pi-babysit's compact stream instead retains only assistantMessageEvent.delta.
 function blockText(content, kind) {
 	if (!Array.isArray(content)) return "";
 	let s = "";
@@ -75,15 +74,20 @@ const openBlock = () => {
 	out("\n");
 };
 
-function streamMessage(msg, fresh = false) {
-	if (!msg || msg.role !== "assistant") return;
-	const id = msg.id ?? `t${turn}`;
+function messageState(id = `t${turn}`, fresh = false) {
 	if (fresh) emitted.delete(id);
 	let st = emitted.get(id);
 	if (!st) {
 		st = { think: 0, text: 0, hThink: false, hText: false };
 		emitted.set(id, st);
 	}
+	return st;
+}
+
+function streamMessage(msg, fresh = false) {
+	if (!msg || msg.role !== "assistant") return;
+	const id = msg.id ?? `t${turn}`;
+	const st = messageState(id, fresh);
 	const think = blockText(msg.content, "thinking");
 	if (think.length > st.think) {
 		if (!st.hThink) {
@@ -106,6 +110,28 @@ function streamMessage(msg, fresh = false) {
 	}
 }
 
+function streamDelta(event) {
+	if (!event || typeof event.delta !== "string" || !event.delta) return;
+	const st = messageState();
+	if (event.type === "thinking_delta") {
+		if (!st.hThink) {
+			openBlock();
+			out(`${C.gray}[think] `);
+			st.hThink = true;
+		}
+		out(C.gray + event.delta + C.reset);
+		st.think += event.delta.length;
+	} else if (event.type === "text_delta") {
+		if (!st.hText) {
+			openBlock();
+			out(`${C.green}[text]${C.reset} `);
+			st.hText = true;
+		}
+		out(event.delta);
+		st.text += event.delta.length;
+	}
+}
+
 function usageLine(msg) {
 	const u = msg?.usage;
 	if (!u) return;
@@ -138,7 +164,8 @@ rl.on("line", (line) => {
 			streamMessage(ev.message, true);
 			break;
 		case "message_update":
-			streamMessage(ev.message);
+			if (ev.message) streamMessage(ev.message);
+			else streamDelta(ev.assistantMessageEvent);
 			break;
 		case "message_end":
 			streamMessage(ev.message);

package/index.ts

@@ -38,7 +38,7 @@ import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
 import { getMarkdownTheme } from "@earendil-works/pi-coding-agent";
-import { Box, Container, Markdown, Text } from "@earendil-works/pi-tui";
+import { Box, Markdown, Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import { StringEnum } from "@earendil-works/pi-ai";
 import { type AgentConfig, type AgentScope, discoverAgents } from "./agents";
@@ -52,16 +52,88 @@ let ROOT = ROOT_BASE;
 const PI_BIN = process.env.PI_BABYSIT_BIN ?? "pi";
 const BABYSIT_BIN = process.env.PI_BABYSIT_CLI ?? "babysit";
 const SHELL = process.env.SHELL ?? "sh";
+const SUBAGENT_DEPTH_ENV = "PI_BABYSIT_INTERNAL_SUBAGENT_DEPTH";
+const SUBAGENT_MAX_DEPTH_ENV = "PI_BABYSIT_INTERNAL_SUBAGENT_MAX_DEPTH";
+const DEFAULT_SUBAGENT_MAX_DEPTH = 1;
+
+export type SubagentSpawnPlan =
+	| { allowed: true; childDepth: number; maxDepth: number }
+	| { allowed: false; error: string };
+
+/**
+ * Plan a subagent spawn without letting an already-spawned worker raise its
+ * inherited recursion allowance. Depth 0 is the user-facing pi process; the
+ * first worker is depth 1 and is allowed by default, but that worker cannot
+ * create depth 2 unless its top-level parent explicitly opted in.
+ */
+export function planSubagentSpawn(
+	requestedMaxDepth?: number,
+	env: Record<string, string | undefined> = process.env,
+): SubagentSpawnPlan {
+	if (
+		requestedMaxDepth !== undefined &&
+		(!Number.isInteger(requestedMaxDepth) || requestedMaxDepth < 1)
+	) {
+		return { allowed: false, error: "`maxDepth` must be a positive integer." };
+	}
+
+	const rawDepth = env[SUBAGENT_DEPTH_ENV];
+	let currentDepth = 0;
+	if (rawDepth !== undefined) {
+		currentDepth = Number(rawDepth);
+		if (!Number.isInteger(currentDepth) || currentDepth < 0) {
+			return {
+				allowed: false,
+				error: `Invalid inherited subagent depth ${JSON.stringify(rawDepth)}; refusing to spawn recursively.`,
+			};
+		}
+	}
+
+	const nested = currentDepth > 0;
+	if (nested && requestedMaxDepth !== undefined) {
+		return {
+			allowed: false,
+			error:
+				`Nested subagents cannot override \`maxDepth\` (current depth ${currentDepth}). ` +
+				"Only the top-level parent may opt in when it creates the first subagent.",
+		};
+	}
+
+	let maxDepth = requestedMaxDepth ?? DEFAULT_SUBAGENT_MAX_DEPTH;
+	if (nested) {
+		const rawMaxDepth = env[SUBAGENT_MAX_DEPTH_ENV];
+		// Missing/corrupt inherited state fails closed at the current depth.
+		maxDepth = rawMaxDepth === undefined ? currentDepth : Number(rawMaxDepth);
+		if (!Number.isInteger(maxDepth) || maxDepth < currentDepth) {
+			return {
+				allowed: false,
+				error: `Invalid inherited max subagent depth ${JSON.stringify(rawMaxDepth)}; refusing to spawn recursively.`,
+			};
+		}
+	}
+
+	const childDepth = currentDepth + 1;
+	if (childDepth > maxDepth) {
+		return {
+			allowed: false,
+			error:
+				`Nested subagent creation is disabled at depth ${currentDepth}: spawning would reach depth ${childDepth}, ` +
+				`but the inherited maxDepth is ${maxDepth}. Have the top-level parent explicitly opt in with ` +
+				`babysit_run { profile: "subagent", task, maxDepth: ${childDepth} } when creating the first worker.`,
+		};
+	}
+	return { allowed: true, childDepth, maxDepth };
+}
 
 // Marker embedded in babysit_run's tool RESULT text for kind=process runs.
 // It is how "the turn parked awaiting a process-exit notification" is told
 // apart from any other turn end (see isParkedToolResult / self-reap.ts).
 export const NOTIFY_MARKER = "[notify-on-exit]";
 
-// Human-readable view for the subagent JSONL stream when a human attaches.
-// babysit records the raw JSON to its log (parsers unaffected) and pipes only
-// the live attach view through this formatter. Set PI_BABYSIT_VIEW_CMD="" to
-// disable (raw JSON), or to a custom command to override.
+// Human-readable view for the compact subagent JSONL stream when a human
+// attaches. The RPC proxy removes cumulative streaming snapshots before both
+// recording and display; authoritative events remain intact for parsers. Set
+// PI_BABYSIT_VIEW_CMD="" to disable formatting, or provide a custom command.
 const EXT_DIR = path.dirname(fileURLToPath(import.meta.url));
 const shq = (s: string) => `'${s.replace(/'/g, `'\\''`)}'`;
 const VIEW_CMD =
@@ -116,7 +188,11 @@ function normalizeSession(s: BsSession): BsSession {
 // long wait be interrupted (Ctrl-C) by killing the child.
 function bs(
 	args: string[],
-	opts: { cwd?: string; signal?: AbortSignal } = {},
+	opts: {
+		cwd?: string;
+		signal?: AbortSignal;
+		env?: Record<string, string | undefined>;
+	} = {},
 ): Promise<{ stdout: string; stderr: string; code: number }> {
 	return new Promise((resolve) => {
 		if (opts.signal?.aborted) {
@@ -125,7 +201,7 @@ function bs(
 		}
 		const child = spawn(BABYSIT_BIN, args, {
 			cwd: opts.cwd,
-			env: { ...process.env, BABYSIT_DIR: ROOT },
+			env: { ...process.env, ...opts.env, BABYSIT_DIR: ROOT },
 		});
 		let stdout = "";
 		let stderr = "";
@@ -295,6 +371,8 @@ interface Meta {
 	task?: string;
 	promptOffset?: number;
 	model?: string;
+	depth?: number;
+	maxDepth?: number;
 }
 
 const metaDir = () => path.join(ROOT, "meta");
@@ -556,7 +634,10 @@ export function summarizeNotificationCommand(command: string | undefined): strin
 			.trim()
 			.replace(/\r/g, "\\r")
 			.replace(/\n/g, "\\n")
-			.replace(/\t/g, "\\t") || "?";
+			.replace(/\t/g, "\\t")
+			.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x9F]/g, (char) =>
+				`\\x${char.charCodeAt(0).toString(16).toUpperCase().padStart(2, "0")}`,
+			) || "?";
 	const bytes = Buffer.from(preview, "utf8");
 	if (bytes.length <= NOTIFY_COMMAND_MAX_BYTES) return preview;
 	if (NOTIFY_COMMAND_MAX_BYTES === 0) return "";
@@ -596,6 +677,7 @@ interface ProcessCompletionMessage {
 		status: CompletionStatus;
 		runtime?: string;
 		logPath?: string;
+		command?: string;
 		count: number;
 		totalCount: number;
 		remainingCount: number;
@@ -605,6 +687,7 @@ interface ProcessCompletionMessage {
 			success: boolean;
 			status: CompletionStatus;
 			runtime: string;
+			command: string | undefined;
 			logPath: string;
 		}>;
 	};
@@ -713,6 +796,7 @@ export function buildProcessCompletionMessage(
 		success: notice.success,
 		status: notice.status,
 		runtime: notice.runtime,
+		command: notice.command,
 		logPath: notice.logPath,
 	}));
 	const single = totalCount === 1 ? batch[0] : undefined;
@@ -727,6 +811,7 @@ export function buildProcessCompletionMessage(
 			status,
 			runtime: single?.runtime,
 			logPath: single?.logPath,
+			command: single?.command,
 			count: batch.length,
 			totalCount,
 			remainingCount: totalCount - batch.length,
@@ -793,7 +878,7 @@ interface ToolCall {
 	name: string;
 	summary: string;
 }
-interface Progress {
+export interface Progress {
 	turns: number;
 	toolCalls: ToolCall[];
 	finalText: string;
@@ -836,7 +921,7 @@ function summarizeToolCall(name: string, args: Record<string, unknown>): string
 	}
 }
 
-function parseEvents(logText: string): Progress {
+export function parseEvents(logText: string): Progress {
 	const p: Progress = {
 		turns: 0,
 		toolCalls: [],
@@ -1003,6 +1088,8 @@ interface SubagentOpts {
 	model?: string;
 	tools?: string[];
 	cwd: string;
+	depth: number;
+	maxDepth: number;
 	// Idle-timeout is OFF by default: an RPC-mode pi is silent while it works,
 	// so idle detection would false-kill a busy subagent. The absolute timeout
 	// is the safety valve instead.
@@ -1042,15 +1129,29 @@ async function spawnSubagent(
 		"--timeout",
 		opts.timeout,
 	];
-	// Pretty-print the JSONL stream for humans who `attach`; the recorded log
-	// stays raw so parseEvents/`babysit log` are unaffected.
+	// Pretty-print the compact JSONL stream for humans who `attach`. The RPC
+	// proxy removes only cumulative streaming snapshots; authoritative final,
+	// tool, lifecycle, response, and error events remain intact for parseEvents.
 	if (VIEW_CMD.trim()) bsArgs.push("--view-cmd", VIEW_CMD);
 	if (opts.idleTimeout && opts.idleTimeout !== "none") {
 		bsArgs.push("--idle-timeout", opts.idleTimeout);
 	}
-	bsArgs.push("--", PI_BIN, ...piArgs);
+	bsArgs.push(
+		"--",
+		process.execPath,
+		path.join(EXT_DIR, "rpc-stream-proxy.mjs"),
+		"--",
+		PI_BIN,
+		...piArgs,
+	);
 
-	const r = await bs(bsArgs, { cwd: opts.cwd });
+	const r = await bs(bsArgs, {
+		cwd: opts.cwd,
+		env: {
+			[SUBAGENT_DEPTH_ENV]: String(opts.depth),
+			[SUBAGENT_MAX_DEPTH_ENV]: String(opts.maxDepth),
+		},
+	});
 	if (r.code !== 0) {
 		return { error: r.stderr || r.stdout || `babysit run failed (exit ${r.code}, no output) — check that \`${BABYSIT_BIN}\` works and ${ROOT} is writable` };
 	}
@@ -1065,7 +1166,13 @@ async function spawnSubagent(
 	// below fails and we kill the session, the exit poller does NOT mistake it
 	// for an un-notified process and fire a spurious process-end notification.
 	// The success path overwrites this with the full task meta.
-	writeMeta(id, { kind: "subagent", task: opts.task, notified: true });
+	writeMeta(id, {
+		kind: "subagent",
+		task: opts.task,
+		notified: true,
+		depth: opts.depth,
+		maxDepth: opts.maxDepth,
+	});
 
 	// Wait for pi to boot (first JSON event in the log), then inject the task.
 	await bs(["expect", "-s", id, "--timeout", "30s", '\\{"type"']);
@@ -1107,6 +1214,8 @@ async function spawnSubagent(
 		task: opts.task,
 		promptOffset: sent.offset,
 		model: resolvedModel,
+		depth: opts.depth,
+		maxDepth: opts.maxDepth,
 		startedAt: Date.now(),
 	});
 	return { id, model: resolvedModel };
@@ -1644,11 +1753,20 @@ export default function (pi: ExtensionAPI) {
 			status?: DisplayStatus;
 			success?: boolean;
 			exitCode?: number | null;
+			command?: string;
+			count?: number;
 		};
 		const status =
 			d.status ?? (d.success ? "success" : d.exitCode == null ? "terminated" : "failed");
+		const payload = d.command
+			? `  ${summarizeNotificationCommand(d.command)}`
+			: d.count && d.count > 1
+				? `  ×${d.count}`
+				: "";
+		const header = theme.fg("warning", theme.bold(`babysit_run COMMAND${payload}`));
 		const box = new Box(1, 1, (t) => theme.bg("toolSuccessBg", t));
-		box.addChild(new Text(renderStatus(status, theme, "babysit_run"), 0, 0));
+		box.addChild(new Text(header, 0, 0));
+		box.addChild(new Text(renderStatus(status, theme), 0, 0));
 		box.addChild(new Text(theme.fg("toolOutput", content), 0, 0));
 		return box;
 	});
@@ -1726,7 +1844,8 @@ export default function (pi: ExtensionAPI) {
 			"`retryOnWorkerDeath` can retry one idempotent command once. " +
 			"(2) `profile: \"subagent\"` + `task` — spawn a pi subagent that works on the task in the " +
 			"background; poll with babysit_check, steer with babysit_send, block with babysit_wait, " +
-			"stop with babysit_kill.",
+			"stop with babysit_kill. Subagents cannot recursively spawn more subagents by default; " +
+			"the top-level caller must explicitly raise `maxDepth` when creating the first worker.",
 		promptSnippet:
 			"Run any shell command with context-safe captured output; quick commands return metadata, longer ones continue in background",
 		promptGuidelines: [
@@ -1736,6 +1855,7 @@ export default function (pi: ExtensionAPI) {
 			"If a babysit worker is killed externally, babysit_run reports it as worker-dead rather than hanging. Set retryOnWorkerDeath: true only for safe, idempotent commands; it retries at most once and may otherwise duplicate side effects.",
 			"babysit_run gives full PTY control: drive interactive programs (installers, wizards, REPLs) with babysit_send (text or named keys) and read the rendered screen with babysit_check { screen: true }.",
 			"Delegate self-contained tasks (codebase recon, a parallelizable subtask, work that would pollute your context) with babysit_run { profile: \"subagent\", task }. Launch several for independent subtasks; they run concurrently.",
+			"Subagents cannot create further subagents by default (maximum depth 1). Only the top-level caller can explicitly opt in by setting maxDepth when it creates the first worker; nested workers inherit that limit and cannot raise it.",
 			"After spawning subagents, do not idle-wait and do not end your turn to wait for them: keep making progress, then call babysit_wait (ids + mode any/all) when you need their results. Steer or send follow-up tasks with babysit_send; kill runaways with babysit_kill.",
 		],
 		parameters: Type.Object({
@@ -1764,6 +1884,13 @@ export default function (pi: ExtensionAPI) {
 			tools: Type.Optional(
 				Type.Array(Type.String(), { description: "Tool allowlist for the subagent." }),
 			),
+			maxDepth: Type.Optional(
+				Type.Integer({
+					minimum: 1,
+					description:
+						"Maximum subagent nesting depth. Top-level subagent mode only; default 1 prevents workers from spawning workers. Nested workers inherit this limit and cannot override it.",
+				}),
+			),
 			agentScope: Type.Optional(
 				StringEnum(["user", "project", "both"] as const, {
 					description: "Where to discover named agents. Default 'user'.",
@@ -1826,6 +1953,19 @@ export default function (pi: ExtensionAPI) {
 				};
 			}
 
+			// Compute nesting only for subagent mode. Ordinary command processes remain
+			// available even when the hosting agent is at its subagent depth limit.
+			const nesting = isSubagent
+				? planSubagentSpawn(params.maxDepth)
+				: undefined;
+			if (nesting && !nesting.allowed) {
+				return {
+					content: [{ type: "text", text: nesting.error }],
+					isError: true,
+					details: {},
+				};
+			}
+
 			// --- process mode ---
 			if (!isSubagent) {
 				const spawnOpts: ProcOpts = {
@@ -1966,12 +2106,16 @@ export default function (pi: ExtensionAPI) {
 				}
 			}
 
+			// The branch above guarantees a successful plan in subagent mode.
+			const subagentNesting = nesting as Extract<SubagentSpawnPlan, { allowed: true }>;
 			const res = await spawnSubagent({
 				agent,
 				task: params.task as string,
 				model: params.model,
 				tools: params.tools,
 				cwd: ctx.cwd,
+				depth: subagentNesting.childDepth,
+				maxDepth: subagentNesting.maxDepth,
 				timeout: params.timeout ?? "15m",
 				idleTimeout: params.idleTimeout,
 			});
@@ -1990,7 +2134,7 @@ export default function (pi: ExtensionAPI) {
 					{
 						type: "text",
 						text:
-							`Subagent started (id: ${res.id})${agent ? ` [agent: ${agent.name}]` : ""}${res.model ? ` [model: ${res.model}]` : ""}.\n` +
+							`Subagent started (id: ${res.id})${agent ? ` [agent: ${agent.name}]` : ""}${res.model ? ` [model: ${res.model}]` : ""} [depth: ${subagentNesting.childDepth}/${subagentNesting.maxDepth}].\n` +
 							`Task accepted — running in the background; keep working (do NOT end your turn just to wait for it).\n` +
 							`Poll:  babysit_check { id: "${res.id}" }\n` +
 							`Wait:  babysit_wait  { id: "${res.id}" }\n` +
@@ -2003,14 +2147,25 @@ export default function (pi: ExtensionAPI) {
 					agent: agent?.name,
 					model: res.model,
 					task: params.task,
+					depth: subagentNesting.childDepth,
+					maxDepth: subagentNesting.maxDepth,
 					status: "started" satisfies DisplayStatus,
 				},
 			};
 		},
-		// The result label already includes "babysit_run"; suppress the default
-		// call header so the tool name is not shown twice in adjacent lines.
-		renderCall() {
-			return new Container();
+		// Make the execution kind and payload identifiable before the result arrives.
+		// Use semantic theme colors rather than the fallback gray tool-call text.
+		renderCall(args, theme) {
+			const isSubagent = args.profile === "subagent";
+			const kind = isSubagent ? "AGENT" : "COMMAND";
+			const payload = isSubagent ? args.task : args.command;
+			const agent = isSubagent && args.agent ? ` [${args.agent}]` : "";
+			const title = theme.bold(`babysit_run ${kind}`);
+			const detail =
+				typeof payload === "string" && payload.length > 0
+					? `  ${summarizeNotificationCommand(payload)}`
+					: "";
+			return new Text(theme.fg("warning", `${title}${agent}${detail}`), 0, 0);
 		},
 		renderResult(result, { isPartial }, theme, context) {
 			const details = (result.details ?? {}) as {
@@ -2038,7 +2193,7 @@ export default function (pi: ExtensionAPI) {
 							: details.kind === "subagent" || content.includes(NOTIFY_MARKER)
 								? "started"
 								: "success");
-			const label = renderStatus(status, theme, "babysit_run");
+			const label = renderStatus(status, theme);
 			return new Text(content ? `${label}\n${theme.fg("toolOutput", content)}` : label, 0, 0);
 		},
 	});
@@ -2094,9 +2249,13 @@ export default function (pi: ExtensionAPI) {
 					const kind = meta?.kind ?? "process";
 					const flag = s.note ? ` ⚑ ${s.note}` : "";
 					const ec = s.exit_code != null ? ` exit=${s.exit_code}` : "";
+					const depth =
+						kind === "subagent" && meta?.depth != null
+							? ` depth=${meta.depth}/${meta.maxDepth ?? "?"}`
+							: "";
 					const what = (kind === "subagent" ? meta?.task : meta?.command) ?? "";
 					const preview = what.length > 60 ? `${what.slice(0, 57)}…` : what;
-					return `${s.id}  [${kind}] ${s.state}${ec}${flag}${preview ? `  — ${preview}` : ""}`;
+					return `${s.id}  [${kind}] ${s.state}${ec}${depth}${flag}${preview ? `  — ${preview}` : ""}`;
 				});
 				return { content: [{ type: "text", text: lines.join("\n") }], details: { sessions } };
 			}
@@ -2182,6 +2341,7 @@ export default function (pi: ExtensionAPI) {
 
 			const parts: string[] = [];
 			let header = `[subagent] state=${st.state}`;
+			if (meta.depth != null) header += ` depth=${meta.depth}/${meta.maxDepth ?? "?"}`;
 			if (st.state === "running") {
 				const el = elapsedOf(params.id);
 				if (el) header += ` elapsed=${el}`;
@@ -2362,6 +2522,8 @@ export default function (pi: ExtensionAPI) {
 					task: params.text,
 					promptOffset: sent.offset,
 					model: meta?.model,
+					depth: meta?.depth,
+					maxDepth: meta?.maxDepth,
 				});
 			}
 			return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yusukeshib/pi-babysit",
-  "version": "0.3.8",
+  "version": "0.3.11",
   "description": "Run any shell command and pi subagents under babysit, with context-safe captured output.",
   "keywords": [
     "pi-package",
@@ -23,6 +23,7 @@
     "agents.ts",
     "self-reap.ts",
     "format-stream.mjs",
+    "rpc-stream-proxy.mjs",
     "search-log.mjs",
     "README.md",
     "LICENSE"

package/rpc-stream-proxy.mjs

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+/**
+ * Transparent stdin/stdout proxy for `pi --mode rpc`.
+ *
+ * Pi's `message_update` events repeat the entire growing assistant message and
+ * `assistantMessageEvent.partial` on every token. Those cumulative snapshots
+ * are useful only while streaming; `message_end` is the authoritative final
+ * message. Persisting every snapshot makes babysit logs grow quadratically.
+ *
+ * This proxy forwards stdin byte-for-byte and compacts only `message_update`
+ * lines on stdout. All final, tool, lifecycle, response, and error events pass
+ * through byte-for-byte.
+ */
+import { spawn } from "node:child_process";
+import { StringDecoder } from "node:string_decoder";
+import { pathToFileURL } from "node:url";
+
+export function compactRpcLine(line) {
+	if (!line.trimStart().startsWith("{")) return line;
+
+	let event;
+	try {
+		event = JSON.parse(line);
+	} catch {
+		return line;
+	}
+	if (event?.type !== "message_update") return line;
+
+	const { message: _cumulativeMessage, assistantMessageEvent, ...rest } = event;
+	if (!assistantMessageEvent || typeof assistantMessageEvent !== "object") {
+		return JSON.stringify(rest);
+	}
+	const { partial: _cumulativePartial, ...deltaEvent } = assistantMessageEvent;
+	return JSON.stringify({ ...rest, assistantMessageEvent: deltaEvent });
+}
+
+function transformRpcOutput(input, output) {
+	return new Promise((resolve, reject) => {
+		const decoder = new StringDecoder("utf8");
+		let buffered = "";
+
+		const write = (value) => {
+			if (!output.write(value)) input.pause();
+		};
+		output.on("drain", () => input.resume());
+		input.on("error", reject);
+		input.on("data", (chunk) => {
+			buffered += decoder.write(chunk);
+			for (;;) {
+				const newline = buffered.indexOf("\n");
+				if (newline < 0) break;
+				const line = buffered.slice(0, newline);
+				buffered = buffered.slice(newline + 1);
+				write(`${compactRpcLine(line)}\n`);
+			}
+		});
+		input.on("end", () => {
+			buffered += decoder.end();
+			if (buffered) write(compactRpcLine(buffered));
+			if (output.writableNeedDrain) output.once("drain", resolve);
+			else resolve();
+		});
+	});
+}
+
+function waitForDrain(stream) {
+	return stream.writableNeedDrain
+		? new Promise((resolve) => stream.once("drain", resolve))
+		: Promise.resolve();
+}
+
+export function runRpcProxy(argv = process.argv.slice(2)) {
+	const separator = argv.indexOf("--");
+	const command = separator >= 0 ? argv[separator + 1] : argv[0];
+	const args = separator >= 0 ? argv.slice(separator + 2) : argv.slice(1);
+	if (!command) {
+		console.error("Usage: rpc-stream-proxy.mjs -- <command> [args...]");
+		process.exitCode = 2;
+		return;
+	}
+
+	const child = spawn(command, args, {
+		cwd: process.cwd(),
+		env: process.env,
+		stdio: ["pipe", "pipe", "pipe"],
+	});
+
+	let transportFailed = false;
+	process.stdin.pipe(child.stdin);
+	// The RPC worker can exit or self-reap while a command is still arriving.
+	// Ignore the resulting pipe-close race so the proxy preserves the worker's
+	// actual exit code/signal instead of crashing with an unhandled EPIPE.
+	child.stdin.on("error", (error) => {
+		if (error?.code === "EPIPE" || error?.code === "ERR_STREAM_DESTROYED") return;
+		transportFailed = true;
+		console.error(`rpc stream proxy stdin failed: ${error.message}`);
+	});
+	const outputFlushed = transformRpcOutput(child.stdout, process.stdout);
+	child.stderr.pipe(process.stderr);
+
+	const forwardedSignals = ["SIGINT", "SIGTERM", "SIGHUP"];
+	const signalHandlers = new Map(
+		forwardedSignals.map((signal) => [signal, () => child.kill(signal)]),
+	);
+	for (const [signal, handler] of signalHandlers) process.on(signal, handler);
+	let spawnFailed = false;
+	child.on("error", (error) => {
+		spawnFailed = true;
+		console.error(`rpc stream proxy failed to start ${command}: ${error.message}`);
+	});
+	child.on("close", async (code, signal) => {
+		try {
+			await outputFlushed;
+			await Promise.all([waitForDrain(process.stdout), waitForDrain(process.stderr)]);
+		} catch (error) {
+			console.error(`rpc stream proxy output failed: ${error.message}`);
+			process.exitCode = 1;
+			return;
+		}
+		if (transportFailed) {
+			process.exitCode = 1;
+			return;
+		}
+		if (signal) {
+			for (const [forwarded, handler] of signalHandlers) process.off(forwarded, handler);
+			process.kill(process.pid, signal);
+			return;
+		}
+		process.exitCode = spawnFailed ? 1 : (code ?? 1);
+	});
+}
+
+const entry = process.argv[1] ? pathToFileURL(process.argv[1]).href : undefined;
+if (entry === import.meta.url) runRpcProxy();