fix(tools): advertise late MCP tools on execute in tests

Search no longer grows the advertised set. The late-dispatch harness
now uses the same call-gate promoter as TUI and exec so schemas land
on the next infer.

Author: TheGreatAxios

e2e/mcp-late-dispatch.test.ts

@@ -6,8 +6,10 @@ import { createAgentWithLiveToolDispatch } from "../src/agent/live-tool-dispatch
 import type { MCPClient } from "../src/mcp/client.js";
 import { mcpClientTools } from "../src/mcp/plugin.js";
 import { createPermissionGate } from "../src/permission/gate.js";
+import { createAdvertisedToolset } from "../src/session/assemble-runtime.js";
 import {
   closeIntegrationSession,
+  INTEGRATION_SOURCE,
   openIntegrationSession,
   runUntilDone,
   toolDoneEvents,
@@ -108,13 +110,35 @@ function toolDoneContents(events: ReactorEmittedEvent[]): string[] {
   );
 }
 
-// Registers dynamic tools as promotable so the next request advertises them.
+// Wires production promote-on-execute: search returns cards only; a call to a
+// registered-but-unadvertised name declares that one schema, then dispatches.
 function promoteDynamicTools(session: IntegrationSession): void {
-  session.toolset.setToolPromoter(() => {
+  const advertised = createAdvertisedToolset({
+    sessionMode: "orchestrator",
+    toolAvailability: { languageServerAvailable: false },
+    getProvider: () => ({
+      providerName: INTEGRATION_SOURCE.provider,
+      model: INTEGRATION_SOURCE.model,
+    }),
+  });
+  session.toolset.dynamicRunner.setCallGate(
+    (name) => advertised.isAdvertised(name),
+    { isActivated: (name) => advertised.activated.has(name) },
+  );
+  session.toolset.setToolPromoter((names) => {
+    if (!advertised.activated.activate(names)) return;
+    if (!advertised.flushPromotions()) return;
     session.updateToolDefinitions(
-      session.toolset.dynamicRunner.currentDefinitions(),
+      advertised.computeAdvertised(
+        session.toolset.dynamicRunner.currentDefinitions(),
+      ),
     );
   });
+  session.updateToolDefinitions(
+    advertised.computeAdvertised(
+      session.toolset.dynamicRunner.currentDefinitions(),
+    ),
+  );
 }
 
 function replyScript(
@@ -318,7 +342,10 @@ describe("integration — late MCP dispatch", () => {
         promotionScript(session, call);
 
         const { events } = await runUntilDone(session, "list one linear issue");
-        const published = publishedTool(await requestBodies(session));
+        const bodies = await requestBodies(session);
+        expect(bodies.length).toBeGreaterThan(0);
+        expect(publishedTool(bodies.slice(0, 1))).toBeUndefined();
+        const published = publishedTool(bodies);
 
         if (schema === undefined) {
           expect(published?.input_schema.properties).toEqual(

src/agent/tool-search.test.ts

@@ -320,7 +320,10 @@ function listedToolNames(out: string): string[] {
   return out
     .split("\n")
     .filter((line) => line.startsWith("- "))
-    .map((line) => line.slice(2).split(":")[0]!.trim());
+    .flatMap((line) => {
+      const name = line.slice(2).split(":")[0];
+      return name === undefined ? [] : [name.trim()];
+    });
 }
 
 async function flushMicrotasks(rounds = 100): Promise<void> {
@@ -342,9 +345,7 @@ describe("createToolSearchTool", () => {
     expect(out).toContain("present");
     expect(out).toContain("layout");
     expect(out).not.toMatch(/promoted/i);
-    expect(
-      advertisedTools(defs).map((d) => d.name),
-    ).not.toContain("present");
+    expect(advertisedTools(defs).map((d) => d.name)).not.toContain("present");
   });
 
   test("default tool_search returns at most 5 matches and does not promote them", async () => {
@@ -666,7 +667,11 @@ describe("createToolSearchTool", () => {
 });
 
 describe("promote-on-execute", () => {
-  const stringTool = (name: string, reply: string, description: string): AgentTool => ({
+  const stringTool = (
+    name: string,
+    reply: string,
+    description: string,
+  ): AgentTool => ({
     kind: "string",
     definition: {
       name,
@@ -678,7 +683,9 @@ describe("promote-on-execute", () => {
 
   function wirePromoteOnExecute() {
     const tools = [
-      ...wideCatalog.map((d) => stringTool(d.name, `ran:${d.name}`, d.description)),
+      ...wideCatalog.map((d) =>
+        stringTool(d.name, `ran:${d.name}`, d.description),
+      ),
       stringTool(
         "mcp__never__searched",
         "ran:never",
@@ -753,7 +760,8 @@ describe("promote-on-execute", () => {
     );
     expect(listed).toHaveLength(3);
     expect(promoted).toEqual([]);
-    const called = listed[0]!;
+    const called = listed[0];
+    if (called === undefined) throw new Error("expected a listed tool");
     const others = listed.slice(1);
     const result = await dispatch(runner, called);
     expect(result.content).toBe(`ran:${called}`);
@@ -772,7 +780,9 @@ describe("promote-on-execute", () => {
     expect(result.content).toBe("ran:never");
     expect(result.isError).toBeUndefined();
     expect(promoted).toEqual(["mcp__never__searched"]);
-    expect(advertisedNames(advertised, runner)).toContain("mcp__never__searched");
+    expect(advertisedNames(advertised, runner)).toContain(
+      "mcp__never__searched",
+    );
   });
 
   test("executing list_dir does not join the advertised tail", async () => {

src/agent/tool-search.ts

@@ -372,8 +372,7 @@ function parseToolSearchArgs(
   rawArgs: Record<string, unknown>,
 ): { error: string } | { query: string; limit: number } {
   const parsed = ToolSearchArgs(rawArgs);
-  const queryRaw =
-    parsed instanceof type.errors ? rawArgs.query : parsed.query;
+  const queryRaw = parsed instanceof type.errors ? rawArgs.query : parsed.query;
   if (typeof queryRaw !== "string") {
     return { error: "Error: tool_search requires query (string)." };
   }

src/auth/store.test.ts

@@ -11,7 +11,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { type } from "arktype";
 
-import { withMockedModule } from "../../tests/helpers/mock-module.js";
+import { withMockedModule } from "../../testkit/mock-module.js";
 import type { BaseTokens } from "./store.js";
 
 let failingUnlinkPath: string | undefined;

src/session/assemble-runtime.test.ts

@@ -157,18 +157,24 @@ describe("createAdvertisedToolset", () => {
   });
 
   test("pruneIdlePromotions drops execute-promoted schemas and keeps the frozen prefix", () => {
-    const { activated, computeAdvertised, flushPromotions, pruneIdlePromotions } =
-      createAdvertisedToolset(
-        wiring({ pinnedTools: ["mcp__linear__save_issue"] }),
-      );
+    const {
+      activated,
+      computeAdvertised,
+      flushPromotions,
+      pruneIdlePromotions,
+    } = createAdvertisedToolset(
+      wiring({ pinnedTools: ["mcp__linear__save_issue"] }),
+    );
     const defs = [
       def("read_file"),
       def("mcp__linear__save_issue"),
       def("mcp__acme__do"),
     ];
     activated.activate(["mcp__acme__do"]);
     expect(flushPromotions()).toBe(true);
-    expect(computeAdvertised(defs).map((d) => d.name)).toContain("mcp__acme__do");
+    expect(computeAdvertised(defs).map((d) => d.name)).toContain(
+      "mcp__acme__do",
+    );
     expect(pruneIdlePromotions()).toBe(true);
     const names = computeAdvertised(defs).map((d) => d.name);
     expect(names).not.toContain("mcp__acme__do");