@code-yeongyu/senpi 2026.9.15 → 2026.9.16

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/detached-cell-manager.ts

@@ -1,14 +1,12 @@
 import type { AgentToolResult } from "@code-yeongyu/senpi";
 import { DEFAULT_HARD_LIMIT_SECONDS, DEFAULT_RUN_BUDGET_SECONDS } from "../config/settings.ts";
 import type { WakeSourceState } from "../extension/wake-source-state.ts";
-import { type CellDeadlineExpiry, CellDeadlines } from "./cell-deadlines.ts";
+import type { CellDeadlineExpiry } from "./cell-deadlines.ts";
 import type {
 	EvalDetachedCellManagerOptions,
 	EvalDetachedCellSnapshot,
-	EvalDetachedCellState,
 	EvalDetachedCellStatusEntry,
 } from "./detached-cell-contract.ts";
-import { detachedNotificationSpillPath } from "./detached-cell-notification.ts";
 import { currentDetachedResult, detachedErrorResult, snapshotDetachedCell } from "./detached-cell-snapshot.ts";
 import {
 	activeDetachedCellReuseError,
@@ -17,6 +15,8 @@ import {
 } from "./detached-cell-state.ts";
 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 { TerminalSnapshotStore } from "./terminal-snapshot-store.ts";
 import type { EvalKernel, EvalLanguage, EvalToolDetails, EvalToolInput } from "./types.ts";
 
 export type {
@@ -28,40 +28,13 @@ export type {
 	EvalDetachedCellStatusEntry,
 } from "./detached-cell-contract.ts";
 
-type LiveResultProvider = () => AgentToolResult<EvalToolDetails>;
-
-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 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>();
 	readonly #detachedByLanguage = new Map<EvalLanguage, ManagedCell>();
+	readonly #terminalSnapshots = new TerminalSnapshotStore();
 	readonly #notificationQueue: DetachedNotificationQueue;
 	readonly #now: () => number;
 	readonly #hardLimitSeconds: number;
@@ -83,40 +56,20 @@ export class EvalDetachedCellManager {
 			if (detachedCellIsActive(existing.state)) throw activeDetachedCellReuseError(existing);
 			this.#cells.delete(cellId);
 		}
-		// An explicit longer per-call timeout raises the deadline, mirroring bash keeping explicit timeouts.
-		const hardLimitSeconds = Math.max(this.#hardLimitSeconds, input.timeout ?? 0);
-		const runBudgetSeconds = input.timeout ?? this.#runBudgetSeconds;
-		const cell: ManagedCell = {
+		this.#terminalSnapshots.delete(cellId);
+		const cell = createManagedCell({
 			cellId,
 			input,
-			spillPath: detachedNotificationSpillPath(this.#artifactsDir, cellId),
-			startedAtMs: this.#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,
-				hardLimitSeconds,
-				runBudgetSeconds,
-				onExpire: (expiry) => {
-					const managed = this.#cells.get(cellId);
-					if (managed !== undefined) void this.#expireDeadline(managed, expiry);
-				},
-			}),
-			hardLimitSeconds,
-			runBudgetSeconds,
-			hardLimited: false,
-			runBudgetExhausted: false,
+			artifactsDir: this.#artifactsDir,
+			now: this.#now,
+			defaultHardLimitSeconds: this.#hardLimitSeconds,
+			defaultRunBudgetSeconds: this.#runBudgetSeconds,
 			onKill,
-			terminal: Promise.withResolvers<EvalDetachedCellSnapshot>(),
-		};
+			onExpire: (expiredId, expiry) => {
+				const managed = this.#cells.get(expiredId);
+				if (managed !== undefined) void this.#expireDeadline(managed, expiry);
+			},
+		});
 		this.#cells.set(cellId, cell);
 		return cell;
 	}
@@ -166,13 +119,15 @@ export class EvalDetachedCellManager {
 	}
 
 	async stop(cellId: string, reason = "Stopped detached eval cell"): Promise<EvalDetachedCellSnapshot> {
-		const cell = this.#get(cellId);
-		if (cell.state === "detached") await this.#cancel(cell, reason);
-		return this.#snapshot(cell);
+		const live = this.#cells.get(cellId);
+		if (live === undefined) return this.#terminal(cellId);
+		if (live.state === "detached") await this.#cancel(live, reason);
+		return this.#snapshot(live);
 	}
 
 	peek(cellId: string): EvalDetachedCellSnapshot {
-		return this.#snapshot(this.#get(cellId));
+		const live = this.#cells.get(cellId);
+		return live === undefined ? this.#terminal(cellId) : this.#snapshot(live);
 	}
 
 	busyFor(language: EvalLanguage): EvalDetachedCellSnapshot | undefined {
@@ -181,7 +136,8 @@ export class EvalDetachedCellManager {
 	}
 
 	async waitForTerminal(cellId: string): Promise<EvalDetachedCellSnapshot> {
-		return await this.#get(cellId).terminal.promise;
+		const live = this.#cells.get(cellId);
+		return live === undefined ? this.#terminal(cellId) : await live.terminal.promise;
 	}
 
 	async dispose(): Promise<void> {
@@ -191,6 +147,8 @@ export class EvalDetachedCellManager {
 		);
 		if (detached.length === 0) this.#emitWakeSourceState([]);
 		await this.#notificationQueue.flush();
+		this.#cells.clear();
+		this.#terminalSnapshots.clear();
 	}
 
 	async flushNotifications(): Promise<void> {
@@ -213,6 +171,8 @@ export class EvalDetachedCellManager {
 		cell.terminalResult = result;
 		cell.liveResult = undefined;
 		cell.terminal.resolve(this.#snapshot(cell));
+		this.#cells.delete(cell.cellId);
+		this.#refreshTerminalSnapshot(cell);
 		if (cell.wasDetached) {
 			if (this.#detachedByLanguage.get(cell.input.language) === cell)
 				this.#detachedByLanguage.delete(cell.input.language);
@@ -257,9 +217,14 @@ export class EvalDetachedCellManager {
 			cell.stateRetained = await handle.stateRetained;
 		} finally {
 			outcome.resolve();
+			this.#refreshTerminalSnapshot(cell);
 		}
 	}
 
+	#refreshTerminalSnapshot(cell: ManagedCell): void {
+		if (!this.#cells.has(cell.cellId)) this.#terminalSnapshots.remember(this.#snapshot(cell));
+	}
+
 	#emitStatus(): void {
 		const liveCells = [...this.#detachedByLanguage.values()];
 		this.#onStatusChange?.(detachedStatusEntries(liveCells));
@@ -274,9 +239,9 @@ export class EvalDetachedCellManager {
 		return snapshotDetachedCell(cell, this.#now());
 	}
 
-	#get(cellId: string): ManagedCell {
-		const cell = this.#cells.get(cellId);
-		if (cell === undefined) throw new Error(`Unknown detached eval cell "${cellId}"`);
-		return cell;
+	#terminal(cellId: string): EvalDetachedCellSnapshot {
+		const snapshot = this.#terminalSnapshots.get(cellId);
+		if (snapshot === undefined) throw new Error(`Unknown detached eval cell "${cellId}"`);
+		return snapshot;
 	}
 }

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/image-resize.ts

@@ -0,0 +1,52 @@
+import type { ExtensionContext } from "@code-yeongyu/senpi";
+import { convertToPng, formatDimensionNote, resizeImage } from "@code-yeongyu/senpi";
+
+export interface EvalImageContent {
+	readonly type: "image";
+	readonly data: string;
+	readonly mimeType: string;
+}
+
+export interface EvalImageResizeResult {
+	readonly image: EvalImageContent;
+	readonly dimensionNote?: string;
+}
+
+export type EvalImageResizer = (
+	image: EvalImageContent,
+	model: ExtensionContext["model"],
+) => Promise<EvalImageResizeResult>;
+
+type WebpModel = { readonly provider: string; readonly api: string } | undefined;
+
+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 }) };
+};

package/node_modules/@code-yeongyu/senpi-codemode/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/node_modules/@code-yeongyu/senpi-codemode/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/node_modules/@code-yeongyu/senpi-codemode/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/node_modules/@code-yeongyu/senpi-codemode/src/tool/run-eval-cell.ts

@@ -1,7 +1,8 @@
 import { randomUUID } from "node:crypto";
 import { join } from "node:path";
-import type { AgentToolResult, ExtensionContext } from "@code-yeongyu/senpi";
+import { type AgentToolResult, type ExtensionContext, kernelToolsStorage } from "@code-yeongyu/senpi";
 import { DEFAULT_FOREGROUND_WINDOW_SECONDS, defaultCodemodeSettings } from "../config/settings.ts";
+import type { KernelToolsCapability } from "../kernels/js/kernel-tools-types.ts";
 import { TIMEOUT_PAUSE_OP, TIMEOUT_RESUME_OP } from "../timeouts/bridge-timeout.ts";
 import { abortError, CellExecution, defaultTimeoutFactory } from "./cell-execution.ts";
 import { CellHandler, type CellState } from "./cell-handler.ts";
@@ -11,7 +12,7 @@ import { buildEvalExecutionEventPayload, type EvalExecutionSettleOutcome } from
 import { evalTimeoutBehavior } from "./eval-request.ts";
 import type { CreateEvalToolOptions, EvalCellInvocation } from "./eval-tool-options.ts";
 import { describeTimeoutState } from "./interrupt-note.ts";
-import type { EvalToolDetails } from "./types.ts";
+import type { EvalKernel, EvalToolDetails } from "./types.ts";
 
 export async function runEvalCell(
 	options: CreateEvalToolOptions,
@@ -166,34 +167,39 @@ async function executeCell(
 				void pending.catch((error: unknown) => execution.cancel(error));
 			}),
 		);
-		execution.setKernel(kernel);
-		const activeHandler = new CellHandler(kernel, state, {
-			executeTool: options.executeTool,
-			...(options.listTools === undefined ? {} : { listTools: options.listTools }),
-			settings: options.settings ?? defaultCodemodeSettings,
-			...(options.complete === undefined ? {} : { complete: options.complete }),
-			ctx: bridgeContext,
-			...(options.artifactsDir === undefined
-				? {}
-				: { artifactPath: join(options.artifactsDir, `eval-${randomUUID()}.log`) }),
-			...(options.imageResizer === undefined ? {} : { imageResizer: options.imageResizer }),
-		});
-		handler = activeHandler;
-		cellManager.markRunning(
-			cell,
-			kernel,
-			() => 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);
-		}
-		if (invocation.input.reset) await execution.wait(kernel.reset());
-		const result = await execution.wait(kernel.run({ cellId: invocation.cellId, code: invocation.input.code }));
-		if (result.ok && state.pendingBridgeCalls.length > 0) await execution.wait(Promise.all(state.pendingBridgeCalls));
-		return await handler.finalize(result);
+		const runBound = async (): Promise<AgentToolResult<EvalToolDetails>> => {
+			execution.setKernel(kernel);
+			const activeHandler = new CellHandler(kernel, state, {
+				executeTool: options.executeTool,
+				...(options.listTools === undefined ? {} : { listTools: options.listTools }),
+				settings: options.settings ?? defaultCodemodeSettings,
+				...(options.complete === undefined ? {} : { complete: options.complete }),
+				ctx: bridgeContext,
+				...(options.artifactsDir === undefined
+					? {}
+					: { artifactPath: join(options.artifactsDir, `eval-${randomUUID()}.log`) }),
+				...(options.imageResizer === undefined ? {} : { imageResizer: options.imageResizer }),
+			});
+			handler = activeHandler;
+			cellManager.markRunning(
+				cell,
+				kernel,
+				() => 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);
+			}
+			if (invocation.input.reset) await execution.wait(kernel.reset());
+			const result = await execution.wait(kernel.run({ cellId: invocation.cellId, code: invocation.input.code }));
+			if (result.ok && state.pendingBridgeCalls.length > 0)
+				await execution.wait(Promise.all(state.pendingBridgeCalls));
+			return await handler.finalize(result);
+		};
+		const kernelTools = jsKernelTools(kernel, invocation.input.language);
+		return kernelTools ? await kernelToolsStorage.run(kernelTools, runBound) : await runBound();
 	} catch (error) {
 		if (handler && error instanceof Error && error.name === "CodemodeSessionDisposedError")
 			return await handler.finalizeCancellation(error);
@@ -206,3 +212,16 @@ async function executeCell(
 		if (handler) await handler.flushOutput();
 	}
 }
+
+function jsKernelTools(kernel: EvalKernel, language: string): KernelToolsCapability | undefined {
+	if (language !== "js") return undefined;
+	if (!("describeKernelTools" in kernel) || typeof kernel.describeKernelTools !== "function") return undefined;
+	const js = kernel as EvalKernel & {
+		describeKernelTools: KernelToolsCapability["describe"];
+		invokeKernelTool: KernelToolsCapability["invoke"];
+	};
+	return {
+		describe: (names) => js.describeKernelTools(names),
+		invoke: (request, signal) => js.invokeKernelTool(request, signal),
+	};
+}