@yusukeshib/pi-babysit 0.2.3 → 0.3.0

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,7 +49,7 @@ 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`) 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_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"` |
@@ -67,6 +68,22 @@ 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`).
 
+## 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
+```
+
+`babysit_check { id, lines }` remains available as a convenient bounded tail.
+Do not read a potentially large log file in full.
+
 ## How completion detection works
 
 - **Process**: a 2.5s poller watches for running→exited transitions and injects

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,
@@ -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;
@@ -231,6 +232,7 @@ interface Meta {
 	name?: string;
 	command?: string;
 	notified?: boolean;
+	completionObservedAt?: number;
 	startedAt?: number;
 	// subagent
 	task?: string;
@@ -239,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 {
@@ -364,7 +367,8 @@ 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
 
 function clip(s: string, maxBytes = TAIL_MAX_BYTES): string {
@@ -377,6 +381,27 @@ function clip(s: string, maxBytes = TAIL_MAX_BYTES): string {
 	return `${head}\n… [${buf.length - maxBytes} bytes elided] …\n${tail}`;
 }
 
+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)
 // ---------------------------------------------------------------------------
@@ -830,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,
@@ -949,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(
@@ -965,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);
@@ -985,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",
@@ -1009,9 +1046,9 @@ async function waitForExit(
 		return { id, kind: "exited", ok: false, text: `No such session: ${id}` };
 	}
 	suppressNotify(id); // the agent sees the exit here; don't notify again
-	const tail = clip((await bs(["log", "-s", id, "--tail", "20"])).stdout.trim());
-	const ok = st.exit_code === 0;
 	const meta = readMeta(id);
+	const ok = st.exit_code === 0;
+	const output = await inlineOutput(id, st);
 	return {
 		id,
 		kind: "exited",
@@ -1020,7 +1057,7 @@ async function waitForExit(
 			`Process ${id}${meta?.command ? ` (${meta.command})` : ""} ` +
 			`${ok ? "completed successfully" : `exited with code ${st.exit_code ?? "?"}`}` +
 			`${expectPattern ? ` before /${expectPattern}/ appeared` : ""}.` +
-			(tail ? `\n\nLast output:\n${tail}` : ""),
+			`\nLog: ${logPath(id)}` + output,
 		status: st,
 	};
 }
@@ -1067,10 +1104,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 tail = 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`
 				: "?";
@@ -1083,11 +1129,10 @@ export default function (pi: ExtensionAPI) {
 				{
 					customType: "pi-babysit-process-end",
 					content:
-						`${summary}\nCommand: ${meta.command ?? "?"}` +
-						(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 },
+					details: { id: s.id, exitCode: s.exit_code, success: ok, runtime, logPath: logPath(s.id) },
 				},
 				{ triggerTurn: true, deliverAs: "steer" },
 			);
@@ -1196,20 +1241,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 " +
+			"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. " +
 			"you can type into it with babysit_send and read its screen with babysit_check. " +
 			"(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').",
+			"babysit_run returns only minimal lifecycle information and a path to the complete log. Inspect that file with bounded shell commands such as `tail` or `rg`; never read a potentially large log in full.",
 			"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.",
@@ -1269,6 +1319,7 @@ 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.",
 				}),
 			),
+
 		}),
 		async execute(_id, params, _signal, _onUpdate, ctx) {
 			await requireBabysit();
@@ -1304,7 +1355,7 @@ export default function (pi: ExtensionAPI) {
 					timeout: params.timeout,
 					idleTimeout: params.idleTimeout,
 					pty: params.pty ?? true,
-				});
+					});
 				if ("error" in res) {
 					return {
 						content: [{ type: "text", text: `Failed to start process: ${res.error}` }],
@@ -1326,7 +1377,23 @@ export default function (pi: ExtensionAPI) {
 					return {
 						content: [{ type: "text", text: outcome.text }],
 						isError: !outcome.ok,
-						details: { id: res.id, kind: "process", command: params.command },
+						details: { id: res.id, kind: "process", command: params.command, logPath: logPath(res.id) },
+					};
+				}
+
+				// 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 });
+				const 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: outcome.text }],
+						isError: !outcome.ok,
+						details: { id: res.id, kind: "process", command: params.command, logPath: logPath(res.id) },
 					};
 				}
 
@@ -1339,13 +1406,13 @@ export default function (pi: ExtensionAPI) {
 						{
 							type: "text",
 							text:
-								`Process started (id: ${res.id}). ${NOTIFY_MARKER}\n${nextStep}\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 },
+					details: { id: res.id, kind: "process", command: params.command, logPath: logPath(res.id) },
 					// 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
@@ -1482,6 +1549,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) {
@@ -1496,7 +1564,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) },
 				};
 			}
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@yusukeshib/pi-babysit",
-  "version": "0.2.3",
-  "description": "Run anything long-lived under babysit — one supervision substrate for processes and pi subagents, surfaced to the agent as babysit_run/check/send/wait/kill.",
+  "version": "0.3.0",
+  "description": "Run any shell command and pi subagents under babysit, with context-safe captured output.",
   "keywords": [
     "pi-package",
     "pi-extension",
@@ -27,6 +27,7 @@
     "LICENSE"
   ],
   "scripts": {
+    "test": "bun test",
     "release": "npm publish --access public"
   },
   "pi": {