@code-yeongyu/senpi-codemode 2026.7.25-2 → 2026.7.28

package/src/tool/eval-tool.ts

@@ -1,38 +1,51 @@
 import { randomUUID } from "node:crypto";
 import { join } from "node:path";
 import type { AgentToolResult, AgentToolUpdateCallback, ExtensionContext, ToolDefinition } from "@code-yeongyu/senpi";
+import type { EvalSchemaToolInfo } from "../bridges/schema-bridge.ts";
 import type { CompletionRequest, CompletionResult } from "../completion/handler.ts";
 import { defaultCodemodeSettings, type ResolvedCodemodeSettings } from "../config/settings.ts";
 import type { EvalExecutionTracker } from "../extension/session-manager.ts";
 import { buildEvalPrompt } from "../prompt/eval-prompt.ts";
 import { TIMEOUT_PAUSE_OP, TIMEOUT_RESUME_OP } from "../timeouts/bridge-timeout.ts";
-import { IdleTimeout } from "../timeouts/idle-timeout.ts";
+import { IdleTimeout, type IdleTimeoutOptions, type TimeoutPauseHandle } from "../timeouts/idle-timeout.ts";
 import { CellHandler, type CellState } from "./cell-handler.ts";
+import { EvalDetachedCellManager, type EvalDetachedCellSnapshot } from "./detached-cell-manager.ts";
 import type { EvalImageResizer } from "./image.ts";
+import { describeTimeoutState, interruptionStateNote } from "./interrupt-note.ts";
 import {
 	createEvalInputSchema,
 	type EnabledEvalLanguages,
+	type EvalCellResult,
+	type EvalControlInput,
 	type EvalInputSchema,
 	type EvalKernel,
 	type EvalKernelManager,
 	type EvalToolDetails,
 	type EvalToolInput,
+	type EvalToolRequest,
 	type ExecuteTool,
 	enabledLanguageList,
 } from "./types.ts";
 
 export type { EnabledEvalLanguages, EvalKernel, EvalKernelManager } from "./types.ts";
 
+export interface EvalTimeoutFactory {
+	create(options: IdleTimeoutOptions): TimeoutPauseHandle & { dispose(): void };
+}
+
 export interface CreateEvalToolOptions {
 	readonly enabledLanguages: EnabledEvalLanguages;
 	readonly kernelManager: EvalKernelManager;
 	readonly cellTimeoutSeconds: number;
 	readonly executeTool: ExecuteTool;
+	readonly listTools?: () => readonly EvalSchemaToolInfo[];
 	readonly complete?: (request: CompletionRequest, ctx: ExtensionContext) => Promise<CompletionResult>;
 	readonly settings?: ResolvedCodemodeSettings;
 	readonly artifactsDir?: string;
 	readonly imageResizer?: EvalImageResizer;
 	readonly executionTracker?: EvalExecutionTracker;
+	readonly cellManager?: EvalDetachedCellManager;
+	readonly timeoutFactory?: EvalTimeoutFactory;
 	readonly proxyExecutor?: (params: EvalToolInput, signal?: AbortSignal) => Promise<AgentToolResult<EvalToolDetails>>;
 	readonly renderers?: Pick<ToolDefinition<EvalInputSchema, EvalToolDetails>, "renderCall" | "renderResult">;
 	/** Whether the task-tool spawn helpers (agent()/output()/<dag>) are advertised in the prompt. */
@@ -56,18 +69,29 @@ interface EvalCellInvocation {
 interface CellExecutionOptions {
 	readonly callerSignal: AbortSignal;
 	readonly cellId: string;
-	readonly onAbort: (error: Error) => void;
 	readonly timeoutMs: number;
+	readonly timeoutFactory: EvalTimeoutFactory;
+	readonly onTimeout: (error: Error) => void;
+	readonly onAbort: (error: Error) => void;
 }
 
 const INTERRUPT_DELIVERY_GRACE_MS = 100;
+const NON_INTERACTIVE_MODES = new Set(["print", "json"]);
+
+const defaultTimeoutFactory: EvalTimeoutFactory = {
+	create(options): IdleTimeout {
+		return new IdleTimeout(options);
+	},
+};
 
 class CellExecution {
 	readonly #callerSignal: AbortSignal;
 	readonly #onAbort: (error: Error) => void;
 	readonly #abortPromise: Promise<never>;
-	readonly #watchdog: IdleTimeout;
+	readonly #detachedPromise: Promise<void>;
+	readonly #watchdog: TimeoutPauseHandle & { dispose(): void };
 	#rejectAbort: ((reason?: unknown) => void) | undefined;
+	#resolveDetached: (() => void) | undefined;
 	#kernel: EvalKernel | undefined;
 	#interruptDeadline: ReturnType<typeof setTimeout> | undefined;
 	#active = true;
@@ -78,26 +102,44 @@ class CellExecution {
 		this.#abortPromise = new Promise<never>((_resolve, reject) => {
 			this.#rejectAbort = reject;
 		});
-		this.#watchdog = new IdleTimeout({
+		this.#detachedPromise = new Promise<void>((resolve) => {
+			this.#resolveDetached = resolve;
+		});
+		this.#watchdog = options.timeoutFactory.create({
 			cellId: options.cellId,
 			timeoutMs: options.timeoutMs,
-			onTimeout: ({ error }) => this.#abort(error),
+			onTimeout: ({ error }) => options.onTimeout(error),
 		});
 		this.#callerSignal.addEventListener("abort", this.#handleCallerAbort, { once: true });
 	}
 
+	get detached(): Promise<void> {
+		return this.#detachedPromise;
+	}
+
 	pause(): void {
 		this.#watchdog.pause();
 	}
+
 	resume(): void {
 		this.#watchdog.resume();
 	}
+
 	setKernel(kernel: EvalKernel): void {
 		this.#kernel = kernel;
 	}
+
+	detach(): void {
+		if (!this.#active) return;
+		this.#watchdog.dispose();
+		this.#resolveDetached?.();
+		this.#resolveDetached = undefined;
+	}
+
 	cancel(reason: unknown): void {
 		this.#abort(reason);
 	}
+
 	finish(): void {
 		this.#active = false;
 		this.#cleanup();
@@ -115,6 +157,9 @@ class CellExecution {
 		this.#abort(this.#callerSignal.reason);
 	};
 
+	/** Outcome of the most recent interrupt, when a kernel was interrupted. */
+	interruptStateRetained: Promise<boolean> | undefined;
+
 	#abort(reason: unknown): void {
 		if (!this.#active) return;
 		this.#active = false;
@@ -128,7 +173,12 @@ class CellExecution {
 		}
 		this.#interruptDeadline = setTimeout(() => this.#settleAbort(error), INTERRUPT_DELIVERY_GRACE_MS);
 		void Promise.resolve()
-			.then(() => kernel.interrupt(error.message))
+			.then(async () => {
+				const handle = await kernel.interrupt(error.message);
+				// Kernels predating the interrupt-outcome contract resolve void; leave
+				// the outcome undefined so callers report an honest unknown state.
+				this.interruptStateRetained = handle?.stateRetained;
+			})
 			.then(
 				() => this.#settleAbort(error),
 				(interruptError: unknown) => this.#settleAbort(interruptError),
@@ -160,6 +210,7 @@ export function createEvalTool(options: CreateEvalToolOptions): ToolDefinition<E
 		...(options.hostLine === undefined ? {} : { hostLine: options.hostLine }),
 	});
 	const languages = enabledLanguageList(options.enabledLanguages);
+	const cellManager = options.cellManager ?? new EvalDetachedCellManager({ artifactsDir: options.artifactsDir });
 	return {
 		name: "eval",
 		label: "Eval",
@@ -171,19 +222,23 @@ export function createEvalTool(options: CreateEvalToolOptions): ToolDefinition<E
 		...(options.renderers?.renderCall === undefined ? {} : { renderCall: options.renderers.renderCall }),
 		...(options.renderers?.renderResult === undefined ? {} : { renderResult: options.renderers.renderResult }),
 		async execute(toolCallId, params, signal, onUpdate, ctx) {
-			if (options.proxyExecutor) return await options.proxyExecutor(params, signal);
-			if (!languages.includes(params.language))
+			const request = requestFrom(params);
+			if (isControlRequest(request)) return await executeControl(cellManager, request);
+			if (options.proxyExecutor) return await options.proxyExecutor(request, signal);
+			if (!languages.includes(request.language))
 				throw new RangeError(
-					`Unsupported eval language "${params.language}". Enabled languages: ${languages.join(", ")}`,
+					`Unsupported eval language "${request.language}". Enabled languages: ${languages.join(", ")}`,
 				);
+			const busy = cellManager.busyFor(request.language);
+			if (busy !== undefined) throw kernelBusyError(busy);
 			options.executionTracker?.assertEvalExecutionAllowed();
 			const lifecycleController = new AbortController();
 			const combinedSignal = signal
 				? AbortSignal.any([signal, lifecycleController.signal])
 				: lifecycleController.signal;
-			const execution = runEvalCell(options, {
+			const execution = runEvalCell(options, cellManager, {
 				cellId: toolCallId,
-				input: params,
+				input: request,
 				signal: combinedSignal,
 				onUpdate,
 				ctx,
@@ -197,10 +252,12 @@ export function createEvalTool(options: CreateEvalToolOptions): ToolDefinition<E
 
 async function runEvalCell(
 	options: CreateEvalToolOptions,
+	cellManager: EvalDetachedCellManager,
 	invocation: EvalCellInvocation,
 ): Promise<AgentToolResult<EvalToolDetails>> {
 	if (invocation.signal.aborted) throw abortError(invocation.signal.reason);
 	const timeoutMs = Math.floor((invocation.input.timeout ?? options.cellTimeoutSeconds) * 1_000);
+	const timeoutBehavior = timeoutBehaviorFor(invocation.input, invocation.ctx);
 	const bridgeAbortController = new AbortController();
 	const cellSignal = AbortSignal.any([invocation.signal, bridgeAbortController.signal]);
 	const bridgeContext: ExtensionContext = { ...invocation.ctx, signal: cellSignal };
@@ -217,20 +274,68 @@ async function runEvalCell(
 		durationMs: 0,
 		status: "pending",
 	};
-	const execution = new CellExecution({
+	const cell = cellManager.create(invocation.cellId, invocation.input);
+	let execution: CellExecution;
+	execution = new CellExecution({
 		callerSignal: invocation.signal,
 		cellId: invocation.cellId,
+		timeoutMs,
+		timeoutFactory: options.timeoutFactory ?? defaultTimeoutFactory,
+		onTimeout: (error) => {
+			if (timeoutBehavior === "detach" && cellManager.detach(cell)) {
+				execution.detach();
+				return;
+			}
+			execution.cancel(error);
+		},
 		onAbort: (error) => {
 			state.active = false;
 			bridgeAbortController.abort(error);
 		},
-		timeoutMs,
 	});
+	const running = executeCell(
+		options,
+		invocation,
+		cellManager,
+		cell,
+		state,
+		execution,
+		bridgeContext,
+		bridgeAbortController,
+	);
+	const finalized = running.then(
+		(result) => {
+			cellManager.complete(cell, result);
+			return result;
+		},
+		(error: unknown) => {
+			cellManager.fail(cell, error instanceof Error ? error : new Error(String(error)));
+			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 detachedResult(cellManager.peek(invocation.cellId), invocation.input);
+	return outcome.result;
+}
+
+async function executeCell(
+	options: CreateEvalToolOptions,
+	invocation: EvalCellInvocation,
+	cellManager: EvalDetachedCellManager,
+	cell: Parameters<EvalDetachedCellManager["markRunning"]>[0],
+	state: CellState,
+	execution: CellExecution,
+	bridgeContext: ExtensionContext,
+	bridgeAbortController: AbortController,
+): Promise<AgentToolResult<EvalToolDetails>> {
 	let handler: CellHandler | undefined;
 	try {
-		const acquired = await execution.wait(
+		const kernel = await execution.wait(
 			options.kernelManager.getKernel(invocation.input.language, (message) => {
-				if (!state.active || !handler) return;
+				if (!state.active || handler === undefined) return;
 				if (message.type === "status") {
 					if (message.event.op === TIMEOUT_PAUSE_OP) {
 						execution.pause();
@@ -245,10 +350,10 @@ async function runEvalCell(
 				void pending.catch((error: unknown) => execution.cancel(error));
 			}),
 		);
-		const kernel = acquired;
 		execution.setKernel(kernel);
 		handler = 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,
@@ -257,6 +362,7 @@ async function runEvalCell(
 				: { artifactPath: join(options.artifactsDir, `eval-${randomUUID()}.log`) }),
 			...(options.imageResizer === undefined ? {} : { imageResizer: options.imageResizer }),
 		});
+		cellManager.markRunning(cell, kernel, () => state.output);
 		if ("setContext" in options.kernelManager && typeof options.kernelManager.setContext === "function") {
 			options.kernelManager.setContext(bridgeContext);
 		}
@@ -265,9 +371,9 @@ async function runEvalCell(
 		if (result.ok && state.pendingBridgeCalls.length > 0) await execution.wait(Promise.all(state.pendingBridgeCalls));
 		return await handler.finalize(result);
 	} catch (error) {
-		if (handler && error instanceof Error && error.name === "CodemodeSessionDisposedError") {
+		if (handler && error instanceof Error && error.name === "CodemodeSessionDisposedError")
 			return await handler.finalizeCancellation(error);
-		}
+		if (error instanceof Error && error.name === "TimeoutError") throw await describeTimeoutState(error, execution);
 		throw error;
 	} finally {
 		state.active = false;
@@ -277,6 +383,138 @@ async function runEvalCell(
 	}
 }
 
+function requestFrom(params: unknown): EvalToolRequest {
+	if (typeof params !== "object" || params === null) throw new TypeError("eval parameters must be an object");
+	const value = params as Record<string, unknown>;
+	if (value.action === "peek" || value.action === "stop") {
+		if (typeof value.cell_id !== "string" || value.cell_id.length === 0)
+			throw new TypeError(`eval action "${value.action}" requires cell_id`);
+		return { action: value.action, cell_id: value.cell_id };
+	}
+	if (value.action !== undefined && value.action !== "run")
+		throw new TypeError(`Unknown eval action "${String(value.action)}"`);
+	if (!isEvalLanguage(value.language)) throw new TypeError("eval run requires language");
+	if (typeof value.code !== "string") throw new TypeError("eval run requires code");
+	if (value.on_timeout !== undefined && value.on_timeout !== "detach" && value.on_timeout !== "error")
+		throw new TypeError(`Unknown eval on_timeout value "${String(value.on_timeout)}"`);
+	return {
+		language: value.language,
+		code: value.code,
+		...(value.action === "run" ? { action: "run" as const } : {}),
+		...(typeof value.title === "string" ? { title: value.title } : {}),
+		...(typeof value.timeout === "number" ? { timeout: value.timeout } : {}),
+		...(value.on_timeout === "detach" || value.on_timeout === "error" ? { on_timeout: value.on_timeout } : {}),
+		...(typeof value.reset === "boolean" ? { reset: value.reset } : {}),
+	};
+}
+
+function isControlRequest(request: EvalToolRequest): request is EvalControlInput {
+	return request.action === "peek" || request.action === "stop";
+}
+
+function isEvalLanguage(value: unknown): value is EvalToolInput["language"] {
+	return value === "py" || value === "js" || value === "rb" || value === "jl";
+}
+
+async function executeControl(
+	cellManager: EvalDetachedCellManager,
+	request: EvalControlInput,
+): Promise<AgentToolResult<EvalToolDetails>> {
+	const snapshot =
+		request.action === "stop" ? await cellManager.stop(request.cell_id) : cellManager.peek(request.cell_id);
+	return snapshotResult(snapshot);
+}
+
+function detachedResult(snapshot: EvalDetachedCellSnapshot, input: EvalToolInput): AgentToolResult<EvalToolDetails> {
+	return {
+		content: [
+			{
+				type: "text",
+				text: `Eval cell ${snapshot.cellId} detached and is still running in the ${input.language} kernel. Completion will arrive as a notification. Use eval({ action: "peek", cell_id: "${snapshot.cellId}" }) or eval({ action: "stop", cell_id: "${snapshot.cellId}" }).`,
+			},
+		],
+		details: {
+			language: input.language,
+			languages: [input.language],
+			...(input.title === undefined ? {} : { title: input.title }),
+			durationMs: 0,
+			toolCalls: [],
+			truncated: false,
+			statusEvents: [{ op: "detached", cellId: snapshot.cellId }],
+			cells: [
+				{
+					index: 0,
+					...(input.title === undefined ? {} : { title: input.title }),
+					code: input.code,
+					language: input.language,
+					output: snapshot.outputTail,
+					status: "detached",
+					statusEvents: [{ op: "detached", cellId: snapshot.cellId }],
+				},
+			],
+		},
+	};
+}
+
+function snapshotResult(snapshot: EvalDetachedCellSnapshot): AgentToolResult<EvalToolDetails> {
+	const terminationNote =
+		snapshot.state === "cancelled" ? interruptionStateNote(snapshot.language, snapshot.stateRetained) : undefined;
+	const text = [
+		`Eval cell ${snapshot.cellId} (${snapshot.language}) is ${snapshot.state}.`,
+		snapshot.outputTail.length === 0 ? "(no buffered output)" : snapshot.outputTail,
+		...(terminationNote === undefined ? [] : [terminationNote]),
+	].join("\n");
+	return {
+		content: [{ type: "text", text }],
+		details: {
+			language: snapshot.language,
+			languages: [snapshot.language],
+			durationMs: snapshot.result?.details.durationMs ?? 0,
+			toolCalls: snapshot.result?.details.toolCalls ?? [],
+			truncated: snapshot.result?.details.truncated ?? false,
+			...(snapshot.state === "failed" ? { isError: true } : {}),
+			statusEvents: [{ op: snapshot.state, cellId: snapshot.cellId }],
+			cells: [
+				{
+					index: 0,
+					code: "",
+					language: snapshot.language,
+					output: snapshot.outputTail,
+					status: cellStatus(snapshot.state),
+					statusEvents: [{ op: snapshot.state, cellId: snapshot.cellId }],
+				},
+			],
+		},
+	};
+}
+
+function cellStatus(state: EvalDetachedCellSnapshot["state"]): EvalCellResult["status"] {
+	switch (state) {
+		case "running":
+			return "running";
+		case "detached":
+			return "detached";
+		case "completed":
+			return "complete";
+		case "failed":
+			return "error";
+		case "cancelled":
+			return "cancelled";
+	}
+}
+
+function kernelBusyError(snapshot: EvalDetachedCellSnapshot): Error {
+	const tail = snapshot.outputTail.length === 0 ? "(no output yet)" : snapshot.outputTail;
+	return new Error(
+		`The ${snapshot.language} eval kernel is busy running detached cell ${snapshot.cellId}. Do not re-run it; use eval({ action: "peek", cell_id: "${snapshot.cellId}" }). Current output tail:\n${tail}`,
+	);
+}
+
+function timeoutBehaviorFor(input: EvalToolInput, ctx: ExtensionContext): "detach" | "error" {
+	if (input.on_timeout !== undefined) return input.on_timeout;
+	return NON_INTERACTIVE_MODES.has(ctx.mode) ? "error" : "detach";
+}
+
 function abortError(reason: unknown): Error {
 	if (reason instanceof Error && reason.name !== "AbortError") return reason;
 	const error = new Error(typeof reason === "string" ? reason : "Eval interrupted", { cause: reason });

package/src/tool/interrupt-note.ts

@@ -0,0 +1,58 @@
+import type { EvalLanguage } from "./types.ts";
+
+const TIMEOUT_STATE_GRACE_MS = 5_500;
+
+function fallbackTimeoutMessage(base: string): string {
+	return `${base} Kernel state may have been lost; re-establish any variables the next cell needs.`;
+}
+
+/**
+ * Appends the kernel's actual post-timeout state to a TimeoutError, waiting a
+ * bounded window for the interrupt outcome so the model knows whether its
+ * variables survived. Falls back to an honest unknown when no outcome arrives.
+ */
+export async function describeTimeoutState(
+	error: Error,
+	execution: { readonly interruptStateRetained: Promise<boolean> | undefined },
+): Promise<Error> {
+	const outcome = execution.interruptStateRetained;
+	if (outcome === undefined) {
+		error.message = fallbackTimeoutMessage(error.message);
+		return error;
+	}
+	let timer: ReturnType<typeof setTimeout> | undefined;
+	const retained = await Promise.race([
+		outcome,
+		new Promise<boolean | undefined>((resolve) => {
+			timer = setTimeout(() => resolve(undefined), TIMEOUT_STATE_GRACE_MS);
+		}),
+	]).finally(() => {
+		if (timer !== undefined) clearTimeout(timer);
+	});
+	if (retained === undefined) error.message = fallbackTimeoutMessage(error.message);
+	else if (retained)
+		error.message = `${error.message} The kernel remains running; its existing variables are preserved.`;
+	else
+		error.message = `${error.message} The kernel was unresponsive and restarted; variables from earlier cells are lost.`;
+	return error;
+}
+
+const LANGUAGE_LABEL: Record<EvalLanguage, string> = {
+	py: "Python kernel",
+	js: "JavaScript worker",
+	rb: "Ruby kernel",
+	jl: "Julia kernel",
+};
+
+/**
+ * Composes the user-facing note for a cancelled eval cell from the interrupt
+ * outcome the kernel actually reported — never a per-language assumption.
+ *
+ * Returns undefined when there is nothing truthful to add (no interrupt ran).
+ */
+export function interruptionStateNote(language: EvalLanguage, stateRetained: boolean | undefined): string | undefined {
+	if (stateRetained === undefined) return undefined;
+	const label = LANGUAGE_LABEL[language];
+	if (stateRetained) return `${label} was interrupted and remains running; its existing variables are preserved.`;
+	return `${label} was unresponsive to interrupt and was restarted; variables from earlier cells are lost.`;
+}

package/src/tool/render.ts

@@ -26,6 +26,7 @@ import type {
 	EvalStatusEvent,
 	EvalToolDetails,
 	EvalToolInput,
+	EvalToolRequest,
 } from "./types.ts";
 
 type EvalToolDefinition = ToolDefinition<EvalInputSchema, EvalToolDetails>;
@@ -202,7 +203,7 @@ type CellBadges = { readonly reset: boolean; readonly timeout: number | undefine
 type PrefixStyle = { readonly prefix: string; readonly continuation: string; readonly color: ThemeColor };
 type DetailedRenderContext = {
 	readonly environment: RenderEnvironment;
-	readonly args: EvalToolInput;
+	readonly args: EvalToolRequest;
 	readonly showImageFallback: boolean;
 };
 
@@ -253,10 +254,14 @@ function cellPresentation(status: CellStatus, spinnerFrame: number | undefined):
 			return { label: "pending", icon: "○", color: "muted" };
 		case "running":
 			return { label: "running", icon: spinner(spinnerFrame), color: "warning" };
+		case "detached":
+			return { label: "detached", icon: "↗", color: "warning" };
 		case "complete":
 			return { label: "done", icon: "✓", color: "success" };
 		case "error":
 			return { label: "error", icon: "✗", color: "error" };
+		case "cancelled":
+			return { label: "cancelled", icon: "×", color: "error" };
 		default:
 			return assertNever(status);
 	}
@@ -404,6 +409,9 @@ function formatStatusEvent(event: EvalStatusEvent, theme: Theme | undefined): st
 		case "phase":
 			parts.push(eventString(event.title) ?? "");
 			break;
+		case "status-events-omitted":
+			parts.push(`${eventNumber(event.count)} earlier events omitted`);
+			break;
 		default: {
 			if (event.count !== undefined) parts.push(String(event.count));
 			const path = eventString(event.path);
@@ -415,8 +423,13 @@ function formatStatusEvent(event: EvalStatusEvent, theme: Theme | undefined): st
 }
 
 function renderStatusEvents(events: readonly EvalStatusEvent[], environment: RenderEnvironment): string[] {
-	const retained = environment.expanded ? events : events.slice(-STATUS_PREVIEW_COUNT);
-	const skipped = events.length - retained.length;
+	// A bounded history stores its exact omission count in a leading marker event; fold that
+	// count into the summary line so collapsing the preview can never understate omissions.
+	const first = events[0];
+	const omittedByBound = first?.op === "status-events-omitted" && typeof first.count === "number" ? first.count : 0;
+	const visible = omittedByBound > 0 ? events.slice(1) : events;
+	const retained = environment.expanded ? visible : visible.slice(-STATUS_PREVIEW_COUNT);
+	const skipped = visible.length - retained.length + omittedByBound;
 	const lines: string[] = [];
 	if (skipped > 0) lines.push(style(environment.theme, "dim", `├ … ${skipped} earlier status events`));
 	for (const [index, event] of retained.entries()) {
@@ -613,9 +626,10 @@ function renderDetailedLines(
 	const lines: string[] = [];
 	const cells = details.cells ?? [];
 	for (const [index, cell] of cells.entries()) {
+		const run = isEvalRunInput(context.args) ? context.args : undefined;
 		const badges = {
-			reset: index === 0 && context.args.reset === true,
-			timeout: index === 0 ? context.args.timeout : undefined,
+			reset: index === 0 && run?.reset === true,
+			timeout: index === 0 ? run?.timeout : undefined,
 		};
 		appendLines(lines, renderCell(cell, context.environment, badges));
 		if (index < cells.length - 1) lines.push("");
@@ -668,6 +682,10 @@ function textOutput(result: AgentToolResult<EvalToolDetails>, showImageFallback:
 	return lines.join("\n");
 }
 
+function isEvalRunInput(args: EvalToolRequest): args is EvalToolInput {
+	return args.action !== "peek" && args.action !== "stop";
+}
+
 function toolCallRows(details: EvalToolDetails | undefined): ToolCallRow[] {
 	if (!details?.toolCalls || details.toolCalls.length === 0) return [];
 	return details.toolCalls.map((call) => {
@@ -720,7 +738,7 @@ function resultMetadata(
 }
 
 export function renderEvalCall(
-	args: EvalToolInput,
+	args: EvalToolRequest,
 	theme: Theme | undefined,
 	context: RenderContext,
 ): EvalRenderComponent {
@@ -731,6 +749,10 @@ export function renderEvalCall(
 		component.setBlocks([]);
 		return component;
 	}
+	if (!isEvalRunInput(args)) {
+		component.setBlocks([{ kind: "text", text: style(theme, "toolTitle", `eval ${args.action} ${args.cell_id}`) }]);
+		return component;
+	}
 	if (theme === undefined && context.spinnerFrame === undefined) {
 		const title = args.title === undefined ? "" : ` ${args.title}`;
 		const reset = args.reset === true ? " reset" : "";

package/src/tool/status-events.ts

@@ -1,12 +1,32 @@
 import type { EvalStatusEvent } from "./types.ts";
 
+export const STATUS_EVENT_HISTORY_LIMIT = 100;
+const OMITTED_STATUS_EVENTS_OP = "status-events-omitted";
+
+function trimStatusHistory(events: EvalStatusEvent[]): void {
+	if (events.length <= STATUS_EVENT_HISTORY_LIMIT) return;
+
+	const first = events[0];
+	if (first?.op === OMITTED_STATUS_EVENTS_OP && typeof first.count === "number") {
+		const removeCount = events.length - STATUS_EVENT_HISTORY_LIMIT;
+		events.splice(1, removeCount);
+		events[0] = { op: OMITTED_STATUS_EVENTS_OP, count: first.count + removeCount };
+		return;
+	}
+
+	const removeCount = events.length - STATUS_EVENT_HISTORY_LIMIT + 1;
+	events.splice(0, removeCount, { op: OMITTED_STATUS_EVENTS_OP, count: removeCount });
+}
+
 export function upsertStatusEvent(events: EvalStatusEvent[], event: EvalStatusEvent): void {
 	if (event.op === "agent" && typeof event.id === "string") {
 		const index = events.findIndex((candidate) => candidate.op === "agent" && candidate.id === event.id);
 		if (index >= 0) {
 			events[index] = event;
+			trimStatusHistory(events);
 			return;
 		}
 	}
 	events.push(event);
+	trimStatusHistory(events);
 }