test(cl-8310): failing gpt narrate-before-tools residual tests

Author: TheGreatAxios

src/agent/model-family-policy.test.ts

@@ -178,4 +178,24 @@ describe("resolveModelFamilyPolicy", () => {
     expect(grok.family).toBe("grok");
     expect(grok.promptResidual).toContain("Tool budget:");
   });
+  test("gpt resolves its own family on permissive default thresholds (CL-8310)", () => {
+    const gpt = resolveModelFamilyPolicy({
+      providerName: "codex/default",
+      model: "gpt-5.5",
+    });
+    const base = resolveModelFamilyPolicy({
+      providerName: "anthropic",
+      model: "claude-sonnet-4",
+    });
+    expect(gpt.family).toBe("gpt");
+    // No eval characterization for gpt tool-only stretches yet: ship the
+    // permissive default, no finish-bias, no discipline rules. The
+    // narrate-before-tools residual is prompt-level (see prompts.ts), not a
+    // threshold.
+    expect(gpt.toolOnlyTurnNudgeAt).toBe(base.toolOnlyTurnNudgeAt);
+    expect(gpt.subAgentStallTimeoutMs).toBe(base.subAgentStallTimeoutMs);
+    expect(gpt.applyGrokFinishBias).toBe(false);
+    expect(gpt.toolDisciplineRules).toBeUndefined();
+    expect(gpt.advertisedToolDeny).toEqual([]);
+  });
 });

src/agent/prompts.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, it } from "bun:test";
 import {
   buildChatSystemPrompt,
   buildClaudeTaskGuidanceNote,
+  buildGptNarrateBeforeToolsNote,
   buildGrokLeafAntiThrashNote,
   buildGuidelines,
   buildPromptDisciplineBlock,
@@ -372,6 +373,7 @@ describe("grok finish-bias residual gating (extends existing provider-family tes
   });
 });
 
+<<<<<<< HEAD
 describe("promptResidual assembly (CL-8297)", () => {
   const TOOL_BUDGET =
     "Tool budget:\n" +
@@ -452,3 +454,79 @@ describe("claude XML task_guidance residual (provider residual, not a prompt for
     );
   });
 });
+
+describe("gpt narrate-before-tools residual (CL-8310)", () => {
+  it("is a 3-line narrate-before-tools note, not manage_tasks ceremony", () => {
+    const note = buildGptNarrateBeforeToolsNote();
+    expect(note).toContain("Narrate before tools (GPT worker):");
+    expect(note).toMatch(/before.*tool call.*one short line/is);
+    expect(note).toMatch(/no narration between them/i);
+    expect(note).toContain("write the report envelope");
+    expect(note.toLowerCase()).not.toContain("manage_tasks");
+  });
+
+  it("appears exactly once on a gpt leaf prompt", () => {
+    const prompt = buildSubAgentSystemPrompt(undefined, undefined, undefined, {
+      orchestrator: false,
+      gptNarrateBeforeTools: true,
+    });
+    const note = buildGptNarrateBeforeToolsNote();
+    expect(countOccurrences(prompt, note)).toBe(1);
+    expect(prompt.trimEnd().endsWith(note)).toBe(true);
+  });
+
+  it("appears exactly once on a gpt primary prompt", () => {
+    const prompt = buildChatSystemPrompt(
+      undefined,
+      undefined,
+      undefined,
+      [],
+      "orchestrator",
+      undefined,
+      undefined,
+      { gptNarrateBeforeTools: true },
+    );
+    const note = buildGptNarrateBeforeToolsNote();
+    expect(countOccurrences(prompt, note)).toBe(1);
+  });
+
+  it("is absent by default on both primary and leaf", () => {
+    const leaf = buildSubAgentSystemPrompt(undefined, undefined, undefined, {
+      orchestrator: false,
+      grokAntiThrash: false,
+    });
+    const primary = buildChatSystemPrompt(
+      undefined,
+      undefined,
+      undefined,
+      [],
+      "orchestrator",
+    );
+    expect(leaf).not.toContain("Narrate before tools (GPT worker):");
+    expect(primary).not.toContain("Narrate before tools (GPT worker):");
+  });
+
+  it("is absent on grok and claude prompts", () => {
+    const grokLeaf = buildSubAgentSystemPrompt(undefined, undefined, undefined, {
+      orchestrator: false,
+      grokAntiThrash: true,
+    });
+    const claudeLeaf = buildSubAgentSystemPrompt(undefined, undefined, undefined, {
+      orchestrator: false,
+      grokAntiThrash: false,
+    });
+    const claudePrimary = buildChatSystemPrompt(
+      undefined,
+      undefined,
+      undefined,
+      [],
+      "orchestrator",
+    );
+    for (const prompt of [grokLeaf, claudeLeaf, claudePrimary]) {
+      expect(prompt).not.toContain("Narrate before tools (GPT worker):");
+      expect(prompt).not.toContain("Narrate before tools (GPT");
+    }
+    // The grok row keeps its own residual, untouched.
+    expect(grokLeaf).toContain("Finish bias (xAI / Grok worker):");
+  });
+});

src/subagent/provider-family.test.ts

@@ -2,10 +2,12 @@ import { describe, expect, test } from "bun:test";
 import {
   detectModelFamily,
   isClaudeLeafProvider,
+  isGptProvider,
   isKimiLeafProvider,
   isXaiGrokLeafProvider,
   shouldApplyGrokAntiThrash,
 } from "./provider-family.js";
+import { CODEX_DEFAULT_MODELS } from "../auth/codex/constants.js";
 
 describe("isXaiGrokLeafProvider", () => {
   test("matches xai/ OAuth provider names", () => {
@@ -194,3 +196,62 @@ describe("detectModelFamily claude row", () => {
     ).toBe("claude");
   });
 });
+
+describe("isGptProvider (CL-8310)", () => {
+  test("matches codex OAuth provider names", () => {
+    expect(isGptProvider({ providerName: "codex/default" })).toBe(true);
+    expect(isGptProvider({ providerName: "codex/work" })).toBe(true);
+  });
+
+  test("matches codex adapter ids and bare codex names", () => {
+    expect(isGptProvider({ providerName: "codex-responses" })).toBe(true);
+    expect(isGptProvider({ providerName: "codex" })).toBe(true);
+  });
+
+  test("matches gpt-* model ids on any provider", () => {
+    expect(
+      isGptProvider({ providerName: "openai", model: "gpt-5.5" }),
+    ).toBe(true);
+    expect(
+      isGptProvider({ providerName: "opencode-go", model: "gpt-5.1" }),
+    ).toBe(true);
+    expect(
+      isGptProvider({ providerName: "openai-compat", model: "gpt-5.6-luna" }),
+    ).toBe(true);
+  });
+
+  test("covers every in-tree codex catalog model without naming cells", () => {
+    // No terra/sol/astra special-casing: every served codex id resolves via
+    // the generic codex-provider / gpt-* match, so future cells ride along.
+    for (const model of CODEX_DEFAULT_MODELS) {
+      expect(isGptProvider({ providerName: "codex/default", model })).toBe(
+        true,
+      );
+      expect(detectModelFamily({ providerName: "codex/default", model })).toBe(
+        "gpt",
+      );
+    }
+  });
+
+  test("rejects grok, kimi, muse, and claude", () => {
+    expect(
+      isGptProvider({ providerName: "xai/default", model: "grok-4.6" }),
+    ).toBe(false);
+    expect(isGptProvider({ providerName: "moonshot", model: "kimi-k2" })).toBe(
+      false,
+    );
+    expect(
+      isGptProvider({
+        providerName: "opencode-go",
+        model: "muse-spark-1.3-contributor",
+      }),
+    ).toBe(false);
+    expect(
+      isGptProvider({
+        providerName: "anthropic",
+        model: "claude-sonnet-4",
+      }),
+    ).toBe(false);
+    expect(isGptProvider({ providerName: "anthropic" })).toBe(false);
+  });
+});