@code-yeongyu/senpi-codemode 2026.7.26 → 2026.7.28-3

package/CHANGELOG.md

@@ -12,6 +12,51 @@
 
 ### Removed
 
+## [2026.7.28-3] - 2026-07-28
+
+### Breaking Changes
+
+### Added
+
+- Add nested tool-call widgets that render the real call shape of tools invoked from eval cells, with truthful status, duration, and sanitized previews ([#444](https://github.com/code-yeongyu/senpi/pull/444)).
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.7.28-2] - 2026-07-28
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+- Start a fresh eval cell when a caller reuses the ID of a terminal cell, preventing completed or failed results from being replayed as though new code had executed ([#439](https://github.com/code-yeongyu/senpi/pull/439)).
+- Omit the eval `took` duration when timing metadata is unavailable, avoiding misleading zero-duration status output for detached or restored cell results ([#439](https://github.com/code-yeongyu/senpi/pull/439)).
+
+### Removed
+
+## [2026.7.28] - 2026-07-28
+
+### Breaking Changes
+
+### Added
+
+- Add `tool_schema()` and return parameter schemas from failed eval tool calls so cells can inspect and self-correct tool invocations ([#407](https://github.com/code-yeongyu/senpi/pull/407)).
+
+### Changed
+
+- Allow eval cells and extensions to activate named searchable tools lazily on the calling surface without globally widening the active tool set ([#408](https://github.com/code-yeongyu/senpi/pull/408)).
+
+### Fixed
+
+### Removed
+
 ## [2026.7.26] - 2026-07-26
 
 ### Breaking Changes

package/README.md

@@ -101,6 +101,7 @@ options object and asynchronous helpers are `await`-able.
 | `write(path, content)` | Creates parent directories and writes text. `local://` paths persist in the session artifact root. |
 | `env(key?, value?)` | Reads all kernel environment values, one value, or sets one value. |
 | `tool.<name>(args)` | Invokes an active Senpi tool through the normal `pi.executeTool` pipeline. |
+| `tool_schema(name?)` | Returns a tool's parameter schema without calling it; omit `name` to list tool names. |
 | `completion(prompt, model?, system?, schema?)` | Requests a one-shot host completion; `schema` asks the host to parse structured output. |
 | `agent(prompt, ...)` | Delegates to the configured active `taskTools.task` tool. Supports background handles and structured JSON results. |
 | `output(ids, format?, offset?, limit?)` | Delegates transcript retrieval to the configured active `taskTools.output` tool. |
@@ -108,6 +109,11 @@ options object and asynchronous helpers are `await`-able.
 | `pipeline(items, ...stages)` | Applies stages left to right with a barrier between stages. |
 | `log(message)` / `phase(title)` | Emits progress text and starts a status phase. |
 
+When a `tool.<name>()` call fails argument validation, the error delivered back
+into the cell carries the tool's expected parameters, so the cell can correct the
+arguments and retry instead of falling back to one-at-a-time tool calls.
+`tool_schema()` exposes the same catalog up front.
+
 `agent()` is available only when the configured task tool is active in the
 session. `output()` similarly requires the configured task-output tool and
 returns immediately: a running task reports its current status, while completed
@@ -179,3 +185,18 @@ Direct real-surface QA drivers live in `scripts/qa-*.ts`: kernel cells
 (`qa-py-cell.ts`, `qa-js-cell.ts`, `qa-rb-cell.ts`, `qa-jl-cell.ts`), end-to-end
 extension execution (`qa-e2e-eval.ts`), and renderer output
 (`qa-render-dump.ts`).
+
+### Nested tool-call widgets
+
+When an eval cell invokes `tool.<name>(...)`, the result panel can render a
+nested widget for the invoked tool. The widget captures bounded args, duration,
+and a sanitized 160 code points result preview; the rendering path is
+always-on and does not depend on any toggle or session flag.
+
+The capture budget is fixed at 30 enriched calls per cell, with a 4096-character
+serialized args budget. Previews are capped at 160 code points, and collapsed
+widgets stay within the 8 lines collapsed widget budget.
+
+Entries without args — including old sessions, reserved/completion rows, and
+calls past the cap — render as plain rows. Edit renders a fallback row by
+design, even when its args are present.

package/package.json

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

package/src/bridge/reserved.ts

@@ -3,6 +3,8 @@
 export const RESERVED_AGENT_TOOL = "__agent__" as const;
 /** ADAPTATION: senpi delegates output through a reserved kernel-side tool name. */
 export const RESERVED_OUTPUT_TOOL = "__output__" as const;
+/** ADAPTATION: senpi resolves tool parameter schemas through a reserved kernel-side tool name. */
+export const RESERVED_SCHEMA_TOOL = "__schema__" as const;
 /** Canonical oh-my-pi eval-timeout pause operation. */
 export const TIMEOUT_PAUSE_OP = "timeout-pause" as const;
 /** Canonical oh-my-pi eval-timeout resume operation. */

package/src/bridges/reserved-dispatch.ts

@@ -0,0 +1,56 @@
+import type { AgentToolResult } from "@code-yeongyu/senpi";
+import { RESERVED_AGENT_TOOL, RESERVED_OUTPUT_TOOL, RESERVED_SCHEMA_TOOL } from "../bridge/reserved.ts";
+import type { EvalStatusEvent, ExecuteTool } from "../tool/types.ts";
+import { type AgentExecuteTool, runEvalAgent } from "./agent-bridge.ts";
+import { type MarshalledToolResult, type OutputExecuteTool, runEvalOutput } from "./output-bridge.ts";
+import { type EvalSchemaToolInfo, runEvalSchema } from "./schema-bridge.ts";
+
+export interface ReservedDispatchContext {
+	readonly callId: string;
+	readonly args: unknown;
+	readonly executeTool: AgentExecuteTool & OutputExecuteTool & ExecuteTool;
+	readonly taskToolName: string;
+	readonly taskOutputToolName: string;
+	readonly listTools: (() => readonly EvalSchemaToolInfo[]) | undefined;
+	readonly signal: AbortSignal | undefined;
+	readonly emitStatus: (event: EvalStatusEvent) => void;
+	readonly marshalToolResult: (result: AgentToolResult<unknown>) => MarshalledToolResult;
+}
+
+class SchemaUnavailableError extends Error {
+	readonly name = "SchemaUnavailableError";
+
+	constructor() {
+		super("tool_schema() unavailable: this session does not expose a tool catalog");
+	}
+}
+
+export function isReservedToolName(toolName: string): boolean {
+	return toolName === RESERVED_AGENT_TOOL || toolName === RESERVED_OUTPUT_TOOL || toolName === RESERVED_SCHEMA_TOOL;
+}
+
+export async function runReservedTool(toolName: string, context: ReservedDispatchContext): Promise<unknown> {
+	if (toolName === RESERVED_AGENT_TOOL) {
+		return await runEvalAgent(context.args, {
+			callId: context.callId,
+			taskToolName: context.taskToolName,
+			executeTool: context.executeTool,
+			...(context.signal === undefined ? {} : { signal: context.signal }),
+			emitStatus: context.emitStatus,
+		});
+	}
+	if (toolName === RESERVED_OUTPUT_TOOL) {
+		return await runEvalOutput(context.args, {
+			taskOutputToolName: context.taskOutputToolName,
+			executeTool: context.executeTool,
+			...(context.signal === undefined ? {} : { signal: context.signal }),
+			marshalToolResult: context.marshalToolResult,
+		});
+	}
+	if (toolName === RESERVED_SCHEMA_TOOL) {
+		const listTools = context.listTools;
+		if (listTools === undefined) throw new SchemaUnavailableError();
+		return runEvalSchema(context.args, { listTools });
+	}
+	throw new Error(`runReservedTool received a non-reserved tool name: ${toolName}`);
+}

package/src/bridges/schema-bridge.ts

@@ -0,0 +1,69 @@
+import { type Static, Type } from "typebox";
+import { Check, Errors } from "typebox/value";
+
+const schemaArgsSchema = Type.Object(
+	{ name: Type.Optional(Type.String({ minLength: 1 })) },
+	{ additionalProperties: false },
+);
+
+type SchemaArgs = Static<typeof schemaArgsSchema>;
+
+export interface EvalSchemaToolInfo {
+	readonly name: string;
+	readonly description?: string | undefined;
+	readonly parameters?: unknown;
+}
+
+export interface RunEvalSchemaOptions {
+	readonly listTools: () => readonly EvalSchemaToolInfo[];
+}
+
+export type EvalSchemaResult =
+	| { readonly tools: readonly string[] }
+	| { readonly name: string; readonly description: string | undefined; readonly parameters: unknown };
+
+class SchemaArgumentsError extends Error {
+	readonly name = "SchemaArgumentsError";
+
+	constructor(summary: string) {
+		super(`schema() received invalid arguments: ${summary}`);
+	}
+}
+
+class SchemaUnknownToolError extends Error {
+	readonly name = "SchemaUnknownToolError";
+
+	constructor(requested: string, suggestions: readonly string[]) {
+		const hint = suggestions.length > 0 ? ` Did you mean: ${suggestions.join(", ")}?` : "";
+		super(`schema() found no tool named "${requested}".${hint}`);
+	}
+}
+
+export function runEvalSchema(args: unknown, options: RunEvalSchemaOptions): EvalSchemaResult {
+	const parsed = parseSchemaArgs(args);
+	const tools = options.listTools();
+	if (parsed.name === undefined) return { tools: tools.map((tool) => tool.name) };
+
+	const match = tools.find((tool) => tool.name === parsed.name);
+	if (match) return { name: match.name, description: match.description, parameters: match.parameters };
+	throw new SchemaUnknownToolError(parsed.name, nearestNames(parsed.name, tools));
+}
+
+function parseSchemaArgs(value: unknown): SchemaArgs {
+	if (Check(schemaArgsSchema, value)) return value;
+	const summary = Errors(schemaArgsSchema, value)
+		.map((error) => `${error.instancePath || "/"} ${error.message}`)
+		.join("; ");
+	throw new SchemaArgumentsError(summary || "invalid value");
+}
+
+function nearestNames(requested: string, tools: readonly EvalSchemaToolInfo[]): readonly string[] {
+	const needle = requested.toLowerCase();
+	return tools
+		.map((tool) => tool.name)
+		.filter((name) => {
+			const candidate = name.toLowerCase();
+			return candidate.includes(needle) || needle.includes(candidate);
+		})
+		.slice(0, 5);
+}

package/src/bridges/schema-hint.ts

@@ -0,0 +1,140 @@
+const SCHEMA_HINT_MAX_CHARS = 1_200;
+const SCHEMA_HINT_MAX_PROPERTIES = 30;
+const DESCRIPTION_MAX_CHARS = 80;
+const ENUM_MAX_VALUES = 8;
+const NESTED_MAX_DEPTH = 2;
+const HINT_HEADER = "Expected parameters:";
+
+interface SchemaLike {
+	readonly type?: unknown;
+	readonly properties?: unknown;
+	readonly required?: unknown;
+	readonly items?: unknown;
+	readonly description?: unknown;
+	readonly enum?: unknown;
+	readonly const?: unknown;
+	readonly oneOf?: unknown;
+	readonly anyOf?: unknown;
+	readonly allOf?: unknown;
+}
+
+export function appendSchemaHint(message: string, toolName: string, schema: unknown): string {
+	const rendered = renderSchemaHint(toolName, schema);
+	if (rendered === undefined) return message;
+	return `${message}\n\n${HINT_HEADER}\n${rendered}`;
+}
+
+export function renderSchemaHint(toolName: string, schema: unknown): string | undefined {
+	if (!isSchemaLike(schema)) return undefined;
+	const lines = renderObjectLines(schema, 0, 1);
+	if (lines.length === 0) return undefined;
+	return fitLines(lines, `[truncated; call tool_schema(${JSON.stringify(toolName)}) for the full schema]`);
+}
+
+function renderObjectLines(schema: SchemaLike, indent: number, depth: number): readonly string[] {
+	const required = stringArray(schema.required);
+	const entries = propertyEntries(schema.properties);
+	if (entries.length === 0 && required.length === 0) return [];
+
+	const ordered = [
+		...entries.filter(([name]) => required.includes(name)),
+		...entries.filter(([name]) => !required.includes(name)),
+	];
+	const pad = "  ".repeat(indent + 1);
+	const lines: string[] = [];
+	if (indent === 0 && required.length > 0) lines.push(`required: ${required.join(", ")}`);
+
+	const shown = ordered.slice(0, SCHEMA_HINT_MAX_PROPERTIES);
+	for (const [name, value] of shown) {
+		lines.push(`${pad}${name}${required.includes(name) ? "" : "?"}: ${describeProperty(value)}`);
+		lines.push(...nestedLines(value, indent, depth));
+	}
+	const hidden = ordered.length - shown.length;
+	if (hidden > 0) lines.push(`${pad}… ${hidden} more propert${hidden === 1 ? "y" : "ies"}`);
+	return lines;
+}
+
+function nestedLines(value: unknown, indent: number, depth: number): readonly string[] {
+	if (depth >= NESTED_MAX_DEPTH || !isSchemaLike(value)) return [];
+	const nested = isSchemaLike(value.items) ? value.items : value;
+	if (propertyEntries(nested.properties).length === 0) return [];
+	return renderObjectLines(nested, indent + 1, depth + 1);
+}
+
+function describeProperty(value: unknown): string {
+	if (!isSchemaLike(value)) return "unknown";
+	const parts = [typeLabel(value)];
+	const description = firstLine(value.description);
+	if (description !== undefined) parts.push(`— ${truncate(description, DESCRIPTION_MAX_CHARS)}`);
+	return parts.join(" ");
+}
+
+function typeLabel(schema: SchemaLike): string {
+	if (Object.hasOwn(schema, "const")) return JSON.stringify(schema.const);
+	const enumValues = schema.enum;
+	if (Array.isArray(enumValues) && enumValues.length > 0) return unionLabel(enumValues.map(literal));
+	const branches = schema.oneOf ?? schema.anyOf;
+	if (Array.isArray(branches) && branches.length > 0) return unionLabel(branches.map(branchLabel));
+	if (Array.isArray(schema.allOf) && schema.allOf.length > 0) return branchLabel(schema.allOf[0]);
+
+	const type = schema.type;
+	const base = typeof type === "string" ? type : Array.isArray(type) ? type.filter(isString).join("|") : "unknown";
+	if (base !== "array") return base;
+	return isSchemaLike(schema.items) ? `array<${typeLabel(schema.items)}>` : "array";
+}
+
+function unionLabel(values: readonly string[]): string {
+	const shown = values.slice(0, ENUM_MAX_VALUES).join(" | ");
+	return values.length > ENUM_MAX_VALUES ? `${shown} | … (${values.length - ENUM_MAX_VALUES} more)` : shown;
+}
+
+function branchLabel(value: unknown): string {
+	return isSchemaLike(value) ? typeLabel(value) : "unknown";
+}
+
+function literal(value: unknown): string {
+	return JSON.stringify(value) ?? String(value);
+}
+
+function fitLines(lines: readonly string[], marker: string): string {
+	const budget = SCHEMA_HINT_MAX_CHARS - HINT_HEADER.length - 1;
+	const kept: string[] = [];
+	let used = 0;
+	for (const line of lines) {
+		const next = used + line.length + (kept.length === 0 ? 0 : 1);
+		if (next > budget - marker.length - 1) {
+			kept.push(marker);
+			return kept.join("\n");
+		}
+		kept.push(line);
+		used = next;
+	}
+	return kept.join("\n");
+}
+
+function propertyEntries(properties: unknown): readonly (readonly [string, unknown])[] {
+	if (typeof properties !== "object" || properties === null || Array.isArray(properties)) return [];
+	return Object.entries(properties);
+}
+
+function stringArray(value: unknown): readonly string[] {
+	return Array.isArray(value) ? value.filter(isString) : [];
+}
+
+function firstLine(value: unknown): string | undefined {
+	if (typeof value !== "string") return undefined;
+	const line = value.split("\n", 1)[0]?.trim();
+	return line === undefined || line.length === 0 ? undefined : line;
+}
+
+function truncate(value: string, maxChars: number): string {
+	return value.length <= maxChars ? value : `${value.slice(0, maxChars)}…`;
+}
+
+function isSchemaLike(value: unknown): value is SchemaLike {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isString(value: unknown): value is string {
+	return typeof value === "string";
+}

package/src/extension/runtime-factory.ts

@@ -87,8 +87,10 @@ export async function createRuntime(
 }
 
 export function createExecuteTool(pi: CodemodeRuntimeAPI, activeTools?: ReadonlySet<string>): AgentExecuteTool {
+	// A cell names tools directly and cannot run tool_search first, so eval opts in to
+	// lazy activation. Eligibility still belongs to the extension that registered the tool.
 	const executeTool: AgentExecuteTool = (toolName, params, executeOptions) =>
-		pi.executeTool(toolName, params, executeOptions);
+		pi.executeTool(toolName, params, { ...executeOptions, activateInactiveTool: true });
 	return Object.assign(executeTool, {
 		isToolAvailable: (name: string): boolean => activeTools?.has(name) ?? pi.getActiveTools().includes(name),
 	});

package/src/index.ts

@@ -1,6 +1,7 @@
 import * as os from "node:os";
 import type { ExtensionContext } from "@code-yeongyu/senpi";
 import type { AgentExecuteTool } from "./bridges/agent-bridge.ts";
+import type { EvalSchemaToolInfo } from "./bridges/schema-bridge.ts";
 import { type CompletionRequest, type CompletionResult, createCompletionHandler } from "./completion/handler.ts";
 import { defaultCodemodeSettings } from "./config/settings.ts";
 import { EvalNotifier } from "./extension/eval-notifier.ts";
@@ -33,6 +34,7 @@ export interface CodemodeExtensionAPI {
 	on(event: CodemodeEvent, handler: (event: unknown, ctx: ExtensionContext) => Promise<void> | void): void;
 	executeTool: AgentExecuteTool;
 	getActiveTools(): string[];
+	getAllTools(): readonly EvalSchemaToolInfo[];
 	sendUserMessage(content: string, options?: { deliverAs?: "steer" | "followUp" }): void;
 }
 
@@ -67,6 +69,7 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 				kernelManager: manager,
 				cellTimeoutSeconds: runtime.settings.cellTimeoutSeconds,
 				executeTool: runtime.executeTool,
+				listTools: () => pi.getAllTools(),
 				complete,
 				settings: runtime.settings,
 				artifactsDir: runtime.artifactsDir,
@@ -95,6 +98,7 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 			kernelManager: manager,
 			cellTimeoutSeconds: defaultCodemodeSettings.cellTimeoutSeconds,
 			executeTool: createExecuteTool(pi),
+			listTools: () => pi.getAllTools(),
 			complete,
 			settings: defaultCodemodeSettings,
 			cellManager: new EvalDetachedCellManager({ notifier }),

package/src/kernels/jl/prelude.jl

@@ -194,6 +194,12 @@ function completion(prompt::AbstractString; model="default", system=nothing, sch
     get(response, "text", response)
 end
 
+function tool_schema(name=nothing)
+    arguments = Dict{String, Any}()
+    name !== nothing && (arguments["name"] = string(name))
+    senpi_with_bridge_timeout_pause(() -> senpi_call_tool("__schema__", arguments))
+end
+
 function output(ids...; format="raw", offset=nothing, limit=nothing)
     isempty(ids) && error("At least one output ID is required")
     format in ("raw", "tail") || error("output() format must be 'raw' or 'tail'")

package/src/kernels/js/local-module-loader.ts

@@ -4,6 +4,7 @@ import type { BridgeConnectionConfig } from "../../bridge/protocol.ts";
 import {
 	RESERVED_AGENT_TOOL,
 	RESERVED_OUTPUT_TOOL,
+	RESERVED_SCHEMA_TOOL,
 	TIMEOUT_PAUSE_OP,
 	TIMEOUT_RESUME_OP,
 } from "../../bridge/reserved.ts";
@@ -33,6 +34,7 @@ type RuntimeModuleContext = {
 	readonly cwdUrl: string;
 	readonly localRootUrls: Readonly<Record<string, string>>;
 	readonly reservedAgentTool: string;
+	readonly reservedSchemaTool: string;
 	readonly reservedOutputTool: string;
 	readonly timeoutPauseOp: string;
 	readonly timeoutResumeOp: string;
@@ -55,6 +57,7 @@ function runtimeContext(options: LocalModuleLoaderOptions): RuntimeModuleContext
 		localRootUrls: roots,
 		reservedAgentTool: RESERVED_AGENT_TOOL,
 		reservedOutputTool: RESERVED_OUTPUT_TOOL,
+		reservedSchemaTool: RESERVED_SCHEMA_TOOL,
 		timeoutPauseOp: TIMEOUT_PAUSE_OP,
 		timeoutResumeOp: TIMEOUT_RESUME_OP,
 	};
@@ -66,6 +69,7 @@ function loaderPrelude(context: RuntimeModuleContext): string {
 		`globalThis.__senpi_module_context__ = ${serialized};`,
 		"globalThis.__senpi_reserved_agent_tool__ = globalThis.__senpi_module_context__.reservedAgentTool;",
 		"globalThis.__senpi_reserved_output_tool__ = globalThis.__senpi_module_context__.reservedOutputTool;",
+		"globalThis.__senpi_reserved_schema_tool__ = globalThis.__senpi_module_context__.reservedSchemaTool;",
 		"globalThis.__senpi_timeout_pause_op__ = globalThis.__senpi_module_context__.timeoutPauseOp;",
 		"globalThis.__senpi_timeout_resume_op__ = globalThis.__senpi_module_context__.timeoutResumeOp;",
 		"globalThis.__senpi_import__ = async (source, options) => {",

package/src/kernels/js/worker-runtime.js

@@ -50,6 +50,7 @@ export class JsWorkerRuntime {
 		globalThis.read = async (path, options, ...rest) => await this.#read(path, helperOptions("read", options, rest));
 		globalThis.write = async (path, content) => await this.#write(path, content);
 		globalThis.output = async (...args) => await this.#output(args);
+		globalThis.tool_schema = async name => await this.#toolSchema(name);
 		globalThis.agent = async (prompt, options, ...rest) => await this.#agent(prompt, options, rest);
 		globalThis.parallel = async thunks => await this.#parallel(thunks);
 		globalThis.pipeline = async (items, ...stages) => await this.#pipeline(items, stages);
@@ -250,6 +251,11 @@ export class JsWorkerRuntime {
 		return node;
 	}
 
+	async #toolSchema(name) {
+		const args = name === undefined || name === null ? {} : { name: String(name) };
+		return await this.#callTool(reservedTool("__senpi_reserved_schema_tool__", "tool_schema"), args);
+	}
+
 	async #callTool(toolName, args) {
 		const hooks = this.#hooks;
 		if (!hooks) throw new Error("tool call outside active JS cell");

package/src/kernels/py/prelude.py

@@ -37,6 +37,7 @@ EMIT_LOCK = Lock()
 # Mirrors src/bridge/reserved.ts; this standalone subprocess asset cannot import TypeScript.
 RESERVED_AGENT_TOOL = "__agent__"
 RESERVED_OUTPUT_TOOL = "__output__"
+RESERVED_SCHEMA_TOOL = "__schema__"
 TIMEOUT_PAUSE_OP = "timeout-pause"
 TIMEOUT_RESUME_OP = "timeout-resume"
 
@@ -374,6 +375,14 @@ def completion(
     return response.get("text", response)
 
 
+def tool_schema(name: str | None = None) -> Any:
+    args: dict[str, Any] = {} if name is None else {"name": name}
+    return bridge_post(
+        "/call",
+        {"callId": f"py-{uuid.uuid4()}", "toolName": RESERVED_SCHEMA_TOOL, "args": args},
+    )
+
+
 def output(
     *ids: str,
     format: str = "raw",
@@ -844,6 +853,7 @@ USER_NS.update(
         "completion": completion,
         "agent": agent,
         "output": output,
+        "tool_schema": tool_schema,
         "__senpi_magic": _magic,
         "__senpi_magic_cell": _magic_cell,
         "__senpi_shell": _shell,

package/src/kernels/rb/prelude.rb

@@ -5,6 +5,7 @@ require "uri"
 
 SENPI_RESERVED_AGENT_TOOL = "__agent__"
 SENPI_RESERVED_OUTPUT_TOOL = "__output__"
+SENPI_RESERVED_SCHEMA_TOOL = "__schema__"
 SENPI_INTERNAL_URL = Regexp.new("\\A([a-z][a-z0-9+.\\-]*)://(.*)\\z", Regexp::IGNORECASE)
 
 def __senpi_status_enabled?
@@ -187,6 +188,11 @@ def completion(prompt, model: "default", system: nil, schema: nil, **kwargs)
   result.fetch("text", result)
 end
 
+def tool_schema(name = nil)
+  args = name.nil? ? {} : { "name" => name.to_s }
+  __senpi_call_tool(SENPI_RESERVED_SCHEMA_TOOL, args)
+end
+
 def output(*ids, format: "raw", offset: nil, limit: nil)
   raise ArgumentError, "At least one output ID is required" if ids.empty?
   raise ArgumentError, "output() format must be 'raw' or 'tail'" unless ["raw", "tail"].include?(format)

package/src/prompt/eval-prompt.ts

@@ -154,6 +154,11 @@ env(key?=None, value?=None) → str | None | dict
     Task/agent output by id. Reads immediately: running tasks return their status; \`format\` selects full (\`"raw"\`) or trailing (\`"tail"\`) output.
 {{/if}}tool.<name>(args) → unknown
     Invoke any session tool; \`args\` = its parameter object.
+tool_schema(name?) → dict
+    Parameter schema of a tool without calling it; omit \`name\` to list tool names.
+    Use it before calling a tool you have not called before — a failed call also
+    returns the expected parameters, so fix the args and retry in the next cell
+    instead of abandoning eval.
 completion(prompt, model?="default", system?=None, schema?=None) → str | dict
     Oneshot, stateless (no history/tools). \`model\`: \`"smol"\` fast | \`"default"\` session | \`"slow"\` most capable. \`schema\` (JSON-Schema) → structured output, parsed object.
 {{#if spawns}}agent(prompt, agent?="{{spawnDefaultAgent}}", model?=None, label?=None, schema?=None, handle?=False) → str | dict

package/src/tool/call-capture.ts

@@ -0,0 +1,93 @@
+import { type AgentToolResult, sanitizeTerminalLabel } from "@code-yeongyu/senpi";
+
+export const MAX_ENRICHED_TOOL_CALLS = 30;
+
+const MAX_ARGUMENT_STRING_CODE_POINTS = 512;
+const MAX_ARGUMENT_ENTRIES = 32;
+const MAX_ARGUMENT_DEPTH = 6;
+const MAX_SERIALIZED_ARGUMENT_LENGTH = 4096;
+const MAX_RESULT_PREVIEW_CODE_POINTS = 160;
+
+type BoundedValue = {
+	readonly value: unknown;
+	readonly truncated: boolean;
+};
+
+export function capCodePoints(text: string, max: number): string {
+	let end = 0;
+	let count = 0;
+	while (count < max && end < text.length) {
+		const firstCodeUnit = text.charCodeAt(end);
+		const secondCodeUnit = text.charCodeAt(end + 1);
+		const isSurrogatePair =
+			firstCodeUnit >= 0xd800 && firstCodeUnit <= 0xdbff && secondCodeUnit >= 0xdc00 && secondCodeUnit <= 0xdfff;
+		end += isSurrogatePair ? 2 : 1;
+		count += 1;
+	}
+	return end === text.length ? text : `${text.slice(0, end)}…`;
+}
+
+function boundValue(value: unknown, depth: number, ancestors: WeakSet<object>): BoundedValue {
+	if (typeof value === "string") {
+		const capped = capCodePoints(value, MAX_ARGUMENT_STRING_CODE_POINTS);
+		return { value: capped, truncated: capped !== value };
+	}
+
+	if (value === null || typeof value !== "object") return { value, truncated: false };
+	if (depth >= MAX_ARGUMENT_DEPTH) return { value: "…", truncated: true };
+	if (ancestors.has(value)) throw new Error("cyclic tool-call arguments");
+
+	ancestors.add(value);
+	try {
+		if (Array.isArray(value)) {
+			const retainedLength = Math.min(value.length, MAX_ARGUMENT_ENTRIES);
+			const clone: unknown[] = [];
+			let truncated = value.length > MAX_ARGUMENT_ENTRIES;
+			for (let index = 0; index < retainedLength; index += 1) {
+				const bounded = boundValue(value[index], depth + 1, ancestors);
+				clone.push(bounded.value);
+				truncated ||= bounded.truncated;
+			}
+			return { value: clone, truncated };
+		}
+
+		const entries: [string, unknown][] = [];
+		let truncated = false;
+		let count = 0;
+		for (const [key, nestedValue] of Object.entries(value)) {
+			if (count >= MAX_ARGUMENT_ENTRIES) {
+				truncated = true;
+				break;
+			}
+			const bounded = boundValue(nestedValue, depth + 1, ancestors);
+			entries.push([key, bounded.value]);
+			truncated ||= bounded.truncated;
+			count += 1;
+		}
+		return { value: Object.fromEntries(entries), truncated };
+	} finally {
+		ancestors.delete(value);
+	}
+}
+
+export function boundToolCallArgs(args: unknown): { args: unknown; truncated: boolean } {
+	try {
+		const bounded = boundValue(args, 0, new WeakSet<object>());
+		const serialized = JSON.stringify(bounded.value);
+		if (typeof serialized !== "string" || serialized.length > MAX_SERIALIZED_ARGUMENT_LENGTH) {
+			return { args: undefined, truncated: true };
+		}
+		return { args: bounded.value, truncated: bounded.truncated };
+	} catch {
+		return { args: undefined, truncated: true };
+	}
+}
+
+export function toolCallResultPreview(result: AgentToolResult<unknown>): string | undefined {
+	for (const part of result.content) {
+		if (part.type !== "text") continue;
+		const preview = sanitizeTerminalLabel(part.text).replace(/\s+/gu, " ").trim();
+		return preview.length === 0 ? undefined : capCodePoints(preview, MAX_RESULT_PREVIEW_CODE_POINTS);
+	}
+	return undefined;
+}

package/src/tool/cell-handler.ts

@@ -1,11 +1,18 @@
-import type { AgentToolResult, AgentToolUpdateCallback, ExtensionContext } from "@code-yeongyu/senpi";
+import {
+	type AgentToolResult,
+	type AgentToolUpdateCallback,
+	type ExtensionContext,
+	sanitizeTerminalLabel,
+} from "@code-yeongyu/senpi";
 import type { KernelToHostMessage } from "../bridge/protocol.ts";
-import { RESERVED_AGENT_TOOL, RESERVED_OUTPUT_TOOL } from "../bridge/reserved.ts";
-import { type AgentExecuteTool, runEvalAgent } from "../bridges/agent-bridge.ts";
-import { runEvalOutput } from "../bridges/output-bridge.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";
+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 {
 	type EvalImageResizer,
 	EvalOutputCollector,
@@ -16,7 +23,19 @@ import {
 import { upsertStatusEvent } from "./status-events.ts";
 import type { EvalKernel, EvalStatusEvent, EvalToolDetails, EvalToolInput } from "./types.ts";
 
-type ResolvedToolReply = { readonly value: unknown; readonly toolCallOk: boolean };
+type ResolvedToolReply = {
+	readonly value: unknown;
+	readonly toolCallOk: boolean;
+	readonly resultPreview?: string;
+	readonly errorText?: string;
+};
+
+type ToolCallEnrichment = {
+	readonly callId: string;
+	readonly args: unknown;
+	readonly startedAt: number;
+	readonly argsTruncated?: true;
+};
 
 const LIVE_OUTPUT_PREVIEW_LINES = 8;
 
@@ -36,6 +55,7 @@ export interface CellState {
 
 export interface CellBridgeRuntime {
 	readonly executeTool: AgentExecuteTool;
+	readonly listTools?: () => readonly EvalSchemaToolInfo[];
 	readonly settings: ResolvedCodemodeSettings;
 	readonly complete?: (request: CompletionRequest, ctx: ExtensionContext) => Promise<CompletionResult>;
 	readonly ctx: ExtensionContext;
@@ -151,25 +171,17 @@ export class CellHandler {
 			});
 			return;
 		}
-		if (message.toolName === RESERVED_AGENT_TOOL) {
+		if (isReservedToolName(message.toolName)) {
 			await this.#deliverToolReply(message, async () => ({
-				value: await runEvalAgent(message.args, {
+				value: await runReservedTool(message.toolName, {
 					callId: message.callId,
-					taskToolName: this.#runtime.settings.taskTools.task,
+					args: message.args,
 					executeTool: this.#runtime.executeTool,
-					signal: this.#state.signal,
-					emitStatus: (event) => this.#recordStatus(event),
-				}),
-				toolCallOk: true,
-			}));
-			return;
-		}
-		if (message.toolName === RESERVED_OUTPUT_TOOL) {
-			await this.#deliverToolReply(message, async () => ({
-				value: await runEvalOutput(message.args, {
+					taskToolName: this.#runtime.settings.taskTools.task,
 					taskOutputToolName: this.#runtime.settings.taskTools.output,
-					executeTool: this.#runtime.executeTool,
+					listTools: this.#runtime.listTools,
 					signal: this.#state.signal,
+					emitStatus: (event) => this.#recordStatus(event),
 					marshalToolResult,
 				}),
 				toolCallOk: true,
@@ -193,25 +205,62 @@ export class CellHandler {
 			this.#emitUpdate(false);
 			return;
 		}
-		await this.#deliverToolReply(message, async () => {
-			const result = await this.#runtime.executeTool(message.toolName, message.args, { signal: this.#state.signal });
-			return { value: marshalToolResult(result), toolCallOk: !toolResultIsError(result) };
-		});
+		const capturedArgs = boundToolCallArgs(message.args);
+		const startedAt = Date.now();
+		await this.#deliverToolReply(
+			message,
+			async () => {
+				const result = await this.#runtime.executeTool(message.toolName, message.args, {
+					signal: this.#state.signal,
+				});
+				const toolCallOk = !toolResultIsError(result);
+				if (toolCallOk) {
+					const resultPreview = toolCallResultPreview(result);
+					return {
+						value: marshalToolResult(result),
+						toolCallOk,
+						...(resultPreview === undefined ? {} : { resultPreview }),
+					};
+				}
+				let errorText: string | undefined;
+				for (const part of result.content) {
+					if (part.type !== "text") continue;
+					errorText = capCodePoints(sanitizeTerminalLabel(part.text), 512);
+					break;
+				}
+				return {
+					value: marshalToolResult(result),
+					toolCallOk,
+					...(errorText === undefined ? {} : { errorText }),
+				};
+			},
+			{
+				callId: message.callId,
+				args: capturedArgs.args,
+				startedAt,
+				...(capturedArgs.truncated ? { argsTruncated: true } : {}),
+			},
+		);
 	}
 
 	async #deliverToolReply(
 		message: Extract<KernelToHostMessage, { type: "tool-call" }>,
 		resolve: () => Promise<ResolvedToolReply>,
+		enrich?: ToolCallEnrichment,
 	): Promise<void> {
 		try {
 			const reply = await resolve();
 			if (!this.#state.active) return;
-			this.#state.toolCalls.push({ name: message.toolName, ok: reply.toolCallOk });
+			this.#pushToolCall(message.toolName, reply.toolCallOk, enrich, 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;
-			const text = error instanceof Error ? error.message : String(error);
-			this.#state.toolCalls.push({ name: message.toolName, ok: false, error: text });
+			const text = appendSchemaHint(
+				error instanceof Error ? error.message : String(error),
+				message.toolName,
+				this.#toolParameters(message.toolName),
+			);
+			this.#pushToolCall(message.toolName, false, enrich, undefined, text);
 			this.#kernel.deliverToolReply({
 				type: "tool-reply",
 				callId: message.callId,
@@ -222,6 +271,33 @@ export class CellHandler {
 		this.#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;
+	}
+
 	#recordStatus(event: EvalStatusEvent): void {
 		if (!this.#runtime.settings.statusEvents) return;
 		upsertStatusEvent(this.#state.statusEvents, event);

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

@@ -68,7 +68,10 @@ export class EvalDetachedCellManager {
 
 	create(cellId: string, input: EvalToolInput): ManagedCell {
 		const existing = this.#cells.get(cellId);
-		if (existing !== undefined) throw new Error(`Eval cell ${cellId} is already managed`);
+		if (existing !== undefined) {
+			if (existing.state === "running" || existing.state === "detached") throw activeCellReuseError(existing);
+			this.#cells.delete(cellId);
+		}
 		const spillPath =
 			this.#artifactsDir === undefined
 				? undefined
@@ -232,6 +235,12 @@ export class EvalDetachedCellManager {
 	}
 }
 
+function activeCellReuseError(cell: ManagedCell): Error {
+	return new Error(
+		`Eval cell ${cell.cellId} from a previous call is still ${cell.state} in the ${cell.input.language} kernel. Use eval({ action: "peek", cell_id: "${cell.cellId}" }) to read it or eval({ action: "stop", cell_id: "${cell.cellId}" }) to end it before its id can be reused.`,
+	);
+}
+
 function allowsTransition(from: EvalDetachedCellState, to: EvalDetachedCellState): boolean {
 	if (from === "running") return to === "detached" || to === "completed" || to === "failed" || to === "cancelled";
 	if (from === "detached") return to === "completed" || to === "failed" || to === "cancelled";

package/src/tool/eval-tool.ts

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { join } from "node:path";
 import type { AgentToolResult, AgentToolUpdateCallback, ExtensionContext, ToolDefinition } from "@code-yeongyu/senpi";
+import type { EvalSchemaToolInfo } from "../bridges/schema-bridge.ts";
 import type { CompletionRequest, CompletionResult } from "../completion/handler.ts";
 import { defaultCodemodeSettings, type ResolvedCodemodeSettings } from "../config/settings.ts";
 import type { EvalExecutionTracker } from "../extension/session-manager.ts";
@@ -37,6 +38,7 @@ export interface CreateEvalToolOptions {
 	readonly kernelManager: EvalKernelManager;
 	readonly cellTimeoutSeconds: number;
 	readonly executeTool: ExecuteTool;
+	readonly listTools?: () => readonly EvalSchemaToolInfo[];
 	readonly complete?: (request: CompletionRequest, ctx: ExtensionContext) => Promise<CompletionResult>;
 	readonly settings?: ResolvedCodemodeSettings;
 	readonly artifactsDir?: string;
@@ -351,6 +353,7 @@ async function executeCell(
 		execution.setKernel(kernel);
 		handler = new CellHandler(kernel, state, {
 			executeTool: options.executeTool,
+			...(options.listTools === undefined ? {} : { listTools: options.listTools }),
 			settings: options.settings ?? defaultCodemodeSettings,
 			...(options.complete === undefined ? {} : { complete: options.complete }),
 			ctx: bridgeContext,

package/src/tool/render.ts

@@ -19,6 +19,7 @@ import {
 	JSON_TREE_SCALAR_LEN_EXPANDED,
 	renderJsonTreeLines,
 } from "./json-tree.ts";
+import { codePointPrefix, formatDuration, renderToolCallWidget } from "./tool-widgets.ts";
 import type {
 	EvalCellResult,
 	EvalInputSchema,
@@ -116,18 +117,6 @@ function appendLines(target: string[], source: readonly string[]): void {
 	for (const line of source) target.push(line);
 }
 
-function codePointPrefix(text: string, maxCodePoints: number): string {
-	let end = 0;
-	for (let count = 0; count < maxCodePoints && end < text.length; count += 1) {
-		const firstCodeUnit = text.charCodeAt(end);
-		const secondCodeUnit = text.charCodeAt(end + 1);
-		const isSurrogatePair =
-			firstCodeUnit >= 0xd800 && firstCodeUnit <= 0xdbff && secondCodeUnit >= 0xdc00 && secondCodeUnit <= 0xdfff;
-		end += isSurrogatePair ? 2 : 1;
-	}
-	return text.slice(0, end);
-}
-
 function renderAllVisualLines(text: string, width: number): string[] {
 	return truncateToVisualLines(text, Number.POSITIVE_INFINITY, width).visualLines.map((line) => line.trimEnd());
 }
@@ -232,18 +221,6 @@ function highlightedCode(code: string, language: EvalLanguage, theme: Theme | un
 	return (theme === undefined ? lines.map((line) => line.replace(/\u001b\[[0-9;]*m/gu, "")) : lines).join("\n");
 }
 
-function formatDuration(milliseconds: number): string {
-	const totalSeconds = Math.floor(Math.max(0, milliseconds) / 1_000);
-	if (totalSeconds < 1) return "<1s";
-	const seconds = totalSeconds % 60;
-	const totalMinutes = Math.floor(totalSeconds / 60);
-	if (totalMinutes < 1) return `${seconds}s`;
-	const minutes = totalMinutes % 60;
-	const hours = Math.floor(totalMinutes / 60);
-	if (hours < 1) return seconds === 0 ? `${minutes}m` : `${minutes}m ${seconds}s`;
-	return minutes === 0 ? `${hours}h` : `${hours}h ${minutes}m`;
-}
-
 function spinner(frame: number | undefined): string {
 	return SPINNER_FRAMES.at((frame ?? 0) % SPINNER_FRAMES.length) ?? SPINNER_FRAMES[0];
 }
@@ -695,6 +672,46 @@ function toolCallRows(details: EvalToolDetails | undefined): ToolCallRow[] {
 	});
 }
 
+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,
@@ -732,7 +749,7 @@ function resultMetadata(
 ): RenderBlock[] {
 	const metadata: string[] = [];
 	if (details?.phase) metadata.push(`phase ${details.phase}`);
-	if (!options.isPartial && details) metadata.push(`took ${details.durationMs}ms`);
+	if (!options.isPartial && typeof details?.durationMs === "number") metadata.push(`took ${details.durationMs}ms`);
 	if (metadata.length === 0) return [];
 	return [{ kind: "text", text: style(theme, "muted", metadata.join(" | ")) }];
 }
@@ -824,7 +841,9 @@ export function renderEvalResult(
 			},
 		];
 		const calls = toolCallRows(details);
-		if (calls.length > 0) blocks.push({ kind: "blank" }, { kind: "toolCalls", calls, expanded, theme });
+		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;
 	}
@@ -888,7 +907,8 @@ export function renderEvalResult(
 		);
 	}
 	const calls = toolCallRows(details);
-	if (calls.length > 0) blocks.push({ kind: "blank" }, { kind: "toolCalls", calls, expanded, theme });
+	const nestedCalls = nestedToolCallBlock(details, theme, context.cwd, expanded);
+	if (calls.length > 0) blocks.push({ kind: "blank" }, nestedCalls ?? { kind: "toolCalls", calls, expanded, theme });
 	if (details?.notice !== undefined)
 		blocks.push({ kind: "blank" }, { kind: "text", text: style(theme, "dim", details.notice) });
 	const warning = formatTruncationWarning(details?.meta) ?? (details?.truncated ? "[eval output truncated]" : null);

package/src/tool/tool-widgets.ts

@@ -0,0 +1,259 @@
+import {
+	createBashToolDefinition,
+	createFindToolDefinition,
+	createGrepToolDefinition,
+	createLsToolDefinition,
+	createReadToolDefinition,
+	createWriteToolDefinition,
+	sanitizeTerminalLabel,
+	type Theme,
+	type ThemeColor,
+	type ToolDefinition,
+	truncateToVisualLines,
+} from "@code-yeongyu/senpi";
+import type { TSchema } from "typebox";
+import { Check } from "typebox/value";
+import type { EvalToolCallSummary } from "./types.ts";
+
+export interface WidgetOptions {
+	readonly cwd: string;
+	readonly theme: Theme | undefined;
+	readonly expanded: boolean;
+	readonly width: number;
+}
+
+type AnyToolDef<TParams extends TSchema, TDetails, TState> = ToolDefinition<TParams, TDetails, TState>;
+type RenderCallOf<TParams extends TSchema, TDetails, TState> = NonNullable<
+	AnyToolDef<TParams, TDetails, TState>["renderCall"]
+>;
+type ToolRenderContext<TParams extends TSchema, TDetails, TState> = Parameters<
+	RenderCallOf<TParams, TDetails, TState>
+>[2];
+type Component<TParams extends TSchema, TDetails, TState> = ReturnType<RenderCallOf<TParams, TDetails, TState>>;
+
+type CoreWidgetName = "bash" | "read" | "write" | "grep" | "find" | "ls";
+type CoreWidgetRenderer = (summary: EvalToolCallSummary, options: WidgetOptions) => string[] | undefined;
+type CoreWidgets = Readonly<Record<CoreWidgetName, CoreWidgetRenderer>>;
+
+const MIN_RENDERER_WIDTH = 20;
+const MAX_RENDERER_LINES = 5;
+const MAX_FALLBACK_ARGUMENT_CODE_POINTS = 120;
+const MAX_COLLAPSED_ERROR_CODE_POINTS = 512;
+const MAX_COLLAPSED_ERROR_LINES = 4;
+const MAX_PREVIEW_LINES = 2;
+const MAX_COLLAPSED_WIDGET_LINES = 8;
+const TOOL_ERROR_OMISSION_MARKER = "[tool error omitted]";
+const WIDGET_TRUNCATION_MARKER = "… (widget truncated)";
+const TERMINAL_ESCAPE_PATTERN =
+	/(?:\u001B\][\s\S]*?(?:\u0007|\u001B\\|\u009C))|[\u001B\u009B][[\]()#;?]*(?:\d{1,4}(?:[;:]\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]/g;
+const TERMINAL_CONTROL_PATTERN = /[\u0000-\u0009\u000b-\u001f\u007f-\u009f]+/g;
+const coreWidgetsByCwd = new Map<string, CoreWidgets>();
+
+export function codePointPrefix(text: string, maxCodePoints: number): string {
+	let end = 0;
+	for (let count = 0; count < maxCodePoints && end < text.length; count += 1) {
+		const firstCodeUnit = text.charCodeAt(end);
+		const secondCodeUnit = text.charCodeAt(end + 1);
+		const isSurrogatePair =
+			firstCodeUnit >= 0xd800 && firstCodeUnit <= 0xdbff && secondCodeUnit >= 0xdc00 && secondCodeUnit <= 0xdfff;
+		end += isSurrogatePair ? 2 : 1;
+	}
+	return text.slice(0, end);
+}
+
+export function formatDuration(milliseconds: number): string {
+	const totalSeconds = Math.floor(Math.max(0, milliseconds) / 1_000);
+	if (totalSeconds < 1) return "<1s";
+	const seconds = totalSeconds % 60;
+	const totalMinutes = Math.floor(totalSeconds / 60);
+	if (totalMinutes < 1) return `${seconds}s`;
+	const minutes = totalMinutes % 60;
+	const hours = Math.floor(totalMinutes / 60);
+	if (hours < 1) return seconds === 0 ? `${minutes}m` : `${minutes}m ${seconds}s`;
+	return minutes === 0 ? `${hours}h` : `${hours}h ${minutes}m`;
+}
+
+function style(theme: Theme | undefined, color: ThemeColor, text: string): string {
+	return theme === undefined ? text : theme.fg(color, text);
+}
+
+function renderAllVisualLines(text: string, width: number): string[] {
+	return truncateToVisualLines(text, Number.POSITIVE_INFINITY, width).visualLines.map((line) => line.trimEnd());
+}
+
+function renderFirstVisualLines(text: string, maxLines: number, width: number): string[] {
+	const truncated = truncateToVisualLines(text, maxLines, width);
+	if (truncated.skippedCount === 0) return truncated.visualLines.map((line) => line.trimEnd());
+	return renderAllVisualLines(text, width).slice(0, maxLines);
+}
+
+function indent(lines: readonly string[]): string[] {
+	return lines.map((line) => `  ${line}`);
+}
+
+function renderWith<TParams extends TSchema, TDetails, TState>(
+	definition: ToolDefinition<TParams, TDetails, TState>,
+	summary: EvalToolCallSummary,
+	options: WidgetOptions,
+	initialState: TState,
+): string[] | undefined {
+	let preparedArgs: unknown = summary.args;
+	try {
+		if (definition.prepareArguments !== undefined) preparedArgs = definition.prepareArguments(preparedArgs);
+		if (!Check(definition.parameters, preparedArgs)) return undefined;
+	} catch {
+		return undefined;
+	}
+
+	const theme = options.theme;
+	const innerWidth = options.width - 2;
+	const renderCall = definition.renderCall;
+	if (theme === undefined || innerWidth < MIN_RENDERER_WIDTH || renderCall === undefined) return undefined;
+
+	const context: ToolRenderContext<TParams, TDetails, TState> = {
+		args: preparedArgs,
+		toolCallId: summary.callId ?? summary.name,
+		invalidate: () => {},
+		lastComponent: undefined,
+		state: initialState,
+		cwd: options.cwd,
+		executionStarted: true,
+		argsComplete: true,
+		isPartial: false,
+		expanded: options.expanded,
+		showImages: false,
+		isError: !summary.ok,
+		hasResult: false,
+	};
+
+	try {
+		const component: Component<TParams, TDetails, TState> = renderCall(preparedArgs, theme, context);
+		const renderedLines = component.render(innerWidth).map((line) => line.trimEnd());
+		const retainedLines = renderedLines.slice(0, MAX_RENDERER_LINES);
+		if (renderedLines.length > retainedLines.length) {
+			retainedLines.push(style(theme, "muted", WIDGET_TRUNCATION_MARKER));
+		}
+		return indent(retainedLines);
+	} catch {
+		return undefined;
+	}
+}
+
+function createCoreWidgets(cwd: string): CoreWidgets {
+	const bashDefinition = createBashToolDefinition(cwd);
+	const readDefinition = createReadToolDefinition(cwd);
+	const writeDefinition = createWriteToolDefinition(cwd);
+	const grepDefinition = createGrepToolDefinition(cwd);
+	const findDefinition = createFindToolDefinition(cwd);
+	const lsDefinition = createLsToolDefinition(cwd);
+	const widgets: CoreWidgets = {
+		bash: (summary, options) =>
+			renderWith(bashDefinition, summary, options, {
+				startedAt: undefined,
+				endedAt: undefined,
+				interval: undefined,
+			}),
+		read: (summary, options) => renderWith(readDefinition, summary, options, {}),
+		write: (summary, options) => renderWith(writeDefinition, summary, options, {}),
+		grep: (summary, options) => renderWith(grepDefinition, summary, options, {}),
+		find: (summary, options) => renderWith(findDefinition, summary, options, {}),
+		ls: (summary, options) => renderWith(lsDefinition, summary, options, {}),
+	};
+	return widgets;
+}
+
+function coreWidgetsFor(cwd: string): CoreWidgets {
+	const cached = coreWidgetsByCwd.get(cwd);
+	if (cached !== undefined) return cached;
+	const widgets = createCoreWidgets(cwd);
+	coreWidgetsByCwd.set(cwd, widgets);
+	return widgets;
+}
+
+function isCoreWidgetName(name: string): name is CoreWidgetName {
+	switch (name) {
+		case "bash":
+		case "read":
+		case "write":
+		case "grep":
+		case "find":
+		case "ls":
+			return true;
+		default:
+			return false;
+	}
+}
+
+function compactArguments(args: unknown): string {
+	if (args === undefined) return "";
+	try {
+		const serialized = JSON.stringify(args);
+		if (serialized === undefined) return "";
+		return codePointPrefix(sanitizeTerminalLabel(serialized), MAX_FALLBACK_ARGUMENT_CODE_POINTS);
+	} catch {
+		return "[unserializable args]";
+	}
+}
+
+function renderFallback(summary: EvalToolCallSummary, width: number): string[] {
+	const name = sanitizeTerminalLabel(summary.name);
+	const fallback = `tool.${name}(${compactArguments(summary.args)})`;
+	return indent(renderAllVisualLines(fallback, width));
+}
+
+function renderStatus(summary: EvalToolCallSummary, options: WidgetOptions, width: number): string[] {
+	const icon = style(options.theme, summary.ok ? "success" : "error", summary.ok ? "✓" : "✗");
+	const parts = [icon];
+	if (summary.durationMs !== undefined) parts.push(formatDuration(summary.durationMs));
+	if (summary.argsTruncated) parts.push("(args truncated)");
+	return indent(renderFirstVisualLines(parts.join(" "), 1, width));
+}
+
+function sanitizeTerminalControl(text: string): string {
+	return text.replace(TERMINAL_ESCAPE_PATTERN, "").replace(TERMINAL_CONTROL_PATTERN, " ");
+}
+
+function renderPreview(preview: string, options: WidgetOptions, width: number): string[] {
+	const sanitized = sanitizeTerminalControl(preview);
+	if (sanitized.length === 0) return [];
+	return indent(renderFirstVisualLines(style(options.theme, "muted", sanitized), MAX_PREVIEW_LINES, width));
+}
+
+function renderCollapsedError(error: string, options: WidgetOptions, width: number): string[] {
+	const guardedError = codePointPrefix(error, MAX_COLLAPSED_ERROR_CODE_POINTS);
+	const guardedLines = renderAllVisualLines(style(options.theme, "error", guardedError), width);
+	if (guardedError.length === error.length && guardedLines.length <= MAX_COLLAPSED_ERROR_LINES) {
+		return indent(guardedLines);
+	}
+
+	const markerLines = renderAllVisualLines(style(options.theme, "muted", TOOL_ERROR_OMISSION_MARKER), width);
+	const errorBudget = Math.max(0, MAX_COLLAPSED_ERROR_LINES - markerLines.length);
+	const lines = guardedLines.slice(0, errorBudget);
+	lines.push(...markerLines.slice(0, MAX_COLLAPSED_ERROR_LINES - lines.length));
+	return indent(lines);
+}
+
+function renderError(error: string, options: WidgetOptions, width: number): string[] {
+	const sanitized = sanitizeTerminalControl(error);
+	if (options.expanded) return indent(renderAllVisualLines(style(options.theme, "error", sanitized), width));
+	return renderCollapsedError(sanitized, options, width);
+}
+
+/**
+ * The theme-less fallback is QA-only. Production's gate lives in render.ts:
+ * nestedToolCallBlock routes theme-less renders to legacy rows before this function is called.
+ */
+export function renderToolCallWidget(summary: EvalToolCallSummary, options: WidgetOptions): string[] {
+	const innerWidth = Math.max(1, options.width - 2);
+	const coreLines = isCoreWidgetName(summary.name)
+		? coreWidgetsFor(options.cwd)[summary.name](summary, options)
+		: undefined;
+	const lines = coreLines ?? renderFallback(summary, innerWidth);
+	lines.push(...renderStatus(summary, options, innerWidth));
+	if (summary.ok && summary.resultPreview !== undefined) {
+		lines.push(...renderPreview(summary.resultPreview, options, innerWidth));
+	} else if (!summary.ok && summary.error !== undefined) {
+		lines.push(...renderError(summary.error, options, innerWidth));
+	}
+	return options.expanded ? lines : lines.slice(0, MAX_COLLAPSED_WIDGET_LINES);
+}

package/src/tool/types.ts

@@ -110,13 +110,18 @@ export interface EvalKernelManager {
 export type ExecuteTool = (
 	toolName: string,
 	params: unknown,
-	options?: { signal?: AbortSignal; onUpdate?: AgentToolUpdateCallback<unknown> },
+	options?: { signal?: AbortSignal; onUpdate?: AgentToolUpdateCallback<unknown>; activateInactiveTool?: boolean },
 ) => Promise<AgentToolResult<unknown>>;
 
 export interface EvalToolCallSummary {
 	readonly name: string;
 	readonly ok: boolean;
 	readonly error?: string;
+	readonly callId?: string;
+	readonly args?: unknown;
+	readonly argsTruncated?: boolean;
+	readonly durationMs?: number;
+	readonly resultPreview?: string;
 }
 
 export type EvalStatusEvent = { readonly op: string } & Readonly<Record<string, unknown>>;