@yusukeshib/pi-babysit 0.5.0 → 0.6.1

package/README.md

@@ -75,8 +75,10 @@ re-enables `bash`, including shell backgrounding (`… &`, `nohup`, `setsid`,
 | `/babysit` | Arrow-key picker over all sessions. Renders an **inline snapshot** (no tmux): running **process** → current rendered screen + recent output + a copy-paste `babysit attach` take-over hint (detach `Ctrl-\ Ctrl-\`); running **subagent** → read-only progress (RPC stdin stays untouchable); finished → summary. Re-run `/babysit` to refresh |
 | `/babysit gc [days]` | Preview and confirm deletion of old Pi-session roots (default 14 days). Active leases, live supervisor/child PIDs, unknown states, the current root, and recent roots are retained; deletion uses a GC lock and atomic rename |
 
-A minimal widget above the editor shows live counts
-(`N processes · M subagents working · K idle`).
+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.
 
 ## Logs without context flooding
 
@@ -125,6 +127,14 @@ 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
+
+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
+not grow linearly when many sessions are active. Lifecycle transitions that keep
+Pi running—`/reload`, `/new`, `/resume`, and `/fork`—leave detached workers
+alone. Reloading or resuming the same Pi session reconnects to its namespace.
+
 ## Unexpected worker loss
 
 If the babysit supervisor disappears without recording an exit, pi-babysit

package/index.ts

@@ -367,6 +367,35 @@ async function awaitConfirmedTermination(id: string): Promise<BsSession | null>
 	return statusOf(id);
 }
 
+export function shouldTerminateSessionsOnShutdown(reason: string | undefined): boolean {
+	return reason === "quit";
+}
+
+async function terminateRunningSessions(): Promise<void> {
+	let listed: Awaited<ReturnType<typeof listSessions>>;
+	try {
+		listed = await listSessions();
+	} catch {
+		return;
+	}
+	if (listed.error) return;
+
+	// A namespace may contain many independent commands and agents. Terminate
+	// them concurrently so quitting Pi does not wait for serial kill timeouts.
+	// allSettled ensures one unreachable worker cannot skip cleanup for others.
+	await Promise.allSettled(
+		listed.sessions
+			.filter((session) => session.state === "running")
+			.map(async (session) => {
+				const result = await bs(["kill", "-s", session.id, "--json"]);
+				if (result.code !== 0 || validateKillResponse(result.stdout)) return;
+				// A later resume of this Pi session must not turn intentional shutdown
+				// cleanup into a process-completion notification.
+				suppressNotify(session.id, "kill");
+			}),
+	);
+}
+
 // ---------------------------------------------------------------------------
 // per-session metadata
 // ---------------------------------------------------------------------------
@@ -2188,13 +2217,56 @@ async function spawnSubagent(
 // 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.
-function renderWidgetLines(procs: number, busy: number, idle: number): string[] {
+export type WidgetSessionKind = "process" | "agent";
+export type WidgetSessionState = "running" | "idle";
+
+export function widgetSummaryText(procs: number, busy: number, idle: number): string {
+	const sections: string[] = [];
+	const running: string[] = [];
+	if (procs > 0) running.push(`${procs} process${procs > 1 ? "es" : ""}`);
+	if (busy > 0) running.push(`${busy} agent${busy > 1 ? "s" : ""}`);
+	if (running.length > 0) sections.push(`RUNNING  ${running.join(" · ")}`);
+	if (idle > 0) sections.push(`IDLE  ${idle} agent${idle > 1 ? "s" : ""}`);
+	return sections.join("  │  ");
+}
+
+export function widgetSessionHeader(
+	id: string,
+	kind: WidgetSessionKind,
+	state: WidgetSessionState,
+	elapsed?: string,
+): string {
+	const icon = state === "running" ? "▶" : "○";
+	return `  ${icon} ${id}  [${kind.toUpperCase()}] [${state.toUpperCase()}]${elapsed ? ` · age ${elapsed}` : ""}`;
+}
+
+function renderWidgetLines(procs: number, busy: number, idle: number, theme: Theme): string[] {
 	if (procs === 0 && busy === 0 && idle === 0) return [];
-	const parts: string[] = [];
-	if (procs > 0) parts.push(`${procs} process${procs > 1 ? "es" : ""}`);
-	if (busy > 0) parts.push(`${busy} subagent${busy > 1 ? "s" : ""} working`);
-	if (idle > 0) parts.push(`${idle} idle`);
-	return [`\x1b[44;97m ${parts.join(" \u00b7 ")} \x1b[0m`];
+	const sections: string[] = [];
+	const running: string[] = [];
+	if (procs > 0) running.push(`${procs} process${procs > 1 ? "es" : ""}`);
+	if (busy > 0) running.push(`${busy} agent${busy > 1 ? "s" : ""}`);
+	if (running.length > 0) {
+		sections.push(`${theme.fg("success", theme.bold("RUNNING"))}  ${running.join(" · ")}`);
+	}
+	if (idle > 0) {
+		sections.push(`${theme.fg("muted", theme.bold("IDLE"))}  ${idle} agent${idle > 1 ? "s" : ""}`);
+	}
+	return [theme.bg("toolPendingBg", ` ${sections.join("  │  ")} `)];
+}
+
+function renderWidgetSessionHeader(
+	id: string,
+	kind: WidgetSessionKind,
+	state: WidgetSessionState,
+	elapsed: string,
+	theme: Theme,
+): string {
+	const running = state === "running";
+	const icon = theme.fg(running ? "success" : "muted", running ? "▶" : "○");
+	const kindLabel = theme.fg(kind === "process" ? "accent" : "warning", theme.bold(`[${kind.toUpperCase()}]`));
+	const stateLabel = theme.fg(running ? "success" : "muted", 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.
@@ -3095,7 +3167,8 @@ export default function (pi: ExtensionAPI) {
 			}
 		}
 		const idle = subs.filter((session) => progressById.get(session.id)?.done).length;
-		const lines = renderWidgetLines(procs, subs.length - idle, idle);
+		const theme = ctx.ui.theme;
+		const lines = renderWidgetLines(procs, subs.length - idle, idle, theme);
 		const tails = await Promise.all(
 			active.map((session) => {
 				const isSubagent = kindOf(session.id) === "subagent";
@@ -3108,11 +3181,17 @@ export default function (pi: ExtensionAPI) {
 		);
 		active.forEach((session, index) => {
 			const isSubagent = kindOf(session.id) === "subagent";
-			const tag = isSubagent
-				? progressById.get(session.id)?.done ? "sub idle" : "sub"
-				: "proc";
+			const state: WidgetSessionState = isSubagent && progressById.get(session.id)?.done
+				? "idle"
+				: "running";
 			const elapsed = elapsedOf(session.id);
-			const header = `  ⏳ ${session.id} [${tag}]${elapsed ? ` ${elapsed}` : ""}`;
+			const header = renderWidgetSessionHeader(
+				session.id,
+				isSubagent ? "agent" : "process",
+				state,
+				elapsed,
+				theme,
+			);
 			if (tails[index].length === 1) {
 				lines.push(`${header}  │ ${tails[index][0]}`);
 			} else {
@@ -3288,9 +3367,15 @@ export default function (pi: ExtensionAPI) {
 		}, POLL_MS);
 	});
 
-	pi.on("session_shutdown", async () => {
+	pi.on("session_shutdown", async (event) => {
 		if (pollTimer) clearInterval(pollTimer);
 		pollTimer = undefined;
+		// Pi also emits session_shutdown while hot-reloading and switching sessions.
+		// Preserve detached work for those lifecycle transitions; only a real Pi
+		// quit owns and terminates every worker in the current session namespace.
+		if (shouldTerminateSessionsOnShutdown(event?.reason)) {
+			await terminateRunningSessions();
+		}
 		releaseRootLease(rootLeasePath);
 		rootLeasePath = undefined;
 	});

package/package.json

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

package/self-reap.ts

@@ -100,12 +100,15 @@ export default function (pi: ExtensionAPI) {
 
 	// agent_end can precede automatic retries, compaction retries, and queued
 	// continuations. Start the grace timer only once Pi is truly settled.
-	pi.on("agent_settled", (_event, ctx) => {
+	pi.on("agent_settled", () => {
 		cancel();
 		if (lastEndWasParked) return;
 		timer = setTimeout(() => {
-			// Graceful shutdown emits session_shutdown for every loaded extension.
-			ctx.shutdown();
+			// In RPC mode ctx.shutdown() only sets a flag that is checked on the next
+			// command or agent_settled event. An already-idle worker receives neither,
+			// so it would remain alive indefinitely. At this point the grace elapsed,
+			// the task is settled, and parked turns were excluded above; exit cleanly.
+			process.exit(0);
 		}, graceMs);
 		timer.unref?.();
 	});