@yusukeshib/pi-babysit 0.3.6 → 0.3.8

package/README.md

@@ -32,7 +32,7 @@ reachable from anywhere (`~/.pi-babysit/<pi-session-id>/`). Two kinds:
 
 | kind | started by | completion | on completion |
 | ---- | ---------- | ---------- | ------------- |
-| **process** | `babysit_run { command }` | process **exit** | automatic notification message (`triggerTurn`) — the agent may end its turn after starting and is resumed on exit, same contract as the old `process` tool |
+| **process** | `babysit_run { command }` | process **exit** | automatic notification message (`triggerTurn`), batched for all exits observed in the same poll — the agent may end its turn after starting and is resumed on exit, same contract as the old `process` tool |
 | **subagent** | `babysit_run { profile: "subagent", task }` | `agent_end` in the RPC event stream (process stays alive) | none — the agent polls `babysit_check` or blocks on `babysit_wait`; the idle session accepts follow-up tasks |
 
 The **profile is a tool parameter, not a separate tool set**: domain knowledge
@@ -53,7 +53,7 @@ programs** (installers, wizards, REPLs): type with `babysit_send`
 | `babysit_check` | List all sessions, inspect one, tail its bounded recent output, or search its raw log with `pattern`; `screen: true` captures TUIs and subagents otherwise show structured live progress |
 | `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) |
+| `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`.
@@ -71,9 +71,13 @@ A minimal widget above the editor shows live counts
 
 `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 it through the session id without creating
-another shell session:
+Explicit run/wait results inline complete output up to 8 KB; unsolicited
+completion notifications use a stricter 2 KB per-process output cap and an 8 KB
+aggregate message cap. Process exits observed in one poll share one message and
+trigger one agent turn. If even the compact summaries and log paths exceed the
+aggregate cap, the largest fitting prefix is delivered and the remainder stays
+pending for the next poll. Larger output stays out of model context. Inspect it
+through the session id without creating another shell session:
 
 ```text
 babysit_check { id: "cargo-test", lines: 50 }
@@ -99,9 +103,10 @@ 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" })` per ended
-  session (deduped via `meta/<id>.json`). `babysit_kill` and an exit already
-  reported by `babysit_wait` suppress the notification.
+  one `pi.sendMessage(…, { triggerTurn: true, deliverAs: "steer" })` containing
+  every deliverable exit observed in that poll (deduped via `meta/<id>.json`).
+  `babysit_kill` and an exit already reported by `babysit_wait` suppress the
+  notification.
 - **Subagent**: `babysit_wait` blocks on `babysit expect '"type":"agent_end"'`.
   An `agent_end` whose last message is a **parked** toolResult — a
   `babysit_run { command }` result carrying the `[notify-on-exit]` marker (or
@@ -123,6 +128,11 @@ rule, so a subagent waiting on a long build is never false-killed.
 | `PI_BABYSIT_CLI` | `babysit` | babysit binary |
 | `PI_BABYSIT_VIEW_CMD` | bundled `format-stream.mjs` | live-attach pretty printer for subagent JSONL (`""` disables) |
 | `PI_BABYSIT_REAP_AFTER` | `120s` | idle grace before a finished subagent self-exits (`off`/`none`/`0` disables) |
+| `PI_BABYSIT_TAIL_MAX_BYTES` | `8000` | cap for explicit log tails/screens returned by `babysit_check` |
+| `PI_BABYSIT_INLINE_OUTPUT_MAX_BYTES` | `8000` | cap for complete output in explicitly requested run/wait results |
+| `PI_BABYSIT_NOTIFY_OUTPUT_MAX_BYTES` | `2000` | per-process output cap for unsolicited completion notifications (`0` omits all output) |
+| `PI_BABYSIT_NOTIFY_COMMAND_MAX_BYTES` | `240` | cap for each command preview in completion notifications |
+| `PI_BABYSIT_NOTIFY_BATCH_MAX_BYTES` | `8000` | hard cap for one aggregated completion notification |
 | `PI_BABYSIT_ALLOW_BASH` | unset | set to `1` to bypass direct-Bash redirection (emergency escape hatch) |
 
 Requires `babysit` 0.13.0 or newer and `pi` on `PATH`. The extension does **not**

package/index.ts

@@ -81,6 +81,7 @@ const SUBAGENT_GUIDANCE = [
 ].join(" ");
 const POLL_MS = 2500;
 const QUICK_COMMAND_GRACE = process.env.PI_BABYSIT_QUICK_GRACE ?? "1s";
+const KILL_CONFIRM_TIMEOUT = "4s";
 
 interface BsSession {
 	id: string;
@@ -241,6 +242,34 @@ async function statusOf(id: string): Promise<BsSession | null> {
 	}
 }
 
+export function isConfirmedTerminalState(state: string): boolean {
+	return state === "killed" || state === "exited";
+}
+
+export function validateKillResponse(stdout: string): string | null {
+	try {
+		const response = JSON.parse(stdout);
+		if (response.killed !== true || response.confirmed === false) {
+			return `Kill was not confirmed by babysit: ${stdout.trim()}`;
+		}
+		return null;
+	} catch {
+		return `Invalid kill response from babysit: ${stdout.trim() || "(empty)"}`;
+	}
+}
+
+async function awaitConfirmedTermination(id: string): Promise<BsSession | null> {
+	const initial = await statusOf(id);
+	if (!initial || isConfirmedTerminalState(initial.state) || initial.state === "dead") {
+		return initial;
+	}
+	// New babysit versions return only after persistence, so this is normally
+	// skipped. It is a bounded compatibility guard for older binaries that
+	// acknowledged signal delivery before the process actually exited.
+	await bs(["wait", "-s", id, "--timeout", KILL_CONFIRM_TIMEOUT]);
+	return statusOf(id);
+}
+
 // ---------------------------------------------------------------------------
 // per-session metadata
 // ---------------------------------------------------------------------------
@@ -254,6 +283,12 @@ interface Meta {
 	name?: string;
 	command?: string;
 	notified?: boolean;
+	// A confirmed kill permanently owns completion delivery. An interrupted
+	// concurrent wait must not re-enable the automatic notification afterward.
+	killNotificationSuppressed?: boolean;
+	// Temporary reservation while kill is in flight. Unlike `notified`, this
+	// must be cleared on failure so a real completion remains deliverable.
+	notificationPaused?: boolean;
 	completionObservedAt?: number;
 	startedAt?: number;
 	// subagent
@@ -282,6 +317,16 @@ function readMeta(id: string): Meta | null {
 	}
 }
 
+export function shouldDeliverProcessCompletion(
+	meta: {
+		kind: "process" | "subagent";
+		notified?: boolean;
+		notificationPaused?: boolean;
+	} | null,
+): meta is { kind: "process"; notified?: boolean; notificationPaused?: boolean } {
+	return meta?.kind === "process" && !meta.notified && !meta.notificationPaused;
+}
+
 const kindOf = (id: string): "process" | "subagent" => readMeta(id)?.kind ?? "process";
 
 // Compact elapsed formatting: "42s", "3m12s", "1h04m".
@@ -389,8 +434,20 @@ 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; // explicit tails / screens
-const INLINE_OUTPUT_MAX_BYTES = 8_000; // complete output returned only below this threshold
+function byteLimitFromEnv(name: string, fallback: number): number {
+	const raw = process.env[name];
+	if (raw == null || raw.trim() === "") return fallback;
+	const value = Number(raw);
+	return Number.isSafeInteger(value) && value >= 0 ? value : fallback;
+}
+
+const TAIL_MAX_BYTES = byteLimitFromEnv("PI_BABYSIT_TAIL_MAX_BYTES", 8_000);
+// Direct run/wait results can carry more context because the caller explicitly
+// requested them. Unsolicited completion notifications default much smaller.
+const INLINE_OUTPUT_MAX_BYTES = byteLimitFromEnv("PI_BABYSIT_INLINE_OUTPUT_MAX_BYTES", 8_000);
+const NOTIFY_OUTPUT_MAX_BYTES = byteLimitFromEnv("PI_BABYSIT_NOTIFY_OUTPUT_MAX_BYTES", 2_000);
+const NOTIFY_COMMAND_MAX_BYTES = byteLimitFromEnv("PI_BABYSIT_NOTIFY_COMMAND_MAX_BYTES", 240);
+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 {
@@ -465,7 +522,15 @@ async function searchLog(
 	});
 }
 
-async function inlineOutput(id: string, status: BsSession): Promise<string> {
+export function shouldInlineCompleteOutput(outputBytes: number, maxBytes: number): boolean {
+	return maxBytes > 0 && outputBytes <= maxBytes;
+}
+
+async function inlineOutput(
+	id: string,
+	status: BsSession,
+	maxBytes = INLINE_OUTPUT_MAX_BYTES,
+): Promise<string> {
 	let bytes = status.output_bytes;
 	if (bytes == null) {
 		try {
@@ -474,17 +539,225 @@ async function inlineOutput(id: string, status: BsSession): Promise<string> {
 			bytes = Number.POSITIVE_INFINITY;
 		}
 	}
-	if (bytes > INLINE_OUTPUT_MAX_BYTES) {
+	if (!shouldInlineCompleteOutput(bytes, maxBytes)) {
 		const size = Number.isFinite(bytes) ? `${bytes} bytes` : "size unavailable";
-		return `\nOutput omitted (${size}; inline limit ${INLINE_OUTPUT_MAX_BYTES}).`;
+		return `\nOutput omitted (${size}; inline limit ${maxBytes}).`;
 	}
 	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).`;
+	if (Buffer.byteLength(output) > maxBytes) {
+		return `\nOutput omitted (exceeds inline limit ${maxBytes} bytes).`;
 	}
 	return output ? `\n\nOutput:\n${output}` : "";
 }
 
+export function summarizeNotificationCommand(command: string | undefined): string {
+	const preview =
+		(command ?? "?")
+			.trim()
+			.replace(/\r/g, "\\r")
+			.replace(/\n/g, "\\n")
+			.replace(/\t/g, "\\t") || "?";
+	const bytes = Buffer.from(preview, "utf8");
+	if (bytes.length <= NOTIFY_COMMAND_MAX_BYTES) return preview;
+	if (NOTIFY_COMMAND_MAX_BYTES === 0) return "";
+	const ellipsis = Buffer.from("…", "utf8");
+	if (NOTIFY_COMMAND_MAX_BYTES <= ellipsis.length) {
+		return ".".repeat(NOTIFY_COMMAND_MAX_BYTES);
+	}
+	const prefix = bytes
+		.subarray(0, NOTIFY_COMMAND_MAX_BYTES - ellipsis.length)
+		.toString("utf8")
+		.replace(/\uFFFD+$/, "");
+	return `${prefix}…`;
+}
+
+type CompletionStatus = "success" | "failed" | "terminated";
+
+export interface ProcessCompletionNotice {
+	id: string;
+	exitCode: number | null | undefined;
+	success: boolean;
+	status: CompletionStatus;
+	runtime: string;
+	summary: string;
+	command: string | undefined;
+	logPath: string;
+	output: string;
+}
+
+interface ProcessCompletionMessage {
+	customType: "pi-babysit-process-end";
+	content: string;
+	display: true;
+	details: {
+		id?: string;
+		exitCode?: number | null;
+		success: boolean;
+		status: CompletionStatus;
+		runtime?: string;
+		logPath?: string;
+		count: number;
+		totalCount: number;
+		remainingCount: number;
+		processes: Array<{
+			id: string;
+			exitCode: number | null | undefined;
+			success: boolean;
+			status: CompletionStatus;
+			runtime: string;
+			logPath: string;
+		}>;
+	};
+}
+
+const COMPLETION_FOOTER =
+	"Automatic completion notification. Inspect the bounded log with babysit_check only if needed.";
+const AGGREGATE_OUTPUT_OMISSION = "\nOutput omitted from aggregate notification; inspect log.";
+
+function truncateUtf8End(value: string, maxBytes: number): string {
+	if (maxBytes <= 0) return "";
+	const bytes = Buffer.from(value, "utf8");
+	if (bytes.length <= maxBytes) return value;
+	const suffix = Buffer.from("…", "utf8");
+	if (maxBytes <= suffix.length) return ".".repeat(maxBytes);
+	const prefix = bytes
+		.subarray(0, maxBytes - suffix.length)
+		.toString("utf8")
+		.replace(/\uFFFD+$/, "");
+	return `${prefix}…`;
+}
+
+/** Build one bounded message for as many deliverable completions as fit. */
+export function buildProcessCompletionMessage(
+	notices: ProcessCompletionNotice[],
+	maxBytes = NOTIFY_BATCH_MAX_BYTES,
+): ProcessCompletionMessage {
+	if (notices.length === 0) throw new Error("At least one completion notice is required.");
+
+	const totalCount = notices.length;
+	const footer = `\n\n${COMPLETION_FOOTER}`;
+	const header = (count: number) =>
+		totalCount === 1
+			? ""
+			: count === totalCount
+				? `${count} processes completed:\n\n`
+				: `${count} of ${totalCount} processes completed:\n\n`;
+	const deferred = (count: number) =>
+		count < totalCount
+			? `\n\n${totalCount - count} completion${totalCount - count === 1 ? "" : "s"} deferred to the next poll.`
+			: "";
+	const renderCompact = (batch: ProcessCompletionNotice[]) =>
+		header(batch.length) +
+		batch.map((notice) => `${notice.summary}\nLog: ${notice.logPath}`).join("\n\n") +
+		deferred(batch.length) +
+		footer;
+
+	// If every summary and log path cannot fit, notify the largest fitting prefix
+	// and leave the rest unacknowledged for a later poll. Always make progress for
+	// pathological single ids/paths by delivering one UTF-8-truncated entry.
+	let batch = notices;
+	if (Buffer.byteLength(renderCompact(batch), "utf8") > maxBytes) {
+		let low = 1;
+		let high = notices.length - 1;
+		let fittedCount = 0;
+		while (low <= high) {
+			const mid = Math.floor((low + high) / 2);
+			if (Buffer.byteLength(renderCompact(notices.slice(0, mid)), "utf8") <= maxBytes) {
+				fittedCount = mid;
+				low = mid + 1;
+			} else {
+				high = mid - 1;
+			}
+		}
+		batch = fittedCount > 0 ? notices.slice(0, fittedCount) : [notices[0]];
+	}
+
+	const blockBase = (notice: ProcessCompletionNotice) =>
+		`${notice.summary}\nCommand: ${summarizeNotificationCommand(notice.command)}\nLog: ${notice.logPath}`;
+	const outputs = batch.map((notice) =>
+		notice.output.startsWith("\n\nOutput:") ? AGGREGATE_OUTPUT_OMISSION : notice.output,
+	);
+	const renderDetailed = () =>
+		header(batch.length) +
+		batch.map((notice, i) => blockBase(notice) + outputs[i]).join("\n\n") +
+		deferred(batch.length) +
+		footer;
+
+	let content = renderDetailed();
+	let contentBytes = Buffer.byteLength(content, "utf8");
+	if (contentBytes <= maxBytes) {
+		// Spend the remaining aggregate budget on complete inline outputs without
+		// repeatedly rebuilding the entire batch for every candidate.
+		for (let i = 0; i < batch.length; i++) {
+			if (!batch[i].output.startsWith("\n\nOutput:")) continue;
+			const delta =
+				Buffer.byteLength(batch[i].output, "utf8") - Buffer.byteLength(outputs[i], "utf8");
+			if (contentBytes + delta > maxBytes) continue;
+			outputs[i] = batch[i].output;
+			contentBytes += delta;
+		}
+		content = renderDetailed();
+	} else {
+		content = truncateUtf8End(renderCompact(batch), maxBytes);
+	}
+
+	const statuses = new Set(batch.map((notice) => notice.status));
+	const status: CompletionStatus = statuses.has("failed")
+		? "failed"
+		: statuses.has("terminated")
+			? "terminated"
+			: "success";
+	const processes = batch.map((notice) => ({
+		id: notice.id,
+		exitCode: notice.exitCode,
+		success: notice.success,
+		status: notice.status,
+		runtime: notice.runtime,
+		logPath: notice.logPath,
+	}));
+	const single = totalCount === 1 ? batch[0] : undefined;
+	return {
+		customType: "pi-babysit-process-end",
+		content,
+		display: true,
+		details: {
+			id: single?.id,
+			exitCode: single?.exitCode,
+			success: batch.every((notice) => notice.success),
+			status,
+			runtime: single?.runtime,
+			logPath: single?.logPath,
+			count: batch.length,
+			totalCount,
+			remainingCount: totalCount - batch.length,
+			processes,
+		},
+	};
+}
+
+/** Send once and only acknowledge notices represented in the accepted batch. */
+export function deliverProcessCompletionMessage(
+	notices: ProcessCompletionNotice[],
+	send: (
+		message: ProcessCompletionMessage,
+		options: { triggerTurn: true; deliverAs: "steer" },
+	) => void,
+	onSent: (notice: ProcessCompletionNotice) => void,
+): boolean {
+	if (notices.length === 0) return false;
+	let message: ProcessCompletionMessage;
+	try {
+		message = buildProcessCompletionMessage(notices);
+		send(message, { triggerTurn: true, deliverAs: "steer" });
+	} catch {
+		return false;
+	}
+	const deliveredIds = new Set(message.details.processes.map(({ id }) => id));
+	for (const notice of notices) {
+		if (deliveredIds.has(notice.id)) onSent(notice);
+	}
+	return true;
+}
 
 // ---------------------------------------------------------------------------
 // parked-turn detection (shared rule with self-reap.ts)
@@ -1050,22 +1323,47 @@ async function waitForTask(
 
 // Mark a process session as already-reported so the exit-notification poller
 // doesn't send a duplicate message for something the agent just observed.
-function suppressNotify(id: string): void {
+function suppressNotify(id: string, reason: "observed" | "kill" = "observed"): void {
 	const meta = readMeta(id);
-	if (meta && meta.kind === "process" && !meta.notified) {
+	if (meta && meta.kind === "process") {
 		meta.notified = true;
+		if (reason === "kill") meta.killNotificationSuppressed = true;
+		delete meta.notificationPaused;
 		writeMeta(id, meta);
 	}
 }
 
+export function canRestoreNotificationAfterWait(meta: {
+	notified?: boolean;
+	killNotificationSuppressed?: boolean;
+}): boolean {
+	return meta.notified === true && meta.killNotificationSuppressed !== true;
+}
+
 function enableNotify(id: string): void {
 	const meta = readMeta(id);
-	if (meta && meta.kind === "process" && meta.notified) {
+	if (meta && meta.kind === "process" && canRestoreNotificationAfterWait(meta)) {
 		meta.notified = false;
 		writeMeta(id, meta);
 	}
 }
 
+function pauseNotify(id: string): void {
+	const meta = readMeta(id);
+	if (meta && meta.kind === "process" && !meta.notificationPaused) {
+		meta.notificationPaused = true;
+		writeMeta(id, meta);
+	}
+}
+
+function resumeNotify(id: string): void {
+	const meta = readMeta(id);
+	if (meta && meta.kind === "process" && meta.notificationPaused) {
+		delete meta.notificationPaused;
+		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(
@@ -1139,7 +1437,7 @@ async function waitForExit(
 		kind: "exited",
 		ok,
 		text:
-			`Process ${id}${meta?.command ? ` (${meta.command})` : ""} ` +
+			`Process ${id}${meta?.command ? ` (${summarizeNotificationCommand(meta.command)})` : ""} ` +
 			(workerDead
 				? "worker-dead: the babysit supervisor disappeared without an exit status"
 				: ok ? "completed successfully" : `exited with code ${st.exit_code ?? "?"}`) +
@@ -1189,61 +1487,81 @@ export default function (pi: ExtensionAPI) {
 	let pollTimer: ReturnType<typeof setInterval> | undefined;
 
 	// Exit notifications for kind=process sessions: the poller detects
-	// running→exited transitions and injects ONE message (triggerTurn) so an
-	// agent that ended its turn after babysit_run is resumed automatically —
-	// the old `process` tool contract. Kills via babysit_kill and exits already
-	// reported by babysit_wait are suppressed via meta.notified.
+	// running→exited transitions and injects ONE message (triggerTurn) for all
+	// processes that became deliverable in the same poll. This resumes an agent
+	// 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> {
 		const { sessions } = await listSessions();
-		for (const s of sessions) {
-			if (s.state === "running") continue;
-			const meta = readMeta(s.id);
-			if (!meta || meta.kind !== "process" || meta.notified) continue;
+		const ready: Array<{ session: BsSession; meta: Meta }> = [];
+		for (const session of sessions) {
+			if (session.state === "running") continue;
+			const meta = readMeta(session.id);
+			if (!shouldDeliverProcessCompletion(meta)) 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);
+				writeMeta(session.id, meta);
 				continue;
 			}
 			if (Date.now() - meta.completionObservedAt < POLL_MS) continue;
-			meta.notified = true;
-			writeMeta(s.id, meta);
-			const ok = s.exit_code === 0;
-			const status: DisplayStatus = ok
+			ready.push({ session, meta });
+		}
+
+		const prepared: ProcessCompletionNotice[] = [];
+		for (const { session, meta } of ready) {
+			const ok = session.exit_code === 0;
+			const status: CompletionStatus = ok
 				? "success"
-				: s.state === "dead" || s.exit_code == null
+				: session.state === "dead" || session.exit_code == null
 					? "terminated"
 					: "failed";
-			const output = await inlineOutput(s.id, s);
+			const output = await inlineOutput(session.id, session, NOTIFY_OUTPUT_MAX_BYTES);
 			const runtime = meta.startedAt
 				? `${Math.round((Date.now() - meta.startedAt) / 1000)}s`
 				: "?";
 			const summary = ok
-				? `Process "${s.id}" completed successfully after ${runtime}.`
-				: s.state === "dead" || s.exit_code == null
-					? `Process "${s.id}" was terminated after ${runtime}.`
-					: `Process "${s.id}" exited with code ${s.exit_code} after ${runtime}.`;
-			pi.sendMessage(
-				{
-					customType: "pi-babysit-process-end",
-					content:
-						`${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 with babysit_check { id: ${JSON.stringify(s.id)}, lines, pattern? }; never read it in full.`,
-					display: true,
-					details: {
-						id: s.id,
-						exitCode: s.exit_code,
-						success: ok,
-						status,
-						runtime,
-						logPath: logPath(s.id),
-					},
-				},
-				{ triggerTurn: true, deliverAs: "steer" },
-			);
+				? `Process "${session.id}" completed successfully after ${runtime}.`
+				: session.state === "dead" || session.exit_code == null
+					? `Process "${session.id}" was terminated after ${runtime}.`
+					: `Process "${session.id}" exited with code ${session.exit_code} after ${runtime}.`;
+			prepared.push({
+				id: session.id,
+				exitCode: session.exit_code,
+				success: ok,
+				status,
+				runtime,
+				summary,
+				command: meta.command,
+				logPath: logPath(session.id),
+				output,
+			});
 		}
+
+		// Output loading above is asynchronous. Re-read every candidate together
+		// immediately before the single send so a concurrent kill/wait cannot claim
+		// an early candidate while a later candidate's output is being loaded.
+		const metadataById = new Map<string, Meta>();
+		const notices = prepared.flatMap((notice) => {
+			const current = readMeta(notice.id);
+			if (!shouldDeliverProcessCompletion(current)) return [];
+			metadataById.set(notice.id, current);
+			return [{ ...notice, command: current.command }];
+		});
+		deliverProcessCompletionMessage(
+			notices,
+			(message, options) => pi.sendMessage(message, options),
+			(notice) => {
+				const meta = metadataById.get(notice.id);
+				if (!meta) return;
+				meta.notified = true;
+				delete meta.notificationPaused;
+				writeMeta(notice.id, meta);
+			},
+		);
 	}
 
 	const refreshWidget = async (ctx: ExtensionContext) => {
@@ -2181,17 +2499,46 @@ export default function (pi: ExtensionAPI) {
 		parameters: Type.Object({ id: Type.String({ description: "Session id." }) }),
 		async execute(_id, params, _signal, _onUpdate, ctx) {
 			await requireBabysit();
-			suppressNotify(params.id); // tool-initiated kill → no end notification
-			const r = await bs(["kill", "-s", params.id, "--json"]);
-			await refreshWidget(ctx);
-			if (r.code !== 0) {
+			// Prevent the exit poller racing a requested kill, but restore delivery
+			// on every failure. Permanent suppression happens only after terminal
+			// state is independently confirmed.
+			pauseNotify(params.id);
+			const fail = async (message: string, status?: BsSession | null) => {
+				resumeNotify(params.id);
+				await refreshWidget(ctx);
 				return {
-					content: [{ type: "text", text: r.stderr || "kill failed" }],
+					content: [{ type: "text" as const, text: message }],
 					isError: true,
-					details: {},
+					details: { id: params.id, status: status?.state, logPath: logPath(params.id) },
 				};
+			};
+
+			const r = await bs(["kill", "-s", params.id, "--json"]);
+			if (r.code !== 0) return fail((r.stderr || r.stdout || "kill failed").trim());
+
+			const responseError = validateKillResponse(r.stdout);
+			if (responseError) return fail(responseError);
+
+			const status = await awaitConfirmedTermination(params.id);
+			if (!status) return fail(`Kill could not be verified: session ${params.id} disappeared.`);
+			if (!isConfirmedTerminalState(status.state)) {
+				return fail(
+					`Kill was acknowledged but ${params.id} is still ${status.state}; completion notifications were restored.`,
+					status,
+				);
 			}
-			return { content: [{ type: "text", text: `Killed ${params.id}.` }], details: {} };
+
+			suppressNotify(params.id, "kill");
+			await refreshWidget(ctx);
+			return {
+				content: [{ type: "text", text: `Killed ${params.id} (confirmed ${status.state}).` }],
+				details: {
+					id: params.id,
+					status: status.state,
+					exitCode: status.exit_code,
+					logPath: logPath(params.id),
+				},
+			};
 		},
 	});
 

package/package.json

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