feat(prompt-variance): residuals-only rows as single source for five families

Deny decision (default residuals-only): the package owns residual TEXT;
tool denial stays live in ModelFamilyPolicy.advertisedToolDeny, applied
at mount time by run.ts. Drops advertisedToolDeny, sectionOmit,
per-model overrides, and the AssembledPromptVariance shape.

Fold tool-budget (CL-8297) + ceremony (CL-8296) + claude (CL-8309) + gpt
(CL-8310) rows into rows.ts; policy residual names alias the rows.
Package renamed to @corbits/prompt-variance at 0.1.0; bun.lock synced.
Size table gains claude/gpt columns; fixture mirrors the director
tail-append for muse discipline rules.

Author: TheGreatAxios

bun.lock

@@ -1,6 +1,6 @@
 {
-  "name": "prompt-variance",
-  "version": "1.4.0",
+  "name": "@corbits/prompt-variance",
+  "version": "0.1.0",
   "private": true,
   "type": "module",
   "license": "SEE LICENSE IN LICENSE.md",

packages/prompt-variance/package.json

@@ -1,52 +1,36 @@
 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.
+import { claudeRow, defaultRow, gptRow, grokRow, museRow } from "./rows.js";
 
 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);
+    const out = assemble(SECTIONS, grokRow);
+    expect(out).toContain("contract");
+    expect(out.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"));
+    expect(assemble(SECTIONS, defaultRow)).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);
-    }
+    const out = assemble(SECTIONS, museRow);
+    expect(out.trimEnd().endsWith(museRow.residual)).toBe(true);
   });
 
-  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("claude and gpt residuals close the prompt the same way", () => {
+    expect(
+      assemble(SECTIONS, claudeRow).trimEnd().endsWith(claudeRow.residual),
+    ).toBe(true);
+    expect(assemble(SECTIONS, gptRow).trimEnd().endsWith(gptRow.residual)).toBe(
+      true,
+    );
   });
 
-  test("refuses a row that denies use_skill", () => {
-    const bad = { ...grokRow, advertisedToolDeny: ["use_skill"] };
-    expect(() => assemble(SECTIONS, bad, TOOLS)).toThrow(/use_skill/);
+  test("tool mounting is out of scope: assemble returns a string, not tool names", () => {
+    const out = assemble(SECTIONS, grokRow);
+    expect(typeof out).toBe("string");
   });
 });

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

@@ -1,33 +1,16 @@
 import type { PromptVarianceRow } from "./rows.js";
 
-export interface AssembledPromptVariance {
-  systemPrompt: string;
-  toolNames: readonly string[];
-}
-
 /**
- * Assemble a prompt from sections plus a family variance row (CL-8269).
- * The row residual renders last; advertised denies filter the mounted
- * tool names. Variance is subtractive only: the output names are always
- * a subset of the input names, in input order.
+ * Append a family variance row's residual at the tail of the assembled
+ * sections (CL-8269). An empty residual leaves the sections unchanged.
+ * Residuals render last so they cannot disturb the cached prompt prefix.
+ * Tool mounting is out of scope: run.ts applies
+ * ModelFamilyPolicy.advertisedToolDeny at mount time.
  */
 export function assemble(
   sections: readonly string[],
   familyRow: PromptVarianceRow,
-  tools: readonly string[],
-): AssembledPromptVariance {
-  if (familyRow.advertisedToolDeny.includes("use_skill")) {
-    throw new Error(
-      `prompt-variance: row "${familyRow.id}" denies use_skill — brief-named skills always load directly`,
-    );
-  }
-  const systemPrompt =
-    familyRow.residual.length > 0
-      ? [...sections, familyRow.residual].join("\n\n")
-      : sections.join("\n\n");
-  const deny = new Set(familyRow.advertisedToolDeny);
-  return {
-    systemPrompt,
-    toolNames: tools.filter((name) => !deny.has(name)),
-  };
+): string {
+  if (familyRow.residual.length === 0) return sections.join("\n\n");
+  return [...sections, familyRow.residual].join("\n\n");
 }

packages/prompt-variance/src/assemble.ts

@@ -1,13 +1,14 @@
-export { assemble, type AssembledPromptVariance } from "./assemble.js";
-export { applyRowOverride, resolvePromptVariance } from "./resolve.js";
+export { assemble } from "./assemble.js";
+export { resolvePromptVariance } from "./resolve.js";
 export {
+  claudeRow,
   defaultRow,
   FAMILY_IDS,
   FAMILY_ROWS,
+  gptRow,
   grokRow,
+  grokToolBudgetResidual,
   museRow,
   type PromptVarianceFamily,
-  type PromptVarianceRender,
   type PromptVarianceRow,
-  type PromptVarianceRowOverride,
 } from "./rows.js";

packages/prompt-variance/src/index.ts

@@ -1,27 +1,37 @@
 import { describe, expect, test } from "bun:test";
-import { applyRowOverride, resolvePromptVariance } from "./resolve.js";
+import { 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");
+    expect(resolvePromptVariance({ family: "claude" }).id).toBe("claude");
+    expect(resolvePromptVariance({ family: "gpt" }).id).toBe("gpt");
   });
 
-  test("grok keeps its finish-bias residual and skill_search deny on leaves", () => {
+  test("grok keeps its finish-bias residual 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", () => {
+  test("grok on orchestrators falls back to the default row", () => {
     const row = resolvePromptVariance({ family: "grok", orchestrator: true });
+    expect(row.id).toBe("default");
     expect(row.residual).toBe("");
-    expect([...row.advertisedToolDeny]).toEqual([]);
+  });
+
+  test("claude keeps its task_guidance block on leaves, not orchestrators", () => {
+    expect(
+      resolvePromptVariance({ family: "claude", orchestrator: false }).residual,
+    ).toContain("<task_guidance>");
+    const orch = resolvePromptVariance({
+      family: "claude",
+      orchestrator: true,
+    });
+    expect(orch.id).toBe("default");
+    expect(orch.residual).toBe("");
   });
 
   test("muse keeps its residual on leaves and orchestrators alike", () => {
@@ -33,27 +43,12 @@ describe("resolvePromptVariance", () => {
     ).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"]);
+  test("gpt keeps its narrate-before-tools nudge on leaves and orchestrators alike", () => {
+    expect(
+      resolvePromptVariance({ family: "gpt", orchestrator: false }).residual,
+    ).toContain("Narrate before tools");
+    expect(
+      resolvePromptVariance({ family: "gpt", orchestrator: true }).residual,
+    ).toContain("Narrate before tools");
   });
 });

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

@@ -6,38 +6,21 @@ import {
 } from "./rows.js";
 
 /**
- * Apply a row's per-model-id override, if any. Model ids match
- * case-insensitively against the row's lowercase override keys; an
- * unknown id resolves to the base row unchanged.
- */
-export function applyRowOverride(
-  row: PromptVarianceRow,
-  model?: string,
-): PromptVarianceRow {
-  if (model === undefined) return row;
-  const override = row.overrides?.[model.trim().toLowerCase()];
-  if (override === undefined) return row;
-  return {
-    ...row,
-    residual: override.residual ?? row.residual,
-    advertisedToolDeny: override.advertisedToolDeny ?? row.advertisedToolDeny,
-    sectionOmit: override.sectionOmit ?? row.sectionOmit,
-  };
-}
-
-/**
- * Resolve the variance row for a family, mirroring the leaves-only gate:
- * the grok finish-bias residual only makes sense on leaf workers, so
- * orchestrators fall back to the default shape. Muse keeps its residual
- * on both — its constructors append the same text at the tail either way.
+ * Resolve the variance row for a family, mirroring the leaves-only gates in
+ * the model family policy: the grok finish-bias residual and the claude
+ * task_guidance block only make sense on leaf workers, so orchestrators
+ * fall back to the default row. Muse keeps its residual on both — the
+ * constructors append the same text at the tail either way — and gpt keeps
+ * its narrate-before-tools nudge on primaries and leaves alike.
  */
 export function resolvePromptVariance(input: {
   family: PromptVarianceFamily;
   orchestrator?: boolean;
-  model?: string;
 }): PromptVarianceRow {
-  if (input.family === "grok" && input.orchestrator === true) {
-    return applyRowOverride(defaultRow, input.model);
+  if (input.orchestrator === true) {
+    if (input.family === "grok" || input.family === "claude") {
+      return defaultRow;
+    }
   }
-  return applyRowOverride(FAMILY_ROWS[input.family], input.model);
+  return FAMILY_ROWS[input.family];
 }