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

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

@@ -8,9 +8,9 @@
  *   Windows has no process groups; this is the interpreter itself when it is launched directly.
  * - anything else, or Windows under Node: `undefined`, and the caller treats the CPU as unknown.
  */
+import { type BunFfi, loadBunFfi } from "./bun-ffi.ts";
 import { readProcessGroupCpuTime } from "./process-group-cpu.ts";
 
-type BunFfi = typeof import("bun:ffi");
 type CpuReader = (pid: number) => bigint | undefined;
 
 const PROCESS_QUERY_LIMITED_INFORMATION = 0x1000;
@@ -26,7 +26,7 @@ export function readKernelCpuTime(pid: number): bigint | undefined {
 }
 
 function createWindowsReader(): CpuReader | undefined {
-	const ffi = process.getBuiltinModule("bun:ffi") as BunFfi | undefined;
+	const ffi = loadBunFfi();
 	if (ffi === undefined) return undefined;
 	try {
 		return bindGetProcessTimes(ffi);
@@ -37,7 +37,11 @@ function createWindowsReader(): CpuReader | undefined {
 }
 
 function bindGetProcessTimes({ dlopen, FFIType, ptr }: BunFfi): CpuReader {
-	const library = dlopen("kernel32.dll", {
+	const library = dlopen<{
+		OpenProcess: (access: number, inheritHandle: number, pid: number) => number | null;
+		GetProcessTimes: (handle: number, create: number, exit: number, kernel: number, user: number) => number;
+		CloseHandle: (handle: number) => number;
+	}>("kernel32.dll", {
 		OpenProcess: { args: [FFIType.u32, FFIType.i32, FFIType.u32], returns: FFIType.ptr },
 		GetProcessTimes: {
 			args: [FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr],

package/src/kernels/shared/process-group-cpu.ts

@@ -15,8 +15,8 @@
  */
 import { execFileSync } from "node:child_process";
 import { readdirSync, readFileSync } from "node:fs";
+import { type BunFfi, loadBunFfi } from "./bun-ffi.ts";
 
-type BunFfi = typeof import("bun:ffi");
 type GroupCpuReader = (pgid: number) => bigint | undefined;
 
 const RUSAGE_INFO_V2 = 2;
@@ -59,7 +59,7 @@ export function parsePsCpuTime(text: string): bigint | undefined {
 function createGroupReader(): GroupCpuReader | undefined {
 	if (process.platform === "linux") return linuxGroupReader;
 	if (process.platform !== "darwin") return undefined;
-	const ffi = process.getBuiltinModule("bun:ffi") as BunFfi | undefined;
+	const ffi = loadBunFfi();
 	if (ffi === undefined) return darwinPsGroupReader;
 	try {
 		return darwinGroupReader(ffi);
@@ -116,7 +116,10 @@ function linuxGroupReader(pgid: number): bigint | undefined {
 }
 
 function darwinGroupReader({ dlopen, FFIType, ptr }: BunFfi): GroupCpuReader {
-	const library = dlopen("libSystem.B.dylib", {
+	const library = dlopen<{
+		proc_listpgrppids: (pgid: number, buffer: number, byteLength: number) => number;
+		proc_pid_rusage: (pid: number, flavor: number, buffer: number) => number;
+	}>("libSystem.B.dylib", {
 		proc_listpgrppids: { args: [FFIType.i32, FFIType.ptr, FFIType.i32], returns: FFIType.i32 },
 		proc_pid_rusage: { args: [FFIType.i32, FFIType.i32, FFIType.ptr], returns: FFIType.i32 },
 	});

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

@@ -1,3 +1,4 @@
+// allow: SIZE_OK — subprocess protocol, FIFO ownership, retirement, and replacement form one serialized state machine.
 import type { HostToKernelMessage, KernelToHostMessage } from "../../bridge/protocol.ts";
 import { decodeBridgeFrame, encodeBridgeFrame, isKernelToHostMessage } from "../../bridge/protocol.ts";
 import type { KernelInterruptHandle, PendingCell } from "../../tool/types.ts";
@@ -7,6 +8,7 @@ import { applySessionEnvironment } from "../session-env.ts";
 import { describeExit } from "./kernel-death.ts";
 import { KernelMemoryHost } from "./kernel-memory-host.ts";
 import type { KernelResult, KernelRunInput, SubprocessKernelOptions, ToolCallMessage } from "./subprocess-contract.ts";
+import { SubprocessMemoryGlobals } from "./subprocess-memory-globals.ts";
 import { type SubprocessLike, SubprocessProcess, type SubprocessSpawn, spawnSubprocess } from "./subprocess-process.ts";
 import { SubprocessRunQueue } from "./subprocess-queue.ts";
 import {
@@ -39,6 +41,7 @@ export class SubprocessKernel {
 	private readonly onMessage?: (message: KernelToHostMessage) => void;
 	private readonly runs = new SubprocessRunQueue();
 	private readonly memory: KernelMemoryHost | null;
+	private readonly globals = new SubprocessMemoryGlobals();
 	private process: SubprocessProcess | null = null;
 	private processReady = false;
 	private startup: SubprocessStartupWatchdog | null = null;
@@ -90,8 +93,10 @@ export class SubprocessKernel {
 			this.runs.settleAll(new CellInterruptedError(reason));
 			return { stateRetained: Promise.resolve(true) };
 		}
+		if (this.globals.completeWithoutGlobals()) return { stateRetained: Promise.resolve(true) };
 		const process = this.process;
 		process?.retire();
+		this.globals.reset();
 		this.runs.clearToolCalls();
 		const run = this.runs.active;
 		if (!run) return { stateRetained: Promise.resolve(true) };
@@ -126,6 +131,7 @@ export class SubprocessKernel {
 
 	async reset(): Promise<void> {
 		if (this.closed) throw new KernelClosedError();
+		this.globals.reset();
 		this.settleAll(new KernelResetError());
 		this.runs.clearToolCalls();
 		await this.restartProcess(this.process);
@@ -135,6 +141,7 @@ export class SubprocessKernel {
 	async close(): Promise<void> {
 		const wasClosed = this.closed;
 		this.closed = true;
+		this.globals.reset();
 		this.startup?.stop();
 		if (!wasClosed) {
 			this.settleAll(new KernelClosingError());
@@ -175,6 +182,7 @@ export class SubprocessKernel {
 		if (this.runs.active !== run || run.settled) return;
 		const process = this.process;
 		process?.retire();
+		this.globals.reset();
 		this.runs.clearToolCalls();
 		this.runs.releaseActive(run);
 		this.runs.settle(run, timeoutResult(run, timeoutMs));
@@ -199,6 +207,7 @@ export class SubprocessKernel {
 			},
 		});
 		this.process = process;
+		this.globals.reset();
 		this.processReady = false;
 		this.startup?.stop();
 		const startup = this.options.startup;
@@ -237,6 +246,7 @@ export class SubprocessKernel {
 		if (!this.accepts(process)) return;
 		if (!this.processReady) this.startup?.observe(message);
 		if (message.type === "ready") {
+			this.globals.reset(message.memoryGlobals === true);
 			this.startup?.stop();
 			this.processReady = true;
 			this.runs.handleMessage(message, this.onMessage);
@@ -248,9 +258,23 @@ export class SubprocessKernel {
 			this.failClosed(new KernelStartupError(message.error.message));
 			return;
 		}
-		const ownResult = message.type === "result" && this.runs.active?.input.cellId === message.cellId;
-		const settled = ownResult && this.memory ? this.memory.annotate(message, process.child.pid) : message;
-		if (!this.runs.handleMessage(settled, this.onMessage)) return;
+		const run = this.runs.active;
+		if (message.type === "memory-globals-result") {
+			if (this.memory) this.globals.reply({ process, run }, message, this.memory);
+			return;
+		}
+		if (message.type === "result" && run?.input.cellId === message.cellId && this.memory) {
+			this.globals.request({ process, run, result: message }, this.memory, (result) => {
+				if (!this.accepts(process) || this.runs.active !== run || run.settled) return;
+				this.settleMessage(result);
+			});
+			return;
+		}
+		this.settleMessage(message);
+	}
+
+	private settleMessage(message: KernelToHostMessage): void {
+		if (!this.runs.handleMessage(message, this.onMessage)) return;
 		this.pumpRuns();
 		this.recycleOverCeilingWhenIdle();
 	}
@@ -270,6 +294,7 @@ export class SubprocessKernel {
 			return;
 		}
 		this.process = null;
+		this.globals.reset();
 		this.processReady = false;
 		const error = new KernelExitedError(signal ?? code ?? "unknown");
 		if (this.options.onDeath) this.die(error, describeExit(code, signal), this.options.onDeath);
@@ -362,6 +387,7 @@ export class SubprocessKernel {
 
 	private failClosed(error: Error): void {
 		this.startup?.stop();
+		this.globals.reset();
 		const process = this.process;
 		this.failure = error;
 		this.closed = true;

package/src/kernels/shared/subprocess-memory-globals.ts

@@ -0,0 +1,101 @@
+import type { KernelMemoryReport } from "../../bridge/memory-protocol.ts";
+import { encodeBridgeFrame, type KernelToHostMessage } from "../../bridge/protocol.ts";
+import type { KernelMemoryHost } from "./kernel-memory-host.ts";
+import type { KernelResult } from "./subprocess-contract.ts";
+import type { SubprocessProcess } from "./subprocess-process.ts";
+import type { PendingRun } from "./subprocess-run.ts";
+
+const GLOBALS_TIMEOUT_MS = 5_000;
+type GlobalsProcess = Pick<SubprocessProcess, "send"> & {
+	readonly child: { readonly pid?: number };
+};
+
+interface PendingGlobals {
+	readonly process: GlobalsProcess;
+	readonly run: PendingRun;
+	readonly result: KernelResult;
+	readonly report: KernelMemoryReport;
+	readonly memory: KernelMemoryHost;
+	readonly finish: (result: KernelResult) => void;
+	readonly timer: ReturnType<typeof setTimeout>;
+}
+
+/** Holds FIFO cell ownership until its bounded diagnostic is returned or its deadline expires. */
+export class SubprocessMemoryGlobals {
+	#pending: PendingGlobals | null = null;
+	#available = false;
+
+	reset(available = false): void {
+		if (this.#pending !== null) clearTimeout(this.#pending.timer);
+		this.#pending = null;
+		this.#available = available;
+	}
+
+	request(
+		owner: {
+			readonly process: GlobalsProcess;
+			readonly run: PendingRun;
+			readonly result: KernelResult;
+		},
+		memory: KernelMemoryHost,
+		finish: (result: KernelResult) => void,
+	): void {
+		if (this.#pending !== null) return;
+		const report = memory.readReport(owner.result, owner.process.child.pid);
+		if (!this.#available || report === undefined || !memory.needsGlobals(report)) {
+			finish(memory.annotateReport(owner.result, report));
+			return;
+		}
+		const pending: PendingGlobals = {
+			...owner,
+			report,
+			memory,
+			finish,
+			timer: setTimeout(() => {
+				if (this.#pending !== pending) return;
+				this.#pending = null;
+				pending.finish(memory.annotateReport(pending.result, report));
+			}, GLOBALS_TIMEOUT_MS),
+		};
+		this.#pending = pending;
+		owner.process.send(
+			encodeBridgeFrame({
+				type: "memory-globals",
+				cellId: owner.result.cellId,
+			}),
+		);
+	}
+
+	/** Settles an already-finished cell immediately when stop arrives during its optional diagnostic. */
+	completeWithoutGlobals(): boolean {
+		const pending = this.#pending;
+		if (pending === null) return false;
+		clearTimeout(pending.timer);
+		this.#pending = null;
+		pending.finish(pending.memory.annotateReport(pending.result, pending.report));
+		return true;
+	}
+
+	reply(
+		owner: {
+			readonly process: GlobalsProcess;
+			readonly run: PendingRun | null;
+		},
+		message: Extract<KernelToHostMessage, { type: "memory-globals-result" }>,
+		memory: KernelMemoryHost,
+	): void {
+		const pending = this.#pending;
+		if (
+			pending === null ||
+			pending.process !== owner.process ||
+			pending.run !== owner.run ||
+			pending.result.cellId !== message.cellId
+		)
+			return;
+		clearTimeout(pending.timer);
+		this.#pending = null;
+		const report = message.globals.length === 0 ? pending.report : { ...pending.report, globals: message.globals };
+		const result = memory.annotateReport(pending.result, report);
+		pending.finish(result);
+	}
+}

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

@@ -1,9 +1,13 @@
 import { spawn as nodeSpawn } from "node:child_process";
 import { createInterface, type Interface as ReadlineInterface } from "node:readline";
+import { killWindowsTree } from "../js/windows-tree-kill-host.ts";
 
 export interface SubprocessLike {
 	readonly pid?: number;
-	readonly stdin: { write(chunk: string): unknown };
+	readonly stdin: {
+		write(chunk: string): unknown;
+		on?(event: "error", listener: (error: Error) => void): unknown;
+	};
 	readonly stdout: NodeJS.ReadableStream;
 	readonly stderr: NodeJS.ReadableStream;
 	on(event: "error", listener: (error: Error) => void): this;
@@ -46,11 +50,13 @@ export class SubprocessProcess {
 	private readonly stdoutReader: ReadlineInterface;
 	private readonly stderrListener: (chunk: string | Buffer) => void;
 	private readonly errorListener: (error: Error) => void;
+	private readonly stdinErrorListener: (error: Error) => void;
 	private exited = false;
 	private retiring = false;
 	private outputDetached = false;
 	private errorReported = false;
 	private terminationPromise: Promise<boolean> | null = null;
+	private windowsTreeKill: Promise<void> | undefined;
 
 	constructor(child: SubprocessLike, handlers: SubprocessProcessHandlers) {
 		this.child = child;
@@ -67,8 +73,16 @@ export class SubprocessProcess {
 		this.stdoutReader.on("line", (line) => {
 			if (!this.retiring) this.handlers.onLine(this, `${line}\n`);
 		});
+		// senpi#3016: a frame written while the child is dying fails on the stdin stream (EPIPE), which emits there
+		// and not on the ChildProcess. Unhandled, it is a process-level error that can end the host; once the child is
+		// gone or being retired the write failure carries no news, otherwise it is this process's error.
+		this.stdinErrorListener = (error) => {
+			if (this.exited || this.retiring) return;
+			this.errorListener(error);
+		};
 		child.stderr.on("data", this.stderrListener);
 		child.on("error", this.errorListener);
+		child.stdin.on?.("error", this.stdinErrorListener);
 		child.once("exit", (code, signal) => {
 			this.exited = true;
 			this.detachOutput();
@@ -83,7 +97,7 @@ export class SubprocessProcess {
 	}
 
 	send(frame: string): boolean {
-		if (this.retiring) return false;
+		if (this.retiring || this.exited) return false;
 		this.child.stdin.write(frame);
 		return true;
 	}
@@ -125,6 +139,8 @@ export class SubprocessProcess {
 		this.retire();
 		if (this.exited) return true;
 		this.kill(initialSignal);
+		// On Windows the kill first lists processes (up to 5 s); the exit wait starts once taskkill has run.
+		if (this.windowsTreeKill) await this.windowsTreeKill;
 		if (await this.waitForExit(escalationMs)) return true;
 		this.kill("SIGKILL");
 		return await this.waitForExit(forcedExitWaitMs);
@@ -151,6 +167,12 @@ export class SubprocessProcess {
 	}
 
 	private kill(signal: NodeJS.Signals): void {
+		if (globalThis.process.platform === "win32") {
+			// taskkill /F is already forced, so escalation reuses the first kill instead of listing again.
+			if (this.child.pid !== undefined) this.windowsTreeKill ??= killWindowsTree(this.child.pid);
+			else this.child.kill(signal);
+			return;
+		}
 		if (this.child.pid !== undefined) {
 			try {
 				globalThis.process.kill(-this.child.pid, signal);

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

@@ -120,6 +120,7 @@ export class SubprocessRunQueue {
 				return false;
 			case "webview-connect":
 			case "memory-query-result":
+			case "memory-globals-result":
 			case "kernel-tools-defined":
 				return false;
 			default: {

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

@@ -14,6 +14,7 @@ import { appendSchemaHint } from "../bridges/schema-hint.ts";
 import type { CompletionRequest, CompletionResult } from "../completion/handler.ts";
 import { handleCompletionToolCall } from "../completion/tool-bridge.ts";
 import type { ResolvedCodemodeSettings } from "../config/settings.ts";
+import type { PackagesInstallEnvironments } from "../environments/packages-install.ts";
 import type { HandleRegistry } from "../handles/handle-registry.ts";
 import type { KernelToolsCapability } from "../kernels/js/kernel-tools-types.ts";
 import {
@@ -54,6 +55,8 @@ export interface CellBridgeRuntime {
 	readonly handles?: HandleRegistry;
 	/** Absolute wall-clock deadline of this cell; a completion handle it creates is bounded by it. */
 	readonly hardDeadlineMs?: number;
+	/** A JS cell's session environment for `packages.install()`; Python cells reach theirs over the bridge. */
+	readonly environments?: PackagesInstallEnvironments;
 }
 
 export class CellHandler {
@@ -235,22 +238,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/cell-reserved-dispatch.ts

@@ -29,6 +29,7 @@ export function reservedDispatchContext(
 		marshalToolResult,
 		...(runtime.handles === undefined ? {} : { handles: runtime.handles }),
 		...(host === undefined ? {} : { evalHandleHost: host }),
+		...(runtime.environments === undefined ? {} : { environments: runtime.environments }),
 	};
 }
 

package/src/tool/cell-runtime.ts

@@ -219,8 +219,10 @@ export class CellResultBuilder {
 	}
 
 	#liveUpdateText(): string {
-		if (this.#state.status === "queued" && this.#state.queuedBehind?.length) {
-			return `queued behind ${this.#state.queuedBehind.join(", ")} in the ${this.#state.input.language} kernel`;
+		if (this.#state.status === "queued" && this.#state.queuedBehind !== undefined) {
+			return this.#state.queuedBehind.length === 0
+				? `waiting for the ${this.#state.input.language} kernel to be ready`
+				: `queued behind ${this.#state.queuedBehind.join(", ")} in the ${this.#state.input.language} kernel`;
 		}
 		const summary = this.#state.input.summary === undefined ? "" : ` ${this.#state.input.summary}`;
 		const output = this.#liveLines.text();

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

@@ -13,7 +13,7 @@ import type {
 	EvalDetachedCellSnapshot,
 	EvalDetachedCellStatusEntry,
 } from "./detached-cell-contract.ts";
-import { currentDetachedResult, detachedErrorResult, snapshotDetachedCell } from "./detached-cell-snapshot.ts";
+import { cancelledDetachedResult, detachedErrorResult, snapshotDetachedCell } from "./detached-cell-snapshot.ts";
 import {
 	activeDetachedCellReuseError,
 	allowsDetachedCellTransition,
@@ -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,
 				});
 			}
 		}
@@ -260,7 +256,7 @@ export class EvalDetachedCellManager {
 			return;
 		}
 		if (foreground) {
-			if (this.#settle(cell, "cancelled", currentDetachedResult(cell))) cell.onKill?.(expiry.error);
+			if (this.#settle(cell, "cancelled", cancelledDetachedResult(cell))) cell.onKill?.(expiry.error);
 			return;
 		}
 		await this.#cancel(cell, expiry.error.message);
@@ -269,7 +265,7 @@ export class EvalDetachedCellManager {
 	#cancelQueued(cell: ManagedCell, reason: string, error = new Error(reason)): void {
 		const dequeued = cell.kernel?.cancelQueued(cell.cellId, reason) ?? false;
 		cell.stateRetained = true;
-		this.#settle(cell, "cancelled", currentDetachedResult(cell));
+		this.#settle(cell, "cancelled", cancelledDetachedResult(cell));
 		// Acquisition/reset has no queue promise yet; its execution has no interrupt target either.
 		if (!dequeued) cell.onKill?.(error);
 	}
@@ -278,7 +274,7 @@ export class EvalDetachedCellManager {
 		const outcome = Promise.withResolvers<void>();
 		cell.interruptOutcome = outcome;
 		try {
-			if (!this.#settle(cell, "cancelled", currentDetachedResult(cell)) || cell.kernel === undefined) return;
+			if (!this.#settle(cell, "cancelled", cancelledDetachedResult(cell)) || cell.kernel === undefined) return;
 			const handle = await cell.kernel.interrupt(reason, cell.cellId);
 			cell.interruptNote = handle.note;
 			cell.stateRetained = await handle.stateRetained;

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");
-}