@code-yeongyu/senpi-codemode 2026.7.25-2 → 2026.7.28

package/CHANGELOG.md

@@ -12,6 +12,45 @@
 
 ### 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
+
+- Remove the separate GPT-only `exec`/`wait` runtime; GPT models now compose active tools through the persistent `eval` surface.
+
+### Added
+
+- Detach interactive `eval` cells on timeout, inject completion notifications, and support `peek`/`stop` actions without blocking other language kernels.
+- Report whether Python kernel state survived an interrupt or timeout, with a real-surface QA driver covering the contract.
+
+### Changed
+
+- Bound each cell's retained status history and summarize omitted events ([#334](https://github.com/code-yeongyu/senpi/pull/334) by [@minpeter](https://github.com/minpeter)).
+- Make task-output lookups non-blocking and document detached-cell state, output, and artifact behavior.
+
+### Fixed
+
+- Preserve Python state when interruption succeeds, report truthful state when it does not, and tolerate kernels predating the interrupt-outcome contract.
+- Stop normal bridge-request completion from aborting still-running host tool calls.
+
+### Removed
+
 ## [2026.7.25-2] - 2026-07-25
 
 ### Breaking Changes

package/README.md

@@ -1,15 +1,19 @@
 # @code-yeongyu/senpi-codemode
 
 `@code-yeongyu/senpi-codemode` is Senpi's source-only Code Mode extension. It
-registers persistent-kernel `eval` for every eligible model and GPT-only
-`exec`/`wait` cells for bounded JavaScript orchestration. `eval` owns one
-persistent kernel per enabled language and re-registers at session start after
-configuration, interpreter availability, and active task-tool names are known.
+registers the persistent-kernel `eval` execution surface for every eligible
+model. `eval` owns one persistent kernel per enabled language and re-registers
+at session start after configuration, interpreter availability, and active
+task-tool names are known.
 
 ## Capabilities
 
 - Persistent JavaScript, Python, Ruby, and Julia cells. State survives later
   cells in the same language until reset, restart, or session disposal.
+- Timeout detachment for interactive `eval`: long pure-compute cells return a
+  handle and continue in their existing kernel. Completion is injected with the
+  final value/error and buffered output; use `eval({ action: "peek"|"stop",
+  cell_id })` to inspect or terminate a detached cell.
 - Loopback, bearer-authenticated kernel bridge with bounded JSONL frames.
 - Structured status events for file operations, environment access, phases,
   bridge activity, and delegated task progress.
@@ -20,8 +24,8 @@ configuration, interpreter availability, and active task-tool names are known.
   fallbacks.
 - JavaScript import rewriting for supported local modules and package imports
   in the persistent Node.js worker.
-- GPT Code Mode `exec`/`wait` cells use fresh JavaScript workers, can compose
-  active tools through `tools.<name>(args)`, and never replace `eval`.
+- GPT models receive a terse `eval` prompt dialect that prioritizes composing
+  active tools through `tool.<name>(args)` and documents detach-on-timeout.
 
 ## Kernels
 
@@ -68,13 +72,13 @@ Configuration is loaded in this order:
 | Key | Default | Effect |
 | --- | --- | --- |
 | `languages` | `py`/`js` enabled; `rb`/`jl` disabled | Selects desired languages before interpreter detection. |
-| `cellTimeoutSeconds` | `30` | Idle timeout for one cell unless the call supplies `timeout`. |
+| `cellTimeoutSeconds` | `30` | Idle timeout for one cell unless the call supplies `timeout`; interactive calls detach by default and print/json calls error. |
 | `parallelPoolWidth` | `4` | Maximum concurrent `parallel()` thunks. |
 | `taskTools.task` | `"task"` | Registered tool name used by `agent()`. |
 | `taskTools.output` | `"task_output"` | Registered tool name used by `output()`. |
 | `outputSink.headBytes` | `20480` | Bytes retained from the beginning of a middle-truncated preview; `0` disables it. |
 | `outputSink.maxColumns` | `768` | Maximum rendered output columns; `0` disables column clamping. |
-| `statusEvents` | `true` | Enables kernel status-event forwarding and rendering. |
+| `statusEvents` | `true` | Enables kernel status-event forwarding and rendering. Each cell retains at most 100 status rows; after overflow, one omitted-count row precedes the latest 99 events. |
 
 `SENPI_CODEMODE_PY`, `SENPI_CODEMODE_JS`, `SENPI_CODEMODE_RB`, and
 `SENPI_CODEMODE_JL` override the corresponding file setting. `1` or `true`
@@ -96,7 +100,8 @@ options object and asynchronous helpers are `await`-able.
 | `read(path, offset?, limit?)` | Reads text with 1-indexed line slicing. `local://` paths resolve under the session artifact root. |
 | `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)` / `tools.<name>(args)` | Invokes an active Senpi tool through the normal `pi.executeTool` pipeline. `tools` is the GPT Code Mode spelling. |
+| `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. |
@@ -104,14 +109,37 @@ 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. Missing
-tools produce a clear availability error instead of importing an orchestration
-package. `agent()` delegates through the tool contract, so task-engine
-permissions, progress updates, and transcripts remain owned by that engine.
+session. `output()` similarly requires the configured task-output tool and
+returns immediately: a running task reports its current status, while completed
+tasks return the requested transcript. Missing tools produce a clear
+availability error instead of importing an orchestration package. `agent()`
+delegates through the tool contract, so task-engine permissions, progress
+updates, and transcripts remain owned by that engine.
 `isolated`, `apply`, and `merge` are accepted for compatibility but emit a
 warning because this task-engine integration has no isolation model.
 
+## Detached cells
+
+`eval` accepts `on_timeout: "detach"|"error"`. The default is `"detach"` in
+interactive TUI, RPC, and app-server sessions; print and JSON one-shot runs
+default to `"error"` so their result is never silently detached. A detached
+cell keeps only its own language kernel busy. A new same-language call returns
+a busy error with its cell id and output tail; calls in other languages continue
+normally. Do not re-run the cell.
+
+Use `eval({ action: "peek", cell_id })` for its state and buffered output, or
+`eval({ action: "stop", cell_id })` to cancel it. Python stop interrupts the
+existing kernel and preserves variables. JavaScript stop kills and restarts its
+worker, so JavaScript VM state is lost. Detached completion messages state when
+kernel variables are available to the next eval cell; oversized buffered output
+is written under the session local root and referenced as `local://…`.
+
 ## Output and artifacts
 
 Cell output is streamed while the cell runs. Large streams spill to an absolute
@@ -139,11 +167,9 @@ Session generations fence retired kernels and callbacks; each cell settles once
 across completion, errors, cancellation, timeout, bridge failure, or a kernel
 crash.
 
-GPT Code Mode is not an additional sandbox: it uses the same Node worker trust
-boundary as JavaScript `eval`. Its separate cell lifecycle exists so a yielded
-`exec` can be observed or terminated with `wait` without affecting persistent
-`eval` kernels. `eval`, `exec`, and `wait` are excluded from the nested tool
-namespace to prevent recursive Code Mode execution.
+GPT models use the same JavaScript `eval` worker trust boundary as other JavaScript cells;
+there is no separate execution runtime. `eval` is excluded from the nested tool
+namespace to prevent recursive execution.
 
 ## Validation
 
@@ -157,5 +183,5 @@ npm run check
 
 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`, `qa-gpt-code-mode.ts`), and renderer output
+extension execution (`qa-e2e-eval.ts`), and renderer output
 (`qa-render-dump.ts`).

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-codemode",
-	"version": "2026.7.25-2",
+	"version": "2026.7.28",
 	"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.25-2",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@^2026.7.28",
 		"typebox": "1.1.38"
 	},
 	"peerDependencies": {
 		"@code-yeongyu/senpi": "*"
 	},
 	"devDependencies": {
-		"@code-yeongyu/senpi": "2026.7.25-2"
+		"@code-yeongyu/senpi": "2026.7.28"
 	},
 	"keywords": [
 		"senpi",

package/src/bridge/http-server.ts

@@ -75,7 +75,12 @@ async function handleRequest(
 	options: BridgeServerOptions,
 ): Promise<void> {
 	const abortController = new AbortController();
-	request.on("close", () => abortController.abort());
+	// IncomingMessage "close" fires on normal message completion in Node >= 16,
+	// so premature disconnect must be detected on the response side instead:
+	// its "close" without a finished response means the connection died mid-call.
+	response.on("close", () => {
+		if (!response.writableFinished) abortController.abort();
+	});
 	if (request.method !== "POST") {
 		sendJson(response, 404, { ok: false, error: transportError("not_found", "Bridge route was not found") });
 		return;

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/output-bridge.ts

@@ -62,7 +62,6 @@ export async function runEvalOutput(args: unknown, options: RunEvalOutputOptions
 					{
 						...(id.startsWith("st_") ? { task_id: id } : { name: id }),
 						mode,
-						block: true,
 					},
 					options.signal === undefined ? undefined : { signal: options.signal },
 				);

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/eval-notifier.ts

@@ -0,0 +1,40 @@
+import type { ExtensionContext } from "@code-yeongyu/senpi";
+import type { EvalDetachedCellNotification, EvalDetachedCellNotifier } from "../tool/detached-cell-manager.ts";
+
+const NON_INTERACTIVE_MODES = new Set(["print", "json"]);
+
+export type EvalNotifyMode = "wake" | "next-turn" | "off";
+
+export interface EvalNotifierDeps {
+	readonly sendUserMessage: (content: string, options?: { deliverAs?: "steer" | "followUp" }) => void;
+	readonly getContext: () => ExtensionContext | undefined;
+	readonly getMode: () => EvalNotifyMode;
+}
+
+/** Session-scoped completion injector with the same no-spin guards as terminal notifications. */
+export class EvalNotifier implements EvalDetachedCellNotifier {
+	readonly #deps: EvalNotifierDeps;
+	readonly #notified = new Set<string>();
+
+	constructor(deps: EvalNotifierDeps) {
+		this.#deps = deps;
+	}
+
+	/** Starts a fresh session generation without suppressing reused tool-call ids. */
+	reset(): void {
+		this.#notified.clear();
+	}
+
+	notify(cells: readonly EvalDetachedCellNotification[]): void {
+		const mode = this.#deps.getMode();
+		if (mode === "off") return;
+		const ctx = this.#deps.getContext();
+		if (ctx === undefined || NON_INTERACTIVE_MODES.has(ctx.mode) || ctx.model === undefined) return;
+		const pending = cells.filter((cell) => !this.#notified.has(cell.cellId));
+		if (pending.length === 0) return;
+		for (const cell of pending) this.#notified.add(cell.cellId);
+		this.#deps.sendUserMessage(pending.map((cell) => cell.content).join("\n\n"), {
+			deliverAs: mode === "wake" ? "steer" : "followUp",
+		});
+	}
+}

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),
 	});