fix(tools): put tool_search promotions on the next infer wire

Promotion opened the call gate but schemas stayed off the provider tools array until compaction, so MCP names could not be emitted.

Author: TheGreatAxios

src/director.test.ts

@@ -1242,13 +1242,10 @@ describe("updateToolDefinitions rewrites infer tools", () => {
     expect(JSON.stringify(after)).toBe(JSON.stringify(before));
   });
 
-  // CL-7868 (direction A): the provider cache is a prefix cache keyed on the
-  // tools array, so a tool_search turn that promotes a genuinely new tool must
-  // not reshape the wire set mid-session. The call gate opens (the model
-  // invokes the tool from the search result's schema) while the advertised
-  // array holds steady; the growth event lands at the next cache-safe
-  // boundary (compaction fold), appended after the untouched fixed prefix.
-  test("a tool_search turn promoting a genuinely new tool leaves the wire byte-identical until the fold commits it", async () => {
+  // Promotion must open the call gate and commit the schema onto the next
+  // infer tools array. Holding growth until compaction left MCP names
+  // dispatchable in the runner but missing from the provider tools list.
+  test("a tool_search turn promoting a genuinely new tool commits it onto the next infer wire", async () => {
     const linearTool = {
       name: "mcp__linear__list_issues",
       description: "list issues",
@@ -1289,42 +1286,26 @@ describe("updateToolDefinitions rewrites infer tools", () => {
     expect(advertised.activated.activate(["mcp__linear__list_issues"])).toBe(
       true,
     );
+    expect(advertised.flushPromotions()).toBe(true);
     director.updateToolDefinitions(
       advertised.computeAdvertised(toolset.dynamicRunner.currentDefinitions()),
     );
 
-    // Mid-session the wire is byte-identical — the hot prefix never grows —
-    // while the gate is open so the model can invoke the match from the
-    // result card's schema.
     const after = await firstInferTools(
       director,
       makeMessageReceivedEvent("continue"),
     );
-    expect(JSON.stringify(after)).toBe(JSON.stringify(before));
+    expect(JSON.stringify(after)).not.toBe(JSON.stringify(before));
     expect(advertised.isAdvertised("mcp__linear__list_issues")).toBe(true);
-
-    // Cache-safe boundary (compaction fold): the pending promotion commits and
-    // the next turn declares it after the untouched fixed prefix.
-    expect(advertised.flushPromotions()).toBe(true);
-    director.updateToolDefinitions(
-      advertised.computeAdvertised(toolset.dynamicRunner.currentDefinitions()),
-    );
-    const folded = await firstInferTools(
-      director,
-      makeMessageReceivedEvent("after fold"),
-    );
-    const foldedNames = (folded as { name: string }[]).map((t) => t.name);
-    expect(foldedNames).toContain("mcp__linear__list_issues");
+    const afterNames = (after as { name: string }[]).map((t) => t.name);
+    expect(afterNames).toContain("mcp__linear__list_issues");
     const beforeNames = (before as { name: string }[])
       .map((t) => t.name)
       .filter((n) => n !== "submit_output");
-    const foldedPrefix = foldedNames.filter(
+    const afterPrefix = afterNames.filter(
       (n) => n !== "submit_output" && n !== "mcp__linear__list_issues",
     );
-    expect(foldedPrefix).toEqual(beforeNames);
-    expect(foldedNames.indexOf("mcp__linear__list_issues")).toBe(
-      beforeNames.length,
-    );
+    expect(afterPrefix).toEqual(beforeNames);
 
     await toolset.dispose();
   });
@@ -1347,13 +1328,9 @@ describe("updateToolDefinitions rewrites infer tools", () => {
     expect(inferToolNames(inferAction)).toContain("submit_output");
   });
 
-  // End-to-end: tool_search matches an MCP tool; the runner's gate-only promote
-  // wiring (mirrored here via createAdvertisedToolset + updateToolDefinitions)
-  // keeps it off the wire the next turn — the hot prefix stays byte-identical
-  // while the gate lets the model call it from the result card. The fold
-  // commits the pending promotion with the tool's full definition, appended
-  // after the untouched fixed prefix, and the array then holds steady.
-  test("a tool_search match stays off the wire until the fold, then holds stable", async () => {
+  // tool_search + flush + updateToolDefinitions puts the match on the next
+  // infer wire; a further turn with no new discovery stays byte-identical.
+  test("a tool_search match is on the next infer wire and then holds stable", async () => {
     const linearTool = {
       name: "mcp__linear__list_issues",
       description: "list issues",
@@ -1399,38 +1376,19 @@ describe("updateToolDefinitions rewrites infer tools", () => {
     // Simulate the runner's gate-only promoter plus its boundary wire push:
     // the gate opens but the wire recompute is byte-identical until the fold.
     advertised.activated.activate(["mcp__linear__list_issues"]);
-    director.updateToolDefinitions(
-      computeAdvertised(toolset.dynamicRunner.currentDefinitions()),
-    );
-
-    const gated = await firstInferTools(
-      director,
-      makeMessageReceivedEvent("continue"),
-    );
-    expect((gated as { name: string }[]).map((t) => t.name)).not.toContain(
-      "mcp__linear__list_issues",
-    );
-    expect(JSON.stringify(gated)).toBe(beforeJson);
-
-    // Simulate the compaction fold: commit the pending promotion, push the
-    // refreshed set, and the tool is declared — appended after the fixed
-    // built-in prefix, which survives untouched ahead of it.
     advertised.flushPromotions();
     director.updateToolDefinitions(
       computeAdvertised(toolset.dynamicRunner.currentDefinitions()),
     );
 
     const after = await firstInferTools(
       director,
-      makeMessageReceivedEvent("after fold"),
+      makeMessageReceivedEvent("continue"),
     );
     const afterTools = after as { name: string }[];
     const afterNames = afterTools.map((t) => t.name);
     expect(afterNames).toContain("mcp__linear__list_issues");
-    // submit_output rides along separately (see withCurrentTools), appended
-    // after computeAdvertised's result every turn — strip it before comparing
-    // the fixed built-in prefix, which must survive untouched ahead of the
-    // newly appended MCP tool.
+    expect(JSON.stringify(after)).not.toBe(beforeJson);
     const beforePrefix = beforeNames.filter((n) => n !== "submit_output");
     const afterPrefix = afterNames.filter(
       (n) => n !== "submit_output" && n !== "mcp__linear__list_issues",
@@ -1440,13 +1398,11 @@ describe("updateToolDefinitions rewrites infer tools", () => {
       beforePrefix.length,
     );
 
-    // A further turn with no new discovery stays byte-identical to `after`.
     const stable = await firstInferTools(
       director,
       makeMessageReceivedEvent("keep going"),
     );
     expect(JSON.stringify(stable)).toBe(JSON.stringify(after));
-    expect(JSON.stringify(after)).not.toBe(beforeJson);
 
     await toolset.dispose();
   });

src/exec/runner.test.ts

@@ -81,39 +81,28 @@ describe("exec director allowlist", () => {
     ).toBe(false);
   });
 
-  test("the promoter gates allow itself and leaves the wire set for the fold", () => {
+  test("the promoter gates allow itself and commits the match onto the wire", () => {
     const overlay = resolveExecDirectorOverlay("explorer");
-    const { activated, computeAdvertised, flushPromotions } =
-      createAdvertisedToolset({
-        sessionMode: "orchestrator",
-        toolAvailability: { languageServerAvailable: true },
-        getProvider: () => ({ providerName: "test", model: "test-model" }),
-        builtInPrefix: overlay.advertisedAllow,
-      });
+    const { activated, flushPromotions } = createAdvertisedToolset({
+      sessionMode: "orchestrator",
+      toolAvailability: { languageServerAvailable: true },
+      getProvider: () => ({ providerName: "test", model: "test-model" }),
+      builtInPrefix: overlay.advertisedAllow,
+    });
+    let committed = 0;
     const promote = createExecToolPromoter({
       activate: (names) => activated.activate(names),
       isAllowed: (name) => isExecOverlayToolAllowed(overlay, name),
-    });
-    const registry = [
-      {
-        name: "read_file",
-        description: "read a file",
-        inputSchema: { type: "object", properties: {} },
+      commitWire: () => {
+        committed += 1;
+        flushPromotions();
       },
-    ];
-    const before = JSON.stringify(computeAdvertised(registry));
-    // A raw activate caller gets no bypass: outside-allow names never open the
-    // gate, while the allowed match opens it at once.
+    });
     promote([OUTSIDE_ALLOW, "read_file"]);
     expect(activated.has(OUTSIDE_ALLOW)).toBe(false);
     expect(activated.has("read_file")).toBe(true);
-    // Gate-only: the wire recompute ignores the fresh activation, so the
-    // provider's cached prefix holds until the fold commits it.
-    expect(JSON.stringify(computeAdvertised(registry))).toBe(before);
-    expect(flushPromotions()).toBe(true);
-    expect(computeAdvertised(registry).map((d) => d.name)).toContain(
-      "read_file",
-    );
+    expect(committed).toBe(1);
+    expect(flushPromotions()).toBe(false);
   });
 
   test("skywalker overlay leaves every tool allowed", () => {

src/exec/runner.ts

@@ -415,13 +415,11 @@ export function createExecToolPromoter(args: {
   activate: (names: readonly string[]) => boolean;
   isAllowed: (name: string) => boolean;
   persist?: () => void;
+  commitWire?: () => void;
 }): (names: string[]) => void {
   return (names) => {
-    // Gate-only, like the TUI promoteTools: activation lets the model invoke
-    // the match from the result card's schema at once, while the schema joins
-    // the wire set at the next cache-safe boundary (compaction fold) so the
-    // provider's cached prefix never grows mid-thread (CL-7868).
     if (!args.activate(names.filter((name) => args.isAllowed(name)))) return;
+    args.commitWire?.();
     args.persist?.();
   };
 }
@@ -912,6 +910,13 @@ export async function runExec(config: Config): Promise<ExecResult> {
         persist: () => {
           void persist("running");
         },
+        commitWire: () => {
+          if (flushPromotions()) {
+            directorHolder.instance?.updateToolDefinitions(
+              computeAdvertised(agentToolset.dynamicRunner.currentDefinitions()),
+            );
+          }
+        },
       }),
     );
 

src/tui/runner/exit.ts

@@ -406,14 +406,20 @@ export async function createRunLifecycle(
   state.reloadIfIdle = reloadIfIdle;
 
   // tool_search (and contextual triggers, e.g. the lsp hint) promote tools by
-  // opening the call gate: the model invokes the match from the result card's
-  // schema on the very next turn. The schema itself joins the wire set at the
-  // next cache-safe boundary (compaction fold), never mid-thread — the
-  // serialized tools array heads the provider's cached prefix (CL-7868). No
-  // reload is scheduled: dispatchability comes from the live call gate, not
-  // the rebuilt agent.
+  // opening the call gate and committing schemas onto the next infer's wire.
+  // Holding them off until compaction (CL-7868) left MCP/plugin names callable
+  // in the runner but missing from the provider tools array, so the model
+  // could not emit those calls. Cache prefix growth on discovery is the cost
+  // of making promotion actually work.
   const promoteTools = (names: string[]): void => {
     if (!services.activatedToolNames.activate(names)) return;
+    if (services.flushPromotions()) {
+      services.directorHolder.instance?.updateToolDefinitions(
+        services.computeAdvertised(
+          services.toolset.dynamicRunner.currentDefinitions(),
+        ),
+      );
+    }
     // Activation is model-visible contract — persist it now so a crash or
     // restart before the next turn boundary does not strand the transcript's
     // "these tools are available" record.

src/tui/runner/session.ts

@@ -718,6 +718,7 @@ export async function assembleTUISession(
     workflowHost,
     activatedToolNames,
     computeAdvertised,
+    flushPromotions,
     buildAgent: chatAgent.buildAgent,
     sessionCost,
     sessionOps,

src/tui/runner/state.ts

@@ -151,6 +151,11 @@ export interface RunnerServices {
       typeof import("../../session/assemble-runtime.js").createAdvertisedToolset
     >
   >["computeAdvertised"];
+  flushPromotions: Awaited<
+    ReturnType<
+      typeof import("../../session/assemble-runtime.js").createAdvertisedToolset
+    >
+  >["flushPromotions"];
   buildAgent: ReturnType<
     typeof import("../../session/assemble-runtime.js").assembleChatAgent
   >["buildAgent"];

tests/unit/exec/runner.test.ts

@@ -787,6 +787,9 @@ describe("exec tool call gate and promoter", () => {
       persist: () => {
         persistCount += 1;
       },
+      commitWire: () => {
+        flushPromotions();
+      },
     });
     const search = createToolSearchTool({
       search: (query) =>
@@ -821,26 +824,17 @@ describe("exec tool call gate and promoter", () => {
     expect(blocked.isError).toBe(true);
     expect(blocked.content).toContain("tool_search");
 
-    const wireBefore = JSON.stringify(
-      computeAdvertised(runner.currentDefinitions()),
-    );
     if (search.kind !== "string") throw new Error("expected string tool");
     await search.handler({ query: "linear" }, new AbortController().signal);
     expect(persistCount()).toBe(1);
 
-    // Gate-only promotion: the tool dispatches now, but the wire set holds
-    // steady until a cache-safe boundary commits it.
     const allowed = await dispatch(runner, "mcp__linear__save_issue");
     expect(allowed.content).toBe("saved");
     expect(allowed.isError).toBeUndefined();
-    expect(JSON.stringify(computeAdvertised(runner.currentDefinitions()))).toBe(
-      wireBefore,
-    );
-
-    expect(flushPromotions()).toBe(true);
     expect(
       computeAdvertised(runner.currentDefinitions()).map((d) => d.name),
     ).toContain("mcp__linear__save_issue");
+    expect(flushPromotions()).toBe(false);
   });
 
   test("present and plugin names pass the gate after tool_search promote", async () => {