@code-yeongyu/senpi-codemode 2026.9.13 → 2026.9.15-2

package/src/tool/image.ts

@@ -1,6 +1,5 @@
 import { writeFile } from "node:fs/promises";
-import type { AgentToolResult, ExtensionContext } from "@code-yeongyu/senpi";
-import { convertToPng, formatDimensionNote, resizeImage } from "@code-yeongyu/senpi";
+import type { ExtensionContext } from "@code-yeongyu/senpi";
 import type { KernelToHostMessage } from "../bridge/protocol.ts";
 import type { TruncationMeta } from "../output/output-meta.ts";
 import {
@@ -12,24 +11,24 @@ import {
 	TailBuffer,
 	truncateTail,
 } from "../output/streaming-output.ts";
+import { type EvalImageContent, type EvalImageResizer, resizeEvalImage } from "./image-resize.ts";
 
-const MAX_DISPLAY_TEXT_BYTES = 8_000;
-
-export interface EvalImageContent {
-	readonly type: "image";
-	readonly data: string;
-	readonly mimeType: string;
-}
+export {
+	type EvalImageContent,
+	type EvalImageResizeResult,
+	type EvalImageResizer,
+	resizeEvalImage,
+	webpExclusionForModel,
+} from "./image-resize.ts";
+export { marshalToolResult, toolResultIsError } from "./tool-result-marshal.ts";
 
-export interface EvalImageResizeResult {
-	readonly image: EvalImageContent;
-	readonly dimensionNote?: string;
-}
+const MAX_DISPLAY_TEXT_BYTES = 8_000;
 
-export type EvalImageResizer = (
-	image: EvalImageContent,
-	model: ExtensionContext["model"],
-) => Promise<EvalImageResizeResult>;
+// Per-cell display caps: display payloads are retained for the whole result lifetime, so an unbounded
+// burst pins base64 originals plus resized copies on the session heap (#1695).
+const MAX_DISPLAY_IMAGES_PER_CELL = 8;
+const MAX_DISPLAY_IMAGE_BYTES_PER_CELL = 24 * 1024 * 1024;
+const MAX_JSON_OUTPUTS_PER_CELL = 64;
 
 export interface EvalOutputOptions {
 	readonly artifactPath?: string;
@@ -51,7 +50,6 @@ export interface EvalOutputResult {
 }
 
 type DisplayMessage = Extract<KernelToHostMessage, { type: "display" }>;
-type WebpModel = { readonly provider: string; readonly api: string } | undefined;
 
 class DisplayPayloadError extends Error {
 	readonly name = "DisplayPayloadError";
@@ -69,6 +67,9 @@ export class EvalOutputCollector {
 	readonly #displayImages: EvalImageContent[] = [];
 	readonly #images: EvalImageContent[] = [];
 	readonly #jsonOutputs: unknown[] = [];
+	#displayImageBytes = 0;
+	#displayImagesElided = 0;
+	#jsonOutputsElided = 0;
 	#hasMarkdown = false;
 	#imagesProcessed = false;
 
@@ -92,11 +93,23 @@ export class EvalOutputCollector {
 
 	display(message: DisplayMessage): void {
 		if (message.mimeType.startsWith("image/")) {
+			if (
+				this.#displayImages.length >= MAX_DISPLAY_IMAGES_PER_CELL ||
+				this.#displayImageBytes + message.dataBase64.length > MAX_DISPLAY_IMAGE_BYTES_PER_CELL
+			) {
+				this.#displayImagesElided++;
+				return;
+			}
 			this.#displayImages.push({ type: "image", mimeType: message.mimeType, data: message.dataBase64 });
+			this.#displayImageBytes += message.dataBase64.length;
 			return;
 		}
 		const text = Buffer.from(message.dataBase64, "base64").toString("utf8");
 		if (message.mimeType === "application/json") {
+			if (this.#jsonOutputs.length >= MAX_JSON_OUTPUTS_PER_CELL) {
+				this.#jsonOutputsElided++;
+				return;
+			}
 			let value: unknown;
 			try {
 				value = JSON.parse(text);
@@ -118,6 +131,12 @@ export class EvalOutputCollector {
 
 	async finish(): Promise<EvalOutputResult> {
 		await this.#processImages();
+		const elided = this.#displayImagesElided + this.#jsonOutputsElided;
+		if (elided > 0) {
+			this.#sink.push(
+				`[${this.#displayImagesElided} display image(s) and ${this.#jsonOutputsElided} JSON output(s) elided beyond per-cell caps]\n`,
+			);
+		}
 		const summary = await this.#finalSummary();
 		const meta = truncationMetaFromSummary(summary, this.#options.maxColumns);
 		const notice = summary.artifactId === undefined ? undefined : artifactNotice(summary.artifactId);
@@ -171,38 +190,6 @@ export class EvalOutputCollector {
 	}
 }
 
-export function webpExclusionForModel(model: WebpModel): true | undefined {
-	if (model === undefined) return undefined;
-	return model.provider === "ollama" ||
-		model.provider === "ollama-cloud" ||
-		model.provider === "llama.cpp" ||
-		model.provider === "lm-studio" ||
-		model.provider === "local-server" ||
-		model.api === "ollama-chat"
-		? true
-		: undefined;
-}
-
-export const resizeEvalImage: EvalImageResizer = async (image, model) => {
-	const excludeWebP = webpExclusionForModel(model);
-	const forceWebpConversion = excludeWebP === true && image.mimeType === "image/webp";
-	const resized = await resizeImage(
-		Buffer.from(image.data, "base64"),
-		image.mimeType,
-		forceWebpConversion ? { maxBytes: Buffer.byteLength(image.data, "utf8") } : undefined,
-	);
-	let output: EvalImageContent =
-		resized === null ? image : { type: "image", data: resized.data, mimeType: resized.mimeType };
-	if (excludeWebP === true && output.mimeType === "image/webp") {
-		const converted = await convertToPng(output.data, output.mimeType);
-		if (converted === null)
-			throw new TypeError(`Unable to convert ${output.mimeType} display output for the active model`);
-		output = { type: "image", data: converted.data, mimeType: converted.mimeType };
-	}
-	const dimensionNote = resized === null ? undefined : formatDimensionNote(resized);
-	return { image: output, ...(dimensionNote === undefined ? {} : { dimensionNote }) };
-};
-
 function formatDisplayJson(value: unknown): string {
 	let text: string;
 	try {
@@ -259,25 +246,3 @@ function truncationMetaFromSummary(summary: OutputSummary, maxColumns: number):
 		...artifact,
 	};
 }
-
-export function marshalToolResult(result: AgentToolResult<unknown>) {
-	const texts = result.content.filter((part) => part.type === "text").map((part) => part.text);
-	const images = result.content
-		.filter((part) => part.type === "image")
-		.map((part) => ({ mimeType: part.mimeType, dataBase64: part.data }));
-	const details =
-		typeof result.details === "object" &&
-		result.details !== null &&
-		!Array.isArray(result.details) &&
-		Object.keys(result.details).length === 0
-			? undefined
-			: result.details;
-	const hasError = toolResultIsError(result);
-	const text = texts.join("\n");
-	return images.length === 0 && details === undefined && !hasError ? { text } : { text, details, images, hasError };
-}
-
-export function toolResultIsError(result: AgentToolResult<unknown>): boolean {
-	const details = result.details;
-	return typeof details === "object" && details !== null && "isError" in details && details.isError === true;
-}

package/src/tool/managed-cell.ts

@@ -0,0 +1,78 @@
+import type { AgentToolResult } from "@code-yeongyu/senpi";
+import { type CellDeadlineExpiry, CellDeadlines } from "./cell-deadlines.ts";
+import type { EvalDetachedCellSnapshot, EvalDetachedCellState } from "./detached-cell-contract.ts";
+import { detachedNotificationSpillPath } from "./detached-cell-notification.ts";
+import type { EvalKernel, EvalToolDetails, EvalToolInput } from "./types.ts";
+
+export type LiveResultProvider = () => AgentToolResult<EvalToolDetails>;
+
+export type ManagedCell = {
+	readonly cellId: string;
+	readonly input: EvalToolInput;
+	readonly spillPath: string | undefined;
+	readonly startedAtMs: number;
+	readonly terminal: PromiseWithResolvers<EvalDetachedCellSnapshot>;
+	state: EvalDetachedCellState;
+	canDetach: boolean;
+	wasDetached: boolean;
+	kernel: EvalKernel | undefined;
+	stateRetained: boolean | undefined;
+	interruptNote: string | undefined;
+	/** Holds the completion notification until the interrupt has reported whether kernel state survived. */
+	interruptOutcome: PromiseWithResolvers<void> | undefined;
+	liveResult: LiveResultProvider | undefined;
+	terminalResult: AgentToolResult<EvalToolDetails> | undefined;
+	notificationQueued: boolean;
+	readonly deadlines: CellDeadlines;
+	readonly hardLimitSeconds: number;
+	readonly runBudgetSeconds: number;
+	hardLimited: boolean;
+	runBudgetExhausted: boolean;
+	/** Foreground killer: the still-awaited CellExecution owns interrupting and rejecting its own call; bound from creation so a deadline firing during kernel boot still ends it. */
+	onKill: ((error: Error) => void) | undefined;
+};
+
+export interface ManagedCellInit {
+	readonly cellId: string;
+	readonly input: EvalToolInput;
+	readonly artifactsDir: string | undefined;
+	readonly now: () => number;
+	readonly defaultHardLimitSeconds: number;
+	readonly defaultRunBudgetSeconds: number;
+	readonly onKill: ((error: Error) => void) | undefined;
+	readonly onExpire: (cellId: string, expiry: CellDeadlineExpiry) => void;
+}
+
+export function createManagedCell(init: ManagedCellInit): ManagedCell {
+	// An explicit longer per-call timeout raises the deadline, mirroring bash keeping explicit timeouts.
+	const hardLimitSeconds = Math.max(init.defaultHardLimitSeconds, init.input.timeout ?? 0);
+	const runBudgetSeconds = init.input.timeout ?? init.defaultRunBudgetSeconds;
+	return {
+		cellId: init.cellId,
+		input: init.input,
+		spillPath: detachedNotificationSpillPath(init.artifactsDir, init.cellId),
+		startedAtMs: init.now(),
+		state: "running",
+		canDetach: false,
+		wasDetached: false,
+		kernel: undefined,
+		stateRetained: undefined,
+		interruptNote: undefined,
+		interruptOutcome: undefined,
+		liveResult: undefined,
+		terminalResult: undefined,
+		notificationQueued: false,
+		deadlines: new CellDeadlines({
+			cellId: init.cellId,
+			hardLimitSeconds,
+			runBudgetSeconds,
+			onExpire: (expiry) => init.onExpire(init.cellId, expiry),
+		}),
+		hardLimitSeconds,
+		runBudgetSeconds,
+		hardLimited: false,
+		runBudgetExhausted: false,
+		onKill: init.onKill,
+		terminal: Promise.withResolvers<EvalDetachedCellSnapshot>(),
+	};
+}

package/src/tool/render.ts

@@ -71,10 +71,15 @@ const TOOL_CALL_COLLAPSED_VISUAL_LINES = 4;
 const TOOL_CALL_COLLAPSED_ERROR_CODE_POINTS = 512;
 const TOOL_ERROR_OMISSION_MARKER = "[tool error omitted]";
 const LIVE_ELAPSED_TICK_MS = 1_000;
+// A live row repaints on every tick, so this many ticks without a render means the row is gone.
+const LIVE_TICKER_MAX_IDLE_TICKS = 60;
 
 class PlainTextComponent implements EvalRenderComponent {
 	#blocks: readonly RenderBlock[] = [];
 	#ticker: ReturnType<typeof setInterval> | undefined;
+	#live = false;
+	#invalidate: (() => void) | undefined;
+	#idleTicks = 0;
 
 	setBlocks(blocks: readonly RenderBlock[]): void {
 		this.#blocks = blocks;
@@ -84,16 +89,19 @@ class PlainTextComponent implements EvalRenderComponent {
 	 * The host only animates tool rows for streaming args, `task`, and results carrying
 	 * `details.progress`; an eval row matches none of them, so nothing repaints it between
 	 * update events. While a cell is non-terminal this drives the repaint itself so the
-	 * header's elapsed time advances, and it emits no tool updates or RPC traffic.
+	 * header's elapsed time advances, and it emits no tool updates or RPC traffic. Detached
+	 * and terminal cards never arm it, and a ticker whose row stopped rendering (transcript
+	 * rebuild, session switch) stops itself after LIVE_TICKER_MAX_IDLE_TICKS and rearms on
+	 * the next render, so dropped rows cannot accumulate intervals.
 	 */
 	syncLiveTicker(isLive: boolean, invalidate: () => void): void {
+		this.#live = isLive;
+		this.#invalidate = invalidate;
 		if (!isLive) {
 			this.stopLiveTicker();
 			return;
 		}
-		if (this.#ticker !== undefined) return;
-		this.#ticker = setInterval(invalidate, LIVE_ELAPSED_TICK_MS);
-		this.#ticker.unref?.();
+		this.#armTicker();
 	}
 
 	stopLiveTicker(): void {
@@ -102,7 +110,24 @@ class PlainTextComponent implements EvalRenderComponent {
 		this.#ticker = undefined;
 	}
 
+	#armTicker(): void {
+		if (this.#ticker !== undefined || this.#invalidate === undefined) return;
+		this.#ticker = setInterval(() => this.#tick(), LIVE_ELAPSED_TICK_MS);
+		this.#ticker.unref?.();
+	}
+
+	#tick(): void {
+		this.#idleTicks += 1;
+		if (this.#idleTicks >= LIVE_TICKER_MAX_IDLE_TICKS) {
+			this.stopLiveTicker();
+			return;
+		}
+		this.#invalidate?.();
+	}
+
 	render(width: number): string[] {
+		this.#idleTicks = 0;
+		if (this.#live) this.#armTicker();
 		const lines: string[] = [];
 		for (const block of this.#blocks) {
 			switch (block.kind) {
@@ -269,7 +294,7 @@ function spinner(frame: number | undefined): string {
 }
 
 function isLiveCellStatus(status: CellStatus): boolean {
-	return status === "pending" || status === "running" || status === "detached";
+	return status === "pending" || status === "running";
 }
 
 function cellPresentation(status: CellStatus, spinnerFrame: number | undefined): StatusPresentation {

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

@@ -49,6 +49,12 @@ export async function runEvalCell(
 	let detached = false;
 	let execution: CellExecution;
 	const cell = cellManager.create(invocation.cellId, invocation.input, (error) => execution.cancel(error));
+	const detach = (): boolean => {
+		if (!cellManager.detach(cell)) return false;
+		detached = true;
+		execution.detach();
+		return true;
+	};
 	execution = new CellExecution({
 		callerSignal: invocation.signal,
 		cellId: invocation.cellId,
@@ -58,12 +64,7 @@ export async function runEvalCell(
 						timeoutMs: detachAfterMs,
 						maxPauseGraceMs: foregroundWindowMs,
 						onTimeout: (error: Error) => {
-							if (cellManager.detach(cell)) {
-								detached = true;
-								execution.detach();
-								return;
-							}
-							execution.cancel(error);
+							if (!detach()) execution.cancel(error);
 						},
 					},
 				}
@@ -74,6 +75,16 @@ export async function runEvalCell(
 			bridgeAbortController.abort(error);
 		},
 	});
+	const steeringSignal =
+		detaches && invocation.ctx.mode !== "print" && invocation.ctx.mode !== "json"
+			? invocation.ctx.steeringSignal
+			: undefined;
+	const onSteering = (): void => {
+		if (!steeringSignal?.aborted || detached || !state.active || invocation.signal.aborted) return;
+		// Losing the slot keeps this call foreground; only the existing deadlines/caller may cancel it.
+		detach();
+	};
+	steeringSignal?.addEventListener("abort", onSteering, { once: true });
 	const running = executeCell(
 		options,
 		invocation,
@@ -83,6 +94,7 @@ export async function runEvalCell(
 		execution,
 		bridgeContext,
 		bridgeAbortController,
+		onSteering,
 	);
 	let settleEventEmitted = false;
 	const emitSettled = (outcome: EvalExecutionSettleOutcome): void => {
@@ -110,12 +122,16 @@ export async function runEvalCell(
 			throw error;
 		},
 	);
-	const outcome = await Promise.race([
-		finalized.then((result) => ({ kind: "result" as const, result })),
-		execution.detached.then(() => ({ kind: "detached" as const })),
-	]);
-	if (outcome.kind === "detached") return resultAfterDetach(cellManager.peek(invocation.cellId), invocation.input);
-	return outcome.result;
+	try {
+		const outcome = await Promise.race([
+			finalized.then((result) => ({ kind: "result" as const, result })),
+			execution.detached.then(() => ({ kind: "detached" as const })),
+		]);
+		if (outcome.kind === "detached") return resultAfterDetach(cellManager.peek(invocation.cellId), invocation.input);
+		return outcome.result;
+	} finally {
+		steeringSignal?.removeEventListener("abort", onSteering);
+	}
 }
 
 async function executeCell(
@@ -127,6 +143,7 @@ async function executeCell(
 	execution: CellExecution,
 	bridgeContext: ExtensionContext,
 	bridgeAbortController: AbortController,
+	onReady: () => void,
 ): Promise<AgentToolResult<EvalToolDetails>> {
 	let handler: CellHandler | undefined;
 	try {
@@ -168,6 +185,8 @@ async function executeCell(
 			() => activeHandler.liveResult(),
 			(error) => execution.cancel(error),
 		);
+		// Includes a steer already queued at execute start or received while acquiring the kernel.
+		onReady();
 		if ("setContext" in options.kernelManager && typeof options.kernelManager.setContext === "function") {
 			options.kernelManager.setContext(bridgeContext);
 		}

package/src/tool/terminal-snapshot-store.ts

@@ -0,0 +1,35 @@
+import type { EvalDetachedCellSnapshot } from "./detached-cell-contract.ts";
+
+export const TERMINAL_SNAPSHOT_CAP = 32;
+
+/** Bounded LRU of settled-cell snapshots; without it every settled cell pins its result and closures for the session lifetime (#1695). */
+export class TerminalSnapshotStore {
+	readonly #snapshots = new Map<string, EvalDetachedCellSnapshot>();
+	readonly #cap: number;
+
+	constructor(cap = TERMINAL_SNAPSHOT_CAP) {
+		this.#cap = cap;
+	}
+
+	remember(snapshot: EvalDetachedCellSnapshot): void {
+		this.#snapshots.delete(snapshot.cellId);
+		this.#snapshots.set(snapshot.cellId, snapshot);
+		while (this.#snapshots.size > this.#cap) {
+			const oldest = this.#snapshots.keys().next();
+			if (oldest.done === true) break;
+			this.#snapshots.delete(oldest.value);
+		}
+	}
+
+	get(cellId: string): EvalDetachedCellSnapshot | undefined {
+		return this.#snapshots.get(cellId);
+	}
+
+	delete(cellId: string): void {
+		this.#snapshots.delete(cellId);
+	}
+
+	clear(): void {
+		this.#snapshots.clear();
+	}
+}

package/src/tool/tool-result-marshal.ts

@@ -0,0 +1,23 @@
+import type { AgentToolResult } from "@code-yeongyu/senpi";
+
+export function marshalToolResult(result: AgentToolResult<unknown>) {
+	const texts = result.content.filter((part) => part.type === "text").map((part) => part.text);
+	const images = result.content
+		.filter((part) => part.type === "image")
+		.map((part) => ({ mimeType: part.mimeType, dataBase64: part.data }));
+	const details =
+		typeof result.details === "object" &&
+		result.details !== null &&
+		!Array.isArray(result.details) &&
+		Object.keys(result.details).length === 0
+			? undefined
+			: result.details;
+	const hasError = toolResultIsError(result);
+	const text = texts.join("\n");
+	return images.length === 0 && details === undefined && !hasError ? { text } : { text, details, images, hasError };
+}
+
+export function toolResultIsError(result: AgentToolResult<unknown>): boolean {
+	const details = result.details;
+	return typeof details === "object" && details !== null && "isError" in details && details.isError === true;
+}

package/src/tool/tool-widgets.ts

@@ -139,6 +139,15 @@ function renderWith<TParams extends TSchema, TDetails, TState>(
 	}
 }
 
+function grepDetailsSummary(summary: EvalToolCallSummary): string | undefined {
+	const details = summary.details;
+	if (details === undefined || details === null || typeof details !== "object") return undefined;
+	const record = details as { matchCount?: unknown; fileCount?: unknown; engine?: unknown };
+	if (typeof record.fileCount !== "number" || typeof record.engine !== "string") return undefined;
+	if (record.matchCount !== null && typeof record.matchCount !== "number") return undefined;
+	return `matches=${record.matchCount ?? "n/a"} files=${record.fileCount} (${record.engine})`;
+}
+
 function createCoreWidgets(cwd: string): CoreWidgets {
 	const bashDefinition = createBashToolDefinition(cwd);
 	const readDefinition = createReadToolDefinition(cwd);
@@ -155,7 +164,13 @@ function createCoreWidgets(cwd: string): CoreWidgets {
 			}),
 		read: (summary, options) => renderWith(readDefinition, summary, options, {}),
 		write: (summary, options) => renderWith(writeDefinition, summary, options, {}),
-		grep: (summary, options) => renderWith(grepDefinition, summary, options, {}),
+		grep: (summary, options) => {
+			const lines = renderWith(grepDefinition, summary, options, {});
+			if (lines === undefined) return undefined;
+			const extra = grepDetailsSummary(summary);
+			if (extra !== undefined) lines.push(`  ${style(options.theme, "muted", extra)}`);
+			return lines;
+		},
 		find: (summary, options) => renderWith(findDefinition, summary, options, {}),
 		ls: (summary, options) => renderWith(lsDefinition, summary, options, {}),
 	};

package/src/tool/types.ts

@@ -153,6 +153,7 @@ export interface EvalToolCallSummary {
 	readonly argsTruncated?: boolean;
 	readonly durationMs?: number;
 	readonly resultPreview?: string;
+	readonly details?: unknown;
 }
 
 export type EvalStatusEvent = { readonly op: string } & Readonly<Record<string, unknown>>;