test(director): prove mid-session promotion reshapes the wire set

Author: TheGreatAxios

src/director.test.ts

@@ -5,6 +5,7 @@ import {
   advertisedTools,
   createActivatedToolTracker,
 } from "./agent/tool-search.js";
+import { createAdvertisedToolset } from "./session/assemble-runtime.js";
 import { createPermissionGate } from "./permission/gate.js";
 import {
   COMPACTOR_KEEP_RECENT_TURNS,
@@ -1145,6 +1146,64 @@ describe("updateToolDefinitions rewrites infer tools", () => {
     expect(JSON.stringify(after)).toBe(JSON.stringify(before));
   });
 
+  // CL-7868: 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
+  // until the next cache-safe boundary.
+  test("a tool_search turn promoting a genuinely new tool leaves the wire byte-identical", async () => {
+    const linearTool = {
+      name: "mcp__linear__list_issues",
+      description: "list issues",
+      inputSchema: { type: "object", properties: {}, required: [] },
+    };
+    const toolset = await createAgentToolset({
+      cwd: process.cwd(),
+      permissionGate: createPermissionGate({
+        approvals: [],
+        interactive: false,
+        skipPermissions: true,
+        reactorGated: false,
+      }),
+      onOperatorGate: async () => ({ kind: "cancel" }),
+    });
+    toolset.dynamicRunner.addTools([
+      { kind: "string", definition: linearTool, handler: async () => "ok" },
+    ]);
+
+    const advertised = createAdvertisedToolset({
+      sessionMode: "orchestrator",
+      toolAvailability: { languageServerAvailable: false },
+      getProvider: () => ({ providerName: "openai", model: "gpt-5" }),
+    });
+    const director = createChatDirector(
+      "base-prompt",
+      advertised.computeAdvertised(toolset.dynamicRunner.currentDefinitions()),
+      { onTasksChange: () => undefined },
+    );
+
+    const before = await firstInferTools(
+      director,
+      makeMessageReceivedEvent("hello"),
+    );
+
+    // tool_search matched a genuinely new tool: the runner opens the call
+    // gate and refreshes the director exactly as it does today.
+    advertised.activated.activate(["mcp__linear__list_issues"]);
+    director.updateToolDefinitions(
+      advertised.computeAdvertised(toolset.dynamicRunner.currentDefinitions()),
+    );
+
+    const after = await firstInferTools(
+      director,
+      makeMessageReceivedEvent("continue"),
+    );
+    expect(JSON.stringify(after)).toBe(JSON.stringify(before));
+    expect(advertised.isAdvertised("mcp__linear__list_issues")).toBe(true);
+
+    await toolset.dispose();
+  });
+
   // submit_output is always on the wire so a workflow going active never grows
   // the array and busts the provider cache prefix.
   test("submit_output is advertised even with no active workflow", async () => {

tests/unit/openai-responses-adapter.test.ts

@@ -3,12 +3,14 @@ import {
   createOpenAIResponsesAdapter,
   OPENAI_SESSION_ID_OPTION,
 } from "../../src/provider/openai-responses.js";
+import { createAdvertisedToolset } from "../../src/session/assemble-runtime.js";
 import { OPENCODE_SESSION_ID_OPTION } from "../../src/provider/opencode-session.js";
 import { BEARER_CREDENTIAL_SENTINEL } from "@intx/inference";
 import type {
   ConversationTurn,
   InferenceOptions,
   LastCycleSource,
+  ToolDefinition,
 } from "@intx/types/runtime";
 
 const SOURCE: LastCycleSource = {
@@ -70,6 +72,43 @@ describe("openai-responses buildRequest", () => {
   });
 });
 
+describe("openai-responses promotion cache safety", () => {
+  function def(name: string): ToolDefinition {
+    return {
+      name,
+      description: `${name} tool`,
+      inputSchema: { type: "object", properties: {} },
+    };
+  }
+
+  // CL-7868: the tools array is the head of the provider's cached prefix, so
+  // a mid-session activation must not change the serialized request body —
+  // the turns differ only in activated tools.
+  test("activating a tool mid-session leaves the serialized wire body byte-identical", () => {
+    const advertised = createAdvertisedToolset({
+      sessionMode: "orchestrator",
+      toolAvailability: { languageServerAvailable: false },
+      getProvider: () => ({ providerName: "openai", model: "gpt-5.6-luna" }),
+    });
+    const defs = [
+      def("read_file"),
+      def("write_file"),
+      def("tool_search"),
+      def("mcp__linear__list_issues"),
+    ];
+    const bodyFor = (tools: ToolDefinition[]): string =>
+      adapter().buildRequest([userTurn("hi")], "gpt-5.6-luna", { tools }).body;
+    const before = bodyFor(advertised.computeAdvertised(defs));
+    expect(JSON.parse(before)).toHaveProperty("tools");
+
+    advertised.activated.activate(["mcp__linear__list_issues"]);
+
+    const after = bodyFor(advertised.computeAdvertised(defs));
+    expect(after).toBe(before);
+    expect(advertised.isAdvertised("mcp__linear__list_issues")).toBe(true);
+  });
+});
+
 describe("openai-responses x-opencode-session header", () => {
   test("sets the header from the opencode session id without leaking it into the body", () => {
     const req = adapter().buildRequest([userTurn("hi")], "gpt-5.6-luna", {