@code-yeongyu/senpi-codemode 2026.9.13-2 → 2026.9.15-2

package/CHANGELOG.md

@@ -12,6 +12,35 @@
 
 ### Removed
 
+## [2026.9.15-2] - 2026-09-15
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+- Detached eval result cards no longer arm the 1 Hz repaint ticker (they render static with frozen elapsed time), and a live ticker whose row stops rendering now stops itself after 60 idle ticks and rearms on the next render, so transcript rebuilds and session switches cannot accumulate intervals on idle sessions ([#1696](https://github.com/code-yeongyu/senpi/issues/1696)).
+- Bounded three unbounded retentions that grew long-lived session heaps without limit: settled eval cells now leave the live registry into a 32-entry terminal snapshot LRU, the JS kernel's unconsumed tool-call queue is capped at 256 and cleared on interrupt/reset/close/crash (mirroring the subprocess kernel), and per-cell display buffers cap at 8 images / 24 MB / 64 JSON outputs with elision notes ([#1695](https://github.com/code-yeongyu/senpi/issues/1695)).
+
+### Removed
+
+## [2026.9.15] - 2026-09-15
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+- Eval cells no longer abandon the processes they spawn. When a JavaScript cell settles, is interrupted, or times out, its `Bun.spawn`/`node:child_process` children and their descendants are terminated (SIGTERM then SIGKILL after a grace), unless the cell asked for a detached process; a child whose worker is lost while blocked is retired by the host instead. Python kernels sweep their process group when they close gracefully, and a parent-death watchdog takes the kernel and its subprocesses down when the host dies mid-cell ([#1697](https://github.com/code-yeongyu/senpi/issues/1697)).
+
+### Removed
+
 ## [2026.9.13-2] - 2026-09-13
 
 ### Breaking Changes

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-codemode",
-	"version": "2026.9.13-2",
+	"version": "2026.9.15-2",
 	"description": "Source-only senpi extension package for codemode evaluation tools",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -30,14 +30,14 @@
 	},
 	"dependencies": {
 		"@babel/parser": "8.0.4",
-		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.9.13-2",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.9.15-2",
 		"typebox": "1.3.27"
 	},
 	"peerDependencies": {
-		"@code-yeongyu/senpi": "2026.9.13-2"
+		"@code-yeongyu/senpi": "2026.9.15-2"
 	},
 	"devDependencies": {
-		"@code-yeongyu/senpi": "2026.9.13-2"
+		"@code-yeongyu/senpi": "2026.9.15-2"
 	},
 	"keywords": [
 		"senpi",

package/src/bridge/reserved.ts

@@ -11,3 +11,5 @@ export const TIMEOUT_PAUSE_OP = "timeout-pause" as const;
 export const TIMEOUT_RESUME_OP = "timeout-resume" as const;
 /** Status op the JS worker emits the moment it receives `interrupt`; proves its event loop is not blocked. */
 export const INTERRUPT_ACK_OP = "interrupt-ack" as const;
+/** Status op the JS worker emits when a cell child is tracked or exits, so the host can retire it if the worker is lost. */
+export const CHILD_LIFECYCLE_OP = "child" as const;

package/src/kernels/js/context-manager.ts

@@ -1,5 +1,5 @@
-import type { HostToKernelMessage, KernelToHostMessage } from "../../bridge/protocol.ts";
-import { INTERRUPT_ACK_OP } from "../../bridge/reserved.ts";
+import type { EvalStatusEvent, HostToKernelMessage, KernelToHostMessage } from "../../bridge/protocol.ts";
+import { CHILD_LIFECYCLE_OP, INTERRUPT_ACK_OP } from "../../bridge/reserved.ts";
 import type { KernelInterruptHandle } from "../../tool/types.ts";
 import { abandonedWorkerNote, awaitCooperativeSettlement, type WorkerRetirement } from "./interrupt-bounds.ts";
 import {
@@ -11,6 +11,7 @@ import {
 	type ToolCallMessage,
 } from "./kernel-contract.ts";
 import { type JavaScriptKernelOptions, LocalModuleLoader } from "./local-module-loader.ts";
+import { terminateProcessTrees } from "./process-tree-host.ts";
 import { JavaScriptRunQueue, type PendingJavaScriptRun, stoppedResult } from "./run-queue.ts";
 import { bridgeError, WorkerStartupCancelledError } from "./worker-host.ts";
 import { WorkerSlot } from "./worker-slot.ts";
@@ -19,6 +20,13 @@ export { JavaScriptKernelClosedError, type JavaScriptKernelMode, type JavaScript
 export type { JavaScriptKernelOptions } from "./local-module-loader.ts";
 export { type JavaScriptWorkerEntryUrlOptions, resolveJsWorkerEntryUrl } from "./worker-startup.ts";
 
+/** How long a lost worker's children get to honour SIGTERM before the host sends SIGKILL. */
+const WORKER_LOSS_CHILD_GRACE_MS = 1_000;
+
+// Pull-API fallback queue bound: a nextToolCall consumer this far behind is already stalled, and the
+// normal push path (onMessage) never reads the queue, so unbounded growth only pins tool args (#1695).
+const MAX_PENDING_TOOL_CALLS = 256;
+
 export class JavaScriptKernel {
 	readonly #options: JavaScriptKernelOptions;
 	readonly #moduleLoader: LocalModuleLoader;
@@ -31,6 +39,8 @@ export class JavaScriptKernel {
 	#timeout: NodeJS.Timeout | null = null;
 	#toolWaiters: Array<(message: ToolCallMessage) => void> = [];
 	#pendingToolCalls: ToolCallMessage[] = [];
+	/** Live cell children the worker reported; retired by the host when the worker itself is lost. */
+	readonly #childPids = new Set<number>();
 
 	constructor(options: JavaScriptKernelOptions) {
 		this.#options = options;
@@ -71,6 +81,7 @@ export class JavaScriptKernel {
 	async reset(): Promise<void> {
 		assertJavaScriptKernelOpen(this.#lifecycle, "reset");
 		await this.#terminate();
+		this.#clearToolCalls();
 		assertJavaScriptKernelOpen(this.#lifecycle, "reset");
 		await this.#ensureReady();
 		this.#startNext();
@@ -91,6 +102,7 @@ export class JavaScriptKernel {
 		this.#slot.postMessage({ type: "close" });
 		this.#lifecycle = "closing";
 		this.#runs.settleAll("JS kernel closed");
+		this.#clearToolCalls();
 		const recovery = this.#recovery;
 		const closePromise = (async () => {
 			if (recovery) await recovery;
@@ -164,15 +176,19 @@ export class JavaScriptKernel {
 		message: string,
 		durationMs = 0,
 	): Promise<{ readonly retained: boolean; readonly note?: string }> {
-		run.interruptResult = { type: "result", cellId: run.input.cellId, ok: false, error: { message }, durationMs };
-		run.interruptAck ??= Promise.withResolvers<void>();
-		this.#slot.postMessage({ type: "interrupt", reason });
-		if ((await awaitCooperativeSettlement(run)) === "settled") return { retained: run.settledByWorker };
-		if (!this.#runs.releaseActive(run)) return { retained: run.settledByWorker };
-		const retirement = await this.#terminate();
-		this.#runs.settle(run, run.interruptResult ?? stoppedResult(run.input.cellId, message));
-		void this.#recover(() => Promise.resolve());
-		return retirement === "abandoned" ? { retained: false, note: abandonedWorkerNote() } : { retained: false };
+		try {
+			run.interruptResult = { type: "result", cellId: run.input.cellId, ok: false, error: { message }, durationMs };
+			run.interruptAck ??= Promise.withResolvers<void>();
+			this.#slot.postMessage({ type: "interrupt", reason });
+			if ((await awaitCooperativeSettlement(run)) === "settled") return { retained: run.settledByWorker };
+			if (!this.#runs.releaseActive(run)) return { retained: run.settledByWorker };
+			const retirement = await this.#terminate();
+			this.#runs.settle(run, run.interruptResult ?? stoppedResult(run.input.cellId, message));
+			void this.#recover(() => Promise.resolve());
+			return retirement === "abandoned" ? { retained: false, note: abandonedWorkerNote() } : { retained: false };
+		} finally {
+			this.#clearToolCalls();
+		}
 	}
 
 	async #restartAfterStop(): Promise<void> {
@@ -208,12 +224,19 @@ export class JavaScriptKernel {
 			this.#runs.active?.interruptAck?.resolve();
 			return;
 		}
+		if (message.type === "status" && message.event.op === CHILD_LIFECYCLE_OP) {
+			this.#trackChildEvent(message.event);
+			return;
+		}
 		this.#options.onMessage?.(message);
 		this.#runs.active?.input.onMessage?.(message);
 		if (message.type === "tool-call") {
 			const waiter = this.#toolWaiters.shift();
 			if (waiter) waiter(message);
-			else this.#pendingToolCalls.push(message);
+			else {
+				this.#pendingToolCalls.push(message);
+				if (this.#pendingToolCalls.length > MAX_PENDING_TOOL_CALLS) this.#pendingToolCalls.shift();
+			}
 			return;
 		}
 		if (message.type !== "result") return;
@@ -240,16 +263,42 @@ export class JavaScriptKernel {
 				durationMs: this.#runs.durationMs(active, performance.now()),
 			});
 		}
+		this.#clearToolCalls();
 		void this.#restartAfterStop();
 	}
 
+	#clearToolCalls(): void {
+		this.#pendingToolCalls.length = 0;
+		this.#toolWaiters.length = 0;
+	}
+
 	#clearTimeout(): void {
 		if (this.#timeout) clearTimeout(this.#timeout);
 		this.#timeout = null;
 	}
 
+	#trackChildEvent(event: EvalStatusEvent): void {
+		const pid = event.pid;
+		if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0) return;
+		if (event.state === "spawned") this.#childPids.add(pid);
+		else if (event.state === "exited") this.#childPids.delete(pid);
+	}
+
+	/**
+	 * Retire the worker, then whatever cell children it still owned: a terminated or crashed worker never
+	 * reaches its own cell-end cleanup, and a pid `ps` no longer lists as our child was reused and is skipped.
+	 */
 	async #terminate(): Promise<WorkerRetirement> {
 		this.#clearTimeout();
-		return await this.#slot.retire();
+		const retirement = await this.#slot.retire();
+		await this.#retireWorkerChildren();
+		return retirement;
+	}
+
+	async #retireWorkerChildren(): Promise<void> {
+		if (this.#childPids.size === 0) return;
+		const pids = [...this.#childPids];
+		this.#childPids.clear();
+		await terminateProcessTrees(pids, { graceMs: WORKER_LOSS_CHILD_GRACE_MS, ownerPid: process.pid });
 	}
 }

package/src/kernels/js/process-tree-host.ts

@@ -0,0 +1,158 @@
+import { execFile } from "node:child_process";
+
+// Host-side twin of worker-runtime's `process-tree.js`. The worker file must stay plain
+// JavaScript (a Node worker thread spawned from a `.js` entry has no TypeScript loader), and
+// `check-ts-relative-imports` forbids a `.ts` file from importing a `.js` one, so the host
+// keeps its own copy the way `worker-core.js` mirrors `reserved.ts` constants. Keep the two in
+// sync when either changes.
+
+export interface TerminateProcessTreesOptions {
+	readonly graceMs: number;
+	readonly killWaitMs?: number;
+	// When set, only roots `ps` still lists as direct children of this pid are signalled, so a
+	// reused pid belonging to another process is never killed.
+	readonly ownerPid?: number;
+}
+
+const PS_MAX_BUFFER = 16 * 1024 * 1024;
+const EXIT_POLL_MS = 25;
+const ZOMBIE_CHECK_INTERVAL_MS = 250;
+
+function isRecord(value: unknown): value is Readonly<Record<string, unknown>> {
+	return typeof value === "object" && value !== null;
+}
+
+export function isProcessAlive(pid: number): boolean {
+	if (!Number.isInteger(pid) || pid <= 0) return false;
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return isRecord(error) && error.code === "EPERM";
+	}
+}
+
+export function signalProcess(pid: number, signal: NodeJS.Signals): boolean {
+	if (!Number.isInteger(pid) || pid <= 0) return false;
+	try {
+		process.kill(pid, signal);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+// `ps -p` exits non-zero when any listed pid is gone but still prints the rest.
+function ps(args: readonly string[]): Promise<string> {
+	return new Promise((resolve) => {
+		execFile("ps", [...args], { maxBuffer: PS_MAX_BUFFER, windowsHide: true }, (_error, output) =>
+			resolve(typeof output === "string" ? output : String(output ?? "")),
+		);
+	});
+}
+
+export async function readProcessTable(): Promise<Map<number, number[]>> {
+	const children = new Map<number, number[]>();
+	if (process.platform === "win32") return children;
+	const stdout = await ps(["-axo", "pid=,ppid="]);
+	for (const line of stdout.split("\n")) {
+		const [pidText, ppidText] = line.trim().split(/\s+/u);
+		const pid = Number(pidText);
+		const ppid = Number(ppidText);
+		if (!Number.isInteger(pid) || !Number.isInteger(ppid)) continue;
+		const siblings = children.get(ppid);
+		if (siblings) siblings.push(pid);
+		else children.set(ppid, [pid]);
+	}
+	return children;
+}
+
+export function collectDescendants(table: ReadonlyMap<number, readonly number[]>, roots: readonly number[]): number[] {
+	const seen = new Set<number>(roots);
+	const queue = [...roots];
+	const descendants: number[] = [];
+	while (queue.length > 0) {
+		const parent = queue.shift();
+		if (parent === undefined) break;
+		for (const child of table.get(parent) ?? []) {
+			if (seen.has(child)) continue;
+			seen.add(child);
+			descendants.push(child);
+			queue.push(child);
+		}
+	}
+	return descendants;
+}
+
+export function ownedRoots(
+	table: ReadonlyMap<number, readonly number[]>,
+	parentPid: number,
+	roots: readonly number[],
+): number[] {
+	const owned = new Set(table.get(parentPid) ?? []);
+	return roots.filter((pid) => owned.has(pid));
+}
+
+function sleep(ms: number): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Retire whole process trees: snapshot the descendants first (a parent that dies before the
+ * snapshot would reparent them to init), SIGTERM everything, wait `graceMs` for the pids to
+ * disappear, then SIGKILL whatever is left. On Windows `taskkill /T /F` does the walk and the kill.
+ */
+export async function terminateProcessTrees(
+	roots: readonly number[],
+	options: TerminateProcessTreesOptions,
+): Promise<void> {
+	const liveRoots = roots.filter(isProcessAlive);
+	if (liveRoots.length === 0) return;
+	if (process.platform === "win32") {
+		for (const pid of liveRoots) await taskkillTree(pid);
+		return;
+	}
+	const table = await readProcessTable();
+	const owned = options.ownerPid === undefined ? liveRoots : ownedRoots(table, options.ownerPid, liveRoots);
+	if (owned.length === 0) return;
+	const targets = [...owned, ...collectDescendants(table, owned)];
+	for (const pid of targets) signalProcess(pid, "SIGTERM");
+	const survivors = await waitForExit(targets, options.graceMs);
+	if (survivors.length === 0) return;
+	for (const pid of survivors) signalProcess(pid, "SIGKILL");
+	await waitForExit(survivors, options.killWaitMs ?? options.graceMs);
+}
+
+// `kill(pid, 0)` still succeeds for a zombie, and a child whose owning worker is blocked or
+// gone is never reaped, so liveness also consults `ps` state.
+async function waitForExit(pids: readonly number[], graceMs: number): Promise<number[]> {
+	const deadline = Date.now() + graceMs;
+	let remaining = await withoutZombies(pids.filter(isProcessAlive));
+	let nextZombieCheck = Date.now() + ZOMBIE_CHECK_INTERVAL_MS;
+	while (remaining.length > 0 && Date.now() < deadline) {
+		await sleep(EXIT_POLL_MS);
+		remaining = remaining.filter(isProcessAlive);
+		if (remaining.length > 0 && Date.now() >= nextZombieCheck) {
+			remaining = await withoutZombies(remaining);
+			nextZombieCheck = Date.now() + ZOMBIE_CHECK_INTERVAL_MS;
+		}
+	}
+	return remaining;
+}
+
+async function withoutZombies(pids: number[]): Promise<number[]> {
+	if (pids.length === 0 || process.platform === "win32") return pids;
+	const stdout = await ps(["-o", "pid=,stat=", "-p", pids.join(",")]);
+	const zombies = new Set<number>();
+	for (const line of stdout.split("\n")) {
+		const [pidText, stat] = line.trim().split(/\s+/u);
+		if (typeof stat === "string" && stat.startsWith("Z")) zombies.add(Number(pidText));
+	}
+	return pids.filter((pid) => !zombies.has(pid));
+}
+
+function taskkillTree(pid: number): Promise<void> {
+	return new Promise((resolve) => {
+		execFile("taskkill", ["/T", "/F", "/PID", String(pid)], { windowsHide: true }, () => resolve());
+	});
+}

package/src/kernels/js/process-tree.d.ts

@@ -0,0 +1,24 @@
+export type ProcessTable = ReadonlyMap<number, readonly number[]>;
+
+export interface TerminateProcessTreesOptions {
+	/** How long the trees get to honour SIGTERM before SIGKILL. */
+	readonly graceMs: number;
+	/** How long to wait after SIGKILL; defaults to `graceMs`. */
+	readonly killWaitMs?: number;
+	/** Resolves once every owned handle has exited; shortens the wait when it settles early. */
+	readonly settled?: Promise<unknown>;
+	/** When set, only roots `ps` still lists as direct children of this pid are signalled (guards against pid reuse). */
+	readonly ownerPid?: number;
+}
+
+export function isProcessAlive(pid: number): boolean;
+
+export function signalProcess(pid: number, signal: NodeJS.Signals): boolean;
+
+export function readProcessTable(): Promise<ProcessTable>;
+
+export function collectDescendants(table: ProcessTable, roots: readonly number[]): number[];
+
+export function ownedRoots(table: ProcessTable, parentPid: number, roots: readonly number[]): number[];
+
+export function terminateProcessTrees(roots: readonly number[], options: TerminateProcessTreesOptions): Promise<void>;

package/src/kernels/js/process-tree.js

@@ -0,0 +1,151 @@
+import { execFile } from "node:child_process";
+
+// Plain JS (with process-tree.d.ts) because the worker runtime imports it and
+// worker files cannot import TypeScript; the host imports the same module so a
+// process tree is retired by one procedure wherever its owner is lost.
+
+const PS_MAX_BUFFER = 16 * 1024 * 1024;
+const EXIT_POLL_MS = 25;
+const ZOMBIE_CHECK_INTERVAL_MS = 250;
+
+export function isProcessAlive(pid) {
+	if (!Number.isInteger(pid) || pid <= 0) return false;
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return isRecord(error) && error.code === "EPERM";
+	}
+}
+
+export function signalProcess(pid, signal) {
+	if (!Number.isInteger(pid) || pid <= 0) return false;
+	try {
+		process.kill(pid, signal);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Parent-to-children map of every process visible to `ps`. Windows has no
+ * `ps`; callers there kill through `taskkill /T`, which walks the tree itself.
+ */
+export async function readProcessTable() {
+	if (process.platform === "win32") return new Map();
+	const stdout = await ps(["-axo", "pid=,ppid="]);
+	const children = new Map();
+	for (const line of stdout.split("\n")) {
+		const [pidText, ppidText] = line.trim().split(/\s+/u);
+		const pid = Number(pidText);
+		const ppid = Number(ppidText);
+		if (!Number.isInteger(pid) || !Number.isInteger(ppid)) continue;
+		const siblings = children.get(ppid);
+		if (siblings) siblings.push(pid);
+		else children.set(ppid, [pid]);
+	}
+	return children;
+}
+
+export function collectDescendants(table, roots) {
+	const seen = new Set(roots);
+	const queue = [...roots];
+	const descendants = [];
+	while (queue.length > 0) {
+		const parent = queue.shift();
+		for (const child of table.get(parent) ?? []) {
+			if (seen.has(child)) continue;
+			seen.add(child);
+			descendants.push(child);
+			queue.push(child);
+		}
+	}
+	return descendants;
+}
+
+/** Roots that `ps` still reports as direct children of `parentPid`; a reused pid belongs to someone else. */
+export function ownedRoots(table, parentPid, roots) {
+	const owned = new Set(table.get(parentPid) ?? []);
+	return roots.filter((pid) => owned.has(pid));
+}
+
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Retire whole process trees: snapshot the descendants first (a parent that
+ * dies before the snapshot would reparent them to init), SIGTERM everything,
+ * wait `graceMs` for `settled` (or for the pids to disappear), then SIGKILL
+ * whatever is left. On Windows `taskkill /T /F` does the walk and the kill.
+ */
+export async function terminateProcessTrees(roots, options) {
+	const liveRoots = roots.filter(isProcessAlive);
+	if (liveRoots.length === 0) return;
+	if (process.platform === "win32") {
+		for (const pid of liveRoots) await taskkillTree(pid);
+		return;
+	}
+	const table = await readProcessTable();
+	const owned = options.ownerPid === undefined ? liveRoots : ownedRoots(table, options.ownerPid, liveRoots);
+	if (owned.length === 0) return;
+	const targets = [...owned, ...collectDescendants(table, owned)];
+	for (const pid of targets) signalProcess(pid, "SIGTERM");
+	const survivors = await waitForExit(targets, options.graceMs, options.settled);
+	if (survivors.length === 0) return;
+	for (const pid of survivors) signalProcess(pid, "SIGKILL");
+	await waitForExit(survivors, options.killWaitMs ?? options.graceMs, options.settled);
+}
+
+// `kill(pid, 0)` still succeeds for a zombie, and a child whose owning worker is
+// blocked or gone is never reaped, so liveness also consults `ps` state.
+async function waitForExit(pids, graceMs, settled) {
+	const deadline = Date.now() + graceMs;
+	let remaining = await withoutZombies(pids.filter(isProcessAlive));
+	let nextZombieCheck = Date.now() + ZOMBIE_CHECK_INTERVAL_MS;
+	while (remaining.length > 0 && Date.now() < deadline) {
+		if (settled) {
+			const outcome = await Promise.race([settled.then(() => "settled"), sleep(EXIT_POLL_MS).then(() => "tick")]);
+			if (outcome === "settled") settled = undefined;
+		} else {
+			await sleep(EXIT_POLL_MS);
+		}
+		remaining = remaining.filter(isProcessAlive);
+		if (remaining.length > 0 && Date.now() >= nextZombieCheck) {
+			remaining = await withoutZombies(remaining);
+			nextZombieCheck = Date.now() + ZOMBIE_CHECK_INTERVAL_MS;
+		}
+	}
+	return remaining;
+}
+
+async function withoutZombies(pids) {
+	if (pids.length === 0 || process.platform === "win32") return pids;
+	const stdout = await ps(["-o", "pid=,stat=", "-p", pids.join(",")]);
+	const zombies = new Set();
+	for (const line of stdout.split("\n")) {
+		const [pidText, stat] = line.trim().split(/\s+/u);
+		if (typeof stat === "string" && stat.startsWith("Z")) zombies.add(Number(pidText));
+	}
+	return pids.filter((pid) => !zombies.has(pid));
+}
+
+// `ps -p` exits non-zero when any listed pid is gone but still prints the rest.
+function ps(args) {
+	return new Promise((resolve) => {
+		execFile("ps", args, { maxBuffer: PS_MAX_BUFFER, windowsHide: true }, (_error, output) =>
+			resolve(typeof output === "string" ? output : String(output ?? "")),
+		);
+	});
+}
+
+function taskkillTree(pid) {
+	return new Promise((resolve) => {
+		execFile("taskkill", ["/T", "/F", "/PID", String(pid)], { windowsHide: true }, () => resolve());
+	});
+}
+
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}

package/src/kernels/js/worker-core.js

@@ -1,7 +1,8 @@
 import { JsWorkerRuntime } from "./worker-runtime.js";
 
-// Mirrors INTERRUPT_ACK_OP in src/bridge/reserved.ts (this worker file cannot import TypeScript).
+// Mirrors INTERRUPT_ACK_OP and CHILD_LIFECYCLE_OP in src/bridge/reserved.ts (this worker file cannot import TypeScript).
 const INTERRUPT_ACK_OP = "interrupt-ack";
+const CHILD_LIFECYCLE_OP = "child";
 
 // Mirrors SESSION_ENVIRONMENT_KEYS in src/kernels/session-env.ts (this worker file
 // cannot import TypeScript). Keys the active session does not set must be dropped so a
@@ -73,6 +74,7 @@ export function createWorkerCore(transport, options) {
 				parallelPoolWidth: options.parallelPoolWidth,
 				localRoots: message.connection.localRoots,
 				artifactsDir: message.connection.artifactsDir,
+				onChildEvent: (event) => emit({ type: "status", event: { op: CHILD_LIFECYCLE_OP, ...event } }),
 			});
 			emit({ type: "ready" });
 			return;

package/src/kernels/js/worker-runtime.js

@@ -3,10 +3,14 @@ import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join, normalize, resolve, sep } from "node:path";
 import { inspect } from "node:util";
 import { encodeDisplayImage, resolveDisplayOps } from "./display-image.js";
+import { terminateProcessTrees } from "./process-tree.js";
 import { awaitMaybePromise, indirectEval, wrapUserCode } from "./worker-indirect-eval.js";
 import { installShellCapture } from "./worker-shell-capture.js";
 
 const PREPARED_CELL_PREFIX = "/*senpi:prepared-cell*/";
+// How long a child gets to honour SIGTERM before SIGKILL. Short, because the
+// cell has already produced its value and the caller is waiting on settle.
+const CHILD_TERMINATION_GRACE_MS = 1_000;
 const INTERNAL_URL = /^([a-z][a-z0-9+.-]*):\/\/(.*)$/iu;
 
 export class JsWorkerRuntime {
@@ -17,10 +21,12 @@ export class JsWorkerRuntime {
 	#hooks = null;
 	#pendingDisplays = [];
 	#children = new Set();
+	#onChildEvent;
 
 	constructor(options) {
 		this.#cwd = options.cwd;
 		this.#parallelPoolWidth = options.parallelPoolWidth;
+		this.#onChildEvent = typeof options.onChildEvent === "function" ? options.onChildEvent : null;
 		this.#localRoots = { ...(options.localRoots ?? {}) };
 		if (options.artifactsDir && !this.#localRoots.local) this.#localRoots.local = join(options.artifactsDir, "local");
 		this.#installGlobals();
@@ -42,24 +48,46 @@ export class JsWorkerRuntime {
 			return value;
 		} finally {
 			this.#pendingDisplays = [];
-			this.#children.clear();
+			// A child still running here has lost its only owner: the cell that
+			// spawned it is over, nothing will await it again, and it would be
+			// reparented to init. Retire it the way timeout and abort cleanup
+			// already do, unless the cell asked for a detached process.
+			await this.#terminateChildren();
 			this.#hooks = null;
 		}
 	}
 
 	interrupt() {
-		for (const child of this.#children) {
-			if (child.exitCode === null && child.signalCode === null) child.kill();
-		}
+		// The tree snapshot, SIGTERM, and SIGKILL escalation run on their own so
+		// the caller's interrupt latency stays that of the acknowledgement.
+		void this.#terminateChildren();
 	}
 
-	#trackChild(child) {
+	#trackChild(child, spawnOptions) {
 		if (child === null || typeof child !== "object" || typeof child.kill !== "function") return;
+		// `detached: true` is the cell saying it wants the process to outlive it.
+		if (isPlainObject(spawnOptions) && spawnOptions.detached === true) return;
 		this.#children.add(child);
-		const forget = () => this.#children.delete(child);
+		const pid = Number.isInteger(child.pid) && child.pid > 0 ? child.pid : null;
+		// The host keeps its own copy of live pids: if this worker is terminated
+		// while blocked, only the host can still retire them.
+		if (pid !== null) this.#onChildEvent?.({ pid, state: "spawned" });
+		const forget = () => {
+			this.#children.delete(child);
+			if (pid !== null) this.#onChildEvent?.({ pid, state: "exited" });
+		};
 		if (child.exited instanceof Promise) child.exited.then(forget, forget);
 	}
 
+	#terminateChildren() {
+		const children = [...this.#children].filter(child => child.exitCode === null && child.signalCode === null);
+		this.#children.clear();
+		if (children.length === 0) return undefined;
+		const roots = children.map(child => child.pid).filter(pid => Number.isInteger(pid) && pid > 0);
+		const settled = Promise.allSettled(children.map(child => (child.exited instanceof Promise ? child.exited : Promise.resolve())));
+		return terminateProcessTrees(roots, { graceMs: CHILD_TERMINATION_GRACE_MS, settled });
+	}
+
 	async #drainPendingDisplays() {
 		while (this.#pendingDisplays.length > 0) {
 			const pending = this.#pendingDisplays;
@@ -114,7 +142,7 @@ export class JsWorkerRuntime {
 		const restoreShellCapture = installShellCapture({
 			isActive: () => this.#hooks !== null,
 			emitText: (stream, data) => this.#emitText(stream, data),
-			onChild: (child) => this.#trackChild(child),
+			onChild: (child, spawnOptions) => this.#trackChild(child, spawnOptions),
 		});
 		globalThis.__senpi_restore_console__ = () => {
 			console.log = originalLog;

package/src/kernels/js/worker-shell-capture.d.ts

@@ -3,6 +3,7 @@ export type ShellCaptureStream = "stdout" | "stderr";
 export type ShellCaptureRestore = () => void;
 
 export interface ShellCaptureChild {
+	readonly pid?: number;
 	readonly exitCode: number | null;
 	readonly signalCode: string | null;
 	readonly exited: Promise<number>;
@@ -13,7 +14,7 @@ export interface ShellCaptureOptions {
 	readonly isActive: () => boolean;
 	readonly emitText: (stream: ShellCaptureStream, data: string) => void;
 	/** Receives every `Bun.spawn` child created while a cell is active so the runtime can kill it on interrupt. */
-	readonly onChild?: (child: ShellCaptureChild) => void;
+	readonly onChild?: (child: ShellCaptureChild, spawnOptions?: unknown) => void;
 }
 
 export function installShellCapture(options: ShellCaptureOptions): ShellCaptureRestore;