@code-yeongyu/senpi-codemode 2026.10.3 → 2026.10.4

package/CHANGELOG.md

@@ -12,6 +12,23 @@
 
 ### Removed
 
+## [2026.10.4] - 2026-10-03
+
+### Breaking Changes
+
+### Added
+
+- Every live eval kernel in a process is listed in a process-wide registry with its session, language, measure, and last-known memory reading; a JavaScript kernel keeps the heap reading from each result and idle collection and answers an on-demand heap query between cells without running one, while Python, Ruby, and Julia kernels report their interpreter's footprint on demand. Thresholds, notices, and the result frame are unchanged ([#2561](https://github.com/code-yeongyu/senpi/issues/2561)).
+
+- An eval regression gate records the full prompt and schema surfaces, helper witnesses across five required runtime legs, codemode-scoped eager imports, measured teardown resources (including global, named-import, promise and AbortSignal timers, named by creation site) and legacy contract results against a frozen baseline. CI provisions every interpreter and publishes the report; unrelated host imports and slow child startup cannot cause a regression failure. ([#2452](https://github.com/code-yeongyu/senpi/issues/2452))
+
+- Added an interleaved eval timing benchmark that judges each runtime, workload and metric on adjacent base/head pairs against its own A/A-calibrated threshold (capped at 5%, or one shared band with `--band-scope global`), with process CPU accounting across interpreter crashes, a per-row minimum detectable effect, and explicit inconclusive results for incomplete, host-contaminated or noise-limited comparisons. ([#2452](https://github.com/code-yeongyu/senpi/issues/2452))
+### Changed
+
+### Fixed
+
+### Removed
+
 ## [2026.10.3] - 2026-10-03
 
 ### Breaking Changes

package/README.md

@@ -425,6 +425,12 @@ bun run --cwd packages/senpi-codemode gate --target <base-checkout> \
   --baseline test/gate/baseline.json --write-baseline
 ```
 
+Record with the canonical runtimes, so the baseline's runtime observations do not
+flip between recordings: Bun 1.4.2, Python 3.14, Julia 1.12 and Ruby 4.x from
+Homebrew (put `/opt/homebrew/opt/ruby/bin` first on `PATH`; macOS's system Ruby
+2.6 records a different runtime). Check `ruby --version` and `python3 --version`
+before `--write-baseline`.
+
 The report is gitignored `gate-report.json` by default (`--report <path>` overrides it).
 `test/gate/allowlist.json` contains reviewed additive changes keyed by plan node;
 it cannot authorize removal or modification of a legacy entry. The test-only

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-codemode",
-	"version": "2026.10.3",
+	"version": "2026.10.4",
 	"description": "Source-only senpi extension package for codemode evaluation tools",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -17,6 +17,7 @@
 	],
 	"scripts": {
 		"gate": "bun scripts/gate-eval.ts",
+		"bench": "bun scripts/bench-eval.ts",
 		"test": "vitest run test/",
 		"clean": "node -e \"\"",
 		"build": "node -e \"\""
@@ -31,14 +32,14 @@
 	},
 	"dependencies": {
 		"@babel/parser": "8.0.4",
-		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.3",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.4",
 		"typebox": "1.3.34"
 	},
 	"peerDependencies": {
-		"@code-yeongyu/senpi": "2026.10.3"
+		"@code-yeongyu/senpi": "2026.10.4"
 	},
 	"devDependencies": {
-		"@code-yeongyu/senpi": "2026.10.3"
+		"@code-yeongyu/senpi": "2026.10.4"
 	},
 	"keywords": [
 		"senpi",

package/src/bridge/memory-protocol.ts

@@ -34,6 +34,20 @@ export const kernelMemoryReportSchema = Type.Object({
 	notice: Type.Optional(Type.String()),
 });
 
+/** On-demand heap reading between cells (JS kernels): no cell runs and no collection is forced. */
+export const kernelMemoryQueryHostToKernelSchemas = [
+	Type.Object({ type: Type.Literal("memory-query"), requestId: Type.String({ minLength: 1 }) }),
+] as const;
+
+export const kernelMemoryQueryKernelToHostSchemas = [
+	Type.Object({
+		type: Type.Literal("memory-query-result"),
+		requestId: Type.String({ minLength: 1 }),
+		liveBytes: Type.Integer({ minimum: 0 }),
+		measure: Type.Literal("heap"),
+	}),
+] as const;
+
 export type KernelMemoryThresholds = Static<typeof kernelMemoryThresholdsSchema>;
 export type KernelMemoryReport = Static<typeof kernelMemoryReportSchema>;
 export type KernelMemoryGlobal = Static<typeof kernelMemoryGlobalSchema>;

package/src/bridge/protocol.ts

@@ -2,7 +2,12 @@ import { createHash, randomBytes, randomUUID, timingSafeEqual } from "node:crypt
 import { type Static, Type } from "typebox";
 import { Value } from "typebox/value";
 import { kernelToolHostToKernelSchemas, kernelToolKernelToHostSchemas } from "./kernel-tools-protocol.ts";
-import { kernelMemoryReportSchema, kernelMemoryThresholdsSchema } from "./memory-protocol.ts";
+import {
+	kernelMemoryQueryHostToKernelSchemas,
+	kernelMemoryQueryKernelToHostSchemas,
+	kernelMemoryReportSchema,
+	kernelMemoryThresholdsSchema,
+} from "./memory-protocol.ts";
 
 export const BRIDGE_FRAME_MAX_BYTES = 10 * 1024 * 1024;
 
@@ -82,6 +87,7 @@ const hostToKernelMessageSchema = Type.Union([
 		error: bridgeErrorSchema,
 	}),
 	...kernelToolHostToKernelSchemas,
+	...kernelMemoryQueryHostToKernelSchemas,
 ]);
 
 const kernelToHostMessageSchema = Type.Union([
@@ -125,6 +131,7 @@ const kernelToHostMessageSchema = Type.Union([
 	Type.Object({ type: Type.Literal("closed") }),
 	Type.Object({ type: Type.Literal("webview-connect"), requestId: Type.String({ minLength: 1 }) }),
 	...kernelToolKernelToHostSchemas,
+	...kernelMemoryQueryKernelToHostSchemas,
 ]);
 
 const bridgeMessageSchema = Type.Union([hostToKernelMessageSchema, kernelToHostMessageSchema]);

package/src/extension/kernel-registration.ts

@@ -0,0 +1,96 @@
+import { readProcessFootprint } from "@code-yeongyu/senpi";
+import type { KernelMemoryThresholds } from "../bridge/memory-protocol.ts";
+import type { BridgeConnectionConfig, KernelToHostMessage } from "../bridge/protocol.ts";
+import { JuliaKernel } from "../kernels/jl/kernel.ts";
+import type { JavaScriptKernel } from "../kernels/js/context-manager.ts";
+import { PythonKernel } from "../kernels/py/kernel.ts";
+import { defaultSpawn } from "../kernels/py/process.ts";
+import { RubyKernel } from "../kernels/rb/kernel.ts";
+import type { SessionEnvironment } from "../kernels/session-env.ts";
+import { spawnSubprocess } from "../kernels/shared/subprocess-process.ts";
+import type { EvalKernel, EvalLanguage } from "../tool/types.ts";
+import { type KernelMemoryReading, kernelRegistry, type RegisteredKernelSource } from "./kernel-registry.ts";
+
+export interface StartedKernel {
+	readonly kernel: EvalKernel;
+	readonly memory: RegisteredKernelSource;
+}
+
+export interface SubprocessKernelStart {
+	readonly language: Exclude<EvalLanguage, "js">;
+	readonly interpreterPath: string;
+	readonly memory: KernelMemoryThresholds;
+	readonly shared: {
+		readonly sessionId: string;
+		readonly cwd: string;
+		readonly sessionEnv?: SessionEnvironment;
+		readonly connection: BridgeConnectionConfig;
+		readonly onMessage: (message: KernelToHostMessage) => void;
+	};
+}
+
+export function registerKernel(sessionId: string, language: EvalLanguage, memory: RegisteredKernelSource): string {
+	const id = crypto.randomUUID();
+	kernelRegistry.register({ id, sessionId, language, source: memory });
+	return id;
+}
+
+export function javaScriptKernelMemory(kernel: JavaScriptKernel): RegisteredKernelSource {
+	return {
+		measure: "heap",
+		lastLiveBytes: () => kernel.lastLiveBytes,
+		busy: () => kernel.queueSnapshot().activeCellId !== null,
+		queryMemory: () => kernel.queryMemory(),
+	};
+}
+
+/**
+ * Starts a py/rb/jl kernel through a spawn that remembers its interpreter's pid, so the registry can read
+ * that process's footprint on demand; a restarted interpreter replaces the pid.
+ */
+export async function startSubprocessKernel(start: SubprocessKernelStart): Promise<StartedKernel> {
+	let pid: number | undefined;
+	const { shared, memory } = start;
+	let kernel: EvalKernel;
+	if (start.language === "py") {
+		kernel = await PythonKernel.start({
+			...shared,
+			interpreterPath: start.interpreterPath,
+			memory,
+			spawnProcess: (options) => {
+				const child = defaultSpawn(options);
+				pid = child.pid;
+				return child;
+			},
+		});
+	} else {
+		// rb/jl runners report no memory: the host reads the interpreter footprint for the ceiling only.
+		const options = {
+			...shared,
+			command: start.interpreterPath,
+			memory: { thresholds: memory, readFootprint: readProcessFootprint },
+			spawn: (command: string, args: readonly string[], spawnOptions: { cwd?: string; env?: NodeJS.ProcessEnv }) => {
+				const child = spawnSubprocess(undefined, { command, args, ...spawnOptions });
+				pid = child.pid;
+				return child;
+			},
+		};
+		kernel = start.language === "rb" ? RubyKernel.start(options) : JuliaKernel.start(options);
+	}
+	return { kernel, memory: footprintMemory(kernel, () => pid) };
+}
+
+function footprintMemory(kernel: EvalKernel, pid: () => number | undefined): RegisteredKernelSource {
+	const read = (): KernelMemoryReading | undefined => {
+		const current = pid();
+		const footprint = current === undefined ? undefined : readProcessFootprint(current);
+		return footprint === undefined ? undefined : { liveBytes: Math.round(footprint.bytes), measure: "footprint" };
+	};
+	return {
+		measure: "footprint",
+		lastLiveBytes: () => read()?.liveBytes,
+		busy: () => kernel.queueSnapshot().activeCellId !== null,
+		queryMemory: async () => read(),
+		pid,
+	};
+}

package/src/extension/kernel-registry.ts

@@ -0,0 +1,105 @@
+import type { EvalLanguage } from "../tool/types.ts";
+
+/** `heap`: a JS worker's own heap estimate; `footprint`: the interpreter process's memory footprint. */
+export type KernelMeasure = "heap" | "footprint";
+
+export interface KernelMemoryReading {
+	readonly liveBytes: number;
+	readonly measure: KernelMeasure;
+}
+
+/**
+ * What the registry reads from a live kernel. It is backed by the kernel object, not its worker or
+ * process, so a kernel that restarts its worker (ceiling, crash, reset) keeps its registry entry.
+ */
+export interface RegisteredKernelSource {
+	readonly measure: KernelMeasure;
+	/** The last reading the host holds, without asking the kernel; `undefined` before the first one. */
+	lastLiveBytes(): number | undefined;
+	/** A cell is running, so the last reading may predate what the kernel holds now. */
+	busy(): boolean;
+	/** A fresh reading taken without running a cell; `undefined` when no worker or process is live. */
+	queryMemory(): Promise<KernelMemoryReading | undefined>;
+	pid?(): number | undefined;
+}
+
+export interface KernelRegistration {
+	readonly id: string;
+	readonly sessionId: string;
+	readonly language: EvalLanguage;
+	readonly source: RegisteredKernelSource;
+}
+
+export interface KernelListing {
+	readonly id: string;
+	readonly sessionId: string;
+	readonly language: EvalLanguage;
+	readonly measure: KernelMeasure;
+	readonly lastLiveBytes?: number;
+	readonly busy: boolean;
+	readonly pid?: number;
+}
+
+export interface KernelRegistry {
+	register(kernel: KernelRegistration): void;
+	unregister(id: string): boolean;
+	list(): KernelListing[];
+	lastLiveBytes(id: string): number | undefined;
+	query(id: string): Promise<KernelMemoryReading | undefined>;
+}
+
+// One registry per process, whichever copy of this module asks: the extension loader can evaluate the
+// codemode module graph more than once in a process, and the host's memory report reads the same key.
+const REGISTRY_KEY = Symbol.for("senpi.codemode.kernel-registry");
+
+function createKernelRegistry(): KernelRegistry {
+	const kernels = new Map<string, KernelRegistration>();
+	return {
+		register(kernel) {
+			kernels.set(kernel.id, kernel);
+		},
+		unregister(id) {
+			return kernels.delete(id);
+		},
+		list() {
+			return [...kernels.values()].map(listing);
+		},
+		lastLiveBytes(id) {
+			return kernels.get(id)?.source.lastLiveBytes();
+		},
+		async query(id) {
+			return await kernels.get(id)?.source.queryMemory();
+		},
+	};
+}
+
+function listing({ id, sessionId, language, source }: KernelRegistration): KernelListing {
+	const lastLiveBytes = source.lastLiveBytes();
+	const pid = source.pid?.();
+	return {
+		id,
+		sessionId,
+		language,
+		measure: source.measure,
+		busy: source.busy(),
+		...(lastLiveBytes === undefined ? {} : { lastLiveBytes }),
+		...(pid === undefined ? {} : { pid }),
+	};
+}
+
+function isKernelRegistry(value: unknown): value is KernelRegistry {
+	if (typeof value !== "object" || value === null) return false;
+	return ["register", "unregister", "list", "lastLiveBytes", "query"].every(
+		(name) => typeof Reflect.get(value, name) === "function",
+	);
+}
+
+function processKernelRegistry(): KernelRegistry {
+	const existing: unknown = Reflect.get(globalThis, REGISTRY_KEY);
+	if (isKernelRegistry(existing)) return existing;
+	const created = createKernelRegistry();
+	Reflect.set(globalThis, REGISTRY_KEY, created);
+	return created;
+}
+
+export const kernelRegistry: KernelRegistry = processKernelRegistry();

package/src/extension/runtime-factory.ts

@@ -72,6 +72,7 @@ export async function createRuntime(
 	const parallelPoolWidth = Number.isFinite(configuredPoolWidth) ? Math.max(1, Math.trunc(configuredPoolWidth)) : 1;
 	const manager = await create({
 		sessionId,
+		ownerSessionId: ctx.sessionManager.getSessionId(),
 		cwd: ctx.cwd,
 		sessionEnv,
 		settings,

package/src/extension/session-manager-contract.ts

@@ -0,0 +1,42 @@
+import type { ExtensionContext } from "@code-yeongyu/senpi";
+import type { EvalSchemaToolInfo } from "../bridges/schema-bridge.ts";
+import type { CompletionRequest, CompletionResult } from "../completion/handler.ts";
+import type { CodemodeSettings } from "../config/settings.ts";
+import type { InterpreterAvailability } from "../interpreters/detect.ts";
+import type { SessionEnvironment } from "../kernels/session-env.ts";
+import type { EvalKernelManager, ExecuteTool } from "../tool/types.ts";
+
+export interface CodemodeSessionManager extends EvalKernelManager {
+	dispose(): Promise<void>;
+	complete(request: CompletionRequest, ctx: ExtensionContext): Promise<CompletionResult>;
+	setContext?(ctx: ExtensionContext): void;
+	bridgeEndpoint?(): BridgeEndpoint;
+}
+
+export interface BridgeEndpoint {
+	readonly port: number;
+	readonly token: string;
+}
+
+export interface EvalExecutionTracker {
+	assertEvalExecutionAllowed(): void;
+	trackEvalExecution<Result>(execution: Promise<Result>, controller: AbortController): Promise<Result>;
+}
+
+export interface CreateCodemodeSessionManagerOptions {
+	readonly sessionId: string;
+	/** The agent session that owns these kernels, as the process kernel registry lists them; defaults to `sessionId`. */
+	readonly ownerSessionId?: string;
+	readonly cwd: string;
+	readonly settings: CodemodeSettings;
+	readonly availability: InterpreterAvailability;
+	/** Session-scoped roots exposed to kernel helpers such as local://. */
+	readonly localRoots?: Readonly<Record<string, string>>;
+	/** Session-adjacent directory used for persisted eval artifacts. */
+	readonly artifactsDir?: string;
+	/** Per-session PI_* values exposed to every kernel and the children it spawns. */
+	readonly sessionEnv?: SessionEnvironment;
+	readonly executeTool: ExecuteTool;
+	readonly listTools?: () => readonly EvalSchemaToolInfo[];
+	readonly complete: (request: CompletionRequest, ctx: ExtensionContext) => Promise<CompletionResult>;
+}

package/src/extension/session-manager.ts

@@ -1,55 +1,35 @@
 import { join } from "node:path";
-import { type ExtensionContext, readProcessFootprint } from "@code-yeongyu/senpi";
+import type { ExtensionContext } from "@code-yeongyu/senpi";
 import { type BridgeServerHandle, startBridgeServer } from "../bridge/http-server.ts";
 import type { KernelToHostMessage } from "../bridge/protocol.ts";
 import { isReservedToolName, runReservedTool } from "../bridges/reserved-dispatch.ts";
-import type { EvalSchemaToolInfo } from "../bridges/schema-bridge.ts";
 import type { CompletionRequest, CompletionResult } from "../completion/handler.ts";
 import { resolveKernelMemoryThresholds } from "../config/memory-settings.ts";
-import { type CodemodeSettings, defaultCodemodeSettings } from "../config/settings.ts";
+import { defaultCodemodeSettings } from "../config/settings.ts";
 import { collectOrphanedChildren } from "../host-sdk.ts";
-import type { InterpreterAvailability } from "../interpreters/detect.ts";
-import { JuliaKernel } from "../kernels/jl/kernel.ts";
 import { JavaScriptKernel } from "../kernels/js/context-manager.ts";
-import { PythonKernel } from "../kernels/py/kernel.ts";
-import { RubyKernel } from "../kernels/rb/kernel.ts";
-import type { SessionEnvironment } from "../kernels/session-env.ts";
 import { marshalToolResult } from "../tool/image.ts";
-import type { EvalKernel, EvalKernelManager, EvalLanguage, ExecuteTool } from "../tool/types.ts";
+import type { EvalKernel, EvalLanguage } from "../tool/types.ts";
+import {
+	javaScriptKernelMemory,
+	registerKernel,
+	type StartedKernel,
+	startSubprocessKernel,
+} from "./kernel-registration.ts";
+import { kernelRegistry } from "./kernel-registry.ts";
 import { assertSessionCwdAvailable } from "./session-cwd.ts";
+import type {
+	BridgeEndpoint,
+	CodemodeSessionManager,
+	CreateCodemodeSessionManagerOptions,
+} from "./session-manager-contract.ts";
 
-export interface CodemodeSessionManager extends EvalKernelManager {
-	dispose(): Promise<void>;
-	complete(request: CompletionRequest, ctx: ExtensionContext): Promise<CompletionResult>;
-	setContext?(ctx: ExtensionContext): void;
-	bridgeEndpoint?(): BridgeEndpoint;
-}
-
-export interface BridgeEndpoint {
-	readonly port: number;
-	readonly token: string;
-}
-
-export interface EvalExecutionTracker {
-	assertEvalExecutionAllowed(): void;
-	trackEvalExecution<Result>(execution: Promise<Result>, controller: AbortController): Promise<Result>;
-}
-
-export interface CreateCodemodeSessionManagerOptions {
-	readonly sessionId: string;
-	readonly cwd: string;
-	readonly settings: CodemodeSettings;
-	readonly availability: InterpreterAvailability;
-	/** Session-scoped roots exposed to kernel helpers such as local://. */
-	readonly localRoots?: Readonly<Record<string, string>>;
-	/** Session-adjacent directory used for persisted eval artifacts. */
-	readonly artifactsDir?: string;
-	/** Per-session PI_* values exposed to every kernel and the children it spawns. */
-	readonly sessionEnv?: SessionEnvironment;
-	readonly executeTool: ExecuteTool;
-	readonly listTools?: () => readonly EvalSchemaToolInfo[];
-	readonly complete: (request: CompletionRequest, ctx: ExtensionContext) => Promise<CompletionResult>;
-}
+export type {
+	BridgeEndpoint,
+	CodemodeSessionManager,
+	CreateCodemodeSessionManagerOptions,
+	EvalExecutionTracker,
+} from "./session-manager-contract.ts";
 
 export async function createCodemodeSessionManager(
 	options: CreateCodemodeSessionManagerOptions,
@@ -79,6 +59,7 @@ class DefaultCodemodeSessionManager implements CodemodeSessionManager {
 	readonly #options: CreateCodemodeSessionManagerOptions;
 	#bridge: BridgeServerHandle | undefined;
 	#kernels = new Map<EvalLanguage, EvalKernel>();
+	readonly #registrations = new Map<EvalLanguage, string>();
 	#kernelCreations = new Map<EvalLanguage, Promise<EvalKernel>>();
 	#onMessageRefs = new Map<EvalLanguage, (message: KernelToHostMessage) => void>();
 	#context: ExtensionContext | undefined;
@@ -187,6 +168,8 @@ class DefaultCodemodeSessionManager implements CodemodeSessionManager {
 		const kernels = [...this.#kernels.values()];
 		const bridge = this.#bridge;
 		this.#kernels.clear();
+		for (const id of this.#registrations.values()) kernelRegistry.unregister(id);
+		this.#registrations.clear();
 		this.#onMessageRefs.clear();
 		this.#bridge = undefined;
 		this.#context = undefined;
@@ -209,12 +192,16 @@ class DefaultCodemodeSessionManager implements CodemodeSessionManager {
 		generation: number,
 	): Promise<EvalKernel> {
 		await assertSessionCwdAvailable(this.#options.cwd);
-		const kernel = await this.#createKernel(language, onMessage);
+		const { kernel, memory } = await this.#createKernel(language, onMessage);
 		if (generation !== this.#generation) {
 			await kernel.close();
 			throw new CodemodeSessionDisposedError();
 		}
 		this.#kernels.set(language, kernel);
+		this.#registrations.set(
+			language,
+			registerKernel(this.#options.ownerSessionId ?? this.#options.sessionId, language, memory),
+		);
 		// The directory can vanish while the interpreter starts; every caller sharing this creation
 		// must see that, not only the next one. The kernel stays stored and dispose still closes it.
 		await assertSessionCwdAvailable(this.#options.cwd);
@@ -223,7 +210,10 @@ class DefaultCodemodeSessionManager implements CodemodeSessionManager {
 		return kernel;
 	}
 
-	async #createKernel(language: EvalLanguage, onMessage: (message: KernelToHostMessage) => void): Promise<EvalKernel> {
+	async #createKernel(
+		language: EvalLanguage,
+		onMessage: (message: KernelToHostMessage) => void,
+	): Promise<StartedKernel> {
 		const bridge = this.#bridge;
 		if (!bridge) throw new Error("codemode bridge server is not running");
 		const configuredPoolWidth = this.#options.settings.parallelPoolWidth;
@@ -235,7 +225,7 @@ class DefaultCodemodeSessionManager implements CodemodeSessionManager {
 			this.#options.localRoots ??
 			(this.#options.artifactsDir ? { local: join(this.#options.artifactsDir, "local") } : undefined);
 		if (language === "js") {
-			return new JavaScriptKernel({
+			const kernel = new JavaScriptKernel({
 				sessionId: this.#options.sessionId,
 				cwd: this.#options.cwd,
 				parallelPoolWidth,
@@ -248,6 +238,7 @@ class DefaultCodemodeSessionManager implements CodemodeSessionManager {
 				...(localRoots ? { localRoots: { ...localRoots } } : {}),
 				...(this.#options.artifactsDir ? { artifactsDir: this.#options.artifactsDir } : {}),
 			});
+			return { kernel, memory: javaScriptKernelMemory(kernel) };
 		}
 		const detected = this.#options.availability[language].detected;
 		if (!detected.ok) throw new Error(`No ${language} interpreter is available`);
@@ -266,11 +257,7 @@ class DefaultCodemodeSessionManager implements CodemodeSessionManager {
 			onMessage,
 		};
 		const memory = resolveKernelMemoryThresholds(this.#options.settings.memory);
-		if (language === "py") return await PythonKernel.start({ ...shared, interpreterPath: detected.path, memory });
-		// rb/jl runners report no memory: the host reads the interpreter footprint for the ceiling only.
-		const hostMeasured = { thresholds: memory, readFootprint: readProcessFootprint };
-		if (language === "rb") return RubyKernel.start({ ...shared, command: detected.path, memory: hostMeasured });
-		return JuliaKernel.start({ ...shared, command: detected.path, memory: hostMeasured });
+		return await startSubprocessKernel({ language, interpreterPath: detected.path, memory, shared });
 	}
 
 	#foreignKernelToolNames(): string[] {

package/src/kernels/js/active-cell-control.ts

@@ -0,0 +1,73 @@
+import type { HostToKernelMessage } from "../../bridge/protocol.ts";
+import {
+	awaitCooperativeSettlement,
+	type JavaScriptInterruptBounds,
+	restartedResult,
+	restartOutcome,
+	type WorkerRetirement,
+} from "./interrupt-bounds.ts";
+import type { JavaScriptRunQueue, PendingJavaScriptRun } from "./run-queue.ts";
+
+export interface CellStopOutcome {
+	readonly retained: boolean;
+	readonly note?: string;
+}
+
+export interface ActiveCellControlHost {
+	readonly runs: JavaScriptRunQueue;
+	readonly bounds: JavaScriptInterruptBounds;
+	post(message: HostToKernelMessage): void;
+	terminate(): Promise<WorkerRetirement>;
+	/** Brings a fresh worker up once the stopped one is retired. */
+	recover(): void;
+	clearToolCalls(): void;
+}
+
+/** The running cell's deadline and the protocol that stops it on a timeout or an interrupt. */
+export class ActiveCellControl {
+	readonly #host: ActiveCellControlHost;
+	#timeout: NodeJS.Timeout | null = null;
+
+	constructor(host: ActiveCellControlHost) {
+		this.#host = host;
+	}
+
+	arm(run: PendingJavaScriptRun): void {
+		const timeoutMs = run.input.timeoutMs;
+		if (timeoutMs) this.#timeout = setTimeout(() => void this.#timedOut(run, timeoutMs), timeoutMs);
+	}
+
+	disarm(): void {
+		if (this.#timeout) clearTimeout(this.#timeout);
+		this.#timeout = null;
+	}
+
+	/**
+	 * Asks the worker to settle the active cell cooperatively (rejecting its bridge calls and killing its
+	 * children); only a cell that stays unsettled past the grace costs the worker VM. Reports whether the
+	 * worker state survived and, when a blocked worker had to be abandoned, the note that explains it.
+	 */
+	async stop(run: PendingJavaScriptRun, reason: string, message: string, durationMs = 0): Promise<CellStopOutcome> {
+		const host = this.#host;
+		try {
+			run.interruptResult = { type: "result", cellId: run.input.cellId, ok: false, error: { message }, durationMs };
+			run.interruptAck ??= Promise.withResolvers<void>();
+			host.post({ type: "interrupt", reason });
+			if ((await awaitCooperativeSettlement(run, host.bounds)) === "settled") {
+				return { retained: run.settledByWorker };
+			}
+			if (!host.runs.releaseActive(run)) return { retained: run.settledByWorker };
+			const retirement = await host.terminate();
+			host.runs.settle(run, restartedResult(run, message));
+			host.recover();
+			return restartOutcome(run, retirement, host.bounds);
+		} finally {
+			host.clearToolCalls();
+		}
+	}
+
+	async #timedOut(run: PendingJavaScriptRun, durationMs: number): Promise<void> {
+		if (this.#host.runs.active !== run || run.settled) return;
+		await this.stop(run, `timed out after ${durationMs}ms`, `JS cell timed out after ${durationMs}ms`, durationMs);
+	}
+}

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

@@ -1,15 +1,8 @@
-import type { EvalStatusEvent, HostToKernelMessage, KernelToHostMessage } from "../../bridge/protocol.ts";
-import { CHILD_LIFECYCLE_OP, INTERRUPT_ACK_OP, MEMORY_COLLECTED_OP } from "../../bridge/reserved.ts";
+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 { KernelMemoryPolicy } from "../shared/kernel-memory.ts";
-import {
-	awaitCooperativeSettlement,
-	DEFAULT_INTERRUPT_BOUNDS,
-	type JavaScriptInterruptBounds,
-	restartedResult,
-	restartOutcome,
-	type WorkerRetirement,
-} from "./interrupt-bounds.ts";
+import { ActiveCellControl } from "./active-cell-control.ts";
+import { DEFAULT_INTERRUPT_BOUNDS, type WorkerRetirement } from "./interrupt-bounds.ts";
 import {
 	assertJavaScriptKernelOpen,
 	type JavaScriptKernelMode,
@@ -19,6 +12,7 @@ import {
 	resolveKernelToolNameSource,
 	type ToolCallMessage,
 } from "./kernel-contract.ts";
+import { type JavaScriptMemoryReading, KernelMemoryBridge } from "./kernel-memory-bridge.ts";
 import { kernelToolError } from "./kernel-tools-errors.ts";
 import { KernelToolHostPump } from "./kernel-tools-host.ts";
 import type {
@@ -27,47 +21,53 @@ import type {
 	KernelToolsInvokeRequest,
 } from "./kernel-tools-types.ts";
 import { type JavaScriptKernelOptions, LocalModuleLoader } from "./local-module-loader.ts";
-import { terminateProcessTrees } from "./process-tree-host.ts";
-import { JavaScriptRunQueue, type PendingJavaScriptRun } from "./run-queue.ts";
-import { bridgeError, WorkerStartupCancelledError } from "./worker-host.ts";
+import { JavaScriptRunQueue } 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";
 
 export { JavaScriptKernelClosedError, type JavaScriptKernelMode, type JavaScriptRunInput } from "./kernel-contract.ts";
+export type { JavaScriptMemoryReading } from "./kernel-memory-bridge.ts";
 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;
 	readonly #slot: WorkerSlot;
 	#lifecycle: LifecycleState = "open";
 	#activation: Promise<void> | null = null;
-	#recovery: Promise<void> | null = null;
 	#closePromise: Promise<void> | null = null;
 	readonly #runs = new JavaScriptRunQueue();
 	readonly #kernelTools = new KernelToolHostPump(
 		(message) => this.#slot.postMessage(message),
 		() => this.#lifecycle === "open" && this.#slot.present,
 	);
-	#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>();
-	readonly #memory: KernelMemoryPolicy | null;
-	readonly #interruptBounds: JavaScriptInterruptBounds;
+	readonly #toolCalls = new ToolCallQueue();
+	readonly #children: WorkerChildren;
+	readonly #memory: KernelMemoryBridge;
+	readonly #activeCell: ActiveCellControl;
+	readonly #recovery = new WorkerRecovery({
+		runs: this.#runs,
+		isOpen: () => this.#lifecycle === "open",
+		ensureReady: () => this.#ensureReady(),
+		startNext: () => this.#startNext(),
+	});
 
 	constructor(options: JavaScriptKernelOptions) {
 		this.#options = options;
-		this.#interruptBounds = options.interruptBounds ?? DEFAULT_INTERRUPT_BOUNDS;
-		this.#memory = options.memory === undefined ? null : new KernelMemoryPolicy("js", options.memory);
+		this.#activeCell = new ActiveCellControl({
+			runs: this.#runs,
+			bounds: options.interruptBounds ?? DEFAULT_INTERRUPT_BOUNDS,
+			post: (message) => this.#slot.postMessage(message),
+			terminate: () => this.#terminate(),
+			recover: () => void this.#recovery.recover(() => Promise.resolve()),
+			clearToolCalls: () => this.#toolCalls.clear(),
+		});
+		this.#memory = new KernelMemoryBridge(options.memory, options.onMemoryCollected);
+		this.#children = new WorkerChildren(options.collectOrphanedChildren);
 		this.#moduleLoader = new LocalModuleLoader(options);
 		this.#slot = new WorkerSlot(options, {
 			isOpen: () => this.#lifecycle === "open",
@@ -80,6 +80,17 @@ 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. */
+	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));
+	}
+
 	get kernelToolEvents(): EventTarget {
 		return this.#kernelTools.events;
 	}
@@ -125,15 +136,15 @@ export class JavaScriptKernel {
 			await this.#restartAfterStop();
 			return { stateRetained: Promise.resolve(false) };
 		}
-		this.#clearTimeout();
-		const stop = await this.#stopActive(active, reason, `JS cell interrupted: ${reason}`);
+		this.#activeCell.disarm();
+		const stop = await this.#activeCell.stop(active, reason, `JS cell interrupted: ${reason}`);
 		return { stateRetained: Promise.resolve(stop.retained), ...(stop.note === undefined ? {} : { note: stop.note }) };
 	}
 
 	async reset(): Promise<void> {
 		assertJavaScriptKernelOpen(this.#lifecycle, "reset");
 		await this.#terminate();
-		this.#clearToolCalls();
+		this.#toolCalls.clear();
 		assertJavaScriptKernelOpen(this.#lifecycle, "reset");
 		await this.#ensureReady();
 		this.#startNext();
@@ -144,9 +155,7 @@ export class JavaScriptKernel {
 	}
 
 	async nextToolCall(): Promise<ToolCallMessage> {
-		const pending = this.#pendingToolCalls.shift();
-		if (pending) return pending;
-		return await new Promise((resolve) => this.#toolWaiters.push(resolve));
+		return await this.#toolCalls.next();
 	}
 
 	async close(): Promise<void> {
@@ -155,8 +164,8 @@ export class JavaScriptKernel {
 		this.#lifecycle = "closing";
 		this.#runs.settleAll("JS kernel closed");
 		this.#kernelTools.rejectAll(kernelToolError("kernel_tool_stale", "JS kernel closed"));
-		this.#clearToolCalls();
-		const recovery = this.#recovery;
+		this.#toolCalls.clear();
+		const recovery = this.#recovery.inFlight;
 		const closePromise = (async () => {
 			if (recovery) await recovery;
 			await this.#terminate();
@@ -169,7 +178,7 @@ export class JavaScriptKernel {
 
 	#activate(): void {
 		if (this.#activation || this.#lifecycle !== "open" || this.#runs.active || !this.#runs.hasWaiting) return;
-		const activation = this.#activateWhenReady();
+		const activation = this.#recovery.bringUp();
 		this.#activation = activation;
 		void activation.then(() => {
 			if (this.#activation === activation) this.#activation = null;
@@ -177,16 +186,6 @@ export class JavaScriptKernel {
 		});
 	}
 
-	async #activateWhenReady(): Promise<void> {
-		try {
-			await this.#ensureReady();
-			if (this.#lifecycle === "open") this.#startNext();
-		} catch (error) {
-			if (error instanceof WorkerStartupCancelledError) return;
-			this.#runs.rejectWaiting(error instanceof Error ? error : new Error(String(error)));
-		}
-	}
-
 	async #ensureReady(): Promise<void> {
 		assertJavaScriptKernelOpen(this.#lifecycle, "run");
 		await this.#slot.ensureReady();
@@ -196,9 +195,7 @@ export class JavaScriptKernel {
 		if (this.#lifecycle !== "open" || this.#runs.active || !this.#slot.present) return;
 		const next = this.#runs.startNext(performance.now());
 		if (!next) return;
-		if (next.input.timeoutMs) {
-			this.#timeout = setTimeout(() => void this.#timeoutActive(next), next.input.timeoutMs);
-		}
+		this.#activeCell.arm(next);
 		this.#slot.postMessage({
 			type: "kernel-tools-names",
 			hostToolNames: resolveKernelToolNameSource(this.#options.hostToolNames),
@@ -212,178 +209,62 @@ export class JavaScriptKernel {
 		});
 	}
 
-	async #timeoutActive(run: PendingJavaScriptRun): Promise<void> {
-		if (this.#runs.active !== run || run.settled) return;
-		const durationMs = run.input.timeoutMs ?? 0;
-		await this.#stopActive(
-			run,
-			`timed out after ${durationMs}ms`,
-			`JS cell timed out after ${durationMs}ms`,
-			durationMs,
-		);
-	}
-
-	/**
-	 * Asks the worker to settle the active cell cooperatively (rejecting its bridge calls and killing its
-	 * children); only a cell that stays unsettled past the grace costs the worker VM. Reports whether the
-	 * worker state survived and, when a blocked worker had to be abandoned, the note that explains it.
-	 */
-	async #stopActive(
-		run: PendingJavaScriptRun,
-		reason: string,
-		message: string,
-		durationMs = 0,
-	): Promise<{ readonly retained: boolean; readonly note?: string }> {
-		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, this.#interruptBounds)) === "settled") {
-				return { retained: run.settledByWorker };
-			}
-			if (!this.#runs.releaseActive(run)) return { retained: run.settledByWorker };
-			const retirement = await this.#terminate();
-			this.#runs.settle(run, restartedResult(run, message));
-			void this.#recover(() => Promise.resolve());
-			return restartOutcome(run, retirement, this.#interruptBounds);
-		} finally {
-			this.#clearToolCalls();
-		}
-	}
-
 	async #restartAfterStop(): Promise<void> {
-		await this.#recover(() => this.#terminate());
-	}
-
-	/** One recovery at a time: retire through `retire` (a no-op when the worker is already gone), then bring a fresh worker up. */
-	async #recover(retire: () => Promise<unknown>): Promise<void> {
-		if (this.#recovery) return await this.#recovery;
-		const recovery = this.#performRecovery(retire);
-		this.#recovery = recovery;
-		try {
-			await recovery;
-		} finally {
-			if (this.#recovery === recovery) this.#recovery = null;
-		}
-	}
-
-	async #performRecovery(retire: () => Promise<unknown>): Promise<void> {
-		try {
-			await retire();
-			if (this.#lifecycle !== "open") return;
-			await this.#ensureReady();
-			if (this.#lifecycle === "open") this.#startNext();
-		} catch (error) {
-			if (error instanceof WorkerStartupCancelledError) return;
-			this.#runs.rejectWaiting(error instanceof Error ? error : new Error(String(error)));
-		}
+		await this.#recovery.recover(() => this.#terminate());
 	}
 
 	#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.#trackChildEvent(message.event);
-			return;
-		}
-		if (message.type === "status" && message.event.op === MEMORY_COLLECTED_OP) {
-			const liveBytes = message.event.liveBytes;
-			if (typeof liveBytes !== "number") return;
-			this.#memory?.observeLive(liveBytes);
-			this.#options.onMemoryCollected?.(liveBytes);
+			this.#children.track(message.event);
 			return;
 		}
 		(this.#runs.active?.input.onMessage ?? this.#options.onMessage)?.(message);
 		if (message.type === "tool-call") {
-			const waiter = this.#toolWaiters.shift();
-			if (waiter) waiter(message);
-			else {
-				this.#pendingToolCalls.push(message);
-				if (this.#pendingToolCalls.length > MAX_PENDING_TOOL_CALLS) this.#pendingToolCalls.shift();
-			}
+			this.#toolCalls.push(message);
 			return;
 		}
 		if (message.type !== "result") return;
 		const active = this.#runs.active;
 		if (!active || active.input.cellId !== message.cellId) return;
-		this.#clearTimeout();
+		this.#activeCell.disarm();
 		this.#runs.releaseActive(active);
 		active.settledByWorker = true;
-		this.#runs.settle(active, active.interruptResult ?? this.#withMemoryPolicy(message));
+		this.#runs.settle(active, active.interruptResult ?? this.#memory.settled(message));
 		this.#startNext();
-		this.#recycleOverCeilingWhenIdle();
-	}
-
-	#withMemoryPolicy(message: ResultMessage): ResultMessage {
-		if (this.#memory === null || message.memory === undefined) return message;
-		return { ...message, memory: this.#memory.annotate(message.memory) };
-	}
-
-	/** A kernel over its memory ceiling restarts only once no cell is running or queued on it. */
-	#recycleOverCeilingWhenIdle(): void {
-		if (this.#memory?.recyclePending !== true || this.#runs.active || this.#runs.hasWaiting) return;
-		this.#memory.recycleStarted();
-		void this.#restartAfterStop();
+		// A kernel over its memory ceiling restarts only once no cell is running or queued on it.
+		if (this.#memory.claimRecycle(!this.#runs.active && !this.#runs.hasWaiting)) void this.#restartAfterStop();
 	}
 
 	#handleCrash(error: Error): void {
 		const active = this.#runs.active;
 		if (!active && this.#slot.startingUp) return;
-		this.#clearTimeout();
+		this.#activeCell.disarm();
 		this.#kernelTools.rejectAll(kernelToolError("kernel_tool_stale", error.message));
+		this.#memory.workerLost(error);
 		if (active) {
 			this.#runs.releaseActive(active);
-			this.#runs.settle(active, {
-				type: "result",
-				cellId: active.input.cellId,
-				ok: false,
-				error: bridgeError(error),
-				durationMs: this.#runs.durationMs(active, performance.now()),
-			});
+			this.#runs.settle(
+				active,
+				crashedResult(active.input.cellId, error, this.#runs.durationMs(active, performance.now())),
+			);
 		}
-		this.#clearToolCalls();
+		this.#toolCalls.clear();
 		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.
-	 */
+	/** Retire the worker, then whatever cell children it still owned. */
 	async #terminate(): Promise<WorkerRetirement> {
-		this.#clearTimeout();
+		this.#activeCell.disarm();
 		this.#kernelTools.rejectAll(kernelToolError("kernel_tool_stale", "JavaScript worker reset"));
-		this.#memory?.kernelRetired();
+		this.#memory.workerLost(new Error("JavaScript worker reset"));
 		const retirement = await this.#slot.retire();
-		await this.#retireWorkerChildren();
+		await this.#children.retire();
 		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 });
-		// The worker that owned these children and their exit watchers is gone, so nothing else will wait on them.
-		await this.#options.collectOrphanedChildren?.(pids);
-	}
 }

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

@@ -0,0 +1,110 @@
+import type { KernelMemoryThresholds } from "../../bridge/memory-protocol.ts";
+import type { HostToKernelMessage, KernelToHostMessage } from "../../bridge/protocol.ts";
+import { MEMORY_COLLECTED_OP } from "../../bridge/reserved.ts";
+import { KernelMemoryPolicy } from "../shared/kernel-memory.ts";
+import type { ResultMessage } from "./kernel-contract.ts";
+
+export interface JavaScriptMemoryReading {
+	readonly liveBytes: number;
+	readonly measure: "heap";
+}
+
+/** A query waits at most this long: the worker answers between cells, never inside one. */
+const MEMORY_QUERY_TIMEOUT_MS = 5_000;
+
+type QueryResult = Extract<KernelToHostMessage, { type: "memory-query-result" }>;
+
+/**
+ * The host half of one JS kernel's memory: the post-cell policy (notice, ceiling, recycle), the last
+ * heap reading the worker sent (result frames, idle collections, queries), and the on-demand queries
+ * still waiting for the worker. Losing the worker forgets the reading and rejects every waiting query.
+ */
+export class KernelMemoryBridge {
+	readonly #policy: KernelMemoryPolicy | null;
+	readonly #onCollected: ((liveBytes: number) => void) | undefined;
+	readonly #queries = new Map<
+		string,
+		{ pending: PromiseWithResolvers<JavaScriptMemoryReading>; timer: ReturnType<typeof setTimeout> }
+	>();
+	#lastLiveBytes: number | undefined;
+
+	constructor(thresholds: KernelMemoryThresholds | undefined, onCollected?: (liveBytes: number) => void) {
+		this.#policy = thresholds === undefined ? null : new KernelMemoryPolicy("js", thresholds);
+		this.#onCollected = onCollected;
+	}
+
+	get lastLiveBytes(): number | undefined {
+		return this.#lastLiveBytes;
+	}
+
+	/** Consumes the worker's memory messages (idle collections, query results); false for anything else. */
+	consume(message: KernelToHostMessage): boolean {
+		if (message.type === "memory-query-result") {
+			this.#answered(message);
+			return true;
+		}
+		if (message.type !== "status" || message.event.op !== MEMORY_COLLECTED_OP) return false;
+		const liveBytes = message.event.liveBytes;
+		if (typeof liveBytes !== "number") return true;
+		this.#lastLiveBytes = liveBytes;
+		this.#policy?.observeLive(liveBytes);
+		this.#onCollected?.(liveBytes);
+		return true;
+	}
+
+	settled(message: ResultMessage): ResultMessage {
+		if (message.memory === undefined) return message;
+		this.#lastLiveBytes = message.memory.liveBytes;
+		if (this.#policy === null) return message;
+		return { ...message, memory: this.#policy.annotate(message.memory) };
+	}
+
+	/** True when an over-ceiling kernel must restart now: it is `idle` (nothing running or queued). */
+	claimRecycle(idle: boolean): boolean {
+		if (!idle || this.#policy?.recyclePending !== true) return false;
+		this.#policy.recycleStarted();
+		return true;
+	}
+
+	/**
+	 * A fresh reading from the worker. The worker answers between cells, so the wait is bounded:
+	 * a kernel whose cell never yields (a sync loop) cannot answer until that cell settles, and the
+	 * query rejects after {@link MEMORY_QUERY_TIMEOUT_MS} instead of hanging its caller forever.
+	 */
+	query(post: (message: HostToKernelMessage) => void): Promise<JavaScriptMemoryReading> {
+		const requestId = crypto.randomUUID();
+		const pending = Promise.withResolvers<JavaScriptMemoryReading>();
+		const timer = setTimeout(() => {
+			if (!this.#queries.delete(requestId)) return;
+			pending.reject(
+				new Error(
+					`memory-query timed out after ${MEMORY_QUERY_TIMEOUT_MS}ms (a cell is running; queries answer between cells)`,
+				),
+			);
+		}, MEMORY_QUERY_TIMEOUT_MS);
+		this.#queries.set(requestId, { pending, timer });
+		post({ type: "memory-query", requestId });
+		return pending.promise;
+	}
+
+	/** The worker is gone (reset, crash, stop, recycle): its memory and its unanswered queries went with it. */
+	workerLost(error: Error): void {
+		this.#policy?.kernelRetired();
+		this.#lastLiveBytes = undefined;
+		const waiting = [...this.#queries.values()];
+		this.#queries.clear();
+		for (const { pending, timer } of waiting) {
+			clearTimeout(timer);
+			pending.reject(error);
+		}
+	}
+
+	#answered(result: QueryResult): void {
+		const waiting = this.#queries.get(result.requestId);
+		if (waiting === undefined) return;
+		this.#queries.delete(result.requestId);
+		clearTimeout(waiting.timer);
+		this.#lastLiveBytes = result.liveBytes;
+		waiting.pending.resolve({ liveBytes: result.liveBytes, measure: result.measure });
+	}
+}

package/src/kernels/js/tool-call-queue.ts

@@ -0,0 +1,32 @@
+import type { ToolCallMessage } from "./kernel-contract.ts";
+
+// 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;
+
+/** Tool calls for `nextToolCall()` consumers: handed to a waiting consumer, else queued up to the bound. */
+export class ToolCallQueue {
+	readonly #waiters: Array<(message: ToolCallMessage) => void> = [];
+	readonly #pending: ToolCallMessage[] = [];
+
+	push(message: ToolCallMessage): void {
+		const waiter = this.#waiters.shift();
+		if (waiter) {
+			waiter(message);
+			return;
+		}
+		this.#pending.push(message);
+		if (this.#pending.length > MAX_PENDING_TOOL_CALLS) this.#pending.shift();
+	}
+
+	async next(): Promise<ToolCallMessage> {
+		const pending = this.#pending.shift();
+		if (pending) return pending;
+		return await new Promise((resolve) => this.#waiters.push(resolve));
+	}
+
+	clear(): void {
+		this.#pending.length = 0;
+		this.#waiters.length = 0;
+	}
+}

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

@@ -0,0 +1,35 @@
+import type { EvalStatusEvent } from "../../bridge/protocol.ts";
+import { terminateProcessTrees } from "./process-tree-host.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;
+
+/** Live cell children the worker reported; retired by the host when the worker itself is lost. */
+export class WorkerChildren {
+	readonly #pids = new Set<number>();
+	readonly #collectOrphanedChildren: ((pids: readonly number[]) => Promise<unknown>) | undefined;
+
+	constructor(collectOrphanedChildren?: (pids: readonly number[]) => Promise<unknown>) {
+		this.#collectOrphanedChildren = collectOrphanedChildren;
+	}
+
+	track(event: EvalStatusEvent): void {
+		const pid = event.pid;
+		if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0) return;
+		if (event.state === "spawned") this.#pids.add(pid);
+		else if (event.state === "exited") this.#pids.delete(pid);
+	}
+
+	/**
+	 * A terminated or crashed worker never reaches its own cell-end cleanup, so the host retires the
+	 * children it still owned; a pid `ps` no longer lists as our child was reused and is skipped.
+	 */
+	async retire(): Promise<void> {
+		if (this.#pids.size === 0) return;
+		const pids = [...this.#pids];
+		this.#pids.clear();
+		await terminateProcessTrees(pids, { graceMs: WORKER_LOSS_CHILD_GRACE_MS, ownerPid: process.pid });
+		// The worker that owned these children and their exit watchers is gone, so nothing else will wait on them.
+		await this.#collectOrphanedChildren?.(pids);
+	}
+}

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

@@ -3,6 +3,7 @@ import { kernelToolError } from "./kernel-tools-errors.js";
 import { createKernelToolPump } from "./kernel-tools-pump.js";
 import { hostDeniedError, hostToolRefusal } from "./kernel-tools-scope.js";
 import { installSessionCwd } from "./worker-cwd.js";
+import { createHeapProbe } from "./worker-heap.js";
 import { createWorkerMemory } from "./worker-memory.js";
 import { JsWorkerRuntime } from "./worker-runtime.js";
 import { installKernelWebView } from "./worker-webview.js";
@@ -28,6 +29,7 @@ const SESSION_ENVIRONMENT_KEYS = [
 export function createWorkerCore(transport, options) {
 	let runtime = null;
 	let memory = null;
+	let heapProbe = null;
 	let activeCell = null;
 	const pendingTools = new Map();
 	const pendingWebViewPorts = new Map();
@@ -146,6 +148,11 @@ export function createWorkerCore(transport, options) {
 			emit({ type: "ready" });
 			return;
 		}
+		if (message.type === "memory-query") {
+			heapProbe ??= createHeapProbe();
+			emit({ type: "memory-query-result", requestId: message.requestId, liveBytes: Math.round(heapProbe.estimate()), measure: "heap" });
+			return;
+		}
 		if (message.type === "run") {
 			void runCell(message);
 			return;

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

@@ -90,6 +90,15 @@ export function bridgeError(error: Error): {
 	return { message: error.message, name: error.name, stack: error.stack };
 }
 
+/** The result a cell settles with when its worker crashed under it. */
+export function crashedResult(
+	cellId: string,
+	error: Error,
+	durationMs: number,
+): Extract<KernelToHostMessage, { type: "result" }> {
+	return { type: "result", cellId, ok: false, error: bridgeError(error), durationMs };
+}
+
 function wrapNodeWorker(worker: Worker, mode: JavaScriptKernelMode): WorkerLike {
 	return {
 		mode,

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

@@ -0,0 +1,60 @@
+import type { JavaScriptRunQueue } from "./run-queue.ts";
+import { WorkerStartupCancelledError } from "./worker-host.ts";
+
+export interface WorkerRecoveryHost {
+	readonly runs: JavaScriptRunQueue;
+	isOpen(): boolean;
+	ensureReady(): Promise<void>;
+	startNext(): void;
+}
+
+/** Brings a worker up for waiting cells, and replaces a lost or retired worker one recovery at a time. */
+export class WorkerRecovery {
+	readonly #host: WorkerRecoveryHost;
+	#recovery: Promise<void> | null = null;
+
+	constructor(host: WorkerRecoveryHost) {
+		this.#host = host;
+	}
+
+	get inFlight(): Promise<void> | null {
+		return this.#recovery;
+	}
+
+	/** Starts a worker when none is live and hands it the next waiting cell; a failed start fails the waiting cells. */
+	async bringUp(): Promise<void> {
+		try {
+			await this.#host.ensureReady();
+			if (this.#host.isOpen()) this.#host.startNext();
+		} catch (error) {
+			this.#failWaiting(error);
+		}
+	}
+
+	/** Retires through `retire` (a no-op when the worker is already gone), then brings a fresh worker up. */
+	async recover(retire: () => Promise<unknown>): Promise<void> {
+		if (this.#recovery) return await this.#recovery;
+		const recovery = this.#perform(retire);
+		this.#recovery = recovery;
+		try {
+			await recovery;
+		} finally {
+			if (this.#recovery === recovery) this.#recovery = null;
+		}
+	}
+
+	async #perform(retire: () => Promise<unknown>): Promise<void> {
+		try {
+			await retire();
+		} catch (error) {
+			this.#failWaiting(error);
+			return;
+		}
+		if (this.#host.isOpen()) await this.bringUp();
+	}
+
+	#failWaiting(error: unknown): void {
+		if (error instanceof WorkerStartupCancelledError) return;
+		this.#host.runs.rejectWaiting(error instanceof Error ? error : new Error(String(error)));
+	}
+}

package/src/kernels/shared/subprocess-queue.ts

@@ -114,6 +114,7 @@ export class SubprocessRunQueue {
 				onMessage?.(message);
 				return false;
 			case "webview-connect":
+			case "memory-query-result":
 				return false;
 			default: {
 				const exhaustive: never = message;