@yusukeshib/pi-babysit 0.2.4 → 0.3.1

package/README.md

@@ -1,8 +1,9 @@
 # pi-babysit
 
-A [pi](https://github.com/earendil-works/pi) extension that runs **anything
-long-lived** under [babysit](https://github.com/yusukeshib/babysit)-supervised
-PTY sessions — one substrate for background processes **and** pi subagents.
+A [pi](https://github.com/earendil-works/pi) extension that runs **any shell
+command** under [babysit](https://github.com/yusukeshib/babysit)-supervised
+sessions — one context-safe substrate for quick commands, background processes,
+and pi subagents.
 It retires both `@mjakl/pi-processes` (the `process` tool) and the old
 `pi-subagent` extension.
 
@@ -48,9 +49,8 @@ programs** (installers, wizards, REPLs): type with `babysit_send`
 
 | Tool | What it does |
 | ---- | ------------ |
-| `babysit_run` | Start a process (`command`, optional `name`/`pty`/`timeout`/`idleTimeout`) or a subagent (`profile: "subagent"`, `task`, optional `agent`/`model`/`tools`). Non-blocking; returns a session id |
+| `babysit_run` | Run any command (`command`, optional `name`/`pty`/`timeout`/`idleTimeout`/`retryOnWorkerDeath`) or start a subagent (`profile: "subagent"`, `task`, optional `agent`/`model`/`tools`). Quick commands return inline; longer ones continue in the background |
 | `babysit_check` | List all sessions, or inspect one: process → state + log tail (or `screen: true` for TUIs); subagent → live progress (turns, recent tool calls, partial answer) |
-| `babysit_analyze` | Run a local JavaScript, Python, or shell analyzer over a process's complete captured log; only its bounded report returns to the model |
 | `babysit_send` | Process: type `text` / press `keys` into the PTY. Subagent: steer mid-run, or send a follow-up task when idle (`mode: auto/steer/task`) |
 | `babysit_wait` | Block until done: process exit (or `expect: "regex"` readiness marker), subagent task completion. Multi-wait: `ids` + `mode: "any"\|"all"` |
 | `babysit_kill` | Terminate a session (suppresses the exit notification) |
@@ -68,39 +68,30 @@ A `tool_call` hook also blocks bash commands that background themselves
 A minimal widget above the editor shows live counts
 (`N processes · M subagents working · K idle`).
 
-## Log reports without context flooding
-
-A process run can include a `report` program. On completion, babysit writes the
-complete recorded log to a temporary file, runs the program in a separate local
-child process, and sends **only the program's bounded stdout** in the automatic
-completion notification. This avoids putting a full test/build log in the model
-context while preserving the original log for `babysit_check`, `/babysit`, or
-`babysit attach`.
-
-```ts
-babysit_run({
-  name: "test",
-  command: "npm test",
-  report: {
-    language: "javascript",
-    code: `
-      const failures = FILE_CONTENT.split("\\n")
-        .filter(line => /FAIL|Error:|✗/.test(line));
-      console.log(`failures: ${failures.length}`);
-      console.log(failures.slice(-20).join("\\n"));
-    `,
-  },
-});
+## Logs without context flooding
+
+`babysit_run`, `babysit_wait`, and automatic completion notifications always
+return lifecycle metadata and the absolute path to the complete `output.log`.
+When the complete output is at most 8 KB it is returned inline; larger output
+stays out of model context. Inspect large logs on demand with bounded shell
+commands such as:
+
+```sh
+tail -n 50 /path/to/output.log
+rg -n 'FAIL|ERROR' /path/to/output.log
 ```
 
-JavaScript and Python reports receive `FILE_CONTENT` and `INPUT`; shell reports
-read the log path from `$BABYSIT_REPORT_INPUT`. `report.timeout` defaults to
-30 seconds. Input is capped at 64 MiB and returned report output at 12 KB.
-Use `babysit_analyze` with the same `language`, `code`, and optional `timeout`
-fields to analyze a running process's output so far or re-analyze a completed
-process. Report code executes with your local user permissions, just like any
-other extension tool command; it is isolated from the pi extension host but is
-not an OS security sandbox.
+`babysit_check { id, lines }` remains available as a convenient bounded tail.
+Do not read a potentially large log file in full.
+
+## External worker death
+
+If endpoint security or another external actor kills the babysit supervisor,
+pi-babysit normalizes the stale `running` state to `worker-dead`, returns
+immediately instead of hanging, and explains that the command may have started.
+For commands known to be safe and idempotent, set `retryOnWorkerDeath: true` to
+retry once with a new session id. It is opt-in because blindly rerunning an
+arbitrary command can duplicate side effects.
 
 ## How completion detection works
 

package/index.ts

@@ -1,6 +1,6 @@
 /**
- * pi-babysit: run ANYTHING long-lived under babysit — one supervision substrate
- * for background processes AND pi subagents. Retires both `pi-processes`
+ * pi-babysit: run ANY shell command under babysit — one context-safe supervision
+ * substrate for quick commands, background processes, AND pi subagents. Retires both `pi-processes`
  * (the `process` tool) and `pi-subagent`.
  *
  * Every session is a babysit-supervised PTY (state in $PI_BABYSIT_DIR,
@@ -26,7 +26,7 @@
  * surface (babysit_run/check/send/wait/kill) covers both, and domain knowledge
  * (RPC bookkeeping, byte offsets, parked-turn detection) stays in code.
  *
- * Tools (LLM):  babysit_run, babysit_check, babysit_analyze, babysit_send, babysit_wait, babysit_kill
+ * Tools (LLM):  babysit_run, babysit_check, babysit_send, babysit_wait, babysit_kill
  * Commands:     /babysit (arrow-key picker: attach/tail/inspect)
  * Widget:       live counts (processes running · subagents working · idle)
  */
@@ -80,6 +80,7 @@ const SUBAGENT_GUIDANCE = [
 	"your controller reads it from the event stream.",
 ].join(" ");
 const POLL_MS = 2500;
+const QUICK_COMMAND_GRACE = process.env.PI_BABYSIT_QUICK_GRACE ?? "1s";
 
 interface BsSession {
 	id: string;
@@ -225,21 +226,13 @@ async function statusOf(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).
-type ReportLanguage = "javascript" | "python" | "shell";
-
-interface ReportSpec {
-	language: ReportLanguage;
-	code: string;
-	timeout?: string;
-}
-
 interface Meta {
 	kind: "process" | "subagent";
 	// process
 	name?: string;
 	command?: string;
-	report?: ReportSpec;
 	notified?: boolean;
+	completionObservedAt?: number;
 	startedAt?: number;
 	// subagent
 	task?: string;
@@ -248,6 +241,7 @@ interface Meta {
 }
 
 const metaDir = () => path.join(ROOT, "meta");
+const logPath = (id: string) => path.join(ROOT, "sessions", id, "output.log");
 
 function writeMeta(id: string, m: Meta): void {
 	try {
@@ -373,11 +367,9 @@ function parseDurMs(s?: string): number | null {
 // megabytes, so we also cap bytes, eliding the middle so both the head and
 // the tail of the output stay visible.
 
-const TAIL_MAX_BYTES = 8_000; // log tails / screens
+const TAIL_MAX_BYTES = 8_000; // explicit tails / screens
+const INLINE_OUTPUT_MAX_BYTES = 8_000; // complete output returned only below this threshold
 const ANSWER_MAX_BYTES = 24_000; // subagent answers / error messages
-const REPORT_MAX_INPUT_BYTES = 64 * 1024 * 1024; // analyzer input log
-const REPORT_MAX_OUTPUT_BYTES = 12_000; // analyzer stdout/stderr returned to the agent
-const REPORT_DEFAULT_TIMEOUT_MS = 30_000;
 
 function clip(s: string, maxBytes = TAIL_MAX_BYTES): string {
 	const buf = Buffer.from(s, "utf8");
@@ -389,132 +381,27 @@ function clip(s: string, maxBytes = TAIL_MAX_BYTES): string {
 	return `${head}\n… [${buf.length - maxBytes} bytes elided] …\n${tail}`;
 }
 
-// ---------------------------------------------------------------------------
-// Report analyzers — a report receives the complete captured process log, but
-// only its bounded stdout is returned to the model. It intentionally runs in
-// a child process: report code is arbitrary user/model-authored code and must
-// never be evaluated inside pi's extension host.
-
-interface ReportOutcome {
-	ok: boolean;
-	text: string;
-}
-
-async function saveSessionLog(id: string, destination: string, signal?: AbortSignal): Promise<string | null> {
-	return new Promise((resolve) => {
-		const child = spawn(BABYSIT_BIN, ["log", "-s", id], {
-			env: { ...process.env, BABYSIT_DIR: ROOT },
-		});
-		const output = fs.createWriteStream(destination);
-		let bytes = 0;
-		let finished = false;
-		const finish = (error: string | null) => {
-			if (finished) return;
-			finished = true;
-			signal?.removeEventListener("abort", abort);
-			output.end(() => resolve(error));
-		};
-		const abort = () => {
-			child.kill("SIGTERM");
-			finish("report analysis was cancelled");
-		};
-		if (signal?.aborted) return abort();
-		signal?.addEventListener("abort", abort, { once: true });
-		child.stdout?.on("data", (chunk: Buffer) => {
-			if (finished) return;
-			bytes += chunk.length;
-			if (bytes > REPORT_MAX_INPUT_BYTES) {
-				child.kill("SIGTERM");
-				finish(`process log exceeds the ${REPORT_MAX_INPUT_BYTES / 1024 / 1024} MiB report limit`);
-				return;
-			}
-			output.write(chunk);
-		});
-		child.on("error", (error) => finish(`could not read process log: ${error.message}`));
-		child.on("close", (code) => {
-			if (finished) return;
-			finish(code === 0 ? null : `could not read process log (babysit log exited ${code ?? 1})`);
-		});
-	});
-}
-
-async function executeReport(spec: ReportSpec, inputPath: string, signal?: AbortSignal): Promise<ReportOutcome> {
-	const dir = path.dirname(inputPath);
-	const scriptPath = path.join(dir, spec.language === "python" ? "report.py" : spec.language === "shell" ? "report.sh" : "report.cjs");
-	const script =
-		spec.language === "javascript"
-			? `const fs = require("node:fs");\nconst FILE_CONTENT = fs.readFileSync(process.env.BABYSIT_REPORT_INPUT, "utf8");\nconst INPUT = FILE_CONTENT;\n(async () => {\n${spec.code}\n})().catch((error) => { console.error(error?.stack ?? String(error)); process.exitCode = 1; });\n`
-			: spec.language === "python"
-				? `import os\nfrom pathlib import Path\nFILE_CONTENT = Path(os.environ["BABYSIT_REPORT_INPUT"]).read_text()\nINPUT = FILE_CONTENT\n${spec.code}\n`
-				: `# Read the complete log from $BABYSIT_REPORT_INPUT.\n${spec.code}\n`;
-	fs.writeFileSync(scriptPath, script, { mode: 0o700 });
-	const command = spec.language === "javascript" ? process.execPath : spec.language === "python" ? "python3" : SHELL;
-	const args = spec.language === "shell" ? [scriptPath] : [scriptPath];
-	const timeoutMs = parseDurMs(spec.timeout) ?? REPORT_DEFAULT_TIMEOUT_MS;
-
-	return new Promise((resolve) => {
-		const child = spawn(command, args, {
-			env: { ...process.env, BABYSIT_REPORT_INPUT: inputPath },
-		});
-		let stdout = "";
-		let stderr = "";
-		let outputTruncated = false;
-		let timedOut = false;
-		let settled = false;
-		const append = (current: string, chunk: Buffer) => {
-			const remaining = REPORT_MAX_OUTPUT_BYTES - Buffer.byteLength(current);
-			if (remaining <= 0) {
-				outputTruncated = true;
-				return current;
-			}
-			const text = chunk.subarray(0, remaining).toString("utf8");
-			if (text.length < chunk.length) outputTruncated = true;
-			return current + text;
-		};
-		const finish = (code: number | null) => {
-			if (settled) return;
-			settled = true;
-			clearTimeout(timer);
-			signal?.removeEventListener("abort", abort);
-			const body = [stdout.trim(), stderr.trim()].filter(Boolean).join("\n");
-			const suffix = outputTruncated ? "\n[report output truncated]" : "";
-			if (timedOut) {
-				resolve({ ok: false, text: `Report timed out after ${Math.ceil(timeoutMs / 1000)}s.${body ? `\n${clip(body, REPORT_MAX_OUTPUT_BYTES)}` : ""}${suffix}` });
-			} else if (code === 0) {
-				resolve({ ok: true, text: `${body || "(report produced no output)"}${suffix}` });
-			} else {
-				resolve({ ok: false, text: `Report failed (exit ${code ?? 1}).${body ? `\n${clip(body, REPORT_MAX_OUTPUT_BYTES)}` : ""}${suffix}` });
-			}
-		};
-		const abort = () => child.kill("SIGTERM");
-		const timer = setTimeout(() => {
-			timedOut = true;
-			child.kill("SIGTERM");
-		}, timeoutMs);
-		if (signal?.aborted) abort();
-		signal?.addEventListener("abort", abort, { once: true });
-		child.stdout?.on("data", (chunk: Buffer) => { stdout = append(stdout, chunk); });
-		child.stderr?.on("data", (chunk: Buffer) => { stderr = append(stderr, chunk); });
-		child.on("error", (error) => {
-			stderr = append(stderr, Buffer.from(error.message));
-			finish(1);
-		});
-		child.on("close", finish);
-	});
-}
-
-async function runReport(id: string, spec: ReportSpec, signal?: AbortSignal): Promise<ReportOutcome> {
-	const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-babysit-report-"));
-	try {
-		const inputPath = path.join(dir, "process.log");
-		const error = await saveSessionLog(id, inputPath, signal);
-		if (error) return { ok: false, text: `Could not prepare report input: ${error}` };
-		return await executeReport(spec, inputPath, signal);
-	} finally {
-		fs.rmSync(dir, { recursive: true, force: true });
+async function inlineOutput(id: string, status: BsSession): Promise<string> {
+	let bytes = status.output_bytes;
+	if (bytes == null) {
+		try {
+			bytes = fs.statSync(logPath(id)).size;
+		} catch {
+			bytes = Number.POSITIVE_INFINITY;
+		}
+	}
+	if (bytes > INLINE_OUTPUT_MAX_BYTES) {
+		const size = Number.isFinite(bytes) ? `${bytes} bytes` : "size unavailable";
+		return `\nOutput omitted (${size}; inline limit ${INLINE_OUTPUT_MAX_BYTES}).`;
+	}
+	const output = (await bs(["log", "-s", id])).stdout.trimEnd();
+	if (Buffer.byteLength(output) > INLINE_OUTPUT_MAX_BYTES) {
+		return `\nOutput omitted (exceeds inline limit ${INLINE_OUTPUT_MAX_BYTES} bytes).`;
 	}
+	return output ? `\n\nOutput:\n${output}` : "";
 }
 
+
 // ---------------------------------------------------------------------------
 // parked-turn detection (shared rule with self-reap.ts)
 // ---------------------------------------------------------------------------
@@ -691,7 +578,6 @@ interface ProcOpts {
 	timeout?: string; // default: none — dev servers may run indefinitely
 	idleTimeout?: string;
 	pty: boolean;
-	report?: ReportSpec;
 }
 
 async function spawnProcess(opts: ProcOpts): Promise<{ id: string } | { error: string }> {
@@ -721,7 +607,6 @@ async function spawnProcess(opts: ProcOpts): Promise<{ id: string } | { error: s
 		kind: "process",
 		name: opts.name ?? id,
 		command: opts.command,
-		report: opts.report,
 		notified: false,
 		startedAt: Date.now(),
 	});
@@ -970,7 +855,7 @@ interface WaitOutcome {
 // 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 → report; still going →
+// Loop: analyze the current-task log slice; done → return; still going →
 // block on the next agent_end via `babysit expect` (race-free byte offsets).
 async function waitForTask(
 	id: string,
@@ -1089,6 +974,14 @@ function suppressNotify(id: string): void {
 	}
 }
 
+function enableNotify(id: string): void {
+	const meta = readMeta(id);
+	if (meta && meta.kind === "process" && meta.notified) {
+		meta.notified = false;
+		writeMeta(id, meta);
+	}
+}
+
 // Wait for a PROCESS session: either until a regex appears in its output
 // (`expect` — e.g. "server listening") or until the process exits.
 async function waitForExit(
@@ -1105,12 +998,11 @@ async function waitForExit(
 			return { id, kind: "interrupted", ok: false, text: `wait for ${id} was interrupted.` };
 		}
 		if (e.code === 0) {
-			const tail = clip((await bs(["log", "-s", id, "--tail", "10"])).stdout.trim());
 			return {
 				id,
 				kind: "done",
 				ok: true,
-				text: `Pattern /${expectPattern}/ matched in ${id} output (process still running).\n\nRecent output:\n${tail}`,
+				text: `Pattern /${expectPattern}/ matched in ${id} output (process still running).\nLog: ${logPath(id)}`,
 			};
 		}
 		const st0 = await statusOf(id);
@@ -1125,14 +1017,19 @@ async function waitForExit(
 		}
 		// fall through: session exited before the pattern appeared
 	} else {
+		// An explicit wait owns completion delivery. Mark it before blocking so
+		// the exit poller cannot race us and inject a duplicate notification.
+		suppressNotify(id);
 		const w = await bs(["wait", "-s", id, "--timeout", t], { signal });
 		if (signal?.aborted || w.code === 130) {
+			enableNotify(id);
 			return { id, kind: "interrupted", ok: false, text: `wait for ${id} was interrupted.` };
 		}
 		if (w.code === 124) {
 			// 124 is ambiguous (timeout vs child exiting 124) — disambiguate.
 			const st0 = await statusOf(id);
 			if (st0?.state === "running") {
+				enableNotify(id);
 				return {
 					id,
 					kind: "timeout",
@@ -1150,20 +1047,23 @@ async function waitForExit(
 	}
 	suppressNotify(id); // the agent sees the exit here; don't notify again
 	const meta = readMeta(id);
-	const report = meta?.report ? await runReport(id, meta.report, signal) : null;
-	const tail = report ? "" : clip((await bs(["log", "-s", id, "--tail", "20"])).stdout.trim());
+	const workerDead = st.state === "dead" && st.exit_code == null;
 	const ok = st.exit_code === 0;
+	const output = await inlineOutput(id, st);
 	return {
 		id,
 		kind: "exited",
 		ok,
 		text:
 			`Process ${id}${meta?.command ? ` (${meta.command})` : ""} ` +
-			`${ok ? "completed successfully" : `exited with code ${st.exit_code ?? "?"}`}` +
+			(workerDead
+				? "worker-dead: the babysit supervisor disappeared without an exit status"
+				: ok ? "completed successfully" : `exited with code ${st.exit_code ?? "?"}`) +
 			`${expectPattern ? ` before /${expectPattern}/ appeared` : ""}.` +
-			(report
-				? `\n\nReport${report.ok ? "" : " (failed)"}:\n${report.text}`
-				: tail ? `\n\nLast output:\n${tail}` : ""),
+			(workerDead
+				? " This commonly indicates an external kill (for example endpoint security). The command may have started, so retry only if it is safe and idempotent."
+				: "") +
+			`\nLog: ${logPath(id)}` + output,
 		status: st,
 	};
 }
@@ -1210,11 +1110,19 @@ export default function (pi: ExtensionAPI) {
 			if (s.state === "running") continue;
 			const meta = readMeta(s.id);
 			if (!meta || meta.kind !== "process" || meta.notified) 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.
+			if (!meta.completionObservedAt) {
+				meta.completionObservedAt = Date.now();
+				writeMeta(s.id, meta);
+				continue;
+			}
+			if (Date.now() - meta.completionObservedAt < POLL_MS) continue;
 			meta.notified = true;
 			writeMeta(s.id, meta);
-			const report = meta.report ? await runReport(s.id, meta.report) : null;
-			const tail = report ? "" : clip((await bs(["log", "-s", s.id, "--tail", "20"])).stdout.trim());
 			const ok = s.exit_code === 0;
+			const output = await inlineOutput(s.id, s);
 			const runtime = meta.startedAt
 				? `${Math.round((Date.now() - meta.startedAt) / 1000)}s`
 				: "?";
@@ -1227,13 +1135,10 @@ export default function (pi: ExtensionAPI) {
 				{
 					customType: "pi-babysit-process-end",
 					content:
-						`${summary}\nCommand: ${meta.command ?? "?"}` +
-						(report
-							? `\n\nReport${report.ok ? "" : " (failed)"}:\n${report.text}`
-							: tail ? `\n\nRecent output:\n${tail}` : "") +
-						`\n\nThis is the automatic process-end notification. Do not call babysit_check just to re-verify; use it once only if you need more logs for debugging.`,
+						`${summary}\nCommand: ${meta.command ?? "?"}\nLog: ${logPath(s.id)}${output}` +
+						`\n\nThis is the automatic process-end notification. Do not call babysit_check just to re-verify. Inspect the log only when needed, using bounded commands such as tail or rg; never read it in full.`,
 					display: true,
-					details: { id: s.id, exitCode: s.exit_code, success: ok, runtime, report },
+					details: { id: s.id, exitCode: s.exit_code, success: ok, runtime, logPath: logPath(s.id) },
 				},
 				{ triggerTurn: true, deliverAs: "steer" },
 			);
@@ -1342,22 +1247,25 @@ export default function (pi: ExtensionAPI) {
 		name: "babysit_run",
 		label: "Babysit: run",
 		description:
-			"Start a supervised background session under babysit (NON-BLOCKING; returns a session id). " +
-			"In non-interactive mode (`pi -p`, no UI) process mode instead BLOCKS until the command " +
-			"exits and returns its output inline — there is no notification loop to resume a parked turn. " +
-			"Two modes: (1) `command` — run any long-lived or slow command (build, tests, dev server, " +
-			"watcher, interactive TUI) in a PTY; you get an AUTOMATIC notification when it exits, and " +
-			"you can type into it with babysit_send and read its screen with babysit_check. Optional `report` " +
-			"runs local code over the full captured log and returns only its concise output on completion. " +
+			"Run any shell command in a supervised babysit session. Commands that finish within a short " +
+			"grace period return completion metadata immediately; longer commands continue in the background " +
+			"and trigger an automatic notification on exit. Complete output is returned inline only when it is " +
+			"small; larger output stays in the log path for bounded inspection with tail or rg. " +
+			"In non-interactive mode (`pi -p`, no UI), process mode blocks until exit because there is no " +
+			"notification loop. Two modes: (1) `command` — run any shell command, including builds, tests, " +
+			"dev servers, watchers, and interactive TUIs; you can type into it with babysit_send and read " +
+			"its screen with babysit_check. If endpoint security kills a worker at startup, " +
+			"`retryOnWorkerDeath` can retry one idempotent command once. " +
 			"(2) `profile: \"subagent\"` + `task` — spawn a pi subagent that works on the task in the " +
 			"background; poll with babysit_check, steer with babysit_send, block with babysit_wait, " +
 			"stop with babysit_kill.",
 		promptSnippet:
-			"Run a command or a pi subagent as a supervised background session (non-blocking); returns a session id",
+			"Run any shell command with context-safe captured output; quick commands return metadata, longer ones continue in background",
 		promptGuidelines: [
-			"Run every long-lived or slow command through babysit_run instead of bash: builds, test suites, dev servers, watchers, `tail -f`, anything expected to take more than a few seconds. Give it a clear stable `name` (e.g. cargo-build).",
+			"Use babysit_run as the default for shell commands, not only long-running work. Small output is returned directly; large stdout/stderr stays out of model context in the returned log path. Give meaningful commands a clear stable `name`.",
+			"Inspect a babysit log only with explicitly bounded commands such as `tail -n N` or focused `rg`; never read or cat a potentially large log in full. Those small inspection commands may use bash directly to avoid recursively creating babysit sessions.",
 			"After babysit_run { command } starts a process, end your response immediately so the automatic process-end notification can resume you; NEVER poll with babysit_check or sleep. Set continueAfterStart: true only when you have immediate, specific, non-polling work to do next. Call babysit_wait when you must consume the result inside the current turn (optionally with `expect` to wait for a readiness line like 'listening on').",
-			"For a build/test/API command with potentially large output, give babysit_run a `report` program that extracts the needed facts from FILE_CONTENT; the automatic completion notification will contain only that report rather than a raw log tail.",
+			"If a babysit worker is killed externally, babysit_run reports it as worker-dead rather than hanging. Set retryOnWorkerDeath: true only for safe, idempotent commands; it retries at most once and may otherwise duplicate side effects.",
 			"babysit_run gives full PTY control: drive interactive programs (installers, wizards, REPLs) with babysit_send (text or named keys) and read the rendered screen with babysit_check { screen: true }.",
 			"Delegate self-contained tasks (codebase recon, a parallelizable subtask, work that would pollute your context) with babysit_run { profile: \"subagent\", task }. Launch several for independent subtasks; they run concurrently.",
 			"After spawning subagents, do not idle-wait and do not end your turn to wait for them: keep making progress, then call babysit_wait (ids + mode any/all) when you need their results. Steer or send follow-up tasks with babysit_send; kill runaways with babysit_kill.",
@@ -1417,20 +1325,13 @@ export default function (pi: ExtensionAPI) {
 						"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.",
 				}),
 			),
-			report: Type.Optional(
-				Type.Object({
-					language: StringEnum(["javascript", "python", "shell"] as const, {
-						description: "Language for the local report program.",
-					}),
-					code: Type.String({
-						description:
-							"Program that analyzes the complete captured log. JavaScript/Python receive FILE_CONTENT and INPUT strings; shell receives $BABYSIT_REPORT_INPUT. Print only the concise report.",
-					}),
-					timeout: Type.Optional(
-						Type.String({ description: "Report-program timeout (default 30s, e.g. '10s')." }),
-					),
+			retryOnWorkerDeath: Type.Optional(
+				Type.Boolean({
+					description:
+						"Process mode only. Retry once if the babysit worker is killed externally during startup. Use only for safe, idempotent commands because the first attempt may have produced side effects.",
 				}),
 			),
+
 		}),
 		async execute(_id, params, _signal, _onUpdate, ctx) {
 			await requireBabysit();
@@ -1456,25 +1357,18 @@ export default function (pi: ExtensionAPI) {
 					details: {},
 				};
 			}
-			if (isSubagent && params.report) {
-				return {
-					content: [{ type: "text", text: "`report` is available only for process sessions." }],
-					isError: true,
-					details: {},
-				};
-			}
 
 			// --- process mode ---
 			if (!isSubagent) {
-				const res = await spawnProcess({
+				const spawnOpts: ProcOpts = {
 					name: params.name,
 					command: params.command as string,
 					cwd: ctx.cwd,
 					timeout: params.timeout,
 					idleTimeout: params.idleTimeout,
 					pty: params.pty ?? true,
-					report: params.report,
-				});
+				};
+				let res = await spawnProcess(spawnOpts);
 				if ("error" in res) {
 					return {
 						content: [{ type: "text", text: `Failed to start process: ${res.error}` }],
@@ -1492,11 +1386,46 @@ export default function (pi: ExtensionAPI) {
 				// outcome in THIS turn. The process still runs under babysit (logged,
 				// killable), we just wait for it here instead of fire-and-forget.
 				if (!ctx.hasUI) {
-					const outcome = await waitForExit(res.id, parseDurMs(params.timeout), _signal);
+					let outcome = await waitForExit(res.id, parseDurMs(params.timeout), _signal);
+					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, parseDurMs(params.timeout), _signal);
+						}
+					}
 					return {
-						content: [{ type: "text", text: outcome.text }],
+						content: [{ type: "text", text: `${retried ? "Retried once after external worker death.\n" : ""}${outcome.text}` }],
 						isError: !outcome.ok,
-						details: { id: res.id, kind: "process", command: params.command, report: params.report },
+						details: { id: res.id, kind: "process", command: params.command, logPath: logPath(res.id), retried },
+					};
+				}
+
+				// Keep ordinary quick commands ergonomic. Give the process a short grace
+				// period; if it exits, return only lifecycle metadata + log path now.
+				// A timeout means it is genuinely background work and follows the normal
+				// parked-turn / automatic-notification contract below.
+				await bs(["wait", "-s", res.id, "--timeout", QUICK_COMMAND_GRACE], { signal: _signal });
+				let quickStatus = await statusOf(res.id);
+				let retried = false;
+				if (params.retryOnWorkerDeath && quickStatus?.state === "dead" && quickStatus.exit_code == null) {
+					const retry = await spawnProcess(spawnOpts);
+					if (!("error" in retry)) {
+						res = retry;
+						retried = true;
+						await bs(["wait", "-s", res.id, "--timeout", QUICK_COMMAND_GRACE], { signal: _signal });
+						quickStatus = await statusOf(res.id);
+					}
+				}
+				if (quickStatus && quickStatus.state !== "running") {
+					const outcome = await waitForExit(res.id, null, _signal);
+					await refreshWidget(ctx);
+					return {
+						content: [{ type: "text", text: `${retried ? "Retried once after external worker death.\n" : ""}${outcome.text}` }],
+						isError: !outcome.ok,
+						details: { id: res.id, kind: "process", command: params.command, logPath: logPath(res.id), retried },
 					};
 				}
 
@@ -1509,13 +1438,14 @@ export default function (pi: ExtensionAPI) {
 						{
 							type: "text",
 							text:
-								`Process started (id: ${res.id}). ${NOTIFY_MARKER}\n${nextStep}\n` +
+								`${retried ? "Retried once after external worker death.\n" : ""}` +
+								`Process started (id: ${res.id}). ${NOTIFY_MARKER}\nLog: ${logPath(res.id)}\n${nextStep}\n` +
 								`Inspect: babysit_check { id: "${res.id}" } (screen: true for TUIs) · ` +
 								`Wait: babysit_wait { id: "${res.id}" } · Kill: babysit_kill { id: "${res.id}" }\n` +
 								`Human can watch/take over: /babysit`,
 						},
 					],
-					details: { id: res.id, kind: "process", command: params.command, report: params.report },
+					details: { id: res.id, kind: "process", command: params.command, logPath: logPath(res.id), retried },
 					// Do not return `terminate: true` here. In RPC/subagent hosts that hint
 					// can shut down the hosting pi worker, whose process-tree cleanup then
 					// kills the otherwise detached babysit supervisor and closes its PTY
@@ -1652,6 +1582,7 @@ export default function (pi: ExtensionAPI) {
 				}
 				if (st.exit_code != null) header += ` exit_code=${st.exit_code}`;
 				if (meta?.command) header += `\ncommand: ${meta.command}`;
+				header += `\nlog: ${logPath(params.id)}`;
 				if (st.note) header += ` ⚑ ${st.note}`;
 				parts.push(header);
 				if (params.screen) {
@@ -1666,7 +1597,7 @@ export default function (pi: ExtensionAPI) {
 				}
 				return {
 					content: [{ type: "text", text: parts.join("\n") }],
-					details: { status: st, kind: "process" },
+					details: { status: st, kind: "process", logPath: logPath(params.id) },
 				};
 			}
 
@@ -1876,62 +1807,6 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 
-	// ----- babysit_analyze ----------------------------------------------------
-	pi.registerTool({
-		name: "babysit_analyze",
-		label: "Babysit: analyze",
-		description:
-			"Run a local analyzer over a babysit process's complete captured log. The raw log remains outside " +
-			"the model context; only the analyzer's bounded stdout is returned. JavaScript/Python receive " +
-			"FILE_CONTENT and INPUT strings; shell receives $BABYSIT_REPORT_INPUT. It can inspect a running " +
-			"session's output so far or a completed session.",
-		promptSnippet: "Analyze a babysit process log locally and return only a concise report",
-		promptGuidelines: [
-			"Use babysit_analyze to extract failures, counts, or other concise facts from a large babysit process log instead of calling babysit_check repeatedly or returning raw logs.",
-		],
-		parameters: Type.Object({
-			id: Type.String({ description: "Process session id whose captured log should be analyzed." }),
-			language: StringEnum(["javascript", "python", "shell"] as const, {
-				description: "Language for the local analyzer program.",
-			}),
-			code: Type.String({
-				description:
-					"Analyzer program. JavaScript/Python receive FILE_CONTENT and INPUT strings; shell reads $BABYSIT_REPORT_INPUT. Print only the concise result.",
-			}),
-			timeout: Type.Optional(
-				Type.String({ description: "Analyzer timeout (default 30s, e.g. '10s')." }),
-			),
-		}),
-		async execute(_id, params, signal) {
-			await requireBabysit();
-			const status = await statusOf(params.id);
-			if (!status) {
-				return {
-					content: [{ type: "text", text: `No such session: ${params.id}` }],
-					isError: true,
-					details: {},
-				};
-			}
-			if (kindOf(params.id) === "subagent") {
-				return {
-					content: [{ type: "text", text: "babysit_analyze supports process sessions only; use babysit_check for subagent progress." }],
-					isError: true,
-					details: {},
-				};
-			}
-			const report = await runReport(params.id, {
-				language: params.language,
-				code: params.code,
-				timeout: params.timeout,
-			}, signal);
-			return {
-				content: [{ type: "text", text: report.text }],
-				isError: !report.ok,
-				details: {},
-			};
-		},
-	});
-
 	// ----- babysit_wait -------------------------------------------------------
 	pi.registerTool({
 		name: "babysit_wait",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@yusukeshib/pi-babysit",
-  "version": "0.2.4",
-  "description": "Run long-lived processes and pi subagents under babysit, with bounded local reports over captured logs.",
+  "version": "0.3.1",
+  "description": "Run any shell command and pi subagents under babysit, with context-safe captured output.",
   "keywords": [
     "pi-package",
     "pi-extension",