@code-yeongyu/senpi-codemode 2026.10.10-10 → 2026.10.10-12

package/src/tool/render.ts

@@ -1,1128 +1,3 @@
-// allow: SIZE_OK — one eval render pipeline avoids the runtime/render TDZ that motivated this module boundary.
-import {
-	type AgentToolResult,
-	sanitizeTerminalLabel,
-	type Theme,
-	type ThemeColor,
-	type ToolDefinition,
-	type ToolRenderResultOptions,
-	truncateToVisualLines,
-	visibleWidth,
-} from "@code-yeongyu/senpi";
-import type { TruncationMeta } from "../output/output-meta.ts";
-import { highlightedCode } from "./code-preview.ts";
-import { displayCode } from "./display-code.ts";
-import { normalizeEvalSummary } from "./eval-request.ts";
-import {
-	JSON_TREE_MAX_DEPTH_COLLAPSED,
-	JSON_TREE_MAX_DEPTH_EXPANDED,
-	JSON_TREE_MAX_LINES_COLLAPSED,
-	JSON_TREE_MAX_LINES_EXPANDED,
-	JSON_TREE_SCALAR_LEN_COLLAPSED,
-	JSON_TREE_SCALAR_LEN_EXPANDED,
-	renderJsonTreeLines,
-} from "./json-tree.ts";
-import { knownLanguage, leadsWithHeadline, liveHeadline } from "./live-headline.ts";
-import { formatRuntimeBadge } from "./runtime-label.ts";
-import { codePointPrefix, formatDuration, renderToolCallWidget } from "./tool-widgets.ts";
-import type {
-	EvalCellResult,
-	EvalInputSchema,
-	EvalResultDetails,
-	EvalStatusEvent,
-	EvalToolDetails,
-	EvalToolInput,
-	EvalToolRequest,
-} from "./types.ts";
-
-type EvalToolDefinition = ToolDefinition<EvalInputSchema, EvalResultDetails>;
-type RenderContext = Parameters<NonNullable<EvalToolDefinition["renderCall"]>>[2];
-type ResultRenderContext = Parameters<NonNullable<EvalToolDefinition["renderResult"]>>[3];
-type CollapsibleKind = "code" | "output";
-
-export interface EvalRenderComponent {
-	render(width: number): string[];
-	invalidate(): void;
-}
-type ToolCallRow = {
-	readonly summary: string;
-	readonly error?: string;
-	readonly color: "success" | "error";
-};
-type RenderBlock =
-	| { readonly kind: "blank" }
-	| {
-			readonly kind: "text";
-			readonly text: string;
-			readonly maxVisualLines?: number;
-			readonly collapseKind?: CollapsibleKind;
-			readonly theme?: Theme;
-	  }
-	| {
-			readonly kind: "toolCalls";
-			readonly calls: readonly ToolCallRow[];
-			readonly expanded: boolean;
-			readonly theme?: Theme;
-	  }
-	| { readonly kind: "dynamic"; readonly render: (width: number) => readonly string[] };
-
-const CODE_PREVIEW_LINES = 4;
-const SUMMARY_PREVIEW_LINES = 3;
-const OUTPUT_PREVIEW_LINES = 8;
-const STATUS_PREVIEW_COUNT = 3;
-const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"] as const;
-const TOOL_CALL_PREVIEW_COUNT = 5;
-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_RENDER_TICK_MS = 100;
-// 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 = 600;
-
-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;
-	}
-
-	/**
-	 * 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 spinner and elapsed time advance, with 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;
-		}
-		this.#armTicker();
-	}
-
-	stopLiveTicker(): void {
-		if (this.#ticker === undefined) return;
-		clearInterval(this.#ticker);
-		this.#ticker = undefined;
-	}
-
-	#armTicker(): void {
-		if (this.#ticker !== undefined || this.#invalidate === undefined) return;
-		this.#ticker = setInterval(() => this.#tick(), LIVE_RENDER_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) {
-				case "blank":
-					lines.push("");
-					break;
-				case "toolCalls":
-					appendLines(lines, renderToolCallBlock(block, width));
-					break;
-				case "text":
-					appendLines(lines, renderTextBlock(block, width));
-					break;
-				case "dynamic":
-					appendLines(lines, block.render(width));
-					break;
-				default:
-					assertNever(block);
-			}
-		}
-		return lines;
-	}
-
-	invalidate(): void {}
-}
-
-function componentFor(context: RenderContext | ResultRenderContext): PlainTextComponent {
-	const existing = context.lastComponent;
-	if (existing instanceof PlainTextComponent) return existing;
-	return new PlainTextComponent();
-}
-
-/** Render-time clock; tests inject a fixed value so elapsed output never depends on wall time. */
-function renderNow(context: RenderContext | ResultRenderContext): number {
-	const injected: unknown = Reflect.get(context, "now");
-	return typeof injected === "number" && Number.isFinite(injected) ? injected : Date.now();
-}
-
-function hasLiveCell(details: EvalToolDetails | undefined): boolean {
-	return (details?.cells ?? []).some((cell) => isLiveCellStatus(cell.status) && cell.startedAt !== undefined);
-}
-
-function style(theme: Theme | undefined, color: ThemeColor, text: string): string {
-	return theme ? theme.fg(color, text) : text;
-}
-
-function appendLines(target: string[], source: readonly string[]): void {
-	for (const line of source) target.push(line);
-}
-
-function renderAllVisualLines(text: string, width: number): string[] {
-	return truncateToVisualLines(text, Number.POSITIVE_INFINITY, width).visualLines.map((line) => line.trimEnd());
-}
-
-// A summary has no length limit, so a collapsed block shows its first lines and marks the cut.
-function summaryVisualLines(summary: string, width: number, expanded: boolean): string[] {
-	const lines = renderAllVisualLines(summary, width);
-	if (expanded || lines.length <= SUMMARY_PREVIEW_LINES) return lines;
-	const kept = renderAllVisualLines(summary, Math.max(1, width - 1)).slice(0, SUMMARY_PREVIEW_LINES);
-	kept[SUMMARY_PREVIEW_LINES - 1] = `${kept[SUMMARY_PREVIEW_LINES - 1] ?? ""}\u2026`;
-	return kept;
-}
-
-function summaryBlock(summary: string, theme: Theme | undefined, expanded: boolean): RenderBlock {
-	return {
-		kind: "dynamic",
-		render: (width) => summaryVisualLines(summary, width, expanded).map((line) => style(theme, "muted", line)),
-	};
-}
-
-function renderTextBlock(block: Extract<RenderBlock, { kind: "text" }>, width: number): string[] {
-	if (block.maxVisualLines === undefined) return renderAllVisualLines(block.text, width);
-	const result = truncateToVisualLines(block.text, block.maxVisualLines, width);
-	const visualLines = result.visualLines.map((line) => line.trimEnd());
-	if (result.skippedCount === 0 || block.collapseKind === undefined) return visualLines;
-	return [
-		...renderAllVisualLines(
-			style(block.theme, "muted", `${result.skippedCount} earlier ${block.collapseKind} lines`),
-			width,
-		),
-		...visualLines,
-	];
-}
-
-function renderToolCall(
-	call: ToolCallRow,
-	block: Extract<RenderBlock, { kind: "toolCalls" }>,
-	width: number,
-): string[] {
-	if (call.error === undefined) return renderAllVisualLines(style(block.theme, call.color, call.summary), width);
-	if (block.expanded)
-		return renderAllVisualLines(style(block.theme, call.color, `${call.summary} (${call.error})`), width);
-
-	const guardedError = codePointPrefix(call.error, TOOL_CALL_COLLAPSED_ERROR_CODE_POINTS);
-	const guardedLines = renderAllVisualLines(
-		style(block.theme, call.color, `${call.summary} (${guardedError})`),
-		width,
-	);
-	if (guardedError.length === call.error.length && guardedLines.length <= TOOL_CALL_COLLAPSED_VISUAL_LINES)
-		return guardedLines;
-
-	const summaryLines = renderAllVisualLines(style(block.theme, call.color, call.summary), width);
-	const errorLines = renderAllVisualLines(style(block.theme, call.color, `  (${guardedError})`), width);
-	const markerLines = renderAllVisualLines(style(block.theme, "muted", TOOL_ERROR_OMISSION_MARKER), width);
-	const lines: string[] = [];
-	const summaryBudget = Math.max(1, TOOL_CALL_COLLAPSED_VISUAL_LINES - markerLines.length);
-	appendLines(lines, summaryLines.slice(0, summaryBudget));
-	const errorBudget = Math.max(0, TOOL_CALL_COLLAPSED_VISUAL_LINES - lines.length - markerLines.length);
-	appendLines(lines, errorLines.slice(0, errorBudget));
-	appendLines(lines, markerLines.slice(0, TOOL_CALL_COLLAPSED_VISUAL_LINES - lines.length));
-	return lines;
-}
-
-function renderToolCallBlock(block: Extract<RenderBlock, { kind: "toolCalls" }>, width: number): string[] {
-	const retainedCalls = block.expanded ? block.calls : block.calls.slice(-TOOL_CALL_PREVIEW_COUNT);
-	const skippedCount = block.calls.length - retainedCalls.length;
-	const toolCallNoun = skippedCount === 1 ? "call" : "calls";
-	const lines =
-		block.expanded || skippedCount === 0
-			? []
-			: renderAllVisualLines(style(block.theme, "muted", `${skippedCount} earlier tool ${toolCallNoun}`), width);
-	for (const call of retainedCalls) {
-		appendLines(lines, renderToolCall(call, block, width));
-	}
-	return lines;
-}
-
-type CellStatus = EvalCellResult["status"];
-type AgentStatus = "pending" | "running" | "completed" | "failed" | "aborted";
-type StatusPresentation = { readonly label: string; readonly icon: string; readonly color: ThemeColor };
-type RenderEnvironment = {
-	readonly expanded: boolean;
-	readonly theme: Theme | undefined;
-	readonly spinnerFrame: number | undefined;
-	readonly width: number;
-	readonly meta: TruncationMeta | undefined;
-	/** Render-time clock, injected so elapsed time is deterministic under test. */
-	readonly now: number;
-	/** Repaints the row once a background-formatted code preview is ready; absent while args stream. */
-	readonly repaint?: () => void;
-};
-type CellBadges = {
-	readonly reset: boolean;
-	readonly timeout: number | undefined;
-	readonly throughput: CellThroughput | undefined;
-};
-type CellThroughput = { readonly calls: number; readonly wallDurationMs: number | undefined };
-type PrefixStyle = { readonly prefix: string; readonly continuation: string; readonly color: ThemeColor };
-type DetailedRenderContext = {
-	readonly environment: RenderEnvironment;
-	readonly args: EvalToolRequest;
-	readonly showImageFallback: boolean;
-	readonly isFinal: boolean;
-};
-
-function assertNever(value: never): never {
-	throw new TypeError(`Unhandled eval render variant: ${String(value)}`);
-}
-
-function spinner(frame: number | undefined): string {
-	return SPINNER_FRAMES.at((frame ?? 0) % SPINNER_FRAMES.length) ?? SPINNER_FRAMES[0];
-}
-
-function isLiveCellStatus(status: CellStatus): boolean {
-	return status === "pending" || status === "running";
-}
-
-function cellPresentation(status: CellStatus, spinnerFrame: number | undefined): StatusPresentation {
-	switch (status) {
-		case "pending":
-			return { label: "pending", icon: "○", color: "muted" };
-		case "queued":
-			return { label: "queued", 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);
-	}
-}
-
-function renderPrefixed(text: string, environment: RenderEnvironment, prefixStyle: PrefixStyle): string[] {
-	const bodyLines = renderAllVisualLines(text, Math.max(1, environment.width - prefixStyle.prefix.length));
-	if (bodyLines.length === 0) return [style(environment.theme, prefixStyle.color, prefixStyle.prefix.trimEnd())];
-	return bodyLines.map(
-		(line, index) =>
-			`${style(environment.theme, prefixStyle.color, index === 0 ? prefixStyle.prefix : prefixStyle.continuation)}${line}`,
-	);
-}
-
-// A running cell only receives updates on output/status events, so a stored duration
-// freezes between them. Non-terminal cells therefore derive elapsed time from the
-// render-time clock; terminal cells keep their settled duration verbatim.
-function cellElapsedMs(cell: EvalCellResult, environment: RenderEnvironment): number | undefined {
-	if (!isLiveCellStatus(cell.status) || cell.startedAt === undefined) return cell.durationMs;
-	return Math.max(0, environment.now - cell.startedAt);
-}
-
-function cellHeader(cell: EvalCellResult, environment: RenderEnvironment, badges: CellBadges): string {
-	const presentation = cellPresentation(
-		cell.status,
-		environment.spinnerFrame ?? Math.floor((cellElapsedMs(cell, environment) ?? 0) / LIVE_RENDER_TICK_MS),
-	);
-	const runtimeBadge = cell.runtime === undefined ? "" : ` (${formatRuntimeBadge(cell.language, cell.runtime)})`;
-	let header = leadsWithHeadline(cell.status)
-		? `eval ${cell.language}${runtimeBadge} ${presentation.label}`
-		: `eval ${cell.language}${runtimeBadge} ${presentation.label} ${presentation.icon}`;
-	if (cell.queuedBehind !== undefined && cell.queuedBehind.length > 0)
-		header += ` · queued behind ${cell.queuedBehind.map(sanitizeTerminalLabel).join(", ")}`;
-	else if (cell.queuedBehind !== undefined && cell.status === "queued")
-		header += ` · waiting for the ${cell.language} kernel to be ready`;
-	const throughputBadge = badges.throughput === undefined ? undefined : formatThroughputBadge(badges.throughput);
-	if (throughputBadge !== undefined) header += ` · ${throughputBadge}`;
-	const elapsedMs = badges.throughput?.wallDurationMs ?? cellElapsedMs(cell, environment);
-	if (elapsedMs !== undefined) header += ` · ${formatDuration(elapsedMs)}`;
-	if (badges.reset) header += " · reset";
-	if (badges.timeout !== undefined) header += ` · timeout ${badges.timeout}s`;
-	if (leadsWithHeadline(cell.status))
-		header = headlined(presentation.icon, cell.summary, cell.code, header, environment);
-	return style(environment.theme, presentation.color, header);
-}
-
-// An in-progress row leads with what the cell is doing (senpi#2802); collapsed, the headline is cut so the whole
-// header stays on one line, and the code moves behind expand.
-function headlined(
-	icon: string,
-	summary: string | undefined,
-	code: string | undefined,
-	rest: string,
-	environment: RenderEnvironment,
-): string {
-	const budget = environment.expanded ? undefined : environment.width - 3 - visibleWidth(`${icon}  · ${rest}`);
-	return `${icon} ${liveHeadline(summary, code, budget)} · ${rest}`;
-}
-
-function previewText(
-	text: string,
-	maxLines: number,
-	width: number,
-): { readonly lines: string[]; readonly skipped: number } {
-	const preview = truncateToVisualLines(text, maxLines, Math.max(1, width));
-	return { lines: preview.visualLines.map((line) => line.trimEnd()), skipped: preview.skippedCount };
-}
-
-function eventString(value: unknown): string | undefined {
-	return typeof value === "string" && value.length > 0 ? value : undefined;
-}
-
-function eventNumber(value: unknown): number {
-	return typeof value === "number" && Number.isFinite(value) ? value : 0;
-}
-
-function plural(count: number, singular: string, pluralNoun: string): string {
-	return `${count} ${count === 1 ? singular : pluralNoun}`;
-}
-
-function formatCallsPerSecond(calls: number, wallDurationMs: number | undefined): string {
-	const seconds = typeof wallDurationMs === "number" && Number.isFinite(wallDurationMs) ? wallDurationMs / 1_000 : 0;
-	if (seconds <= 0) return "n/a calls/s";
-	return `${(calls / seconds).toFixed(2)} calls/s`;
-}
-
-// A cell that issued no tool calls has no throughput to report: emitting
-// "0 calls · 0.00 calls/s" is noise, so the whole badge is dropped instead.
-function formatThroughputBadge(throughput: CellThroughput): string | undefined {
-	if (throughput.calls <= 0) return undefined;
-	return `${plural(throughput.calls, "call", "calls")} · ${formatCallsPerSecond(
-		throughput.calls,
-		throughput.wallDurationMs,
-	)}`;
-}
-
-function statusIcon(op: string): string {
-	if (op.startsWith("git_")) return "⌁";
-	switch (op) {
-		case "read":
-		case "write":
-		case "cat":
-		case "touch":
-			return "▣";
-		case "ls":
-		case "cd":
-		case "pwd":
-		case "mkdir":
-			return "▤";
-		case "run":
-		case "sh":
-			return "▶";
-		case "completion":
-			return "◇";
-		case "phase":
-			return "◆";
-		default:
-			return "•";
-	}
-}
-
-function formatStatusEvent(event: EvalStatusEvent, theme: Theme | undefined): string {
-	const op = event.op;
-	const icon = style(theme, "muted", statusIcon(op));
-	const error = eventString(event.error);
-	if (error !== undefined) return `${icon} ${style(theme, "warning", op)}: ${style(theme, "dim", error)}`;
-	const parts: string[] = [];
-	switch (op) {
-		case "read": {
-			parts.push(`${eventNumber(event.chars ?? event.bytes)} chars`);
-			const path = eventString(event.path);
-			if (path !== undefined) parts.push(`from ${path}`);
-			break;
-		}
-		case "write": {
-			parts.push(`${eventNumber(event.chars ?? event.bytes)} chars`);
-			const path = eventString(event.path);
-			if (path !== undefined) parts.push(`to ${path}`);
-			break;
-		}
-		case "cat":
-			parts.push(plural(eventNumber(event.files), "file", "files"));
-			parts.push(`${eventNumber(event.chars)} chars`);
-			break;
-		case "ls":
-			parts.push(plural(eventNumber(event.count), "entry", "entries"));
-			break;
-		case "env": {
-			const action = eventString(event.action);
-			const key = eventString(event.key);
-			const value = eventString(event.value) ?? "";
-			if (action === "set" && key !== undefined) parts.push(`set ${key}=${value.slice(0, 30)}`);
-			else if (action === "get" && key !== undefined) parts.push(`${key}=${value.slice(0, 30)}`);
-			else parts.push(plural(eventNumber(event.count), "variable", "variables"));
-			break;
-		}
-		case "git_status": {
-			if (event.clean === true) parts.push("clean");
-			else {
-				const changes: string[] = [];
-				for (const key of ["staged", "modified", "untracked"] as const) {
-					const count = eventNumber(event[key]);
-					if (count > 0) changes.push(`${count} ${key}`);
-				}
-				parts.push(changes.join(", ") || "unknown");
-			}
-			const branch = eventString(event.branch);
-			if (branch !== undefined) parts.push(`on ${branch}`);
-			break;
-		}
-		case "git_diff":
-			parts.push(plural(eventNumber(event.lines), "line", "lines"));
-			if (event.staged === true) parts.push("staged");
-			break;
-		case "git_log":
-			parts.push(plural(eventNumber(event.commits), "commit", "commits"));
-			break;
-		case "run":
-		case "sh": {
-			const command = eventString(event.command ?? event.cmd);
-			if (command !== undefined) parts.push(command);
-			if (typeof event.exitCode === "number") parts.push(`exit ${event.exitCode}`);
-			break;
-		}
-		case "completion": {
-			const model = eventString(event.model);
-			const tier = eventString(event.tier);
-			if (model !== undefined) parts.push(model);
-			if (tier !== undefined && tier !== model) parts.push(tier);
-			parts.push(`${eventNumber(event.chars)} chars`);
-			break;
-		}
-		case "log":
-			parts.push(eventString(event.message) ?? "");
-			break;
-		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);
-			if (path !== undefined) parts.push(path);
-		}
-	}
-	const description = parts.filter((part) => part.length > 0).join(" · ");
-	return `${icon} ${style(theme, "muted", op)}${description.length > 0 ? ` ${style(theme, "dim", description)}` : ""}`;
-}
-
-function renderStatusEvents(events: readonly EvalStatusEvent[], environment: RenderEnvironment): string[] {
-	// 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()) {
-		const branch = index === retained.length - 1 ? "└" : "├";
-		lines.push(`${style(environment.theme, "dim", branch)} ${formatStatusEvent(event, environment.theme)}`);
-	}
-	return lines;
-}
-
-function agentStatus(value: unknown): AgentStatus {
-	switch (value) {
-		case "pending":
-		case "running":
-		case "completed":
-		case "failed":
-		case "aborted":
-			return value;
-		default:
-			return "running";
-	}
-}
-
-function coalesceAgentEvents(events: readonly EvalStatusEvent[]): EvalStatusEvent[] {
-	const rows: EvalStatusEvent[] = [];
-	const indexes = new Map<string, number>();
-	for (const event of events) {
-		const id = eventString(event.id);
-		if (id === undefined) {
-			rows.push(event);
-			continue;
-		}
-		const index = indexes.get(id);
-		if (index === undefined) {
-			indexes.set(id, rows.length);
-			rows.push(event);
-		} else rows[index] = event;
-	}
-	return rows;
-}
-
-function agentPresentation(status: AgentStatus, spinnerFrame: number | undefined): StatusPresentation {
-	switch (status) {
-		case "pending":
-			return { label: "pending", icon: "○", color: "muted" };
-		case "running":
-			return { label: "running", icon: spinner(spinnerFrame), color: "warning" };
-		case "completed":
-			return { label: "done", icon: "✓", color: "success" };
-		case "failed":
-			return { label: "failed", icon: "✗", color: "error" };
-		case "aborted":
-			return { label: "aborted", icon: "×", color: "error" };
-		default:
-			return assertNever(status);
-	}
-}
-
-function renderAgentProgressEvents(events: readonly EvalStatusEvent[], environment: RenderEnvironment): string[] {
-	const rows = coalesceAgentEvents(events);
-	const lines: string[] = [];
-	// Senpi Theme has no tree-token API; fixed ├/└/│ glyphs intentionally mirror omp.
-	for (const [index, event] of rows.entries()) {
-		const isLast = index === rows.length - 1;
-		const status = agentStatus(event.status);
-		const presentation = agentPresentation(status, environment.spinnerFrame);
-		const id = eventString(event.id) ?? "agent";
-		const styledId = environment.theme === undefined ? id : environment.theme.bold(id);
-		let body = `${style(environment.theme, presentation.color, presentation.icon)} ${styledId} ${presentation.label}`;
-		if (status === "completed" || status === "failed" || status === "aborted") {
-			const duration = eventNumber(event.durationMs);
-			if (duration > 0) body += ` · ${style(environment.theme, "dim", formatDuration(duration))}`;
-		}
-		const branch = isLast ? "└ " : "├ ";
-		const continuation = isLast ? "  " : "│ ";
-		appendLines(
-			lines,
-			renderPrefixed(body, environment, { prefix: branch, continuation: continuation, color: "dim" }),
-		);
-		if (status !== "running") continue;
-		const currentTool = eventString(event.currentTool);
-		const lastIntent = eventString(event.lastIntent);
-		if (currentTool === undefined && lastIntent === undefined) continue;
-		const detail =
-			currentTool === undefined
-				? (lastIntent ?? "")
-				: `${currentTool}${lastIntent === undefined ? "" : `: ${lastIntent}`}`;
-		appendLines(
-			lines,
-			renderPrefixed(detail, environment, {
-				prefix: `${continuation}└ `,
-				continuation: `${continuation}  `,
-				color: "dim",
-			}),
-		);
-	}
-	return lines;
-}
-
-function renderCell(cell: EvalCellResult, environment: RenderEnvironment, badges: CellBadges): string[] {
-	if (leadsWithHeadline(cell.status) && !environment.expanded && cell.output.trim().length === 0) {
-		const statusEvents = (cell.statusEvents ?? []).filter((event) => event.op !== "agent");
-		if (statusEvents.length === 0) {
-			// Nothing to frame yet: the collapsed live row is its headline alone, one line, no empty box.
-			const lines = renderPrefixed(cellHeader(cell, environment, badges), environment, LIVE_LINE_PREFIX);
-			const agentEvents = (cell.statusEvents ?? []).filter((event) => event.op === "agent");
-			if (agentEvents.length > 0) appendLines(lines, renderAgentProgressEvents(agentEvents, environment));
-			return lines;
-		}
-	}
-	const lines = renderPrefixed(cellHeader(cell, environment, badges), environment, {
-		prefix: "╭─ ",
-		continuation: "│  ",
-		color: "borderAccent",
-	});
-	const headlined = leadsWithHeadline(cell.status);
-	if (cell.summary !== undefined && !headlined) {
-		appendLines(
-			lines,
-			summaryVisualLines(cell.summary, Math.max(1, environment.width - 2), environment.expanded).map(
-				(line) => `${style(environment.theme, "muted", "│ ")}${style(environment.theme, "muted", line)}`,
-			),
-		);
-	}
-	const innerWidth = Math.max(1, environment.width - 2);
-	const codePreview =
-		headlined && !environment.expanded
-			? { lines: [], skipped: 0 }
-			: previewText(
-					highlightedCode(cell.code, cell.language, environment.theme, environment.repaint),
-					environment.expanded ? Number.POSITIVE_INFINITY : CODE_PREVIEW_LINES,
-					innerWidth,
-				);
-	if (codePreview.skipped > 0) {
-		appendLines(
-			lines,
-			renderPrefixed(`${codePreview.skipped} earlier code lines`, environment, {
-				prefix: "│ ",
-				continuation: "│ ",
-				color: "muted",
-			}),
-		);
-	}
-	for (const line of codePreview.lines) {
-		appendLines(lines, renderPrefixed(line, environment, { prefix: "│ ", continuation: "│ ", color: "borderMuted" }));
-	}
-	const output = cell.output.trimEnd();
-	if (output.length > 0) {
-		appendLines(lines, renderPrefixed("output", environment, { prefix: "├─ ", continuation: "│  ", color: "dim" }));
-		const outputColor: ThemeColor = cell.status === "error" ? "error" : "toolOutput";
-		const styledOutput = output
-			.split("\n")
-			.map((line) => style(environment.theme, outputColor, line))
-			.join("\n");
-		const outputPreview = previewText(
-			styledOutput,
-			environment.expanded ? Number.POSITIVE_INFINITY : OUTPUT_PREVIEW_LINES,
-			innerWidth,
-		);
-		if (outputPreview.skipped > 0) {
-			appendLines(
-				lines,
-				renderPrefixed(`${outputPreview.skipped} earlier output lines`, environment, {
-					prefix: "│ ",
-					continuation: "│ ",
-					color: "muted",
-				}),
-			);
-		}
-		for (const line of outputPreview.lines) {
-			appendLines(
-				lines,
-				renderPrefixed(line, environment, { prefix: "│ ", continuation: "│ ", color: "borderMuted" }),
-			);
-		}
-	}
-	const allEvents = cell.statusEvents ?? [];
-	const statusEvents = allEvents.filter((event) => event.op !== "agent");
-	if (statusEvents.length > 0) {
-		appendLines(lines, renderPrefixed("status", environment, { prefix: "├─ ", continuation: "│  ", color: "dim" }));
-		for (const line of renderStatusEvents(statusEvents, environment)) {
-			appendLines(
-				lines,
-				renderPrefixed(line, environment, { prefix: "│ ", continuation: "│ ", color: "borderMuted" }),
-			);
-		}
-	}
-	lines.push(style(environment.theme, "borderMuted", "╰─"));
-	const agentEvents = allEvents.filter((event) => event.op === "agent");
-	if (agentEvents.length > 0) appendLines(lines, renderAgentProgressEvents(agentEvents, environment));
-	return lines;
-}
-
-function renderJsonOutputs(values: readonly unknown[], environment: RenderEnvironment): string[] {
-	const lines: string[] = [];
-	const depth = environment.expanded ? JSON_TREE_MAX_DEPTH_EXPANDED : JSON_TREE_MAX_DEPTH_COLLAPSED;
-	const lineCap = environment.expanded ? JSON_TREE_MAX_LINES_EXPANDED : JSON_TREE_MAX_LINES_COLLAPSED;
-	const scalarLen = environment.expanded ? JSON_TREE_SCALAR_LEN_EXPANDED : JSON_TREE_SCALAR_LEN_COLLAPSED;
-	for (const [index, value] of values.entries()) {
-		appendLines(
-			lines,
-			renderAllVisualLines(style(environment.theme, "dim", `display[${index + 1}]`), environment.width),
-		);
-		const tree = renderJsonTreeLines(value, environment.theme, depth, lineCap, scalarLen);
-		for (const line of tree.lines) appendLines(lines, renderAllVisualLines(line, environment.width));
-		if (tree.truncated)
-			appendLines(lines, renderAllVisualLines(style(environment.theme, "dim", "…"), environment.width));
-	}
-	return lines;
-}
-
-function renderDetailedLines(
-	details: EvalToolDetails,
-	result: AgentToolResult<EvalResultDetails>,
-	context: DetailedRenderContext,
-): string[] {
-	const lines: string[] = [];
-	const cells = details.cells ?? [];
-	for (const [index, cell] of cells.entries()) {
-		const run = isEvalRunInput(context.args) ? context.args : undefined;
-		const throughput =
-			context.isFinal &&
-			cells.length === 1 &&
-			cell.status === "complete" &&
-			typeof details.toolCallCount === "number"
-				? { calls: details.toolCallCount, wallDurationMs: details.wallDurationMs }
-				: undefined;
-		const badges = {
-			reset: index === 0 && run?.reset === true,
-			timeout: index === 0 ? run?.timeout : undefined,
-			throughput,
-		};
-		appendLines(lines, renderCell(cell, context.environment, badges));
-		if (index < cells.length - 1) lines.push("");
-	}
-	const jsonOutputs = details.jsonOutputs ?? [];
-	if (jsonOutputs.length > 0) {
-		if (lines.length > 0) lines.push("");
-		appendLines(lines, renderJsonOutputs(jsonOutputs, context.environment));
-	}
-	if (context.showImageFallback) {
-		for (const part of result.content) {
-			if (part.type !== "image") continue;
-			if (lines.length > 0) lines.push("");
-			appendLines(
-				lines,
-				renderAllVisualLines(`[image: ${sanitizeTerminalLabel(part.mimeType)}]`, context.environment.width),
-			);
-		}
-	}
-	if (details.phase !== undefined)
-		appendLines(
-			lines,
-			renderAllVisualLines(
-				style(context.environment.theme, "muted", `phase ${details.phase}`),
-				context.environment.width,
-			),
-		);
-	return lines;
-}
-
-function textOutput(result: AgentToolResult<EvalResultDetails>, showImageFallback: boolean): string {
-	const lines: string[] = [];
-	for (const part of result.content) {
-		if (part.type === "text" && part.audience !== "model") lines.push(part.text);
-		else if (showImageFallback && part.type === "image") {
-			lines.push(`[image: ${sanitizeTerminalLabel(part.mimeType)}]`);
-		}
-	}
-	return lines.join("\n");
-}
-
-function isEvalRunInput(args: EvalToolRequest): args is EvalToolInput {
-	return args.action === undefined || args.action === "run";
-}
-
-function toolCallRows(details: EvalToolDetails | undefined): ToolCallRow[] {
-	if (!details?.toolCalls || details.toolCalls.length === 0) return [];
-	return details.toolCalls.map((call) => {
-		const status = call.ok ? "ok" : "error";
-		const row = { summary: `- tool.${call.name}: ${status}`, color: call.ok ? "success" : "error" } as const;
-		return call.error === undefined ? row : { ...row, error: call.error };
-	});
-}
-
-function nestedToolCallBlock(
-	details: EvalToolDetails | undefined,
-	theme: Theme | undefined,
-	cwd: string,
-	expanded: boolean,
-): RenderBlock | undefined {
-	const toolCalls = details?.toolCalls;
-	if (theme === undefined || toolCalls === undefined || !toolCalls.some((call) => call.args !== undefined)) {
-		return undefined;
-	}
-	const legacyRows = toolCallRows(details);
-	return {
-		kind: "dynamic",
-		render: (width) => {
-			const retainedCalls = expanded ? toolCalls : toolCalls.slice(-TOOL_CALL_PREVIEW_COUNT);
-			const retainedRows = expanded ? legacyRows : legacyRows.slice(-TOOL_CALL_PREVIEW_COUNT);
-			const skippedCount = toolCalls.length - retainedCalls.length;
-			const toolCallNoun = skippedCount === 1 ? "call" : "calls";
-			const lines =
-				expanded || skippedCount === 0
-					? []
-					: renderAllVisualLines(style(theme, "muted", `${skippedCount} earlier tool ${toolCallNoun}`), width);
-			const legacyBlock: Extract<RenderBlock, { kind: "toolCalls" }> = {
-				kind: "toolCalls",
-				calls: retainedRows,
-				expanded,
-				theme,
-			};
-			for (const [index, call] of retainedCalls.entries()) {
-				if (call.args !== undefined) {
-					appendLines(lines, renderToolCallWidget(call, { cwd, theme, expanded, width }));
-				} else {
-					appendLines(lines, renderToolCall(retainedRows[index], legacyBlock, width));
-				}
-			}
-			return lines;
-		},
-	};
-}
-
-function resultStatus(
-	details: EvalToolDetails | undefined,
-	options: ToolRenderResultOptions,
-	hostIsError: boolean,
-): "running" | "done" | "error" {
-	if (details?.isError || hostIsError) return "error";
-	return options.isPartial ? "running" : "done";
-}
-
-function resultHeader(
-	details: EvalToolDetails | undefined,
-	status: "running" | "done" | "error",
-	theme: Theme | undefined,
-): string {
-	let color: ThemeColor;
-	switch (status) {
-		case "running":
-			color = "warning";
-			break;
-		case "done":
-			color = "success";
-			break;
-		case "error":
-			color = "error";
-			break;
-	}
-	const runtimeBadge =
-		details?.runtime === undefined ? "" : ` (${formatRuntimeBadge(details.language, details.runtime)})`;
-	return style(theme, color, `eval ${details?.language ?? "?"}${runtimeBadge} ${status}`);
-}
-
-function resultMetadata(
-	details: EvalToolDetails | undefined,
-	options: ToolRenderResultOptions,
-	theme: Theme | undefined,
-	status: "running" | "done" | "error",
-): RenderBlock[] {
-	const metadata: string[] = [];
-	if (details?.phase) metadata.push(`phase ${details.phase}`);
-	const elapsedMs = details?.wallDurationMs ?? details?.durationMs;
-	if (!options.isPartial && typeof elapsedMs === "number") metadata.push(`took ${formatDuration(elapsedMs)}`);
-	if (status === "done" && typeof details?.toolCallCount === "number") {
-		const badge = formatThroughputBadge({ calls: details.toolCallCount, wallDurationMs: details.wallDurationMs });
-		if (badge !== undefined) metadata.push(badge);
-	}
-	if (metadata.length === 0) return [];
-	return [{ kind: "text", text: style(theme, "muted", metadata.join(" | ")) }];
-}
-
-// The call renderer reads the assistant message's raw arguments, which keep the provider's
-// original summary (senpi#1472 detached preparation from the message), so it normalizes here,
-// idempotently: an already-normalized value is returned unchanged.
-function displaySummary(summary: string | undefined): string | undefined {
-	return normalizeEvalSummary(summary);
-}
-
-function cellIdSuffix(cellId: unknown): string {
-	return typeof cellId === "string" && cellId !== "" ? ` ${sanitizeTerminalLabel(cellId)}` : "";
-}
-
-export function renderEvalCall(
-	args: EvalToolRequest,
-	theme: Theme | undefined,
-	context: RenderContext,
-): EvalRenderComponent {
-	const component = componentFor(context);
-	if (context.hasResult === true) {
-		// The result renderer owns the full pending -> running -> done frame once a result exists.
-		// Rendering the call frame too would stack a duplicate box, so yield to it here.
-		component.setBlocks([]);
-		return component;
-	}
-	if (!isEvalRunInput(args)) {
-		// While a peek/stop call streams in, `cell_id` can still be missing; the title is the action alone until it arrives.
-		const title = args.action === "list" ? "eval list" : `eval ${args.action}${cellIdSuffix(args.cell_id)}`;
-		component.setBlocks([{ kind: "text", text: style(theme, "toolTitle", title) }]);
-		return component;
-	}
-	// While the model streams the call, `code` usually arrives before `language` and `summary`; a partial call still
-	// renders (the host would otherwise fall back to a raw key=value row).
-	const code = typeof args.code === "string" ? args.code : "";
-	const language = knownLanguage(args.language);
-	if (theme === undefined && context.spinnerFrame === undefined) {
-		const reset = args.reset === true ? " reset" : "";
-		const timeout = args.timeout === undefined ? "" : ` timeout ${args.timeout}s`;
-		component.setBlocks([
-			{
-				kind: "text",
-				text: style(theme, "toolTitle", `eval${language === undefined ? "" : ` ${language}`}${reset}${timeout}`),
-			},
-			...(displaySummary(args.summary) === undefined
-				? []
-				: [summaryBlock(displaySummary(args.summary) ?? "", theme, context.expanded)]),
-			{
-				kind: "text",
-				text: style(
-					theme,
-					"mdCodeBlock",
-					code.trim().length === 0
-						? "..."
-						: language === undefined
-							? code
-							: displayCode(code, language, context.argsComplete ? context.invalidate : undefined),
-				),
-				maxVisualLines: context.expanded ? undefined : CODE_PREVIEW_LINES,
-				collapseKind: "code",
-				theme,
-			},
-		]);
-		return component;
-	}
-	component.setBlocks([
-		{
-			kind: "dynamic",
-			render: (width) => {
-				const environment: RenderEnvironment = {
-					expanded: context.expanded,
-					theme,
-					spinnerFrame: context.spinnerFrame,
-					width,
-					meta: undefined,
-					now: renderNow(context),
-					...(context.argsComplete ? { repaint: context.invalidate } : {}),
-				};
-				const summary = displaySummary(args.summary);
-				if (language === undefined) return streamingCallLines(summary, code, environment);
-				const cell: EvalCellResult = {
-					index: 0,
-					...(summary === undefined ? {} : { summary }),
-					code,
-					language,
-					output: "",
-					status: context.spinnerFrame === undefined ? "pending" : "running",
-				};
-				return renderCell(cell, environment, {
-					reset: args.reset === true,
-					timeout: args.timeout,
-					throughput: undefined,
-				});
-			},
-		},
-	]);
-	return component;
-}
-
-/** A call whose language has not streamed in yet: the headline row alone, until the full frame can render. */
-function streamingCallLines(summary: string | undefined, code: string, environment: RenderEnvironment): string[] {
-	const icon = environment.spinnerFrame === undefined ? "○" : spinner(environment.spinnerFrame);
-	return renderPrefixed(headlined(icon, summary, code, "eval", environment), environment, LIVE_LINE_PREFIX);
-}
-
-const LIVE_LINE_PREFIX: PrefixStyle = { prefix: "╶─ ", continuation: "   ", color: "borderAccent" };
-
-export function renderEvalResult(
-	result: AgentToolResult<EvalResultDetails>,
-	options: ToolRenderResultOptions,
-	theme: Theme | undefined,
-	context: ResultRenderContext,
-): EvalRenderComponent {
-	const component = componentFor(context);
-	const details = result.details;
-	if (details && "action" in details) {
-		component.syncLiveTicker(false, context.invalidate);
-		component.setBlocks([
-			{ kind: "text", text: style(theme, "toolTitle", "eval list") },
-			{ kind: "text", text: style(theme, "toolOutput", textOutput(result, false)) },
-		]);
-		return component;
-	}
-	const expanded = options.expanded || context.expanded;
-	const imageProtocol = context.imageProtocol ?? null;
-	component.syncLiveTicker(hasLiveCell(details), context.invalidate);
-	if (details?.cells !== undefined && details.cells.length > 0) {
-		const blocks: RenderBlock[] = [
-			{
-				kind: "dynamic",
-				render: (width) =>
-					renderDetailedLines(details, result, {
-						environment: {
-							expanded,
-							theme,
-							spinnerFrame: context.spinnerFrame,
-							width,
-							meta: details.meta,
-							now: renderNow(context),
-							repaint: context.invalidate,
-						},
-						args: context.args,
-						showImageFallback: context.showImages && imageProtocol === null,
-						isFinal: !options.isPartial,
-					}),
-			},
-		];
-		const calls = toolCallRows(details);
-		const nestedCalls = nestedToolCallBlock(details, theme, context.cwd, expanded);
-		if (calls.length > 0)
-			blocks.push({ kind: "blank" }, nestedCalls ?? { kind: "toolCalls", calls, expanded, theme });
-		component.setBlocks(blocks);
-		return component;
-	}
-	const status = resultStatus(details, options, context.isError);
-	const blocks: RenderBlock[] = [
-		{ kind: "text", text: resultHeader(details, status, theme) },
-		...(details?.summary === undefined ? [] : [summaryBlock(details.summary, theme, expanded)]),
-		...resultMetadata(details, options, theme, status),
-		{ kind: "blank" },
-	];
-	const rawOutput = textOutput(result, context.showImages && imageProtocol === null);
-	const output = rawOutput.trimEnd();
-	const hasRenderedImage =
-		context.showImages && imageProtocol !== null && result.content.some((part) => part.type === "image");
-	if (output.length > 0) {
-		blocks.push({
-			kind: "text",
-			text: style(theme, "toolOutput", output),
-			maxVisualLines: expanded ? undefined : OUTPUT_PREVIEW_LINES,
-			collapseKind: "output",
-			theme,
-		});
-	} else if (!hasRenderedImage) blocks.push({ kind: "text", text: style(theme, "muted", "(no output)") });
-	const statusEvents = details?.statusEvents ?? [];
-	const nonAgentEvents = statusEvents.filter((event) => event.op !== "agent");
-	const agentEvents = statusEvents.filter((event) => event.op === "agent");
-	if (nonAgentEvents.length > 0 || agentEvents.length > 0) {
-		blocks.push(
-			{ kind: "blank" },
-			{
-				kind: "dynamic",
-				render: (width) => {
-					const environment: RenderEnvironment = {
-						expanded,
-						theme,
-						spinnerFrame: context.spinnerFrame,
-						width,
-						meta: details?.meta,
-						now: renderNow(context),
-					};
-					return [
-						...renderStatusEvents(nonAgentEvents, environment),
-						...renderAgentProgressEvents(agentEvents, environment),
-					];
-				},
-			},
-		);
-	}
-	if ((details?.jsonOutputs?.length ?? 0) > 0) {
-		blocks.push(
-			{ kind: "blank" },
-			{
-				kind: "dynamic",
-				render: (width) =>
-					renderJsonOutputs(details?.jsonOutputs ?? [], {
-						expanded,
-						theme,
-						spinnerFrame: context.spinnerFrame,
-						width,
-						meta: details?.meta,
-						now: renderNow(context),
-					}),
-			},
-		);
-	}
-	const calls = toolCallRows(details);
-	const nestedCalls = nestedToolCallBlock(details, theme, context.cwd, expanded);
-	if (calls.length > 0) blocks.push({ kind: "blank" }, nestedCalls ?? { kind: "toolCalls", calls, expanded, theme });
-	component.setBlocks(blocks);
-	return component;
-}
+export type { EvalRenderComponent } from "./render-blocks.ts";
+export { renderEvalCall } from "./render-call.ts";
+export { renderEvalResult } from "./render-result.ts";