@yusukeshib/pi-babysit 0.2.0 → 0.2.2

package/index.ts

@@ -746,6 +746,50 @@ function renderWidgetLines(procs: number, busy: number, idle: number): string[]
 	return [`\x1b[44;97m ${parts.join(" \u00b7 ")} \x1b[0m`];
 }
 
+// How many trailing output lines to show per running session in the widget.
+const WIDGET_TAIL_LINES = 1;
+const WIDGET_TAIL_WIDTH = 100;
+
+// Strip ANSI/control escapes and clamp width so raw PTY output can't wrap or
+// corrupt the widget area.
+function sanitizeTailLine(s: string): string {
+	const clean = s
+		.replace(/\r/g, "")
+		// CSI / OSC / other escape sequences
+		.replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, "")
+		.replace(/\x1b[@-Z\\-_]|\x1b\[[0-?]*[ -/]*[@-~]/g, "")
+		// remaining non-printable control chars (keep tab)
+		.replace(/[\x00-\x08\x0b-\x1f\x7f]/g, "");
+	return clean.length > WIDGET_TAIL_WIDTH ? `${clean.slice(0, WIDGET_TAIL_WIDTH - 1)}…` : clean;
+}
+
+// Trailing lines to show for a running session (sanitized, unprefixed).
+// process → raw log tail; subagent → derived activity (recent tool calls /
+// partial answer), since its log is RPC JSONL, not human-readable.
+async function widgetTail(id: string, isSub: boolean): Promise<string[]> {
+	let raw: string[];
+	if (!isSub) {
+		const out = (await bs(["log", "-s", id, "--tail", String(WIDGET_TAIL_LINES)])).stdout;
+		raw = out.split("\n");
+	} else {
+		const meta = readMeta(id);
+		const logArgs = ["log", "-s", id];
+		if (meta?.promptOffset) logArgs.push("--since", String(meta.promptOffset));
+		const prog = parseEvents((await bs(logArgs)).stdout);
+		if (prog.finalText.trim()) {
+			raw = prog.finalText.trim().split("\n");
+		} else if (prog.toolCalls.length > 0) {
+			raw = prog.toolCalls.map((t) => t.summary);
+		} else {
+			raw = prog.errorMsg ? [`⚠ ${prog.errorMsg}`] : [];
+		}
+	}
+	return raw
+		.map(sanitizeTailLine)
+		.filter((l) => l.trim().length > 0)
+		.slice(-WIDGET_TAIL_LINES);
+}
+
 // Classify a running subagent as busy or idle by analyzing the current task's
 // log slice (same logic babysit_check uses).
 async function isTaskDone(id: string): Promise<boolean> {
@@ -1060,12 +1104,22 @@ export default function (pi: ExtensionAPI) {
 		const lines = renderWidgetLines(procs, subs.length - idle, idle);
 		// Per-session elapsed time (live: refreshed every poll tick).
 		const doneById = new Map(subs.map((s, i) => [s.id, doneFlags[i]]));
-		for (const s of active) {
+		const tails = await Promise.all(
+			active.map((s) => widgetTail(s.id, kindOf(s.id) === "subagent")),
+		);
+		active.forEach((s, i) => {
 			const isSub = kindOf(s.id) === "subagent";
 			const tag = isSub ? (doneById.get(s.id) ? "sub idle" : "sub") : "proc";
 			const el = elapsedOf(s.id);
-			lines.push(`  ⏳ ${s.id} [${tag}]${el ? ` ${el}` : ""}`);
-		}
+			const header = `  ⏳ ${s.id} [${tag}]${el ? ` ${el}` : ""}`;
+			if (tails[i].length === 1) {
+				// Single tail line: keep it on the same row as the header.
+				lines.push(`${header}  │ ${tails[i][0]}`);
+			} else {
+				lines.push(header);
+				for (const t of tails[i]) lines.push(`     │ ${t}`);
+			}
+		});
 		ctx.ui.setWidget("pi-babysit", lines, { placement: "belowEditor" });
 	};
 
@@ -1143,6 +1197,8 @@ export default function (pi: ExtensionAPI) {
 		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. " +
@@ -1257,6 +1313,23 @@ export default function (pi: ExtensionAPI) {
 					};
 				}
 				await refreshWidget(ctx);
+
+				// One-shot / non-interactive mode (e.g. `pi -p`): there is no live
+				// event loop to deliver the exit notification, and ending the turn
+				// would exit pi entirely — orphaning the babysat process and losing
+				// the session (the agent "settles" the moment it is told the turn will
+				// stop). So block inline like a normal command and return the full
+				// 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);
+					return {
+						content: [{ type: "text", text: outcome.text }],
+						isError: !outcome.ok,
+						details: { id: res.id, kind: "process", command: params.command },
+					};
+				}
+
 				const continueAfter = params.continueAfterStart === true;
 				const nextStep = continueAfter
 					? "Continue with specific non-polling work now; the exit notification will arrive on its own."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yusukeshib/pi-babysit",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "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.",
   "keywords": [
     "pi-package",