@yusukeshib/pi-babysit 0.6.0 → 0.6.2

package/README.md

@@ -56,24 +56,27 @@ 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. Quick commands return inline; longer process runs notify in the background |
+| `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_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"` |
 | `babysit_kill` | Terminate a session, verify terminal state, then suppress the exit notification |
 
 The built-in `bash` tool is removed from the active tool set so the model does
-not waste a failed tool turn before choosing `babysit_run`. A fallback
-`tool_call` hook still blocks direct shell calls if another extension or preset
-re-enables `bash`, including shell backgrounding (`… &`, `nohup`, `setsid`,
-`disown`). Set `PI_BABYSIT_ALLOW_BASH=1` to retain direct `bash` explicitly.
+not waste a failed tool turn before choosing `babysit_run`. Process commands
+retain the built-in Bash tool's dynamic Pi metadata environment:
+`PI_SESSION_ID`, `PI_SESSION_FILE`, `PI_PROVIDER`, `PI_MODEL`, and
+`PI_REASONING_LEVEL`. A fallback `tool_call` hook still blocks direct shell
+calls if another extension or preset re-enables `bash`, including shell
+backgrounding (`… &`, `nohup`, `setsid`, `disown`). Set
+`PI_BABYSIT_ALLOW_BASH=1` to retain direct `bash` explicitly.
 
 ## Commands (human)
 
 | Command | What it does |
 | ------- | ------------ |
 | `/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 |
+| `/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; old empty roots are eligible once their lease is gone. Deletion uses a GC lock and atomic rename |
 
 A widget below the editor separates session **kind** from task **state** at a glance:
 summary counts use `RUNNING` / `IDLE`, and every row is labeled
@@ -127,6 +130,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
@@ -149,7 +160,9 @@ because blindly rerunning an arbitrary command can duplicate side effects.
   currently running member to stop and then share one notification even when
   their exits span multiple polls.
   `babysit_kill` and an exit already reported by `babysit_wait` suppress the
-  notification.
+  notification. Kill results are reconciled with persisted terminal state, so
+  a backend escalation warning that arrives after the child has already exited
+  does not produce a false failure followed by a redundant notification.
 - **Subagent**: `foreground: true` or `babysit_wait` blocks on
   `babysit expect '"type":"agent_settled"'`. A background task that settles or
   exits before it is collected emits one ready-to-collect reminder; the parent
@@ -169,10 +182,12 @@ grace window (`PI_BABYSIT_REAP_AFTER`, default 120s) using the same parked-turn
 rule, so a subagent waiting on a long build is never false-killed. Give bounded
 recon/review tasks at least one cost, turn, tool-call, or token budget; omit
 budgets only for intentionally open-ended work. Optional task budgets are
-observed by the parent poller. At 80% of a limit the worker is steered to wrap
-up; reaching the configured limit starts the hard grace immediately, even if a
-wedged worker cannot accept steering. An in-flight model call or parallel tool
-batch can still overshoot before the next poll. If the worker remains active
+observed by the parent poller. `maxUsageTokens` counts cumulative input, output,
+and cache-token usage, so size it above the worker's initial context and
+expected calls. At 80% of a limit the worker is steered to wrap up; reaching the
+configured limit starts the hard grace immediately, even if a wedged worker
+cannot accept steering. An in-flight model call or parallel tool batch can
+still overshoot before the next poll. If the worker remains active
 after `PI_BABYSIT_BUDGET_GRACE`, termination is verified before it is marked
 budget-killed. Usage shown by check/wait is cumulative, and the first terminal
 wait for each task charges that nested usage exactly once to the parent Pi

package/index.ts

@@ -220,9 +220,15 @@ function bs(
 			resolve({ stdout: "", stderr: "aborted", code: 130 });
 			return;
 		}
+		const env: NodeJS.ProcessEnv = { ...process.env };
+		for (const [name, value] of Object.entries(opts.env ?? {})) {
+			if (value === undefined) delete env[name];
+			else env[name] = value;
+		}
+		env.BABYSIT_DIR = ROOT;
 		const child = spawn(BABYSIT_BIN, args, {
 			cwd: opts.cwd,
-			env: { ...process.env, ...opts.env, BABYSIT_DIR: ROOT },
+			env,
 		});
 		let stdout = "";
 		let stderr = "";
@@ -236,7 +242,12 @@ function bs(
 		});
 		child.on("error", (e) => {
 			opts.signal?.removeEventListener("abort", onAbort);
-			resolve({ stdout, stderr: stderr + String(e), code: 1 });
+			const installHint = babysitSpawnInstallHint(e);
+			if (installHint) {
+				babysitPreflightError = installHint;
+				babysitPreflightCheckedAt = Date.now();
+			}
+			resolve({ stdout, stderr: installHint ?? stderr + String(e), code: 1 });
 		});
 		child.on("close", (code) => {
 			opts.signal?.removeEventListener("abort", onAbort);
@@ -261,6 +272,10 @@ const INSTALL_HINT =
 	`The \`babysit\` binary was not found (tried "${BABYSIT_BIN}").\n` + INSTALL_STEPS;
 const MIN_BABYSIT_VERSION = [0, 13, 0] as const;
 
+export function babysitSpawnInstallHint(error: unknown): string | null {
+	return (error as NodeJS.ErrnoException | undefined)?.code === "ENOENT" ? INSTALL_HINT : null;
+}
+
 export function isSupportedBabysitVersion(output: string): boolean {
 	const match = /\b(\d+)\.(\d+)\.(\d+)(-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?\b/.exec(output);
 	if (!match) return false;
@@ -271,7 +286,8 @@ export function isSupportedBabysitVersion(output: string): boolean {
 	return match[4] === undefined;
 }
 
-// Cached preflight — probe `babysit --version` exactly once per process.
+// Cached preflight. A supported binary stays cached until a later spawn reports
+// ENOENT; failures are retried after a short delay so installation can recover.
 // undefined = not probed, null = supported, string = actionable error.
 let babysitPreflightError: string | null | undefined;
 let babysitPreflightCheckedAt = 0;
@@ -355,6 +371,22 @@ export function validateKillResponse(stdout: string): string | null {
 	}
 }
 
+export function resolveKillConfirmation(
+	id: string,
+	backendError: string | null,
+	state: string | undefined,
+): { confirmed: true; warning?: string } | { confirmed: false; error: string } {
+	if (state && isConfirmedTerminalState(state)) {
+		return backendError ? { confirmed: true, warning: backendError } : { confirmed: true };
+	}
+	if (backendError) return { confirmed: false, error: backendError };
+	if (!state) return { confirmed: false, error: `Kill could not be verified: session ${id} disappeared.` };
+	return {
+		confirmed: false,
+		error: `Kill was acknowledged but ${id} is still ${state}; completion notifications were restored.`,
+	};
+}
+
 async function awaitConfirmedTermination(id: string): Promise<BsSession | null> {
 	const initial = await statusOf(id);
 	if (!initial || isConfirmedTerminalState(initial.state) || initial.state === "dead") {
@@ -367,6 +399,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
 // ---------------------------------------------------------------------------
@@ -562,9 +623,12 @@ function gcRootIsSafe(root: string): boolean {
 	let sessionDirs: fs.Dirent[];
 	try {
 		sessionDirs = fs.readdirSync(sessionsDir, { withFileTypes: true });
-	} catch {
-		return false;
+	} catch (error) {
+		// session_start acquires a lease before the first worker exists. Once that
+		// lease is gone, an old root with no sessions is safe to collect.
+		return (error as NodeJS.ErrnoException).code === "ENOENT";
 	}
+	if (!sessionDirs.some((entry) => entry.isDirectory())) return true;
 	let sawStatus = false;
 	for (const sessionEntry of sessionDirs) {
 		if (!sessionEntry.isDirectory()) continue;
@@ -1864,12 +1928,26 @@ interface ProcOpts {
 	name?: string;
 	command: string;
 	cwd: string;
+	env?: Record<string, string | undefined>;
 	timeout?: string; // default: none — dev servers may run indefinitely
 	idleTimeout?: string;
 	pty: boolean;
 	notificationGroup?: string;
 }
 
+export function processSessionEnvironment(
+	ctx: ExtensionContext,
+	reasoningLevel = (ctx as ExtensionContext & { thinkingLevel?: string }).thinkingLevel,
+): Record<string, string | undefined> {
+	return {
+		PI_SESSION_ID: ctx.sessionManager.getSessionId(),
+		PI_SESSION_FILE: ctx.sessionManager.getSessionFile(),
+		PI_PROVIDER: ctx.model?.provider,
+		PI_MODEL: ctx.model?.id,
+		PI_REASONING_LEVEL: reasoningLevel,
+	};
+}
+
 async function spawnProcess(opts: ProcOpts): Promise<{ id: string } | { error: string }> {
 	const bsArgs = ["run", "-d", "--json", "--size", "120x40"];
 	if (!opts.pty) bsArgs.push("--no-tty");
@@ -1882,7 +1960,7 @@ async function spawnProcess(opts: ProcOpts): Promise<{ id: string } | { error: s
 
 	let r: Awaited<ReturnType<typeof bs>>;
 	try {
-		r = await bs(bsArgs, { cwd: opts.cwd });
+		r = await bs(bsArgs, { cwd: opts.cwd, env: opts.env });
 	} finally {
 		if (reservedId) reservedSessionIds.delete(reservedId);
 	}
@@ -2814,6 +2892,21 @@ export function automaticNotificationGroup(entry: unknown): string | undefined {
 	return runs.length >= 2 ? group : undefined;
 }
 
+export function prepareBabysitRunArguments(args: unknown): unknown {
+	if (!args || typeof args !== "object") return args;
+	const input = args as Record<string, unknown>;
+	if (
+		input.profile === "subagent" &&
+		input.continueAfterStart === true &&
+		input.foreground !== true
+	) {
+		const prepared = { ...input };
+		delete prepared.continueAfterStart;
+		return prepared;
+	}
+	return args;
+}
+
 export function resolveSubagentSendMode(
 	requested: "auto" | "steer" | "task",
 	streaming?: boolean,
@@ -3338,9 +3431,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;
 	});
@@ -3395,14 +3494,18 @@ export default function (pi: ExtensionAPI) {
 		promptSnippet: "Run supervised commands or bounded pi subagents with context-safe logs",
 		promptGuidelines: [
 			"Use babysit_run for shell commands and give meaningful sessions a stable name; bundle tiny related read-only observations into one command.",
-			"Use babysit_run foreground mode for one process or subagent whose result is needed now; never issue sibling foreground runs in parallel. For parallel checks, start background runs with continueAfterStart and collect them with one multi-session babysit_wait.",
+			"Use babysit_run foreground mode for one process or subagent whose result is needed now; never issue sibling foreground runs in parallel. For parallel process checks, start background runs with continueAfterStart and collect them with one multi-session babysit_wait.",
 			"Use returnPattern/returnLines for noisy commands. During edit/fix loops run targeted checks first and one full validation suite at the end instead of repeating every full gate.",
-			"After a background process starts, stop the turn for its automatic notification; never poll or sleep. Use continueAfterStart only for specific non-polling work.",
+			"After a background process starts, stop the turn for its automatic notification; never poll or sleep. Use continueAfterStart only for specific non-polling process work.",
 			"Inspect large logs with a narrow babysit_check pattern and maxBytes rather than broad tails.",
 			"Use retryOnWorkerDeath only once and only for idempotent commands; retries may duplicate side effects.",
-			"Delegate independent work with bounded babysit_run subagents. Prefer foreground for one result needed now; every background subagent must be collected with babysit_wait before the parent task finishes. Size budgets above the worker's initial context and expected tool count.",
+			"Delegate independent work with bounded babysit_run subagents. Prefer foreground for one result needed now; every background subagent must be collected with babysit_wait before the parent task finishes. Size budgets above the worker's initial context and expected tool count; maxUsageTokens counts cumulative input/cache tokens and can overshoot by one in-flight model call.",
+			"Omit babysit_run.agent unless you know a named agent definition exists in the selected agentScope.",
 			"Subagent recursion defaults to depth 1; only a top-level caller may explicitly raise maxDepth.",
 		],
+		prepareArguments(args) {
+			return prepareBabysitRunArguments(args) as never;
+		},
 		parameters: Type.Object({
 			command: Type.Optional(
 				Type.String({
@@ -3509,7 +3612,7 @@ export default function (pi: ExtensionAPI) {
 			continueAfterStart: Type.Optional(
 				Type.Boolean({
 					description:
-						"Process mode only. Default false: starting a process ENDS the current turn (you are resumed by the exit notification). Set true only when you have immediate, specific, non-polling work to do after starting.",
+						"Process mode. Default false: starting a process ENDS the current turn (you are resumed by the exit notification). Set true only for immediate, specific, non-polling process work. In subagent mode true is accepted as a compatibility alias for the default background behavior.",
 				}),
 			),
 			retryOnWorkerDeath: Type.Optional(
@@ -3570,14 +3673,7 @@ export default function (pi: ExtensionAPI) {
 					details: {},
 				};
 			}
-			if (isSubagent && params.continueAfterStart != null) {
-				return {
-					content: [{ type: "text", text: "`continueAfterStart` is available only in process mode." }],
-					isError: true,
-					details: {},
-				};
-			}
-			if (!isSubagent && params.foreground && params.continueAfterStart) {
+			if (params.foreground && params.continueAfterStart) {
 				return {
 					content: [{ type: "text", text: "`foreground` and `continueAfterStart` are mutually exclusive." }],
 					isError: true,
@@ -3622,6 +3718,7 @@ export default function (pi: ExtensionAPI) {
 					timeout: params.timeout,
 					idleTimeout: params.idleTimeout,
 					pty: params.pty ?? true,
+					env: processSessionEnvironment(ctx, pi.getThinkingLevel()),
 					notificationGroup: params.notificationGroup?.trim() || undefined,
 				};
 				let res = await spawnProcess(spawnOpts);
@@ -3750,7 +3847,7 @@ export default function (pi: ExtensionAPI) {
 					const avail = agents.map((a) => a.name).join(", ") || "none";
 					return {
 						content: [
-							{ type: "text", text: `Unknown agent "${params.agent}". Available: ${avail}.` },
+							{ type: "text", text: `Unknown agent "${params.agent}". Available: ${avail}. Omit \`agent\` to use the default subagent configuration.` },
 						],
 						isError: true,
 						details: {},
@@ -4546,29 +4643,34 @@ export default function (pi: ExtensionAPI) {
 			};
 
 			const r = await bs(["kill", "-s", params.id, "--json"]);
-			if (r.code !== 0) return fail((r.stderr || r.stdout || "kill failed").trim());
-
-			const responseError = validateKillResponse(r.stdout);
-			if (responseError) return fail(responseError);
-
+			const backendError = r.code !== 0
+				? (r.stderr || r.stdout || "kill failed").trim()
+				: validateKillResponse(r.stdout);
+			// A backend can report an escalation error after the child has already
+			// reached a persisted terminal state. Reconcile against authoritative
+			// state before deciding whether to restore completion notifications.
 			const status = await awaitConfirmedTermination(params.id);
+			const confirmation = resolveKillConfirmation(params.id, backendError, status?.state);
+			if (!confirmation.confirmed) return fail(confirmation.error, status);
 			if (!status) return fail(`Kill could not be verified: session ${params.id} disappeared.`);
-			if (!isConfirmedTerminalState(status.state)) {
-				return fail(
-					`Kill was acknowledged but ${params.id} is still ${status.state}; completion notifications were restored.`,
-					status,
-				);
-			}
 
 			suppressNotify(params.id, "kill");
 			await refreshWidget(ctx);
 			return {
-				content: [{ type: "text", text: `Killed ${params.id} (confirmed ${status.state}).` }],
+				content: [
+					{
+						type: "text",
+						text:
+							`Killed ${params.id} (confirmed ${status.state}).` +
+							(confirmation.warning ? ` Backend warning after termination: ${confirmation.warning}` : ""),
+					},
+				],
 				details: {
 					id: params.id,
 					status: status.state,
 					exitCode: status.exit_code,
 					logPath: logPath(params.id),
+					backendWarning: confirmation.warning,
 				},
 			};
 		},

package/package.json

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