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

package/CHANGELOG.md

@@ -12,6 +12,51 @@
 
 ### 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
+
+### Added
+
+- Added `PI_SESSION_CWD` and `PI_GOAL_STORE_FILE` session environment keys for kernels and shell children, including clearing of inherited values when absent (fixes #1663).
+
+- Interactive foreground eval cells detach on queued steering without cancelling their computation or in-flight tools. An occupied detached slot keeps the call waiting ([#1637](https://github.com/code-yeongyu/senpi/issues/1637)).
+
+### Changed
+
+### Fixed
+
+### Removed
+
 ## [2026.9.13] - 2026-09-13
 
 ### Breaking Changes

package/README.md

@@ -57,8 +57,9 @@ schema; it is not an installation failure.
 ### Session environment
 
 Every kernel starts with the active session's `PI_*` environment — `PI_SESSION_ID`,
-`PI_SESSION_FILE` (when the session is persistent), `PI_PROVIDER`, `PI_MODEL`, and
-`PI_REASONING_LEVEL` (when set) — resolved at session start, mirroring the bash tool's
+`PI_SESSION_FILE` (when the session is persistent), `PI_SESSION_CWD` (the session's
+working directory), `PI_GOAL_STORE_FILE` (the authoritative goal-store path, when the
+host provides it), `PI_PROVIDER`, `PI_MODEL`, and `PI_REASONING_LEVEL` (when set) — resolved at session start, mirroring the bash tool's
 session environment contract. The values are visible to `env()`/`process.env`/`os.environ`
 inside cells and are inherited by every child process a cell spawns
 (`Bun.$`, `Bun.spawn`, `child_process`, `subprocess`, ...). Inherited `PI_*` values from
@@ -67,6 +68,11 @@ what a child spawned from the bash tool sees. The values snapshot at kernel star
 mid-session model switch updates the bash tool's next command but not already-running
 kernels; a new session starts fresh kernels with fresh values.
 
+`PI_GOAL_STORE_FILE` is supplied by the host's optional `ExtensionContext.goalStoreFile`
+getter and may name a file that does not exist yet. It honors session-directory overrides
+and in-memory sessions; it cannot be derived reliably from `PI_SESSION_FILE`. If the host
+omits the getter, the variable is unset rather than inherited from the launching process.
+
 ## Settings
 
 Configuration is loaded in this order:
@@ -177,6 +183,12 @@ cell keeps only its own language kernel busy. A new same-language call returns
 a busy error with its cell id and output tail; calls in other languages continue
 normally. Do not re-run the cell.
 
+Queued steering also detaches an eligible interactive foreground call, including
+one paused in a host tool bridge, without cancelling its computation. If the
+language's detached slot is occupied, steering leaves the call waiting. Follow-up
+messages, explicit `on_timeout: "error"`, and print/JSON calls do not trigger this
+transition; caller abort and existing deadlines retain their cancellation behavior.
+
 Every cell, detached or not, is bounded by two kill deadlines. The run budget
 (`runBudgetSeconds`, or the call's `timeout`) charges only the cell's own
 execution time and is paused while a host tool call is in flight, so a cell
@@ -185,8 +197,8 @@ The hard limit (`hardLimitSeconds`, raised by a larger `timeout`) is wall-clock
 and bounds parked cells too. A cell killed by either deadline reports which one
 in its result or completion notification, together with whether kernel state
 survived; the tool schema states the configured numbers. The `timeout` value
-never changes when an interactive call detaches: that is `cellTimeoutSeconds`
-capped by `foregroundWindowSeconds`.
+never changes the idle detach deadline: that is `cellTimeoutSeconds` capped by
+`foregroundWindowSeconds`; queued steering can detach the call earlier.
 
 While any cell is detached, the interactive footer shows a highlighted
 `↗ <language> · <summary>` status on the extension status line (the cell id

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-codemode",
-	"version": "2026.9.13",
+	"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",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.9.15-2",
 		"typebox": "1.3.27"
 	},
 	"peerDependencies": {
-		"@code-yeongyu/senpi": "2026.9.13"
+		"@code-yeongyu/senpi": "2026.9.15-2"
 	},
 	"devDependencies": {
-		"@code-yeongyu/senpi": "2026.9.13"
+		"@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
@@ -9,6 +10,8 @@ const INTERRUPT_ACK_OP = "interrupt-ack";
 const SESSION_ENVIRONMENT_KEYS = [
 	"PI_SESSION_ID",
 	"PI_SESSION_FILE",
+	"PI_SESSION_CWD",
+	"PI_GOAL_STORE_FILE",
 	"PI_PROVIDER",
 	"PI_MODEL",
 	"PI_REASONING_LEVEL",
@@ -71,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;