@code-yeongyu/senpi-codemode 2026.10.10 → 2026.10.11

package/src/kernels/js/cell-ownership.js

@@ -0,0 +1,268 @@
+import { currentCell, onReleaseOf, settleWithCell } from "./cell-run-context.js";
+
+// What a cell owns, and how each kind ends when the cell is stopped. Every patch is a no-op outside a cell, refuses
+// (or never starts) new work for a released cell, and registers what a live cell starts so release can end it.
+const RESOURCE_CLOSERS = ["terminate", "destroy", "stop", "close", "end"];
+
+// Some host bindings are read-only (Bun.fetch); those keep their own behaviour and are not owned by cells.
+function replace(owner, name, replacement, patched) {
+	const original = owner[name];
+	try {
+		owner[name] = replacement;
+	} catch {
+		return;
+	}
+	if (owner[name] !== replacement) return;
+	patched.push(() => {
+		owner[name] = original;
+	});
+}
+
+function builtin(name) {
+	return process.getBuiltinModule?.(name);
+}
+
+function closeResource(resource) {
+	for (const method of RESOURCE_CLOSERS) {
+		if (typeof resource?.[method] !== "function") continue;
+		if (method === "stop") resource.stop(true);
+		else resource[method]();
+		return;
+	}
+}
+
+function ownResultsOf(owner, names, patched) {
+	for (const name of names) {
+		const original = owner?.[name];
+		if (typeof original !== "function") continue;
+		const own = function (...args) {
+			const cell = currentCell();
+			if (cell === undefined) return original.apply(this, args);
+			if (cell.released) throw cell.interruption;
+			const result = original.apply(this, args);
+			const register = (resource) => {
+				onReleaseOf(cell, () => closeResource(resource));
+				return resource;
+			};
+			return result instanceof Promise ? result.then(register) : register(result);
+		};
+		Object.assign(own, original);
+		replace(owner, name, own, patched);
+	}
+}
+
+// `globals` is the global scope already patched: a module binding that is the same owned function is left alone.
+function patchTimers(scope, patched, globals = undefined) {
+	for (const [name, clearName] of [
+		["setTimeout", "clearTimeout"],
+		["setInterval", "clearInterval"],
+		["setImmediate", "clearImmediate"],
+	]) {
+		const original = scope?.[name];
+		const clear = scope?.[clearName];
+		if (typeof original !== "function" || typeof clear !== "function") continue;
+		if (globals !== undefined && original === globals[name]) continue;
+		const owned = function (callback, ...rest) {
+			const cell = currentCell();
+			if (cell === undefined || typeof callback !== "function") return original.call(this, callback, ...rest);
+			if (cell.released) {
+				const never = original.call(this, () => {}, ...rest);
+				clear.call(scope, never);
+				return never;
+			}
+			let forget = () => {};
+			const handle = original.call(
+				this,
+				function (...args) {
+					if (name !== "setInterval") forget();
+					return callback.apply(this, args);
+				},
+				...rest,
+			);
+			forget = onReleaseOf(cell, () => clear.call(scope, handle));
+			return handle;
+		};
+		Object.assign(owned, original);
+		replace(scope, name, owned, patched);
+	}
+}
+
+function patchPromiseApi(owner, name, patched) {
+	const original = owner?.[name];
+	if (typeof original !== "function") return;
+	const bound = function (...args) {
+		const cell = currentCell();
+		if (cell === undefined) return original.apply(this, args);
+		if (cell.released) return Promise.reject(cell.interruption);
+		return settleWithCell(cell, original.apply(this, args));
+	};
+	Object.assign(bound, original);
+	replace(owner, name, bound, patched);
+}
+
+function patchTimerPromises(patched) {
+	const timers = builtin("node:timers/promises");
+	if (timers === undefined) return;
+	patchPromiseApi(timers, "setTimeout", patched);
+	patchPromiseApi(timers, "setImmediate", patched);
+	const original = timers.setInterval;
+	if (typeof original !== "function") return;
+	const owned = function (...args) {
+		const cell = currentCell();
+		if (cell?.released) throw cell.interruption;
+		const iterator = original.apply(this, args);
+		if (cell === undefined) return iterator;
+		onReleaseOf(cell, () => void iterator.return?.());
+		return iterator;
+	};
+	replace(timers, "setInterval", owned, patched);
+}
+
+function patchFetch(scope, patched, name = "fetch") {
+	const original = scope[name];
+	if (typeof original !== "function") return;
+	const owned = function (input, init) {
+		const cell = currentCell();
+		if (cell === undefined) return original.call(this, input, init);
+		if (cell.released) return Promise.reject(cell.interruption);
+		const controller = new AbortController();
+		const own = init?.signal ?? (input instanceof Request ? input.signal : undefined);
+		const signal = own === undefined ? controller.signal : AbortSignal.any([own, controller.signal]);
+		const forget = onReleaseOf(cell, () => controller.abort(cell.interruption));
+		return original.call(this, input, { ...init, signal }).finally(forget);
+	};
+	Object.assign(owned, original);
+	replace(scope, name, owned, patched);
+}
+
+// A released cell's code may still be resumed by a short I/O completion; refusing new I/O at that point makes such a
+// loop throw the interruption on its next operation instead of running on in the kept worker.
+function refuseWhenReleased(owner, names, patched) {
+	for (const name of names) {
+		const original = owner?.[name];
+		if (typeof original !== "function") continue;
+		const guarded = function (...args) {
+			const cell = currentCell();
+			if (cell?.released) throw cell.interruption;
+			const result = original.apply(this, args);
+			return cell === undefined ? result : settleWithCell(cell, result);
+		};
+		Object.assign(guarded, original);
+		replace(owner, name, guarded, patched);
+	}
+}
+
+// The callback form: a released cell's operation is never started, so its callback never runs, the same way a timer a
+// released cell sets never fires.
+function neverStartWhenReleased(owner, names, patched) {
+	for (const name of names) {
+		const original = owner?.[name];
+		if (typeof original !== "function") continue;
+		const guarded = function (...args) {
+			if (currentCell()?.released) return undefined;
+			return original.apply(this, args);
+		};
+		Object.assign(guarded, original);
+		replace(owner, name, guarded, patched);
+	}
+}
+
+const FS_OPERATIONS = ["readFile", "writeFile", "appendFile", "readdir", "stat", "lstat", "open", "access", "mkdir", "rm", "unlink", "rename", "copyFile"];
+
+// For ES classes only (Worker, WebSocket, MessageChannel): `instanceof` keeps accepting instances the runtime creates
+// internally from the original class. Node's function-style constructors are owned on activation instead.
+function patchClass(scope, name, close, patched) {
+	const Original = scope?.[name];
+	if (typeof Original !== "function") return;
+	const Owned = class extends Original {
+		constructor(...args) {
+			const cell = currentCell();
+			if (cell?.released) throw cell.interruption;
+			super(...args);
+			if (cell !== undefined) onReleaseOf(cell, () => close(this));
+		}
+		static [Symbol.hasInstance](value) {
+			return value instanceof Original;
+		}
+	};
+	Object.defineProperty(Owned, "name", { value: Original.name });
+	replace(scope, name, Owned, patched);
+}
+
+const NODE_RESOURCE_FACTORIES = {
+	"node:net": ["createConnection", "connect", "createServer"],
+	"node:tls": ["connect", "createServer"],
+	"node:http": ["request", "get", "createServer"],
+	"node:https": ["request", "get", "createServer"],
+	"node:dgram": ["createSocket"],
+	"node:fs": ["createReadStream", "createWriteStream", "watch"],
+	"node:readline": ["createInterface"],
+	"node:readline/promises": ["createInterface"],
+};
+
+// Node's socket and server types are function-style constructors that Node's own subclasses call with `.call(this)`
+// (http.Server calls net.Server), so they cannot be swapped for a class. A socket or server only does anything once it
+// connects, listens or binds, so that call is where a cell takes ownership of it; http, https and tls inherit these.
+const NODE_ACTIVATIONS = {
+	"node:net": { Socket: ["connect"], Server: ["listen"] },
+	"node:dgram": { Socket: ["bind"] },
+};
+
+function ownOnActivation(proto, names, patched) {
+	for (const name of names) {
+		const original = proto?.[name];
+		if (typeof original !== "function") continue;
+		const owned = new WeakSet();
+		const activate = function (...args) {
+			const cell = currentCell();
+			if (cell === undefined) return original.apply(this, args);
+			if (cell.released) throw cell.interruption;
+			if (!owned.has(this)) {
+				owned.add(this);
+				onReleaseOf(cell, () => closeResource(this));
+			}
+			return original.apply(this, args);
+		};
+		replace(proto, name, activate, patched);
+	}
+}
+
+export function installCellOwnership(scope = globalThis) {
+	const patched = [];
+	patchTimers(scope, patched);
+	patchTimers(builtin("node:timers"), patched, scope);
+	patchTimerPromises(patched);
+	patchFetch(scope, patched);
+	patchClass(scope, "WebSocket", (socket) => socket.close(), patched);
+	patchClass(scope, "Worker", (worker) => void worker.terminate(), patched);
+	refuseWhenReleased(builtin("node:fs/promises"), FS_OPERATIONS, patched);
+	neverStartWhenReleased(builtin("node:fs"), FS_OPERATIONS, patched);
+	patchClass(scope, "MessageChannel", (channel) => {
+		channel.port1.close();
+		channel.port2.close();
+	}, patched);
+	patchClass(scope, "BroadcastChannel", (channel) => channel.close(), patched);
+	const bun = scope.Bun;
+	if (bun !== undefined) {
+		patchPromiseApi(bun, "sleep", patched);
+		if (bun.fetch !== scope.fetch) patchFetch(bun, patched, "fetch");
+		refuseWhenReleased(bun, ["file", "write"], patched);
+		ownResultsOf(bun, ["connect", "listen", "serve", "udpSocket"], patched);
+	}
+	for (const [module, factories] of Object.entries(NODE_RESOURCE_FACTORIES)) ownResultsOf(builtin(module), factories, patched);
+	patchClass(builtin("node:worker_threads"), "Worker", (worker) => void worker.terminate(), patched);
+	for (const [module, types] of Object.entries(NODE_ACTIVATIONS)) {
+		for (const [name, methods] of Object.entries(types)) ownOnActivation(builtin(module)?.[name]?.prototype, methods, patched);
+	}
+	// Node hands `import("node:…")` its own ESM namespace; without this sync a cell importing the module gets the
+	// unowned originals.
+	syncBuiltinExports();
+	return () => {
+		for (const undo of patched.reverse()) undo();
+		syncBuiltinExports();
+	};
+}
+
+function syncBuiltinExports() {
+	builtin("node:module")?.syncBuiltinESMExports?.();
+}

package/src/kernels/js/cell-run-context.js

@@ -0,0 +1,89 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+
+// Every continuation a cell creates (awaits, timers, I/O callbacks) runs inside its cell record. Stopping a cell
+// releases it: everything it owns is cleared, rejected or closed (`cell-ownership.js` decides what a cell owns), and
+// anything its code tries to start afterwards is refused, while the kernel and its variables stay.
+const cellRuns = new AsyncLocalStorage();
+const releasedInterruptions = new WeakMap();
+const MAX_CAUSE_DEPTH = 8;
+
+export function runInCell(cell, run) {
+	return cellRuns.run(cell, run);
+}
+
+export function currentCell() {
+	return cellRuns.getStore();
+}
+
+export function releasedCellError() {
+	const cell = cellRuns.getStore();
+	return cell?.released === true ? cell.interruption : undefined;
+}
+
+export function assertCellLive() {
+	const error = releasedCellError();
+	if (error !== undefined) throw error;
+}
+
+export function onCellRelease(close) {
+	const cell = cellRuns.getStore();
+	return cell === undefined ? () => {} : onReleaseOf(cell, close);
+}
+
+export function onReleaseOf(cell, close) {
+	cell.onRelease ??= new Set();
+	cell.onRelease.add(close);
+	return () => cell.onRelease.delete(close);
+}
+
+/**
+ * Releases the cell: every closer runs even when an earlier one throws, and the failures are returned so the caller
+ * can report them; a resource that would not close is a fact the user should see, not something to swallow.
+ */
+export function releaseCell(cell) {
+	cell.released = true;
+	releasedInterruptions.set(cell.interruption, cell);
+	const failures = [];
+	for (const close of cell.onRelease ?? []) {
+		try {
+			close();
+		} catch (error) {
+			failures.push(error);
+		}
+	}
+	cell.onRelease?.clear();
+	return failures;
+}
+
+/**
+ * The cell an unhandled rejection came from: a released cell whose interruption is the reason or sits in its `cause`
+ * chain, or the cell whose async context the rejection runs in (Node exposes it to the handler; Bun does not).
+ */
+export function cellOfRejection(reason) {
+	let current = reason;
+	for (let depth = 0; depth < MAX_CAUSE_DEPTH && typeof current === "object" && current !== null; depth++) {
+		const cell = releasedInterruptions.get(current);
+		if (cell !== undefined) return cell;
+		current = current.cause;
+	}
+	return cellRuns.getStore();
+}
+
+// An operation already in flight when its cell is released rejects with the interruption at once, so the stopped
+// cell's continuation never runs again; a non-promise result is returned as it is.
+export function settleWithCell(cell, result) {
+	if (result === null || typeof result !== "object" || typeof result.then !== "function") return result;
+	return new Promise((resolve, reject) => {
+		const forget = onReleaseOf(cell, () => reject(cell.interruption));
+		result.then(
+			(value) => {
+				forget();
+				resolve(value);
+			},
+			(error) => {
+				forget();
+				reject(error);
+			},
+		);
+	});
+}

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

@@ -1,9 +1,9 @@
 import type { 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 { KernelToolHostPump } from "../shared/kernel-tools-pump.ts";
 import { ActiveCellControl } from "./active-cell-control.ts";
 import { dispatchCell } from "./cell-dispatch.ts";
+import { consumeControlFrame } from "./control-frames.ts";
 import { HostEntries } from "./host-entries.ts";
 import { DEFAULT_INTERRUPT_BOUNDS, JS_INTERRUPT_GRACE_MS, type WorkerRetirement } from "./interrupt-bounds.ts";
 import {
@@ -14,7 +14,8 @@ import {
 	type ResultMessage,
 	type ToolCallMessage,
 } from "./kernel-contract.ts";
-import { type JavaScriptMemoryReading, KernelMemoryBridge } from "./kernel-memory-bridge.ts";
+import { JavaScriptKernelMemory } from "./kernel-memory.ts";
+import type { JavaScriptMemoryReading } from "./kernel-memory-bridge.ts";
 import { kernelToolError } from "./kernel-tools-errors.ts";
 import type {
 	KernelToolsDescribeResult,
@@ -25,7 +26,6 @@ import { type JavaScriptKernelOptions, LocalModuleLoader } from "./local-module-
 import { JavaScriptRunQueue, type PendingJavaScriptRun } from "./run-queue.ts";
 import { ToolCallQueue } from "./tool-call-queue.ts";
 import { WorkerChildren } from "./worker-children.ts";
-import { crashedResult } from "./worker-host.ts";
 import { WorkerRecovery } from "./worker-recovery.ts";
 import { WorkerSlot } from "./worker-slot.ts";
 
@@ -57,7 +57,7 @@ export class JavaScriptKernel {
 	);
 	readonly #toolCalls = new ToolCallQueue();
 	readonly #children: WorkerChildren;
-	readonly #memory: KernelMemoryBridge;
+	readonly #memory: JavaScriptKernelMemory;
 	readonly #activeCell: ActiveCellControl;
 	readonly #recovery = new WorkerRecovery({
 		runs: this.#runs,
@@ -76,7 +76,7 @@ export class JavaScriptKernel {
 			recover: () => void this.#recovery.recover(() => Promise.resolve()),
 			clearToolCalls: () => this.#toolCalls.clear(),
 		});
-		this.#memory = new KernelMemoryBridge(options.memory, options.onMemoryCollected);
+		this.#memory = new JavaScriptKernelMemory(options, () => this.#slot.processPid);
 		this.#children = new WorkerChildren(options.collectOrphanedChildren);
 		this.#moduleLoader = new LocalModuleLoader(options);
 		this.#slot = new WorkerSlot(options, {
@@ -90,15 +90,20 @@ export class JavaScriptKernel {
 		return this.#slot.mode;
 	}
 
-	/** The last heap reading the worker sent (a result, an idle collection, a query); none before the first. */
+	/** The kernel process's pid in process mode; none in worker mode or before it starts. */
+	get processPid(): number | undefined {
+		return this.#slot.processPid;
+	}
+
+	/** The last memory reading (a result, an idle collection, a query); none before the first. */
 	get lastLiveBytes(): number | undefined {
 		return this.#memory.lastLiveBytes;
 	}
 
 	/** A heap reading taken between cells without running one; nothing when no worker is live to ask. */
 	async queryMemory(): Promise<JavaScriptMemoryReading | undefined> {
-		if (this.#lifecycle !== "open" || !this.#slot.present || this.#slot.startingUp) return undefined;
-		return await this.#memory.query((message) => this.#slot.postMessage(message));
+		const ready = this.#lifecycle === "open" && this.#slot.present && !this.#slot.startingUp;
+		return await this.#memory.query(ready ? (message) => this.#slot.postMessage(message) : undefined);
 	}
 
 	get kernelToolEvents(): EventTarget {
@@ -202,7 +207,13 @@ export class JavaScriptKernel {
 
 	async #ensureReady(): Promise<void> {
 		assertJavaScriptKernelOpen(this.#lifecycle, "run");
-		await this.#slot.ensureReady();
+		try {
+			await this.#slot.ensureReady();
+		} catch (error) {
+			if (this.#options.isolation !== "process") throw error;
+			// Process mode reports a failed start on the waiting cell, never as a rejection of run().
+			if (this.#lifecycle === "open") this.#runs.settleAll(error instanceof Error ? error.message : String(error));
+		}
 	}
 
 	#startNext(): void {
@@ -224,15 +235,7 @@ export class JavaScriptKernel {
 
 	#handleMessage(message: KernelToHostMessage): void {
 		if (this.#kernelTools.consume(message) && message.type !== "tool-call") return;
-		if (this.#memory.consume(message)) return;
-		if (message.type === "status" && message.event.op === INTERRUPT_ACK_OP) {
-			this.#runs.acknowledgeInterrupt(message.event);
-			return;
-		}
-		if (message.type === "status" && message.event.op === CHILD_LIFECYCLE_OP) {
-			this.#children.track(message.event);
-			return;
-		}
+		if (consumeControlFrame(message, { memory: this.#memory, runs: this.#runs, children: this.#children })) return;
 		(this.#runs.active?.input.onMessage ?? this.#options.onMessage)?.(message);
 		if (message.type === "tool-call") {
 			this.#toolCalls.push(message);
@@ -255,14 +258,10 @@ export class JavaScriptKernel {
 		if (!active && this.#slot.startingUp) return;
 		this.#activeCell.disarm();
 		this.#kernelTools.rejectAll(kernelToolError("kernel_tool_stale", error.message));
-		this.#memory.workerLost(error);
+		this.#memory.crashed(error);
 		// A crash mid-install stops the install (process group killed, nothing published); it settles itself once stopped.
 		if (active && !this.#hostEntries.abort(active, `JavaScript worker crashed: ${error.message}`)) {
-			this.#runs.releaseActive(active);
-			this.#runs.settle(
-				active,
-				crashedResult(active.input.cellId, error, this.#runs.durationMs(active, performance.now())),
-			);
+			this.#runs.settleCrashed(active, error);
 		}
 		this.#toolCalls.clear();
 		void this.#restartAfterStop();

package/src/kernels/js/control-frames.ts

@@ -0,0 +1,24 @@
+import type { KernelToHostMessage } from "../../bridge/protocol.ts";
+import { CHILD_LIFECYCLE_OP, INTERRUPT_ACK_OP } from "../../bridge/reserved.ts";
+import type { JavaScriptKernelMemory } from "./kernel-memory.ts";
+import type { JavaScriptRunQueue } from "./run-queue.ts";
+import type { WorkerChildren } from "./worker-children.ts";
+
+export interface ControlFrameOwners {
+	readonly memory: Pick<JavaScriptKernelMemory, "consume">;
+	readonly runs: Pick<JavaScriptRunQueue, "acknowledgeInterrupt">;
+	readonly children: Pick<WorkerChildren, "track">;
+}
+
+/** Routes a worker's side-channel frames (memory readings, interrupt acks, child lifecycle) to their owners. */
+export function consumeControlFrame(message: KernelToHostMessage, owners: ControlFrameOwners): boolean {
+	if (owners.memory.consume(message)) return true;
+	if (message.type !== "status") return false;
+	if (message.event.op === INTERRUPT_ACK_OP) {
+		owners.runs.acknowledgeInterrupt(message.event);
+		return true;
+	}
+	if (message.event.op !== CHILD_LIFECYCLE_OP) return false;
+	owners.children.track(message.event);
+	return true;
+}

package/src/kernels/js/group-signal-notice.js

@@ -0,0 +1,117 @@
+// senpi#2995: Bun.$, node:child_process exec/execFile and the synchronous spawners leave their children in the
+// agent's process group (Bun.$ has no such option, Bun ignores `detached` for exec/execFile, and a synchronous call
+// keeps the terminal), so a group-wide signal from the same cell stops the agent. Such a command gets a notice; the
+// notice only warns and never fails the cell.
+
+// A command starts a (possibly indented) line, follows `;`, `|`, `&`, `(`, a backtick, `{`, `!`, a shell keyword
+// (`then`, `do`, `else`) or a runner (`nohup`, `time`, `xargs`, `env`, `exec`, `sudo` with flags), or opens a `-c '...'` script; a
+// `kill` word anywhere else (`git log --grep kill`, `echo kill ...`) is text.
+const COMMAND_POSITION = String.raw`(?:^\s*|[;|&(\x60]\s*|\b(?:then|do|else|nohup|time|xargs|env|exec)\s+|[{!]\s+|\bsudo(?:\s+-\S+)*\s+|\s-[A-Za-z]*c\s+['"]\s*)`;
+
+// A group target is a dash argument after the signal options: a number, `$var`, `${var}` or `$(...)`.
+const GROUP_TARGET = String.raw`-(?:\d+|\$\$|\$\{?\w+\}?|\$\()`;
+const SIGNAL_OPTION = String.raw`(?:-s\s+\w+|-n\s+\d+|-[A-Za-z]+\d*|-\d+)`;
+// The first dash argument is a signal, so a group is one after `--`, after a signal option, or after a plain pid:
+// `kill -- -<pgid>`, `kill -SIG -<pgid>`, `kill -TERM 1234 -5678`, `kill -- -$$`.
+const PID = String.raw`[^\s\-;|&][^\s;|&]*`;
+const KILL_GROUP = new RegExp(
+	String.raw`${COMMAND_POSITION}kill\b(?:` +
+		String.raw`\s+--\s+${GROUP_TARGET}` +
+		String.raw`|(?:\s+${SIGNAL_OPTION})+(?:\s+${PID})*\s+(?:--\s+)?${GROUP_TARGET}` +
+		String.raw`|(?:\s+${SIGNAL_OPTION})*(?:\s+${PID})+\s+${GROUP_TARGET})`,
+	"mu",
+);
+const PKILL_GROUP = new RegExp(String.raw`${COMMAND_POSITION}pkill\b[^\n;|&]*\s(?:-g\d*|--pgroup)\b`, "mu");
+// `killall` in command position (also after `sudo` or as a `-c` script) signals every process with that name, which
+// can include the agent's own (bun, node, senpi). Inside an `echo` string it is only text.
+const KILLALL = new RegExp(String.raw`${COMMAND_POSITION}killall\s`, "mu");
+
+export const GROUP_SIGNAL_NOTICE_TAG = "[senpi:group-signal]";
+
+export function signalsProcessGroup(commandText) {
+	return KILL_GROUP.test(commandText) || PKILL_GROUP.test(commandText) || KILLALL.test(commandText);
+}
+
+export function groupSignalNotice(api, readGroup = agentProcessGroup) {
+	const pgid = readGroup();
+	const group = pgid === undefined ? "the agent's process group" : `the agent's process group (${pgid})`;
+	return (
+		`${GROUP_SIGNAL_NOTICE_TAG} This command signals a process group. Children of ${api} share ${group}, so ` +
+		"signalling that group can stop this session. Start background jobs with Bun.spawn or child_process.spawn, " +
+		"which give them their own group, or signal them by pid.\n"
+	);
+}
+
+let cachedGroup;
+
+// A bounded `ps` lookup, kept once it succeeds; a missing `ps` or a failed run only drops the number from this notice.
+export function agentProcessGroup(spawnSync = globalThis.Bun?.spawnSync) {
+	if (cachedGroup !== undefined) return cachedGroup;
+	let text = "";
+	try {
+		const result = spawnSync?.(["ps", "-o", "pgid=", "-p", String(process.pid)], { timeout: 2_000 });
+		text = result?.success ? String(result.stdout).trim() : "";
+	} catch {
+		text = "";
+	}
+	if (!/^\d+$/u.test(text)) return undefined;
+	cachedGroup = text;
+	return cachedGroup;
+}
+
+export function shellCommandText(strings, expressions) {
+	if (!Array.isArray(strings)) return String(strings ?? "");
+	return strings.reduce((text, part, index) => text + part + (index < expressions.length ? String(expressions[index]) : ""), "");
+}
+
+const { promisify } = process.getBuiltinModule("node:util");
+const SCANNED_SPAWNERS = ["exec", "execFile", "execSync", "execFileSync", "spawnSync"];
+
+function commandTextOf(name, args) {
+	if (name === "exec" || name === "execSync") return String(args[0]);
+	return [args[0], ...(Array.isArray(args[1]) ? args[1] : [])].join(" ");
+}
+
+export function noticeChildProcessGroupSignals(emitText, isActive) {
+	const childProcess = process.getBuiltinModule("node:child_process");
+	const originals = new Map();
+	for (const name of SCANNED_SPAWNERS) {
+		const original = childProcess[name];
+		if (typeof original !== "function") continue;
+		originals.set(name, original);
+		const scan = (args) => {
+			try {
+				if (isActive() && signalsProcessGroup(commandTextOf(name, args))) {
+					emitText("stderr", groupSignalNotice(`child_process.${name}`));
+				}
+			} catch {
+				// The notice is advisory; the call itself always runs.
+			}
+		};
+		const scanned = function scannedSpawner(...args) {
+			scan(args);
+			return original.apply(this, args);
+		};
+		// Every own property, symbols included: `util.promisify.custom` is what makes promisify(exec) resolve to
+		// { stdout, stderr }. That custom function calls the original directly, so it is scanned too.
+		for (const key of Reflect.ownKeys(original)) {
+			if (key === "length" || key === "name" || key === "prototype" || key === promisify.custom) continue;
+			const descriptor = Object.getOwnPropertyDescriptor(original, key);
+			if (descriptor) Object.defineProperty(scanned, key, descriptor);
+		}
+		const customPromisify = original[promisify.custom];
+		if (typeof customPromisify === "function") {
+			Object.defineProperty(scanned, promisify.custom, {
+				configurable: true,
+				value: function scannedPromisified(...args) {
+					scan(args);
+					return customPromisify.apply(this, args);
+				},
+			});
+		}
+		childProcess[name] = scanned;
+	}
+	return () => {
+		for (const [name, original] of originals) childProcess[name] = original;
+	};
+}

package/src/kernels/js/inline-worker.ts

@@ -19,6 +19,8 @@ export function resolveInlineWorkerEntryUrl(options: JavaScriptInlineWorkerEntry
 
 export interface WorkerLike {
 	readonly mode: JavaScriptKernelMode;
+	/** The child pid when `mode` is `"process"`; the slot reports it for orphan accounting after a crash. */
+	readonly pid?: number;
 	postMessage(message: HostToKernelMessage, transfer?: readonly MessagePort[]): void;
 	onMessage(handler: (message: KernelToHostMessage) => void): () => void;
 	onError(handler: (error: Error) => void): () => void;

package/src/kernels/js/kernel-contract.ts

@@ -7,7 +7,7 @@ import type { JavaScriptInterruptBounds } from "./interrupt-bounds.ts";
 export type ResultMessage = Extract<KernelToHostMessage, { type: "result" }>;
 export type ToolCallMessage = Extract<KernelToHostMessage, { type: "tool-call" }>;
 
-export type JavaScriptKernelMode = "worker" | "inline";
+export type JavaScriptKernelMode = "worker" | "inline" | "process";
 
 /** Snapshot or live provider consulted when the worker registry checks collisions. */
 export type KernelToolNameSource = readonly string[] | (() => readonly string[]);
@@ -30,8 +30,23 @@ export interface JavaScriptKernelOptions {
 	readonly workerEntryUrl?: URL;
 	/** Per-session PI_* values applied to the worker environment before the first cell runs. */
 	readonly sessionEnv?: SessionEnvironment;
+	/** Opt-in child-process kernel; absent keeps the worker-thread kernel. */
+	readonly isolation?: "process";
+	/** Resolution root for the process-mode runtime (bun, then node); `""` names a machine with none on PATH. */
+	readonly processCommandPath?: string;
+	/** The host's executable, which runs the child when it is bun or node; defaults to `process.execPath`. */
+	readonly processExecPath?: string;
+	/** How long a process-mode child gets to report ready; defaults to `PROCESS_STARTUP_DEADLINE_MS`. */
+	readonly processStartupDeadlineMs?: number;
+	/** Process-mode memory policy: the host reads the child's footprint instead of the in-heap worker reading. */
+	readonly processMemory?: {
+		readonly thresholds: KernelMemoryThresholds;
+		readonly readFootprint?: (pid: number) => { readonly bytes: number } | undefined;
+	};
 	/** Host tool names denied as JS kernel-tool identifiers (init protocol). */
 	readonly hostToolNames?: KernelToolNameSource;
+	/** `kernelTools.enabled`; false makes `tool(fn)` refuse with `tools_unavailable`. Unset keeps them on. */
+	readonly kernelToolsEnabled?: boolean;
 	/** Tool names registered in another kernel language, denied as JS kernel-tool identifiers. */
 	readonly foreignLanguageNames?: KernelToolNameSource;
 	/** Post-cell collection, notice, and ceiling thresholds; absent leaves the worker's memory unmanaged. */

package/src/kernels/js/kernel-memory-bridge.ts

@@ -6,7 +6,7 @@ import type { ResultMessage } from "./kernel-contract.ts";
 
 export interface JavaScriptMemoryReading {
 	readonly liveBytes: number;
-	readonly measure: "heap";
+	readonly measure: "heap" | "footprint";
 }
 
 /** A query waits at most this long: the worker answers between cells, never inside one. */