@yusukeshib/pi-babysit 0.6.4 → 0.6.5

package/README.md

@@ -56,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`/`notificationGroup`). Set `foreground: true` for one process or subagent whose result is needed in the same tool call; use `returnPattern`/`returnLines`/`maxBytes` to keep noisy process output bounded. Or start a named background subagent (`profile: "subagent"`, `task`, optional `name`/`agent`/`model`/`tools`/`maxDepth` and budget fields), then always collect it with `babysit_wait`. `maxDepth` defaults to 1. Subagent `continueAfterStart: true` is accepted as a compatibility alias for this default background behavior. Quick commands return inline; longer process runs notify in the background |
+| `babysit_run` | Run any command (`command`, optional `name`/`pty`/`timeout`/`idleTimeout`/`retryOnWorkerDeath`/`notificationGroup`/`lifecycle`). Set `foreground: true` for one process or subagent whose result is needed in the same tool call; use `returnPattern`/`returnLines`/`maxBytes` to keep noisy process output bounded. Foreground and non-interactive process waits default to lifecycle `attached`, which terminates the process tree if that owning tool call is interrupted; background starts default to `detached`. Or start a named background subagent (`profile: "subagent"`, `task`, optional `name`/`agent`/`model`/`tools`/`maxDepth` and budget fields), then always collect it with `babysit_wait`. `maxDepth` defaults to 1. Subagent `continueAfterStart: true` is accepted as a compatibility alias for this default background behavior. Quick commands return inline; longer process runs notify in the background |
 | `babysit_check` | Without an id, list sessions with state/kind filters. With an id, inspect bounded output, search with `pattern`, or capture a TUI with `screen: true`; `maxBytes` overrides the 4 KB default up to 24 KB |
 | `babysit_send` | Process: type `text` / press `keys` into the PTY. Subagent: steer mid-run, or send a follow-up task when confirmed settled (`mode: auto/steer/task`); explicit task mode rejects busy, parked, or unknown state |
 | `babysit_wait` | Block until done: process exit (or `expect: "regex"` readiness marker), subagent task completion. Multi-wait: up to 32 unique `ids` + `mode: "any"\|"all"` |
@@ -132,7 +132,20 @@ suite at the end. Background subagents must likewise be collected before the
 parent task finishes so their answer and nested usage are not lost.
 Set `PI_BABYSIT_ALLOW_BASH=1` only as an explicit emergency escape hatch.
 
-## Pi shutdown and reload
+## Process ownership, interruption, shutdown, and reload
+
+An inline process wait (`foreground: true`, or process execution in a non-UI
+mode) defaults to `lifecycle: "attached"`. If its owning `babysit_run` tool call
+is interrupted through Pi's AbortSignal, pi-babysit terminates the supervised
+process tree through the babysit session API and verifies persisted terminal
+state before returning. Set `lifecycle: "detached"` explicitly only when a
+foreground wait may be interrupted but the process must continue. Interactive
+background starts are detached; `lifecycle: "attached"` therefore requires
+`foreground: true` in interactive mode.
+
+An explicit `babysit_wait` is only a waiter, not the process owner. Interrupting
+it never terminates the process; call `babysit_kill` when termination is wanted.
+This cooperative policy does not claim to detect an abrupt host `SIGKILL`.
 
 A real Pi quit terminates every running process and subagent in the current Pi
 session namespace. The workers are killed concurrently, so shutdown time does

package/index.ts

@@ -43,7 +43,7 @@ import type {
 	ToolDefinition,
 } from "@earendil-works/pi-coding-agent";
 import { getMarkdownTheme } from "@earendil-works/pi-coding-agent";
-import { Box, Markdown, Text } from "@earendil-works/pi-tui";
+import { Box, Markdown, Text, truncateToWidth } from "@earendil-works/pi-tui";
 import { Type, type TSchema } from "typebox";
 import { StringEnum } from "@earendil-works/pi-ai";
 import { type AgentConfig, type AgentScope, discoverAgents } from "./agents";
@@ -1449,36 +1449,63 @@ export function deliverProcessCompletionMessage(
 // parked-turn detection (shared rule with self-reap.ts)
 // ---------------------------------------------------------------------------
 
-// A turn that ends right after `babysit_run { command }` only means "parked
-// awaiting the process-exit notification" — pi resumes it on its own; that is
-// NOT task completion. Such runs stamp NOTIFY_MARKER into their tool result,
-// so the marker in the LAST message's toolResult identifies a parked turn.
-// (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 isParkedMessages(
-	messages:
-		| {
-				role?: string;
-				toolName?: string;
-				content?: unknown;
-				details?: { kind?: string; status?: string };
-			}[]
-		| undefined,
-): boolean {
+// A turn that ends after `babysit_run { command }` can be parked awaiting an
+// automatic process-exit notification. A later terminal babysit_wait/kill for
+// that same id consumes the start, however, so it must not make a completed
+// subagent task look parked. (A subagent-profile run does not carry the marker.)
+// `process` is the legacy pi-processes tool and remains conservative because it
+// does not expose equivalent structured collection metadata.
+type ParkedMessage = {
+	role?: string;
+	toolName?: string;
+	content?: unknown;
+	details?: {
+		id?: string;
+		kind?: string;
+		status?: string | { id?: string; state?: string };
+		results?: Array<{ id?: string; kind?: string }>;
+		first?: { id?: string; kind?: string };
+	};
+};
+
+function isParkedMessages(messages: ParkedMessage[] | undefined): boolean {
 	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).
+	const terminalCounts = new Map<string, number>();
+	const addTerminal = (id: string) => terminalCounts.set(id, (terminalCounts.get(id) ?? 0) + 1);
+
+	// Walk backwards so only a terminal collection that occurred after a start
+	// can consume it. Counts preserve repeated starts that reuse the same id.
 	for (let i = messages.length - 1; i >= 0; i--) {
 		const message = messages[i];
 		if (message?.role !== "toolResult") continue;
+		if (message.toolName === "babysit_wait") {
+			const status = message.details?.status;
+			if (
+				status &&
+				typeof status === "object" &&
+				typeof status.id === "string" &&
+				typeof status.state === "string" &&
+				status.state !== "running"
+			) {
+				addTerminal(status.id);
+			}
+			for (const result of message.details?.results ?? []) {
+				if (result.kind === "exited" && typeof result.id === "string") addTerminal(result.id);
+			}
+			const first = message.details?.first;
+			if (first?.kind === "exited" && typeof first.id === "string") addTerminal(first.id);
+			continue;
+		}
+		if (
+			message.toolName === "babysit_kill" &&
+			typeof message.details?.id === "string" &&
+			["exited", "killed", "dead"].includes(String(message.details.status))
+		) {
+			addTerminal(message.details.id);
+			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 } =>
@@ -1489,7 +1516,16 @@ function isParkedMessages(
 			: typeof message.content === "string"
 				? message.content
 				: "";
-		if (/^Process started \(id: [^)]+\)\. \[notify-on-exit\]\nLog: /.test(text)) return true;
+		const textMatch = /^Process started \(id: ([^)]+)\)\. \[notify-on-exit\]\nLog: /.exec(text);
+		const structuredStart =
+			message.details?.kind === "process" && message.details.status === "started";
+		if (!structuredStart && !textMatch) continue;
+		const id = typeof message.details?.id === "string" ? message.details.id : textMatch?.[1];
+		if (!id) return true;
+		const count = terminalCounts.get(id) ?? 0;
+		if (count === 0) return true;
+		if (count === 1) terminalCounts.delete(id);
+		else terminalCounts.set(id, count - 1);
 	}
 	return false;
 }
@@ -1764,16 +1800,7 @@ function parseEventLine(progress: Progress, raw: string): void {
 			progress.lastEndWasProcessWait =
 				typeof event.piBabysitParked === "boolean"
 					? event.piBabysitParked
-					: isParkedMessages(
-							event.messages as
-								| {
-										role?: string;
-										toolName?: string;
-										content?: unknown;
-										details?: { kind?: string; status?: string };
-									}[]
-								| undefined,
-						);
+					: isParkedMessages(event.messages as ParkedMessage[] | undefined);
 			break;
 		}
 		case "agent_settled":
@@ -2319,9 +2346,74 @@ function renderWidgetSessionHeader(
 }
 
 // How many trailing output lines to show per running session in the widget.
-const WIDGET_TAIL_LINES = 1;
+const WIDGET_COLLAPSED_TAIL_LINES = 1;
+const WIDGET_EXPANDED_TAIL_LINES = 20;
 const WIDGET_TAIL_WIDTH = 100;
 
+export interface WidgetSessionDisplay {
+	id: string;
+	header: string;
+	tail: string[];
+	expandable: boolean;
+}
+
+interface WidgetMouseEvent {
+	type: string;
+	button: string;
+	y: number;
+}
+
+/**
+ * Build the live widget as a mouse-aware component without depending on newer
+ * pi-tui mouse classes. Older hosts still render it normally; fullscreen hosts
+ * dispatch component-local click coordinates to handleMouse.
+ */
+export function createWidgetComponent(
+	summaryLines: string[],
+	sessions: WidgetSessionDisplay[],
+	expandedProcessIds: Set<string>,
+) {
+	let processIdByLine: Array<string | undefined> = [];
+
+	return {
+		render(width: number): string[] {
+			const lines: string[] = [];
+			processIdByLine = [];
+			const push = (text: string, processId?: string) => {
+				lines.push(truncateToWidth(text, Math.max(0, width), ""));
+				processIdByLine.push(processId);
+			};
+
+			for (const line of summaryLines) push(line);
+			for (const session of sessions) {
+				const expanded = session.expandable && expandedProcessIds.has(session.id);
+				const tail = session.tail.slice(
+					expanded ? -WIDGET_EXPANDED_TAIL_LINES : -WIDGET_COLLAPSED_TAIL_LINES,
+				);
+				const processId = session.expandable ? session.id : undefined;
+				if (!expanded && tail.length === 1) {
+					push(`${session.header} ${tail[0]}`, processId);
+				} else {
+					push(session.header, processId);
+					for (const line of tail) push(`      ${line}`, processId);
+				}
+			}
+			return lines;
+		},
+		handleMouse(event: WidgetMouseEvent) {
+			if (event.type !== "click" || event.button !== "left") return undefined;
+			const id = processIdByLine[event.y];
+			if (!id) return undefined;
+			if (expandedProcessIds.has(id)) expandedProcessIds.delete(id);
+			else expandedProcessIds.add(id);
+			return { handled: true, render: true };
+		},
+		invalidate() {
+			processIdByLine = [];
+		},
+	};
+}
+
 // Strip ANSI/control escapes and clamp width so raw PTY output can't wrap or
 // corrupt the widget area.
 function sanitizeTailLine(s: string): string {
@@ -2369,10 +2461,11 @@ async function widgetTail(
 	id: string,
 	isSub: boolean,
 	subagentProgress?: Progress,
+	lines = WIDGET_COLLAPSED_TAIL_LINES,
 ): Promise<string[]> {
 	let raw: string[];
 	if (!isSub) {
-		raw = readTailLines(logPath(id), WIDGET_TAIL_LINES);
+		raw = readTailLines(logPath(id), lines);
 	} else {
 		const progress = subagentProgress ?? taskProgressOf(id).progress;
 		if (progress.finalText.trim()) {
@@ -2386,7 +2479,7 @@ async function widgetTail(
 	return raw
 		.map(sanitizeTailLine)
 		.filter((line) => line.trim().length > 0)
-		.slice(-WIDGET_TAIL_LINES);
+		.slice(-lines);
 }
 
 // ---------------------------------------------------------------------------
@@ -2413,6 +2506,63 @@ interface WaitOutcome {
 	progress?: Progress;
 }
 
+export type ProcessLifecycle = "attached" | "detached";
+
+export function resolveProcessLifecycle(
+	requested: ProcessLifecycle | undefined,
+	waitsInline: boolean,
+): ProcessLifecycle {
+	return requested ?? (waitsInline ? "attached" : "detached");
+}
+
+async function terminateAttachedProcessAfterInterrupt(id: string): Promise<WaitOutcome> {
+	const killed = await bs(["kill", "-s", id, "--json"]);
+	const backendError =
+		killed.code === 0
+			? validateKillResponse(killed.stdout)
+			: killed.stderr.trim() || killed.stdout.trim() || `babysit kill exited ${killed.code}`;
+	const status = await awaitConfirmedTermination(id);
+	const confirmation = resolveKillConfirmation(id, backendError, status?.state);
+	if (!confirmation.confirmed) {
+		return {
+			id,
+			kind: "interrupted",
+			ok: false,
+			text:
+				`Foreground process ${id} was interrupted, but attached lifecycle termination could not be verified: ${confirmation.error}\n` +
+				`Log: ${logPath(id)}`,
+			status,
+		};
+	}
+
+	// The interrupted owning call reports the termination, so the background
+	// poller must not emit a second completion notification.
+	suppressNotify(id, "kill");
+	return {
+		id,
+		kind: "interrupted",
+		ok: false,
+		text:
+			`Foreground process ${id} was interrupted; attached lifecycle cleanup confirmed terminal state.` +
+			(confirmation.warning ? ` Backend warning: ${confirmation.warning}` : "") +
+			`\nLog: ${logPath(id)}`,
+		status,
+	};
+}
+
+async function waitForProcessWithLifecycle(
+	id: string,
+	signal: AbortSignal | undefined,
+	lifecycle: ProcessLifecycle,
+	outputSelection?: ProcessOutputSelection,
+): Promise<WaitOutcome> {
+	const outcome = await waitForExit(id, null, signal, undefined, outputSelection);
+	if (lifecycle !== "attached" || !signal?.aborted || outcome.kind !== "interrupted") {
+		return outcome;
+	}
+	return terminateAttachedProcessAfterInterrupt(id);
+}
+
 export interface NestedUsage {
 	input: number;
 	output: number;
@@ -3215,6 +3365,8 @@ export default function (pi: ExtensionAPI) {
 		}
 	}
 
+	const expandedWidgetProcesses = new Set<string>();
+
 	const refreshWidget = async (ctx: ExtensionContext, snapshot?: BsSession[]) => {
 		if (!ctx.hasUI) return;
 		const active = (snapshot ?? (await listSessions()).sessions).filter(
@@ -3231,8 +3383,15 @@ export default function (pi: ExtensionAPI) {
 			}
 		}
 		const idle = subs.filter((session) => progressById.get(session.id)?.done).length;
+		const activeProcessIds = new Set(
+			active.filter((session) => kindOf(session.id) !== "subagent").map((session) => session.id),
+		);
+		for (const id of expandedWidgetProcesses) {
+			if (!activeProcessIds.has(id)) expandedWidgetProcesses.delete(id);
+		}
+
 		const theme = ctx.ui.theme;
-		const lines = renderWidgetLines(procs, subs.length - idle, idle, theme);
+		const summaryLines = renderWidgetLines(procs, subs.length - idle, idle, theme);
 		const tails = await Promise.all(
 			active.map((session) => {
 				const isSubagent = kindOf(session.id) === "subagent";
@@ -3240,30 +3399,41 @@ export default function (pi: ExtensionAPI) {
 					session.id,
 					isSubagent,
 					isSubagent ? progressById.get(session.id) : undefined,
+					isSubagent ? WIDGET_COLLAPSED_TAIL_LINES : WIDGET_EXPANDED_TAIL_LINES,
 				);
 			}),
 		);
-		active.forEach((session, index) => {
+		const displays = active.map((session, index): WidgetSessionDisplay => {
 			const isSubagent = kindOf(session.id) === "subagent";
 			const state: WidgetSessionState = isSubagent && progressById.get(session.id)?.done
 				? "idle"
 				: "running";
-			const elapsed = elapsedOf(session.id);
-			const header = renderWidgetSessionHeader(
-				session.id,
-				isSubagent ? "agent" : "process",
-				state,
-				elapsed,
-				theme,
-			);
-			if (tails[index].length === 1) {
-				lines.push(`${header} ${tails[index][0]}`);
-			} else {
-				lines.push(header);
-				for (const tail of tails[index]) lines.push(`      ${tail}`);
-			}
+			return {
+				id: session.id,
+				header: renderWidgetSessionHeader(
+					session.id,
+					isSubagent ? "agent" : "process",
+					state,
+					elapsedOf(session.id),
+					theme,
+				),
+				tail: tails[index],
+				expandable: !isSubagent,
+			};
 		});
-		ctx.ui.setWidget("pi-babysit", lines, { placement: "belowEditor" });
+
+		if (ctx.mode === "tui") {
+			ctx.ui.setWidget(
+				"pi-babysit",
+				() => createWidgetComponent(summaryLines, displays, expandedWidgetProcesses),
+				{ placement: "belowEditor" },
+			);
+		} else {
+			const component = createWidgetComponent(summaryLines, displays, new Set());
+			ctx.ui.setWidget("pi-babysit", component.render(10_000), {
+				placement: "belowEditor",
+			});
+		}
 	};
 
 	type DisplayStatus = "started" | "running" | "idle" | "success" | "failed" | "terminated";
@@ -3603,6 +3773,12 @@ export default function (pi: ExtensionAPI) {
 					description: "Process or subagent: wait for completion and return the result in this tool call.",
 				}),
 			),
+			lifecycle: Type.Optional(
+				StringEnum(["attached", "detached"] as const, {
+					description:
+						"Process mode only. attached terminates the process tree if the owning inline babysit_run wait is interrupted; detached leaves it running. Defaults to attached for foreground/non-interactive waits and detached for background starts.",
+				}),
+			),
 			returnPattern: Type.Optional(
 				Type.String({ description: "Foreground/quick process: return only latest regex matches." }),
 			),
@@ -3675,6 +3851,20 @@ export default function (pi: ExtensionAPI) {
 					details: {},
 				};
 			}
+			if (isSubagent && params.lifecycle) {
+				return {
+					content: [{ type: "text", text: "`lifecycle` is available only in process mode." }],
+					isError: true,
+					details: {},
+				};
+			}
+			if (!isSubagent && params.lifecycle === "attached" && ctx.hasUI && !params.foreground) {
+				return {
+					content: [{ type: "text", text: "`lifecycle: attached` requires `foreground: true` in interactive process mode." }],
+					isError: true,
+					details: {},
+				};
+			}
 			if (isSubagent && (params.returnPattern || params.returnLines != null || params.maxBytes != null)) {
 				return {
 					content: [{ type: "text", text: "`returnPattern`, `returnLines`, and `maxBytes` are process-output options." }],
@@ -3705,6 +3895,8 @@ export default function (pi: ExtensionAPI) {
 
 			// --- process mode ---
 			if (!isSubagent) {
+				const waitsInline = !ctx.hasUI || params.foreground === true;
+				const lifecycle = resolveProcessLifecycle(params.lifecycle, waitsInline);
 				if (params.returnPattern) {
 					try {
 						new RegExp(params.returnPattern);
@@ -3746,19 +3938,19 @@ export default function (pi: ExtensionAPI) {
 				// result in interactive mode, avoiding a separate babysit_wait model turn.
 				// The command remains supervised, logged, killable, and subject to its
 				// babysit timeout in either case.
-				if (!ctx.hasUI || params.foreground) {
+				if (waitsInline) {
 					// The babysit supervisor owns the absolute command timeout. Waiting with
 					// the same deadline here races its terminal-state write and can return a
 					// false "still running" result at the boundary, so wait for the
 					// supervisor's definitive exit instead.
-					let outcome = await waitForExit(res.id, null, _signal, undefined, outputSelection);
+					let outcome = await waitForProcessWithLifecycle(res.id, _signal, lifecycle, outputSelection);
 					let retried = false;
 					if (params.retryOnWorkerDeath && outcome.status?.state === "dead" && outcome.status.exit_code == null) {
 						const retry = await spawnProcess(spawnOpts);
 						if (!("error" in retry)) {
 							res = retry;
 							retried = true;
-							outcome = await waitForExit(res.id, null, _signal, undefined, outputSelection);
+							outcome = await waitForProcessWithLifecycle(res.id, _signal, lifecycle, outputSelection);
 						}
 					}
 					if (ctx.hasUI) await refreshWidget(ctx);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yusukeshib/pi-babysit",
-  "version": "0.6.4",
+  "version": "0.6.5",
   "description": "Run any shell command and pi subagents under babysit, with context-safe captured output.",
   "keywords": [
     "pi-package",

package/rpc-stream-proxy.mjs

@@ -19,14 +19,40 @@ import { pathToFileURL } from "node:url";
 
 function isParkedMessages(messages) {
 	if (!Array.isArray(messages)) return false;
+	const terminalCounts = new Map();
+	const addTerminal = (id) => terminalCounts.set(id, (terminalCounts.get(id) ?? 0) + 1);
+
 	for (let index = messages.length - 1; index >= 0; index--) {
 		const message = messages[index];
 		if (message?.role !== "toolResult") continue;
+		if (message.toolName === "babysit_wait") {
+			const status = message.details?.status;
+			if (
+				status &&
+				typeof status === "object" &&
+				typeof status.id === "string" &&
+				typeof status.state === "string" &&
+				status.state !== "running"
+			) {
+				addTerminal(status.id);
+			}
+			for (const result of message.details?.results ?? []) {
+				if (result.kind === "exited" && typeof result.id === "string") addTerminal(result.id);
+			}
+			const first = message.details?.first;
+			if (first?.kind === "exited" && typeof first.id === "string") addTerminal(first.id);
+			continue;
+		}
+		if (
+			message.toolName === "babysit_kill" &&
+			typeof message.details?.id === "string" &&
+			["exited", "killed", "dead"].includes(String(message.details.status))
+		) {
+			addTerminal(message.details.id);
+			continue;
+		}
 		if (message.toolName === "process") return true;
 		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?.type === "text" && typeof part.text === "string")
@@ -35,9 +61,16 @@ function isParkedMessages(messages) {
 			: typeof message.content === "string"
 				? message.content
 				: "";
-		if (/^Process started \(id: [^)]+\)\. \[notify-on-exit\]\nLog: /.test(text)) {
-			return true;
-		}
+		const textMatch = /^Process started \(id: ([^)]+)\)\. \[notify-on-exit\]\nLog: /.exec(text);
+		const structuredStart =
+			message.details?.kind === "process" && message.details.status === "started";
+		if (!structuredStart && !textMatch) continue;
+		const id = typeof message.details?.id === "string" ? message.details.id : textMatch?.[1];
+		if (!id) return true;
+		const count = terminalCounts.get(id) ?? 0;
+		if (count === 0) return true;
+		if (count === 1) terminalCounts.delete(id);
+		else terminalCounts.set(id, count - 1);
 	}
 	return false;
 }

package/self-reap.ts

@@ -36,25 +36,55 @@ function parseDurMs(s: string | undefined): number | null {
 
 // Same parked-turn rule as the parent: scan the run because models sometimes
 // add an assistant note after the marker-bearing tool result.
-export function isParked(
-	messages:
-		| {
-				role?: string;
-				toolName?: string;
-				content?: unknown;
-				details?: { kind?: string; status?: string };
-			}[]
-		| undefined,
-): boolean {
+type ParkedMessage = {
+	role?: string;
+	toolName?: string;
+	content?: unknown;
+	details?: {
+		id?: string;
+		kind?: string;
+		status?: string | { id?: string; state?: string };
+		results?: Array<{ id?: string; kind?: string }>;
+		first?: { id?: string; kind?: string };
+	};
+};
+
+export function isParked(messages: ParkedMessage[] | undefined): boolean {
 	if (!messages) return false;
+	const terminalCounts = new Map<string, number>();
+	const addTerminal = (id: string) => terminalCounts.set(id, (terminalCounts.get(id) ?? 0) + 1);
+
 	for (let index = messages.length - 1; index >= 0; index--) {
 		const message = messages[index];
 		if (message?.role !== "toolResult") continue;
+		if (message.toolName === "babysit_wait") {
+			const status = message.details?.status;
+			if (
+				status &&
+				typeof status === "object" &&
+				typeof status.id === "string" &&
+				typeof status.state === "string" &&
+				status.state !== "running"
+			) {
+				addTerminal(status.id);
+			}
+			for (const result of message.details?.results ?? []) {
+				if (result.kind === "exited" && typeof result.id === "string") addTerminal(result.id);
+			}
+			const first = message.details?.first;
+			if (first?.kind === "exited" && typeof first.id === "string") addTerminal(first.id);
+			continue;
+		}
+		if (
+			message.toolName === "babysit_kill" &&
+			typeof message.details?.id === "string" &&
+			["exited", "killed", "dead"].includes(String(message.details.status))
+		) {
+			addTerminal(message.details.id);
+			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 } =>
@@ -65,7 +95,16 @@ export function isParked(
 			: typeof message.content === "string"
 				? message.content
 				: "";
-		if (/^Process started \(id: [^)]+\)\. \[notify-on-exit\]\nLog: /.test(text)) return true;
+		const textMatch = /^Process started \(id: ([^)]+)\)\. \[notify-on-exit\]\nLog: /.exec(text);
+		const structuredStart =
+			message.details?.kind === "process" && message.details.status === "started";
+		if (!structuredStart && !textMatch) continue;
+		const id = typeof message.details?.id === "string" ? message.details.id : textMatch?.[1];
+		if (!id) return true;
+		const count = terminalCounts.get(id) ?? 0;
+		if (count === 0) return true;
+		if (count === 1) terminalCounts.delete(id);
+		else terminalCounts.set(id, count - 1);
 	}
 	return false;
 }
@@ -92,9 +131,7 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	pi.on("agent_end", (event) => {
-		const messages = (
-			event as { messages?: { role?: string; toolName?: string; content?: unknown }[] }
-		).messages;
+		const messages = (event as { messages?: ParkedMessage[] }).messages;
 		lastEndWasParked = isParked(messages);
 	});