@code-yeongyu/senpi 2026.8.13 → 2026.8.16

package/examples/extensions/subagent/agents.ts

@@ -23,6 +23,42 @@ export interface AgentDiscoveryResult {
 	projectAgentsDir: string | null;
 }
 
+/**
+ * Raw agent frontmatter. Values are `unknown` because `parseFrontmatter` runs a
+ * real YAML parser, so any scalar or collection can appear here.
+ *
+ * A type alias rather than an interface: `parseFrontmatter` constrains its
+ * parameter to `Record<string, unknown>`, and only an alias picks up the
+ * implicit index signature that satisfies it.
+ */
+type AgentFrontmatter = {
+	name?: unknown;
+	description?: unknown;
+	tools?: unknown;
+	model?: unknown;
+};
+
+/**
+ * Normalize a frontmatter `tools` value to a list of tool names.
+ *
+ * Both spellings are valid YAML and both are in use:
+ *
+ *     tools: read, bash        # string
+ *     tools: [read, bash]      # array
+ *
+ * so accept either. Anything else (a number, a map, a nested list) yields no
+ * tools rather than throwing: this runs inside agent discovery, where a single
+ * bad file must not take down every other agent in the same directory.
+ */
+function parseToolList(value: unknown): string[] | undefined {
+	const raw = Array.isArray(value) ? value : typeof value === "string" ? value.split(",") : [];
+	const tools = raw
+		.filter((t): t is string => typeof t === "string")
+		.map((t) => t.trim())
+		.filter(Boolean);
+	return tools.length > 0 ? tools : undefined;
+}
+
 function loadAgentsFromDir(dir: string, source: "user" | "project"): AgentConfig[] {
 	const agents: AgentConfig[] = [];
 
@@ -49,22 +85,17 @@ function loadAgentsFromDir(dir: string, source: "user" | "project"): AgentConfig
 			continue;
 		}
 
-		const { frontmatter, body } = parseFrontmatter<Record<string, string>>(content);
+		const { frontmatter, body } = parseFrontmatter<AgentFrontmatter>(content);
 
-		if (!frontmatter.name || !frontmatter.description) {
+		if (typeof frontmatter.name !== "string" || typeof frontmatter.description !== "string") {
 			continue;
 		}
 
-		const tools = frontmatter.tools
-			?.split(",")
-			.map((t: string) => t.trim())
-			.filter(Boolean);
-
 		agents.push({
 			name: frontmatter.name,
 			description: frontmatter.description,
-			tools: tools && tools.length > 0 ? tools : undefined,
-			model: frontmatter.model,
+			tools: parseToolList(frontmatter.tools),
+			model: typeof frontmatter.model === "string" ? frontmatter.model : undefined,
 			systemPrompt: body,
 			source,
 			filePath,

package/examples/extensions/subagent/index.ts

@@ -10,6 +10,11 @@
  *   - Chain: { chain: [{ agent: "name", task: "... {previous} ..." }, ...] }
  *
  * Uses JSON mode to capture structured output from subagents.
+ *
+ * Agent definitions live in `~/.pi/agent/agents/*.md` (user scope) and `.pi/agents/*.md`
+ * (project scope), with `name`, `description`, optional `tools` (`read, bash` or `[read, bash]`)
+ * and optional `model` frontmatter. When `model` is omitted, the subagent inherits the
+ * dispatching session's active model and thinking level.
  */
 
 import { spawn } from "node:child_process";
@@ -23,7 +28,7 @@ import {
 	getMarkdownTheme,
 	withFileMutationQueue,
 } from "@code-yeongyu/senpi";
-import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import type { AgentToolResult, ThinkingLevel } from "@earendil-works/pi-agent-core";
 import type { Message } from "@earendil-works/pi-ai";
 import { StringEnum } from "@earendil-works/pi-ai";
 import { Container, Markdown, Spacer, Text } from "@earendil-works/pi-tui";
@@ -264,8 +269,14 @@ function getPiInvocation(args: string[]): { command: string; args: string[] } {
 
 type OnUpdateCallback = (partial: AgentToolResult<SubagentDetails>) => void;
 
+interface DispatchDefaults {
+	model?: string;
+	thinkingLevel?: ThinkingLevel;
+}
+
 async function runSingleAgent(
 	defaultCwd: string,
+	dispatchDefaults: DispatchDefaults,
 	agents: AgentConfig[],
 	agentName: string,
 	task: string,
@@ -292,7 +303,12 @@ async function runSingleAgent(
 	}
 
 	const args: string[] = ["--mode", "json", "-p", "--no-session"];
-	if (agent.model) args.push("--model", agent.model);
+	const inheritsDispatchConfig = !agent.model;
+	const model = agent.model ?? dispatchDefaults.model;
+	if (model) args.push("--model", model);
+	if (inheritsDispatchConfig && dispatchDefaults.thinkingLevel) {
+		args.push("--thinking", dispatchDefaults.thinkingLevel);
+	}
 	if (agent.tools && agent.tools.length > 0) args.push("--tools", agent.tools.join(","));
 
 	let tmpPromptDir: string | null = null;
@@ -306,7 +322,7 @@ async function runSingleAgent(
 		messages: [],
 		stderr: "",
 		usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 },
-		model: agent.model,
+		model,
 		step,
 	};
 
@@ -471,6 +487,10 @@ export default function (pi: ExtensionAPI) {
 
 		async execute(_toolCallId, params, signal, onUpdate, ctx) {
 			const agentScope: AgentScope = params.agentScope ?? "user";
+			const dispatchDefaults: DispatchDefaults = {
+				model: ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined,
+				thinkingLevel: ctx.thinkingLevel,
+			};
 			const discovery = discoverAgents(ctx.cwd, agentScope);
 			const agents = discovery.agents;
 			const confirmProjectAgents = params.confirmProjectAgents ?? true;
@@ -552,6 +572,7 @@ export default function (pi: ExtensionAPI) {
 
 					const result = await runSingleAgent(
 						ctx.cwd,
+						dispatchDefaults,
 						agents,
 						step.agent,
 						taskWithContext,
@@ -624,6 +645,7 @@ export default function (pi: ExtensionAPI) {
 				const results = await mapWithConcurrencyLimit(params.tasks, MAX_CONCURRENCY, async (t, index) => {
 					const result = await runSingleAgent(
 						ctx.cwd,
+						dispatchDefaults,
 						agents,
 						t.agent,
 						t.task,
@@ -666,6 +688,7 @@ export default function (pi: ExtensionAPI) {
 			if (params.agent && params.task) {
 				const result = await runSingleAgent(
 					ctx.cwd,
+					dispatchDefaults,
 					agents,
 					params.agent,
 					params.task,

package/node_modules/@code-yeongyu/senpi-codemode/CHANGELOG.md

@@ -12,6 +12,44 @@
 
 ### Removed
 
+## [2026.8.16] - 2026-08-16
+
+### Breaking Changes
+
+### Added
+
+- Published one versioned `senpi.eval.execution` event per settled eval cell: the in-process bus receives bounded rich call details, while the external RPC projection exposes only byte-capped timing/count metadata for safe OMO analytics; total wall time, kernel runtime, pending calls, exact aggregate totals, and overflow accounting are reported separately ([#897](https://github.com/code-yeongyu/senpi/pull/897)).
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.8.14] - 2026-08-14
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.8.13-2] - 2026-08-13
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
 ## [2026.8.13] - 2026-08-13
 
 ### Breaking Changes

package/node_modules/@code-yeongyu/senpi-codemode/README.md

@@ -20,6 +20,11 @@ task-tool names are known.
 - Loopback, bearer-authenticated kernel bridge with bounded JSONL frames.
 - Structured status events for file operations, environment access, phases,
   bridge activity, and delegated task progress.
+- One versioned `senpi.eval.execution` event at terminal cell settlement. The
+  in-process event bus receives bounded per-call arguments and result previews
+  for extension-owned consumers; external RPC clients receive a 32 KiB-capped
+  metadata-only projection with wall time, kernel time, exact call counts,
+  pending-call counts, and bounded per-tool aggregates.
 - Bounded streaming output with head/tail previews, column clamping, and
   session-adjacent spill files for large streams.
 - TUI and HTML-export rendering for syntax-highlighted cells, status rows,

package/node_modules/@code-yeongyu/senpi-codemode/package.json

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

package/node_modules/@code-yeongyu/senpi-codemode/src/index.ts

@@ -17,6 +17,11 @@ import type { CodemodeSessionManager, CreateCodemodeSessionManagerOptions } from
 import { SessionManagerProxy } from "./extension/session-manager-proxy.ts";
 import { WAKE_SOURCE_STATE_EVENT, type WakeSourceState } from "./extension/wake-source-state.ts";
 import { EvalDetachedCellManager, type EvalDetachedCellStatusEntry } from "./tool/detached-cell-manager.ts";
+import {
+	EVAL_EXECUTION_EVENT,
+	type EvalExecutionEventPayload,
+	toEvalExecutionRpcPayload,
+} from "./tool/eval-execution-event.ts";
 import { createEvalTool } from "./tool/eval-tool.ts";
 import { renderEvalCall, renderEvalResult } from "./tool/render.ts";
 
@@ -39,8 +44,10 @@ export interface CodemodeExtensionAPI {
 	getActiveTools(): string[];
 	getAllTools(): readonly EvalSchemaToolInfo[];
 	sendUserMessage(content: string, options?: { deliverAs?: "steer" | "followUp" }): void;
-	/** Optional host event bus; a host without one turns wake-source emission into a harmless no-op. */
+	/** Optional host event bus; a host without one turns extension event emission into a harmless no-op. */
 	events?: { emit(name: string, data: unknown): void };
+	/** Optional host RPC surface for forwarding extension-owned events to connected clients. */
+	rpc?: { emit(name: string, data: unknown): void };
 }
 
 export interface SenpiCodemodeOptions {
@@ -90,6 +97,11 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 		modelId: string | undefined,
 		cellManager: EvalDetachedCellManager,
 	): void => {
+		const onCellSettled = (payload: EvalExecutionEventPayload): void => {
+			if (activeCells !== cellManager) return;
+			pi.rpc?.emit(EVAL_EXECUTION_EVENT, toEvalExecutionRpcPayload(payload));
+			pi.events?.emit(EVAL_EXECUTION_EVENT, payload);
+		};
 		pi.registerTool(
 			createEvalTool({
 				enabledLanguages: runtime.enabledLanguages,
@@ -102,6 +114,7 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 				artifactsDir: runtime.artifactsDir,
 				cellManager,
 				executionTracker: manager,
+				onCellSettled,
 				renderers,
 				spawns: runtime.spawns,
 				spawnDefaultAgent: runtime.settings.taskTools.task,

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/call-capture.ts

@@ -1,6 +1,11 @@
 import { type AgentToolResult, sanitizeTerminalLabel } from "@code-yeongyu/senpi";
+import type { EvalToolCallSummary } from "./types.ts";
 
 export const MAX_ENRICHED_TOOL_CALLS = 30;
+export const MAX_AGGREGATED_TOOL_NAMES = 64;
+export const MAX_CAPTURED_IDENTIFIER_CODE_POINTS = 128;
+export const MAX_CAPTURED_TOOL_NAME_CODE_POINTS = 128;
+export const MAX_RPC_EVENT_BYTES = 32 * 1024;
 
 const MAX_ARGUMENT_STRING_CODE_POINTS = 512;
 const MAX_ARGUMENT_ENTRIES = 32;
@@ -13,6 +18,22 @@ type BoundedValue = {
 	readonly truncated: boolean;
 };
 
+export interface EvalToolCallMetric {
+	readonly name: string;
+	readonly startedAt: number;
+	ok: boolean | undefined;
+	durationMs: number | undefined;
+}
+
+export interface ToolCallCapture {
+	readonly callId: string;
+	readonly args: unknown;
+	readonly startedAt: number;
+	readonly metric: EvalToolCallMetric;
+	readonly includeDetails: boolean;
+	readonly argsTruncated?: true;
+}
+
 export function capCodePoints(text: string, max: number): string {
 	let end = 0;
 	let count = 0;
@@ -83,6 +104,49 @@ export function boundToolCallArgs(args: unknown): { args: unknown; truncated: bo
 	}
 }
 
+export function createToolCallMetric(name: string, startedAt: number): EvalToolCallMetric {
+	return {
+		name: capCodePoints(name, MAX_CAPTURED_TOOL_NAME_CODE_POINTS),
+		startedAt,
+		ok: undefined,
+		durationMs: undefined,
+	};
+}
+
+export function settleToolCallMetric(metric: EvalToolCallMetric, ok: boolean, completedAt: number): void {
+	metric.ok = ok;
+	metric.durationMs = Math.max(0, completedAt - metric.startedAt);
+}
+
+export function recordToolCall(
+	toolCalls: EvalToolCallSummary[],
+	ok: boolean,
+	capture: ToolCallCapture,
+	resultPreview: string | undefined,
+	error: string | undefined,
+): void {
+	const completedAt = Date.now();
+	settleToolCallMetric(capture.metric, ok, completedAt);
+	const summary = {
+		name: capture.metric.name,
+		ok,
+		...(error === undefined ? {} : { error: capCodePoints(error, 512) }),
+		...(capture.includeDetails ? { durationMs: completedAt - capture.startedAt } : {}),
+	};
+	const enrichedCount = toolCalls.filter((toolCall) => toolCall.callId !== undefined).length;
+	if (!capture.includeDetails || enrichedCount >= MAX_ENRICHED_TOOL_CALLS) {
+		toolCalls.push(summary);
+		return;
+	}
+	toolCalls.push({
+		...summary,
+		callId: capture.callId,
+		args: capture.args,
+		...(capture.argsTruncated === true ? { argsTruncated: true } : {}),
+		...(resultPreview === undefined ? {} : { resultPreview }),
+	});
+}
+
 export function toolCallResultPreview(result: AgentToolResult<unknown>): string | undefined {
 	for (const part of result.content) {
 		if (part.type !== "text") continue;

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

@@ -1,5 +1,6 @@
 import { type AgentToolResult, type ExtensionContext, sanitizeTerminalLabel } from "@code-yeongyu/senpi";
 import type { KernelToHostMessage } from "../bridge/protocol.ts";
+import { RESERVED_SCHEMA_TOOL } from "../bridge/reserved.ts";
 import type { AgentExecuteTool } from "../bridges/agent-bridge.ts";
 import { isReservedToolName, runReservedTool } from "../bridges/reserved-dispatch.ts";
 import type { EvalSchemaToolInfo } from "../bridges/schema-bridge.ts";
@@ -7,7 +8,15 @@ import { appendSchemaHint } from "../bridges/schema-hint.ts";
 import type { CompletionRequest, CompletionResult } from "../completion/handler.ts";
 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 {
+	boundToolCallArgs,
+	capCodePoints,
+	createToolCallMetric,
+	MAX_CAPTURED_IDENTIFIER_CODE_POINTS,
+	recordToolCall,
+	type ToolCallCapture,
+	toolCallResultPreview,
+} from "./call-capture.ts";
 import { CellResultBuilder, type CellState } from "./cell-runtime.ts";
 import { type EvalImageResizer, marshalToolResult, toolResultIsError } from "./image.ts";
 import { upsertStatusEvent } from "./status-events.ts";
@@ -22,13 +31,6 @@ type ResolvedToolReply = {
 	readonly errorText?: string;
 };
 
-type ToolCallEnrichment = {
-	readonly callId: string;
-	readonly args: unknown;
-	readonly startedAt: number;
-	readonly argsTruncated?: true;
-};
-
 export interface CellBridgeRuntime {
 	readonly executeTool: AgentExecuteTool;
 	readonly listTools?: () => readonly EvalSchemaToolInfo[];
@@ -111,9 +113,21 @@ export class CellHandler {
 	}
 
 	async #handleToolCall(message: Extract<KernelToHostMessage, { type: "tool-call" }>): Promise<void> {
+		const startedAt = Date.now();
+		const metric = createToolCallMetric(message.toolName, startedAt);
+		this.#state.toolCallMetrics.push(metric);
+		const capturedArgs = boundToolCallArgs(message.args);
+		const capture: ToolCallCapture = {
+			callId: capCodePoints(message.callId, MAX_CAPTURED_IDENTIFIER_CODE_POINTS),
+			args: capturedArgs.args,
+			startedAt,
+			metric,
+			includeDetails: message.toolName !== RESERVED_SCHEMA_TOOL,
+			...(capturedArgs.truncated ? { argsTruncated: true } : {}),
+		};
 		if (message.toolName === "eval") {
 			const error = "recursive eval is not allowed";
-			this.#state.toolCalls.push({ name: message.toolName, ok: false, error });
+			recordToolCall(this.#state.toolCalls, false, capture, undefined, error);
 			this.#kernel.deliverToolReply({
 				type: "tool-reply",
 				callId: message.callId,
@@ -123,20 +137,24 @@ export class CellHandler {
 			return;
 		}
 		if (isReservedToolName(message.toolName)) {
-			await this.#deliverToolReply(message, async () => ({
-				value: await runReservedTool(message.toolName, {
-					callId: message.callId,
-					args: message.args,
-					executeTool: this.#runtime.executeTool,
-					taskToolName: this.#runtime.settings.taskTools.task,
-					taskOutputToolName: this.#runtime.settings.taskTools.output,
-					listTools: this.#runtime.listTools,
-					signal: this.#state.signal,
-					emitStatus: (event) => this.#recordStatus(event),
-					marshalToolResult,
+			await this.#deliverToolReply(
+				message,
+				async () => ({
+					value: await runReservedTool(message.toolName, {
+						callId: message.callId,
+						args: message.args,
+						executeTool: this.#runtime.executeTool,
+						taskToolName: this.#runtime.settings.taskTools.task,
+						taskOutputToolName: this.#runtime.settings.taskTools.output,
+						listTools: this.#runtime.listTools,
+						signal: this.#state.signal,
+						emitStatus: (event) => this.#recordStatus(event),
+						marshalToolResult,
+					}),
+					toolCallOk: true,
 				}),
-				toolCallOk: true,
-			}));
+				capture,
+			);
 			return;
 		}
 		if (message.toolName === "completion" && this.#runtime.complete) {
@@ -148,16 +166,10 @@ export class CellHandler {
 				isActive: () => this.#state.active,
 			});
 			if (!this.#state.active) return;
-			this.#state.toolCalls.push(
-				result.ok
-					? { name: message.toolName, ok: true }
-					: { name: message.toolName, ok: false, error: result.error },
-			);
+			recordToolCall(this.#state.toolCalls, result.ok, capture, undefined, result.ok ? undefined : result.error);
 			this.#resultBuilder.emitUpdate(false);
 			return;
 		}
-		const capturedArgs = boundToolCallArgs(message.args);
-		const startedAt = Date.now();
 		await this.#deliverToolReply(
 			message,
 			async () => {
@@ -185,24 +197,19 @@ export class CellHandler {
 					...(errorText === undefined ? {} : { errorText }),
 				};
 			},
-			{
-				callId: message.callId,
-				args: capturedArgs.args,
-				startedAt,
-				...(capturedArgs.truncated ? { argsTruncated: true } : {}),
-			},
+			capture,
 		);
 	}
 
 	async #deliverToolReply(
 		message: Extract<KernelToHostMessage, { type: "tool-call" }>,
 		resolve: () => Promise<ResolvedToolReply>,
-		enrich?: ToolCallEnrichment,
+		capture: ToolCallCapture,
 	): Promise<void> {
 		try {
 			const reply = await resolve();
 			if (!this.#state.active) return;
-			this.#pushToolCall(message.toolName, reply.toolCallOk, enrich, reply.resultPreview, reply.errorText);
+			recordToolCall(this.#state.toolCalls, reply.toolCallOk, capture, reply.resultPreview, reply.errorText);
 			this.#kernel.deliverToolReply({ type: "tool-reply", callId: message.callId, ok: true, value: reply.value });
 		} catch (error) {
 			if (!this.#state.active) return;
@@ -211,7 +218,7 @@ export class CellHandler {
 				message.toolName,
 				this.#toolParameters(message.toolName),
 			);
-			this.#pushToolCall(message.toolName, false, enrich, undefined, text);
+			recordToolCall(this.#state.toolCalls, false, capture, undefined, text);
 			this.#kernel.deliverToolReply({
 				type: "tool-reply",
 				callId: message.callId,
@@ -222,29 +229,6 @@ export class CellHandler {
 		this.#resultBuilder.emitUpdate(false);
 	}
 
-	#pushToolCall(
-		name: string,
-		ok: boolean,
-		enrich: ToolCallEnrichment | undefined,
-		resultPreview: string | undefined,
-		error: string | undefined,
-	): void {
-		const summary = { name, ok, ...(error === undefined ? {} : { error }) };
-		const enrichedCount = this.#state.toolCalls.filter((toolCall) => toolCall.callId !== undefined).length;
-		if (enrich === undefined || enrichedCount >= MAX_ENRICHED_TOOL_CALLS) {
-			this.#state.toolCalls.push(summary);
-			return;
-		}
-		this.#state.toolCalls.push({
-			...summary,
-			callId: enrich.callId,
-			args: enrich.args,
-			durationMs: Date.now() - enrich.startedAt,
-			...(enrich.argsTruncated === true ? { argsTruncated: true } : {}),
-			...(resultPreview === undefined ? {} : { resultPreview }),
-		});
-	}
-
 	#toolParameters(toolName: string): unknown {
 		return this.#runtime.listTools?.().find((tool) => tool.name === toolName)?.parameters;
 	}

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

@@ -1,5 +1,6 @@
 import type { AgentToolResult, AgentToolUpdateCallback, ExtensionContext } from "@code-yeongyu/senpi";
 import type { KernelToHostMessage } from "../bridge/protocol.ts";
+import type { EvalToolCallMetric } from "./call-capture.ts";
 import { type EvalImageResizer, EvalOutputCollector, type EvalOutputResult } from "./image.ts";
 import type { EvalStatusEvent, EvalToolDetails, EvalToolInput } from "./types.ts";
 
@@ -9,14 +10,17 @@ type ToolCall = EvalToolDetails["toolCalls"] extends readonly (infer Item)[] ? I
 
 export interface CellState {
 	readonly input: EvalToolInput;
+	readonly startedAt: number;
 	readonly signal: AbortSignal;
 	readonly onUpdate: AgentToolUpdateCallback<EvalToolDetails> | undefined;
 	readonly toolCalls: ToolCall[];
+	readonly toolCallMetrics: EvalToolCallMetric[];
 	readonly pendingBridgeCalls: Promise<void>[];
 	readonly statusEvents: EvalStatusEvent[];
 	active: boolean;
 	output: string;
 	phase: string | undefined;
+	error: string | undefined;
 	durationMs: number;
 	status: "pending" | "running" | "complete" | "error";
 }
@@ -70,6 +74,7 @@ export class CellResultBuilder {
 			if (result.valueRepr) this.#output.push(`${result.valueRepr}\n`);
 			this.#state.status = "complete";
 		} else {
+			this.#state.error = result.error.message;
 			this.#output.push(`${result.error.message}\n`);
 			this.#state.status = "error";
 		}
@@ -77,6 +82,7 @@ export class CellResultBuilder {
 	}
 
 	async finalizeCancellation(error: Error): Promise<AgentToolResult<EvalToolDetails>> {
+		this.#state.error = error.message;
 		this.#output.push(`${error.message}\n`);
 		this.#state.status = "error";
 		return await this.#finish(true);