@yusukeshib/pi-babysit 0.3.9 → 0.3.12

package/README.md

@@ -62,8 +62,11 @@ programs** (installers, wizards, REPLs): type with `babysit_send`
 | `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, verify terminal state, then suppress the exit notification |
 
-A `tool_call` hook blocks shell backgrounding (`… &`, `nohup`, `setsid`,
-`disown`) and redirects all direct `bash` commands to `babysit_run`.
+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.
 
 ## Commands (human)
 
@@ -91,11 +94,21 @@ babysit_check { id: "cargo-test", lines: 50 }
 babysit_check { id: "cargo-test", pattern: "FAIL|ERROR", lines: 50 }
 ```
 
-Tail and search results are capped at 200 lines and clipped to 8 KB. Pattern
-search returns the latest matching lines with line numbers. Do not read a
-potentially large log file in full.
-
-All shell commands, including `pwd` and Git, are redirected to `babysit_run`.
+Tail and search results are capped at 200 lines, and the complete returned tool
+result (including lifecycle headers) is clipped to 8 KB. Pattern search returns
+the latest matching lines with line numbers. Prefer a targeted pattern over a
+broad tail, and do not read a potentially large log file in full.
+
+Subagent logs also compact Pi's streaming `message_update` events before they
+are recorded. Pi repeats the complete growing assistant message and partial
+snapshot on every token; pi-babysit retains only the incremental delta while
+leaving authoritative `message_end`, tool, lifecycle, response, and error
+events untouched. This keeps long RPC sessions approximately linear in emitted
+content without changing final answers, completion detection, or follow-up
+behavior. Live `/babysit` and attach views render the retained deltas.
+
+All shell commands, including `pwd` and Git, go through `babysit_run`. Bundle
+closely related tiny observations when doing so safely reduces tool turns.
 Set `PI_BABYSIT_ALLOW_BASH=1` only as an explicit emergency escape hatch.
 
 ## Unexpected worker loss
@@ -109,9 +122,12 @@ because blindly rerunning an arbitrary command can duplicate side effects.
 
 ## How completion detection works
 
-- **Process**: a 2.5s poller watches for running→exited transitions and injects
-  one `pi.sendMessage(…, { triggerTurn: true, deliverAs: "steer" })` containing
-  every deliverable exit observed in that poll (deduped via `meta/<id>.json`).
+- **Process**: a 2.5s poller watches for running→exited transitions and, once the
+  parent agent is idle, injects one
+  `pi.sendMessage(…, { triggerTurn: true, deliverAs: "steer" })` containing every
+  deliverable exit observed in that poll (deduped via `meta/<id>.json`). Waiting
+  for idleness prevents an immediately-following `babysit_wait` from racing the
+  poller and receiving a duplicate completion.
   `babysit_kill` and an exit already reported by `babysit_wait` suppress the
   notification.
 - **Subagent**: `babysit_wait` blocks on `babysit expect '"type":"agent_end"'`.

package/format-stream.mjs

@@ -1,12 +1,11 @@
 #!/usr/bin/env node
 /**
- * format-stream.mjs — human-readable view for a `pi --mode json` event stream.
+ * format-stream.mjs — human-readable view for a `pi --mode rpc` event stream.
  *
- * babysit records the raw JSONL to its log (machine scrapers + `babysit log`
- * stay untouched); this filter only sits on the interactive attach path via
- * `babysit run --view-cmd`. It reads the JSONL on stdin and prints a colored,
- * incrementally-streamed transcript on stdout so a human attaching the tmux
- * pane sees turns, thinking, tool calls and answers instead of a JSON firehose.
+ * This filter sits on the interactive attach path via `babysit run --view-cmd`.
+ * It accepts both Pi's raw cumulative updates and pi-babysit's compact deltas,
+ * then prints a colored, incrementally streamed transcript so a human sees
+ * turns, thinking, tool calls and answers instead of a JSON firehose.
  */
 import * as readline from "node:readline";
 
@@ -52,8 +51,8 @@ function summarizeTool(name, a = {}) {
 }
 
 // Join the text of a given block kind ("text" or "thinking") in a message's
-// content array. message_update re-emits the whole (growing) message, so we
-// compare lengths against what we've already printed to append only the delta.
+// content array. Unfiltered RPC streams repeat the whole growing message;
+// pi-babysit's compact stream instead retains only assistantMessageEvent.delta.
 function blockText(content, kind) {
 	if (!Array.isArray(content)) return "";
 	let s = "";
@@ -75,15 +74,20 @@ const openBlock = () => {
 	out("\n");
 };
 
-function streamMessage(msg, fresh = false) {
-	if (!msg || msg.role !== "assistant") return;
-	const id = msg.id ?? `t${turn}`;
+function messageState(id = `t${turn}`, fresh = false) {
 	if (fresh) emitted.delete(id);
 	let st = emitted.get(id);
 	if (!st) {
 		st = { think: 0, text: 0, hThink: false, hText: false };
 		emitted.set(id, st);
 	}
+	return st;
+}
+
+function streamMessage(msg, fresh = false) {
+	if (!msg || msg.role !== "assistant") return;
+	const id = msg.id ?? `t${turn}`;
+	const st = messageState(id, fresh);
 	const think = blockText(msg.content, "thinking");
 	if (think.length > st.think) {
 		if (!st.hThink) {
@@ -106,6 +110,28 @@ function streamMessage(msg, fresh = false) {
 	}
 }
 
+function streamDelta(event) {
+	if (!event || typeof event.delta !== "string" || !event.delta) return;
+	const st = messageState();
+	if (event.type === "thinking_delta") {
+		if (!st.hThink) {
+			openBlock();
+			out(`${C.gray}[think] `);
+			st.hThink = true;
+		}
+		out(C.gray + event.delta + C.reset);
+		st.think += event.delta.length;
+	} else if (event.type === "text_delta") {
+		if (!st.hText) {
+			openBlock();
+			out(`${C.green}[text]${C.reset} `);
+			st.hText = true;
+		}
+		out(event.delta);
+		st.text += event.delta.length;
+	}
+}
+
 function usageLine(msg) {
 	const u = msg?.usage;
 	if (!u) return;
@@ -138,7 +164,8 @@ rl.on("line", (line) => {
 			streamMessage(ev.message, true);
 			break;
 		case "message_update":
-			streamMessage(ev.message);
+			if (ev.message) streamMessage(ev.message);
+			else streamDelta(ev.assistantMessageEvent);
 			break;
 		case "message_end":
 			streamMessage(ev.message);

package/index.ts

@@ -36,10 +36,15 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
-import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
+import type {
+	ExtensionAPI,
+	ExtensionContext,
+	Theme,
+	ToolDefinition,
+} from "@earendil-works/pi-coding-agent";
 import { getMarkdownTheme } from "@earendil-works/pi-coding-agent";
-import { Box, Container, Markdown, Text } from "@earendil-works/pi-tui";
-import { Type } from "typebox";
+import { Box, Markdown, Text } 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";
 
@@ -130,10 +135,10 @@ export function planSubagentSpawn(
 // apart from any other turn end (see isParkedToolResult / self-reap.ts).
 export const NOTIFY_MARKER = "[notify-on-exit]";
 
-// Human-readable view for the subagent JSONL stream when a human attaches.
-// babysit records the raw JSON to its log (parsers unaffected) and pipes only
-// the live attach view through this formatter. Set PI_BABYSIT_VIEW_CMD="" to
-// disable (raw JSON), or to a custom command to override.
+// Human-readable view for the compact subagent JSONL stream when a human
+// attaches. The RPC proxy removes cumulative streaming snapshots before both
+// recording and display; authoritative events remain intact for parsers. Set
+// PI_BABYSIT_VIEW_CMD="" to disable formatting, or provide a custom command.
 const EXT_DIR = path.dirname(fileURLToPath(import.meta.url));
 const shq = (s: string) => `'${s.replace(/'/g, `'\\''`)}'`;
 const VIEW_CMD =
@@ -365,6 +370,10 @@ interface Meta {
 	// Temporary reservation while kill is in flight. Unlike `notified`, this
 	// must be cleared on failure so a real completion remains deliverable.
 	notificationPaused?: boolean;
+	// Concurrent explicit waits share a reference-counted notification claim.
+	// A timeout must not re-enable the poller while another wait still owns it.
+	waitReservations?: number;
+	waitCompletionClaimed?: boolean;
 	completionObservedAt?: number;
 	startedAt?: number;
 	// subagent
@@ -405,6 +414,10 @@ export function shouldDeliverProcessCompletion(
 	return meta?.kind === "process" && !meta.notified && !meta.notificationPaused;
 }
 
+export function shouldDeferCompletionNotification(agentIsIdle: boolean): boolean {
+	return !agentIsIdle;
+}
+
 const kindOf = (id: string): "process" | "subagent" => readMeta(id)?.kind ?? "process";
 
 // Compact elapsed formatting: "42s", "3m12s", "1h04m".
@@ -528,14 +541,26 @@ const NOTIFY_COMMAND_MAX_BYTES = byteLimitFromEnv("PI_BABYSIT_NOTIFY_COMMAND_MAX
 const NOTIFY_BATCH_MAX_BYTES = byteLimitFromEnv("PI_BABYSIT_NOTIFY_BATCH_MAX_BYTES", 8_000);
 const ANSWER_MAX_BYTES = 24_000; // subagent answers / error messages
 
-function clip(s: string, maxBytes = TAIL_MAX_BYTES): string {
+export function clip(s: string, maxBytes = TAIL_MAX_BYTES): string {
+	if (maxBytes <= 0) return "";
 	const buf = Buffer.from(s, "utf8");
 	if (buf.length <= maxBytes) return s;
-	const half = Math.floor(maxBytes / 2);
-	// Strip replacement chars from a mid-codepoint cut at the boundary.
-	const head = buf.subarray(0, half).toString("utf8").replace(/\uFFFD+$/, "");
-	const tail = buf.subarray(buf.length - half).toString("utf8").replace(/^\uFFFD+/, "");
-	return `${head}\n… [${buf.length - maxBytes} bytes elided] …\n${tail}`;
+
+	// The marker counts toward the limit. Recompute a few times because the
+	// omitted-byte count can change the marker's digit width.
+	let available = maxBytes;
+	let marker = "";
+	for (let i = 0; i < 3; i++) {
+		marker = `\n… [${buf.length - available} bytes elided] …\n`;
+		available = Math.max(0, maxBytes - Buffer.byteLength(marker, "utf8"));
+	}
+	if (Buffer.byteLength(marker, "utf8") > maxBytes) return truncateUtf8End(marker, maxBytes);
+	const headBytes = Math.floor(available / 2);
+	const tailBytes = available - headBytes;
+	// Strip replacement chars from a mid-codepoint cut at either boundary.
+	const head = buf.subarray(0, headBytes).toString("utf8").replace(/\uFFFD+$/, "");
+	const tail = buf.subarray(buf.length - tailBytes).toString("utf8").replace(/^\uFFFD+/, "");
+	return `${head}${marker}${tail}`;
 }
 
 async function searchLog(
@@ -634,7 +659,10 @@ export function summarizeNotificationCommand(command: string | undefined): strin
 			.trim()
 			.replace(/\r/g, "\\r")
 			.replace(/\n/g, "\\n")
-			.replace(/\t/g, "\\t") || "?";
+			.replace(/\t/g, "\\t")
+			.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x9F]/g, (char) =>
+				`\\x${char.charCodeAt(0).toString(16).toUpperCase().padStart(2, "0")}`,
+			) || "?";
 	const bytes = Buffer.from(preview, "utf8");
 	if (bytes.length <= NOTIFY_COMMAND_MAX_BYTES) return preview;
 	if (NOTIFY_COMMAND_MAX_BYTES === 0) return "";
@@ -674,6 +702,7 @@ interface ProcessCompletionMessage {
 		status: CompletionStatus;
 		runtime?: string;
 		logPath?: string;
+		command?: string;
 		count: number;
 		totalCount: number;
 		remainingCount: number;
@@ -683,6 +712,7 @@ interface ProcessCompletionMessage {
 			success: boolean;
 			status: CompletionStatus;
 			runtime: string;
+			command: string | undefined;
 			logPath: string;
 		}>;
 	};
@@ -791,6 +821,7 @@ export function buildProcessCompletionMessage(
 		success: notice.success,
 		status: notice.status,
 		runtime: notice.runtime,
+		command: notice.command,
 		logPath: notice.logPath,
 	}));
 	const single = totalCount === 1 ? batch[0] : undefined;
@@ -805,6 +836,7 @@ export function buildProcessCompletionMessage(
 			status,
 			runtime: single?.runtime,
 			logPath: single?.logPath,
+			command: single?.command,
 			count: batch.length,
 			totalCount,
 			remainingCount: totalCount - batch.length,
@@ -871,7 +903,7 @@ interface ToolCall {
 	name: string;
 	summary: string;
 }
-interface Progress {
+export interface Progress {
 	turns: number;
 	toolCalls: ToolCall[];
 	finalText: string;
@@ -914,7 +946,7 @@ function summarizeToolCall(name: string, args: Record<string, unknown>): string
 	}
 }
 
-function parseEvents(logText: string): Progress {
+export function parseEvents(logText: string): Progress {
 	const p: Progress = {
 		turns: 0,
 		toolCalls: [],
@@ -1122,13 +1154,21 @@ async function spawnSubagent(
 		"--timeout",
 		opts.timeout,
 	];
-	// Pretty-print the JSONL stream for humans who `attach`; the recorded log
-	// stays raw so parseEvents/`babysit log` are unaffected.
+	// Pretty-print the compact JSONL stream for humans who `attach`. The RPC
+	// proxy removes only cumulative streaming snapshots; authoritative final,
+	// tool, lifecycle, response, and error events remain intact for parseEvents.
 	if (VIEW_CMD.trim()) bsArgs.push("--view-cmd", VIEW_CMD);
 	if (opts.idleTimeout && opts.idleTimeout !== "none") {
 		bsArgs.push("--idle-timeout", opts.idleTimeout);
 	}
-	bsArgs.push("--", PI_BIN, ...piArgs);
+	bsArgs.push(
+		"--",
+		process.execPath,
+		path.join(EXT_DIR, "rpc-stream-proxy.mjs"),
+		"--",
+		PI_BIN,
+		...piArgs,
+	);
 
 	const r = await bs(bsArgs, {
 		cwd: opts.cwd,
@@ -1427,19 +1467,47 @@ function suppressNotify(id: string, reason: "observed" | "kill" = "observed"): v
 	}
 }
 
-export function canRestoreNotificationAfterWait(meta: {
+export interface WaitReservationState {
 	notified?: boolean;
 	killNotificationSuppressed?: boolean;
-}): boolean {
-	return meta.notified === true && meta.killNotificationSuppressed !== true;
+	waitReservations?: number;
+	waitCompletionClaimed?: boolean;
 }
 
-function enableNotify(id: string): void {
-	const meta = readMeta(id);
-	if (meta && meta.kind === "process" && canRestoreNotificationAfterWait(meta)) {
-		meta.notified = false;
-		writeMeta(id, meta);
+export function canRestoreNotificationAfterWait(meta: WaitReservationState): boolean {
+	return (
+		meta.notified === true &&
+		meta.killNotificationSuppressed !== true &&
+		meta.waitCompletionClaimed !== true &&
+		(meta.waitReservations ?? 0) === 0
+	);
+}
+
+export function transitionWaitReservation(
+	state: WaitReservationState,
+	action: "reserve" | "abandon" | "claim",
+): WaitReservationState {
+	const next = { ...state };
+	if (action === "reserve") {
+		next.waitReservations = (next.waitReservations ?? 0) + 1;
+		next.notified = true;
+		return next;
 	}
+
+	next.waitReservations = Math.max(0, (next.waitReservations ?? 0) - 1);
+	if (action === "claim") next.waitCompletionClaimed = true;
+	if (action === "claim" || next.waitCompletionClaimed) {
+		next.notified = true;
+	} else if (canRestoreNotificationAfterWait(next)) {
+		next.notified = false;
+	}
+	return next;
+}
+
+function updateWaitReservation(id: string, action: "reserve" | "abandon" | "claim"): void {
+	const meta = readMeta(id);
+	if (!meta || meta.kind !== "process") return;
+	writeMeta(id, { ...meta, ...transitionWaitReservation(meta, action) });
 }
 
 function pauseNotify(id: string): void {
@@ -1493,19 +1561,20 @@ 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);
+		// An explicit wait owns completion delivery. Reference-count the claim so
+		// one concurrent wait timing out cannot re-enable notifications underneath
+		// another wait that is still pending.
+		updateWaitReservation(id, "reserve");
 		const w = await bs(["wait", "-s", id, "--timeout", t], { signal });
 		if (signal?.aborted || w.code === 130) {
-			enableNotify(id);
+			updateWaitReservation(id, "abandon");
 			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);
+				updateWaitReservation(id, "abandon");
 				return {
 					id,
 					kind: "timeout",
@@ -1519,9 +1588,15 @@ async function waitForExit(
 
 	const st = await statusOf(id);
 	if (!st) {
+		// A non-pattern backend wait returned before this lookup, so preserve its
+		// completion claim when status persistence is transiently unavailable.
+		// Abandoning here can re-enable the poller and duplicate a completion the
+		// explicit wait already consumed. This matches the old suppress-first rule.
+		if (!expectPattern) updateWaitReservation(id, "claim");
 		return { id, kind: "exited", ok: false, text: `No such session: ${id}` };
 	}
-	suppressNotify(id); // the agent sees the exit here; don't notify again
+	if (expectPattern) suppressNotify(id);
+	else updateWaitReservation(id, "claim"); // the agent sees the exit here; don't notify again
 	const meta = readMeta(id);
 	const workerDead = st.state === "dead" && st.exit_code == null;
 	const ok = st.exit_code === 0;
@@ -1573,12 +1648,41 @@ export function isAllowedDirectBash(_command: string): boolean {
 	return process.env.PI_BABYSIT_ALLOW_BASH === "1";
 }
 
+export function activeToolsWithoutDirectBash(activeTools: string[], allowDirectBash: boolean): string[] {
+	return allowDirectBash ? activeTools : activeTools.filter((name) => name !== "bash");
+}
+
 // ---------------------------------------------------------------------------
 // extension
 // ---------------------------------------------------------------------------
 
 export default function (pi: ExtensionAPI) {
 	let pollTimer: ReturnType<typeof setInterval> | undefined;
+	const declaredToolErrors = new Set<string>();
+
+	// Pi only persists custom-tool failures when they are thrown or patched by a
+	// tool_result hook; an `isError` property returned from execute() is ignored.
+	// Keep the structured result (status, log path, diagnostics) while promoting
+	// its declared error bit at the supported hook boundary.
+	const registerTool = <TParams extends TSchema, TDetails, TState>(
+		tool: ToolDefinition<TParams, TDetails, TState>,
+	): void => {
+		const execute = tool.execute;
+		pi.registerTool({
+			...tool,
+			async execute(toolCallId, params, signal, onUpdate, ctx) {
+				const result = await execute(toolCallId, params, signal, onUpdate, ctx);
+				if ((result as typeof result & { isError?: boolean }).isError === true) {
+					declaredToolErrors.add(toolCallId);
+				}
+				return result;
+			},
+		});
+	};
+
+	pi.on("tool_result", (event) => {
+		if (declaredToolErrors.delete(event.toolCallId)) return { isError: true };
+	});
 
 	// Exit notifications for kind=process sessions: the poller detects
 	// running→exited transitions and injects ONE message (triggerTurn) for all
@@ -1586,7 +1690,11 @@ export default function (pi: ExtensionAPI) {
 	// that ended its turn after babysit_run without spending one turn per exit.
 	// Kills via babysit_kill and exits already reported by babysit_wait are
 	// suppressed via meta.notified.
-	async function notifyEndedProcesses(): Promise<void> {
+	async function notifyEndedProcesses(ctx: ExtensionContext): Promise<void> {
+		// Never steer a completion into an active agent turn. In particular, this
+		// lets an immediately-following babysit_wait reserve the completion first,
+		// instead of racing the poller and receiving both wait + auto notification.
+		if (shouldDeferCompletionNotification(ctx.isIdle())) return;
 		const { sessions } = await listSessions();
 		const ready: Array<{ session: BsSession; meta: Meta }> = [];
 		for (const session of sessions) {
@@ -1645,6 +1753,9 @@ export default function (pi: ExtensionAPI) {
 			metadataById.set(notice.id, current);
 			return [{ ...notice, command: current.command }];
 		});
+		// Output collection above yields to the event loop. Re-check idleness so a
+		// newly-started agent turn cannot receive a duplicate completion mid-turn.
+		if (shouldDeferCompletionNotification(ctx.isIdle())) return;
 		deliverProcessCompletionMessage(
 			notices,
 			(message, options) => pi.sendMessage(message, options),
@@ -1738,17 +1849,36 @@ export default function (pi: ExtensionAPI) {
 			status?: DisplayStatus;
 			success?: boolean;
 			exitCode?: number | null;
+			command?: string;
+			count?: number;
 		};
 		const status =
 			d.status ?? (d.success ? "success" : d.exitCode == null ? "terminated" : "failed");
+		const payload = d.command
+			? `  ${summarizeNotificationCommand(d.command)}`
+			: d.count && d.count > 1
+				? `  ×${d.count}`
+				: "";
+		const header = theme.fg("warning", theme.bold(`babysit_run COMMAND${payload}`));
 		const box = new Box(1, 1, (t) => theme.bg("toolSuccessBg", t));
-		box.addChild(new Text(renderStatus(status, theme, "babysit_run"), 0, 0));
+		box.addChild(new Text(header, 0, 0));
+		box.addChild(new Text(renderStatus(status, theme), 0, 0));
 		box.addChild(new Text(theme.fg("toolOutput", content), 0, 0));
 		return box;
 	});
 
 	let polling = false;
 	pi.on("session_start", async (_event, ctx) => {
+		// Do not expose the built-in bash tool only to reject it after the model has
+		// already paid for a failed tool turn. The tool_call hook remains a fallback
+		// if another extension/preset re-enables bash later in the session.
+		const activeTools = pi.getActiveTools();
+		const supervisedTools = activeToolsWithoutDirectBash(
+			activeTools,
+			isAllowedDirectBash(""),
+		);
+		if (supervisedTools.length !== activeTools.length) pi.setActiveTools(supervisedTools);
+
 		// Session-local registry: scope the babysit root to this pi session so
 		// other sessions' processes/subagents are invisible here. Resuming a
 		// session keeps the same id, so its sessions come back with it.
@@ -1768,7 +1898,7 @@ export default function (pi: ExtensionAPI) {
 			// calls never stack up.
 			if (polling) return;
 			polling = true;
-			Promise.all([notifyEndedProcesses(), refreshWidget(ctx)])
+			Promise.all([notifyEndedProcesses(ctx), refreshWidget(ctx)])
 				.catch(() => {
 					/* ignore poll errors */
 				})
@@ -1805,7 +1935,7 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	// ----- babysit_run --------------------------------------------------------
-	pi.registerTool({
+	registerTool({
 		name: "babysit_run",
 		label: "Babysit: run",
 		description:
@@ -1826,7 +1956,8 @@ export default function (pi: ExtensionAPI) {
 			"Run any shell command with context-safe captured output; quick commands return metadata, longer ones continue in background",
 		promptGuidelines: [
 			"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 with babysit_check { id, lines, pattern? }; never read or cat a potentially large log file in full.",
+			"Bundle closely related tiny observations into one babysit_run command when that reduces tool turns without obscuring lifecycle or failure handling.",
+			"Inspect a babysit log with babysit_check { id, lines, pattern? }; never read or cat a potentially large log file in full. Prefer a targeted `pattern` search over returning a broad tail.",
 			"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').",
 			"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 }.",
@@ -2129,10 +2260,19 @@ export default function (pi: ExtensionAPI) {
 				},
 			};
 		},
-		// The result label already includes "babysit_run"; suppress the default
-		// call header so the tool name is not shown twice in adjacent lines.
-		renderCall() {
-			return new Container();
+		// Make the execution kind and payload identifiable before the result arrives.
+		// Use semantic theme colors rather than the fallback gray tool-call text.
+		renderCall(args, theme) {
+			const isSubagent = args.profile === "subagent";
+			const kind = isSubagent ? "AGENT" : "COMMAND";
+			const payload = isSubagent ? args.task : args.command;
+			const agent = isSubagent && args.agent ? ` [${args.agent}]` : "";
+			const title = theme.bold(`babysit_run ${kind}`);
+			const detail =
+				typeof payload === "string" && payload.length > 0
+					? `  ${summarizeNotificationCommand(payload)}`
+					: "";
+			return new Text(theme.fg("warning", `${title}${agent}${detail}`), 0, 0);
 		},
 		renderResult(result, { isPartial }, theme, context) {
 			const details = (result.details ?? {}) as {
@@ -2160,13 +2300,13 @@ export default function (pi: ExtensionAPI) {
 							: details.kind === "subagent" || content.includes(NOTIFY_MARKER)
 								? "started"
 								: "success");
-			const label = renderStatus(status, theme, "babysit_run");
+			const label = renderStatus(status, theme);
 			return new Text(content ? `${label}\n${theme.fg("toolOutput", content)}` : label, 0, 0);
 		},
 	});
 
 	// ----- babysit_check ------------------------------------------------------
-	pi.registerTool({
+	registerTool({
 		name: "babysit_check",
 		label: "Babysit: check",
 		description:
@@ -2224,7 +2364,7 @@ export default function (pi: ExtensionAPI) {
 					const preview = what.length > 60 ? `${what.slice(0, 57)}…` : what;
 					return `${s.id}  [${kind}] ${s.state}${ec}${depth}${flag}${preview ? `  — ${preview}` : ""}`;
 				});
-				return { content: [{ type: "text", text: lines.join("\n") }], details: { sessions } };
+				return { content: [{ type: "text", text: clip(lines.join("\n")) }], details: { sessions } };
 			}
 
 			const st = await statusOf(params.id);
@@ -2266,7 +2406,7 @@ export default function (pi: ExtensionAPI) {
 					? `--- latest matches /${params.pattern}/ ---\n${result.text}`
 					: `(no output matching /${params.pattern}/)`;
 				return {
-					content: [{ type: "text", text: `${header}\n${body}` }],
+					content: [{ type: "text", text: clip(`${header}\n${body}`) }],
 					details: { status: st, kind, logPath: logPath(params.id), pattern: params.pattern },
 				};
 			}
@@ -2294,7 +2434,7 @@ export default function (pi: ExtensionAPI) {
 					parts.push(tail ? `--- recent output ---\n${tail}` : "(no output yet)");
 				}
 				return {
-					content: [{ type: "text", text: parts.join("\n") }],
+					content: [{ type: "text", text: clip(parts.join("\n")) }],
 					details: { status: st, kind: "process", logPath: logPath(params.id) },
 				};
 			}
@@ -2356,7 +2496,7 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	// ----- babysit_send -------------------------------------------------------
-	pi.registerTool({
+	registerTool({
 		name: "babysit_send",
 		label: "Babysit: send",
 		description:
@@ -2509,7 +2649,7 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	// ----- babysit_wait -------------------------------------------------------
-	pi.registerTool({
+	registerTool({
 		name: "babysit_wait",
 		label: "Babysit: wait",
 		description:
@@ -2620,7 +2760,7 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	// ----- babysit_kill -------------------------------------------------------
-	pi.registerTool({
+	registerTool({
 		name: "babysit_kill",
 		label: "Babysit: kill",
 		description: "Terminate a babysit session (process or subagent).",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yusukeshib/pi-babysit",
-  "version": "0.3.9",
+  "version": "0.3.12",
   "description": "Run any shell command and pi subagents under babysit, with context-safe captured output.",
   "keywords": [
     "pi-package",
@@ -23,6 +23,7 @@
     "agents.ts",
     "self-reap.ts",
     "format-stream.mjs",
+    "rpc-stream-proxy.mjs",
     "search-log.mjs",
     "README.md",
     "LICENSE"

package/rpc-stream-proxy.mjs

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+/**
+ * Transparent stdin/stdout proxy for `pi --mode rpc`.
+ *
+ * Pi's `message_update` events repeat the entire growing assistant message and
+ * `assistantMessageEvent.partial` on every token. Those cumulative snapshots
+ * are useful only while streaming; `message_end` is the authoritative final
+ * message. Persisting every snapshot makes babysit logs grow quadratically.
+ *
+ * This proxy forwards stdin byte-for-byte and compacts only `message_update`
+ * lines on stdout. All final, tool, lifecycle, response, and error events pass
+ * through byte-for-byte.
+ */
+import { spawn } from "node:child_process";
+import { StringDecoder } from "node:string_decoder";
+import { pathToFileURL } from "node:url";
+
+export function compactRpcLine(line) {
+	if (!line.trimStart().startsWith("{")) return line;
+
+	let event;
+	try {
+		event = JSON.parse(line);
+	} catch {
+		return line;
+	}
+	if (event?.type !== "message_update") return line;
+
+	const { message: _cumulativeMessage, assistantMessageEvent, ...rest } = event;
+	if (!assistantMessageEvent || typeof assistantMessageEvent !== "object") {
+		return JSON.stringify(rest);
+	}
+	const { partial: _cumulativePartial, ...deltaEvent } = assistantMessageEvent;
+	return JSON.stringify({ ...rest, assistantMessageEvent: deltaEvent });
+}
+
+function transformRpcOutput(input, output) {
+	return new Promise((resolve, reject) => {
+		const decoder = new StringDecoder("utf8");
+		let buffered = "";
+
+		const write = (value) => {
+			if (!output.write(value)) input.pause();
+		};
+		output.on("drain", () => input.resume());
+		input.on("error", reject);
+		input.on("data", (chunk) => {
+			buffered += decoder.write(chunk);
+			for (;;) {
+				const newline = buffered.indexOf("\n");
+				if (newline < 0) break;
+				const line = buffered.slice(0, newline);
+				buffered = buffered.slice(newline + 1);
+				write(`${compactRpcLine(line)}\n`);
+			}
+		});
+		input.on("end", () => {
+			buffered += decoder.end();
+			if (buffered) write(compactRpcLine(buffered));
+			if (output.writableNeedDrain) output.once("drain", resolve);
+			else resolve();
+		});
+	});
+}
+
+function waitForDrain(stream) {
+	return stream.writableNeedDrain
+		? new Promise((resolve) => stream.once("drain", resolve))
+		: Promise.resolve();
+}
+
+export function runRpcProxy(argv = process.argv.slice(2)) {
+	const separator = argv.indexOf("--");
+	const command = separator >= 0 ? argv[separator + 1] : argv[0];
+	const args = separator >= 0 ? argv.slice(separator + 2) : argv.slice(1);
+	if (!command) {
+		console.error("Usage: rpc-stream-proxy.mjs -- <command> [args...]");
+		process.exitCode = 2;
+		return;
+	}
+
+	const child = spawn(command, args, {
+		cwd: process.cwd(),
+		env: process.env,
+		stdio: ["pipe", "pipe", "pipe"],
+	});
+
+	let transportFailed = false;
+	process.stdin.pipe(child.stdin);
+	// The RPC worker can exit or self-reap while a command is still arriving.
+	// Ignore the resulting pipe-close race so the proxy preserves the worker's
+	// actual exit code/signal instead of crashing with an unhandled EPIPE.
+	child.stdin.on("error", (error) => {
+		if (error?.code === "EPIPE" || error?.code === "ERR_STREAM_DESTROYED") return;
+		transportFailed = true;
+		console.error(`rpc stream proxy stdin failed: ${error.message}`);
+	});
+	const outputFlushed = transformRpcOutput(child.stdout, process.stdout);
+	child.stderr.pipe(process.stderr);
+
+	const forwardedSignals = ["SIGINT", "SIGTERM", "SIGHUP"];
+	const signalHandlers = new Map(
+		forwardedSignals.map((signal) => [signal, () => child.kill(signal)]),
+	);
+	for (const [signal, handler] of signalHandlers) process.on(signal, handler);
+	let spawnFailed = false;
+	child.on("error", (error) => {
+		spawnFailed = true;
+		console.error(`rpc stream proxy failed to start ${command}: ${error.message}`);
+	});
+	child.on("close", async (code, signal) => {
+		try {
+			await outputFlushed;
+			await Promise.all([waitForDrain(process.stdout), waitForDrain(process.stderr)]);
+		} catch (error) {
+			console.error(`rpc stream proxy output failed: ${error.message}`);
+			process.exitCode = 1;
+			return;
+		}
+		if (transportFailed) {
+			process.exitCode = 1;
+			return;
+		}
+		if (signal) {
+			for (const [forwarded, handler] of signalHandlers) process.off(forwarded, handler);
+			process.kill(process.pid, signal);
+			return;
+		}
+		process.exitCode = spawnFailed ? 1 : (code ?? 1);
+	});
+}
+
+const entry = process.argv[1] ? pathToFileURL(process.argv[1]).href : undefined;
+if (entry === import.meta.url) runRpcProxy();