@code-yeongyu/senpi-codemode 2026.9.13 → 2026.9.15

package/CHANGELOG.md

@@ -12,6 +12,36 @@
 
 ### 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",
 	"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",
 		"typebox": "1.3.27"
 	},
 	"peerDependencies": {
-		"@code-yeongyu/senpi": "2026.9.13"
+		"@code-yeongyu/senpi": "2026.9.15"
 	},
 	"devDependencies": {
-		"@code-yeongyu/senpi": "2026.9.13"
+		"@code-yeongyu/senpi": "2026.9.15"
 	},
 	"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,9 @@ 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;
+
 export class JavaScriptKernel {
 	readonly #options: JavaScriptKernelOptions;
 	readonly #moduleLoader: LocalModuleLoader;
@@ -31,6 +35,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;
@@ -208,6 +214,10 @@ 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") {
@@ -248,8 +258,28 @@ export class JavaScriptKernel {
 		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;

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;

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

@@ -154,7 +154,7 @@ function capturedSpawn(originalSpawn, options, pinEnv) {
 					? originalSpawn(...args)
 					: originalSpawn(effective);
 		}
-		options.onChild?.(child);
+		options.onChild?.(child, Array.isArray(first) ? second : first);
 		return child;
 	};
 }

package/src/kernels/py/prelude.py

@@ -23,7 +23,7 @@ import uuid
 from collections.abc import Iterable
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from pathlib import Path
-from threading import Lock
+from threading import Lock, Thread
 from typing import Any, Callable
 from urllib.parse import unquote
 
@@ -1022,14 +1022,48 @@ def handle(message: dict[str, Any]) -> bool:
     return True
 
 
+def _terminate_process_group() -> None:
+    # The kernel is spawned into its own session (setsid), so its pid is its process
+    # group id and a cell's subprocesses inherit that group. Killing the group takes
+    # those children down with the kernel instead of orphaning them to init.
+    if os.name != "posix":
+        return
+    with contextlib.suppress(OSError):
+        os.killpg(os.getpgrp(), signal.SIGKILL)
+
+
+def _watch_parent(initial_ppid: int) -> None:
+    # A cell blocked in the main thread (for example a multiprocessing pool) never
+    # returns to the stdin loop, so it cannot notice the host closing its pipe. This
+    # daemon thread notices the reparenting instead and takes the whole group down.
+    while True:
+        time.sleep(1.0)
+        if os.getppid() != initial_ppid:
+            _terminate_process_group()
+            return
+
+
+def _start_parent_watch() -> None:
+    if os.name != "posix":
+        return
+    Thread(target=_watch_parent, args=(os.getppid(),), name="senpi-parent-watch", daemon=True).start()
+
+
 def main() -> None:
     signal.signal(signal.SIGINT, signal.SIG_IGN)
+    _start_parent_watch()
+    host_closed = False
     for raw in sys.stdin:
         try:
             if not handle(json.loads(raw)):
+                host_closed = True
                 break
         except BaseException as exc:  # noqa: BROAD_EXCEPT_OK — process boundary serializes malformed input and interrupts.
             emit({"type": "init-failed", "error": bridge_error(exc)})
+    # Reaching here without a close frame means the host's pipe hit EOF: it is gone,
+    # so retire any subprocess the last cell left running before the interpreter exits.
+    if not host_closed:
+        _terminate_process_group()
 
 
 if __name__ == "__main__":

package/src/kernels/py/process.ts

@@ -45,6 +45,12 @@ export function splitCommand(commandLine: string): { readonly command: string; r
 	return { command, args };
 }
 
+function errorCode(error: unknown): string | undefined {
+	if (typeof error !== "object" || error === null) return undefined;
+	const code = Reflect.get(error, "code");
+	return typeof code === "string" ? code : undefined;
+}
+
 export function numberOrNull(value: unknown): number | null {
 	return typeof value === "number" ? value : null;
 }
@@ -80,6 +86,20 @@ export async function waitForExit(child: KernelChild, timeoutMs: number): Promis
 	});
 }
 
+// A cell's own subprocess is spawned into the detached kernel's process group. When the
+// leader exits gracefully on close, kill the group so a Popen the cell left running does
+// not outlive the kernel; the group is addressed by the leader pid (== pgid) while members live.
+export function sweepProcessGroup(child: KernelChild): void {
+	if (child.pid === undefined || process.platform === "win32") return;
+	try {
+		process.kill(-child.pid, "SIGKILL");
+	} catch (error) {
+		// ESRCH means the group is already gone (the success case). Any other error
+		// (for example EPERM on a member we cannot signal) must not fail a graceful close.
+		if (errorCode(error) !== "ESRCH") return;
+	}
+}
+
 export async function hardKill(child: KernelChild, timeoutMs: number): Promise<void> {
 	await new Promise<void>((resolve, reject) => {
 		let timer: NodeJS.Timeout | undefined;

package/src/kernels/py/transport.ts

@@ -19,6 +19,7 @@ import {
 	numberOrNull,
 	signalOrNull,
 	splitCommand,
+	sweepProcessGroup,
 	waitForExit,
 	withTimeout,
 } from "./process.ts";
@@ -145,7 +146,10 @@ export class PythonKernelTransport {
 		} catch (error) {
 			if (!(error instanceof Error)) throw error;
 		}
-		if (!(await exited)) await hardKill(this.#child, hardKillWaitMs);
+		// hardKill kills the whole group; a graceful leader exit does not, so sweep it
+		// to retire any subprocess the cell left running in the kernel's process group.
+		if (await exited) sweepProcessGroup(this.#child);
+		else await hardKill(this.#child, hardKillWaitMs);
 	}
 
 	retire(): Promise<void> {

package/src/kernels/session-env.ts

@@ -12,6 +12,8 @@
 export const SESSION_ENVIRONMENT_KEYS = [
 	"PI_SESSION_ID",
 	"PI_SESSION_FILE",
+	"PI_SESSION_CWD",
+	"PI_GOAL_STORE_FILE",
 	"PI_PROVIDER",
 	"PI_MODEL",
 	"PI_REASONING_LEVEL",
@@ -22,6 +24,8 @@ export type SessionEnvironment = Readonly<Record<string, string>>;
 
 /** Structural slice of `ExtensionContext` the session environment is resolved from. */
 export interface SessionEnvironmentSource {
+	readonly cwd: string;
+	readonly goalStoreFile?: string;
 	readonly sessionManager: {
 		getSessionId(): string;
 		getSessionFile(): string | undefined;
@@ -33,6 +37,8 @@ export interface SessionEnvironmentSource {
 export function sessionEnvironmentFrom(source: SessionEnvironmentSource): SessionEnvironment {
 	const env: Record<string, string> = {};
 	env.PI_SESSION_ID = source.sessionManager.getSessionId();
+	env.PI_SESSION_CWD = source.cwd;
+	if (source.goalStoreFile) env.PI_GOAL_STORE_FILE = source.goalStoreFile;
 	const sessionFile = source.sessionManager.getSessionFile();
 	if (sessionFile) env.PI_SESSION_FILE = sessionFile;
 	const model = source.model;

package/src/tool/detached-cell-manager.ts

@@ -144,7 +144,12 @@ export class EvalDetachedCellManager {
 	}
 
 	detach(cell: ManagedCell): boolean {
-		if (!cell.canDetach || !allowsDetachedCellTransition(cell.state, "detached")) return false;
+		if (
+			!cell.canDetach ||
+			!allowsDetachedCellTransition(cell.state, "detached") ||
+			this.#detachedByLanguage.has(cell.input.language)
+		)
+			return false;
 		cell.state = "detached";
 		cell.wasDetached = true;
 		this.#detachedByLanguage.set(cell.input.language, cell);

package/src/tool/run-eval-cell.ts

@@ -49,6 +49,12 @@ export async function runEvalCell(
 	let detached = false;
 	let execution: CellExecution;
 	const cell = cellManager.create(invocation.cellId, invocation.input, (error) => execution.cancel(error));
+	const detach = (): boolean => {
+		if (!cellManager.detach(cell)) return false;
+		detached = true;
+		execution.detach();
+		return true;
+	};
 	execution = new CellExecution({
 		callerSignal: invocation.signal,
 		cellId: invocation.cellId,
@@ -58,12 +64,7 @@ export async function runEvalCell(
 						timeoutMs: detachAfterMs,
 						maxPauseGraceMs: foregroundWindowMs,
 						onTimeout: (error: Error) => {
-							if (cellManager.detach(cell)) {
-								detached = true;
-								execution.detach();
-								return;
-							}
-							execution.cancel(error);
+							if (!detach()) execution.cancel(error);
 						},
 					},
 				}
@@ -74,6 +75,16 @@ export async function runEvalCell(
 			bridgeAbortController.abort(error);
 		},
 	});
+	const steeringSignal =
+		detaches && invocation.ctx.mode !== "print" && invocation.ctx.mode !== "json"
+			? invocation.ctx.steeringSignal
+			: undefined;
+	const onSteering = (): void => {
+		if (!steeringSignal?.aborted || detached || !state.active || invocation.signal.aborted) return;
+		// Losing the slot keeps this call foreground; only the existing deadlines/caller may cancel it.
+		detach();
+	};
+	steeringSignal?.addEventListener("abort", onSteering, { once: true });
 	const running = executeCell(
 		options,
 		invocation,
@@ -83,6 +94,7 @@ export async function runEvalCell(
 		execution,
 		bridgeContext,
 		bridgeAbortController,
+		onSteering,
 	);
 	let settleEventEmitted = false;
 	const emitSettled = (outcome: EvalExecutionSettleOutcome): void => {
@@ -110,12 +122,16 @@ export async function runEvalCell(
 			throw error;
 		},
 	);
-	const outcome = await Promise.race([
-		finalized.then((result) => ({ kind: "result" as const, result })),
-		execution.detached.then(() => ({ kind: "detached" as const })),
-	]);
-	if (outcome.kind === "detached") return resultAfterDetach(cellManager.peek(invocation.cellId), invocation.input);
-	return outcome.result;
+	try {
+		const outcome = await Promise.race([
+			finalized.then((result) => ({ kind: "result" as const, result })),
+			execution.detached.then(() => ({ kind: "detached" as const })),
+		]);
+		if (outcome.kind === "detached") return resultAfterDetach(cellManager.peek(invocation.cellId), invocation.input);
+		return outcome.result;
+	} finally {
+		steeringSignal?.removeEventListener("abort", onSteering);
+	}
 }
 
 async function executeCell(
@@ -127,6 +143,7 @@ async function executeCell(
 	execution: CellExecution,
 	bridgeContext: ExtensionContext,
 	bridgeAbortController: AbortController,
+	onReady: () => void,
 ): Promise<AgentToolResult<EvalToolDetails>> {
 	let handler: CellHandler | undefined;
 	try {
@@ -168,6 +185,8 @@ async function executeCell(
 			() => activeHandler.liveResult(),
 			(error) => execution.cancel(error),
 		);
+		// Includes a steer already queued at execute start or received while acquiring the kernel.
+		onReady();
 		if ("setContext" in options.kernelManager && typeof options.kernelManager.setContext === "function") {
 			options.kernelManager.setContext(bridgeContext);
 		}

package/src/tool/tool-widgets.ts

@@ -139,6 +139,15 @@ function renderWith<TParams extends TSchema, TDetails, TState>(
 	}
 }
 
+function grepDetailsSummary(summary: EvalToolCallSummary): string | undefined {
+	const details = summary.details;
+	if (details === undefined || details === null || typeof details !== "object") return undefined;
+	const record = details as { matchCount?: unknown; fileCount?: unknown; engine?: unknown };
+	if (typeof record.fileCount !== "number" || typeof record.engine !== "string") return undefined;
+	if (record.matchCount !== null && typeof record.matchCount !== "number") return undefined;
+	return `matches=${record.matchCount ?? "n/a"} files=${record.fileCount} (${record.engine})`;
+}
+
 function createCoreWidgets(cwd: string): CoreWidgets {
 	const bashDefinition = createBashToolDefinition(cwd);
 	const readDefinition = createReadToolDefinition(cwd);
@@ -155,7 +164,13 @@ function createCoreWidgets(cwd: string): CoreWidgets {
 			}),
 		read: (summary, options) => renderWith(readDefinition, summary, options, {}),
 		write: (summary, options) => renderWith(writeDefinition, summary, options, {}),
-		grep: (summary, options) => renderWith(grepDefinition, summary, options, {}),
+		grep: (summary, options) => {
+			const lines = renderWith(grepDefinition, summary, options, {});
+			if (lines === undefined) return undefined;
+			const extra = grepDetailsSummary(summary);
+			if (extra !== undefined) lines.push(`  ${style(options.theme, "muted", extra)}`);
+			return lines;
+		},
 		find: (summary, options) => renderWith(findDefinition, summary, options, {}),
 		ls: (summary, options) => renderWith(lsDefinition, summary, options, {}),
 	};

package/src/tool/types.ts

@@ -153,6 +153,7 @@ export interface EvalToolCallSummary {
 	readonly argsTruncated?: boolean;
 	readonly durationMs?: number;
 	readonly resultPreview?: string;
+	readonly details?: unknown;
 }
 
 export type EvalStatusEvent = { readonly op: string } & Readonly<Record<string, unknown>>;