@yusukeshib/pi-babysit 0.6.4 → 0.6.6

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"` |
@@ -80,8 +80,14 @@ backgrounding (`… &`, `nohup`, `setsid`, `disown`). Set
 
 A widget below the editor separates session **kind** from task **state** at a glance:
 summary counts use `RUNNING` / `IDLE`, and every row is labeled
-`PROCESS RUNNING`, `AGENT RUNNING`, or `AGENT IDLE`. The displayed `age`
-is total session age, not time spent in the current state. Transcript details
+`PROCESS RUNNING`, `AGENT RUNNING`, or `AGENT IDLE`. In fullscreen mode, click
+any live row to toggle between its latest line and latest 20 available output
+lines. Finished sessions are behind a clickable `FINISHED` row; browse all
+retained sessions five at a time and click a row to expand it, including failed
+processes and agents. A session with no available output shows an explicit
+placeholder when expanded. Mouse clicks require fullscreen mode; `/babysit`
+works in regular mode. The displayed `age` is total session age, not time spent
+in the current state. Transcript details
 from tool results, snapshots, and completion notifications collapse or expand
 with Pi's tool-output toggle (`Ctrl+O` by default).
 
@@ -132,7 +138,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":
@@ -2260,14 +2287,23 @@ async function spawnSubagent(
 }
 
 // ---------------------------------------------------------------------------
-// widget (live counts)
+// widget (live counts and browsable finished sessions)
 // ---------------------------------------------------------------------------
 
+export function widgetSessionGroups(sessions: BsSession[], startedAt: (id: string) => number) {
+	const active = sessions.filter((session) => session.state === "running");
+	// Default view stays compact; the finished section pages over every retained session.
+	const finished = sessions.filter((session) => session.state !== "running");
+	const started = new Map(finished.map((session) => [session.id, startedAt(session.id)]));
+	finished.sort((a, b) => (started.get(b.id) ?? 0) - (started.get(a.id) ?? 0) || b.id.localeCompare(a.id));
+	return { active, finished };
+}
+
 // A subagent whose task is done stays alive as an idle RPC worker (for
 // follow-ups), so "running" in babysit does NOT mean "working" — count
 // processes / busy subagents / idle subagents separately.
 export type WidgetSessionKind = "process" | "agent";
-export type WidgetSessionState = "running" | "idle";
+export type WidgetSessionState = "running" | "idle" | "finished" | "failed";
 
 export function widgetSummaryText(procs: number, busy: number, idle: number): string {
 	const sections: string[] = [];
@@ -2285,7 +2321,7 @@ export function widgetSessionHeader(
 	state: WidgetSessionState,
 	elapsed?: string,
 ): string {
-	const icon = state === "running" ? "▶" : "○";
+	const icon = state === "running" ? "▶" : state === "failed" ? "✗" : "○";
 	return `  ${icon} ${id} ${kind.toUpperCase()} ${state.toUpperCase()}${elapsed ? ` age ${elapsed}` : ""}`;
 }
 
@@ -2311,16 +2347,121 @@ function renderWidgetSessionHeader(
 	elapsed: string,
 	theme: Theme,
 ): string {
-	const running = state === "running";
-	const icon = theme.fg(running ? "success" : "muted", running ? "▶" : "○");
+	const color = state === "running" ? "success" : state === "failed" ? "error" : "muted";
+	const icon = theme.fg(color, state === "running" ? "▶" : state === "failed" ? "✗" : "○");
 	const kindLabel = theme.fg(kind === "process" ? "accent" : "warning", theme.bold(kind.toUpperCase()));
-	const stateLabel = theme.fg(running ? "success" : "muted", theme.bold(state.toUpperCase()));
+	const stateLabel = theme.fg(color, theme.bold(state.toUpperCase()));
 	return `  ${icon} ${id} ${kindLabel} ${stateLabel}${elapsed ? theme.fg("dim", ` age ${elapsed}`) : ""}`;
 }
 
-// How many trailing output lines to show per running session in the widget.
-const WIDGET_TAIL_LINES = 1;
+// How many trailing output lines to show per session in the widget.
+const WIDGET_COLLAPSED_TAIL_LINES = 1;
+const WIDGET_EXPANDED_TAIL_LINES = 20;
 const WIDGET_TAIL_WIDTH = 100;
+const WIDGET_FINISHED_PAGE_SIZE = 5;
+
+export interface WidgetFinishedState {
+	open: boolean;
+	page: number;
+}
+
+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[],
+	expandedSessionIds: Set<string>,
+	finished?: { sessions: WidgetSessionDisplay[]; state: WidgetFinishedState },
+) {
+	type Target = { type: "session"; id: string } | { type: "finished" | "prev" | "next" };
+	let targetByLine: Array<Target | undefined> = [];
+
+	return {
+		render(width: number): string[] {
+			const lines: string[] = [];
+			targetByLine = [];
+			const push = (text: string, target?: Target) => {
+				lines.push(truncateToWidth(text, Math.max(0, width), ""));
+				targetByLine.push(target);
+			};
+			const pushSession = (session: WidgetSessionDisplay) => {
+				const expanded = session.expandable && expandedSessionIds.has(session.id);
+				const tail = session.tail.slice(
+					expanded ? -WIDGET_EXPANDED_TAIL_LINES : -WIDGET_COLLAPSED_TAIL_LINES,
+				);
+				const target = session.expandable ? { type: "session" as const, id: session.id } : undefined;
+				if (!expanded && tail.length === 1) {
+					push(`${session.header} ${tail[0]}`, target);
+				} else {
+					push(session.header, target);
+					for (const line of tail) push(`      ${line}`, target);
+					if (expanded && tail.length === 0) push("      (no output available)", target);
+				}
+			};
+
+			for (const line of summaryLines) push(line);
+			if (finished?.sessions.length) {
+				const pageCount = Math.ceil(finished.sessions.length / WIDGET_FINISHED_PAGE_SIZE);
+				finished.state.page = Math.min(Math.max(0, finished.state.page), pageCount - 1);
+				push(
+					` FINISHED ${finished.sessions.length} — ${finished.state.open ? "hide" : "browse"} (click)`,
+					{ type: "finished" },
+				);
+				if (finished.state.open) {
+					if (pageCount > 1) {
+						if (finished.state.page > 0) push("  ← Previous", { type: "prev" });
+						push(`  ${finished.state.page === pageCount - 1 ? "↻ First" : "Next →"} (${finished.state.page + 1}/${pageCount})`, { type: "next" });
+					}
+					const start = finished.state.page * WIDGET_FINISHED_PAGE_SIZE;
+					for (const session of finished.sessions.slice(start, start + WIDGET_FINISHED_PAGE_SIZE)) {
+						pushSession(session);
+					}
+				}
+			}
+			for (const session of sessions) pushSession(session);
+			return lines;
+		},
+		handleMouse(event: WidgetMouseEvent) {
+			if (event.button !== "left") return undefined;
+			const target = targetByLine[event.y];
+			if (!target) return undefined;
+			// Toggle on press so a terminal that omits release still works.
+			if (event.type === "press") {
+				if (target.type === "session") {
+					if (expandedSessionIds.has(target.id)) expandedSessionIds.delete(target.id);
+					else expandedSessionIds.add(target.id);
+				} else if (finished) {
+					if (target.type === "finished") finished.state.open = !finished.state.open;
+					else if (target.type === "prev") finished.state.page--;
+					else finished.state.page = (finished.state.page + 1) % Math.ceil(finished.sessions.length / WIDGET_FINISHED_PAGE_SIZE);
+				}
+				return { handled: true, render: true };
+			}
+			// Consume Pi's synthesized click without toggling a second time.
+			if (event.type === "click") return { handled: true, render: false };
+			return undefined;
+		},
+		invalidate() {
+			targetByLine = [];
+		},
+	};
+}
 
 // Strip ANSI/control escapes and clamp width so raw PTY output can't wrap or
 // corrupt the widget area.
@@ -2362,20 +2503,23 @@ function readTailLines(file: string, lines: number, maxBytes = 64_000): string[]
 	}
 }
 
-// Trailing lines to show for a running session (sanitized, unprefixed).
+// Trailing lines to show for a session (sanitized, unprefixed).
 // Process tails are read directly from the bounded end of output.log, avoiding
-// one `babysit log` subprocess per active process on every poll.
-async function widgetTail(
+// one `babysit log` subprocess per visible process.
+export function widgetTail(
 	id: string,
 	isSub: boolean,
 	subagentProgress?: Progress,
-): Promise<string[]> {
+	lines = WIDGET_COLLAPSED_TAIL_LINES,
+): 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()) {
+		if (progress.streamingText.trim()) {
+			raw = progress.streamingText.trim().split("\n");
+		} else if (progress.finalText.trim()) {
 			raw = progress.finalText.trim().split("\n");
 		} else if (progress.toolCalls.length > 0) {
 			raw = progress.toolCalls.map((tool) => tool.summary);
@@ -2386,7 +2530,7 @@ async function widgetTail(
 	return raw
 		.map(sanitizeTailLine)
 		.filter((line) => line.trim().length > 0)
-		.slice(-WIDGET_TAIL_LINES);
+		.slice(-lines);
 }
 
 // ---------------------------------------------------------------------------
@@ -2413,6 +2557,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,11 +3416,13 @@ export default function (pi: ExtensionAPI) {
 		}
 	}
 
+	const expandedWidgetSessions = new Set<string>();
+	const finishedWidgetState: WidgetFinishedState = { open: false, page: 0 };
+
 	const refreshWidget = async (ctx: ExtensionContext, snapshot?: BsSession[]) => {
 		if (!ctx.hasUI) return;
-		const active = (snapshot ?? (await listSessions()).sessions).filter(
-			(session) => session.state === "running",
-		);
+		const all = snapshot ?? (await listSessions()).sessions;
+		const { active, finished } = widgetSessionGroups(all, (id) => readMeta(id)?.startedAt ?? 0);
 		const subs = active.filter((session) => kindOf(session.id) === "subagent");
 		const procs = active.length - subs.length;
 		const progressById = new Map<string, Progress>();
@@ -3231,8 +3434,13 @@ export default function (pi: ExtensionAPI) {
 			}
 		}
 		const idle = subs.filter((session) => progressById.get(session.id)?.done).length;
+		const sessionIds = new Set(all.map((session) => session.id));
+		for (const id of expandedWidgetSessions) {
+			if (!sessionIds.has(id)) expandedWidgetSessions.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 +3448,67 @@ export default function (pi: ExtensionAPI) {
 					session.id,
 					isSubagent,
 					isSubagent ? progressById.get(session.id) : undefined,
+					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: true,
+			};
+		});
+		const finishedDisplays = finished.map((session): WidgetSessionDisplay => {
+			const isSubagent = kindOf(session.id) === "subagent";
+			const id = session.id;
+			return {
+				id,
+				header: renderWidgetSessionHeader(
+					id,
+					isSubagent ? "agent" : "process",
+					session.state === "exited" && session.exit_code === 0 ? "finished" : "failed",
+					"",
+					theme,
+				),
+				// Only read/parse the five visible finished sessions on demand.
+				get tail() {
+					try {
+						return widgetTail(id, isSubagent, undefined, WIDGET_EXPANDED_TAIL_LINES);
+					} catch {
+						return [];
+					}
+				},
+				expandable: true,
+			};
 		});
-		ctx.ui.setWidget("pi-babysit", lines, { placement: "belowEditor" });
+
+		if (ctx.mode === "tui") {
+			ctx.ui.setWidget(
+				"pi-babysit",
+				() => createWidgetComponent(summaryLines, displays, expandedWidgetSessions, {
+					sessions: finishedDisplays,
+					state: finishedWidgetState,
+				}),
+				{ 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 +3848,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 +3926,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 +3970,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 +4013,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.6",
   "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);
 	});