@code-yeongyu/senpi-codemode 2026.9.9 → 2026.9.10

package/src/tool/cell-execution.ts

@@ -13,21 +13,28 @@ export const defaultTimeoutFactory: EvalTimeoutFactory = {
 	},
 };
 
+export interface CellIdleWatchdogOptions {
+	readonly timeoutMs: number;
+	/** Caps how long a host-bridge pause may suspend the idle watchdog (the foreground window for a detaching cell). */
+	readonly maxPauseGraceMs: number;
+	readonly onTimeout: (error: Error) => void;
+}
+
 export interface CellExecutionOptions {
 	readonly callerSignal: AbortSignal;
 	readonly cellId: string;
-	readonly timeoutMs: number;
-	/**
-	 * Caps how long a host-bridge pause may suspend the idle watchdog. When the cell will detach on
-	 * timeout this is set to the foreground window so a bridge-parked cell still frees the turn at the
-	 * window; left undefined (error mode) it keeps the idle-timeout default grace.
-	 */
-	readonly maxPauseGraceMs?: number;
+	/** Interactive calls detach at this idle watchdog; a call that never detaches is bounded by its deadlines alone. */
+	readonly idle?: CellIdleWatchdogOptions;
 	readonly timeoutFactory: EvalTimeoutFactory;
-	readonly onTimeout: (error: Error) => void;
 	readonly onAbort: (error: Error) => void;
 }
 
+const NO_WATCHDOG: TimeoutPauseHandle & { dispose(): void } = {
+	pause(): void {},
+	resume(): void {},
+	dispose(): void {},
+};
+
 export class CellExecution {
 	readonly #callerSignal: AbortSignal;
 	readonly #onAbort: (error: Error) => void;
@@ -49,12 +56,16 @@ export class CellExecution {
 		this.#detachedPromise = new Promise<void>((resolve) => {
 			this.#resolveDetached = resolve;
 		});
-		this.#watchdog = options.timeoutFactory.create({
-			cellId: options.cellId,
-			timeoutMs: options.timeoutMs,
-			...(options.maxPauseGraceMs === undefined ? {} : { maxPauseGraceMs: options.maxPauseGraceMs }),
-			onTimeout: ({ error }) => options.onTimeout(error),
-		});
+		const idle = options.idle;
+		this.#watchdog =
+			idle === undefined
+				? NO_WATCHDOG
+				: options.timeoutFactory.create({
+						cellId: options.cellId,
+						timeoutMs: idle.timeoutMs,
+						maxPauseGraceMs: idle.maxPauseGraceMs,
+						onTimeout: ({ error }) => idle.onTimeout(error),
+					});
 		this.#callerSignal.addEventListener("abort", this.#handleCallerAbort, {
 			once: true,
 		});

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

@@ -15,6 +15,8 @@ export interface EvalDetachedCellSnapshot {
 	readonly interruptNote?: string;
 	/** Set only when the wall-clock kill deadline ended this cell. */
 	readonly hardLimitSeconds?: number;
+	/** Set only when the cell's own execution time exhausted its run budget. */
+	readonly runBudgetSeconds?: number;
 }
 
 export interface EvalDetachedCellNotification {
@@ -38,6 +40,8 @@ export interface EvalDetachedCellManagerOptions {
 	readonly notifier?: EvalDetachedCellNotifier;
 	/** Wall-clock kill deadline in seconds; defaults to the bash-parity 1800s. */
 	readonly hardLimitSeconds?: number;
+	/** Kill deadline for a cell's own execution time in seconds; a per-call `timeout` replaces it. Defaults to 300s. */
+	readonly runBudgetSeconds?: 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,6 +1,7 @@
 import type { AgentToolResult } from "@code-yeongyu/senpi";
-import { DEFAULT_HARD_LIMIT_SECONDS } from "../config/settings.ts";
+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 {
 	EvalDetachedCellManagerOptions,
 	EvalDetachedCellSnapshot,
@@ -46,18 +47,15 @@ type ManagedCell = {
 	liveResult: LiveResultProvider | undefined;
 	terminalResult: AgentToolResult<EvalToolDetails> | undefined;
 	notificationQueued: boolean;
-	hardLimitSeconds: number;
-	hardLimitTimer: ReturnType<typeof setTimeout> | undefined;
+	readonly deadlines: CellDeadlines;
+	readonly hardLimitSeconds: number;
+	readonly runBudgetSeconds: number;
 	hardLimited: boolean;
-	onHardLimit: ((error: Error) => void) | undefined;
+	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 function hardLimitError(cellId: string, hardLimitSeconds: number): Error {
-	const error = new Error(`Eval cell ${cellId} was killed at the ${hardLimitSeconds}s hard limit.`);
-	error.name = "TimeoutError";
-	return error;
-}
-
 export class EvalDetachedCellManager {
 	readonly #artifactsDir: string | undefined;
 	readonly #onStatusChange: ((entries: readonly EvalDetachedCellStatusEntry[]) => void) | undefined;
@@ -67,6 +65,7 @@ export class EvalDetachedCellManager {
 	readonly #notificationQueue: DetachedNotificationQueue;
 	readonly #now: () => number;
 	readonly #hardLimitSeconds: number;
+	readonly #runBudgetSeconds: number;
 
 	constructor(options: EvalDetachedCellManagerOptions = {}) {
 		this.#artifactsDir = options.artifactsDir;
@@ -75,14 +74,18 @@ export class EvalDetachedCellManager {
 		this.#notificationQueue = new DetachedNotificationQueue(options.notifier);
 		this.#now = options.now ?? Date.now;
 		this.#hardLimitSeconds = options.hardLimitSeconds ?? DEFAULT_HARD_LIMIT_SECONDS;
+		this.#runBudgetSeconds = options.runBudgetSeconds ?? DEFAULT_RUN_BUDGET_SECONDS;
 	}
 
-	create(cellId: string, input: EvalToolInput): ManagedCell {
+	create(cellId: string, input: EvalToolInput, onKill?: (error: Error) => void): ManagedCell {
 		const existing = this.#cells.get(cellId);
 		if (existing !== undefined) {
 			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 = {
 			cellId,
 			input,
@@ -98,15 +101,23 @@ export class EvalDetachedCellManager {
 			liveResult: undefined,
 			terminalResult: undefined,
 			notificationQueued: false,
-			// An explicit longer per-call timeout raises the deadline, mirroring bash keeping explicit timeouts.
-			hardLimitSeconds: Math.max(this.#hardLimitSeconds, input.timeout ?? 0),
-			hardLimitTimer: undefined,
+			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,
-			onHardLimit: undefined,
+			runBudgetExhausted: false,
+			onKill,
 			terminal: Promise.withResolvers<EvalDetachedCellSnapshot>(),
 		};
 		this.#cells.set(cellId, cell);
-		this.#armHardLimit(cell);
 		return cell;
 	}
 
@@ -114,16 +125,24 @@ export class EvalDetachedCellManager {
 		cell: ManagedCell,
 		kernel: EvalKernel,
 		liveResult: LiveResultProvider,
-		/** Foreground killer: the still-awaited CellExecution owns interrupting and rejecting its own call. */
-		onHardLimit?: (error: Error) => void,
+		onKill?: (error: Error) => void,
 	): void {
 		if (cell.state !== "running") return;
-		cell.onHardLimit = onHardLimit;
+		cell.onKill = onKill ?? cell.onKill;
 		cell.kernel = kernel;
 		cell.liveResult = liveResult;
 		cell.canDetach = true;
 	}
 
+	/** A host bridge call is in flight for this cell; its run budget stops charging until {@link resume}. */
+	pause(cell: ManagedCell): void {
+		cell.deadlines.pause();
+	}
+
+	resume(cell: ManagedCell): void {
+		cell.deadlines.resume();
+	}
+
 	detach(cell: ManagedCell): boolean {
 		if (!cell.canDetach || !allowsDetachedCellTransition(cell.state, "detached")) return false;
 		cell.state = "detached";
@@ -184,7 +203,7 @@ export class EvalDetachedCellManager {
 		result: AgentToolResult<EvalToolDetails>,
 	): boolean {
 		if (!allowsDetachedCellTransition(cell.state, state)) return false;
-		this.#clearHardLimit(cell);
+		cell.deadlines.clear();
 		cell.state = state;
 		cell.terminalResult = result;
 		cell.liveResult = undefined;
@@ -207,32 +226,20 @@ export class EvalDetachedCellManager {
 		return true;
 	}
 
-	#armHardLimit(cell: ManagedCell): void {
-		const timer = setTimeout(() => void this.#expireHardLimit(cell), cell.hardLimitSeconds * 1_000);
-		timer.unref?.();
-		cell.hardLimitTimer = timer;
-	}
-
-	#clearHardLimit(cell: ManagedCell): void {
-		if (cell.hardLimitTimer === undefined) return;
-		clearTimeout(cell.hardLimitTimer);
-		cell.hardLimitTimer = undefined;
-	}
-
 	/**
-	 * The wall-clock kill deadline. Unlike the idle watchdog it is never paused by a bridge tool call and
-	 * survives detach, so it is the only bound a detached cell has.
+	 * A kill deadline fired (see {@link CellDeadlines}). A foreground cell is killed through the
+	 * CellExecution that still awaits it; a detached cell is cancelled here, which interrupts its kernel.
 	 */
-	async #expireHardLimit(cell: ManagedCell): Promise<void> {
+	async #expireDeadline(cell: ManagedCell, expiry: CellDeadlineExpiry): Promise<void> {
 		if (!detachedCellIsActive(cell.state)) return;
-		const foreground = cell.state === "running" && cell.onHardLimit !== undefined;
-		cell.hardLimited = true;
-		const error = hardLimitError(cell.cellId, cell.hardLimitSeconds);
+		const foreground = cell.state === "running" && cell.onKill !== undefined;
+		cell.hardLimited = expiry.kind === "hard-limit";
+		cell.runBudgetExhausted = expiry.kind === "run-budget";
 		if (foreground) {
-			if (this.#settle(cell, "cancelled", currentDetachedResult(cell))) cell.onHardLimit?.(error);
+			if (this.#settle(cell, "cancelled", currentDetachedResult(cell))) cell.onKill?.(expiry.error);
 			return;
 		}
-		await this.#cancel(cell, error.message);
+		await this.#cancel(cell, expiry.error.message);
 	}
 
 	async #cancel(cell: ManagedCell, reason: string): Promise<void> {

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

@@ -69,6 +69,8 @@ function textContent(cell: EvalDetachedCellSnapshot): string {
 
 function outcomeOf(cell: EvalDetachedCellSnapshot): string {
 	if (cell.hardLimitSeconds !== undefined) return `was killed at the ${cell.hardLimitSeconds}s hard limit`;
+	if (cell.runBudgetSeconds !== undefined)
+		return `was killed after exhausting its ${cell.runBudgetSeconds}s run budget (own execution time; host tool calls excluded)`;
 	if (cell.state === "completed") return "completed";
 	if (cell.state === "cancelled") return "cancelled";
 	return "failed";

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

@@ -15,6 +15,8 @@ export interface DetachedCellResultSource {
 	terminalResult: AgentToolResult<EvalToolDetails> | undefined;
 	hardLimited?: boolean;
 	hardLimitSeconds?: number;
+	runBudgetExhausted?: boolean;
+	runBudgetSeconds?: number;
 }
 
 export function snapshotDetachedCell(cell: DetachedCellResultSource, nowMs: number): EvalDetachedCellSnapshot {
@@ -31,6 +33,9 @@ export function snapshotDetachedCell(cell: DetachedCellResultSource, nowMs: numb
 		...(cell.hardLimited === true && cell.hardLimitSeconds !== undefined
 			? { hardLimitSeconds: cell.hardLimitSeconds }
 			: {}),
+		...(cell.runBudgetExhausted === true && cell.runBudgetSeconds !== undefined
+			? { runBudgetSeconds: cell.runBudgetSeconds }
+			: {}),
 	};
 }
 

package/src/tool/eval-tool-options.ts

@@ -20,15 +20,20 @@ import type {
 export interface CreateEvalToolOptions {
 	readonly enabledLanguages: EnabledEvalLanguages;
 	readonly kernelManager: EvalKernelManager;
+	/** Idle time an interactive (detach-behavior) call blocks the agent loop before the cell detaches. */
 	readonly cellTimeoutSeconds: number;
 	/**
-	 * Longest an interactive (detach-behavior) call blocks the agent loop before the cell detaches,
-	 * capping the `timeout` detach budget. Defaults to {@link DEFAULT_FOREGROUND_WINDOW_SECONDS}.
-	 * Does not affect `on_timeout: "error"` calls or the wall-clock hard limit.
+	 * Caps `cellTimeoutSeconds` and the bridge-parked grace for interactive calls. Defaults to
+	 * {@link DEFAULT_FOREGROUND_WINDOW_SECONDS}. Does not affect the kill deadlines.
 	 */
 	readonly foregroundWindowSeconds?: number;
 	/** Wall-clock kill deadline applied to every cell; only used when this factory creates its own manager. */
 	readonly hardLimitSeconds?: number;
+	/**
+	 * Kill deadline for a cell's own execution time (host tool calls excluded); a per-call `timeout`
+	 * replaces it. Rendered into the tool schema and description; also seeds a self-created manager.
+	 */
+	readonly runBudgetSeconds?: number;
 	readonly executeTool: ExecuteTool;
 	readonly listTools?: () => readonly EvalSchemaToolInfo[];
 	readonly complete?: (request: CompletionRequest, ctx: ExtensionContext) => Promise<CompletionResult>;

package/src/tool/eval-tool.ts

@@ -1,19 +1,14 @@
-import { randomUUID } from "node:crypto";
-import { join } from "node:path";
-import type { AgentToolResult, ExtensionContext, ToolDefinition } from "@code-yeongyu/senpi";
-import { DEFAULT_FOREGROUND_WINDOW_SECONDS, defaultCodemodeSettings } from "../config/settings.ts";
+import type { ToolDefinition } from "@code-yeongyu/senpi";
+import { DEFAULT_FOREGROUND_WINDOW_SECONDS } from "../config/settings.ts";
 import { buildEvalPrompt } from "../prompt/eval-prompt.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";
 import { EvalDetachedCellManager } from "./detached-cell-manager.ts";
-import { detachedKernelBusyError, executeEvalControl, resultAfterDetach } from "./detached-eval-result.ts";
-import { buildEvalExecutionEventPayload, type EvalExecutionSettleOutcome } from "./eval-execution-event.ts";
-import { clampEvalSummary, evalTimeoutBehavior, isEvalControlRequest, parseEvalRequest } from "./eval-request.ts";
-import type { CreateEvalToolOptions, EvalCellInvocation } from "./eval-tool-options.ts";
-import { describeTimeoutState } from "./interrupt-note.ts";
+import { detachedKernelBusyError, executeEvalControl } from "./detached-eval-result.ts";
+import { clampEvalSummary, isEvalControlRequest, parseEvalRequest } from "./eval-request.ts";
+import type { CreateEvalToolOptions } from "./eval-tool-options.ts";
+import { runEvalCell } from "./run-eval-cell.ts";
 import {
 	createEvalInputSchema,
+	defaultEvalDeadlineSeconds,
 	type EvalInputSchema,
 	type EvalToolDetails,
 	type EvalToolRequest,
@@ -25,10 +20,18 @@ export type { CreateEvalToolOptions } from "./eval-tool-options.ts";
 export type { EnabledEvalLanguages, EvalKernel, EvalKernelManager } from "./types.ts";
 
 export function createEvalTool(options: CreateEvalToolOptions): ToolDefinition<EvalInputSchema, EvalToolDetails> {
-	const parameters = createEvalInputSchema(options.enabledLanguages);
+	const foregroundWindowSeconds = options.foregroundWindowSeconds ?? DEFAULT_FOREGROUND_WINDOW_SECONDS;
+	const deadlines = {
+		runBudgetSeconds: options.runBudgetSeconds ?? defaultEvalDeadlineSeconds.runBudgetSeconds,
+		detachAfterSeconds: Math.min(options.cellTimeoutSeconds, foregroundWindowSeconds),
+		foregroundWindowSeconds,
+		hardLimitSeconds: options.hardLimitSeconds ?? defaultEvalDeadlineSeconds.hardLimitSeconds,
+	};
+	const parameters = createEvalInputSchema(options.enabledLanguages, deadlines);
 	const prompt = buildEvalPrompt(options.enabledLanguages, {
 		spawns: options.spawns ?? false,
 		monitor: options.monitor,
+		runBudgetSeconds: deadlines.runBudgetSeconds,
 		...(options.spawnDefaultAgent === undefined ? {} : { spawnDefaultAgent: options.spawnDefaultAgent }),
 		...(options.modelId === undefined ? {} : { modelId: options.modelId }),
 		...(options.hostLine === undefined ? {} : { hostLine: options.hostLine }),
@@ -41,6 +44,7 @@ export function createEvalTool(options: CreateEvalToolOptions): ToolDefinition<E
 		new EvalDetachedCellManager({
 			...(options.artifactsDir === undefined ? {} : { artifactsDir: options.artifactsDir }),
 			...(options.hardLimitSeconds === undefined ? {} : { hardLimitSeconds: options.hardLimitSeconds }),
+			...(options.runBudgetSeconds === undefined ? {} : { runBudgetSeconds: options.runBudgetSeconds }),
 		});
 	return {
 		name: "eval",
@@ -94,177 +98,3 @@ 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 timeoutBehavior = evalTimeoutBehavior(invocation.input, invocation.ctx);
-	const requestedTimeoutMs = Math.floor((invocation.input.timeout ?? options.cellTimeoutSeconds) * 1_000);
-	// The `timeout` (and its `cellTimeoutSeconds` default) is the detach budget for interactive calls.
-	// Cap it at the foreground window so a large `timeout` — whose real purpose is to raise the
-	// wall-clock hard limit (see EvalDetachedCellManager) — frees the turn at the window instead of
-	// blocking the agent loop for its full duration. `on_timeout: "error"` (and print/json) keep the
-	// unclamped deadline, since there the cell is killed rather than detached.
-	const foregroundWindowMs = (options.foregroundWindowSeconds ?? DEFAULT_FOREGROUND_WINDOW_SECONDS) * 1_000;
-	const timeoutMs =
-		timeoutBehavior === "detach" ? Math.min(requestedTimeoutMs, foregroundWindowMs) : requestedTimeoutMs;
-	// A cell that pauses its watchdog for a host bridge call would otherwise wait the full pause grace
-	// (~10 min) before detaching; cap the grace at the foreground window too so the detach guarantee
-	// holds for bridge-parked cells. Error mode keeps the default grace (its timeout is the deadline).
-	const bridgeAbortController = new AbortController();
-	const cellSignal = AbortSignal.any([invocation.signal, bridgeAbortController.signal]);
-	const bridgeContext: ExtensionContext = { ...invocation.ctx, signal: cellSignal };
-	const runtime = options.runtimes?.[invocation.input.language];
-	const state: CellState = {
-		input: invocation.input,
-		...(runtime === undefined ? {} : { runtime }),
-		startedAt: Date.now(),
-		signal: cellSignal,
-		onUpdate: invocation.onUpdate,
-		toolCalls: [],
-		toolCallMetrics: [],
-		pendingBridgeCalls: [],
-		statusEvents: [],
-		active: true,
-		output: "",
-		phase: undefined,
-		error: undefined,
-		durationMs: 0,
-		status: "pending",
-	};
-	const cell = cellManager.create(invocation.cellId, invocation.input);
-	let detached = false;
-	let execution: CellExecution;
-	execution = new CellExecution({
-		callerSignal: invocation.signal,
-		cellId: invocation.cellId,
-		timeoutMs,
-		...(timeoutBehavior === "detach" ? { maxPauseGraceMs: foregroundWindowMs } : {}),
-		timeoutFactory: options.timeoutFactory ?? defaultTimeoutFactory,
-		onTimeout: (error) => {
-			if (timeoutBehavior === "detach" && cellManager.detach(cell)) {
-				detached = true;
-				execution.detach();
-				return;
-			}
-			execution.cancel(error);
-		},
-		onAbort: (error) => {
-			state.active = false;
-			bridgeAbortController.abort(error);
-		},
-	});
-	const running = executeCell(
-		options,
-		invocation,
-		cellManager,
-		cell,
-		state,
-		execution,
-		bridgeContext,
-		bridgeAbortController,
-	);
-	let settleEventEmitted = false;
-	const emitSettled = (outcome: EvalExecutionSettleOutcome): void => {
-		if (settleEventEmitted) return;
-		settleEventEmitted = true;
-		options.onCellSettled?.(
-			buildEvalExecutionEventPayload({
-				cellId: invocation.cellId,
-				state,
-				outcome,
-				completedAt: Date.now(),
-				detached,
-			}),
-		);
-	};
-	const finalized = running.then(
-		(result) => {
-			cellManager.complete(cell, result);
-			emitSettled({ result });
-			return result;
-		},
-		(error: unknown) => {
-			cellManager.fail(cell, error instanceof Error ? error : new Error(String(error)));
-			emitSettled({ 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 resultAfterDetach(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 kernel = await execution.wait(
-			options.kernelManager.getKernel(invocation.input.language, (message) => {
-				if (!state.active || handler === undefined) return;
-				if (message.type === "status") {
-					if (message.event.op === TIMEOUT_PAUSE_OP) {
-						execution.pause();
-						return;
-					}
-					if (message.event.op === TIMEOUT_RESUME_OP) {
-						execution.resume();
-						return;
-					}
-				}
-				const pending = handler.handle(message);
-				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),
-		);
-		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);
-	} catch (error) {
-		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;
-		bridgeAbortController.abort();
-		execution.finish();
-		if (handler) await handler.flushOutput();
-	}
-}