@yusukeshib/pi-babysit 0.3.12 → 0.3.14

package/index.ts

@@ -18,7 +18,7 @@
  *   kind=subagent  `babysit_run { profile: "subagent", task }` — a long-lived
  *                  `pi --mode rpc` worker. Tasks are injected as RPC `prompt`
  *                  commands over stdin, completion is detected from the JSONL
- *                  event stream (`agent_end`), NOT process exit; the session
+ *                  event stream (`agent_settled`), NOT process exit; the session
  *                  stays alive for cheap follow-up tasks. Same design as the
  *                  old pi-subagent extension.
  *
@@ -132,7 +132,7 @@ export function planSubagentSpawn(
 
 // 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).
+// apart from any other turn end (see isParkedMessages / self-reap.ts).
 export const NOTIFY_MARKER = "[notify-on-exit]";
 
 // Human-readable view for the compact subagent JSONL stream when a human
@@ -301,28 +301,25 @@ async function listSessions(): Promise<{ sessions: BsSession[]; error?: string }
 	}
 }
 
-async function statusOf(id: string): Promise<BsSession | null> {
-	// `status --json` shape: { session, status: { state, exit_code, ... } }.
-	// `note` lives only in `list --json`, so fold it in from there.
-	const r = await bs(["status", "-s", id, "--json"]);
-	if (r.code !== 0) return null;
+async function lookupStatus(
+	id: string,
+): Promise<{ session: BsSession | null; error?: string }> {
+	// `list --json` already carries every lifecycle field used by the extension,
+	// including `alive` and `note`. Using it directly avoids the old
+	// status-then-list pair (two CLI subprocesses for every status lookup).
 	try {
-		const parsed = JSON.parse(r.stdout);
-		const inner = parsed.status ?? parsed;
-		// `note` and `alive` live only in `list --json`, so fold them in from there
-		// (alive is what lets us detect a crashed-but-"running" worker).
-		const listed = (await listSessions()).sessions.find((s) => s.id === id);
-		return normalizeSession({
-			id: parsed.session ?? id,
-			note: listed?.note ?? null,
-			alive: listed?.alive,
-			...inner,
-		});
-	} catch {
-		return null;
+		const listed = await listSessions();
+		if (listed.error) return { session: null, error: listed.error };
+		return { session: listed.sessions.find((session) => session.id === id) ?? null };
+	} catch (error) {
+		return { session: null, error: error instanceof Error ? error.message : String(error) };
 	}
 }
 
+async function statusOf(id: string): Promise<BsSession | null> {
+	return (await lookupStatus(id)).session;
+}
+
 export function isConfirmedTerminalState(state: string): boolean {
 	return state === "killed" || state === "exited";
 }
@@ -358,11 +355,19 @@ async function awaitConfirmedTermination(id: string): Promise<BsSession | null>
 // kind=process: name/command + `notified` (exit notification dedup).
 // kind=subagent: task + the raw-log byte offset of the last prompt, which lets
 // check/wait analyze only the CURRENT task's events (important for follow-ups).
+export interface SubagentBudget {
+	maxCost?: number;
+	maxTurns?: number;
+	maxToolCalls?: number;
+	maxUsageTokens?: number;
+}
+
 interface Meta {
 	kind: "process" | "subagent";
 	// process
 	name?: string;
 	command?: string;
+	notificationGroup?: string;
 	notified?: boolean;
 	// A confirmed kill permanently owns completion delivery. An interrupted
 	// concurrent wait must not re-enable the automatic notification afterward.
@@ -380,8 +385,14 @@ interface Meta {
 	task?: string;
 	promptOffset?: number;
 	model?: string;
+	tools?: string[];
+	messageTempDirs?: Array<{ dir: string; afterAgentEnd: number }>;
 	depth?: number;
 	maxDepth?: number;
+	budget?: SubagentBudget;
+	budgetExceededAt?: number;
+	budgetReason?: string;
+	budgetKilled?: boolean;
 }
 
 const metaDir = () => path.join(ROOT, "meta");
@@ -404,20 +415,287 @@ function readMeta(id: string): Meta | null {
 	}
 }
 
+export interface BabysitGcResult {
+	candidates: string[];
+	deleted: string[];
+	bytes: number;
+	skippedLive: string[];
+}
+
+function processIsAlive(pid: number): boolean {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return (error as NodeJS.ErrnoException).code === "EPERM";
+	}
+}
+
+const GC_LOCK_FILE = ".pi-babysit-gc.lock";
+const ACTIVE_LEASE_PREFIX = ".pi-babysit-active-";
+
+function scanTreeStats(root: string): { bytes: number; newestMtimeMs: number } {
+	let bytes = 0;
+	let newestMtimeMs = 0;
+	const pending = [root];
+	while (pending.length > 0) {
+		const current = pending.pop() as string;
+		let entries: fs.Dirent[];
+		try {
+			entries = fs.readdirSync(current, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+		for (const entry of entries) {
+			if (entry.name === GC_LOCK_FILE) continue;
+			const fullPath = path.join(current, entry.name);
+			try {
+				const stat = fs.lstatSync(fullPath);
+				newestMtimeMs = Math.max(newestMtimeMs, stat.mtimeMs);
+				if (entry.isDirectory()) pending.push(fullPath);
+				else if (entry.isFile()) bytes += stat.size;
+			} catch {
+				/* raced with cleanup */
+			}
+		}
+	}
+	return { bytes, newestMtimeMs };
+}
+
+function gcRootIsSafe(root: string): boolean {
+	let rootEntries: fs.Dirent[];
+	try {
+		rootEntries = fs.readdirSync(root, { withFileTypes: true });
+	} catch {
+		return false;
+	}
+	for (const entry of rootEntries) {
+		if (!entry.isFile() || !entry.name.startsWith(ACTIVE_LEASE_PREFIX)) continue;
+		try {
+			const lease = JSON.parse(fs.readFileSync(path.join(root, entry.name), "utf8")) as {
+				pid?: number;
+			};
+			if (!Number.isSafeInteger(lease.pid) || (lease.pid as number) <= 0) return false;
+			if (processIsAlive(lease.pid as number)) return false;
+		} catch {
+			return false;
+		}
+	}
+
+	const sessionsDir = path.join(root, "sessions");
+	let sessionDirs: fs.Dirent[];
+	try {
+		sessionDirs = fs.readdirSync(sessionsDir, { withFileTypes: true });
+	} catch {
+		return false;
+	}
+	let sawStatus = false;
+	for (const sessionEntry of sessionDirs) {
+		if (!sessionEntry.isDirectory()) continue;
+		const sessionDir = path.join(sessionsDir, sessionEntry.name);
+		try {
+			const status = JSON.parse(
+				fs.readFileSync(path.join(sessionDir, "status.json"), "utf8"),
+			) as { state?: string; child_pid?: number | null };
+			sawStatus = true;
+			if (status.state !== "running") {
+				if (!status.state || (!isConfirmedTerminalState(status.state) && status.state !== "dead")) {
+					return false;
+				}
+				continue;
+			}
+			const supervisorPid = Number(
+				(JSON.parse(fs.readFileSync(path.join(sessionDir, "meta.json"), "utf8")) as {
+					babysit_pid?: number;
+				}).babysit_pid,
+			);
+			const childPid = Number(status.child_pid);
+			if (
+				!Number.isSafeInteger(supervisorPid) ||
+				supervisorPid <= 0 ||
+				processIsAlive(supervisorPid) ||
+				(Number.isSafeInteger(childPid) && childPid > 0 && processIsAlive(childPid))
+			) {
+				return false;
+			}
+		} catch {
+			return false;
+		}
+	}
+	return sawStatus;
+}
+
+function acquireRootLease(root: string): string | null {
+	fs.mkdirSync(root, { recursive: true });
+	const leasePath = path.join(
+		root,
+		`${ACTIVE_LEASE_PREFIX}${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}.json`,
+	);
+	const sleeper = new Int32Array(new SharedArrayBuffer(4));
+	for (let attempt = 0; attempt < 100; attempt++) {
+		if (fs.existsSync(path.join(root, GC_LOCK_FILE))) {
+			Atomics.wait(sleeper, 0, 0, 50);
+			continue;
+		}
+		try {
+			fs.writeFileSync(leasePath, JSON.stringify({ pid: process.pid, startedAt: Date.now() }), {
+				flag: "wx",
+			});
+			if (!fs.existsSync(path.join(root, GC_LOCK_FILE))) return leasePath;
+			fs.rmSync(leasePath, { force: true });
+		} catch {
+			/* retry while a collector owns the namespace */
+		}
+		Atomics.wait(sleeper, 0, 0, 50);
+	}
+	return null;
+}
+
+function releaseRootLease(leasePath: string | undefined): void {
+	if (!leasePath) return;
+	try {
+		fs.rmSync(leasePath, { force: true });
+	} catch {
+		/* best-effort */
+	}
+}
+
+export function gcBabysitRoots(options: {
+	rootBase: string;
+	currentRoot: string;
+	olderThanMs: number;
+	dryRun?: boolean;
+	now?: number;
+}): BabysitGcResult {
+	const now = options.now ?? Date.now();
+	const current = path.resolve(options.currentRoot);
+	const result: BabysitGcResult = { candidates: [], deleted: [], bytes: 0, skippedLive: [] };
+	let roots: fs.Dirent[];
+	try {
+		roots = fs.readdirSync(options.rootBase, { withFileTypes: true });
+	} catch {
+		return result;
+	}
+
+	for (const entry of roots) {
+		if (!entry.isDirectory() || entry.name.startsWith(".pi-babysit-gc-")) continue;
+		const root = path.join(options.rootBase, entry.name);
+		if (path.resolve(root) === current) continue;
+		if (!gcRootIsSafe(root)) {
+			result.skippedLive.push(entry.name);
+			continue;
+		}
+		const stats = scanTreeStats(root);
+		if (now - stats.newestMtimeMs < options.olderThanMs) continue;
+		result.candidates.push(entry.name);
+		if (options.dryRun !== false) {
+			result.bytes += stats.bytes;
+			continue;
+		}
+
+		const lockPath = path.join(root, GC_LOCK_FILE);
+		let lockFd: number | undefined;
+		let tombstone: string | undefined;
+		try {
+			lockFd = fs.openSync(lockPath, "wx");
+			// Compatible Pi processes acquire an active lease around this same lock.
+			// Revalidate after locking, then atomically rename the root so a resume
+			// racing deletion creates a fresh namespace instead of writing into rmSync.
+			if (!gcRootIsSafe(root)) {
+				result.skippedLive.push(entry.name);
+				continue;
+			}
+			const refreshedStats = scanTreeStats(root);
+			if (now - refreshedStats.newestMtimeMs < options.olderThanMs) continue;
+			tombstone = path.join(
+				options.rootBase,
+				`.pi-babysit-gc-${entry.name}-${process.pid}-${Date.now()}`,
+			);
+			fs.closeSync(lockFd);
+			lockFd = undefined;
+			fs.renameSync(root, tombstone);
+			fs.rmSync(tombstone, { recursive: true, force: true });
+			result.deleted.push(entry.name);
+			result.bytes += refreshedStats.bytes;
+		} catch {
+			/* report only roots whose atomic removal completed */
+		} finally {
+			if (lockFd != null) {
+				try {
+					fs.closeSync(lockFd);
+				} catch {
+					/* best-effort */
+				}
+			}
+			try {
+				fs.rmSync(lockPath, { force: true });
+			} catch {
+				/* root may already have been atomically renamed */
+			}
+		}
+	}
+	return result;
+}
+
+function cleanupMessageTempDirs(id: string, meta: Meta, agentEnds: number): void {
+	if (!meta.messageTempDirs?.length) return;
+	const keep: NonNullable<Meta["messageTempDirs"]> = [];
+	for (const entry of meta.messageTempDirs) {
+		if (entry.afterAgentEnd > agentEnds) {
+			keep.push(entry);
+			continue;
+		}
+		try {
+			fs.rmSync(entry.dir, { recursive: true, force: true });
+		} catch {
+			/* best-effort */
+		}
+	}
+	if (keep.length > 0) meta.messageTempDirs = keep;
+	else delete meta.messageTempDirs;
+	writeMeta(id, meta);
+}
+
 export function shouldDeliverProcessCompletion(
-	meta: {
-		kind: "process" | "subagent";
-		notified?: boolean;
-		notificationPaused?: boolean;
-	} | null,
-): meta is { kind: "process"; notified?: boolean; notificationPaused?: boolean } {
+	meta: Meta | null,
+): meta is Meta & { kind: "process" } {
 	return meta?.kind === "process" && !meta.notified && !meta.notificationPaused;
 }
 
+export function isNotificationGroupReady(
+	meta: Meta,
+	sessions: BsSession[],
+	metaFor: (id: string) => Meta | null,
+): boolean {
+	if (!meta.notificationGroup) return true;
+	return !sessions.some(
+		(session) =>
+			session.state === "running" &&
+			metaFor(session.id)?.notificationGroup === meta.notificationGroup,
+	);
+}
+
 export function shouldDeferCompletionNotification(agentIsIdle: boolean): boolean {
 	return !agentIsIdle;
 }
 
+export function shouldKeepPolling(
+	sessions: Array<{ id: string; state: string }>,
+	metaFor: (id: string) => Meta | null,
+): boolean {
+	return sessions.some(
+		(session) =>
+			session.state === "running" || shouldDeliverProcessCompletion(metaFor(session.id)),
+	);
+}
+
+export function shouldKeepPollingAfterList(
+	listed: { sessions: Array<{ id: string; state: string }>; error?: string },
+	metaFor: (id: string) => Meta | null,
+): boolean {
+	return Boolean(listed.error) || shouldKeepPolling(listed.sessions, metaFor);
+}
+
 const kindOf = (id: string): "process" | "subagent" => readMeta(id)?.kind ?? "process";
 
 // Compact elapsed formatting: "42s", "3m12s", "1h04m".
@@ -455,6 +733,44 @@ async function sendRpc(
 	}
 }
 
+export function parseRpcResponseBytes(
+	bytes: Buffer,
+	since: number,
+	command: string,
+):
+	| { ok: true; data?: Record<string, unknown>; offset: number }
+	| { ok: false; error: string } {
+	let start = 0;
+	while (start < bytes.length) {
+		const newline = bytes.indexOf(0x0a, start);
+		const end = newline < 0 ? bytes.length : newline + 1;
+		const line = bytes
+			.subarray(start, newline < 0 ? end : newline)
+			.toString("utf8")
+			.replace(/\r$/, "")
+			.trim();
+		if (line.startsWith("{")) {
+			try {
+				const event = JSON.parse(line);
+				if (event.type === "response" && event.command === command) {
+					if (event.success === false) {
+						return { ok: false, error: clip(String(event.error ?? `${command} failed`)) };
+					}
+					return {
+						ok: true,
+						data: event.data as Record<string, unknown> | undefined,
+						offset: since + end,
+					};
+				}
+			} catch {
+				/* partial line */
+			}
+		}
+		start = end;
+	}
+	return { ok: false, error: `no ${command} response found in log` };
+}
+
 // Wait for `{"type":"response","command":<command>}` after `since`, then parse
 // it. Distinguishes: success, explicit failure (success:false → the error
 // message, e.g. "No API key found for …"), subagent death, and timeout — this
@@ -465,7 +781,10 @@ async function rpcResponse(
 	command: string,
 	timeout = "30s",
 	signal?: AbortSignal,
-): Promise<{ ok: true; data?: Record<string, unknown> } | { ok: false; error: string }> {
+): Promise<
+	| { ok: true; data?: Record<string, unknown>; offset: number }
+	| { ok: false; error: string }
+> {
 	const e = await bs(
 		["expect", "-s", id, "--since", String(since), "--timeout", timeout, `"command":"${command}"`],
 		{ signal },
@@ -473,12 +792,19 @@ async function rpcResponse(
 	if (e.code !== 0) {
 		const st = await statusOf(id);
 		if (st && st.state !== "running") {
-			const tail = clip((await bs(["log", "-s", id, "--tail", "15"])).stdout.trim());
+			let structuredError = "";
+			try {
+				const bytes = fs.readFileSync(logPath(id));
+				structuredError = parseEvents(bytes.subarray(Math.min(since, bytes.length)).toString("utf8")).errorMsg ?? "";
+			} catch {
+				/* full log path below remains the diagnostic source */
+			}
 			return {
 				ok: false,
 				error:
 					`subagent exited (exit_code=${st.exit_code ?? "?"}) before responding to ${command}.` +
-					(tail ? `\nLast output:\n${tail}` : ""),
+					(structuredError ? `\n${structuredError}` : "") +
+					`\nFull log: ${logPath(id)}`,
 			};
 		}
 		return {
@@ -489,23 +815,26 @@ async function rpcResponse(
 					: e.stderr || `expect failed (code ${e.code})`,
 		};
 	}
-	const lg = await bs(["log", "-s", id, "--since", String(since)]);
-	for (const raw of lg.stdout.split("\n")) {
-		const line = raw.replace(/\r$/, "").trim();
-		if (!line.startsWith("{")) continue;
+	try {
+		const file = logPath(id);
+		const size = fs.statSync(file).size;
+		const length = Math.max(0, size - since);
+		const bytes = Buffer.allocUnsafe(length);
+		const fd = fs.openSync(file, "r");
+		let read = 0;
 		try {
-			const ev = JSON.parse(line);
-			if (ev.type === "response" && ev.command === command) {
-				if (ev.success === false) {
-					return { ok: false, error: clip(String(ev.error ?? `${command} failed`)) };
-				}
-				return { ok: true, data: ev.data as Record<string, unknown> | undefined };
+			while (read < length) {
+				const count = fs.readSync(fd, bytes, read, length - read, since + read);
+				if (count === 0) break;
+				read += count;
 			}
-		} catch {
-			/* partial line */
+		} finally {
+			fs.closeSync(fd);
 		}
+		return parseRpcResponseBytes(bytes.subarray(0, read), since, command);
+	} catch (error) {
+		return { ok: false, error: `could not read ${command} response: ${String(error)}` };
 	}
-	return { ok: false, error: `no ${command} response found in log` };
 }
 
 // "5m" / "30s" / "2h" → milliseconds (null = no limit).
@@ -539,7 +868,10 @@ const INLINE_OUTPUT_MAX_BYTES = byteLimitFromEnv("PI_BABYSIT_INLINE_OUTPUT_MAX_B
 const NOTIFY_OUTPUT_MAX_BYTES = byteLimitFromEnv("PI_BABYSIT_NOTIFY_OUTPUT_MAX_BYTES", 2_000);
 const NOTIFY_COMMAND_MAX_BYTES = byteLimitFromEnv("PI_BABYSIT_NOTIFY_COMMAND_MAX_BYTES", 240);
 const NOTIFY_BATCH_MAX_BYTES = byteLimitFromEnv("PI_BABYSIT_NOTIFY_BATCH_MAX_BYTES", 8_000);
-const ANSWER_MAX_BYTES = 24_000; // subagent answers / error messages
+const ANSWER_MAX_BYTES = 24_000; // single subagent answers / structured error messages
+const MAX_MULTI_WAIT_SESSIONS = 32;
+const SUBAGENT_BUDGET_GRACE_MS =
+	parseDurMs(process.env.PI_BABYSIT_BUDGET_GRACE ?? "30s") ?? 30_000;
 
 export function clip(s: string, maxBytes = TAIL_MAX_BYTES): string {
 	if (maxBytes <= 0) return "";
@@ -563,6 +895,13 @@ export function clip(s: string, maxBytes = TAIL_MAX_BYTES): string {
 	return `${head}${marker}${tail}`;
 }
 
+export function clipMultiWaitResult(
+	value: string,
+	maxBytes = INLINE_OUTPUT_MAX_BYTES,
+): string {
+	return clip(value, Math.min(maxBytes, ANSWER_MAX_BYTES));
+}
+
 async function searchLog(
 	id: string,
 	pattern: string,
@@ -880,19 +1219,42 @@ export function deliverProcessCompletionMessage(
 // (A subagent-profile run does NOT carry the marker: ending a turn to "wait"
 // for a subagent is a guidance violation, and treating it as completion keeps
 // the parent from hanging forever.) `process` is the legacy pi-processes tool.
-function isParkedToolResult(
-	last: { role?: string; toolName?: string; content?: unknown } | undefined,
+function isParkedMessages(
+	messages:
+		| {
+				role?: string;
+				toolName?: string;
+				content?: unknown;
+				details?: { kind?: string; status?: string };
+			}[]
+		| undefined,
 ): boolean {
-	if (!last || last.role !== "toolResult") return false;
-	if (last.toolName === "process") return true; // legacy
-	if (last.toolName !== "babysit_run") return false;
-	try {
-		const s = JSON.stringify(last.content ?? null);
-		if (s === "null") return true; // content unavailable — err on "parked" (never false-kill a build wait)
-		return s.includes(NOTIFY_MARKER);
-	} catch {
-		return true;
+	if (!messages) return false;
+	// Models sometimes add a short assistant note after starting a process. Scan
+	// the run rather than requiring the marker-bearing tool result to be the last
+	// message, otherwise that harmless note turns a parked build into false task
+	// completion (and lets the self-reaper kill it).
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const message = messages[i];
+		if (message?.role !== "toolResult") continue;
+		if (message.toolName === "process") return true; // legacy pi-processes
+		if (message.toolName !== "babysit_run") continue;
+		if (message.details?.kind === "process" && message.details.status === "started") {
+			return true;
+		}
+		const text = Array.isArray(message.content)
+			? message.content
+					.filter((part): part is { type: "text"; text: string } =>
+						Boolean(part && typeof part === "object" && part.type === "text" && typeof part.text === "string"),
+					)
+					.map((part) => part.text)
+					.join("")
+			: typeof message.content === "string"
+				? message.content
+				: "";
+		if (/^Process started \(id: [^)]+\)\. \[notify-on-exit\]\nLog: /.test(text)) return true;
 	}
+	return false;
 }
 
 // ---------------------------------------------------------------------------
@@ -907,12 +1269,22 @@ export interface Progress {
 	turns: number;
 	toolCalls: ToolCall[];
 	finalText: string;
+	/** Context size reported by the most recent assistant response. */
 	tokens?: number;
-	cost?: number;
+	/** Cumulative model usage for the current subagent task. */
+	modelCalls: number;
+	usageTokens: number;
+	inputTokens: number;
+	outputTokens: number;
+	cacheReadTokens: number;
+	cacheWriteTokens: number;
+	reasoningTokens: number;
+	cost: number;
 	errorMsg?: string;
 	// RPC lifecycle bookkeeping (computed over the analyzed log slice):
 	agentStarts: number;
 	agentEnds: number;
+	agentSettled: number;
 	lastEndWasProcessWait: boolean;
 	running: boolean; // an agent run is in flight right now
 	waitingOnProcess: boolean; // idle, but a process resume is pending
@@ -946,82 +1318,268 @@ function summarizeToolCall(name: string, args: Record<string, unknown>): string
 	}
 }
 
-export function parseEvents(logText: string): Progress {
-	const p: Progress = {
+function emptyProgress(): Progress {
+	return {
 		turns: 0,
 		toolCalls: [],
 		finalText: "",
+		modelCalls: 0,
+		usageTokens: 0,
+		inputTokens: 0,
+		outputTokens: 0,
+		cacheReadTokens: 0,
+		cacheWriteTokens: 0,
+		reasoningTokens: 0,
+		cost: 0,
 		agentStarts: 0,
 		agentEnds: 0,
+		agentSettled: 0,
 		lastEndWasProcessWait: false,
 		running: false,
 		waitingOnProcess: false,
 		done: false,
 	};
-	for (const raw of logText.split("\n")) {
-		const line = raw.replace(/\r$/, "").trim();
-		if (!line.startsWith("{")) continue;
-		let ev: Record<string, unknown>;
-		try {
-			ev = JSON.parse(line);
-		} catch {
-			continue; // partial trailing line, etc.
+}
+
+export function subagentBudgetViolation(
+	progress: Progress,
+	budget?: SubagentBudget,
+): string | null {
+	if (!budget) return null;
+	if (budget.maxCost != null && progress.cost >= budget.maxCost) {
+		return `cost $${progress.cost.toFixed(4)} reached maxCost $${budget.maxCost.toFixed(4)}`;
+	}
+	if (budget.maxTurns != null && progress.turns >= budget.maxTurns) {
+		return `${progress.turns} turns reached maxTurns ${budget.maxTurns}`;
+	}
+	if (budget.maxToolCalls != null && progress.toolCalls.length >= budget.maxToolCalls) {
+		return `${progress.toolCalls.length} tool calls reached maxToolCalls ${budget.maxToolCalls}`;
+	}
+	if (budget.maxUsageTokens != null && progress.usageTokens >= budget.maxUsageTokens) {
+		return `${progress.usageTokens} usage tokens reached maxUsageTokens ${budget.maxUsageTokens}`;
+	}
+	return null;
+}
+
+export function subagentBudgetAction(
+	progress: Progress,
+	budget: SubagentBudget | undefined,
+	exceededAt: number | undefined,
+	now: number,
+	graceMs: number,
+): { action: "none" | "steer" | "kill"; reason?: string } {
+	const reason = subagentBudgetViolation(progress, budget);
+	if (!reason) return { action: "none" };
+	if (exceededAt == null) return { action: "steer", reason };
+	return now - exceededAt >= graceMs
+		? { action: "kill", reason }
+		: { action: "none", reason };
+}
+
+function updateProgressState(progress: Progress): Progress {
+	progress.running = progress.agentStarts > progress.agentEnds;
+	progress.waitingOnProcess =
+		!progress.running && progress.agentEnds > 0 && progress.lastEndWasProcessWait;
+	// `agent_end` is not final: Pi may still retry, compact-and-retry, or process
+	// queued continuations. `agent_settled` is the authoritative completion event.
+	progress.done =
+		!progress.running &&
+		progress.agentSettled > 0 &&
+		!progress.lastEndWasProcessWait;
+	return progress;
+}
+
+function parseEventLine(progress: Progress, raw: string): void {
+	const line = raw.replace(/\r$/, "").trim();
+	if (!line.startsWith("{")) return;
+	let event: Record<string, unknown>;
+	try {
+		event = JSON.parse(line);
+	} catch {
+		return; // partial trailing line, etc.
+	}
+	switch (event.type) {
+		case "turn_start":
+			progress.turns++;
+			break;
+		case "tool_execution_start": {
+			const name = String(event.toolName ?? "tool");
+			progress.toolCalls.push({
+				name,
+				summary: summarizeToolCall(name, (event.args as Record<string, unknown>) ?? {}),
+			});
+			break;
 		}
-		switch (ev.type) {
-			case "turn_start":
-				p.turns++;
-				break;
-			case "tool_execution_start": {
-				const name = String(ev.toolName ?? "tool");
-				p.toolCalls.push({
-					name,
-					summary: summarizeToolCall(name, (ev.args as Record<string, unknown>) ?? {}),
-				});
-				break;
-			}
-			case "message_end": {
-				const msg = ev.message as
-					| { role?: string; content?: { type: string; text?: string }[]; usage?: { totalTokens?: number; cost?: { total?: number } } }
-					| undefined;
-				if (msg?.role === "assistant") {
-					const txt = (msg.content ?? [])
-						.filter((c) => c.type === "text" && c.text)
-						.map((c) => c.text)
-						.join("");
-					if (txt.trim()) p.finalText = txt; // keep the latest non-empty assistant text
-					if (msg.usage) {
-						p.tokens = msg.usage.totalTokens;
-						p.cost = msg.usage.cost?.total;
+		case "message_end": {
+			const message = event.message as
+				| {
+						role?: string;
+						content?: { type: string; text?: string }[];
+						usage?: {
+							input?: number;
+							output?: number;
+							cacheRead?: number;
+							cacheWrite?: number;
+							reasoning?: number;
+							totalTokens?: number;
+							cost?: { total?: number };
+						};
 					}
+				| undefined;
+			if (message?.role === "assistant") {
+				const text = (message.content ?? [])
+					.filter((content) => content.type === "text" && content.text)
+					.map((content) => content.text)
+					.join("");
+				if (text.trim()) progress.finalText = text;
+				if (message.usage) {
+					const finite = (value: number | undefined) =>
+						typeof value === "number" && Number.isFinite(value) ? value : 0;
+					progress.modelCalls++;
+					progress.tokens = message.usage.totalTokens;
+					progress.usageTokens += finite(message.usage.totalTokens);
+					progress.inputTokens += finite(message.usage.input);
+					progress.outputTokens += finite(message.usage.output);
+					progress.cacheReadTokens += finite(message.usage.cacheRead);
+					progress.cacheWriteTokens += finite(message.usage.cacheWrite);
+					progress.reasoningTokens += finite(message.usage.reasoning);
+					progress.cost += finite(message.usage.cost?.total);
 				}
-				break;
 			}
-			case "agent_start":
-				p.agentStarts++;
-				break;
-			case "agent_end": {
-				p.agentEnds++;
-				const msgs = ev.messages as
-					| { role?: string; toolName?: string; content?: unknown }[]
-					| undefined;
-				p.lastEndWasProcessWait = isParkedToolResult(msgs?.[msgs.length - 1]);
-				break;
+			break;
+		}
+		case "agent_start":
+			progress.agentStarts++;
+			break;
+		case "agent_end": {
+			progress.agentEnds++;
+			progress.lastEndWasProcessWait =
+				typeof event.piBabysitParked === "boolean"
+					? event.piBabysitParked
+					: isParkedMessages(
+							event.messages as
+								| {
+										role?: string;
+										toolName?: string;
+										content?: unknown;
+										details?: { kind?: string; status?: string };
+									}[]
+								| undefined,
+						);
+			break;
+		}
+		case "agent_settled":
+			progress.agentSettled++;
+			break;
+		case "response":
+			if (event.success === false) {
+				progress.errorMsg = String(event.error ?? `rpc ${event.command ?? "command"} failed`);
 			}
-			case "response":
-				// RPC command failures (bad model, no API key, …) surface here.
-				if (ev.success === false) {
-					p.errorMsg = String(ev.error ?? `rpc ${ev.command ?? "command"} failed`);
-				}
-				break;
-			case "error":
-				p.errorMsg = String(ev.message ?? ev.error ?? line);
-				break;
+			break;
+		case "error":
+			progress.errorMsg = String(event.message ?? event.error ?? line);
+			break;
+		case "extension_error": {
+			const extension = event.extensionPath ? `${String(event.extensionPath)}: ` : "";
+			progress.errorMsg = `${extension}${String(event.error ?? "extension failed")}`;
+			break;
 		}
 	}
-	p.running = p.agentStarts > p.agentEnds;
-	p.waitingOnProcess = !p.running && p.agentEnds > 0 && p.lastEndWasProcessWait;
-	p.done = !p.running && p.agentEnds > 0 && !p.lastEndWasProcessWait;
-	return p;
+}
+
+export function parseEvents(logText: string): Progress {
+	const progress = emptyProgress();
+	for (const line of logText.split("\n")) parseEventLine(progress, line);
+	return updateProgressState(progress);
+}
+
+export function buildSubagentDoneResult(
+	progress: Progress,
+): { body: string; ok: boolean } {
+	const finalText = progress.finalText.trim();
+	return {
+		body: clip(
+			progress.errorMsg
+				? `Extension error: ${progress.errorMsg}` +
+					(finalText ? `\n\n--- final answer ---\n${finalText}` : "")
+				: finalText || "(no answer text)",
+			ANSWER_MAX_BYTES,
+		),
+		ok: !progress.errorMsg,
+	};
+}
+
+export function buildSubagentExitDiagnostic(
+	progress: Progress,
+	fullLogPath: string,
+): string {
+	const body = clip(
+		progress.errorMsg ||
+			progress.finalText.trim() ||
+			"(no structured error was emitted; inspect the full log)",
+		ANSWER_MAX_BYTES,
+	);
+	return `${body}\n\nFull log: ${fullLogPath}`;
+}
+
+interface TaskProgressCache {
+	base: number;
+	offset: number;
+	pending: Buffer;
+	progress: Progress;
+}
+const taskProgressCache = new Map<string, TaskProgressCache>();
+
+/** Parse only bytes appended since the previous observation of this task. */
+function taskProgressOf(id: string): { progress: Progress; offset: number } {
+	const base = readMeta(id)?.promptOffset ?? 0;
+	const file = logPath(id);
+	const size = fs.statSync(file).size;
+	let cached = taskProgressCache.get(id);
+	if (!cached || cached.base !== base || size < cached.offset) {
+		cached = { base, offset: base, pending: Buffer.alloc(0), progress: emptyProgress() };
+		taskProgressCache.set(id, cached);
+	}
+	if (size > cached.offset) {
+		const added = Buffer.allocUnsafe(size - cached.offset);
+		const fd = fs.openSync(file, "r");
+		let read = 0;
+		try {
+			while (read < added.length) {
+				const count = fs.readSync(fd, added, read, added.length - read, cached.offset + read);
+				if (count === 0) break;
+				read += count;
+			}
+		} finally {
+			fs.closeSync(fd);
+		}
+		cached.offset += read;
+		const bytes = cached.pending.length
+			? Buffer.concat([cached.pending, added.subarray(0, read)])
+			: added.subarray(0, read);
+		let start = 0;
+		for (let index = 0; index < bytes.length; index++) {
+			if (bytes[index] !== 0x0a) continue;
+			parseEventLine(cached.progress, bytes.subarray(start, index).toString("utf8"));
+			start = index + 1;
+		}
+		cached.pending = Buffer.from(bytes.subarray(start));
+	}
+	updateProgressState(cached.progress);
+	const currentMeta = readMeta(id);
+	if (currentMeta?.budgetKilled && currentMeta.budgetReason) {
+		cached.progress.errorMsg = `Subagent budget exceeded: ${currentMeta.budgetReason}`;
+	}
+	if (cached.progress.agentEnds > 0) {
+		const meta = currentMeta;
+		if (meta) cleanupMessageTempDirs(id, meta, cached.progress.agentEnds);
+	}
+	// If the writer was observed mid-record, let `babysit expect --since` start
+	// before that partial line so a split agent_settled marker cannot be missed.
+	return {
+		progress: cached.progress,
+		offset: cached.offset - cached.pending.length,
+	};
 }
 
 // ---------------------------------------------------------------------------
@@ -1045,6 +1603,7 @@ interface ProcOpts {
 	timeout?: string; // default: none — dev servers may run indefinitely
 	idleTimeout?: string;
 	pty: boolean;
+	notificationGroup?: string;
 }
 
 async function spawnProcess(opts: ProcOpts): Promise<{ id: string } | { error: string }> {
@@ -1074,6 +1633,7 @@ async function spawnProcess(opts: ProcOpts): Promise<{ id: string } | { error: s
 		kind: "process",
 		name: opts.name ?? id,
 		command: opts.command,
+		notificationGroup: opts.notificationGroup,
 		notified: false,
 		startedAt: Date.now(),
 	});
@@ -1098,13 +1658,32 @@ function writePromptTempFile(agentName: string, prompt: string): string {
 // Anything over this budget is written to a file instead, and only a short
 // "read this file" instruction travels through the PTY.
 const PTY_SAFE_MESSAGE_BYTES = 600;
+const messageNeedsReadTool = (text: string): boolean =>
+	Buffer.byteLength(text, "utf-8") > PTY_SAFE_MESSAGE_BYTES;
+
+interface DeliverableMessage {
+	message: string;
+	tempDir?: string;
+}
 
-function deliverableMessage(kind: "task" | "steering message", text: string): string {
-	if (Buffer.byteLength(text, "utf-8") <= PTY_SAFE_MESSAGE_BYTES) return text;
+function deliverableMessage(kind: "task" | "steering message", text: string): DeliverableMessage {
+	if (!messageNeedsReadTool(text)) return { message: text };
 	const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-babysit-msg-"));
 	const file = path.join(dir, "message.md");
 	fs.writeFileSync(file, text, "utf-8");
-	return `Your full ${kind} is in the file ${file} — read it with the Read tool FIRST, then carry it out exactly as written.`;
+	return {
+		message: `Your full ${kind} is in the file ${file} — read it with the Read tool FIRST, then carry it out exactly as written.`,
+		tempDir: dir,
+	};
+}
+
+function discardDelivery(delivery: DeliverableMessage): void {
+	if (!delivery.tempDir) return;
+	try {
+		fs.rmSync(delivery.tempDir, { recursive: true, force: true });
+	} catch {
+		/* best-effort */
+	}
 }
 
 interface SubagentOpts {
@@ -1115,6 +1694,7 @@ interface SubagentOpts {
 	cwd: string;
 	depth: number;
 	maxDepth: number;
+	budget?: SubagentBudget;
 	// 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.
@@ -1132,12 +1712,29 @@ async function spawnSubagent(
 	const model = opts.model ?? opts.agent?.model;
 	if (model) piArgs.push("--model", model);
 	const tools = opts.tools ?? opts.agent?.tools;
+	if (messageNeedsReadTool(opts.task) && tools?.length && !tools.includes("read")) {
+		return {
+			error:
+				"This task exceeds the PTY-safe inline limit and must be delivered through a file, " +
+				"but the subagent tool allowlist excludes `read`. Add `read` or shorten the task.",
+		};
+	}
 	if (tools && tools.length > 0) piArgs.push("--tools", tools.join(","));
 	piArgs.push("--append-system-prompt", SUBAGENT_GUIDANCE);
+	let promptTempFile: string | undefined;
 	if (opts.agent?.systemPrompt?.trim()) {
-		const f = writePromptTempFile(opts.agent.name, opts.agent.systemPrompt);
-		piArgs.push("--append-system-prompt", f);
+		promptTempFile = writePromptTempFile(opts.agent.name, opts.agent.systemPrompt);
+		piArgs.push("--append-system-prompt", promptTempFile);
 	}
+	const cleanupPromptTemp = () => {
+		if (!promptTempFile) return;
+		try {
+			fs.rmSync(path.dirname(promptTempFile), { recursive: true, force: true });
+		} catch {
+			/* best-effort */
+		}
+		promptTempFile = undefined;
+	};
 	// Self-reaper: a finished subagent exits after a short idle grace instead of
 	// lingering until the absolute --timeout. Cancelled by a follow-up task, and
 	// it never reaps a turn parked on a process-exit notification. See self-reap.ts.
@@ -1155,8 +1752,8 @@ async function spawnSubagent(
 		opts.timeout,
 	];
 	// 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.
+	// proxy retains authoritative message_end/response/error events and reduces
+	// redundant lifecycle/tool payloads; parseEvents accepts both log formats.
 	if (VIEW_CMD.trim()) bsArgs.push("--view-cmd", VIEW_CMD);
 	if (opts.idleTimeout && opts.idleTimeout !== "none") {
 		bsArgs.push("--idle-timeout", opts.idleTimeout);
@@ -1178,12 +1775,14 @@ async function spawnSubagent(
 		},
 	});
 	if (r.code !== 0) {
+		cleanupPromptTemp();
 		return { error: r.stderr || r.stdout || `babysit run failed (exit ${r.code}, no output) — check that \`${BABYSIT_BIN}\` works and ${ROOT} is writable` };
 	}
 	let id: string;
 	try {
 		id = JSON.parse(r.stdout).id;
 	} catch {
+		cleanupPromptTemp();
 		return { error: `could not parse id from: ${r.stdout}` };
 	}
 
@@ -1197,15 +1796,29 @@ async function spawnSubagent(
 		notified: true,
 		depth: opts.depth,
 		maxDepth: opts.maxDepth,
+		budget: opts.budget,
 	});
 
 	// Wait for pi to boot (first JSON event in the log), then inject the task.
-	await bs(["expect", "-s", id, "--timeout", "30s", '\\{"type"']);
+	// Pi has loaded --append-system-prompt before emitting that event, so the
+	// anonymous prompt file can be removed immediately instead of leaking.
+	const boot = await bs(["expect", "-s", id, "--timeout", "30s", '\\{"type"']);
+	cleanupPromptTemp();
+	if (boot.code !== 0) {
+		await bs(["kill", "-s", id]);
+		return {
+			error: boot.code === 124
+				? `subagent ${id} did not emit an RPC startup event within 30s`
+				: boot.stderr || `subagent ${id} startup probe failed (code ${boot.code})`,
+		};
+	}
+	const delivery = deliverableMessage("task", opts.task);
 	const sent = await sendRpc(id, {
 		type: "prompt",
-		message: `Task: ${deliverableMessage("task", opts.task)}`,
+		message: `Task: ${delivery.message}`,
 	});
 	if ("error" in sent) {
+		discardDelivery(delivery);
 		await bs(["kill", "-s", id]);
 		return { error: `could not send task to subagent ${id}: ${sent.error}` };
 	}
@@ -1213,6 +1826,7 @@ async function spawnSubagent(
 	// and similar config errors surface — fail the spawn loudly).
 	const resp = await rpcResponse(id, sent.offset, "prompt", "60s");
 	if (!resp.ok) {
+		discardDelivery(delivery);
 		await bs(["kill", "-s", id]);
 		return { error: `subagent ${id} rejected the task: ${resp.error}` };
 	}
@@ -1225,6 +1839,7 @@ async function spawnSubagent(
 		if (st.ok && st.data) {
 			const m = (st.data as { model?: { id?: string } | null }).model;
 			if (m === null) {
+				discardDelivery(delivery);
 				await bs(["kill", "-s", id]);
 				return {
 					error: `subagent ${id} has no usable model${opts.model ? ` (requested "${opts.model}")` : ""} — check the model name with \`pi --list-models\`.`,
@@ -1237,10 +1852,15 @@ async function spawnSubagent(
 	writeMeta(id, {
 		kind: "subagent",
 		task: opts.task,
-		promptOffset: sent.offset,
+		promptOffset: resp.offset,
 		model: resolvedModel,
+		tools,
+		messageTempDirs: delivery.tempDir
+			? [{ dir: delivery.tempDir, afterAgentEnd: 1 }]
+			: undefined,
 		depth: opts.depth,
 		maxDepth: opts.maxDepth,
+		budget: opts.budget,
 		startedAt: Date.now(),
 	});
 	return { id, model: resolvedModel };
@@ -1282,43 +1902,31 @@ function sanitizeTailLine(s: string): string {
 // Trailing lines to show for a running session (sanitized, unprefixed).
 // process → raw log tail; subagent → derived activity (recent tool calls /
 // partial answer), since its log is RPC JSONL, not human-readable.
-async function widgetTail(id: string, isSub: boolean): Promise<string[]> {
+async function widgetTail(
+	id: string,
+	isSub: boolean,
+	subagentProgress?: Progress,
+): Promise<string[]> {
 	let raw: string[];
 	if (!isSub) {
 		const out = (await bs(["log", "-s", id, "--tail", String(WIDGET_TAIL_LINES)])).stdout;
 		raw = out.split("\n");
 	} else {
-		const meta = readMeta(id);
-		const logArgs = ["log", "-s", id];
-		if (meta?.promptOffset) logArgs.push("--since", String(meta.promptOffset));
-		const prog = parseEvents((await bs(logArgs)).stdout);
-		if (prog.finalText.trim()) {
-			raw = prog.finalText.trim().split("\n");
-		} else if (prog.toolCalls.length > 0) {
-			raw = prog.toolCalls.map((t) => t.summary);
+		const progress = subagentProgress ?? taskProgressOf(id).progress;
+		if (progress.finalText.trim()) {
+			raw = progress.finalText.trim().split("\n");
+		} else if (progress.toolCalls.length > 0) {
+			raw = progress.toolCalls.map((tool) => tool.summary);
 		} else {
-			raw = prog.errorMsg ? [`⚠ ${prog.errorMsg}`] : [];
+			raw = progress.errorMsg ? [`⚠ ${progress.errorMsg}`] : [];
 		}
 	}
 	return raw
 		.map(sanitizeTailLine)
-		.filter((l) => l.trim().length > 0)
+		.filter((line) => line.trim().length > 0)
 		.slice(-WIDGET_TAIL_LINES);
 }
 
-// Classify a running subagent as busy or idle by analyzing the current task's
-// log slice (same logic babysit_check uses).
-async function isTaskDone(id: string): Promise<boolean> {
-	try {
-		const meta = readMeta(id);
-		const logArgs = ["log", "-s", id];
-		if (meta?.promptOffset) logArgs.push("--since", String(meta.promptOffset));
-		return parseEvents((await bs(logArgs)).stdout).done;
-	} catch {
-		return false; // when unsure, treat as busy — never hide a live worker
-	}
-}
-
 // ---------------------------------------------------------------------------
 // human take-over hint (no tmux dependency)
 // ---------------------------------------------------------------------------
@@ -1343,72 +1951,61 @@ interface WaitOutcome {
 	progress?: Progress;
 }
 
-// Wait for ONE subagent's current task. Completion = an agent_end whose last
-// message is NOT a parked babysit_run/process toolResult (that one only means
-// "turn parked, waiting for a background process — pi resumes on its own").
-// Loop: analyze the current-task log slice; done → return; still going →
-// block on the next agent_end via `babysit expect` (race-free byte offsets).
+// Wait for ONE subagent's current task. Completion = agent_settled without a
+// parked babysit_run/process result (a parked run only means "waiting for
+// process exit; pi will resume itself"). Parse appended bytes incrementally,
+// then block on the next agent_settled via race-free byte offsets.
 async function waitForTask(
 	id: string,
 	limitMs: number | null,
 	signal?: AbortSignal,
 ): Promise<WaitOutcome> {
-	const meta = readMeta(id);
-	const base = meta?.promptOffset ?? 0;
 	const t0 = Date.now();
 
 	for (;;) {
-		const lg = await bs(["log", "-s", id, "--since", String(base), "--json"]);
-		let text = "";
-		let cur = base;
+		let observed: { progress: Progress; offset: number };
 		try {
-			const j = JSON.parse(lg.stdout);
-			text = j.text ?? "";
-			cur = j.offset ?? base;
+			observed = taskProgressOf(id);
 		} catch {
-			text = lg.stdout;
+			observed = { progress: emptyProgress(), offset: readMeta(id)?.promptOffset ?? 0 };
 		}
-		const prog = parseEvents(text);
+		const { progress: prog, offset: cur } = observed;
 		const st = await statusOf(id);
 
 		const stats =
-			`turns=${prog.turns} tools=${prog.toolCalls.length}` +
+			`turns=${prog.turns} calls=${prog.modelCalls} tools=${prog.toolCalls.length}` +
 			(prog.tokens != null ? ` ctx=${prog.tokens}` : "") +
-			(prog.cost != null ? ` $${prog.cost.toFixed(4)}` : "");
+			(prog.modelCalls > 0
+				? ` usage=${prog.usageTokens} (in=${prog.inputTokens} out=${prog.outputTokens} cache=${prog.cacheReadTokens}) $${prog.cost.toFixed(4)}`
+				: "");
 
 		if (prog.done) {
-			const body = clip(
-				prog.finalText.trim() || prog.errorMsg || "(no answer text)",
-				ANSWER_MAX_BYTES,
-			);
-			const ok = prog.finalText.trim().length > 0 || !prog.errorMsg;
+			const completed = buildSubagentDoneResult(prog);
 			return {
 				id,
 				kind: "done",
-				ok,
+				ok: completed.ok,
 				text:
 					`Subagent ${id} finished its task (${stats}).\n` +
 					`Session stays alive — follow-up: babysit_send { id: "${id}" }, ` +
-					`or babysit_kill when done.\n\n${body}`,
+					`or babysit_kill when done.\n\n${completed.body}`,
 				status: st,
 				progress: prog,
 			};
 		}
 
 		if (!st || st.state !== "running") {
-			// Crash / timeout / external kill — make the cause visible.
-			const tail = clip((await bs(["log", "-s", id, "--tail", "20"])).stdout.trim());
-			const body = clip(
-				prog.finalText.trim() || prog.errorMsg || tail || "(no output)",
-				ANSWER_MAX_BYTES,
-			);
+			// Never inject a raw RPC JSON tail into model context. Structured errors
+			// are parsed above; the complete stream remains available at the log path.
+			const diagnostic = buildSubagentExitDiagnostic(prog, logPath(id));
 			return {
 				id,
 				kind: "exited",
 				ok: false,
 				text:
 					`Subagent ${id} EXITED before completing the task ` +
-					`(state=${st?.state ?? "missing"}, exit_code=${st?.exit_code ?? "?"}, ${stats}).\n\n${body}`,
+					`(state=${st?.state ?? "missing"}, exit_code=${st?.exit_code ?? "?"}, ${stats}).\n\n` +
+					diagnostic,
 				status: st,
 				progress: prog,
 			};
@@ -1425,7 +2022,8 @@ async function waitForTask(
 			progress: prog,
 		});
 
-		// Still working — block on the next agent_end.
+		// Still working — block until Pi declares the run fully settled. Unlike
+		// agent_end, this cannot fire before an automatic retry/compaction retry.
 		let expectTimeout = "0"; // indefinite
 		if (limitMs != null) {
 			const remaining = limitMs - (Date.now() - t0);
@@ -1433,7 +2031,7 @@ async function waitForTask(
 			expectTimeout = `${Math.ceil(remaining / 1000)}s`;
 		}
 		const e = await bs(
-			["expect", "-s", id, "--since", String(cur), "--timeout", expectTimeout, '"type":"agent_end"'],
+			["expect", "-s", id, "--since", String(cur), "--timeout", expectTimeout, '"type":"agent_settled"'],
 			{ signal },
 		);
 		if (signal?.aborted || e.code === 130) {
@@ -1586,12 +2184,20 @@ async function waitForExit(
 		}
 	}
 
-	const st = await statusOf(id);
+	const statusLookup = await lookupStatus(id);
+	if (statusLookup.error) {
+		// The registry could not be read, so do not convert a transient backend
+		// failure into a missing session or permanently claim its notification.
+		if (!expectPattern) updateWaitReservation(id, "abandon");
+		return {
+			id,
+			kind: "interrupted",
+			ok: false,
+			text: `Could not verify ${id} after waiting: ${statusLookup.error}`,
+		};
+	}
+	const st = statusLookup.session;
 	if (!st) {
-		// A non-pattern backend wait returned before this lookup, so preserve its
-		// completion claim when status persistence is transiently unavailable.
-		// Abandoning here can re-enable the poller and duplicate a completion the
-		// explicit wait already consumed. This matches the old suppress-first rule.
 		if (!expectPattern) updateWaitReservation(id, "claim");
 		return { id, kind: "exited", ok: false, text: `No such session: ${id}` };
 	}
@@ -1658,14 +2264,35 @@ export function activeToolsWithoutDirectBash(activeTools: string[], allowDirectB
 
 export default function (pi: ExtensionAPI) {
 	let pollTimer: ReturnType<typeof setInterval> | undefined;
+	let pollNeeded = true;
+	let automaticGcRan = false;
+	let rootLeasePath: string | undefined;
 	const declaredToolErrors = new Set<string>();
+	const sessionRpcTails = new Map<string, Promise<void>>();
+
+	async function withSessionRpcLock<T>(id: string, operation: () => Promise<T>): Promise<T> {
+		const previous = sessionRpcTails.get(id) ?? Promise.resolve();
+		let release!: () => void;
+		const gate = new Promise<void>((resolve) => {
+			release = resolve;
+		});
+		const tail = previous.then(() => gate);
+		sessionRpcTails.set(id, tail);
+		await previous;
+		try {
+			return await operation();
+		} finally {
+			release();
+			if (sessionRpcTails.get(id) === tail) sessionRpcTails.delete(id);
+		}
+	}
 
 	// Pi only persists custom-tool failures when they are thrown or patched by a
 	// tool_result hook; an `isError` property returned from execute() is ignored.
 	// Keep the structured result (status, log path, diagnostics) while promoting
 	// its declared error bit at the supported hook boundary.
-	const registerTool = <TParams extends TSchema, TDetails, TState>(
-		tool: ToolDefinition<TParams, TDetails, TState>,
+	const registerTool = <TParams extends TSchema>(
+		tool: ToolDefinition<TParams, unknown, unknown>,
 	): void => {
 		const execute = tool.execute;
 		pi.registerTool({
@@ -1684,23 +2311,104 @@ export default function (pi: ExtensionAPI) {
 		if (declaredToolErrors.delete(event.toolCallId)) return { isError: true };
 	});
 
+	async function enforceSubagentBudgets(sessions: BsSession[]): Promise<void> {
+		for (const session of sessions) {
+			if (session.state !== "running") continue;
+			await withSessionRpcLock(session.id, async () => {
+				const latestStatus = await statusOf(session.id);
+				const meta = readMeta(session.id);
+				if (
+					latestStatus?.state !== "running" ||
+					meta?.kind !== "subagent" ||
+					!meta.budget ||
+					meta.budgetKilled
+				) {
+					return;
+				}
+
+				let progress: Progress;
+				try {
+					progress = taskProgressOf(session.id).progress;
+				} catch {
+					return;
+				}
+				if (progress.done) return;
+				const now = Date.now();
+				const decision = subagentBudgetAction(
+					progress,
+					meta.budget,
+					meta.budgetExceededAt,
+					now,
+					SUBAGENT_BUDGET_GRACE_MS,
+				);
+				if (decision.action === "none") return;
+				const reason = decision.reason as string;
+
+				if (decision.action === "steer") {
+					// Start the grace period only after Pi accepts the steering command.
+					const sent = await sendRpc(session.id, {
+						type: "steer",
+						message: `Budget reached (${reason}). Stop calling tools and provide your final answer now.`,
+					});
+					if ("error" in sent) return;
+					const accepted = await rpcResponse(session.id, sent.offset, "steer", "3s");
+					if (!accepted.ok) return;
+					const current = readMeta(session.id);
+					if (
+						current?.kind !== "subagent" ||
+						current.promptOffset !== meta.promptOffset ||
+						current.budgetExceededAt
+					) {
+						return;
+					}
+					current.budgetExceededAt = now;
+					current.budgetReason = reason;
+					writeMeta(session.id, current);
+					return;
+				}
+
+				const killed = await bs(["kill", "-s", session.id, "--json"]);
+				if (killed.code !== 0) return;
+				const terminal = await awaitConfirmedTermination(session.id);
+				const current = readMeta(session.id);
+				if (
+					terminal &&
+					isConfirmedTerminalState(terminal.state) &&
+					current?.kind === "subagent" &&
+					current.promptOffset === meta.promptOffset &&
+					current.budgetExceededAt === meta.budgetExceededAt
+				) {
+					current.budgetKilled = true;
+					current.budgetReason = current.budgetReason ?? reason;
+					writeMeta(session.id, current);
+				}
+			});
+		}
+	}
+
 	// Exit notifications for kind=process sessions: the poller detects
 	// running→exited transitions and injects ONE message (triggerTurn) for all
 	// processes that became deliverable in the same poll. This resumes an agent
 	// that ended its turn after babysit_run without spending one turn per exit.
 	// Kills via babysit_kill and exits already reported by babysit_wait are
 	// suppressed via meta.notified.
-	async function notifyEndedProcesses(ctx: ExtensionContext): Promise<void> {
+	async function notifyEndedProcesses(
+		ctx: ExtensionContext,
+		snapshot?: BsSession[],
+	): Promise<void> {
 		// Never steer a completion into an active agent turn. In particular, this
 		// lets an immediately-following babysit_wait reserve the completion first,
 		// instead of racing the poller and receiving both wait + auto notification.
 		if (shouldDeferCompletionNotification(ctx.isIdle())) return;
-		const { sessions } = await listSessions();
+		const sessions = snapshot ?? (await listSessions()).sessions;
 		const ready: Array<{ session: BsSession; meta: Meta }> = [];
 		for (const session of sessions) {
 			if (session.state === "running") continue;
 			const meta = readMeta(session.id);
 			if (!shouldDeliverProcessCompletion(meta)) continue;
+			// A notification group is delivered only after all currently known
+			// members have stopped, even when their exit times span many polls.
+			if (!isNotificationGroupReady(meta, sessions, readMeta)) continue;
 			// Delay delivery by one poll interval. This gives an agent that chose
 			// babysit_wait immediately after babysit_run enough time to claim the
 			// completion and suppress the otherwise duplicate automatic message.
@@ -1743,13 +2451,17 @@ export default function (pi: ExtensionAPI) {
 			});
 		}
 
-		// Output loading above is asynchronous. Re-read every candidate together
-		// immediately before the single send so a concurrent kill/wait cannot claim
-		// an early candidate while a later candidate's output is being loaded.
+		// Output loading above is asynchronous. Refresh sessions and metadata
+		// immediately before the single send so concurrent wait/kill calls and newly
+		// started notification-group members are honored.
+		const refreshed = await listSessions();
+		if (refreshed.error) return;
+		const finalSessions = refreshed.sessions;
 		const metadataById = new Map<string, Meta>();
 		const notices = prepared.flatMap((notice) => {
 			const current = readMeta(notice.id);
 			if (!shouldDeliverProcessCompletion(current)) return [];
+			if (!isNotificationGroupReady(current, finalSessions, readMeta)) return [];
 			metadataById.set(notice.id, current);
 			return [{ ...notice, command: current.command }];
 		});
@@ -1769,30 +2481,45 @@ export default function (pi: ExtensionAPI) {
 		);
 	}
 
-	const refreshWidget = async (ctx: ExtensionContext) => {
+	const refreshWidget = async (ctx: ExtensionContext, snapshot?: BsSession[]) => {
 		if (!ctx.hasUI) return;
-		const active = (await listSessions()).sessions.filter((s) => s.state === "running");
-		const subs = active.filter((s) => kindOf(s.id) === "subagent");
+		const active = (snapshot ?? (await listSessions()).sessions).filter(
+			(session) => session.state === "running",
+		);
+		const subs = active.filter((session) => kindOf(session.id) === "subagent");
 		const procs = active.length - subs.length;
-		const doneFlags = await Promise.all(subs.map((s) => isTaskDone(s.id)));
-		const idle = doneFlags.filter(Boolean).length;
+		const progressById = new Map<string, Progress>();
+		for (const subagent of subs) {
+			try {
+				progressById.set(subagent.id, taskProgressOf(subagent.id).progress);
+			} catch {
+				progressById.set(subagent.id, emptyProgress());
+			}
+		}
+		const idle = subs.filter((session) => progressById.get(session.id)?.done).length;
 		const lines = renderWidgetLines(procs, subs.length - idle, idle);
-		// Per-session elapsed time (live: refreshed every poll tick).
-		const doneById = new Map(subs.map((s, i) => [s.id, doneFlags[i]]));
 		const tails = await Promise.all(
-			active.map((s) => widgetTail(s.id, kindOf(s.id) === "subagent")),
+			active.map((session) => {
+				const isSubagent = kindOf(session.id) === "subagent";
+				return widgetTail(
+					session.id,
+					isSubagent,
+					isSubagent ? progressById.get(session.id) : undefined,
+				);
+			}),
 		);
-		active.forEach((s, i) => {
-			const isSub = kindOf(s.id) === "subagent";
-			const tag = isSub ? (doneById.get(s.id) ? "sub idle" : "sub") : "proc";
-			const el = elapsedOf(s.id);
-			const header = `  ⏳ ${s.id} [${tag}]${el ? ` ${el}` : ""}`;
-			if (tails[i].length === 1) {
-				// Single tail line: keep it on the same row as the header.
-				lines.push(`${header}  │ ${tails[i][0]}`);
+		active.forEach((session, index) => {
+			const isSubagent = kindOf(session.id) === "subagent";
+			const tag = isSubagent
+				? progressById.get(session.id)?.done ? "sub idle" : "sub"
+				: "proc";
+			const elapsed = elapsedOf(session.id);
+			const header = `  ⏳ ${session.id} [${tag}]${elapsed ? ` ${elapsed}` : ""}`;
+			if (tails[index].length === 1) {
+				lines.push(`${header}  │ ${tails[index][0]}`);
 			} else {
 				lines.push(header);
-				for (const t of tails[i]) lines.push(`     │ ${t}`);
+				for (const tail of tails[index]) lines.push(`     │ ${tail}`);
 			}
 		});
 		ctx.ui.setWidget("pi-babysit", lines, { placement: "belowEditor" });
@@ -1882,25 +2609,71 @@ export default function (pi: ExtensionAPI) {
 		// Session-local registry: scope the babysit root to this pi session so
 		// other sessions' processes/subagents are invisible here. Resuming a
 		// session keeps the same id, so its sessions come back with it.
+		releaseRootLease(rootLeasePath);
 		try {
 			ROOT = path.join(ROOT_BASE, ctx.sessionManager.getSessionId());
 		} catch {
 			ROOT = ROOT_BASE;
 		}
+		rootLeasePath = acquireRootLease(ROOT) ?? undefined;
+		if (!rootLeasePath) {
+			const desiredRoot = ROOT;
+			ROOT = `${desiredRoot}-active-${process.pid}-${Date.now()}`;
+			rootLeasePath = acquireRootLease(ROOT) ?? undefined;
+			if (ctx.hasUI) {
+				ctx.ui.notify(
+					`Babysit GC was busy for ${desiredRoot}; using an isolated root for this run.`,
+					"warning",
+				);
+			}
+		}
+		taskProgressCache.clear();
+		pollNeeded = true;
+		const retentionDays = Number(process.env.PI_BABYSIT_RETENTION_DAYS);
+		if (!automaticGcRan && Number.isFinite(retentionDays) && retentionDays > 0) {
+			automaticGcRan = true;
+			const gc = gcBabysitRoots({
+				rootBase: ROOT_BASE,
+				currentRoot: ROOT,
+				olderThanMs: retentionDays * 86_400_000,
+				dryRun: false,
+			});
+			if (gc.deleted.length > 0 && ctx.hasUI) {
+				ctx.ui.notify(
+					`pi-babysit GC removed ${gc.deleted.length} roots (${gc.bytes} bytes).`,
+					"info",
+				);
+			}
+		}
 		// Warn early if the binary is missing so the user isn't surprised only when
 		// a tool later fails. Tools/commands still enforce it via requireBabysit.
 		if (ctx.hasUI && !(await babysitAvailable())) {
-			ctx.ui.notify(babysitPreflightError ?? INSTALL_HINT, "warn");
+			ctx.ui.notify(babysitPreflightError ?? INSTALL_HINT, "warning");
 		}
 		if (pollTimer) clearInterval(pollTimer);
 		pollTimer = setInterval(() => {
-			// Skip if the previous (async) poll hasn't finished, so slow babysit
-			// calls never stack up.
-			if (polling) return;
+			// Once a namespace has no live workers or pending notifications, avoid
+			// spawning `babysit list` forever while the UI is idle. A successful
+			// babysit_run re-arms polling below.
+			if (polling || !pollNeeded) return;
 			polling = true;
-			Promise.all([notifyEndedProcesses(ctx), refreshWidget(ctx)])
+			void (async () => {
+				const listed = await listSessions();
+				if (listed.error) {
+					pollNeeded = shouldKeepPollingAfterList(listed, readMeta);
+					throw new Error(listed.error);
+				}
+				const snapshot = listed.sessions;
+				await enforceSubagentBudgets(snapshot);
+				await Promise.all([
+					notifyEndedProcesses(ctx, snapshot),
+					refreshWidget(ctx, snapshot),
+				]);
+				pollNeeded = shouldKeepPolling(snapshot, readMeta);
+			})()
 				.catch(() => {
-					/* ignore poll errors */
+					// Keep polling armed after a transient CLI/filesystem error.
+					pollNeeded = true;
 				})
 				.finally(() => {
 					polling = false;
@@ -1911,6 +2684,8 @@ export default function (pi: ExtensionAPI) {
 	pi.on("session_shutdown", async () => {
 		if (pollTimer) clearInterval(pollTimer);
 		pollTimer = undefined;
+		releaseRootLease(rootLeasePath);
+		rootLeasePath = undefined;
 	});
 
 	pi.on("tool_call", async (event) => {
@@ -1998,6 +2773,24 @@ export default function (pi: ExtensionAPI) {
 						"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.",
 				}),
 			),
+			maxCost: Type.Optional(
+				Type.Number({
+					exclusiveMinimum: 0,
+					description: "Subagent only: steer it to wrap up at this cumulative reported cost, then kill after the budget grace period.",
+				}),
+			),
+			maxTurns: Type.Optional(
+				Type.Integer({ minimum: 1, description: "Subagent only: maximum turns per task." }),
+			),
+			maxToolCalls: Type.Optional(
+				Type.Integer({ minimum: 1, description: "Subagent only: maximum tool calls per task." }),
+			),
+			maxUsageTokens: Type.Optional(
+				Type.Integer({
+					minimum: 1,
+					description: "Subagent only: maximum cumulative reported totalTokens across model calls.",
+				}),
+			),
 			agentScope: Type.Optional(
 				StringEnum(["user", "project", "both"] as const, {
 					description: "Where to discover named agents. Default 'user'.",
@@ -2021,6 +2814,12 @@ export default function (pi: ExtensionAPI) {
 						"Process mode: run in a PTY (default true; enables interactive input/screen). false = plain pipes for cleaner line-oriented logs.",
 				}),
 			),
+			notificationGroup: Type.Optional(
+				Type.String({
+					description:
+						"Process mode: defer automatic completion until every running process with this group has stopped, then send one batched notification.",
+				}),
+			),
 			continueAfterStart: Type.Optional(
 				Type.Boolean({
 					description:
@@ -2059,6 +2858,25 @@ export default function (pi: ExtensionAPI) {
 					details: {},
 				};
 			}
+			const hasBudget =
+				params.maxCost != null ||
+				params.maxTurns != null ||
+				params.maxToolCalls != null ||
+				params.maxUsageTokens != null;
+			if (!isSubagent && hasBudget) {
+				return {
+					content: [{ type: "text", text: "Subagent budget parameters require profile 'subagent'." }],
+					isError: true,
+					details: {},
+				};
+			}
+			if (isSubagent && params.notificationGroup) {
+				return {
+					content: [{ type: "text", text: "`notificationGroup` is available only in process mode." }],
+					isError: true,
+					details: {},
+				};
+			}
 
 			// Compute nesting only for subagent mode. Ordinary command processes remain
 			// available even when the hosting agent is at its subagent depth limit.
@@ -2082,6 +2900,7 @@ export default function (pi: ExtensionAPI) {
 					timeout: params.timeout,
 					idleTimeout: params.idleTimeout,
 					pty: params.pty ?? true,
+					notificationGroup: params.notificationGroup?.trim() || undefined,
 				};
 				let res = await spawnProcess(spawnOpts);
 				if ("error" in res) {
@@ -2091,6 +2910,7 @@ export default function (pi: ExtensionAPI) {
 						details: {},
 					};
 				}
+				pollNeeded = true;
 				await refreshWidget(ctx);
 
 				// One-shot / non-interactive mode (e.g. `pi -p`): there is no live
@@ -2223,6 +3043,15 @@ export default function (pi: ExtensionAPI) {
 				cwd: ctx.cwd,
 				depth: subagentNesting.childDepth,
 				maxDepth: subagentNesting.maxDepth,
+				budget:
+					hasBudget
+						? {
+							maxCost: params.maxCost,
+							maxTurns: params.maxTurns,
+							maxToolCalls: params.maxToolCalls,
+							maxUsageTokens: params.maxUsageTokens,
+						}
+						: undefined,
 				timeout: params.timeout ?? "15m",
 				idleTimeout: params.idleTimeout,
 			});
@@ -2235,6 +3064,7 @@ export default function (pi: ExtensionAPI) {
 				};
 			}
 
+			pollNeeded = true;
 			await refreshWidget(ctx);
 			return {
 				content: [
@@ -2439,10 +3269,8 @@ export default function (pi: ExtensionAPI) {
 				};
 			}
 
-			// --- subagent: analyze only the current task's slice ---
-			const logArgs = ["log", "-s", params.id];
-			if (meta?.promptOffset) logArgs.push("--since", String(meta.promptOffset));
-			const prog = parseEvents((await bs(logArgs)).stdout);
+			// --- subagent: analyze only bytes appended for the current task ---
+			const prog = taskProgressOf(params.id).progress;
 			const nTools = Math.min(Math.max(1, params.tools ?? 8), 50);
 			const recent = prog.toolCalls.slice(-nTools);
 
@@ -2459,9 +3287,9 @@ export default function (pi: ExtensionAPI) {
 						: " · working";
 			}
 			if (st.exit_code != null) header += ` exit_code=${st.exit_code}`;
-			header += ` turns=${prog.turns} tools=${prog.toolCalls.length}`;
+			header += ` turns=${prog.turns} calls=${prog.modelCalls} tools=${prog.toolCalls.length}`;
 			if (prog.tokens != null) header += ` ctx=${prog.tokens}`;
-			if (prog.cost != null) header += ` $${prog.cost.toFixed(4)}`;
+			if (prog.modelCalls > 0) header += ` usage=${prog.usageTokens} $${prog.cost.toFixed(4)}`;
 			if (st.note) header += ` ⚑ ${st.note}`;
 			parts.push(header);
 
@@ -2478,10 +3306,7 @@ export default function (pi: ExtensionAPI) {
 			if (prog.finalText.trim()) {
 				parts.push(`--- answer so far ---\n${clip(prog.finalText.trim(), ANSWER_MAX_BYTES)}`);
 			} else if (prog.toolCalls.length === 0 && st.state !== "running") {
-				// Died before doing anything — show the log tail so the cause of
-				// death (model error, crash, timeout) is visible, not hidden.
-				const tail = clip((await bs(["log", "-s", params.id, "--tail", "15"])).stdout.trim());
-				parts.push(tail ? `--- last output ---\n${tail}` : "(no output)");
+				parts.push(buildSubagentExitDiagnostic(prog, logPath(params.id)));
 			} else if (prog.toolCalls.length === 0) {
 				parts.push("(starting up… no events yet)");
 			} else {
@@ -2489,7 +3314,7 @@ export default function (pi: ExtensionAPI) {
 			}
 
 			return {
-				content: [{ type: "text", text: parts.join("\n") }],
+				content: [{ type: "text", text: clip(parts.join("\n")) }],
 				details: { status: st, progress: prog, kind: "subagent" },
 			};
 		},
@@ -2584,6 +3409,21 @@ export default function (pi: ExtensionAPI) {
 			}
 
 			// --- subagent: steer / follow-up task over RPC ---
+			return withSessionRpcLock(params.id, async () => {
+				const lockedStatus = await statusOf(params.id);
+				const meta = readMeta(params.id);
+				if (lockedStatus?.state !== "running" || meta?.kind !== "subagent") {
+					return {
+						content: [
+							{
+								type: "text" as const,
+								text: `Session ${params.id} is not a running subagent (${lockedStatus?.state ?? "missing"}).`,
+							},
+						],
+						isError: true,
+						details: {},
+					};
+				}
 			if (!params.text) {
 				return {
 					content: [{ type: "text", text: "Provide `text` (steering or follow-up task)." }],
@@ -2591,6 +3431,18 @@ export default function (pi: ExtensionAPI) {
 					details: {},
 				};
 			}
+			if (messageNeedsReadTool(params.text) && meta.tools?.length && !meta.tools.includes("read")) {
+				return {
+					content: [
+						{
+							type: "text",
+							text: "This message is too large for PTY-safe inline delivery, but the subagent cannot read the required temporary file. Add `read` to its tool allowlist or shorten the message.",
+						},
+					],
+					isError: true,
+					details: {},
+				};
+			}
 			let mode = params.mode ?? "auto";
 			if (mode === "auto") {
 				// isStreaming tells us whether an agent run is in flight right now.
@@ -2602,12 +3454,27 @@ export default function (pi: ExtensionAPI) {
 				}
 				mode = streaming ? "steer" : "task";
 			}
+			const deliveryCleanupAfter =
+				mode === "steer"
+					? (() => {
+							try {
+								return taskProgressOf(params.id).progress.agentEnds + 1;
+							} catch {
+								return 1;
+							}
+						})()
+					: 1;
+			const delivery = deliverableMessage(
+				mode === "steer" ? "steering message" : "task",
+				params.text,
+			);
 			const cmd =
 				mode === "steer"
-					? { type: "steer", message: deliverableMessage("steering message", params.text) }
-					: { type: "prompt", message: deliverableMessage("task", params.text) };
+					? { type: "steer", message: delivery.message }
+					: { type: "prompt", message: delivery.message };
 			const sent = await sendRpc(params.id, cmd);
 			if ("error" in sent) {
+				discardDelivery(delivery);
 				return {
 					content: [{ type: "text", text: sent.error }],
 					isError: true,
@@ -2616,6 +3483,7 @@ export default function (pi: ExtensionAPI) {
 			}
 			const resp = await rpcResponse(params.id, sent.offset, cmd.type, "15s");
 			if (!resp.ok) {
+				discardDelivery(delivery);
 				return {
 					content: [{ type: "text", text: `${cmd.type} was not accepted: ${resp.error}` }],
 					isError: true,
@@ -2627,10 +3495,29 @@ export default function (pi: ExtensionAPI) {
 				writeMeta(params.id, {
 					kind: "subagent",
 					task: params.text,
-					promptOffset: sent.offset,
+					// Start after the prompt-acceptance response. This excludes a
+					// preceding run that settled between `send` and RPC acceptance.
+					promptOffset: resp.offset,
 					model: meta?.model,
+					tools: meta?.tools,
+					messageTempDirs: delivery.tempDir
+						? [{ dir: delivery.tempDir, afterAgentEnd: deliveryCleanupAfter }]
+						: undefined,
 					depth: meta?.depth,
 					maxDepth: meta?.maxDepth,
+					budget: meta?.budget,
+					// Each follow-up task receives a fresh budget window.
+					budgetExceededAt: undefined,
+					budgetReason: undefined,
+					budgetKilled: undefined,
+				});
+			} else if (delivery.tempDir && meta) {
+				writeMeta(params.id, {
+					...meta,
+					messageTempDirs: [
+						...(meta.messageTempDirs ?? []),
+						{ dir: delivery.tempDir, afterAgentEnd: deliveryCleanupAfter },
+					],
 				});
 			}
 			return {
@@ -2645,6 +3532,7 @@ export default function (pi: ExtensionAPI) {
 				],
 				details: { mode, kind: "subagent" },
 			};
+			});
 		},
 	});
 
@@ -2658,6 +3546,8 @@ export default function (pi: ExtensionAPI) {
 			"for 'listening on' before hitting a dev server). A subagent finishes when its current " +
 			"TASK completes (the session stays alive for follow-ups). Pass `id` for one session, or " +
 			"`ids` + `mode`: 'all' (default) waits for every one, 'any' returns on the FIRST finisher. " +
+			"Multi-session results are capped at the inline-output limit (8 KB by default); use `maxBytes` " +
+			"to opt into a larger result up to 24 KB. " +
 			"Prefer ending your turn over babysit_wait when a process result is not needed this turn — " +
 			"the exit notification will resume you.",
 		promptSnippet: "Block until session(s) finish — process exit / output pattern / subagent task done",
@@ -2665,7 +3555,8 @@ export default function (pi: ExtensionAPI) {
 			id: Type.Optional(Type.String({ description: "Session id (single wait)." })),
 			ids: Type.Optional(
 				Type.Array(Type.String(), {
-					description: "Session ids for a multi-wait (use with mode).",
+					maxItems: MAX_MULTI_WAIT_SESSIONS,
+					description: `Session ids for a multi-wait (use with mode; maximum ${MAX_MULTI_WAIT_SESSIONS}, no duplicates).`,
 				}),
 			),
 			mode: Type.Optional(
@@ -2682,6 +3573,14 @@ export default function (pi: ExtensionAPI) {
 						"Process only: return as soon as this regex appears in the output (readiness marker) instead of waiting for exit.",
 				}),
 			),
+			maxBytes: Type.Optional(
+				Type.Integer({
+					minimum: 1_000,
+					maximum: ANSWER_MAX_BYTES,
+					description:
+						"Multi-session result cap in bytes. Defaults to PI_BABYSIT_INLINE_OUTPUT_MAX_BYTES (8 KB).",
+				}),
+			),
 		}),
 		async execute(_id, params, signal) {
 			await requireBabysit();
@@ -2693,7 +3592,27 @@ export default function (pi: ExtensionAPI) {
 					details: {},
 				};
 			}
+			if (ids.length > MAX_MULTI_WAIT_SESSIONS) {
+				return {
+					content: [{ type: "text", text: `Multi-wait supports at most ${MAX_MULTI_WAIT_SESSIONS} sessions.` }],
+					isError: true,
+					details: {},
+				};
+			}
+			if (new Set(ids).size !== ids.length) {
+				return {
+					content: [{ type: "text", text: "Multi-wait session ids must be unique." }],
+					isError: true,
+					details: {},
+				};
+			}
 			const limitMs = parseDurMs(params.timeout);
+			const multiResultMaxBytes = params.maxBytes ?? INLINE_OUTPUT_MAX_BYTES;
+			if (params.timeout !== undefined && limitMs === null) {
+				throw new Error(
+					`Invalid timeout ${JSON.stringify(params.timeout)}; use an integer with ms, s, m, or h (for example "90s" or "5m").`,
+				);
+			}
 
 			if (ids.length === 1) {
 				const r = await waitFor(ids[0], limitMs, signal, params.expect);
@@ -2719,7 +3638,10 @@ export default function (pi: ExtensionAPI) {
 					content: [
 						{
 							type: "text",
-							text: results.map((r) => `── ${r.id} [${r.kind}] ──\n${r.text}`).join("\n\n"),
+							text: clipMultiWaitResult(
+								results.map((result) => `── ${result.id} [${result.kind}] ──\n${result.text}`).join("\n\n"),
+								multiResultMaxBytes,
+							),
 						},
 					],
 					isError: !ok,
@@ -2743,10 +3665,12 @@ export default function (pi: ExtensionAPI) {
 					content: [
 						{
 							type: "text",
-							text:
+							text: clipMultiWaitResult(
 								`First to finish: ${first.id} [${first.kind}]` +
-								(others.length ? ` — still waiting-able: ${others.join(", ")}` : "") +
-								`\n\n${first.text}`,
+									(others.length ? ` — still waiting-able: ${others.join(", ")}` : "") +
+									`\n\n${first.text}`,
+								multiResultMaxBytes,
+							),
 						},
 					],
 					isError: !first.ok,
@@ -2817,8 +3741,46 @@ export default function (pi: ExtensionAPI) {
 	// output + a copy-paste `babysit attach` take-over hint; running subagent →
 	// read-only progress; finished → summary. Re-run to refresh.
 	pi.registerCommand("babysit", {
-		description: "Pick a babysit session (↑/↓) to snapshot/inspect",
-		handler: async (_args, ctx) => {
+		description: "Pick a session to inspect, or `/babysit gc [days]` to remove old terminal roots",
+		handler: async (args, ctx) => {
+			const command = args.trim();
+			if (command === "gc" || command.startsWith("gc ")) {
+				const daysText = command.slice(2).trim();
+				const days = daysText ? Number(daysText) : 14;
+				if (!Number.isFinite(days) || days <= 0) {
+					ctx.ui.notify("Usage: /babysit gc [positive retention days]", "error");
+					return;
+				}
+				const options = {
+					rootBase: ROOT_BASE,
+					currentRoot: ROOT,
+					olderThanMs: days * 86_400_000,
+				};
+				const preview = gcBabysitRoots({ ...options, dryRun: true });
+				if (preview.candidates.length === 0) {
+					ctx.ui.notify(
+						`No terminal pi-babysit roots older than ${days} days are safe to remove.`,
+						"info",
+					);
+					return;
+				}
+				const confirmed = await ctx.ui.confirm(
+					"Remove old pi-babysit roots?",
+					`${preview.candidates.length} roots · ${preview.bytes} bytes · older than ${days} days\n` +
+						"Running supervisors and the current Pi session are excluded.",
+				);
+				if (!confirmed) return;
+				const removed = gcBabysitRoots({ ...options, dryRun: false });
+				ctx.ui.notify(
+					`Removed ${removed.deleted.length} pi-babysit roots (${removed.bytes} bytes).`,
+					"info",
+				);
+				return;
+			}
+			if (command) {
+				ctx.ui.notify("Usage: /babysit or /babysit gc [days]", "error");
+				return;
+			}
 			if (!(await babysitAvailable())) {
 				ctx.ui.notify(babysitPreflightError ?? INSTALL_HINT, "error");
 				return;
@@ -2860,16 +3822,15 @@ export default function (pi: ExtensionAPI) {
 			// Inline snapshot (running) or summary (finished) — no tmux window.
 			if (kind === "subagent") {
 				// Parse the RPC event stream and show the final answer, not raw JSONL.
-				const prog = parseEvents((await bs(["log", "-s", picked.id])).stdout);
+				const prog = taskProgressOf(picked.id).progress;
 				const stats =
-					`turns=${prog.turns} tools=${prog.toolCalls.length}` +
+					`turns=${prog.turns} calls=${prog.modelCalls} tools=${prog.toolCalls.length}` +
 					(prog.tokens != null ? ` ctx=${prog.tokens}` : "") +
-					(prog.cost != null ? ` $${prog.cost.toFixed(4)}` : "");
+					(prog.modelCalls > 0 ? ` usage=${prog.usageTokens} $${prog.cost.toFixed(4)}` : "");
 				const body =
 					(prog.finalText.trim() ||
 						prog.errorMsg ||
-						(await bs(["log", "-s", picked.id, "--tail", "20"])).stdout.trim() ||
-						"(no output)") +
+						`(no structured output; full log: ${logPath(picked.id)})`) +
 					(picked.state === "running"
 						? "\n\n_Live subagent (read-only). Re-run `/babysit` to refresh this snapshot._"
 						: "");