@code-yeongyu/senpi-codemode 2026.9.28 → 2026.9.29-3

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

@@ -4,6 +4,7 @@ import type { KernelInterruptHandle } from "../../tool/types.ts";
 import type { KernelToolsInvokeOptions } from "../js/kernel-tools-types.ts";
 import { rejectKernelToolsUnavailable } from "../kernel-tools-unavailable.ts";
 import { applySessionEnvironment } from "../session-env.ts";
+import { KernelMemoryHost } from "./kernel-memory-host.ts";
 import type { KernelResult, KernelRunInput, SubprocessKernelOptions, ToolCallMessage } from "./subprocess-contract.ts";
 import { type SubprocessLike, SubprocessProcess, type SubprocessSpawn, spawnSubprocess } from "./subprocess-process.ts";
 import { SubprocessRunQueue } from "./subprocess-queue.ts";
@@ -21,13 +22,20 @@ import {
 	timeoutResult,
 } from "./subprocess-run.ts";
 
-export type { KernelResult, KernelRunInput, SubprocessKernelOptions, ToolCallMessage } from "./subprocess-contract.ts";
+export type {
+	KernelResult,
+	KernelRunInput,
+	SubprocessKernelMemory,
+	SubprocessKernelOptions,
+	ToolCallMessage,
+} from "./subprocess-contract.ts";
 export type { SubprocessLike, SubprocessSpawn };
 
 export class SubprocessKernel {
 	private readonly options: SubprocessKernelOptions;
 	private readonly onMessage?: (message: KernelToHostMessage) => void;
 	private readonly runs = new SubprocessRunQueue();
+	private readonly memory: KernelMemoryHost | null;
 	private process: SubprocessProcess | null = null;
 	private processReady = false;
 	private retirementPromise: Promise<void> | null = null;
@@ -39,6 +47,8 @@ export class SubprocessKernel {
 	constructor(options: SubprocessKernelOptions) {
 		this.options = options;
 		this.onMessage = options.onMessage;
+		const memory = options.memory;
+		this.memory = memory ? new KernelMemoryHost(memory.language, memory.thresholds, memory) : null;
 		this.spawnProcess();
 	}
 
@@ -176,6 +186,7 @@ export class SubprocessKernel {
 		});
 		this.process = process;
 		this.processReady = false;
+		this.memory?.processReplaced();
 		try {
 			process.send(
 				encodeBridgeFrame({ type: "init", sessionId: this.options.sessionId, connection: this.options.connection }),
@@ -210,7 +221,17 @@ export class SubprocessKernel {
 			this.failClosed(new KernelStartupError(message.error.message));
 			return;
 		}
-		if (this.runs.handleMessage(message, this.onMessage)) this.pumpRuns();
+		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;
+		this.pumpRuns();
+		this.recycleOverCeilingWhenIdle();
+	}
+
+	/** An over-ceiling interpreter restarts only once no cell is running or queued on it. */
+	private recycleOverCeilingWhenIdle(): void {
+		const idle = this.runs.active === null && this.runs.snapshot().queuedCellIds.length === 0;
+		if (this.memory?.claimRecycle(idle)) void this.restartProcess(this.process);
 	}
 
 	private handleExit(process: SubprocessProcess, code: number | null, signal: NodeJS.Signals | null): void {

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

@@ -113,6 +113,8 @@ export class SubprocessRunQueue {
 			case "kernel-tool-invoke-reply":
 				onMessage?.(message);
 				return false;
+			case "webview-connect":
+				return false;
 			default: {
 				const exhaustive: never = message;
 				return exhaustive;

package/src/output/streaming-output-buffer.ts

@@ -23,10 +23,47 @@ export function truncateTailBytes(text: string, maxBytes: number): ByteSlice {
 	return { text: slice.toString("utf8"), bytes: slice.length };
 }
 
+/** UTF-8 width of the code point starting at `index`; a lone surrogate counts 3 bytes, as the encoder writes U+FFFD. */
+function utf8Width(codePoint: number): number {
+	if (codePoint < 0x80) return 1;
+	if (codePoint < 0x800) return 2;
+	if (codePoint < 0x10000) return 3;
+	return 4;
+}
+
+/**
+ * The shortest suffix of `text` whose leading whole code points total at least `excess` UTF-8 bytes, i.e. exactly
+ * what truncateTailBytes keeps, computed by walking the dropped prefix only. Lone surrogates in the kept text become
+ * U+FFFD as they would after a UTF-8 round trip.
+ */
+function dropLeadingBytes(text: string, excess: number): ByteSlice {
+	const totalBytes = Buffer.byteLength(text, "utf8");
+	let index = 0;
+	let dropped = 0;
+	while (dropped < excess && index < text.length) {
+		const codePoint = text.codePointAt(index) ?? 0;
+		dropped += utf8Width(codePoint);
+		index += codePoint > 0xffff ? 2 : 1;
+	}
+	const kept = text.slice(index);
+	return { text: kept.isWellFormed() ? kept : kept.toWellFormed(), bytes: totalBytes - dropped };
+}
+
+/**
+ * Trailing byte window over a chunk stream. Appends only queue the chunk and drop whole chunks that fall
+ * out of the window, so a streaming append costs time and memory proportional to the chunk (#2262); the
+ * exact code-point-aligned trim runs when the window is read, with the same result as truncating the whole
+ * stream to `maxBytes` after every append.
+ */
 export class TailBuffer {
 	readonly #maxBytes: number;
-	#text = "";
+	#chunks: string[] = [];
+	#chunkBytes: number[] = [];
+	#head = 0;
+	/** Sum of the queued chunks' UTF-8 sizes; exact after #normalize. */
 	#bytes = 0;
+	/** The stream exceeded the window since the last normalization, so the next read must trim. */
+	#overflowed = false;
 
 	constructor(maxBytes: number) {
 		this.#maxBytes = Math.max(0, Math.floor(maxBytes));
@@ -34,25 +71,205 @@ export class TailBuffer {
 
 	append(text: string): void {
 		if (text.length === 0) return;
-		if (this.#maxBytes === 0) {
-			this.#text = "";
-			this.#bytes = 0;
+		if (this.#maxBytes === 0) return;
+		const incomingBytes = Buffer.byteLength(text, "utf8");
+		if (incomingBytes >= this.#maxBytes) {
+			this.#chunks = [text];
+			this.#chunkBytes = [incomingBytes];
+			this.#head = 0;
+			this.#bytes = incomingBytes;
+			this.#overflowed = true;
 			return;
 		}
-		const incomingBytes = Buffer.byteLength(text, "utf8");
-		const next =
-			incomingBytes >= this.#maxBytes
-				? truncateTailBytes(text, this.#maxBytes)
-				: truncateTailBytes(this.#text + text, this.#maxBytes);
-		this.#text = next.text;
-		this.#bytes = next.bytes;
+		this.#chunks.push(text);
+		this.#chunkBytes.push(incomingBytes);
+		this.#bytes += incomingBytes;
+		if (this.#bytes > this.#maxBytes) this.#overflowed = true;
+		// Keep a small margin so a surrogate pair split across chunks cannot make the kept window short.
+		while (
+			this.#head < this.#chunks.length - 1 &&
+			this.#bytes - (this.#chunkBytes[this.#head] ?? 0) >= this.#maxBytes + 4
+		) {
+			this.#bytes -= this.#chunkBytes[this.#head] ?? 0;
+			this.#head++;
+		}
+		if (this.#head > 1024 && this.#head * 2 > this.#chunks.length) {
+			this.#chunks = this.#chunks.slice(this.#head);
+			this.#chunkBytes = this.#chunkBytes.slice(this.#head);
+			this.#head = 0;
+		}
 	}
 
 	text(): string {
-		return this.#text;
+		return this.#normalize();
 	}
 
 	bytes(): number {
+		this.#normalize();
 		return this.#bytes;
 	}
+
+	#normalize(): string {
+		if (this.#maxBytes === 0) return "";
+		const pending = this.#chunks.length - this.#head;
+		if (pending === 0) return "";
+		const joined = pending === 1 ? (this.#chunks[this.#head] ?? "") : this.#chunks.slice(this.#head).join("");
+		const total = Buffer.byteLength(joined, "utf8");
+		const kept = this.#overflowed
+			? dropLeadingBytes(joined, Math.max(0, total - this.#maxBytes))
+			: { text: joined, bytes: total };
+		this.#chunks = [kept.text];
+		this.#chunkBytes = [kept.bytes];
+		this.#head = 0;
+		this.#bytes = kept.bytes;
+		this.#overflowed = false;
+		return kept.text;
+	}
+}
+
+export interface TailLineRingOptions {
+	readonly maxBytes: number;
+	readonly maxLines: number;
+}
+
+/**
+ * Rolling live-output window over a chunk stream: `text()` returns the last
+ * `maxLines` lines of the trailing `maxBytes` byte window, byte-identical to
+ * truncating the whole stream to `maxBytes` bytes and keeping its final lines,
+ * while `append` costs time proportional to the chunk (#2262).
+ *
+ * Invariant: the retained content (compacted line groups plus recent lines,
+ * joined with "\n", plus the partial current line) is a suffix of the stream
+ * that either covers the whole stream or keeps the last-`maxLines`-lines window
+ * reachable — older content is only dropped as whole lines when the remaining
+ * lines still cover the line window, and any line trimmed from its start (only
+ * for lines larger than the byte budget) is halved so repeated trims stay
+ * amortized and never drop below what the byte window still needs.
+ */
+export class TailLineRing {
+	readonly #maxBytes: number;
+	readonly #maxLines: number;
+	readonly #blobs: string[] = [];
+	readonly #blobBytes: number[] = [];
+	readonly #lines: string[] = [];
+	readonly #lineBytes: number[] = [];
+	#current = "";
+	#currentBytes = 0;
+	#bytes = 0;
+
+	constructor(options: TailLineRingOptions) {
+		this.#maxBytes = Math.max(0, Math.floor(options.maxBytes));
+		this.#maxLines = Math.max(1, Math.floor(options.maxLines));
+	}
+
+	append(chunk: string): void {
+		if (chunk.length === 0) return;
+		let start = 0;
+		for (;;) {
+			const newline = chunk.indexOf("\n", start);
+			const end = newline === -1 ? chunk.length : newline;
+			if (end > start) {
+				const piece = chunk.slice(start, end);
+				const pieceBytes = Buffer.byteLength(piece, "utf8");
+				this.#current += piece;
+				this.#currentBytes += pieceBytes;
+				this.#bytes += pieceBytes;
+			}
+			if (newline === -1) break;
+			this.#completeLine();
+			start = newline + 1;
+		}
+		this.#enforce();
+	}
+
+	text(): string {
+		const endsWithNewline = this.#current === "" && this.#bytes > 0;
+		const keptLines = endsWithNewline ? this.#maxLines : this.#maxLines - 1;
+		if (this.#lines.length >= keptLines) {
+			const parts = this.#lines.slice(-keptLines);
+			if (!endsWithNewline) parts.push(this.#current);
+			const window = `${parts.join("\n")}${endsWithNewline ? "\n" : ""}`;
+			if (Buffer.byteLength(window, "utf8") <= this.#maxBytes) return window;
+		}
+		return this.#bytePathText(endsWithNewline);
+	}
+
+	#completeLine(): void {
+		this.#lines.push(this.#current);
+		this.#lineBytes.push(this.#currentBytes);
+		this.#current = "";
+		this.#currentBytes = 0;
+		this.#bytes += 1;
+		const keep = Math.max(this.#maxLines * 4, 64);
+		if (this.#lines.length > keep * 2) this.#compact(keep);
+	}
+
+	/**
+	 * Folds the oldest individual lines into one compacted group so a long stream of
+	 * tiny lines cannot grow the line array without bound. The recent lines kept
+	 * always outnumber the window, so compaction never touches rendered content.
+	 */
+	#compact(keep: number): void {
+		const movedCount = this.#lines.length - keep;
+		const moved = this.#lines.splice(0, movedCount);
+		const movedBytes = this.#lineBytes.splice(0, movedCount);
+		let bytes = 0;
+		for (const entry of movedBytes) bytes += entry;
+		this.#blobs.push(moved.join("\n"));
+		this.#blobBytes.push(bytes + Math.max(0, moved.length - 1));
+	}
+
+	#enforce(): void {
+		while (this.#bytes > this.#maxBytes) {
+			if (this.#blobs.length > 0) {
+				if (!this.#shedFront(this.#blobs, this.#blobBytes, this.#lines.length)) return;
+				continue;
+			}
+			if (this.#lines.length > 0) {
+				if (!this.#shedFront(this.#lines, this.#lineBytes, this.#lines.length - 1)) return;
+				continue;
+			}
+			if (this.#currentBytes <= this.#maxBytes) return;
+			const kept = truncateTailBytes(this.#current, Math.max(this.#maxBytes, Math.floor(this.#currentBytes / 2)));
+			this.#bytes -= this.#currentBytes - kept.bytes;
+			this.#current = kept.text;
+			this.#currentBytes = kept.bytes;
+		}
+	}
+
+	/**
+	 * Drops or trims the oldest retained unit. Dropping is safe when the remaining
+	 * bytes still cover the byte window or the remaining individual lines still cover
+	 * the line window; otherwise the unit is trimmed from its start (halved, never
+	 * below what the byte window still needs), which keeps the retained content a
+	 * suffix holding at least `maxBytes` bytes. Returns false when nothing more can
+	 * be shed without breaking the invariant.
+	 */
+	#shedFront(texts: string[], byteCosts: number[], retainedLines: number): boolean {
+		const unitBytes = byteCosts[0];
+		const restBytes = this.#bytes - unitBytes - 1;
+		if (restBytes >= this.#maxBytes || retainedLines >= this.#maxLines) {
+			texts.shift();
+			byteCosts.shift();
+			this.#bytes = restBytes;
+			return true;
+		}
+		const needBytes = this.#maxBytes - restBytes;
+		const keepBytes = Math.max(needBytes, unitBytes >> 1);
+		if (keepBytes >= unitBytes) return false;
+		const kept = truncateTailBytes(texts[0], keepBytes);
+		texts[0] = kept.text;
+		byteCosts[0] = kept.bytes;
+		this.#bytes -= unitBytes - kept.bytes;
+		return true;
+	}
+
+	#bytePathText(endsWithNewline: boolean): string {
+		const units = [...this.#blobs, ...this.#lines];
+		const joined = units.length === 0 ? this.#current : `${units.join("\n")}\n${this.#current}`;
+		const tail = truncateTailBytes(joined, this.#maxBytes).text;
+		let tailLines = tail.split("\n");
+		if (endsWithNewline) tailLines = tailLines.slice(0, -1);
+		return `${tailLines.slice(-this.#maxLines).join("\n")}${endsWithNewline ? "\n" : ""}`;
+	}
 }

package/src/output/streaming-output.ts

@@ -2,11 +2,11 @@ import { createWriteStream, mkdirSync, type WriteStream } from "node:fs";
 import { dirname } from "node:path";
 import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, truncateTail } from "../host-sdk.ts";
 import { formatMiddleElisionMarker } from "./output-meta.ts";
-import { TailBuffer, truncateHeadBytes } from "./streaming-output-buffer.ts";
+import { TailBuffer, TailLineRing, truncateHeadBytes } from "./streaming-output-buffer.ts";
 
 export { artifactNotice, formatMiddleElisionMarker, resolveSessionArtifactsDir } from "./output-meta.ts";
 export { truncateHeadBytes, truncateTailBytes } from "./streaming-output-buffer.ts";
-export { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, TailBuffer, truncateTail };
+export { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, TailBuffer, TailLineRing, truncateTail };
 
 export const ARTIFACT_DEFAULT_HEAD_BYTES = 3 * 1024 * 1024;
 

package/src/prompt/eval-prompt.ts

@@ -112,7 +112,7 @@ export function buildEvalPrompt(
 		promptSnippet: "Run one incremental code cell in a persistent language kernel.",
 		promptGuidelines: [
 			style === "gpt" && context.monitor === true ? GPT_MONITOR_BATCHING_GUIDELINE : BATCHING_GUIDELINES[style],
-			"Use eval reset only when a language kernel must be wiped; reset is scoped to the selected language.",
+			"Use eval reset only when a language kernel must be wiped; reset is scoped to the selected language. A bracketed kernel memory notice in a result names the globals holding the most memory; drop the ones you no longer need.",
 		],
 	};
 }

package/src/skill/bun-1-4/references/runtime-apis.md

@@ -34,6 +34,7 @@ await Bun.write("page.png", await view.screenshot());
 ```
 
 - macOS: system WebKit, nothing to install. macOS/Linux/Windows: can drive installed Chrome/Chromium/Edge.
+- In the eval js kernel, Chrome-backed views (the default off macOS, or `backend: "chrome"`) are served by the process main thread; the API is the same, a constructor error surfaces on the first awaited call, and `Bun.WebView.closeAll()` closes only this kernel's views. A kernel reset closes every view the kernel left open.
 - Clicks/scrolls are trusted user input (`event.isTrusted === true`).
 - Extends `EventTarget`; screenshots are `Blob`s; `.cdp(method, params?)` escape hatch for raw Chrome DevTools Protocol.
 

package/src/tool/cell-runtime.ts

@@ -1,8 +1,14 @@
 import type { AgentToolResult, AgentToolUpdateCallback, ExtensionContext } from "@code-yeongyu/senpi";
+import type { KernelMemoryReport } from "../bridge/memory-protocol.ts";
 import type { KernelToHostMessage } from "../bridge/protocol.ts";
+import { DEFAULT_MAX_BYTES, TailLineRing } from "../output/streaming-output.ts";
 import type { EvalToolCallMetric } from "./call-capture.ts";
 import { type EvalImageResizer, EvalOutputCollector, type EvalOutputResult } from "./image.ts";
-import type { EvalRuntimeInfo, EvalStatusEvent, EvalToolDetails, EvalToolInput } from "./types.ts";
+import type { EvalMemoryDetails, EvalRuntimeInfo, EvalStatusEvent, EvalToolDetails, EvalToolInput } from "./types.ts";
+
+const LIVE_UPDATE_LINES = 8;
+/** Same cadence as the core bash tool's streaming updates (BASH_UPDATE_THROTTLE_MS). */
+const LIVE_OUTPUT_UPDATE_THROTTLE_MS = 100;
 
 type KernelResult = Extract<KernelToHostMessage, { type: "result" }>;
 type DisplayMessage = Extract<KernelToHostMessage, { type: "display" }>;
@@ -40,6 +46,10 @@ export interface CellResultBuilderOptions {
 export class CellResultBuilder {
 	readonly #output: EvalOutputCollector;
 	readonly #state: CellState;
+	#memory: KernelMemoryReport | undefined;
+	readonly #liveLines = new TailLineRing({ maxBytes: DEFAULT_MAX_BYTES * 2, maxLines: LIVE_UPDATE_LINES });
+	#lastOutputUpdateAt = 0;
+	#outputUpdateTimer: ReturnType<typeof setTimeout> | undefined;
 
 	constructor(options: CellResultBuilderOptions) {
 		this.#state = options.state;
@@ -49,9 +59,9 @@ export class CellResultBuilder {
 			model: options.model,
 			...(options.artifactPath === undefined ? {} : { artifactPath: options.artifactPath }),
 			...(options.imageResizer === undefined ? {} : { imageResizer: options.imageResizer }),
-			onChunk: (_aggregate, cell) => {
-				options.state.output = cell;
-				this.emitUpdate(false);
+			onChunk: (chunk) => {
+				this.#liveLines.append(chunk);
+				this.#scheduleOutputUpdate();
 			},
 		});
 		if (options.state.status !== "queued") options.state.status = "running";
@@ -73,6 +83,7 @@ export class CellResultBuilder {
 
 	async finalize(result: KernelResult): Promise<AgentToolResult<EvalToolDetails>> {
 		this.#state.durationMs = result.durationMs;
+		this.#memory = result.memory;
 		if (result.ok) {
 			if (result.valueRepr) this.#output.push(`${result.valueRepr}\n`);
 			this.#state.status = "complete";
@@ -96,6 +107,7 @@ export class CellResultBuilder {
 	}
 
 	liveResult(): AgentToolResult<EvalToolDetails> {
+		this.#state.output = this.#output.cellTailText();
 		return {
 			content: [{ type: "text", text: this.#liveUpdateText() }],
 			details: this.#details(undefined, this.#state.status === "error"),
@@ -110,7 +122,33 @@ export class CellResultBuilder {
 		});
 	}
 
+	#scheduleOutputUpdate(): void {
+		const delay = LIVE_OUTPUT_UPDATE_THROTTLE_MS - (Date.now() - this.#lastOutputUpdateAt);
+		if (delay <= 0) {
+			this.#clearOutputUpdateTimer();
+			this.#emitOutputUpdate();
+			return;
+		}
+		this.#outputUpdateTimer ??= setTimeout(() => {
+			this.#outputUpdateTimer = undefined;
+			this.#emitOutputUpdate();
+		}, delay);
+	}
+
+	#emitOutputUpdate(): void {
+		this.#lastOutputUpdateAt = Date.now();
+		this.#state.output = this.#output.cellTailText();
+		this.emitUpdate(false);
+	}
+
+	#clearOutputUpdateTimer(): void {
+		if (this.#outputUpdateTimer === undefined) return;
+		clearTimeout(this.#outputUpdateTimer);
+		this.#outputUpdateTimer = undefined;
+	}
+
 	async #finish(isError: boolean): Promise<AgentToolResult<EvalToolDetails>> {
+		this.#clearOutputUpdateTimer();
 		const output = await this.#output.finish();
 		this.#state.output = output.output;
 		const details = this.#details(output, isError);
@@ -120,7 +158,9 @@ export class CellResultBuilder {
 			(output.images.length > 0
 				? `(displayed ${output.images.length} image${output.images.length === 1 ? "" : "s"}; no text output)`
 				: "(no output)");
-		return { content: [{ type: "text", text }, ...output.images], details };
+		const notice = this.#memory?.notice;
+		const noticePart = notice === undefined ? [] : [{ type: "text" as const, text: notice }];
+		return { content: [{ type: "text", text }, ...noticePart, ...output.images], details };
 	}
 
 	#details(output: EvalOutputResult | undefined, isError: boolean): EvalToolDetails {
@@ -159,6 +199,7 @@ export class CellResultBuilder {
 			...(output === undefined || output.jsonOutputs.length === 0 ? {} : { jsonOutputs: output.jsonOutputs }),
 			...(output?.notice === undefined ? {} : { notice: output.notice }),
 			...(output?.meta === undefined ? {} : { meta: output.meta }),
+			...(output === undefined || this.#memory === undefined ? {} : { memory: memoryDetails(this.#memory) }),
 		};
 	}
 
@@ -167,11 +208,12 @@ export class CellResultBuilder {
 			return `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 aggregateOutput = this.#output.aggregateText();
-		const outputLines = aggregateOutput.split("\n");
-		const hasTrailingNewline = aggregateOutput.endsWith("\n");
-		if (hasTrailingNewline) outputLines.pop();
-		const output = `${outputLines.slice(-8).join("\n")}${hasTrailingNewline ? "\n" : ""}`;
+		const output = this.#liveLines.text();
 		return `1/1 cells ${this.#state.status}\n[1] ${this.#state.input.language}${summary} ${this.#state.status}${output.length === 0 ? "" : `\n${output}`}`;
 	}
 }
+
+function memoryDetails(report: KernelMemoryReport): EvalMemoryDetails {
+	const { notice: _notice, ...details } = report;
+	return details;
+}

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

@@ -47,6 +47,10 @@ export interface EvalDetachedCellManagerOptions {
 	readonly runBudgetSeconds?: number;
 	/** Global detached-cell capacity; defaults to 15. Full capacity keeps new cells foreground. */
 	readonly maxDetachedCells?: number;
+	/** Estimated in-memory byte budget for settled-cell snapshots kept for peek/list; 0 keeps only the count cap. */
+	readonly retainedResultsBytes?: number;
+	/** Disk budget for settled-cell images spilled under `artifactsDir`; 0 keeps only the count cap. */
+	readonly retainedImagesBytes?: number;
 	readonly onStatusChange?: (entries: readonly EvalDetachedCellStatusEntry[]) => void;
 	/** Receives a full per-source liveness snapshot on every detached-cell transition; used by the goal builtin. */
 	readonly onWakeSourceState?: (state: WakeSourceState) => void;

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

@@ -1,4 +1,6 @@
+import { join } from "node:path";
 import type { AgentToolResult } from "@code-yeongyu/senpi";
+import { DEFAULT_RETAINED_IMAGES_MB, DEFAULT_RETAINED_RESULTS_MB } from "../config/memory-settings.ts";
 import {
 	DEFAULT_HARD_LIMIT_SECONDS,
 	DEFAULT_MAX_DETACHED_CELLS,
@@ -20,6 +22,7 @@ import {
 import { detachedStatusEntries, detachedWakeSourceState } from "./detached-cell-status.ts";
 import { DetachedNotificationQueue } from "./detached-notification-queue.ts";
 import { createManagedCell, type LiveResultProvider, type ManagedCell } from "./managed-cell.ts";
+import { SettledImageSpill } from "./settled-image-spill.ts";
 import { TerminalSnapshotStore } from "./terminal-snapshot-store.ts";
 import type { EvalKernel, EvalLanguage, EvalToolDetails, EvalToolInput } from "./types.ts";
 
@@ -38,7 +41,7 @@ export class EvalDetachedCellManager {
 	readonly #onWakeSourceState: ((state: WakeSourceState) => void) | undefined;
 	readonly #cells = new Map<string, ManagedCell>();
 	readonly #detached = new Map<string, ManagedCell>();
-	readonly #terminalSnapshots = new TerminalSnapshotStore();
+	readonly #terminalSnapshots: TerminalSnapshotStore;
 	readonly #notificationQueue: DetachedNotificationQueue;
 	readonly #now: () => number;
 	readonly #hardLimitSeconds: number;
@@ -54,6 +57,18 @@ export class EvalDetachedCellManager {
 		this.#hardLimitSeconds = options.hardLimitSeconds ?? DEFAULT_HARD_LIMIT_SECONDS;
 		this.#runBudgetSeconds = options.runBudgetSeconds ?? DEFAULT_RUN_BUDGET_SECONDS;
 		this.#maxDetachedCells = options.maxDetachedCells ?? DEFAULT_MAX_DETACHED_CELLS;
+		const artifactsDir = options.artifactsDir;
+		this.#terminalSnapshots = new TerminalSnapshotStore({
+			byteBudget: options.retainedResultsBytes ?? DEFAULT_RETAINED_RESULTS_MB * 1024 * 1024,
+			...(artifactsDir === undefined
+				? {}
+				: {
+						spill: new SettledImageSpill({
+							dir: join(artifactsDir, "settled-images"),
+							byteBudget: options.retainedImagesBytes ?? DEFAULT_RETAINED_IMAGES_MB * 1024 * 1024,
+						}),
+					}),
+		});
 	}
 
 	get maxDetachedCells(): number {

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

@@ -2,6 +2,7 @@ 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 { EvalMemoryDetails } from "./types.ts";
 
 const NOTIFICATION_TAIL_BYTES = 512;
 
@@ -77,11 +78,19 @@ function outcomeOf(cell: EvalDetachedCellSnapshot): string {
 }
 
 function stateNoteOf(cell: EvalDetachedCellSnapshot): string {
-	if (cell.state !== "cancelled") return "Kernel state updated - variables are available to the next eval cell.";
+	if (cell.state !== "cancelled") return memoryStateNote(cell.result.details?.memory);
 	const note = interruptionStateNote(cell.language, cell.stateRetained) ?? unknownInterruptionStateNote(cell.language);
 	return cell.interruptNote === undefined ? note : `${note} ${cell.interruptNote.trim()}`;
 }
 
+export function memoryStateNote(memory: EvalMemoryDetails | undefined): string {
+	if (memory?.overCeiling === true)
+		return "Kernel memory is over its ceiling - the kernel restarts before the next eval cell and every global is lost.";
+	if (memory?.recycled === true)
+		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, "_");
 }

package/src/tool/image.ts

@@ -36,7 +36,7 @@ export interface EvalOutputOptions {
 	readonly maxColumns: number;
 	readonly model: ExtensionContext["model"];
 	readonly imageResizer?: EvalImageResizer;
-	readonly onChunk: (aggregateText: string, cellText: string) => void;
+	readonly onChunk: (chunk: string) => void;
 }
 
 export interface EvalOutputResult {
@@ -82,7 +82,7 @@ export class EvalOutputCollector {
 			onChunk: (chunk) => {
 				this.#aggregateTail.append(chunk);
 				this.#cellTail.append(chunk);
-				options.onChunk(this.#aggregateTail.text(), this.#cellTail.text());
+				options.onChunk(chunk);
 			},
 		});
 	}
@@ -129,6 +129,10 @@ export class EvalOutputCollector {
 		return this.#aggregateTail.text();
 	}
 
+	cellTailText(): string {
+		return this.#cellTail.text();
+	}
+
 	async finish(): Promise<EvalOutputResult> {
 		await this.#processImages();
 		const elided = this.#displayImagesElided + this.#jsonOutputsElided;

package/src/tool/run-eval-cell.ts

@@ -188,24 +188,24 @@ async function executeCell(
 	onReady: () => void,
 ): Promise<AgentToolResult<EvalToolDetails>> {
 	let handler: CellHandler | undefined;
-	try {
-		const onMessage = (message: KernelToHostMessage): void => {
-			if (!state.active || handler === undefined) return;
-			if (message.type === "status") {
-				if (message.event.op === TIMEOUT_PAUSE_OP) {
-					execution.pause();
-					cellManager.pause(cell);
-					return;
-				}
-				if (message.event.op === TIMEOUT_RESUME_OP) {
-					execution.resume();
-					cellManager.resume(cell);
-					return;
-				}
+	const onMessage = (message: KernelToHostMessage): void => {
+		if (!state.active || handler === undefined) return;
+		if (message.type === "status") {
+			if (message.event.op === TIMEOUT_PAUSE_OP) {
+				execution.pause();
+				cellManager.pause(cell);
+				return;
 			}
-			const pending = handler.handle(message);
-			void pending.catch((error: unknown) => execution.cancel(error));
-		};
+			if (message.event.op === TIMEOUT_RESUME_OP) {
+				execution.resume();
+				cellManager.resume(cell);
+				return;
+			}
+		}
+		const pending = handler.handle(message);
+		void pending.catch((error: unknown) => execution.cancel(error));
+	};
+	try {
 		const kernel = await execution.wait(options.kernelManager.getKernel(invocation.input.language, onMessage));
 		// Computed before the handler so the cell's capability can be entered per host tool call from the
 		// worker's message loop, which runs outside the `kernelToolsStorage.run` context below (#1754).
@@ -287,6 +287,8 @@ async function executeCell(
 		bridgeAbortController.abort();
 		execution.finish();
 		if (handler) await handler.flushOutput();
+		// The cell settled: stop the kernel dispatcher from holding this cell's listener (#2260).
+		options.kernelManager.releaseKernelListener?.(invocation.input.language, onMessage);
 	}
 }