@code-yeongyu/senpi-codemode 2026.10.8 → 2026.10.10-10

package/src/kernels/py/prelude.py

@@ -13,6 +13,7 @@ import asyncio  # noqa: ANYIO_OK — stdlib-only embedded kernel runner.
 import base64
 import codecs
 import contextlib
+import importlib
 import gc
 import inspect
 import io
@@ -60,6 +61,7 @@ RESERVED_HANDLE_STATUS_TOOL = "__handle_status__"
 RESERVED_HANDLE_OUTPUT_TOOL = "__handle_output__"
 RESERVED_HANDLE_SEND_TOOL = "__handle_send__"
 RESERVED_HANDLE_CANCEL_TOOL = "__handle_cancel__"
+RESERVED_PACKAGES_INSTALL_TOOL = "__packages_install__"
 TIMEOUT_PAUSE_OP = "timeout-pause"
 TIMEOUT_RESUME_OP = "timeout-resume"
 
@@ -374,7 +376,15 @@ _BRIDGE_SOCKET_TIMEOUT_SECONDS = 60
 _WAIT_SOCKET_GRACE_SECONDS = 30
 
 
+# The host's secret for the run in this context. Every host call carries it, so the host gives the call that run's
+# kernel tools; copied contexts (parallel workers) keep it, plain threads do not, and the host forgets it at settle.
+CURRENT_CELL_TOKEN: contextvars.ContextVar[str | None] = contextvars.ContextVar("senpi_cell_token", default=None)
+
+
 def bridge_post(path: str, payload: dict[str, Any], *, socket_timeout: float | None = _BRIDGE_SOCKET_TIMEOUT_SECONDS) -> Any:
+    cell_token = CURRENT_CELL_TOKEN.get()
+    if path == "/call" and cell_token is not None and "cellToken" not in payload:
+        payload = {**payload, "cellToken": cell_token}
     port = CONNECTION.get("port")
     token = CONNECTION.get("token")
     if not isinstance(port, int) or not isinstance(token, str):
@@ -695,7 +705,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.
@@ -704,6 +715,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:
@@ -974,7 +987,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)
 
 
@@ -1088,10 +1106,18 @@ class Workpool:
         return _workpool_call({"op": "cancel", "pool_id": self.pool_id})
 
 
-def workpool(agent: dict[str, JsonValue], name: str, *, mode: str | None = None) -> Workpool:
+def workpool(
+    agent: dict[str, JsonValue], name: str, *, mode: str | None = None, tools: list[str] | None = None
+) -> Workpool:
     args: dict[str, JsonValue] = {"op": "create", "agent": agent, "name": name}
     if mode is not None:
         args["mode"] = mode
+    if tools is not None:
+        if not isinstance(tools, (list, tuple)) or not all(isinstance(name, str) for name in tools):
+            raise PreludeRuntimeError(
+                f"workpool(tools=...) takes a list of tool names; got {type(tools).__name__}", "invalid_tools"
+            )
+        args["tools"] = list(tools)
     result = _workpool_call(args)
     details = result.get("details")
     if isinstance(details, dict):
@@ -1137,6 +1163,27 @@ def tool_schema(name: str | None = None) -> Any:
     )
 
 
+class _Packages:
+    """packages.install(manager, requirements, *, timeout=600): the %pip installer as a call; returns its receipt."""
+
+    __slots__ = ()
+
+    def install(self, manager: str, requirements: Any, *, timeout: float | None = None) -> Any:
+        args: dict[str, Any] = {"manager": manager, "requirements": requirements}
+        if timeout is not None:
+            args["timeout"] = timeout
+        # A long install must not hit the 60 s socket cap; the host bounds it by the timeout (600 s by default).
+        socket_timeout = (600 if timeout is None else float(timeout)) + _WAIT_SOCKET_GRACE_SECONDS
+        return bridge_post(
+            "/call",
+            {"callId": f"py-{uuid.uuid4()}", "toolName": RESERVED_PACKAGES_INSTALL_TOOL, "args": args},
+            socket_timeout=socket_timeout,
+        )
+
+
+packages = _Packages()
+
+
 def output(
     *ids: str,
     format: str = "raw",
@@ -1169,9 +1216,12 @@ def agent(
     apply: bool | None = None,
     merge: bool | str | None = None,
     handle: bool = False,
+    tools: list[str] | None = None,
 ) -> Any:
     """Delegate work; isolated/apply/merge need a host that supports isolation, otherwise a warning.
 
+    tools grants the child this kernel's @tool functions by name, as JavaScript's agent(prompt, { tools }) does.
+
     merge accepts "patch"/"branch" or False/True respectively. Unapplied foreground
     changes raise an error with recovery instructions. A handle returns immediately;
     await the completion notification or read task_output for the isolation result.
@@ -1193,6 +1243,10 @@ def agent(
         args["merge"] = merge
     if handle:
         args["handle"] = True
+    if tools is not None:
+        if not isinstance(tools, (list, tuple)) or not all(isinstance(name, str) for name in tools):
+            raise PreludeRuntimeError(f"agent(tools=...) takes a list of tool names; got {type(tools).__name__}", "invalid_tools")
+        args["tools"] = list(tools)
 
     response = bridge_post(
         "/call",
@@ -1577,8 +1631,14 @@ _LINE_MAGICS: dict[str, Callable[[str], Any]] = {
 }
 
 
+_HOST_MAGICS = frozenset({"pip", "environment"})
+
+
 def _magic(name: str, args: str) -> Any:
     handler = _LINE_MAGICS.get(name)
+    if handler is None and name in _HOST_MAGICS:
+        # The host runs these only as a cell's first code line; anywhere else they reach here.
+        raise PreludeRuntimeError(f"put %{name} on its own cell, then run the code that uses it in the next cell")
     if handler is None:
         raise PreludeRuntimeError(f"Unsupported line magic: %{name}")
     return handler(args)
@@ -1751,6 +1811,7 @@ USER_NS.update(
         "workpool": workpool,
         "output": output,
         "tool_schema": tool_schema,
+        "packages": packages,
         "wait": wait,
         "handle": handle,
         "__senpi_magic": _magic,
@@ -2069,8 +2130,8 @@ KERNEL_MEMORY = _KernelMemory()
 TLA_FLAG = getattr(ast, "PyCF_ALLOW_TOP_LEVEL_AWAIT", 0x2000)
 
 
-def compile_cell(source: str) -> tuple[Any | None, Any | None]:
-    module = ast.parse(transform_cell(source), mode="exec")
+def compile_cell(source: str, filename: str = "<cell>") -> tuple[Any | None, Any | None]:
+    module = ast.parse(transform_cell(source), filename=filename, mode="exec")
     if not module.body:
         return None, None
     last = module.body[-1]
@@ -2078,13 +2139,13 @@ def compile_cell(source: str) -> tuple[Any | None, Any | None]:
         body = ast.Module(body=module.body[:-1], type_ignores=[])
         expression = ast.Expression(body=last.value)
         ast.copy_location(expression, last)
-        return compile(body, "<cell>", "exec", flags=TLA_FLAG), compile(
+        return compile(body, filename, "exec", flags=TLA_FLAG), compile(
             expression,
-            "<cell>",
+            filename,
             "eval",
             flags=TLA_FLAG,
         )
-    return compile(module, "<cell>", "exec", flags=TLA_FLAG), None
+    return compile(module, filename, "exec", flags=TLA_FLAG), None
 
 
 async def run_code(code: Any, want_value: bool) -> Any:
@@ -2111,7 +2172,41 @@ def apply_preludes(preludes: Any) -> None:
             exec(compile(contribution.get("python", ""), "<kernel-prelude>", "exec"), USER_NS)
 
 
-def run_cell(cell_id: str, code: str, preludes: Any = None) -> None:
+def _enter_source_file(source_file: str | None) -> Callable[[], None]:
+    # A %load cell runs as its file: __file__ names it and its directory comes first on the import path,
+    # so `from sibling import x` resolves next to the file the way it does when the file runs as a script.
+    # The returned step undoes both when the cell ends, so a later cell never imports from that directory
+    # ahead of the session environment; the file's own sys.path edits stay.
+    if source_file is None:
+        return lambda: None
+    missing = object()
+    previous_file = USER_NS.get("__file__", missing)
+    directory = os.path.dirname(source_file)
+    previous_index = sys.path.index(directory) if directory in sys.path else None
+    with contextlib.suppress(ValueError):
+        sys.path.remove(directory)
+    sys.path.insert(0, directory)
+    importlib.invalidate_caches()
+    USER_NS["__file__"] = source_file
+
+    def restore() -> None:
+        with contextlib.suppress(ValueError):
+            sys.path.remove(directory)
+        if previous_index is not None:
+            sys.path.insert(min(previous_index, len(sys.path)), directory)
+        if previous_file is missing:
+            USER_NS.pop("__file__", None)
+        else:
+            USER_NS["__file__"] = previous_file
+        # Last: it calls every sys.meta_path finder, and user code may have installed one that raises.
+        importlib.invalidate_caches()
+
+    return restore
+
+
+def run_cell(
+    cell_id: str, code: str, preludes: Any = None, source_file: str | None = None, cell_token: str | None = None
+) -> None:
     start = time.monotonic()
     stdout = io.StringIO()
     stderr = io.StringIO()
@@ -2119,12 +2214,15 @@ def run_cell(cell_id: str, code: str, preludes: Any = None) -> None:
     # cells) ignores it so a late signal cannot kill the stdin-read loop.
     signal.signal(signal.SIGINT, signal.default_int_handler)
     result: dict[str, Any]
+    leave_source_file: Callable[[], None] = lambda: None
+    cell_scope = CURRENT_CELL_TOKEN.set(cell_token)
     try:
         KERNEL_TOOL_TOKEN.acquire()
         cell_stdout, cell_stderr = KERNEL_TOOL_STREAMS
         with cell_stdout.capture(stdout, cell=True), cell_stderr.capture(stderr, cell=True):
             apply_preludes(preludes)
-            body, expression = compile_cell(code)
+            leave_source_file = _enter_source_file(source_file)
+            body, expression = compile_cell(code, source_file or "<cell>")
             LOOP.run_until_complete(run_code(body, False))
             value = LOOP.run_until_complete(run_code(expression, True))
         text("stdout", stdout.getvalue())
@@ -2148,7 +2246,13 @@ def run_cell(cell_id: str, code: str, preludes: Any = None) -> None:
             "durationMs": elapsed(start),
         }
     finally:
+        # Liveness and revocation first: nothing the cell installed (an import finder, a path hook) can skip them.
         KERNEL_TOOL_TOKEN.release()
+        CURRENT_CELL_TOKEN.reset(cell_scope)
+        try:
+            leave_source_file()
+        except BaseException as exc:  # noqa: BROAD_EXCEPT_OK — user code can break the restore; it must not wedge the kernel.
+            text("stderr", f"[senpi] %load could not fully restore the import path: {exc}\n")
         signal.signal(signal.SIGINT, signal.SIG_IGN)
     try:
         memory = KERNEL_MEMORY.after_cell()
@@ -2180,7 +2284,18 @@ def _handle_message(message: dict[str, Any]) -> bool:
         emit({"type": "ready"})
         return True
     if message_type == "run":
-        run_cell(str(message.get("cellId", "")), str(message.get("code", "")), message.get("preludes"))
+        env_root = message.get("envRoot")
+        if isinstance(env_root, str):
+            _activate_env_root(env_root)
+        source_file = message.get("sourceFile")
+        token = message.get("bridgeCellToken")
+        run_cell(
+            str(message.get("cellId", "")),
+            str(message.get("code", "")),
+            message.get("preludes"),
+            source_file if isinstance(source_file, str) and source_file else None,
+            token if isinstance(token, str) else None,
+        )
         return True
     if message_type == "close":
         KERNEL_TOOL_RUNNER.close()
@@ -2189,6 +2304,25 @@ def _handle_message(message: dict[str, Any]) -> bool:
     return True
 
 
+_ACTIVE_ENV_ROOT: list[str] = []
+
+
+def _activate_env_root(root: str) -> None:
+    # One environment revision is on the import path at a time: a newer revision already holds every
+    # package of the previous one, so it replaces that entry instead of stacking another.
+    # An empty root means the session's current mode has nothing installed: the previous revision leaves too.
+    wanted = [root] if root else []
+    if _ACTIVE_ENV_ROOT == wanted:
+        return
+    for previous in _ACTIVE_ENV_ROOT:
+        with contextlib.suppress(ValueError):
+            sys.path.remove(previous)
+    _ACTIVE_ENV_ROOT[:] = wanted
+    if root:
+        sys.path.insert(0, root)
+    importlib.invalidate_caches()
+
+
 def _terminate_process_group() -> None:
     # The kernel is spawned into its own session (setsid), so its pid is its process
     # group id and a cell's subprocesses inherit that group. Killing the group takes

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/py/transport.ts

@@ -35,6 +35,9 @@ export interface PythonTransportRunInput {
 	readonly code: string;
 	readonly timeoutMs?: number;
 	readonly preludePlan?: KernelPreludePlan;
+	readonly envRoot?: () => string;
+	readonly sourceFile?: string;
+	readonly bridgeCellToken?: string;
 }
 
 export interface PythonTransportOptions {
@@ -157,7 +160,16 @@ export class PythonKernelTransport {
 			install: input.preludePlan.install.map(({ exports, python }) => ({ exports: [...exports], python })),
 			remove: [...input.preludePlan.remove],
 		};
-		this.#write({ type: "run", cellId: input.cellId, code: input.code, timeoutMs: input.timeoutMs, preludes });
+		this.#write({
+			type: "run",
+			cellId: input.cellId,
+			code: input.code,
+			timeoutMs: input.timeoutMs,
+			preludes,
+			...(input.envRoot === undefined ? {} : { envRoot: input.envRoot() }),
+			...(input.sourceFile === undefined ? {} : { sourceFile: input.sourceFile }),
+			...(input.bridgeCellToken === undefined ? {} : { bridgeCellToken: input.bridgeCellToken }),
+		});
 	}
 
 	interrupt(reason: string): void {

package/src/kernels/rb/workpool.rb

@@ -23,9 +23,15 @@ class SenpiWorkpool
   end
 end
 
-def workpool(agent, name, mode: nil)
+def workpool(agent, name, mode: nil, tools: nil)
   args = { "op" => "create", "agent" => agent, "name" => name }
   args["mode"] = mode unless mode.nil?
+  unless tools.nil?
+    unless tools.is_a?(Array) && tools.all? { |name| name.is_a?(String) }
+      raise SenpiBridgeError.new("workpool(tools: ...) takes an array of tool names; got #{tools.class}", "invalid_tools")
+    end
+    args["tools"] = tools.dup
+  end
   result = __senpi_workpool_call(args)
   details = result["details"]
   if details.is_a?(Hash)

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

@@ -0,0 +1,141 @@
+import type { ResolvedSandbox } from "../../config/feature-settings.ts";
+import { marshalToolResult } from "../../tool/image.ts";
+import type { EvalRuntimeInfo, 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;
+}
+
+/**
+ * The runtime an isolated cell's result reports: the QuickJS build it runs on, never the persistent kernel's (senpi#2811).
+ * Read from the installed quickjs-wasi package the wasm loads from, only when an isolated cell runs; when that package
+ * cannot be resolved the cell itself fails with eval_isolate_unavailable, and the version says so.
+ */
+export function sandboxRuntimeInfo(): EvalRuntimeInfo {
+	let version = "unavailable";
+	try {
+		// getBuiltinModule, not a static import: node:module would otherwise load with the extension.
+		const manifest: unknown = process.getBuiltinModule("node:module").createRequire(import.meta.url)(
+			"quickjs-wasi/package.json",
+		);
+		if (
+			typeof manifest === "object" &&
+			manifest !== null &&
+			"version" in manifest &&
+			typeof manifest.version === "string"
+		)
+			version = manifest.version;
+	} catch {
+		// Reported as "unavailable": the same missing package makes the cell fail with eval_isolate_unavailable.
+	}
+	return { name: "quickjs", version, isolation: "sandbox" };
+}
+
+// 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/cell-source-at-start.ts

@@ -0,0 +1,18 @@
+import type { CellSourceAtStart, EvalKernelRunInput } from "../../tool/types.ts";
+
+/** The run input with its turn-time source applied, or the refusal to settle the cell with. */
+export function inputAtStart<T extends EvalKernelRunInput>(input: T): T | { readonly refused: string } {
+	if (input.resolveAtStart === undefined) return input;
+	let source: CellSourceAtStart;
+	try {
+		source = input.resolveAtStart();
+	} catch (error) {
+		return { refused: error instanceof Error ? error.message : String(error) };
+	}
+	if (!source.ok) return { refused: source.message };
+	return {
+		...input,
+		code: source.code,
+		...(source.sourceFile === undefined ? {} : { sourceFile: source.sourceFile }),
+	};
+}

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 };
+}