test(prompt-variance): red — failing tests for family rows, assemble, per-row sizes

CL-8269: versioned prompt-variance package (default/muse/grok rows,
assemble, per-model overrides, per-row sizes) plus three-family
director prompt-size coverage. All fail until the package lands.

Author: TheGreatAxios

packages/prompt-variance/src/assemble.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, test } from "bun:test";
+import { assemble } from "./assemble.js";
+import { defaultRow, grokRow, museRow } from "./rows.js";
+
+// CL-8269 RED: assemble does not exist yet — every test below fails until
+// the GREEN lands packages/prompt-variance.
+
+const SECTIONS = ["contract", "Tools (names only): read_file", "context"];
+const TOOLS = ["read_file", "skill_search", "use_skill", "run_shell"];
+
+describe("assemble", () => {
+  test("joins sections with the residual as the last section", () => {
+    const out = assemble(SECTIONS, grokRow, TOOLS);
+    expect(out.systemPrompt).toContain("contract");
+    expect(out.systemPrompt.trimEnd().endsWith(grokRow.residual)).toBe(true);
+  });
+
+  test("a row without residual leaves the sections unchanged", () => {
+    const out = assemble(SECTIONS, defaultRow, TOOLS);
+    expect(out.systemPrompt).toBe(SECTIONS.join("\n\n"));
+  });
+
+  test("muse residual closes the prompt like the shipped tail append", () => {
+    const out = assemble(SECTIONS, museRow, TOOLS);
+    expect(out.systemPrompt.trimEnd().endsWith(museRow.residual)).toBe(true);
+  });
+
+  test("filters advertisedToolDeny from the tool names, preserving order", () => {
+    const out = assemble(SECTIONS, grokRow, TOOLS);
+    expect([...out.toolNames]).toEqual(["read_file", "use_skill", "run_shell"]);
+  });
+
+  test("variance cannot grant tools: output is always a subset of the input", () => {
+    for (const row of [defaultRow, museRow, grokRow]) {
+      const out = assemble(SECTIONS, row, TOOLS);
+      for (const name of out.toolNames) {
+        expect(TOOLS).toContain(name);
+      }
+      expect(out.toolNames.length).toBeLessThanOrEqual(TOOLS.length);
+    }
+  });
+
+  test("variance cannot grant tools: unknown mounted names pass through untouched", () => {
+    const out = assemble(SECTIONS, defaultRow, ["alpha", "beta"]);
+    expect([...out.toolNames]).toEqual(["alpha", "beta"]);
+  });
+
+  test("refuses a row that denies use_skill", () => {
+    const bad = { ...grokRow, advertisedToolDeny: ["use_skill"] };
+    expect(() => assemble(SECTIONS, bad, TOOLS)).toThrow(/use_skill/);
+  });
+});

packages/prompt-variance/src/resolve.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, test } from "bun:test";
+import { applyRowOverride, resolvePromptVariance } from "./resolve.js";
+import { grokRow } from "./rows.js";
+
+// CL-8269 RED: the resolver does not exist yet — every test below fails
+// until the GREEN lands packages/prompt-variance.
+
+describe("resolvePromptVariance", () => {
+  test("resolves each family to its row", () => {
+    expect(resolvePromptVariance({ family: "default" }).id).toBe("default");
+    expect(resolvePromptVariance({ family: "muse" }).id).toBe("muse");
+    expect(resolvePromptVariance({ family: "grok" }).id).toBe("grok");
+  });
+
+  test("grok keeps its finish-bias residual and skill_search deny on leaves", () => {
+    const row = resolvePromptVariance({ family: "grok", orchestrator: false });
+    expect(row.residual).toBe(grokRow.residual);
+    expect(row.advertisedToolDeny).toContain("skill_search");
+  });
+
+  test("grok on orchestrators falls back to the default shape", () => {
+    const row = resolvePromptVariance({ family: "grok", orchestrator: true });
+    expect(row.residual).toBe("");
+    expect([...row.advertisedToolDeny]).toEqual([]);
+  });
+
+  test("muse keeps its residual on leaves and orchestrators alike", () => {
+    expect(
+      resolvePromptVariance({ family: "muse", orchestrator: false }).residual,
+    ).not.toBe("");
+    expect(
+      resolvePromptVariance({ family: "muse", orchestrator: true }).residual,
+    ).not.toBe("");
+  });
+
+  test("applies per-model-id overrides from the row", () => {
+    const row = applyRowOverride(
+      {
+        ...grokRow,
+        overrides: {
+          "grok-4-special": { advertisedToolDeny: [] },
+        },
+      },
+      "GROK-4-SPECIAL",
+    );
+    expect([...row.advertisedToolDeny]).toEqual([]);
+    expect(row.residual).toBe(grokRow.residual);
+  });
+
+  test("an unknown model id resolves to the base row", () => {
+    const row = resolvePromptVariance({
+      family: "grok",
+      orchestrator: false,
+      model: "grok-9-unknown",
+    });
+    expect(row.residual).toBe(grokRow.residual);
+    expect([...row.advertisedToolDeny]).toEqual(["skill_search"]);
+  });
+});

packages/prompt-variance/src/rows.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, test } from "bun:test";
+import {
+  defaultRow,
+  FAMILY_IDS,
+  grokRow,
+  museRow,
+  type PromptVarianceFamily,
+} from "./rows.js";
+
+// CL-8269 RED: the versioned prompt-variance package does not exist yet, so
+// every test below fails at import time until the GREEN lands it.
+
+describe("prompt-variance family rows", () => {
+  test("ships exactly the default/muse/grok families", () => {
+    expect([...FAMILY_IDS]).toEqual(["default", "muse", "grok"]);
+  });
+
+  test("has no glm/claude/gpt rows until their evals land (CL-8265/7772/7775)", () => {
+    for (const id of FAMILY_IDS) {
+      expect(["glm", "claude", "gpt"]).not.toContain(id);
+    }
+  });
+
+  test("every row carries the render/residual/deny/omit shape", () => {
+    for (const row of [defaultRow, museRow, grokRow]) {
+      expect(row.render).toBe("tail");
+      expect(typeof row.residual).toBe("string");
+      expect(Array.isArray([...row.advertisedToolDeny])).toBe(true);
+      expect(Array.isArray([...row.sectionOmit])).toBe(true);
+    }
+  });
+
+  test("row ids match their family", () => {
+    const ids: PromptVarianceFamily[] = [
+      defaultRow.id,
+      museRow.id,
+      grokRow.id,
+    ];
+    expect(ids).toEqual(["default", "muse", "grok"]);
+  });
+
+  test("muse row is the shipped CL-7869 tool-discipline text", () => {
+    expect(museRow.residual).toContain("Tool discipline:");
+    expect(museRow.residual).toContain("Batch independent tool calls");
+    expect(museRow.residual).toContain("Never re-read a file");
+    expect(museRow.residual).toContain("Do not narrate; act.");
+  });
+
+  test("grok row is the existing finish-bias residual", () => {
+    expect(grokRow.residual).toContain("Finish bias (xAI / Grok worker):");
+    expect(grokRow.residual).toContain("prefer the structured report");
+    expect(grokRow.residual).toContain("re-open paths you already read");
+    expect(grokRow.residual).toContain("done-definition is met");
+    expect(grokRow.residual).toContain("never run_shell");
+  });
+
+  test("default row carries no residual", () => {
+    expect(defaultRow.residual).toBe("");
+  });
+
+  test("grok leaves deny skill_search only; other rows deny nothing", () => {
+    expect([...grokRow.advertisedToolDeny]).toEqual(["skill_search"]);
+    expect([...defaultRow.advertisedToolDeny]).toEqual([]);
+    expect([...museRow.advertisedToolDeny]).toEqual([]);
+  });
+
+  test("no row denies use_skill — brief-named skills always load directly", () => {
+    for (const row of [defaultRow, museRow, grokRow]) {
+      expect(row.advertisedToolDeny).not.toContain("use_skill");
+    }
+  });
+
+  test("sectionOmit starts empty on every row", () => {
+    for (const row of [defaultRow, museRow, grokRow]) {
+      expect([...row.sectionOmit]).toEqual([]);
+    }
+  });
+});

packages/prompt-variance/src/sizes.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, test } from "bun:test";
+import { defaultRow, grokRow, museRow } from "./rows.js";
+
+// CL-8269 RED: per-family-row prompt sizes. Residuals are tail appends, so
+// each must stay a small fraction of a worker prompt: non-empty for the
+// tuned families, empty for default, and bounded well under a kilobyte each.
+
+describe("prompt-variance prompt sizes per family row", () => {
+  test("default residual is empty", () => {
+    expect(defaultRow.residual.length).toBe(0);
+  });
+
+  test("every tuned residual stays under 2000 chars / 3000 bytes", () => {
+    for (const row of [museRow, grokRow]) {
+      expect(row.residual.length).toBeGreaterThan(0);
+      expect(row.residual.length).toBeLessThan(2000);
+      expect(Buffer.byteLength(row.residual, "utf8")).toBeLessThan(3000);
+    }
+  });
+
+  test("the grok finish-bias residual is larger than the muse discipline rules", () => {
+    expect(grokRow.residual.length).toBeGreaterThan(museRow.residual.length);
+  });
+});

src/agent/prompt-sizes.test.ts

@@ -127,10 +127,10 @@ function budgetMessage(
 describe("director prompt size budget", () => {
   const rows = directorPromptSizeTable();
 
-  test("covers every director in both families", () => {
-    expect(rows.length).toBe(DIRECTOR_IDS.length * 2);
+  test("covers every director in all three variance families", () => {
+    expect(rows.length).toBe(DIRECTOR_IDS.length * 3);
     for (const directorId of DIRECTOR_IDS) {
-      for (const family of ["default", "grok"] as const) {
+      for (const family of ["default", "muse", "grok"] as const) {
         expect(
           rows.some((r) => r.directorId === directorId && r.family === family),
         ).toBe(true);
@@ -177,6 +177,21 @@ describe("director prompt size budget", () => {
     }
   });
 
+  test("muse family appends the shipped tool-discipline rules", () => {
+    for (const directorId of DIRECTOR_IDS) {
+      const base = rows.find(
+        (r) => r.directorId === directorId && r.family === "default",
+      );
+      const muse = rows.find(
+        (r) => r.directorId === directorId && r.family === "muse",
+      );
+      expect(muse?.chars ?? 0).toBeGreaterThan(base?.chars ?? 0);
+      expect(assembleDirectorPrompt(directorId, "muse")).toContain(
+        "Tool discipline:",
+      );
+    }
+  });
+
   test("measurement is deterministic", () => {
     const again = directorPromptSizeTable();
     expect(again.map((r) => r.chars)).toEqual(rows.map((r) => r.chars));