@code-yeongyu/senpi 2026.8.14 → 2026.8.17

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);
@@ -121,6 +127,8 @@ export class CellResultBuilder {
 			languages: [this.#state.input.language],
 			...(this.#state.input.summary === undefined ? {} : { summary: this.#state.input.summary }),
 			durationMs: this.#state.durationMs,
+			wallDurationMs: Math.max(0, Date.now() - this.#state.startedAt),
+			toolCallCount: this.#state.toolCallMetrics.length,
 			toolCalls: [...this.#state.toolCalls],
 			truncated: output?.truncated ?? false,
 			...(isError ? { isError: true } : {}),

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/eval-execution-event.ts

@@ -0,0 +1,201 @@
+import type { AgentToolResult } from "@code-yeongyu/senpi";
+import {
+	capCodePoints,
+	MAX_AGGREGATED_TOOL_NAMES,
+	MAX_CAPTURED_IDENTIFIER_CODE_POINTS,
+	MAX_ENRICHED_TOOL_CALLS,
+	MAX_RPC_EVENT_BYTES,
+} from "./call-capture.ts";
+import type { CellState } from "./cell-runtime.ts";
+import type { EvalLanguage, EvalToolCallSummary, EvalToolDetails } from "./types.ts";
+
+export const EVAL_EXECUTION_EVENT = "senpi.eval.execution";
+
+export interface EvalToolAggregate {
+	readonly count: number;
+	readonly totalDurationMs: number;
+	readonly okCount: number;
+	readonly errorCount: number;
+	readonly pendingCount: number;
+}
+
+export type EvalToolAggregates = Record<string, EvalToolAggregate>;
+
+interface EvalExecutionBasePayload {
+	readonly version: 1;
+	readonly cellId: string;
+	readonly language: EvalLanguage;
+	readonly ok: boolean;
+	readonly startedAt: number;
+	readonly completedAt: number;
+	readonly durationMs: number;
+	readonly kernelDurationMs?: number;
+	readonly detached: boolean;
+	readonly toolCallCount: number;
+	readonly pendingToolCallCount: number;
+	readonly distinctToolsCalled: readonly string[];
+	readonly toolAggregates: EvalToolAggregates;
+	readonly toolAggregatesTruncated: boolean;
+	readonly toolAggregateOverflow?: EvalToolAggregate;
+}
+
+export interface EvalExecutionEventPayload extends EvalExecutionBasePayload {
+	readonly detailLevel: "full";
+	readonly error?: string;
+	readonly toolCalls: readonly EvalToolCallSummary[];
+}
+
+export interface EvalExecutionRpcToolCallSummary {
+	readonly name: string;
+	readonly ok: boolean;
+	readonly durationMs?: number;
+}
+
+export interface EvalExecutionRpcPayload extends EvalExecutionBasePayload {
+	readonly detailLevel: "metadata";
+	readonly rpcTruncated: boolean;
+	readonly toolCalls: readonly EvalExecutionRpcToolCallSummary[];
+}
+
+export type EvalExecutionSettleOutcome =
+	| { readonly result: AgentToolResult<EvalToolDetails> }
+	| { readonly error: unknown };
+
+export interface BuildEvalExecutionEventPayloadOptions {
+	readonly cellId: string;
+	readonly state: CellState;
+	readonly outcome: EvalExecutionSettleOutcome;
+	readonly completedAt: number;
+	readonly detached: boolean;
+}
+
+export function buildEvalExecutionEventPayload(
+	options: BuildEvalExecutionEventPayloadOptions,
+): EvalExecutionEventPayload {
+	const { cellId, state, outcome, completedAt, detached } = options;
+	const result = "result" in outcome ? outcome.result : undefined;
+	const ok = result?.details.isError !== true && !("error" in outcome);
+	const aggregateState = aggregateToolCalls(state, completedAt);
+	const error = ok ? undefined : settleError(state, outcome);
+	return {
+		version: 1,
+		detailLevel: "full",
+		cellId: capCodePoints(cellId, MAX_CAPTURED_IDENTIFIER_CODE_POINTS),
+		language: state.input.language,
+		ok,
+		...(error === undefined ? {} : { error: capCodePoints(error, 512) }),
+		startedAt: state.startedAt,
+		completedAt,
+		durationMs: Math.max(0, completedAt - state.startedAt),
+		...(result === undefined ? {} : { kernelDurationMs: result.details.durationMs }),
+		detached,
+		toolCallCount: state.toolCallMetrics.length,
+		pendingToolCallCount: aggregateState.pendingCount,
+		toolCalls: state.toolCalls.slice(0, MAX_ENRICHED_TOOL_CALLS),
+		distinctToolsCalled: [...aggregateState.aggregates.keys()],
+		toolAggregates: Object.fromEntries(aggregateState.aggregates),
+		toolAggregatesTruncated: aggregateState.overflow !== undefined,
+		...(aggregateState.overflow === undefined ? {} : { toolAggregateOverflow: aggregateState.overflow }),
+	};
+}
+
+export function toEvalExecutionRpcPayload(payload: EvalExecutionEventPayload): EvalExecutionRpcPayload {
+	const candidate: EvalExecutionRpcPayload = {
+		version: payload.version,
+		detailLevel: "metadata",
+		rpcTruncated: false,
+		cellId: payload.cellId,
+		language: payload.language,
+		ok: payload.ok,
+		startedAt: payload.startedAt,
+		completedAt: payload.completedAt,
+		durationMs: payload.durationMs,
+		...(payload.kernelDurationMs === undefined ? {} : { kernelDurationMs: payload.kernelDurationMs }),
+		detached: payload.detached,
+		toolCallCount: payload.toolCallCount,
+		pendingToolCallCount: payload.pendingToolCallCount,
+		toolCalls: payload.toolCalls.map((call) => ({
+			name: call.name,
+			ok: call.ok,
+			...(call.durationMs === undefined ? {} : { durationMs: call.durationMs }),
+		})),
+		distinctToolsCalled: payload.distinctToolsCalled,
+		toolAggregates: payload.toolAggregates,
+		toolAggregatesTruncated: payload.toolAggregatesTruncated,
+		...(payload.toolAggregateOverflow === undefined ? {} : { toolAggregateOverflow: payload.toolAggregateOverflow }),
+	};
+	if (serializedBytes(candidate) <= MAX_RPC_EVENT_BYTES) return candidate;
+	return {
+		...candidate,
+		rpcTruncated: true,
+		toolCalls: [],
+		distinctToolsCalled: [],
+		toolAggregates: {},
+		toolAggregatesTruncated: true,
+		toolAggregateOverflow: totalAggregate(payload),
+	};
+}
+
+function aggregateToolCalls(
+	state: CellState,
+	completedAt: number,
+): {
+	readonly aggregates: Map<string, EvalToolAggregate>;
+	readonly overflow: EvalToolAggregate | undefined;
+	readonly pendingCount: number;
+} {
+	const aggregates = new Map<string, EvalToolAggregate>();
+	let overflow: EvalToolAggregate | undefined;
+	let pendingCount = 0;
+	for (const metric of state.toolCallMetrics) {
+		const item: EvalToolAggregate = {
+			count: 1,
+			totalDurationMs: metric.durationMs ?? Math.max(0, completedAt - metric.startedAt),
+			okCount: metric.ok === true ? 1 : 0,
+			errorCount: metric.ok === false ? 1 : 0,
+			pendingCount: metric.ok === undefined ? 1 : 0,
+		};
+		pendingCount += item.pendingCount;
+		const existing = aggregates.get(metric.name);
+		if (existing !== undefined) {
+			aggregates.set(metric.name, addAggregate(existing, item));
+			continue;
+		}
+		if (aggregates.size < MAX_AGGREGATED_TOOL_NAMES) {
+			aggregates.set(metric.name, item);
+			continue;
+		}
+		overflow = overflow === undefined ? item : addAggregate(overflow, item);
+	}
+	return { aggregates, overflow, pendingCount };
+}
+
+function addAggregate(left: EvalToolAggregate, right: EvalToolAggregate): EvalToolAggregate {
+	return {
+		count: left.count + right.count,
+		totalDurationMs: left.totalDurationMs + right.totalDurationMs,
+		okCount: left.okCount + right.okCount,
+		errorCount: left.errorCount + right.errorCount,
+		pendingCount: left.pendingCount + right.pendingCount,
+	};
+}
+
+function totalAggregate(payload: EvalExecutionEventPayload): EvalToolAggregate {
+	let total: EvalToolAggregate = { count: 0, totalDurationMs: 0, okCount: 0, errorCount: 0, pendingCount: 0 };
+	for (const aggregate of Object.values(payload.toolAggregates)) total = addAggregate(total, aggregate);
+	if (payload.toolAggregateOverflow !== undefined) total = addAggregate(total, payload.toolAggregateOverflow);
+	return total;
+}
+
+function serializedBytes(value: unknown): number {
+	return new TextEncoder().encode(JSON.stringify(value)).byteLength;
+}
+
+function settleError(state: CellState, outcome: EvalExecutionSettleOutcome): string | undefined {
+	if (state.error !== undefined) return state.error;
+	if ("error" in outcome) return outcome.error instanceof Error ? outcome.error.message : String(outcome.error);
+	for (const part of outcome.result.content) {
+		if (part.type === "text" && part.text.length > 0) return part.text.trimEnd();
+	}
+	return undefined;
+}

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/eval-tool-options.ts

@@ -5,6 +5,7 @@ import type { ResolvedCodemodeSettings } from "../config/settings.ts";
 import type { EvalExecutionTracker } from "../extension/session-manager.ts";
 import type { EvalTimeoutFactory } from "./cell-execution.ts";
 import type { EvalDetachedCellManager } from "./detached-cell-manager.ts";
+import type { EvalExecutionEventPayload } from "./eval-execution-event.ts";
 import type { EvalImageResizer } from "./image.ts";
 import type {
 	EnabledEvalLanguages,
@@ -29,6 +30,7 @@ export interface CreateEvalToolOptions {
 	readonly imageResizer?: EvalImageResizer;
 	readonly executionTracker?: EvalExecutionTracker;
 	readonly cellManager?: EvalDetachedCellManager;
+	readonly onCellSettled?: (payload: EvalExecutionEventPayload) => void;
 	readonly timeoutFactory?: EvalTimeoutFactory;
 	readonly proxyExecutor?: (params: EvalToolInput, signal?: AbortSignal) => Promise<AgentToolResult<EvalToolDetails>>;
 	readonly renderers?: Pick<ToolDefinition<EvalInputSchema, EvalToolDetails>, "renderCall" | "renderResult">;

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

@@ -8,6 +8,7 @@ import { abortError, CellExecution, defaultTimeoutFactory } from "./cell-executi
 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";
@@ -99,18 +100,22 @@ async function runEvalCell(
 	const bridgeContext: ExtensionContext = { ...invocation.ctx, signal: cellSignal };
 	const state: CellState = {
 		input: invocation.input,
+		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,
@@ -119,6 +124,7 @@ async function runEvalCell(
 		timeoutFactory: options.timeoutFactory ?? defaultTimeoutFactory,
 		onTimeout: (error) => {
 			if (timeoutBehavior === "detach" && cellManager.detach(cell)) {
+				detached = true;
 				execution.detach();
 				return;
 			}
@@ -139,13 +145,29 @@ async function runEvalCell(
 		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;
 		},
 	);

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

@@ -188,12 +188,18 @@ type RenderEnvironment = {
 	readonly width: number;
 	readonly meta: TruncationMeta | undefined;
 };
-type CellBadges = { readonly reset: boolean; readonly timeout: number | undefined };
+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 {
@@ -256,7 +262,9 @@ function renderPrefixed(text: string, environment: RenderEnvironment, prefixStyl
 function cellHeader(cell: EvalCellResult, environment: RenderEnvironment, badges: CellBadges): string {
 	const presentation = cellPresentation(cell.status, environment.spinnerFrame);
 	let header = `eval ${cell.language} ${presentation.label} ${presentation.icon}`;
-	if (cell.durationMs !== undefined) header += ` · ${formatDuration(cell.durationMs)}`;
+	if (badges.throughput !== undefined) header += ` · ${formatThroughputBadge(badges.throughput)}`;
+	const elapsedMs = badges.throughput?.wallDurationMs ?? cell.durationMs;
+	if (elapsedMs !== undefined) header += ` · ${formatDuration(elapsedMs)}`;
 	if (badges.reset) header += " · reset";
 	if (badges.timeout !== undefined) header += ` · timeout ${badges.timeout}s`;
 	return style(environment.theme, presentation.color, header);
@@ -283,6 +291,19 @@ 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 calls === 0 ? "0.00 calls/s" : "n/a calls/s";
+	return `${(calls / seconds).toFixed(2)} calls/s`;
+}
+
+function formatThroughputBadge(throughput: CellThroughput): string {
+	return `${plural(throughput.calls, "call", "calls")} · ${formatCallsPerSecond(
+		throughput.calls,
+		throughput.wallDurationMs,
+	)}`;
+}
+
 function statusIcon(op: string): string {
 	if (op.startsWith("git_")) return "⌁";
 	switch (op) {
@@ -613,9 +634,17 @@ function renderDetailedLines(
 	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("");
@@ -754,11 +783,14 @@ 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}`);
-	if (!options.isPartial && typeof details?.durationMs === "number")
-		metadata.push(`took ${formatDuration(details.durationMs)}`);
+	const elapsedMs = details?.wallDurationMs ?? details?.durationMs;
+	if (!options.isPartial && typeof elapsedMs === "number") metadata.push(`took ${formatDuration(elapsedMs)}`);
+	if (status === "done" && typeof details?.toolCallCount === "number")
+		metadata.push(formatThroughputBadge({ calls: details.toolCallCount, wallDurationMs: details.wallDurationMs }));
 	if (metadata.length === 0) return [];
 	return [{ kind: "text", text: style(theme, "muted", metadata.join(" | ")) }];
 }
@@ -814,7 +846,11 @@ export function renderEvalCall(
 					output: "",
 					status: context.spinnerFrame === undefined ? "pending" : "running",
 				};
-				return renderCell(cell, environment, { reset: args.reset === true, timeout: args.timeout });
+				return renderCell(cell, environment, {
+					reset: args.reset === true,
+					timeout: args.timeout,
+					throughput: undefined,
+				});
 			},
 		},
 	]);
@@ -846,6 +882,7 @@ export function renderEvalResult(
 						},
 						args: context.args,
 						showImageFallback: context.showImages && imageProtocol === null,
+						isFinal: !options.isPartial,
 					}),
 			},
 		];
@@ -862,7 +899,7 @@ export function renderEvalResult(
 		...(details?.summary === undefined
 			? []
 			: [{ kind: "text" as const, text: style(theme, "muted", details.summary) }]),
-		...resultMetadata(details, options, theme),
+		...resultMetadata(details, options, theme, status),
 		{ kind: "blank" },
 	];
 	const rawOutput = textOutput(result, context.showImages && imageProtocol === null);

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

@@ -164,6 +164,10 @@ export interface EvalToolDetails {
 	readonly languages?: readonly EvalLanguage[];
 	readonly summary?: string;
 	readonly durationMs: number;
+	/** True wall-clock elapsed time since the cell started; `durationMs` stays kernel-reported. */
+	readonly wallDurationMs?: number;
+	/** Exact count of initiated nested tool calls, including calls still pending at settlement. */
+	readonly toolCallCount?: number;
 	readonly toolCalls: readonly EvalToolCallSummary[];
 	readonly truncated: boolean;
 	readonly isError?: boolean;

package/node_modules/@earendil-works/pi-agent-core/dist/agent-loop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-loop.d.ts","sourceRoot":"","sources":["../src/agent-loop.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAIN,WAAW,EAGX,MAAM,uBAAuB,CAAC;AAO/B,OAAO,KAAK,EACX,YAAY,EACZ,UAAU,EACV,eAAe,EAEf,YAAY,EACZ,SAAS,EACT,aAAa,EAEb,QAAQ,EACR,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,cAAc,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAEzE;;;GAGG;AACH,wBAAgB,SAAS,CACxB,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CAiBzC;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAChC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CAwBzC;AAED,wBAAsB,YAAY,CACjC,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,OAAO,CAAC,YAAY,EAAE,CAAC,CAgBzB;AAED,wBAAsB,oBAAoB,CACzC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,OAAO,CAAC,YAAY,EAAE,CAAC,CAiBzB;AAywBD,MAAM,WAAW,qBAAqB;IACrC,QAAQ,EAAE,aAAa,CAAC;IACxB,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,OAAO,CAAC;CACd;AAED,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,aAAa,GAAG,aAAa,CAYrG;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,aAAa,GAAG,qBAAqB,CAOpG"}
+{"version":3,"file":"agent-loop.d.ts","sourceRoot":"","sources":["../src/agent-loop.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAMN,WAAW,EAIX,MAAM,uBAAuB,CAAC;AAO/B,OAAO,KAAK,EACX,YAAY,EACZ,UAAU,EACV,eAAe,EAEf,YAAY,EACZ,SAAS,EACT,aAAa,EAEb,QAAQ,EACR,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,cAAc,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAEzE;;;GAGG;AACH,wBAAgB,SAAS,CACxB,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CAiBzC;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAChC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CAwBzC;AAED,wBAAsB,YAAY,CACjC,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,OAAO,CAAC,YAAY,EAAE,CAAC,CAgBzB;AAED,wBAAsB,oBAAoB,CACzC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,OAAO,CAAC,YAAY,EAAE,CAAC,CAiBzB;AA4zBD,MAAM,WAAW,qBAAqB;IACrC,QAAQ,EAAE,aAAa,CAAC;IACxB,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,OAAO,CAAC;CACd;AAED,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,aAAa,GAAG,aAAa,CAYrG;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,aAAa,GAAG,qBAAqB,CAOpG"}