@code-yeongyu/senpi-codemode 2026.7.31 → 2026.8.1

package/CHANGELOG.md

@@ -12,6 +12,39 @@
 
 ### Removed
 
+## [2026.8.1] - 2026-08-01
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+- Preserve rich live and terminal `eval` details when peeking detached cells,
+  including code, title, output, phase, status events, tool-call summaries,
+  duration, and structured displays; cancellation now remains authoritative
+  over late completion races
+  ([#603](https://github.com/code-yeongyu/senpi/pull/603)).
+
+### Removed
+
+## [2026.7.31-2] - 2026-07-31
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+- Include a live elapsed label in detached `eval` footer status. The ticker updates only when the rendered duration
+  changes and is disposed when the cell completes, fails, or is stopped.
+
+### Fixed
+
+### Removed
+
 ## [2026.7.31] - 2026-07-31
 
 ### Breaking Changes

package/README.md

@@ -11,9 +11,12 @@ task-tool names are known.
 - Persistent JavaScript, Python, Ruby, and Julia cells. State survives later
   cells in the same language until reset, restart, or session disposal.
 - Timeout detachment for interactive `eval`: long pure-compute cells return a
-  handle and continue in their existing kernel. Completion is injected with the
-  final value/error and buffered output; use `eval({ action: "peek"|"stop",
-  cell_id })` to inspect or terminate a detached cell.
+	handle and continue in their existing kernel. Completion is injected with the
+	final value/error and buffered output; use `eval({ action: "peek"|"stop",
+	cell_id })` to inspect or terminate a detached cell. A running peek preserves
+	the original code and title together with current output, phase, status
+	events, tool-call summaries, elapsed duration, and structured display state;
+	a terminal peek preserves the exact final result.
 - Loopback, bearer-authenticated kernel bridge with bounded JSONL frames.
 - Structured status events for file operations, environment access, phases,
   bridge activity, and delegated task progress.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-codemode",
-	"version": "2026.7.31",
+	"version": "2026.8.1",
 	"description": "Source-only senpi extension package for codemode evaluation tools",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -30,14 +30,14 @@
 	},
 	"dependencies": {
 		"@babel/parser": "8.0.4",
-		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@^2026.7.31",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@^2026.8.1",
 		"typebox": "1.3.8"
 	},
 	"peerDependencies": {
 		"@code-yeongyu/senpi": "*"
 	},
 	"devDependencies": {
-		"@code-yeongyu/senpi": "2026.7.31"
+		"@code-yeongyu/senpi": "2026.8.1"
 	},
 	"keywords": [
 		"senpi",

package/src/extension/eval-status-ticker.ts

@@ -0,0 +1,79 @@
+import type { EvalDetachedCellStatusEntry } from "../tool/detached-cell-manager.ts";
+import { formatEvalCellStatus } from "./eval-status.ts";
+
+/** Footer live-elapsed refresh cadence while at least one detached cell is running. */
+export const EVAL_STATUS_TICK_INTERVAL_MS = 1000;
+
+/** Receives the freshly formatted footer status text (undefined clears the status). */
+export type EvalStatusRender = (status: string | undefined) => void;
+
+export interface EvalStatusTickerOptions {
+	readonly render: EvalStatusRender;
+	/** Injectable clock for tests; defaults to Date.now. */
+	readonly now?: () => number;
+}
+
+/**
+ * Drives a once-per-second footer refresh while detached eval cells are running so
+ * the "↗ py · … (Ns)" elapsed label advances live instead of freezing between
+ * cell-set transitions. Same shape as the terminal builtin's MonitorStatusTicker:
+ * the interval is unref'd, and ticks producing the already-rendered label are skipped.
+ */
+export class EvalStatusTicker {
+	private readonly render: EvalStatusRender;
+	private readonly now: () => number;
+	private intervalId: NodeJS.Timeout | undefined;
+	private entries: readonly EvalDetachedCellStatusEntry[] = [];
+	private lastRenderedStatus: string | undefined;
+	private hasRendered = false;
+
+	constructor(options: EvalStatusTickerOptions) {
+		this.render = options.render;
+		this.now = options.now ?? Date.now;
+	}
+
+	get running(): boolean {
+		return this.intervalId !== undefined;
+	}
+
+	/**
+	 * Point the ticker at the current detached-cell set, render once immediately,
+	 * and start the interval while cells are live (or stop it when none remain).
+	 */
+	sync(entries: readonly EvalDetachedCellStatusEntry[]): void {
+		this.entries = entries;
+		this.hasRendered = false;
+		this.tick();
+		if (entries.length === 0) {
+			this.stopInterval();
+			return;
+		}
+		if (this.intervalId !== undefined) return;
+		const handle = setInterval(() => this.tick(), EVAL_STATUS_TICK_INTERVAL_MS);
+		handle.unref();
+		this.intervalId = handle;
+	}
+
+	/** Stop the interval and drop the retained entries. */
+	stop(): void {
+		this.stopInterval();
+		this.entries = [];
+		this.lastRenderedStatus = undefined;
+		this.hasRendered = false;
+	}
+
+	private stopInterval(): void {
+		if (this.intervalId !== undefined) {
+			clearInterval(this.intervalId);
+			this.intervalId = undefined;
+		}
+	}
+
+	private tick(): void {
+		const status = formatEvalCellStatus(this.entries, this.now());
+		if (this.hasRendered && status === this.lastRenderedStatus) return;
+		this.hasRendered = true;
+		this.lastRenderedStatus = status;
+		this.render(status);
+	}
+}

package/src/extension/eval-status.ts

@@ -31,14 +31,47 @@ function labelOf(entry: EvalDetachedCellStatusEntry): string {
 	return entry.title === undefined || entry.title.length === 0 ? entry.cellId : entry.title;
 }
 
+/**
+ * Goal-style compact elapsed label (`5s`, `3m`, `2h 30m`, `1d 2h 3m`). Mirrors
+ * the monitor builtin's formatElapsedSeconds; kept local like the rest of the
+ * duplicated status-file helpers between the two packages.
+ */
+export function formatElapsedSeconds(value: number): string {
+	const seconds = Math.max(0, Math.trunc(value));
+	if (seconds < 60) return `${seconds}s`;
+	const minutes = Math.trunc(seconds / 60);
+	if (minutes < 60) return `${minutes}m`;
+	const hours = Math.trunc(minutes / 60);
+	const remainingMinutes = minutes % 60;
+	if (hours >= 24) {
+		const days = Math.trunc(hours / 24);
+		const remainingHours = hours % 24;
+		return `${days}d ${remainingHours}h ${remainingMinutes}m`;
+	}
+	if (remainingMinutes === 0) return `${hours}h`;
+	return `${hours}h ${remainingMinutes}m`;
+}
+
+/** Whole seconds since the oldest detached cell was created; never negative on clock skew. */
+export function evalCellElapsedSeconds(entries: readonly EvalDetachedCellStatusEntry[], nowMs: number): number {
+	let oldest = Number.POSITIVE_INFINITY;
+	for (const entry of entries) oldest = Math.min(oldest, entry.startedAtMs);
+	if (!Number.isFinite(oldest)) return 0;
+	return Math.max(0, Math.round((nowMs - oldest) / 1000));
+}
+
 /** Brief footer text for the cells still running detached; undefined clears the status. */
-export function formatEvalCellStatus(entries: readonly EvalDetachedCellStatusEntry[]): string | undefined {
+export function formatEvalCellStatus(
+	entries: readonly EvalDetachedCellStatusEntry[],
+	nowMs: number,
+): string | undefined {
 	const first = entries[0];
 	if (first === undefined) return undefined;
+	const suffix = ` (${formatElapsedSeconds(evalCellElapsedSeconds(entries, nowMs))})`;
 	if (entries.length === 1) {
 		const head = `${DETACHED_GLYPH} ${first.language} · `;
-		return head + truncateEnd(labelOf(first), MAX_STATUS_LENGTH - head.length);
+		return head + truncateEnd(labelOf(first), MAX_STATUS_LENGTH - head.length - suffix.length) + suffix;
 	}
 	const head = `${DETACHED_GLYPH} eval ${entries.length}: `;
-	return head + packLabels(entries.map(labelOf), MAX_STATUS_LENGTH - head.length);
+	return head + packLabels(entries.map(labelOf), MAX_STATUS_LENGTH - head.length - suffix.length) + suffix;
 }

package/src/index.ts

@@ -5,7 +5,8 @@ import type { EvalSchemaToolInfo } from "./bridges/schema-bridge.ts";
 import { type CompletionRequest, type CompletionResult, createCompletionHandler } from "./completion/handler.ts";
 import { defaultCodemodeSettings } from "./config/settings.ts";
 import { EvalNotifier } from "./extension/eval-notifier.ts";
-import { EVAL_CELLS_STATUS_KEY, formatEvalCellStatus } from "./extension/eval-status.ts";
+import { EVAL_CELLS_STATUS_KEY } from "./extension/eval-status.ts";
+import { EvalStatusTicker } from "./extension/eval-status-ticker.ts";
 import {
 	createExecuteTool,
 	createRuntime,
@@ -44,6 +45,8 @@ export interface SenpiCodemodeOptions {
 		options: CreateCodemodeSessionManagerOptions,
 	) => CodemodeSessionManager | Promise<CodemodeSessionManager>;
 	readonly complete?: (request: CompletionRequest, ctx: ExtensionContext) => Promise<CompletionResult>;
+	/** Injectable clock for detached-cell elapsed labels; defaults to Date.now. */
+	readonly now?: () => number;
 }
 
 export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCodemodeOptions = {}): void {
@@ -59,17 +62,22 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 		getContext: () => activeContext,
 		getMode: () => "wake",
 	});
+	const statusTicker = new EvalStatusTicker({
+		...(options.now === undefined ? {} : { now: options.now }),
+		render: (status) => {
+			const ctx = activeContext;
+			if (ctx?.ui?.setStatus === undefined) return;
+			const theme = ctx.ui.theme;
+			ctx.ui.setStatus(
+				EVAL_CELLS_STATUS_KEY,
+				status === undefined || ctx.mode !== "tui" || theme === undefined
+					? status
+					: theme.bg("selectedBg", theme.fg("text", status)),
+			);
+		},
+	});
 	const showDetachedCells = (entries: readonly EvalDetachedCellStatusEntry[]): void => {
-		const ctx = activeContext;
-		if (ctx?.ui?.setStatus === undefined) return;
-		const status = formatEvalCellStatus(entries);
-		const theme = ctx.ui.theme;
-		ctx.ui.setStatus(
-			EVAL_CELLS_STATUS_KEY,
-			status === undefined || ctx.mode !== "tui" || theme === undefined
-				? status
-				: theme.bg("selectedBg", theme.fg("text", status)),
-		);
+		statusTicker.sync(entries);
 	};
 	const registerEvalForRuntime = (
 		runtime: SessionRuntime,
@@ -101,6 +109,7 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 		activeRuntime = undefined;
 		activeModelId = undefined;
 		activeCells = undefined;
+		statusTicker.stop();
 		await cells?.dispose();
 		activeContext = undefined;
 		await manager.dispose();
@@ -114,7 +123,11 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 			listTools: () => pi.getAllTools(),
 			complete,
 			settings: defaultCodemodeSettings,
-			cellManager: new EvalDetachedCellManager({ notifier, onStatusChange: showDetachedCells }),
+			cellManager: new EvalDetachedCellManager({
+				notifier,
+				onStatusChange: showDetachedCells,
+				...(options.now === undefined ? {} : { now: options.now }),
+			}),
 			executionTracker: manager,
 			renderers,
 			hostLine: hostLine(),
@@ -143,6 +156,7 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 			artifactsDir: runtime.artifactsDir,
 			notifier,
 			onStatusChange: showDetachedCells,
+			...(options.now === undefined ? {} : { now: options.now }),
 		});
 		activeCells = cellManager;
 		activeRuntime = runtime;

package/src/tool/cell-execution.ts

@@ -0,0 +1,146 @@
+import { IdleTimeout, type IdleTimeoutOptions, type TimeoutPauseHandle } from "../timeouts/idle-timeout.ts";
+import type { EvalKernel } from "./types.ts";
+
+const INTERRUPT_DELIVERY_GRACE_MS = 100;
+
+export interface EvalTimeoutFactory {
+	create(options: IdleTimeoutOptions): TimeoutPauseHandle & { dispose(): void };
+}
+
+export const defaultTimeoutFactory: EvalTimeoutFactory = {
+	create(options): IdleTimeout {
+		return new IdleTimeout(options);
+	},
+};
+
+export interface CellExecutionOptions {
+	readonly callerSignal: AbortSignal;
+	readonly cellId: string;
+	readonly timeoutMs: number;
+	readonly timeoutFactory: EvalTimeoutFactory;
+	readonly onTimeout: (error: Error) => void;
+	readonly onAbort: (error: Error) => void;
+}
+
+export class CellExecution {
+	readonly #callerSignal: AbortSignal;
+	readonly #onAbort: (error: Error) => void;
+	readonly #abortPromise: Promise<never>;
+	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;
+
+	constructor(options: CellExecutionOptions) {
+		this.#callerSignal = options.callerSignal;
+		this.#onAbort = options.onAbort;
+		this.#abortPromise = new Promise<never>((_resolve, reject) => {
+			this.#rejectAbort = reject;
+		});
+		this.#detachedPromise = new Promise<void>((resolve) => {
+			this.#resolveDetached = resolve;
+		});
+		this.#watchdog = options.timeoutFactory.create({
+			cellId: options.cellId,
+			timeoutMs: options.timeoutMs,
+			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();
+	}
+
+	async wait<Result>(operation: Promise<Result>): Promise<Result> {
+		const guarded = operation.then(
+			(value): Result | Promise<never> => (this.#active ? value : this.#abortPromise),
+			(reason: unknown): Promise<never> => (this.#active ? Promise.reject(reason) : this.#abortPromise),
+		);
+		return await Promise.race([guarded, this.#abortPromise]);
+	}
+
+	readonly #handleCallerAbort = (): void => {
+		this.#abort(this.#callerSignal.reason);
+	};
+
+	interruptStateRetained: Promise<boolean> | undefined;
+
+	#abort(reason: unknown): void {
+		if (!this.#active) return;
+		this.#active = false;
+		this.#cleanup();
+		const error = abortError(reason);
+		this.#onAbort(error);
+		const kernel = this.#kernel;
+		if (kernel === undefined) {
+			this.#settleAbort(error);
+			return;
+		}
+		this.#interruptDeadline = setTimeout(() => this.#settleAbort(error), INTERRUPT_DELIVERY_GRACE_MS);
+		void Promise.resolve()
+			.then(async () => {
+				const handle = await kernel.interrupt(error.message);
+				this.interruptStateRetained = handle?.stateRetained;
+			})
+			.then(
+				() => this.#settleAbort(error),
+				(interruptError: unknown) => this.#settleAbort(interruptError),
+			);
+	}
+
+	#settleAbort(reason: unknown): void {
+		const reject = this.#rejectAbort;
+		if (reject === undefined) return;
+		this.#rejectAbort = undefined;
+		if (this.#interruptDeadline !== undefined) clearTimeout(this.#interruptDeadline);
+		reject(reason);
+	}
+
+	#cleanup(): void {
+		this.#callerSignal.removeEventListener("abort", this.#handleCallerAbort);
+		this.#watchdog.dispose();
+		if (this.#interruptDeadline !== undefined) clearTimeout(this.#interruptDeadline);
+		this.#interruptDeadline = undefined;
+	}
+}
+
+export 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 });
+	error.name = "AbortError";
+	return error;
+}

package/src/tool/cell-handler.ts

@@ -1,9 +1,4 @@
-import {
-	type AgentToolResult,
-	type AgentToolUpdateCallback,
-	type ExtensionContext,
-	sanitizeTerminalLabel,
-} from "@code-yeongyu/senpi";
+import { type AgentToolResult, type ExtensionContext, sanitizeTerminalLabel } from "@code-yeongyu/senpi";
 import type { KernelToHostMessage } from "../bridge/protocol.ts";
 import type { AgentExecuteTool } from "../bridges/agent-bridge.ts";
 import { isReservedToolName, runReservedTool } from "../bridges/reserved-dispatch.ts";
@@ -13,15 +8,12 @@ import type { CompletionRequest, CompletionResult } from "../completion/handler.
 import { handleCompletionToolCall } from "../completion/tool-bridge.ts";
 import type { ResolvedCodemodeSettings } from "../config/settings.ts";
 import { boundToolCallArgs, capCodePoints, MAX_ENRICHED_TOOL_CALLS, toolCallResultPreview } from "./call-capture.ts";
-import {
-	type EvalImageResizer,
-	EvalOutputCollector,
-	type EvalOutputResult,
-	marshalToolResult,
-	toolResultIsError,
-} from "./image.ts";
+import { CellResultBuilder, type CellState } from "./cell-runtime.ts";
+import { type EvalImageResizer, marshalToolResult, toolResultIsError } from "./image.ts";
 import { upsertStatusEvent } from "./status-events.ts";
-import type { EvalKernel, EvalStatusEvent, EvalToolDetails, EvalToolInput } from "./types.ts";
+import type { EvalKernel, EvalStatusEvent, EvalToolDetails } from "./types.ts";
+
+export type { CellState } from "./cell-runtime.ts";
 
 type ResolvedToolReply = {
 	readonly value: unknown;
@@ -37,22 +29,6 @@ type ToolCallEnrichment = {
 	readonly argsTruncated?: true;
 };
 
-const LIVE_OUTPUT_PREVIEW_LINES = 8;
-
-export interface CellState {
-	readonly input: EvalToolInput;
-	readonly signal: AbortSignal;
-	readonly onUpdate: AgentToolUpdateCallback<EvalToolDetails> | undefined;
-	readonly toolCalls: EvalToolDetails["toolCalls"] extends readonly (infer Item)[] ? Item[] : never;
-	readonly pendingBridgeCalls: Promise<void>[];
-	readonly statusEvents: EvalStatusEvent[];
-	active: boolean;
-	output: string;
-	phase: string | undefined;
-	durationMs: number;
-	status: "pending" | "running" | "complete" | "error";
-}
-
 export interface CellBridgeRuntime {
 	readonly executeTool: AgentExecuteTool;
 	readonly listTools?: () => readonly EvalSchemaToolInfo[];
@@ -67,46 +43,40 @@ export class CellHandler {
 	readonly #kernel: EvalKernel;
 	readonly #state: CellState;
 	readonly #runtime: CellBridgeRuntime;
-	readonly #output: EvalOutputCollector;
+	readonly #resultBuilder: CellResultBuilder;
 
 	constructor(kernel: EvalKernel, state: CellState, runtime: CellBridgeRuntime) {
 		this.#kernel = kernel;
 		this.#state = state;
 		this.#runtime = runtime;
 		const settings = runtime.settings.outputSink;
-		this.#output = new EvalOutputCollector({
+		this.#resultBuilder = new CellResultBuilder({
+			state,
 			headBytes: settings.headBytes,
 			maxColumns: settings.maxColumns,
 			model: runtime.ctx.model,
 			...(runtime.artifactPath === undefined ? {} : { artifactPath: runtime.artifactPath }),
 			...(runtime.imageResizer === undefined ? {} : { imageResizer: runtime.imageResizer }),
-			onChunk: (_aggregate, cell) => {
-				state.output = cell;
-				this.#emitUpdate(false);
-			},
 		});
-		state.status = "running";
-		this.#emitUpdate(false);
 	}
 
 	async handle(message: KernelToHostMessage): Promise<void> {
 		if (!this.#state.active) return;
 		switch (message.type) {
 			case "text":
-				this.#output.push(message.data);
+				this.#resultBuilder.push(message.data);
 				return;
 			case "phase":
-				this.#state.phase = message.title;
-				this.#emitUpdate(false);
+				this.#resultBuilder.setPhase(message.title);
 				return;
 			case "status":
 				this.#recordStatus(message.event);
 				return;
 			case "log":
-				this.#output.push(`${message.message}\n`);
+				this.#resultBuilder.push(`${message.message}\n`);
 				return;
 			case "display":
-				this.#output.display(message);
+				this.#resultBuilder.display(message);
 				return;
 			case "tool-call": {
 				const pending = this.#handleToolCall(message);
@@ -125,38 +95,19 @@ export class CellHandler {
 	}
 
 	async finalize(result: Extract<KernelToHostMessage, { type: "result" }>): Promise<AgentToolResult<EvalToolDetails>> {
-		this.#state.durationMs = result.durationMs;
-		if (result.ok) {
-			if (result.valueRepr) this.#output.push(`${result.valueRepr}\n`);
-			this.#state.status = "complete";
-		} else {
-			this.#output.push(`${result.error.message}\n`);
-			this.#state.status = "error";
-		}
-		return await this.#finish(!result.ok);
+		return await this.#resultBuilder.finalize(result);
 	}
 
 	async finalizeCancellation(error: Error): Promise<AgentToolResult<EvalToolDetails>> {
-		this.#output.push(`${error.message}\n`);
-		this.#state.status = "error";
-		return await this.#finish(true);
+		return await this.#resultBuilder.finalizeCancellation(error);
 	}
 
 	async flushOutput(): Promise<void> {
-		await this.#output.flush();
+		await this.#resultBuilder.flushOutput();
 	}
 
-	async #finish(isError: boolean): Promise<AgentToolResult<EvalToolDetails>> {
-		const output = await this.#output.finish();
-		this.#state.output = output.output;
-		const details = this.#details(output, isError);
-		this.#emitUpdate(isError);
-		const text =
-			output.output ||
-			(output.images.length > 0
-				? `(displayed ${output.images.length} image${output.images.length === 1 ? "" : "s"}; no text output)`
-				: "(no output)");
-		return { content: [{ type: "text", text }, ...output.images], details };
+	liveResult(): AgentToolResult<EvalToolDetails> {
+		return this.#resultBuilder.liveResult();
 	}
 
 	async #handleToolCall(message: Extract<KernelToHostMessage, { type: "tool-call" }>): Promise<void> {
@@ -202,7 +153,7 @@ export class CellHandler {
 					? { name: message.toolName, ok: true }
 					: { name: message.toolName, ok: false, error: result.error },
 			);
-			this.#emitUpdate(false);
+			this.#resultBuilder.emitUpdate(false);
 			return;
 		}
 		const capturedArgs = boundToolCallArgs(message.args);
@@ -268,7 +219,7 @@ export class CellHandler {
 				error: { message: text },
 			});
 		}
-		this.#emitUpdate(false);
+		this.#resultBuilder.emitUpdate(false);
 	}
 
 	#pushToolCall(
@@ -301,55 +252,6 @@ export class CellHandler {
 	#recordStatus(event: EvalStatusEvent): void {
 		if (!this.#runtime.settings.statusEvents) return;
 		upsertStatusEvent(this.#state.statusEvents, event);
-		this.#emitUpdate(false);
-	}
-
-	#details(output: EvalOutputResult | undefined, isError: boolean): EvalToolDetails {
-		const statusEvents = this.#state.statusEvents.length > 0 ? [...this.#state.statusEvents] : undefined;
-		return {
-			language: this.#state.input.language,
-			languages: [this.#state.input.language],
-			...(this.#state.input.title === undefined ? {} : { title: this.#state.input.title }),
-			durationMs: this.#state.durationMs,
-			toolCalls: [...this.#state.toolCalls],
-			truncated: output?.truncated ?? false,
-			...(isError ? { isError: true } : {}),
-			...(this.#state.phase === undefined ? {} : { phase: this.#state.phase }),
-			cells: [
-				{
-					index: 0,
-					...(this.#state.input.title === undefined ? {} : { title: this.#state.input.title }),
-					code: this.#state.input.code,
-					language: this.#state.input.language,
-					output: this.#state.output,
-					status: this.#state.status,
-					durationMs: this.#state.durationMs,
-					...(statusEvents === undefined ? {} : { statusEvents }),
-					...(output?.hasMarkdown ? { hasMarkdown: true } : {}),
-				},
-			],
-			...(statusEvents === undefined ? {} : { statusEvents }),
-			...(output === undefined || output.jsonOutputs.length === 0 ? {} : { jsonOutputs: output.jsonOutputs }),
-			...(output?.notice === undefined ? {} : { notice: output.notice }),
-			...(output?.meta === undefined ? {} : { meta: output.meta }),
-		};
-	}
-
-	#liveUpdateText(): string {
-		const title = this.#state.input.title === undefined ? "" : ` ${this.#state.input.title}`;
-		const aggregateOutput = this.#output.aggregateText();
-		const outputLines = aggregateOutput.split("\n");
-		const hasTrailingNewline = aggregateOutput.endsWith("\n");
-		if (hasTrailingNewline) outputLines.pop();
-		const output = `${outputLines.slice(-LIVE_OUTPUT_PREVIEW_LINES).join("\n")}${hasTrailingNewline ? "\n" : ""}`;
-		return `1/1 cells ${this.#state.status}\n[1] ${this.#state.input.language}${title} ${this.#state.status}${output.length === 0 ? "" : `\n${output}`}`;
-	}
-
-	#emitUpdate(isError: boolean): void {
-		if (!this.#state.active) return;
-		this.#state.onUpdate?.({
-			content: [{ type: "text", text: this.#liveUpdateText() }],
-			details: this.#details(undefined, isError),
-		});
+		this.#resultBuilder.emitUpdate(false);
 	}
 }