@code-yeongyu/senpi-codemode 2026.10.9 → 2026.10.10-3

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

@@ -2,8 +2,10 @@ import { dirname, join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { type CodemodeRuntimeAssetEnvironment, requireCodemodeRuntimeAsset } from "../shared/runtime-asset.ts";
 import { createInlineWorker, type WorkerLike } from "./inline-worker.ts";
+import { retireWorker } from "./interrupt-bounds.ts";
 import { resolveKernelToolNameSource } from "./kernel-contract.ts";
 import { type JavaScriptKernelOptions, localBridgeConnection } from "./local-module-loader.ts";
+import { resolveJsProcessEntryUrl, spawnProcessWorker } from "./process-worker.ts";
 import { spawnNodeWorker, WorkerStartupCancelledError, waitForReady } from "./worker-host.ts";
 
 export interface JavaScriptWorkerEntryUrlOptions extends CodemodeRuntimeAssetEnvironment {
@@ -15,6 +17,21 @@ export function resolveJsWorkerEntryUrl(options: JavaScriptWorkerEntryUrlOptions
 	return pathToFileURL(requireCodemodeRuntimeAsset(localPath, join("kernels", "js", "worker-entry.js"), options));
 }
 
+/**
+ * How long a process-mode kernel child gets to report ready. A child that a starved host never schedules would
+ * otherwise hold every queued cell forever: no cell's own timeout is armed until the kernel is up.
+ */
+export const PROCESS_STARTUP_DEADLINE_MS = 30_000;
+
+export class ProcessKernelStartupTimeoutError extends Error {
+	constructor(deadlineMs: number) {
+		super(
+			`JavaScript kernel process did not become ready within ${deadlineMs / 1000}s; it was stopped, and the next cell starts a fresh one`,
+		);
+		this.name = "ProcessKernelStartupTimeoutError";
+	}
+}
+
 export interface WorkerStartupHooks {
 	readonly options: JavaScriptKernelOptions;
 	readonly kernelGeneration: number;
@@ -36,6 +53,13 @@ export async function startWorkerWithInlineFallback(hooks: WorkerStartupHooks, s
 			await worker.terminate();
 			throw new WorkerStartupCancelledError();
 		}
+		// Process mode never falls back: the user asked for isolation, so a failed start stays visible. The child that
+		// failed to start is stopped (bounded), so a stuck one is not left behind.
+		if (worker.mode === "process") {
+			hooks.retire(worker);
+			await retireWorker(worker);
+			throw error;
+		}
 		if (worker.mode === "inline") throw error;
 		hooks.retire(worker);
 		await worker.terminate();
@@ -47,6 +71,15 @@ export async function startWorkerWithInlineFallback(hooks: WorkerStartupHooks, s
 }
 
 function spawnWorker(options: JavaScriptKernelOptions): WorkerLike {
+	if (options.isolation === "process") {
+		const url = resolveJsProcessEntryUrl();
+		return spawnProcessWorker(url, {
+			cwd: options.cwd,
+			parallelPoolWidth: options.parallelPoolWidth,
+			...(options.processCommandPath === undefined ? {} : { searchPath: options.processCommandPath }),
+			...(options.processExecPath === undefined ? {} : { execPath: options.processExecPath }),
+		});
+	}
 	try {
 		const url = options.workerEntryUrl ?? resolveJsWorkerEntryUrl();
 		return spawnNodeWorker(url, options.cwd, options.parallelPoolWidth);
@@ -57,7 +90,10 @@ function spawnWorker(options: JavaScriptKernelOptions): WorkerLike {
 }
 
 async function initializeWorker(worker: WorkerLike, hooks: WorkerStartupHooks, signal: AbortSignal): Promise<void> {
-	const ready = waitForReady(worker, signal);
+	const ready =
+		worker.mode === "process"
+			? withStartupDeadline(waitForReady(worker, signal), hooks.options)
+			: waitForReady(worker, signal);
 	const options = hooks.options;
 	worker.postMessage({
 		type: "init",
@@ -68,6 +104,18 @@ async function initializeWorker(worker: WorkerLike, hooks: WorkerStartupHooks, s
 		foreignLanguageNames: resolveKernelToolNameSource(options.foreignLanguageNames),
 		...(options.sessionEnv === undefined ? {} : { sessionEnv: options.sessionEnv }),
 		...(options.memory === undefined ? {} : { memory: options.memory }),
+		...(options.kernelToolsEnabled === false ? { kernelToolsDisabled: true } : {}),
 	});
 	await ready;
 }
+
+function withStartupDeadline(ready: Promise<void>, options: JavaScriptKernelOptions): Promise<void> {
+	const deadlineMs = options.processStartupDeadlineMs ?? PROCESS_STARTUP_DEADLINE_MS;
+	let timer: NodeJS.Timeout | undefined;
+	const expired = new Promise<never>((_resolve, reject) => {
+		timer = setTimeout(() => reject(new ProcessKernelStartupTimeoutError(deadlineMs)), deadlineMs);
+	});
+	// When the deadline wins, the stopped child's readiness promise rejects later; that outcome is already reported.
+	ready.catch(() => {});
+	return Promise.race([ready, expired]).finally(() => clearTimeout(timer));
+}

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

@@ -5,6 +5,7 @@ import { DELIVER_EVENT, WebViewPortClient, webViewError } from "./worker-webview
 // `Bun` parameter bound to a stand-in whose `WebView` forwards Chrome-backed views to the
 // main-thread service over a private port; every other `Bun.*` member is the real one.
 const KERNEL_BUN = Symbol.for("senpi.kernel.bun");
+const KERNEL_PROCESS_MODE = Symbol.for("senpi.kernel.processMode");
 
 export function bindKernelBun(source) {
 	if (!globalThis[KERNEL_BUN]) return source;
@@ -17,6 +18,10 @@ export function installKernelWebView(requestPort) {
 	globalThis[KERNEL_BUN] = shadowBun(bun, createKernelWebView(bun.WebView, requestPort));
 }
 
+export function markKernelProcessMode() {
+	globalThis[KERNEL_PROCESS_MODE] = true;
+}
+
 function shadowBun(real, WebView) {
 	return new Proxy(
 		{},
@@ -35,7 +40,10 @@ function shadowBun(real, WebView) {
 }
 
 // The macOS default (WebKit) stays a native worker view: its host process serves any thread.
+// A process-mode kernel already runs its cells on the child's main thread, so the native
+// WebView constructs there directly and no MessagePort proxy is ever needed.
 function needsMainThread(options) {
+	if (globalThis[KERNEL_PROCESS_MODE]) return false;
 	const backend = options?.backend;
 	if (backend === undefined) return process.platform !== "darwin";
 	return backend === "chrome" || (typeof backend === "object" && backend !== null && backend.type === "chrome");

package/src/kernels/py/host-cell.ts

@@ -1,42 +1,19 @@
 import type { KernelToHostMessage } from "../../bridge/protocol.ts";
 import type { HostCellExecutor } from "../../tool/types.ts";
-
-type HostCellOutcome = Awaited<ReturnType<HostCellExecutor>>;
-
+import { runHostCell as runSharedHostCell } from "../shared/host-cell.ts";
 import type { PendingRun, ResultMessage } from "./kernel-contract.ts";
-import { failedPythonResult } from "./transport.ts";
 
 export function runHostCell(
 	pending: PendingRun,
 	host: HostCellExecutor,
 	io: { readonly emit: (message: KernelToHostMessage) => void; readonly settle: (result: ResultMessage) => void },
 ): void {
-	const abort = new AbortController();
-	pending.hostAbort = abort;
-	const cellId = pending.input.cellId;
-	let finished = false;
-	// Output from an executor that was aborted, or after its outcome, belongs to no cell.
-	const emit = (message: KernelToHostMessage): void => {
-		if (!finished && !abort.signal.aborted) io.emit(message);
-	};
-	// Calling the executor inside a promise keeps a synchronous throw in this cell instead of failing the queue.
-	const done = new Promise<HostCellOutcome>((resolve) => resolve(host({ signal: abort.signal, emit }))).then(
-		(outcome): ResultMessage =>
-			outcome.ok
-				? {
-						type: "result",
-						cellId,
-						ok: true,
-						durationMs: 0,
-						...(outcome.valueRepr === undefined ? {} : { valueRepr: outcome.valueRepr }),
-					}
-				: { type: "result", cellId, ok: false, error: outcome.error, durationMs: 0 },
-		(error: unknown): ResultMessage =>
-			failedPythonResult(cellId, error instanceof Error ? error.message : String(error)),
-	);
-	pending.hostDone = done;
-	void done.then((result) => {
-		finished = true;
-		if (!abort.signal.aborted) io.settle(result);
+	const run = runSharedHostCell(pending.input.cellId, host, {
+		emit: io.emit,
+		settle: io.settle,
+		durationMs: () => 0,
+		settleAfterAbort: false,
 	});
+	pending.hostAbort = run.abort;
+	pending.hostDone = run.done;
 }

package/src/kernels/py/prelude.py

@@ -704,7 +704,8 @@ class _Entry:
 
 
 class Registry:
-    def __init__(self, on_change: Callable[[list[str]], None]) -> None:
+    def __init__(self, on_change: Callable[[list[str]], None], *, disabled: bool = False) -> None:
+        self._disabled = disabled
         self._lock = threading.Lock()
         self._entries: dict[str, _Entry] = {}
         # Revisions outlive undefine: a redefined name never reuses a revision an old descriptor carries.
@@ -713,6 +714,8 @@ class Registry:
         self.generation = 1
 
     def define(self, fn: Any, *, name: Any = None, description: Any = None, schema: Any = None) -> Any:
+        if self._disabled:
+            raise KernelToolError("tools_unavailable", "kernel tools are turned off for this project (kernelTools.enabled is false)")
         inferred = infer_tool(fn, name=name, description=description, schema=schema)
         key = tool_key(inferred["name"])
         with self._lock:
@@ -983,7 +986,12 @@ async def _awaited(awaitable: Any) -> Any:
 
 KERNEL_TOOL_TOKEN = OwnerToken()
 KERNEL_TOOL_STREAMS = (ThreadRoutedStream(stderr=False), ThreadRoutedStream(stderr=True))
-KERNEL_TOOL_REGISTRY = Registry(lambda names: emit({"type": "kernel-tools-defined", "names": names}))
+# kernelTools.enabled is read once, while the prelude loads and before any cell runs, then removed from the
+# environment: rewriting os.environ cannot turn kernel tools back on, and cell subprocesses never see the switch.
+KERNEL_TOOL_REGISTRY = Registry(
+    lambda names: emit({"type": "kernel-tools-defined", "names": names}),
+    disabled=os.environ.pop("SENPI_CODEMODE_KERNEL_TOOLS", None) == "0",
+)
 KERNEL_TOOL_RUNNER = KernelToolRunner(emit, KERNEL_TOOL_TOKEN, KERNEL_TOOL_REGISTRY, KERNEL_TOOL_STREAMS)
 
 

package/src/kernels/py/process.ts

@@ -1,4 +1,6 @@
 import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { isAbsolute } from "node:path";
 import type { Readable, Writable } from "node:stream";
 
 export interface KernelChild {
@@ -53,6 +55,8 @@ export function defaultSpawn(options: KernelSpawnOptions): KernelChild {
 }
 
 export function splitCommand(commandLine: string): { readonly command: string; readonly args: readonly string[] } {
+	// A configured interpreter path is one executable even when it contains spaces.
+	if (isAbsolute(commandLine) && existsSync(commandLine)) return { command: commandLine, args: [] };
 	const [command, ...args] = commandLine.split(" ").filter(Boolean);
 	if (!command) throw new Error("Python interpreter path is empty");
 	return { command, args };

package/src/kernels/sandbox/sandbox-cell.ts

@@ -0,0 +1,116 @@
+import type { ResolvedSandbox } from "../../config/feature-settings.ts";
+import { marshalToolResult } from "../../tool/image.ts";
+import type { ExecuteTool, HostCellExecutor } from "../../tool/types.ts";
+import type { CodemodeSandbox } from "./vendor/pi-codemode/runtime/host.ts";
+import type { CodemodeError, CodemodeOutputFrame, CodemodeTool } from "./vendor/pi-codemode/types.ts";
+
+export interface SandboxCellOptions {
+	readonly sandbox: ResolvedSandbox;
+	readonly executeTool: ExecuteTool;
+	readonly toolNames: () => readonly string[];
+	readonly describeTool?: (name: string) => string | undefined;
+	/** Where the QuickJS wasm lives; by default the installed `quickjs-wasi` package's file. */
+	readonly wasmPath?: string;
+}
+
+// On the script's first line so reported line numbers still match the cell; globals, so a cell's own
+// `const print` shadows them instead of failing as a redeclaration.
+const OUTPUT_ALIASES =
+	'globalThis.print = (...values) => text(values.map((value) => (typeof value === "string" ? value : JSON.stringify(value))).join(" ")); globalThis.display = (value) => ((typeof value === "string" && value.startsWith("data:image/")) || (value !== null && typeof value === "object" && ("image_url" in value || value.type === "image")) ? image(value) : text(typeof value === "string" ? value : JSON.stringify(value))); globalThis.tool = tools; ';
+
+const ERROR_CODES: Partial<Record<CodemodeError["kind"], string>> = {
+	timeout: "eval_isolate_timeout",
+	aborted: "eval_isolate_aborted",
+	sandbox: "eval_isolate_unavailable",
+};
+
+function codeFor(error: CodemodeError): string | undefined {
+	if (error.kind === "script" && error.reason === "memory") return "eval_isolate_memory_limit";
+	if (error.kind === "script" && error.name === "CodemodeStoreDisabledError") return "eval_isolate_no_state";
+	if (error.kind === "script" && error.reason === "unresolved") return "eval_isolate_unresolved_promise";
+	return ERROR_CODES[error.kind];
+}
+
+/** The persistent kernel never sees an isolated cell; its tools go through executeTool so permission hooks still apply. */
+export function sandboxCellExecutor(code: string, options: SandboxCellOptions): HostCellExecutor {
+	return async ({ signal, emit }) => {
+		let sandbox: CodemodeSandbox;
+		try {
+			// Lazy: the vendored QuickJS runtime loads only when a session runs its first isolated cell. The wasm is loaded
+			// here, before any of the cell runs, so a missing runtime is reported as unavailable instead of failing inside
+			// the script.
+			const runtime = await import("./vendor/pi-codemode/runtime/host.ts");
+			const { loadQuickJSWasm } = await import("./vendor/pi-codemode/wasm.ts");
+			const wasm = await loadQuickJSWasm(options.wasmPath);
+			const items = new Map<number, string[]>();
+			const tools: CodemodeTool[] = options
+				.toolNames()
+				.filter((name) => name !== "eval")
+				.map((name) => ({
+					name,
+					description: options.describeTool?.(name) ?? "",
+					execute: async (args: unknown, context: { signal: AbortSignal }) =>
+						marshalToolResult(await options.executeTool(name, args, { signal: context.signal })),
+				}));
+			sandbox = new runtime.CodemodeSandbox({
+				wasm,
+				tools,
+				timeoutMs: options.sandbox.timeoutSeconds * 1_000,
+				memoryLimitBytes: options.sandbox.memoryMb * 1024 * 1024,
+				output: "stream",
+				builtins: { store: "reject" },
+				onOutputFrame: (frame: CodemodeOutputFrame) => {
+					const parts = items.get(frame.itemId) ?? [];
+					parts.push(frame.chunk);
+					if (!frame.final) {
+						items.set(frame.itemId, parts);
+						return;
+					}
+					items.delete(frame.itemId);
+					const payload = parts.join("");
+					if (frame.type === "image") {
+						emit({ type: "display", mimeType: frame.mimeType ?? "image/png", dataBase64: payload });
+					} else {
+						emit({ type: "text", stream: "stdout", data: payload.endsWith("\n") ? payload : `${payload}\n` });
+					}
+				},
+			});
+		} catch (error) {
+			// The full error, paths included, goes to the host's own log so a maintainer can diagnose it; the cell gets
+			// only what failed and the error's code. This covers every setup step: the runtime import, the tool list,
+			// the wasm load and the sandbox itself.
+			console.error("[senpi-codemode] isolated cell setup failed:", error);
+			const code =
+				error instanceof Error && "code" in error && typeof error.code === "string" ? ` (${error.code})` : "";
+			return {
+				ok: false,
+				error: {
+					name: "SandboxUnavailableError",
+					message: `eval_isolate_unavailable: the QuickJS runtime for isolated cells could not be loaded${code}; nothing in the cell ran`,
+				},
+			};
+		}
+		try {
+			const result = await sandbox.execute(OUTPUT_ALIASES + code, { signal });
+			if (result.ok) {
+				return result.value === undefined
+					? { ok: true }
+					: {
+							ok: true,
+							valueRepr: typeof result.value === "string" ? result.value : JSON.stringify(result.value),
+						};
+			}
+			const errorCode = codeFor(result.error);
+			return {
+				ok: false,
+				error: {
+					...(result.error.name === undefined ? {} : { name: result.error.name }),
+					message: errorCode === undefined ? result.error.message : `${errorCode}: ${result.error.message}`,
+					...(result.error.stack === undefined ? {} : { stack: result.error.stack }),
+				},
+			};
+		} finally {
+			await sandbox.close();
+		}
+	};
+}

package/src/kernels/sandbox/vendor/pi-codemode/VENDORED.md

@@ -40,3 +40,4 @@ A sync must re-apply both kinds: dropping a marked line (for example `"output-fr
    - A normal finish settles only after every frame is consumed. An abort or timeout settles at once and drops frames still queued. The timer and the abort signal stay armed while a finished run's last frames drain, so a late abort, timeout or `close()` abandons them too (the run settles with that error): a consumer that never returns cannot keep a run alive.
    - `frameBytes` and `windowBytes` must be at least 4, so a frame can always hold a whole surrogate pair.
 2. **Builtin store policy** (`builtins: { store: "collect" | "reject" }`; `types.ts`, `runtime/protocol.ts`, `runtime/worker.ts`, `runtime/host.ts`, `runtime/prelude-source.ts`). With `"reject"`, `load()` returns `undefined` and `store()` throws `CodemodeStoreDisabledError`. The names stay defined, so scripts written for upstream fail with a clear message instead of a ReferenceError.
+3. **Runtime-set error reasons** (`types.ts` `CodemodeError.reason`, `runtime/prelude-source.ts`, `runtime/worker.ts`). The prelude captures the engine's own `InternalError` before user code runs and tags a failure `reason: "memory"` only for an instance of it whose message is exactly "out of memory"; its stalled-promise failure is tagged `reason: "unresolved"`; the worker tags an engine out-of-memory from `evalCode` the same way; and `text()` rethrows the engine's own error instead of replacing it with a `TypeError`. The host maps the isolate error codes from `reason` only, never from message text. Upstream has no `reason`, so its behaviour is unchanged.

package/src/kernels/sandbox/vendor/pi-codemode/runtime/prelude-source.ts

@@ -46,6 +46,10 @@ export const PRELUDE_SOURCE: string = `(function (bridge, toolsJson, globalsJson
 	const options = optionsJson === undefined ? {} : JSON.parse(optionsJson);
 	const streamOutput = options.streamOutput === true;
 	const rejectStore = options.store === "reject";
+	// The engine's own InternalError, captured before user code runs: a failure is tagged by identity, never by its
+	// text, so a cell's own error that merely mentions memory keeps its own code. A script can still construct this
+	// constructor itself and so label its own failure as the memory limit; that mislabels only its own cell.
+	const EngineInternalError = typeof InternalError === "function" ? InternalError : undefined;
 	// senpi-change end
 	"use strict";
 	const stringify = JSON.stringify;
@@ -94,7 +98,13 @@ export const PRELUDE_SOURCE: string = `(function (bridge, toolsJson, globalsJson
 
 	function describeError(error) {
 		if (error instanceof ErrorCtor) {
-			return stringify({ name: error.name, message: error.message, stack: errorText(error) });
+			// senpi-change begin: the engine's out-of-memory error is reported by identity, not by matching its message
+			const reason =
+				EngineInternalError !== undefined && error instanceof EngineInternalError && error.message === "out of memory"
+					? "memory"
+					: undefined;
+			return stringify({ name: error.name, message: error.message, stack: errorText(error), reason });
+			// senpi-change end
 		}
 		return stringify({ message: format(error) });
 	}
@@ -285,6 +295,8 @@ export const PRELUDE_SOURCE: string = `(function (bridge, toolsJson, globalsJson
 		try {
 			rendered = outputText(value);
 		} catch (error) {
+			// The engine's own out-of-memory error keeps its identity, so it is still reported as the memory limit.
+			if (EngineInternalError !== undefined && error instanceof EngineInternalError) throw error; // senpi-change
 			throw new TypeErrorCtor(error instanceof ErrorCtor ? error.message : String(error));
 		}
 		output("text", rendered);
@@ -423,6 +435,7 @@ export const PRELUDE_SOURCE: string = `(function (bridge, toolsJson, globalsJson
 					name: "Error",
 					message:
 						"The script is waiting on a promise that can never settle: no tool call is pending, and timers do not exist here.",
+					reason: "unresolved", // senpi-change: tagged by the runtime, so a script's own error text never matches it
 				}),
 			);
 			return true;

package/src/kernels/sandbox/vendor/pi-codemode/runtime/worker.ts

@@ -48,7 +48,10 @@ function discardOutput(memory: { readonly buffer: ArrayBufferLike }) {
 function describeException(error: JSException): string {
 	const head = error.message ? `${error.name}: ${error.message}` : error.name;
 	const stack = error.stack?.trimEnd();
-	return JSON.stringify({ name: error.name, message: error.message, stack: stack ? `${head}\n${stack}` : head });
+	// senpi-change begin: evalCode fails before any script runs, so an InternalError here is the engine's own
+	const reason = error.name === "InternalError" && error.message === "out of memory" ? "memory" : undefined;
+	return JSON.stringify({ name: error.name, message: error.message, stack: stack ? `${head}\n${stack}` : head, reason });
+	// senpi-change end
 }
 // senpi-change begin: output streaming
 /**

package/src/kernels/sandbox/vendor/pi-codemode/types.ts

@@ -71,6 +71,8 @@ export interface CodemodeError {
 	name?: string;
 	message: string;
 	stack?: string;
+	/** senpi-change: set by the runtime itself (never from script text) for its own memory-limit and stalled failures. */
+	reason?: "memory" | "unresolved";
 }
 
 /** Keys the script changed with `store()`. Only successful executions report writes. */

package/src/kernels/shared/host-cell.ts

@@ -0,0 +1,57 @@
+import type { KernelToHostMessage } from "../../bridge/protocol.ts";
+import type { HostCellExecutor } from "../../tool/types.ts";
+
+type HostCellOutcome = Awaited<ReturnType<HostCellExecutor>>;
+type HostResult = Extract<KernelToHostMessage, { type: "result" }>;
+
+export interface HostCellRun {
+	readonly cellId: string;
+	readonly abort: AbortController;
+	readonly done: Promise<HostResult>;
+}
+
+/**
+ * Runs a host entry (a cell the host executes, such as an install) for one queue slot: output after the outcome or after
+ * an abort belongs to no cell, a synchronous throw stays in this cell, and `settle` receives the cell's result.
+ * `settleAfterAbort` says whether an aborted entry still settles here or whoever aborted it settles the cell.
+ */
+export function runHostCell(
+	cellId: string,
+	host: HostCellExecutor,
+	io: {
+		readonly emit: (message: KernelToHostMessage) => void;
+		readonly settle: (result: HostResult) => void;
+		readonly durationMs: () => number;
+		readonly settleAfterAbort: boolean;
+	},
+): HostCellRun {
+	const abort = new AbortController();
+	let finished = false;
+	const emit = (message: KernelToHostMessage): void => {
+		if (!finished && !abort.signal.aborted) io.emit(message);
+	};
+	const done = new Promise<HostCellOutcome>((resolve) => resolve(host({ signal: abort.signal, emit }))).then(
+		(outcome): HostResult =>
+			outcome.ok
+				? {
+						type: "result",
+						cellId,
+						ok: true,
+						durationMs: io.durationMs(),
+						...(outcome.valueRepr === undefined ? {} : { valueRepr: outcome.valueRepr }),
+					}
+				: { type: "result", cellId, ok: false, error: outcome.error, durationMs: 0 },
+		(error: unknown): HostResult => ({
+			type: "result",
+			cellId,
+			ok: false,
+			error: { message: error instanceof Error ? error.message : String(error) },
+			durationMs: 0,
+		}),
+	);
+	void done.then((result) => {
+		finished = true;
+		if (io.settleAfterAbort || !abort.signal.aborted) io.settle(result);
+	});
+	return { cellId, abort, done };
+}

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

@@ -151,6 +151,11 @@ export class SubprocessProcess {
 	}
 
 	private kill(signal: NodeJS.Signals): void {
+		if (globalThis.process.platform === "win32") {
+			if (this.child.pid !== undefined) killProcessTree(this.child.pid);
+			else this.child.kill(signal);
+			return;
+		}
 		if (this.child.pid !== undefined) {
 			try {
 				globalThis.process.kill(-this.child.pid, signal);
@@ -163,6 +168,15 @@ export class SubprocessProcess {
 	}
 }
 
+// Windows has no process-group signal: taskkill /T /F walks the tree rooted at the child.
+function killProcessTree(pid: number): void {
+	try {
+		nodeSpawn("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore" });
+	} catch (error) {
+		if (!(error instanceof Error)) throw error;
+	}
+}
+
 export function spawnSubprocess(spawn: SubprocessSpawn | undefined, request: SubprocessSpawnRequest): SubprocessLike {
 	if (spawn) return spawn(request.command, request.args, { cwd: request.cwd, env: request.env });
 	const child = nodeSpawn(request.command, [...request.args], {

package/src/prompt/eval-prompt.ts

@@ -18,6 +18,8 @@ export interface EvalPromptParts {
 
 export interface EvalPromptOptions {
 	readonly spawns: boolean;
+	/** `prompt.advertiseHelpers`: true appends one pointer line to the helper documentation entry. */
+	readonly advertiseHelpers?: boolean;
 	/** Whether the session registry exposes the monitor tool through eval. */
 	readonly monitor?: boolean;
 	readonly spawnDefaultAgent?: string;
@@ -74,6 +76,10 @@ export function evalEmphasisStyle(modelId: string | undefined): EvalEmphasisStyl
 type ContextValue = string | boolean;
 type Context = Readonly<Record<string, ContextValue>>;
 
+/** The single line `prompt.advertiseHelpers: true` adds; off by default, so the default description is unchanged. */
+export const ADVERTISED_HELPERS_LINE =
+	"Advanced cell helpers (handle controls, wait(), kernel tools in workpools) are documented on demand: tool_schema('eval:helpers').";
+
 export function buildEvalPrompt(
 	enabled: EnabledLanguages,
 	options: EvalPromptOptions = { spawns: false },
@@ -104,9 +110,10 @@ export function buildEvalPrompt(
 		maxDetachedCells: String(options.maxDetachedCells ?? DEFAULT_MAX_DETACHED_CELLS),
 		kernelPreludeDocs: (options.kernelPreludes ?? []).map((prelude) => prelude.documentation).join("\n"),
 	};
-	const description = renderTemplate(EVAL_PROMPT_TEMPLATE, context)
+	const rendered = renderTemplate(EVAL_PROMPT_TEMPLATE, context)
 		.replace(/\n{3,}/g, "\n\n")
 		.trim();
+	const description = options.advertiseHelpers === true ? `${rendered}\n\n${ADVERTISED_HELPERS_LINE}` : rendered;
 	return {
 		description,
 		promptSnippet: "Run one incremental code cell in a persistent language kernel.",

package/src/tool/AGENTS.md

@@ -17,6 +17,7 @@ anchor most suites).
 | Code preview layout | `code-preview.ts` -> `display-code.ts` (JS: `display-js*.ts` Bun-only masked `Bun.Transpiler`; Python: `display-python*.ts` user interpreter, background + repaint) |
 | Status events, execution events | `status-events.ts`, `eval-execution-event.ts` |
 | Interrupt, capture | `interrupt-note.ts`, `call-capture.ts` |
+| Magic cells | `magic-cells.ts` (parsing), `magic-cell-host.ts` (`%pip`, `%bun`/`%npm`, `%environment`), `load-cell.ts` (`%load`); installs live in `../environments/` |
 
 ## CONVENTIONS
 

package/src/tool/cell-handler.ts

@@ -235,22 +235,20 @@ export class CellHandler {
 			this.#kernel.deliverToolReply({ type: "tool-reply", callId: message.callId, ok: true, value: reply.value });
 		} catch (error) {
 			if (!this.#state.active) return;
-			const text = appendSchemaHint(
-				error instanceof Error ? error.message : String(error),
-				message.toolName,
-				this.#toolParameters(message.toolName),
-			);
+			const code =
+				error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : undefined;
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			// A blocked call (a permission denial or another hook's veto) is not an argument problem.
+			const text =
+				code === "blocked"
+					? errorMessage
+					: appendSchemaHint(errorMessage, message.toolName, this.#toolParameters(message.toolName));
 			recordToolCall(this.#state.toolCalls, false, capture, undefined, text);
 			this.#kernel.deliverToolReply({
 				type: "tool-reply",
 				callId: message.callId,
 				ok: false,
-				error: {
-					message: text,
-					...(error instanceof Error && "code" in error && typeof error.code === "string"
-						? { code: error.code }
-						: {}),
-				},
+				error: { message: text, ...(code === undefined ? {} : { code }) },
 			});
 		}
 		this.#resultBuilder.emitUpdate(false);

package/src/tool/eval-request.ts

@@ -17,9 +17,19 @@ export function normalizeEvalSummary(value: unknown): string | undefined {
 	return normalized.length === 0 ? undefined : normalized;
 }
 
+export class EvalIsolateInvalidError extends TypeError {
+	readonly name = "EvalIsolateInvalidError";
+	readonly code = "eval_isolate_invalid";
+
+	constructor(reason: string) {
+		super(`eval_isolate_invalid: ${reason}`);
+	}
+}
+
 export function parseEvalRequest(
 	params: unknown,
 	enabledLanguages: readonly EvalLanguage[] = evalLanguageOrder,
+	options: { readonly sandbox?: boolean } = {},
 ): EvalToolRequest {
 	if (!isRecord(params)) throw new TypeError("eval parameters must be an object");
 	if (params.action === "list") return { action: "list" };
@@ -30,7 +40,9 @@ export function parseEvalRequest(
 	}
 	if (params.action !== undefined && params.action !== "run")
 		throw new TypeError(`Unknown eval action "${String(params.action)}"`);
-	if (!isEvalLanguage(params.language)) throw new TypeError(evalRunRequiresLanguageMessage(enabledLanguages));
+	if (params.language === undefined) throw new TypeError(evalRunRequiresLanguageMessage(enabledLanguages));
+	if (!isEvalLanguage(params.language))
+		throw new TypeError(`eval run language must be one of: ${enabledLanguages.join(", ")}`);
 	if (typeof params.code !== "string")
 		throw new TypeError("eval run requires code — the cell body to execute, verbatim");
 	const summary = normalizeEvalSummary(params.summary);
@@ -40,6 +52,15 @@ export function parseEvalRequest(
 		);
 	if (params.on_timeout !== undefined && params.on_timeout !== "detach" && params.on_timeout !== "error")
 		throw new TypeError(`Unknown eval on_timeout value "${String(params.on_timeout)}"`);
+	if (params.isolate !== undefined && params.isolate !== false) {
+		if (params.isolate !== true) throw new EvalIsolateInvalidError("isolate must be true or false");
+		if (options.sandbox !== true) {
+			throw new EvalIsolateInvalidError("sandbox cells are turned off (set sandbox.enabled in codemode settings)");
+		}
+		if (params.language !== "js")
+			throw new EvalIsolateInvalidError('sandbox cells run JavaScript only (language: "js")');
+		if (params.reset === true) throw new EvalIsolateInvalidError("a sandbox cell starts fresh; reset does not apply");
+	}
 	return {
 		language: params.language,
 		code: params.code,
@@ -48,6 +69,7 @@ export function parseEvalRequest(
 		...(typeof params.timeout === "number" ? { timeout: params.timeout } : {}),
 		...(params.on_timeout === "detach" || params.on_timeout === "error" ? { on_timeout: params.on_timeout } : {}),
 		...(typeof params.reset === "boolean" ? { reset: params.reset } : {}),
+		...(params.isolate === true ? { isolate: true } : {}),
 	};
 }
 

package/src/tool/eval-tool-options.ts

@@ -8,6 +8,7 @@ import type {
 import type { EvalSchemaToolInfo } from "../bridges/schema-bridge.ts";
 import type { CompletionRequest, CompletionResult } from "../completion/handler.ts";
 import type { ResolvedCodemodeSettings } from "../config/settings.ts";
+import type { JsEnvironments } from "../environments/js-environments.ts";
 import type { PythonEnvironments } from "../environments/python-environments.ts";
 import type { EvalExecutionTracker } from "../extension/session-manager.ts";
 import type { HandleRegistry } from "../handles/handle-registry.ts";
@@ -72,6 +73,8 @@ export interface CreateEvalToolOptions {
 	readonly kernelPreludes?: () => readonly KernelPreludeContribution[];
 	/** The session's Python environments: `%pip` / `%environment` cells and the import root of every Python cell. */
 	readonly pythonEnvironments?: PythonEnvironments;
+	/** The session's managed JavaScript packages: `%bun add` / `%npm add` cells and the bare-import fallback root. */
+	readonly jsEnvironments?: JsEnvironments;
 	/** Contributions whose documentation lines the description lists; snapshot taken when the tool is (re)registered. */
 	readonly promptKernelPreludes?: readonly KernelPreludeContribution[];
 }