fix(tui): report reconnecting instead of unknown tool for promoted-but-unmounted calls

Summary: the live call gate now distinguishes a registry miss on a gate-activated (promoted) name — its server dropped between search and call — from a never-activated miss. Activated misses return a reconnecting/retry-shortly error; plain misses keep the exact unknown tool string. Both production gates (TUI session, exec) pass the activation predicate; the wire hold-off machinery is untouched.

Verification: bun test on dynamic-tool-runner, assemble-runtime, tool-search, exec runner suites plus src/tui/runner (87 pass, 0 fail); oxfmt/oxlint clean on changed files; tsc shows only the pre-existing vendor semver error (proven on pristine HEAD via stash).

Author: TheGreatAxios

src/exec/runner.ts

@@ -846,6 +846,8 @@ export async function runExec(config: Config): Promise<ExecResult> {
       createExecToolCallGate(isAdvertised, {
         isCodex: isCodexProviderName(config.providerName),
       }),
+      // Same promoted-but-unmounted contract as the TUI gate (see above).
+      { isActivated: (name) => activatedToolNames.has(name) },
     );
 
     const { directorHolder, buildAgent } = assembleChatAgent({

src/tui/dynamic-tool-runner.test.ts

@@ -180,6 +180,48 @@ describe("mangled dispatch names", () => {
   });
 });
 
+describe("activated-but-unmounted registry miss", () => {
+  test("a gate-activated name missing from the registry reports reconnecting, not unknown tool", async () => {
+    const runner = createDynamicToolRunner([
+      stringTool("read_file", "core"),
+      stringTool("mcp__acme__do", "blind-result"),
+    ]);
+    const activated = new Set(["mcp__acme__do"]);
+    runner.setCallGate((name) => name === "read_file" || activated.has(name), {
+      isActivated: (name) => activated.has(name),
+    });
+
+    // The tool was promoted (gate open) but its server disconnected before the
+    // call, so removeTools dropped it from the registry mid-window.
+    runner.removeTools(["mcp__acme__do"]);
+    const result = await runner.run(
+      { id: "1", name: "mcp__acme__do", arguments: {} },
+      new AbortController().signal,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("mcp__acme__do");
+    expect(result.content).toContain("reconnecting");
+    expect(result.content).toContain("Retry the call shortly");
+    expect(result.content).not.toBe("unknown tool: mcp__acme__do");
+  });
+
+  test("a never-activated miss keeps the exact unknown tool string", async () => {
+    const runner = createDynamicToolRunner([stringTool("read_file", "core")]);
+    runner.setCallGate((name) => name === "read_file", {
+      isActivated: () => false,
+    });
+
+    const result = await runner.run(
+      { id: "1", name: "mcp__gone__tool", arguments: {} },
+      new AbortController().signal,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toBe("unknown tool: mcp__gone__tool");
+  });
+});
+
 describe("terminal control stripping", () => {
   test("strips escape sequences from any tool's result, including MCP", async () => {
     const payload = "before\x1b]52;c;ZXZpbA==\x07\x1b[31mred\x1b[0m\x07after";

src/tui/dynamic-tool-runner.ts

@@ -31,8 +31,18 @@ export type DynamicToolRunner = AgentToolRunner & {
    * the current wire (built-in prefix + pinned + activated) with an error
    * pointing at tool_search, instead of silently dispatching. Without a gate
    * every registered tool stays dispatchable — sub-agent runners never set one.
+   *
+   * `options.isActivated` is the promotion side of the gate: a name the model
+   * was already shown (tool_search activated it) that is absent from the
+   * registry — its server disconnected or the snapshot rebuilt under it —
+   * reports "not currently available, server may be reconnecting, retry
+   * shortly" instead of the bare unknown-tool string. Names never activated
+   * keep the exact unknown-tool string.
    */
-  setCallGate(isCallable: (name: string) => boolean): void;
+  setCallGate(
+    isCallable: (name: string) => boolean,
+    options?: { isActivated?: (name: string) => boolean },
+  ): void;
 };
 
 export function createDynamicToolRunner(
@@ -41,6 +51,7 @@ export function createDynamicToolRunner(
 ): DynamicToolRunner {
   const byName = new Map<string, AgentTool>();
   let callGate: ((name: string) => boolean) | undefined;
+  let isActivated: ((name: string) => boolean) | undefined;
 
   const addTools = (tools: AgentTool[]): void => {
     const incoming = new Set<string>();
@@ -69,8 +80,12 @@ export function createDynamicToolRunner(
     addTools,
     removeTools,
     currentDefinitions,
-    setCallGate(isCallable: (name: string) => boolean): void {
+    setCallGate(
+      isCallable: (name: string) => boolean,
+      options?: { isActivated?: (name: string) => boolean },
+    ): void {
       callGate = isCallable;
+      isActivated = options?.isActivated;
     },
     async run(call: ToolCall, signal: AbortSignal): Promise<ToolResult> {
       const resolved = resolveRegisteredToolName(call.name, (name) =>
@@ -85,6 +100,20 @@ export function createDynamicToolRunner(
       }
       const found = byName.get(resolved);
       if (found === undefined) {
+        // The name was promoted (gate-activated) but the registry no longer
+        // holds it — the server dropped between search and call. Say so: the
+        // model already has the schema from the tool_search card and only
+        // needs to retry, not re-search. A name never activated keeps the
+        // exact unknown-tool string.
+        if (isActivated?.(call.name) === true) {
+          return {
+            callId: call.id,
+            content:
+              `Error: ${call.name} is not currently available — its server may ` +
+              `still be reconnecting. Retry the call shortly.`,
+            isError: true,
+          };
+        }
         return {
           callId: call.id,
           content: `unknown tool: ${call.name}`,

src/tui/runner/session.ts

@@ -498,6 +498,9 @@ export async function assembleTUISession(
   ]);
   toolset.dynamicRunner.setCallGate(
     (name) => unadvertisedCallable.has(name) || isAdvertised(name),
+    // A promoted-but-unmounted name (server dropped between search and call)
+    // reports reconnecting instead of bare unknown-tool at the call gate.
+    { isActivated: (name) => activatedToolNames.has(name) },
   );
 
   // Reload, interrupt, compaction continuation, and proxy deliver share one queue