@yusukeshib/pi-babysit 0.3.12 → 0.3.14

package/package.json

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

package/rpc-stream-proxy.mjs

@@ -7,15 +7,45 @@
  * 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.
+ * This proxy forwards stdin byte-for-byte. `message_update` snapshots are
+ * always compacted. In opt-in `compact` log mode, redundant payloads on
+ * lifecycle/tool events are also removed while authoritative `message_end`,
+ * response, and error events remain intact. Set PI_BABYSIT_RPC_LOG_MODE=standard
+ * to retain the legacy lifecycle payloads.
  */
 import { spawn } from "node:child_process";
 import { StringDecoder } from "node:string_decoder";
 import { pathToFileURL } from "node:url";
 
-export function compactRpcLine(line) {
+function isParkedMessages(messages) {
+	if (!Array.isArray(messages)) return false;
+	for (let index = messages.length - 1; index >= 0; index--) {
+		const message = messages[index];
+		if (message?.role !== "toolResult") continue;
+		if (message.toolName === "process") return true;
+		if (message.toolName !== "babysit_run") continue;
+		if (message.details?.kind === "process" && message.details.status === "started") {
+			return true;
+		}
+		const text = Array.isArray(message.content)
+			? message.content
+					.filter((part) => part?.type === "text" && typeof part.text === "string")
+					.map((part) => part.text)
+					.join("")
+			: typeof message.content === "string"
+				? message.content
+				: "";
+		if (/^Process started \(id: [^)]+\)\. \[notify-on-exit\]\nLog: /.test(text)) {
+			return true;
+		}
+	}
+	return false;
+}
+
+export function compactRpcLine(
+	line,
+	mode = process.env.PI_BABYSIT_RPC_LOG_MODE ?? "standard",
+) {
 	if (!line.trimStart().startsWith("{")) return line;
 
 	let event;
@@ -24,14 +54,44 @@ export function compactRpcLine(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);
+	if (event?.type === "message_update") {
+		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 });
+	}
+	if (mode !== "compact") return line;
+
+	switch (event?.type) {
+		case "message_start": {
+			const { message, ...rest } = event;
+			return JSON.stringify({
+				...rest,
+				message:
+					message && typeof message === "object"
+						? { role: message.role, toolName: message.toolName, toolCallId: message.toolCallId }
+						: message,
+			});
+		}
+		case "turn_end": {
+			const { message: _message, toolResults: _toolResults, ...rest } = event;
+			return JSON.stringify(rest);
+		}
+		case "agent_end": {
+			const { messages, ...rest } = event;
+			return JSON.stringify({ ...rest, piBabysitParked: isParkedMessages(messages) });
+		}
+		case "tool_execution_end": {
+			if (event.isError) return line;
+			const { result: _result, ...rest } = event;
+			return JSON.stringify(rest);
+		}
+		default:
+			return line;
 	}
-	const { partial: _cumulativePartial, ...deltaEvent } = assistantMessageEvent;
-	return JSON.stringify({ ...rest, assistantMessageEvent: deltaEvent });
 }
 
 function transformRpcOutput(input, output) {

package/self-reap.ts

@@ -13,8 +13,8 @@
  *      keep talking to never dies; only a genuinely-abandoned one does.
  *   2. Process parks — a turn that ends only to await a background-process
  *      exit notification (babysit_run inside the subagent, or the legacy
- *      `process` tool) also emits `agent_end`, but pi resumes on its own. We
- *      detect that (last message is a parked toolResult, same rule the parent
+ *      `process` tool) also settles the agent, but pi resumes on its own. We
+ *      detect a parked toolResult anywhere in that run (same rule the parent
  *      uses) and DON'T schedule a reap, so a subagent waiting on a long
  *      build/test is never false-killed.
  *
@@ -23,10 +23,8 @@
  */
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
-// Keep in sync with NOTIFY_MARKER in index.ts (not imported: this file is
-// loaded standalone into the subagent process via --extension).
-const NOTIFY_MARKER = "[notify-on-exit]";
-
+// Loaded standalone into the subagent process via --extension, so the parked
+// result-shape check below intentionally mirrors index.ts without importing it.
 function parseDurMs(s: string | undefined): number | null {
 	if (!s || s === "none" || s === "off" || s === "0") return null;
 	const m = /^(\d+)(ms|s|m|h)?$/.exec(s.trim());
@@ -36,22 +34,40 @@ function parseDurMs(s: string | undefined): number | null {
 	return n * (u === "ms" ? 1 : u === "s" ? 1000 : u === "m" ? 60_000 : 3_600_000);
 }
 
-// Same parked-turn rule as the parent (see index.ts isParkedToolResult):
-// a babysit_run process start stamps NOTIFY_MARKER into its tool result; that
-// as the LAST message means "parked awaiting the exit notification".
-function isParked(
-	last: { role?: string; toolName?: string; content?: unknown } | undefined,
+// Same parked-turn rule as the parent: scan the run because models sometimes
+// add an assistant note after the marker-bearing tool result.
+export function isParked(
+	messages:
+		| {
+				role?: string;
+				toolName?: string;
+				content?: unknown;
+				details?: { kind?: string; status?: string };
+			}[]
+		| undefined,
 ): boolean {
-	if (!last || last.role !== "toolResult") return false;
-	if (last.toolName === "process") return true; // legacy pi-processes
-	if (last.toolName !== "babysit_run") return false;
-	try {
-		const s = JSON.stringify(last.content ?? null);
-		if (s === "null") return true; // unsure — never reap a possible build wait
-		return s.includes(NOTIFY_MARKER);
-	} catch {
-		return true;
+	if (!messages) return false;
+	for (let index = messages.length - 1; index >= 0; index--) {
+		const message = messages[index];
+		if (message?.role !== "toolResult") continue;
+		if (message.toolName === "process") return true; // legacy pi-processes
+		if (message.toolName !== "babysit_run") continue;
+		if (message.details?.kind === "process" && message.details.status === "started") {
+			return true;
+		}
+		const text = Array.isArray(message.content)
+			? message.content
+					.filter((part): part is { type: "text"; text: string } =>
+						Boolean(part && typeof part === "object" && part.type === "text" && typeof part.text === "string"),
+					)
+					.map((part) => part.text)
+					.join("")
+			: typeof message.content === "string"
+				? message.content
+				: "";
+		if (/^Process started \(id: [^)]+\)\. \[notify-on-exit\]\nLog: /.test(text)) return true;
 	}
+	return false;
 }
 
 export default function (pi: ExtensionAPI) {
@@ -61,6 +77,7 @@ export default function (pi: ExtensionAPI) {
 	if (graceMs == null) return; // reaping disabled
 
 	let timer: ReturnType<typeof setTimeout> | undefined;
+	let lastEndWasParked = false;
 	const cancel = () => {
 		if (timer) {
 			clearTimeout(timer);
@@ -71,22 +88,25 @@ export default function (pi: ExtensionAPI) {
 	// A new task/turn is starting — the subagent is wanted again. Stand down.
 	pi.on("before_agent_start", () => {
 		cancel();
+		lastEndWasParked = false;
 	});
 
 	pi.on("agent_end", (event) => {
-		cancel(); // supersede any earlier schedule with this end's decision
-
-		const msgs = (
+		const messages = (
 			event as { messages?: { role?: string; toolName?: string; content?: unknown }[] }
 		).messages;
-		if (isParked(msgs?.[msgs.length - 1])) return;
+		lastEndWasParked = isParked(messages);
+	});
 
+	// agent_end can precede automatic retries, compaction retries, and queued
+	// continuations. Start the grace timer only once Pi is truly settled.
+	pi.on("agent_settled", (_event, ctx) => {
+		cancel();
+		if (lastEndWasParked) return;
 		timer = setTimeout(() => {
-			// Clean exit: babysit sees the child exit and marks the session done,
-			// so it drops out of the session list/widget instead of idling.
-			process.exit(0);
+			// Graceful shutdown emits session_shutdown for every loaded extension.
+			ctx.shutdown();
 		}, graceMs);
-		// Don't let this timer keep the event loop alive on its own.
 		timer.unref?.();
 	});
 }