@code-yeongyu/senpi-codemode 2026.10.10-4 → 2026.10.10-6

package/src/kernels/js/process-entry.js

@@ -441,7 +441,11 @@ function reportCrash(error) {
 	}
 }
 process.on("uncaughtException", reportCrash);
-process.on("unhandledRejection", reportCrash);
+// Once the worker core is up it reports unhandled rejections to the cells (the kernel keeps running); before that, one
+// is a startup crash.
+process.on("unhandledRejection", (reason) => {
+	if (process.listenerCount("unhandledRejection") === 1) reportCrash(reason);
+});
 
 const cwd = process.env.SENPI_CODEMODE_PROCESS_CWD ?? process.cwd();
 const poolWidth = Number.parseInt(process.env.SENPI_CODEMODE_PROCESS_POOL_WIDTH ?? "1", 10) || 1;

package/src/kernels/js/rejection-reports.js

@@ -0,0 +1,61 @@
+import { cellOfRejection } from "./cell-run-context.js";
+
+const STACK_FRAMES = 3;
+
+// An unhandled rejection is reported, never fatal: the kernel keeps its variables (the Node REPL and Jupyter norm). The
+// report names the cell that started the work when it is known and lands on the cell running now, or on the next one.
+// A burst is folded into one report plus a count, so a stopped loop cannot flood a cell's output.
+export function createRejectionReports({ activeCell, emitText }) {
+	let waiting = null;
+	const shownInCell = new WeakMap();
+
+	function report(reason) {
+		const text = describe(reason, cellOfRejection(reason), activeCell());
+		const cell = activeCell();
+		if (cell === null || cell.released) {
+			if (waiting === null) waiting = { text, more: 0 };
+			else waiting.more++;
+			return;
+		}
+		const shown = shownInCell.get(cell) ?? 0;
+		shownInCell.set(cell, shown + 1);
+		if (shown === 0) emitText(text);
+	}
+
+	return {
+		report,
+		startCell(cell) {
+			if (waiting === null) return;
+			emitText(`${waiting.text}${moreLine(waiting.more)}`);
+			shownInCell.set(cell, 1);
+			waiting = null;
+		},
+		finishCell(cell) {
+			const shown = shownInCell.get(cell) ?? 0;
+			if (shown > 1) emitText(moreLine(shown - 1));
+		},
+	};
+}
+
+function moreLine(more) {
+	return more === 0 ? "" : `... and ${more} more unhandled promise ${more === 1 ? "rejection" : "rejections"}\n`;
+}
+
+function describe(reason, origin, running) {
+	const where =
+		origin === undefined
+			? "(the cell that started it is unknown)"
+			: origin === running && !origin.released
+				? "in this cell"
+				: `from cell ${origin.cellId}${origin.released ? ", after it was stopped" : ""}`;
+	return `Unhandled promise rejection ${where}: ${summary(reason)}\n`;
+}
+
+function summary(reason) {
+	if (!(reason instanceof Error)) return String(reason);
+	const frames = (reason.stack ?? "")
+		.split("\n")
+		.filter((line) => line.trim().startsWith("at "))
+		.slice(0, STACK_FRAMES);
+	return [`${reason.name}: ${reason.message}`, ...frames.map((line) => `    ${line.trim()}`)].join("\n");
+}

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

@@ -1,3 +1,5 @@
+import { installCellOwnership } from "./cell-ownership.js";
+import { releaseCell, releasedCellError, runInCell } from "./cell-run-context.js";
 import { kernelToolCallContext } from "./kernel-tools-context.js";
 import { kernelToolError } from "./kernel-tools-errors.js";
 import { createKernelToolPump } from "./kernel-tools-pump.js";
@@ -5,6 +7,7 @@ import { hostDeniedError, hostToolRefusal } from "./kernel-tools-scope.js";
 import { installSessionCwd } from "./worker-cwd.js";
 import { installPackageResolver } from "./worker-package-resolve.js";
 import { createHeapProbe } from "./worker-heap.js";
+import { createRejectionReports } from "./rejection-reports.js";
 import { createWorkerMemory } from "./worker-memory.js";
 import { JsWorkerRuntime } from "./worker-runtime.js";
 import { installKernelWebView } from "./worker-webview.js";
@@ -29,10 +32,17 @@ const SESSION_ENVIRONMENT_KEYS = [
 ];
 
 export function createWorkerCore(transport, options) {
+	const restoreOwnership = installCellOwnership();
 	let runtime = null;
 	let memory = null;
 	let heapProbe = null;
 	let activeCell = null;
+	const rejections = createRejectionReports({
+		activeCell: () => activeCell,
+		emitText: (data) => emit({ type: "text", stream: "stderr", data }),
+	});
+	const reportRejection = (reason) => rejections.report(reason);
+	process.on("unhandledRejection", reportRejection);
 	const pendingTools = new Map();
 	const pendingWebViewPorts = new Map();
 	const nestedInvokes = new Map();
@@ -46,23 +56,38 @@ export function createWorkerCore(transport, options) {
 		transport.send(message);
 	}
 
+	function stopProblem(cell, what, error) {
+		const detail = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+		emit({ type: "text", stream: "stderr", data: `Stopping cell ${cell.cellId}: ${what}: ${detail}\n` });
+	}
+
 	async function runCell(message) {
 		if (!runtime) {
 			emit({ type: "result", cellId: message.cellId, ok: false, error: { message: "JS runtime not initialized" }, durationMs: 0 });
 			return;
 		}
 		const startedAtMs = performance.now();
-		activeCell = { cellId: message.cellId, interruption: null };
+		const release = Promise.withResolvers();
+		const cell = { cellId: message.cellId, interruption: null, released: false, release: release.reject };
+		activeCell = cell;
+		rejections.startCell(cell);
 		try {
-			const value = await runtime.run(message.code, message.cellId, {
-				emit,
-				callTool: async (toolName, args) => await callTool(toolName, args),
-			});
+			const run = runInCell(cell, () =>
+				runtime.run(message.code, message.cellId, {
+					emit: (event) => {
+						if (releasedCellError() === undefined) emit(event);
+					},
+					callTool: async (toolName, args) => await callTool(toolName, args),
+				}),
+			);
+			const value = await Promise.race([run, release.promise]);
+			rejections.finishCell(cell);
 			emit({ type: "result", cellId: message.cellId, ok: true, valueRepr: valueRepr(value), durationMs: durationMs(startedAtMs), ...memoryReport() });
 		} catch (error) {
+			rejections.finishCell(cell);
 			emit({ type: "result", cellId: message.cellId, ok: false, error: bridgeError(error), durationMs: durationMs(startedAtMs), ...memoryReport() });
 		} finally {
-			activeCell = null;
+			if (activeCell === cell) activeCell = null;
 		}
 	}
 
@@ -71,6 +96,8 @@ export function createWorkerCore(transport, options) {
 	}
 
 	async function callTool(toolName, args) {
+		const released = releasedCellError();
+		if (released !== undefined) throw released;
 		const nested = kernelToolCallContext.getStore();
 		if (!nested && activeCell?.interruption) throw activeCell.interruption;
 		if (nested?.signal.aborted) throw nested.signal.reason;
@@ -105,6 +132,17 @@ export function createWorkerCore(transport, options) {
 		}
 		kernelTools.abortAll(kernelToolError("kernel_tool_stale", interruption.message));
 		runtime.interrupt();
+		// A free event loop with no Bun.$ wait can let the cell go and keep the VM. A Bun.$ wait keeps the
+		// restart (#2453): the shell cannot be cancelled, so only retiring the worker ends it.
+		if (runtime.shellWaitActive) return;
+		const cell = activeCell;
+		for (const error of releaseCell(cell)) stopProblem(cell, "a resource it opened would not close", error);
+		// The result settles after the cell's children are gone, so the next cell never overlaps them. A failed release
+		// is reported as such, never left to surface as an unhandled rejection blamed on the stopped cell.
+		void runtime
+			.release()
+			.catch((error) => stopProblem(cell, "releasing its work failed", error))
+			.finally(() => cell.release(interruption));
 	}
 
 	function acknowledgeInterrupt() {
@@ -186,6 +224,8 @@ export function createWorkerCore(transport, options) {
 	return {
 		dispose() {
 			unsubscribe();
+			restoreOwnership();
+			process.off("unhandledRejection", reportRejection);
 			globalThis.__senpi_restore_console__?.();
 		},
 	};

package/src/kernels/js/worker-indirect-eval.js

@@ -1,4 +1,13 @@
-import { findShadowedGlobalName } from "./worker-shadow-guard.js";
+import { isKernelGlobal } from "./worker-shadow-guard.js";
+
+// A cell may declare a name the kernel or the platform already defines (`const log = []`, `const fetch = ...`). The
+// binding lives in a per-kernel user scope that later cells read through `with`, so it persists for the user's cells
+// while the kernel, its prelude and imported libraries keep the original global. `delete <name>` in a cell restores it.
+const USER_SCOPE_KEY = Symbol.for("senpi.kernel.userScope");
+const USER_SCOPE = "__senpiUserScope";
+// The persistence rewrite itself writes through `globalThis`, so that one name cannot be shadowed.
+const UNSHADOWABLE = new Set(["globalThis"]);
+let shadowedNames = null;
 
 export function indirectEval(source, filename) {
 	const withPragma = filename ? `${source}\n//# sourceURL=${filename}` : source;
@@ -11,10 +20,31 @@ export async function awaitMaybePromise(value) {
 	return await value;
 }
 
-export function wrapUserCode(code) {
-	const persistentCode = persistTopLevelDeclarations(code);
-	if (scanTopLevelStatements(persistentCode).hasTopLevelReturn) return `(async () => {\n${persistentCode}\n})()`;
-	return `(async () => {\n${captureLastExpression(persistentCode)}\n})()`;
+/** Wraps a cell for persistent evaluation; `shadowed` receives the kernel-global names the cell declares. */
+export function wrapUserCode(code, shadowed = []) {
+	shadowedNames = shadowed;
+	let persistentCode;
+	try {
+		persistentCode = persistTopLevelDeclarations(code);
+	} finally {
+		shadowedNames = null;
+	}
+	const body = scanTopLevelStatements(persistentCode).hasTopLevelReturn ? persistentCode : captureLastExpression(persistentCode);
+	const scope = globalThis[USER_SCOPE_KEY];
+	if (shadowed.length === 0 && (scope === undefined || Object.keys(scope).length === 0)) return `(async () => {\n${body}\n})()`;
+	globalThis[USER_SCOPE_KEY] ??= Object.create(null);
+	return `(async (${USER_SCOPE}) => { with (${USER_SCOPE}) { return await (async () => {\n${body}\n})(); } })(globalThis[Symbol.for("senpi.kernel.userScope")])`;
+}
+
+function persistTarget(name) {
+	if (UNSHADOWABLE.has(name)) {
+		throw new Error(
+			`eval cell declares top-level \`${name}\`, which the JS kernel needs to keep cell variables between cells. Rename the binding (for example \`${name}Local\`).`,
+		);
+	}
+	if (!isKernelGlobal(name)) return `globalThis[${JSON.stringify(name)}]`;
+	if (shadowedNames !== null && !shadowedNames.includes(name)) shadowedNames.push(name);
+	return `${USER_SCOPE}[${JSON.stringify(name)}]`;
 }
 
 const IDENTIFIER_START_RE = /[$_\p{ID_Start}]/u;
@@ -267,14 +297,8 @@ function rewriteDeclaration(code, declarationStart, start, end, keyword) {
 		const bindings = [];
 		collectPatternNames(pattern, bindings);
 		if (bindings.length === 0) return undefined;
-		const shadowed = findShadowedGlobalName(bindings);
-		if (shadowed !== undefined) {
-			throw new Error(
-				`eval cell declares top-level \`${shadowed}\`, but a global with that name already exists in the JS kernel. Persisting it would replace that global for every later cell. Rename the binding (for example \`${shadowed}Local\`), or assign globalThis.${shadowed} explicitly if replacing it is truly intended.`,
-			);
-		}
 		if (preserveDeclaration) {
-			for (const name of bindings) assignments.push(`globalThis[${JSON.stringify(name)}] = ${name};`);
+			for (const name of bindings) assignments.push(`${persistTarget(name)} = ${name};`);
 			continue;
 		}
 		const target = rewriteBindingPattern(pattern);
@@ -296,7 +320,7 @@ function rewriteBindingPattern(source) {
 		const target = rewriteBindingPattern(pattern.slice(0, defaultStart));
 		return target === undefined ? undefined : `${target} = ${pattern.slice(defaultStart + 1).trim()}`;
 	}
-	if (IDENTIFIER_RE.test(pattern)) return `globalThis[${JSON.stringify(pattern)}]`;
+	if (IDENTIFIER_RE.test(pattern)) return persistTarget(pattern);
 	if (pattern.startsWith("{") && pattern.endsWith("}")) {
 		const properties = splitPatternElements(pattern.slice(1, -1)).map((property) => rewriteObjectBinding(property));
 		if (properties.some((property) => property === undefined)) return undefined;

package/src/kernels/js/worker-require.d.ts

@@ -0,0 +1,19 @@
+export interface CellRequireContext {
+	readonly cwdUrl: string;
+	readonly packageRootUrl?: string | null;
+}
+
+export interface CellResolve {
+	(specifier: string, options?: { readonly paths?: readonly string[] }): string;
+	paths(specifier: string): string[] | null;
+}
+
+export interface CellRequire {
+	(specifier: string): unknown;
+	readonly resolve: CellResolve;
+	readonly cache: Record<string, unknown>;
+}
+
+export function createCellRequire(context: () => CellRequireContext): CellRequire;
+
+export { createRequire } from "node:module";

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

@@ -0,0 +1,52 @@
+import { createRequire, isBuiltin } from "node:module";
+
+// `require` in a cell resolves the way `import` does there: builtins natively, relative paths from the cell's
+// directory, bare packages from the session's project first and then its managed package environment
+// (%bun add / %npm add). It uses the runtime's own CommonJS loader, so JSON files and the `require` export conditions
+// behave as in Node. Like Node's own `require`, it carries `resolve`, `resolve.paths` and `cache`.
+export function createCellRequire(context) {
+	const requirers = () => {
+		const { cwdUrl, packageRootUrl } = context();
+		const fromCwd = createRequire(new URL("package.json", cwdUrl));
+		const fromPackages = packageRootUrl ? createRequire(new URL("package.json", packageRootUrl)) : undefined;
+		return { fromCwd, fromPackages };
+	};
+	const isPathLike = (name) => name.startsWith(".") || name.startsWith("/") || /^[A-Za-z]:[\\/]/.test(name);
+	// The one lookup both the call and `resolve` use, so they can never pick different copies of a package. Builtins
+	// (`fs`, `node:fs`, Bun's `bun:sqlite`) and paths resolve natively; a bare name the project does not have falls
+	// back to the managed environment, and a miss there reports the project's own not-found error.
+	const resolve = function resolve(specifier, options) {
+		const name = String(specifier);
+		const { fromCwd, fromPackages } = requirers();
+		if (isBuiltin(name) || isPathLike(name) || fromPackages === undefined || options?.paths !== undefined) {
+			return fromCwd.resolve(name, options);
+		}
+		try {
+			return fromCwd.resolve(name, options);
+		} catch (error) {
+			if (error?.code !== "MODULE_NOT_FOUND") throw error;
+			try {
+				return fromPackages.resolve(name, options);
+			} catch (fallback) {
+				throw fallback?.code === "MODULE_NOT_FOUND" ? error : fallback;
+			}
+		}
+	};
+	resolve.paths = (specifier) => {
+		const name = String(specifier);
+		const { fromCwd, fromPackages } = requirers();
+		const own = fromCwd.resolve.paths(name);
+		if (own === null || fromPackages === undefined || isPathLike(name)) return own;
+		return [...new Set([...own, ...(fromPackages.resolve.paths(name) ?? [])])];
+	};
+	// The call loads exactly what `resolve` names: a builtin id or an absolute file, through the runtime's loader.
+	const require = function require(specifier) {
+		return requirers().fromCwd(resolve(specifier));
+	};
+	require.resolve = resolve;
+	// One CommonJS cache per runtime: the cell's view is the loader's own, so deleting an entry forces a reload.
+	Object.defineProperty(require, "cache", { enumerable: true, get: () => createRequire(import.meta.url).cache });
+	return require;
+}
+
+export { createRequire };

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

@@ -1,4 +1,6 @@
 // allow: SIZE_OK — private runtime state and installed globals must stay in one worker module.
+import { pathToFileURL } from "node:url";
+import { createCellRequire, createRequire } from "./worker-require.js";
 import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join, normalize, resolve, sep } from "node:path";
 import { inspect } from "node:util";
@@ -31,6 +33,7 @@ export class JsWorkerRuntime {
 	#hooks = null;
 	#pendingDisplays = [];
 	#children = new Set();
+	#childrenStopping;
 	#shellWaits = new Set();
 	#onChildEvent;
 	#onShellWaitChange;
@@ -74,24 +77,35 @@ export class JsWorkerRuntime {
 				if (typeof prepared.sourceFile === "string") sourceName = prepared.sourceFile;
 			}
 			if (prelude) indirectEval(prelude, PRELUDE_SOURCE_URL);
-			const value = await awaitMaybePromise(indirectEval(bindKernelBun(wrapUserCode(cellCode)), sourceName));
+			const shadowed = [];
+			const source = bindKernelBun(wrapUserCode(cellCode, shadowed));
+			if (shadowed.length > 0) this.#emitText("stderr", shadowNote(shadowed));
+			const value = await awaitMaybePromise(indirectEval(source, sourceName));
 			await this.#drainPendingDisplays();
 			return value;
 		} finally {
-			this.#pendingDisplays = [];
-			// A child still running here has lost its only owner: the cell that
-			// spawned it is over, nothing will await it again, and it would be
-			// reparented to init. Retire it the way timeout and abort cleanup
-			// already do, unless the cell asked for a detached process.
-			await this.#terminateChildren();
-			this.#hooks = null;
+			// A released run finishing late must not clear the state of the cell running now.
+			if (this.#hooks === hooks) await this.release();
 		}
 	}
 
+	/** Ends the current run's ownership now: its displays, its hooks, and (unless detached) its child processes. */
+	async release() {
+		const hooks = this.#hooks;
+		this.#pendingDisplays = [];
+		// A child still running here has lost its only owner: the cell that
+		// spawned it is over, nothing will await it again, and it would be
+		// reparented to init. Retire it the way timeout and abort cleanup
+		// already do, unless the cell asked for a detached process.
+		await Promise.all([this.#childrenStopping, this.#terminateChildren()]);
+		this.#childrenStopping = undefined;
+		if (this.#hooks === hooks) this.#hooks = null;
+	}
+
 	interrupt() {
 		// The tree snapshot, SIGTERM, and SIGKILL escalation run on their own so
 		// the caller's interrupt latency stays that of the acknowledgement.
-		void this.#terminateChildren();
+		this.#childrenStopping = this.#terminateChildren();
 	}
 
 	#trackChild(child, spawnOptions) {
@@ -155,6 +169,8 @@ export class JsWorkerRuntime {
 			{ defined: () => this.#tools.defined(), undefine: (name) => this.#tools.undefine(name) },
 		);
 		globalThis.tools = globalThis.tool;
+		globalThis.require = createCellRequire(() => globalThis.__senpi_module_context__ ?? { cwdUrl: pathToFileURL(`${process.cwd()}/`).href });
+		globalThis.createRequire = createRequire;
 		const originalLog = console.log.bind(console);
 		const originalError = console.error.bind(console);
 		const originalStdoutWrite = process.stdout.write;
@@ -423,6 +439,12 @@ export class JsWorkerRuntime {
 	}
 }
 
+function shadowNote(names) {
+	const list = names.map((name) => `\`${name}\``).join(", ");
+	const restore = names.map((name) => `delete ${name}`).join("; ");
+	return `Note: ${list} ${names.length === 1 ? "shadows a kernel or platform global" : "shadow kernel or platform globals"} in your later cells; the kernel and imported libraries keep the original. \`${restore}\` restores ${names.length === 1 ? "it" : "them"}.\n`;
+}
+
 function isPlainObject(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value);
 }

package/src/kernels/js/worker-shadow-guard.js

@@ -12,10 +12,6 @@ function protectedGlobals() {
 	return protectedGlobalNames;
 }
 
-export function findShadowedGlobalName(bindings) {
-	const names = protectedGlobals();
-	for (const name of bindings) {
-		if (names.has(name)) return name;
-	}
-	return undefined;
+export function isKernelGlobal(name) {
+	return protectedGlobals().has(name);
 }

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

@@ -1,3 +1,5 @@
+import { assertCellLive } from "./cell-run-context.js";
+
 const SHELL_CONFIG_METHODS = ["env", "cwd", "nothrow", "throws"];
 const SHELL_READ_METHODS = ["text", "json", "lines", "arrayBuffer", "bytes", "blob"];
 // `true | ( … )` hands every command in the template an empty pipe as stdin. The worker thread shares
@@ -39,6 +41,7 @@ function isBunRuntime(bun) {
 
 function capturedShell(originalShell, options) {
 	const shell = (strings, ...expressions) => {
+		assertCellLive();
 		if (!options.isActive()) return originalShell(strings, ...expressions);
 		const promise = originalShell(isolateStdin(strings), ...expressions);
 		return captureShellPromise(promise, options);
@@ -132,6 +135,7 @@ function outputText(value) {
 // without an explicit env must get the worker's view pinned too (measured on Bun 1.4.0).
 function capturedSpawnSync(originalSpawnSync, pinEnv) {
 	return (...args) => {
+		assertCellLive();
 		if (!pinEnv) return originalSpawnSync(...args);
 		const [first, second] = args;
 		if (Array.isArray(first)) {
@@ -148,6 +152,7 @@ function capturedSpawnSync(originalSpawnSync, pinEnv) {
 
 function capturedSpawn(originalSpawn, options, pinEnv) {
 	return (...args) => {
+		assertCellLive();
 		if (!options.isActive()) return originalSpawn(...args);
 		const [first, second] = args;
 		let child;

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

@@ -1,3 +1,4 @@
+import { onCellRelease } from "./cell-run-context.js";
 import { DELIVER_EVENT, WebViewPortClient, webViewError } from "./worker-webview-client.js";
 
 // Bun constructs "chrome"-backend WebViews only on the process main thread, and this kernel runs in
@@ -90,13 +91,16 @@ function createKernelWebView(NativeWebView, requestPort) {
 		#console;
 		#ready;
 		#closed = false;
+		#forgetRelease;
 		onNavigated = null;
 		onNavigationFailed = null;
 
 		constructor(options = {}) {
 			if (!needsMainThread(options)) {
 				const view = new NativeWebView(options);
-				natives.add(new WeakRef(view));
+				const ref = new WeakRef(view);
+				natives.add(ref);
+				onCellRelease(() => ref.deref()?.close());
 				return view;
 			}
 			super();
@@ -104,6 +108,7 @@ function createKernelWebView(NativeWebView, requestPort) {
 			this.#console = capture;
 			proxied.add(this);
 			live.add(this);
+			this.#forgetRelease = onCellRelease(() => this.close());
 			const viewId = this.#viewId;
 			this.#ready = connect().then(async client => {
 				client.register(viewId, this);
@@ -157,6 +162,7 @@ function createKernelWebView(NativeWebView, requestPort) {
 		close() {
 			if (this.#closed) return;
 			this.#closed = true;
+			this.#forgetRelease?.();
 			live.delete(this);
 			const viewId = this.#viewId;
 			this.#ready.then(

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

@@ -1,5 +1,6 @@
 import type { AgentToolResult } from "@code-yeongyu/senpi";
 import type { WakeSourceState } from "../extension/wake-source-state.ts";
+import type { EvalImageContent } from "./image-resize.ts";
 import type { EvalLanguage, EvalToolDetails } from "./types.ts";
 
 export type EvalDetachedCellState = "queued" | "running" | "detached" | "completed" | "failed" | "cancelled";
@@ -24,6 +25,8 @@ export interface EvalDetachedCellSnapshot {
 export interface EvalDetachedCellNotification {
 	readonly cellId: string;
 	readonly content: string;
+	/** Images the cell displayed, delivered with the notification the way a foreground result delivers them. */
+	readonly images?: readonly EvalImageContent[];
 }
 
 export interface EvalDetachedCellNotifier {

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

@@ -36,7 +36,6 @@ export type {
 } from "./detached-cell-contract.ts";
 
 export class EvalDetachedCellManager {
-	readonly #artifactsDir: string | undefined;
 	readonly #onStatusChange: ((entries: readonly EvalDetachedCellStatusEntry[]) => void) | undefined;
 	readonly #onWakeSourceState: ((state: WakeSourceState) => void) | undefined;
 	readonly #cells = new Map<string, ManagedCell>();
@@ -49,7 +48,6 @@ export class EvalDetachedCellManager {
 	readonly #maxDetachedCells: number;
 
 	constructor(options: EvalDetachedCellManagerOptions = {}) {
-		this.#artifactsDir = options.artifactsDir;
 		this.#onStatusChange = options.onStatusChange;
 		this.#onWakeSourceState = options.onWakeSourceState;
 		this.#notificationQueue = new DetachedNotificationQueue(options.notifier);
@@ -85,7 +83,6 @@ export class EvalDetachedCellManager {
 		const cell = createManagedCell({
 			cellId,
 			input,
-			artifactsDir: this.#artifactsDir,
 			now: this.#now,
 			defaultHardLimitSeconds: this.#hardLimitSeconds,
 			defaultRunBudgetSeconds: this.#runBudgetSeconds,
@@ -239,7 +236,6 @@ export class EvalDetachedCellManager {
 						await cell.interruptOutcome?.promise;
 						return this.#snapshot(cell);
 					},
-					spillPath: cell.spillPath,
 				});
 			}
 		}

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

@@ -1,61 +1,21 @@
-import { mkdir, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
 import type { EvalDetachedCellNotification, EvalDetachedCellSnapshot } from "./detached-cell-manager.ts";
 import { interruptionStateNote, unknownInterruptionStateNote } from "./interrupt-note.ts";
 import type { EvalKernelState, EvalMemoryDetails } from "./types.ts";
 
-const NOTIFICATION_TAIL_BYTES = 512;
-
-export function detachedNotificationSpillPath(artifactsDir: string | undefined, cellId: string): string | undefined {
-	if (artifactsDir === undefined) return undefined;
-	return join(artifactsDir, "local", `detached-eval-${safeCellId(cellId)}.log`);
-}
-
-export async function buildDetachedCellNotification(
-	snapshot: EvalDetachedCellSnapshot,
-	spillPath: string | undefined,
-): Promise<EvalDetachedCellNotification> {
-	const body = notificationBody(snapshot);
-	const overflow = Buffer.byteLength(body, "utf8") > NOTIFICATION_TAIL_BYTES;
-	let spillNotice = "";
-	if (overflow && spillPath !== undefined) {
-		try {
-			await mkdir(dirname(spillPath), { recursive: true });
-			await writeFile(spillPath, body, "utf8");
-			// The agent read tool resolves plain paths only, so the notice must carry
-			// the absolute spill path, never the kernel-helper local:// scheme.
-			spillNotice = `\nBuffered output overflowed; full output: ${spillPath}`;
-		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			spillNotice = `\nBuffered output overflow could not be spilled: ${message}`;
-		}
-	}
-	return {
-		cellId: snapshot.cellId,
-		content: `${overflow ? notificationPreview(snapshot) : body}${overflow ? "\n[…notification tail capped…]" : ""}${spillNotice}`,
-	};
-}
-
-function notificationBody(cell: EvalDetachedCellSnapshot): string {
-	const outcome = outcomeOf(cell);
-	const resultText = textContent(cell);
-	const stateNote = stateNoteOf(cell);
-	return [
-		`<system-reminder>Detached eval cell ${cell.cellId} (${cell.language}) ${outcome}.`,
-		resultText.length === 0 ? "(no output)" : resultText,
-		`${stateNote}</system-reminder>`,
-	].join("\n");
+/**
+ * A detached cell's completion carries the same text its result would have shown in the foreground: the output sink
+ * already bounded it (the configured head, the tail, the middle marker and the artifact notice), plus its images.
+ */
+export function buildDetachedCellNotification(snapshot: EvalDetachedCellSnapshot): EvalDetachedCellNotification {
+	const images = snapshot.result.content.filter((part) => part.type === "image");
+	return { cellId: snapshot.cellId, content: notificationText(snapshot, textContent(snapshot)), images };
 }
 
-function notificationPreview(cell: EvalDetachedCellSnapshot): string {
-	const outcome = outcomeOf(cell);
-	const resultText = textContent(cell);
-	const stateNote = stateNoteOf(cell);
+function notificationText(cell: EvalDetachedCellSnapshot, output: string): string {
 	return [
-		`<system-reminder>Detached eval cell ${cell.cellId} (${cell.language}) ${outcome}.`,
-		"Buffered output tail:",
-		truncateTailUtf8(resultText, NOTIFICATION_TAIL_BYTES),
-		`${stateNote}</system-reminder>`,
+		`<system-reminder>Detached eval cell ${cell.cellId} (${cell.language}) ${outcomeOf(cell)}.`,
+		output.length === 0 ? "(no output)" : output,
+		`${stateNoteOf(cell)}</system-reminder>`,
 	].join("\n");
 }
 
@@ -101,15 +61,3 @@ export function memoryStateNote(memory: EvalMemoryDetails | undefined): string {
 		return "The kernel was restarted before this cell ran - globals from earlier cells are gone; this cell's variables are available to the next eval cell.";
 	return "Kernel state updated - variables are available to the next eval cell.";
 }
-
-function safeCellId(cellId: string): string {
-	return cellId.replace(/[^a-zA-Z0-9_-]/gu, "_");
-}
-
-function truncateTailUtf8(text: string, maxBytes: number): string {
-	if (Buffer.byteLength(text, "utf8") <= maxBytes) return text;
-	const bytes = Buffer.from(text, "utf8");
-	let start = bytes.length - maxBytes;
-	while (start < bytes.length && (bytes[start] & 0xc0) === 0x80) start++;
-	return bytes.subarray(start).toString("utf8");
-}

package/src/tool/detached-notification-queue.ts

@@ -3,7 +3,6 @@ import { buildDetachedCellNotification } from "./detached-cell-notification.ts";
 
 export interface PendingDetachedNotification {
 	readonly snapshot: () => EvalDetachedCellSnapshot | Promise<EvalDetachedCellSnapshot>;
-	readonly spillPath: string | undefined;
 }
 
 export class DetachedNotificationQueue {
@@ -30,7 +29,7 @@ export class DetachedNotificationQueue {
 		const flush = Promise.resolve().then(async () => {
 			const pending = this.#pending.splice(0);
 			const notifications = await Promise.all(
-				pending.map(async (item) => await buildDetachedCellNotification(await item.snapshot(), item.spillPath)),
+				pending.map(async (item) => buildDetachedCellNotification(await item.snapshot())),
 			);
 			this.#notifier?.notify(notifications);
 		});