@warmdrift/kgauto-compiler 2.0.0-alpha.74 → 2.0.0-alpha.76

package/dist/index.mjs

@@ -16,7 +16,7 @@ import {
 import {
   LIBRARY_VERSION,
   createKeyHealthRoute
-} from "./chunk-EB2YR7HL.mjs";
+} from "./chunk-WZZCW6NA.mjs";
 import {
   ABSOLUTE_FLOOR,
   ARCHETYPE_FLOOR_DEFAULT,
@@ -828,7 +828,7 @@ function passScoreTargets(ir, opts) {
     }
     const measuredGate = opts.measuredFailureGates?.get(modelId);
     if (measuredGate) qualityGatePenalty = QUALITY_GATE_PENALTY;
-    const isPromoted = promotion?.promotedModel === modelId;
+    const isPromoted = promotion?.mode === "downswap" && promotion.promotedModel === modelId;
     if (isPromoted && promotion.suppressQualityGate && !measuredGate) {
       qualityGatePenalty = 0;
     }
@@ -2341,6 +2341,16 @@ var DISCIPLINE_GATES_V1_NO_TOOLS = `Work through these gates at every judgment p
 3. Innocent explanation first: state the most plausible benign reading before alleging the alarming one.
 4. Label each claim: mark it observed, inferred, or assumed.
 5. A surfaced gap beats a guessed answer: flag what you cannot determine rather than fabricating past it.`;
+var RULE_DISCIPLINE_GATES_V1_STRUCTURED = "discipline-gates-v1-structured";
+var DISCIPLINE_GATES_V1_STRUCTURED_WITH_TOOLS = `Work through these gates at every judgment point, explicitly:
+1. Evidence before reasoning: cite what you observed before concluding from it.
+2. One extra signal: when a finding feels conclusive, check one more adjacent signal before stating it.
+3. Expand, don't guess: resolve a compressed or referenced item by looking it up rather than inferring its contents.
+4. Innocent explanation first: state the most plausible benign reading before alleging the alarming one.`;
+var DISCIPLINE_GATES_V1_STRUCTURED_NO_TOOLS = `Work through these gates at every judgment point, explicitly:
+1. Evidence before reasoning: cite what you observed before concluding from it.
+2. One extra signal: when a finding feels conclusive, check one more adjacent signal before stating it.
+3. Innocent explanation first: state the most plausible benign reading before alleging the alarming one.`;
 var DISCIPLINE_ELIGIBLE_ARCHETYPES = /* @__PURE__ */ new Set([
   "hunt",
   "summarize",
@@ -2351,7 +2361,12 @@ var DISCIPLINE_ELIGIBLE_ARCHETYPES = /* @__PURE__ */ new Set([
 function matchRule(kind, profile, archetype, ctx) {
   if (kind === "discipline_contract") {
     if (!DISCIPLINE_ELIGIBLE_ARCHETYPES.has(archetype)) return null;
-    if (ctx.outputMode !== "text") return null;
+    if (ctx.outputMode !== "text") {
+      return {
+        id: RULE_DISCIPLINE_GATES_V1_STRUCTURED,
+        preamble: ctx.hasTools ? DISCIPLINE_GATES_V1_STRUCTURED_WITH_TOOLS : DISCIPLINE_GATES_V1_STRUCTURED_NO_TOOLS
+      };
+    }
     return {
       id: RULE_DISCIPLINE_GATES_V1,
       preamble: ctx.hasTools ? DISCIPLINE_GATES_V1_WITH_TOOLS : DISCIPLINE_GATES_V1_NO_TOOLS
@@ -2444,9 +2459,13 @@ function mapRowsToPromotions(rows) {
     if (!isRawPromotionRow(row)) continue;
     const id = coerceId(row.id);
     if (id === null) continue;
+    const mode = row.mode === "strategy" ? "strategy" : row.mode === "downswap" || row.mode === void 0 ? "downswap" : null;
+    if (mode === null) continue;
     out.push({
       id,
       archetype: row.intent_archetype,
+      mode,
+      strategy: typeof row.strategy === "string" ? row.strategy : null,
       promotedModel: row.promoted_model,
       incumbentModel: row.incumbent_model,
       evalRunId: coerceId(row.eval_run_id ?? null),
@@ -2477,7 +2496,7 @@ function getApplicablePromotion(opts) {
   const rt = runtime4;
   if (!rt) return void 0;
   const appId = opts.appId;
-  if (!appId || !opts.archetype) return void 0;
+  if (!appId || !opts.archetype || !opts.mode) return void 0;
   let snap = snapshots4.get(appId);
   if (!snap) {
     snap = { data: [], expiresAt: 0, refreshing: false };
@@ -2489,7 +2508,9 @@ function getApplicablePromotion(opts) {
     snap.refreshing = true;
     void asyncRefresh4(rt, appId);
   }
-  return snap.data.find((p) => p.archetype === opts.archetype);
+  return snap.data.find(
+    (p) => p.archetype === opts.archetype && p.mode === opts.mode
+  );
 }
 var pendingRefreshes4 = /* @__PURE__ */ new Map();
 async function asyncRefresh4(rt, appId) {
@@ -2775,10 +2796,12 @@ function compile(ir, opts = {}) {
   ];
   const activePromotion = getApplicablePromotion({
     appId: ir.appId,
-    archetype: ir.intent.archetype
+    archetype: ir.intent.archetype,
+    mode: "downswap"
   });
   const promotion = activePromotion ? {
     id: activePromotion.id,
+    mode: activePromotion.mode,
     promotedModel: activePromotion.promotedModel,
     evalRunId: activePromotion.evalRunId,
     suppressQualityGate: activePromotion.suppressQualityGate
@@ -2829,6 +2852,24 @@ function compile(ir, opts = {}) {
     structuredOutput: ir.constraints?.structuredOutput,
     toolCount: ir.tools?.length ?? 0
   });
+  const strategyPromotion = getApplicablePromotion({
+    appId: ir.appId,
+    archetype: ir.intent.archetype,
+    mode: "strategy"
+  });
+  if (strategyPromotion?.strategy === "discipline-gates-v1" && !(workingIR.sections ?? []).some((s) => s.kind === "discipline_contract")) {
+    workingIR = {
+      ...workingIR,
+      sections: [
+        ...workingIR.sections ?? [],
+        {
+          id: `__kgauto_strategy_promotion_${strategyPromotion.id}__`,
+          kind: "discipline_contract",
+          text: ""
+        }
+      ]
+    };
+  }
   const translated = applySectionRewrites({
     ir: workingIR,
     profile,
@@ -2837,6 +2878,16 @@ function compile(ir, opts = {}) {
   });
   workingIR = translated.rewrittenIR;
   const sectionRewritesApplied = translated.rewrites;
+  if (strategyPromotion && translated.rewrites.some(
+    (rw) => rw.kind === "discipline_contract" && rw.sectionId === `__kgauto_strategy_promotion_${strategyPromotion.id}__`
+  )) {
+    accumulatedMutations.push({
+      id: `strategy-promotion-applied-${strategyPromotion.id}`,
+      source: "strategy_promotion",
+      passName: "translator",
+      description: `Strategy promotion #${strategyPromotion.id} (${strategyPromotion.strategy}) enabled the discipline gates on ${ir.appId}/${ir.intent.archetype} \u2014 measured gates-on verdict behind the 7-day rollback guard.`
+    });
+  }
   const disciplineRewrite = sectionRewritesApplied.find(
     (rw) => rw.kind === "discipline_contract"
   );
@@ -5383,6 +5434,58 @@ function hashForGolden(s) {
   }
   return `g${h.toString(36)}`;
 }
+var STRATEGY_GATES_SECTION_ID = "__kgauto_strategy_eval_gates__";
+function withDisciplineContract(ir) {
+  return {
+    ...ir,
+    sections: [
+      ...ir.sections ?? [],
+      { id: STRATEGY_GATES_SECTION_ID, kind: "discipline_contract", text: "" }
+    ]
+  };
+}
+var DISCIPLINE_GATES_V1_ALT_HEADER = "Before stating any conclusion, run this check:";
+var ALT_BULLETS = {
+  observe: "- What did I actually observe? Quote it before reasoning from it.",
+  extraSignal: "- This feels settled \u2014 what one adjacent signal have I not checked?",
+  expand: "- Is anything here compressed or referenced? Open it; do not infer its contents.",
+  innocent: "- What is the ordinary explanation? State it before any alarming one.",
+  label: "- For each claim: is it observed, inferred, or assumed? Say which.",
+  gap: "- What can I not determine from what I have? Name it rather than filling it in."
+};
+function altBlock(parts) {
+  return [DISCIPLINE_GATES_V1_ALT_HEADER, ...parts.map((p) => ALT_BULLETS[p])].join("\n");
+}
+function altGatesBlockFor(args) {
+  const shapeAltering = args.outputMode === "text" ? ["label", "gap"] : [];
+  const expand = args.hasTools ? ["expand"] : [];
+  return altBlock([
+    "observe",
+    "extraSignal",
+    ...expand,
+    "innocent",
+    ...shapeAltering
+  ]);
+}
+var STRATEGY_ALT_SECTION_ID = "__kgauto_strategy_eval_gates_alt__";
+function withAltDisciplineContract(ir) {
+  const outputMode = resolveOutputMode({
+    declared: ir.constraints?.outputMode,
+    structuredOutput: ir.constraints?.structuredOutput,
+    toolCount: ir.tools?.length ?? 0
+  });
+  const hasTools = (ir.tools?.length ?? 0) > 0;
+  return {
+    ...ir,
+    sections: [
+      ...ir.sections ?? [],
+      {
+        id: STRATEGY_ALT_SECTION_ID,
+        text: altGatesBlockFor({ outputMode, hasTools })
+      }
+    ]
+  };
+}
 async function runGoldenEval(opts) {
   const fetchFn = opts.fetchImpl ?? fetch;
   const progress = opts.onProgress ?? (() => {
@@ -5393,6 +5496,14 @@ async function runGoldenEval(opts) {
   const minJudgeable = opts.minJudgeableCases ?? 5;
   const judgeModel = opts.judgeModel ?? "claude-opus-4-8";
   const notes = [];
+  const axis = opts.axis ?? "model";
+  const strategyId = opts.strategy;
+  if (axis === "strategy" && !strategyId) {
+    throw new Error("golden-eval: axis 'strategy' requires opts.strategy.");
+  }
+  if (axis === "model" && !opts.candidateModel) {
+    throw new Error("golden-eval: axis 'model' requires opts.candidateModel.");
+  }
   const restHeaders = {
     apikey: opts.serviceKey,
     Authorization: `Bearer ${opts.serviceKey}`
@@ -5414,7 +5525,7 @@ async function runGoldenEval(opts) {
     );
   }
   progress(`Loaded ${goldenRows.length} golden case(s).`);
-  let incumbentModel = opts.incumbentModel;
+  let incumbentModel = axis === "strategy" ? opts.strategyModel : opts.incumbentModel;
   if (!incumbentModel) {
     const counts = /* @__PURE__ */ new Map();
     for (const row of goldenRows) {
@@ -5425,21 +5536,27 @@ async function runGoldenEval(opts) {
     incumbentModel = top[0];
     notes.push(`incumbent defaulted to most-captured model: ${incumbentModel}`);
   }
-  if (incumbentModel === opts.candidateModel) {
+  const candidateModel = axis === "strategy" ? incumbentModel : opts.candidateModel;
+  if (axis === "model" && incumbentModel === candidateModel) {
     throw new Error("golden-eval: candidate and incumbent are the same model.");
   }
   const judgeProfile = tryGetProfile(judgeModel);
   if (!judgeProfile) {
     throw new Error(`golden-eval: judge model '${judgeModel}' is not in the roster.`);
   }
-  if (judgeProfile.family && [incumbentModel, opts.candidateModel].some(
+  if (judgeProfile.family && [incumbentModel, candidateModel].some(
     (m) => tryGetProfile(m)?.family === judgeProfile.family
   )) {
     notes.push(
       `WARNING: judge family (${judgeProfile.family}) overlaps a compared model \u2014 self-preference risk; consider --judge from another provider.`
     );
   }
-  const replay = async (ir, model) => {
+  const armBIr = (ir) => {
+    if (axis !== "strategy") return ir;
+    return strategyId === "discipline-gates-v1-alt" ? withAltDisciplineContract(ir) : withDisciplineContract(ir);
+  };
+  const replay = async (ir, model, captureGates = false) => {
+    let gates;
     try {
       const evalIr = {
         ...ir,
@@ -5447,6 +5564,29 @@ async function runGoldenEval(opts) {
         constraints: { ...ir.constraints ?? {}, forceModel: model }
       };
       const compiled = compile(evalIr);
+      if (captureGates) {
+        if (strategyId === "discipline-gates-v1-alt") {
+          const altSection = (evalIr.sections ?? []).find(
+            (s) => s.id === STRATEGY_ALT_SECTION_ID
+          );
+          gates = {
+            fired: altSection !== void 0 && altSection.text.length > 0,
+            rule: "discipline-gates-v1-alt",
+            gateTokens: altSection ? countTokens(`${altSection.text}
+
+`) : 0
+          };
+        } else {
+          const gateRewrite = compiled.sectionRewritesApplied.find(
+            (rw) => rw.rule.startsWith("discipline-gates-")
+          );
+          gates = {
+            fired: gateRewrite !== void 0 && compiled.diagnostics.disciplineGateTokens > 0,
+            rule: gateRewrite?.rule,
+            gateTokens: compiled.diagnostics.disciplineGateTokens
+          };
+        }
+      }
       const attempt = () => execute(compiled.request, { apiKeys: opts.apiKeys, fetchImpl: opts.fetchImpl });
       let started = Date.now();
       let exec = await attempt();
@@ -5465,7 +5605,8 @@ async function runGoldenEval(opts) {
           tokensIn: 0,
           tokensOut: 0,
           latencyMs,
-          errorClass: exec.errorCode
+          errorClass: exec.errorCode,
+          ...gates ? { gates } : {}
         };
       }
       const validated = _internal.validateStructuredContract(exec, evalIr);
@@ -5477,7 +5618,8 @@ async function runGoldenEval(opts) {
           tokensIn: exec.response.tokens.input,
           tokensOut: exec.response.tokens.output,
           latencyMs,
-          contractViolation: validated.errorCode
+          contractViolation: validated.errorCode,
+          ...gates ? { gates } : {}
         };
       }
       return {
@@ -5487,7 +5629,8 @@ async function runGoldenEval(opts) {
         parseError: validated.response.parseError,
         tokensIn: validated.response.tokens.input,
         tokensOut: validated.response.tokens.output,
-        latencyMs
+        latencyMs,
+        ...gates ? { gates } : {}
       };
     } catch (err) {
       return {
@@ -5497,7 +5640,8 @@ async function runGoldenEval(opts) {
         tokensIn: 0,
         tokensOut: 0,
         latencyMs: 0,
-        errorClass: err instanceof Error ? `execute_rejected:${err.message}` : "execute_rejected"
+        errorClass: err instanceof Error ? `execute_rejected:${err.message}` : "execute_rejected",
+        ...gates ? { gates } : {}
       };
     }
   };
@@ -5556,12 +5700,39 @@ async function runGoldenEval(opts) {
   };
   for (const [i, row] of goldenRows.entries()) {
     progress(
-      `Case ${i + 1}/${goldenRows.length} (golden #${row.id}): replaying ${incumbentModel} + ${opts.candidateModel}\u2026`
+      `Case ${i + 1}/${goldenRows.length} (golden #${row.id}): replaying ${incumbentModel} + ${candidateModel}\u2026`
     );
     const [inc, cand] = await Promise.all([
       replay(row.ir, incumbentModel),
-      replay(row.ir, opts.candidateModel)
+      replay(armBIr(row.ir), candidateModel, axis === "strategy")
     ]);
+    if (axis === "strategy" && !cand.gates?.fired) {
+      notes.push(
+        `ABORT gates-did-not-fire: arm B compile produced no discipline-gate rewrite (case golden #${row.id}; archetype=${opts.archetype}; gateTokens=${cand.gates?.gateTokens ?? 0}). No verdict written \u2014 a tied-because-identical run is not evidence about the strategy.`
+      );
+      return {
+        verdict: "inconclusive",
+        axis,
+        strategy: strategyId,
+        appId: opts.appId,
+        archetype: opts.archetype,
+        incumbentModel,
+        candidateModel,
+        judgeModel,
+        nCases: 0,
+        wins: 0,
+        ties: 0,
+        losses: 0,
+        floorViolations: 0,
+        floorDetail: {},
+        winOrTieRatio: null,
+        latencyRatio: null,
+        costIncumbentUsd: null,
+        costCandidateUsd: null,
+        cases,
+        notes
+      };
+    }
     if (!inc.ok || inc.contractViolation) {
       const why = !inc.ok ? `incumbent replay failed (${inc.errorClass ?? "unknown"})` : `incumbent contract violation (${inc.contractViolation})`;
       cases.push({
@@ -5623,6 +5794,9 @@ async function runGoldenEval(opts) {
     cases.push({
       goldenIrId: row.id,
       verdict: verdict2,
+      // Release B — the raw pair the fold discards; positional-disagreement
+      // rate is the strategy experiment's primary metric.
+      orderVerdicts: { run1: v1, run2: v2 },
       judgeRationale: order1.rationale ?? order2.rationale,
       floorViolations: [],
       incumbent: incumbentLeg,
@@ -5646,7 +5820,7 @@ async function runGoldenEval(opts) {
   );
   const costCandidateUsd = sum(
     evaluable.map(
-      (c) => c.candidate ? costUsd(opts.candidateModel, c.candidate.tokensIn, c.candidate.tokensOut) : null
+      (c) => c.candidate ? costUsd(candidateModel, c.candidate.tokensIn, c.candidate.tokensOut) : null
     )
   );
   const latencyFloorOk = latencyRatio === null || latencyRatio <= latencyFloorRatio;
@@ -5664,10 +5838,12 @@ async function runGoldenEval(opts) {
   }
   const result = {
     verdict,
+    axis,
+    ...strategyId ? { strategy: strategyId } : {},
     appId: opts.appId,
     archetype: opts.archetype,
     incumbentModel,
-    candidateModel: opts.candidateModel,
+    candidateModel,
     judgeModel,
     nCases: evaluable.length,
     wins,
@@ -5697,8 +5873,12 @@ async function runGoldenEval(opts) {
     body: JSON.stringify({
       app_id: opts.appId,
       intent_archetype: opts.archetype,
+      // Release B (migration 048) — a run row that can't say which axis
+      // produced its verdict is a false-attribution engine.
+      axis,
+      strategy: strategyId ?? null,
       incumbent_model: incumbentModel,
-      candidate_model: opts.candidateModel,
+      candidate_model: candidateModel,
       trigger_source: opts.triggerSource ?? "manual",
       judge_model: judgeModel,
       n_cases: result.nCases,
@@ -5733,8 +5913,8 @@ async function runGoldenEval(opts) {
     return {
       app_id: opts.appId,
       intent_archetype: opts.archetype,
-      family: tryGetProfile(opts.candidateModel)?.family ?? "unknown",
-      candidate_model: opts.candidateModel,
+      family: tryGetProfile(candidateModel)?.family ?? "unknown",
+      candidate_model: candidateModel,
       current_model: incumbentModel,
       prompt_hash: hashForGolden(turn),
       current_response: c.incumbent?.text.slice(0, 500) ?? null,
@@ -5780,8 +5960,8 @@ async function runGoldenEval(opts) {
   const latestOutcomeId = latest[0]?.id;
   if (latestOutcomeId !== void 0) {
     const costLine = costIncumbentUsd !== null && costCandidateUsd !== null ? ` Eval cost basis: incumbent $${costIncumbentUsd.toFixed(4)} vs candidate $${costCandidateUsd.toFixed(4)} across the set.` : "";
-    const message = `Golden-set eval (run #${result.runId}): ${opts.candidateModel} vs ${incumbentModel} on ${opts.appId}/${opts.archetype} \u2014 verdict ${verdict.toUpperCase()}. ${wins}W/${ties}T/${losses}L over ${result.nCases} real workload case(s), wins-or-ties ${(100 * (winOrTieRatio ?? 0)).toFixed(0)}% (threshold ${(100 * threshold).toFixed(0)}%), ${result.floorViolations} hard-floor violation(s), latency ratio ${latencyRatio?.toFixed(2) ?? "n/a"}.` + costLine;
-    const suggestion = verdict === "promote-ready" ? `Candidate passed the non-inferiority rule on your real workload. To promote: node v2/scripts/promote-model.mjs --model ${opts.candidateModel} (or ask kgauto-Cairn). Evidence: kgauto_golden_eval_runs #${result.runId} + probe_outcomes golden_run_id=${result.runId}.` : `Candidate did NOT clear the non-inferiority rule \u2014 no action needed; the incumbent stays. Evidence rows: golden_run_id=${result.runId}.`;
+    const message = `Golden-set eval (run #${result.runId}): ${candidateModel} vs ${incumbentModel} on ${opts.appId}/${opts.archetype} \u2014 verdict ${verdict.toUpperCase()}. ${wins}W/${ties}T/${losses}L over ${result.nCases} real workload case(s), wins-or-ties ${(100 * (winOrTieRatio ?? 0)).toFixed(0)}% (threshold ${(100 * threshold).toFixed(0)}%), ${result.floorViolations} hard-floor violation(s), latency ratio ${latencyRatio?.toFixed(2) ?? "n/a"}.` + costLine;
+    const suggestion = verdict === "promote-ready" ? `Candidate passed the non-inferiority rule on your real workload. To promote: node v2/scripts/promote-model.mjs --model ${candidateModel} (or ask kgauto-Cairn). Evidence: kgauto_golden_eval_runs #${result.runId} + probe_outcomes golden_run_id=${result.runId}.` : `Candidate did NOT clear the non-inferiority rule \u2014 no action needed; the incumbent stays. Evidence rows: golden_run_id=${result.runId}.`;
     const advRes = await fetchFn(rest("compile_outcome_advisories"), {
       method: "POST",
       headers: { ...restHeaders, "Content-Type": "application/json", Prefer: "return=minimal" },
@@ -5810,6 +5990,33 @@ async function runGoldenEval(opts) {
   }
   return result;
 }
+function classifyStrategyOutcome(r) {
+  if (r.verdict === "inconclusive") return "inconclusive";
+  if (r.wins > r.losses) return "wins";
+  if (r.losses > r.wins) return "loses";
+  return "ties";
+}
+var STRATEGY_AUTHORSHIP_LIMITATION = "Both gate wordings share one author (kgauto-Cairn); a shared blind spot is invisible to this experiment. Strong verdicts: both-lose (mechanism) and v1-loses/alt-wins (wording). An independently-authored alt would strengthen every other cell.";
+async function runStrategyEvalWithAttribution(opts) {
+  const primary = await runGoldenEval({
+    ...opts,
+    axis: "strategy",
+    strategy: "discipline-gates-v1"
+  });
+  const outcome = classifyStrategyOutcome(primary);
+  if (outcome !== "loses") {
+    const attribution2 = outcome === "wins" ? "mechanism-works" : outcome === "ties" ? "no-lift" : "inconclusive";
+    return { attribution: attribution2, primary, limitation: STRATEGY_AUTHORSHIP_LIMITATION };
+  }
+  const alt = await runGoldenEval({
+    ...opts,
+    axis: "strategy",
+    strategy: "discipline-gates-v1-alt"
+  });
+  const altOutcome = classifyStrategyOutcome(alt);
+  const attribution = altOutcome === "wins" ? "wording-failure" : altOutcome === "loses" ? "mechanism-failure" : "wording-inconclusive";
+  return { attribution, primary, alt, limitation: STRATEGY_AUTHORSHIP_LIMITATION };
+}
 
 // src/oracle.ts
 var DEFAULT_DIMENSIONS = ["correctness", "completeness", "conciseness", "format"];
@@ -6231,6 +6438,211 @@ async function markExclusionFindingHandled(opts) {
   return { ok: true };
 }
 
+// src/decomposition.ts
+var DECOMPOSITION_TEMPLATES_VERSION = "decomposition-templates-v1";
+var DECOMPOSITION_TEMPLATES = {
+  summarize: {
+    archetype: "summarize",
+    version: DECOMPOSITION_TEMPLATES_VERSION,
+    rationale: "A long-input summarize is mostly reading. A cheap extractor reads the full payload and emits compressed notes; the incumbent composes the summary from the notes \u2014 frontier tokens are spent only on the part that needs frontier judgment.",
+    steps: [
+      {
+        role: "chunk-extract",
+        archetype: "extract",
+        tier: "delegate",
+        inputShare: 1,
+        emitsShareOfInput: 0.15,
+        outputShare: 0
+      },
+      {
+        role: "compose",
+        archetype: "summarize",
+        tier: "anchor",
+        inputShare: 0.15,
+        // reads the notes, not the raw payload
+        emitsShareOfInput: 0,
+        outputShare: 1
+      }
+    ]
+  },
+  hunt: {
+    archetype: "hunt",
+    version: DECOMPOSITION_TEMPLATES_VERSION,
+    rationale: "Hunt decomposes into breadth (search sweeps), mechanical harvesting (extraction), and judgment (dedupe + compose). The sweeps and the harvest are grunt work; the composition anchors on the incumbent.",
+    steps: [
+      {
+        role: "search-sweep",
+        archetype: "hunt",
+        tier: "delegate",
+        inputShare: 0.5,
+        emitsShareOfInput: 0.2,
+        outputShare: 0
+      },
+      {
+        role: "harvest",
+        archetype: "extract",
+        tier: "delegate",
+        inputShare: 0.35,
+        emitsShareOfInput: 0.1,
+        outputShare: 0
+      },
+      {
+        role: "dedupe-compose",
+        archetype: "judge",
+        tier: "anchor",
+        inputShare: 0.3,
+        // sweep notes + harvest notes
+        emitsShareOfInput: 0,
+        outputShare: 1
+      }
+    ]
+  },
+  plan: {
+    archetype: "plan",
+    version: DECOMPOSITION_TEMPLATES_VERSION,
+    rationale: "Planning splits into context-gathering (mechanical reading) and the plan itself (judgment). The gatherer reads the corpus and briefs; the incumbent plans from the brief.",
+    steps: [
+      {
+        role: "gather-brief",
+        archetype: "extract",
+        tier: "delegate",
+        inputShare: 1,
+        emitsShareOfInput: 0.2,
+        outputShare: 0
+      },
+      {
+        role: "draft-plan",
+        archetype: "plan",
+        tier: "anchor",
+        inputShare: 0.2,
+        emitsShareOfInput: 0,
+        outputShare: 1
+      }
+    ]
+  }
+};
+var COACH_CFG = {
+  /** Same felt-utility floor as promotions (alpha.67 family). */
+  minMonthlySavingUsd: 5,
+  /** Executor must clear this archetypePerf on the step's archetype —
+   * same floor as the translator/advisor (ARCHETYPE_FLOOR_DEFAULT). */
+  executorPerfFloor: 6,
+  daysPerMonth: 30
+};
+function planDecomposition(args) {
+  const { stats, incumbentPricing, pickExecutor } = args;
+  const cfg = { ...COACH_CFG, ...args.cfg ?? {} };
+  const template = DECOMPOSITION_TEMPLATES[stats.archetype];
+  if (!template) return void 0;
+  const perCall = (pricing, tokensIn, tokensOut) => tokensIn / 1e6 * pricing.costInputPer1m + tokensOut / 1e6 * pricing.costOutputPer1m;
+  const monolithCostPerCallUsd = perCall(
+    incumbentPricing,
+    stats.avgTokensIn,
+    stats.avgTokensOut
+  );
+  const assumptions = [
+    `per-step token shares are ${template.version} JUDGMENT numbers \u2014 no fan-out traffic exists to measure them from yet; they graduate per surface when branch traffic lands`
+  ];
+  const steps = [];
+  let splitCostPerCallUsd = 0;
+  for (const step of template.steps) {
+    const stepTokensIn = stats.avgTokensIn * step.inputShare;
+    const stepTokensOut = stats.avgTokensIn * step.emitsShareOfInput + stats.avgTokensOut * step.outputShare;
+    if (step.tier === "anchor") {
+      const cost2 = perCall(incumbentPricing, stepTokensIn, stepTokensOut);
+      splitCostPerCallUsd += cost2;
+      steps.push({
+        ...step,
+        executorModel: stats.incumbentModel,
+        executorGrounding: "measured",
+        // the incumbent IS the measured baseline
+        executorPerfScore: null,
+        projectedCostPerCallUsd: cost2
+      });
+      continue;
+    }
+    const candidate = pickExecutor(step.archetype);
+    if (candidate && candidate.modelId === stats.incumbentModel) {
+      const cost2 = perCall(incumbentPricing, stepTokensIn, stepTokensOut);
+      splitCostPerCallUsd += cost2;
+      steps.push({
+        ...step,
+        tier: "anchor",
+        executorModel: stats.incumbentModel,
+        executorGrounding: candidate.grounding,
+        executorPerfScore: candidate.perfScore,
+        projectedCostPerCallUsd: cost2
+      });
+      assumptions.push(
+        `step '${step.role}': the cheapest qualified executor IS the incumbent \u2014 nothing to delegate to`
+      );
+      continue;
+    }
+    if (!candidate || candidate.perfScore < cfg.executorPerfFloor) {
+      const cost2 = perCall(incumbentPricing, stepTokensIn, stepTokensOut);
+      splitCostPerCallUsd += cost2;
+      steps.push({
+        ...step,
+        tier: "anchor",
+        executorModel: stats.incumbentModel,
+        executorGrounding: "measured",
+        executorPerfScore: candidate?.perfScore ?? null,
+        projectedCostPerCallUsd: cost2
+      });
+      assumptions.push(
+        `step '${step.role}' (${step.archetype}): no executor clears the perf floor ${cfg.executorPerfFloor} \u2014 kept on the incumbent`
+      );
+      continue;
+    }
+    const cost = perCall(candidate, stepTokensIn, stepTokensOut);
+    splitCostPerCallUsd += cost;
+    steps.push({
+      ...step,
+      executorModel: candidate.modelId,
+      executorGrounding: candidate.grounding,
+      executorPerfScore: candidate.perfScore,
+      projectedCostPerCallUsd: cost
+    });
+    if (candidate.grounding === "judgment") {
+      assumptions.push(
+        `step '${step.role}': ${candidate.modelId} perf ${candidate.perfScore}/10 on ${step.archetype} is JUDGMENT-grounded (no measured portfolio outcomes for the tuple yet)`
+      );
+    }
+  }
+  const savingPerCallUsd = monolithCostPerCallUsd - splitCostPerCallUsd;
+  const monthlyCalls = stats.nCalls / stats.windowDays * cfg.daysPerMonth;
+  const projectedMonthlySavingUsd = savingPerCallUsd * monthlyCalls;
+  const breakEvenMonthlyCalls = savingPerCallUsd > 0 ? cfg.minMonthlySavingUsd / savingPerCallUsd : null;
+  let verdict;
+  let verdictReason;
+  if (savingPerCallUsd <= 0) {
+    verdict = "keep-monolith";
+    verdictReason = "the split costs MORE per call than the monolith at current pricing \u2014 no volume makes it pay";
+  } else if (projectedMonthlySavingUsd < cfg.minMonthlySavingUsd) {
+    verdict = "keep-monolith";
+    verdictReason = `the split pays $${projectedMonthlySavingUsd.toFixed(2)}/mo at your ~${Math.round(monthlyCalls)} calls/mo \u2014 below the $${cfg.minMonthlySavingUsd} felt-utility floor. Break-even is ~${Math.ceil(breakEvenMonthlyCalls ?? 0)} calls/mo; revisit when volume gets there. Decomposition adds moving parts, and a saving you can't feel doesn't buy them`;
+  } else {
+    verdict = "split-pays";
+    verdictReason = `projected $${projectedMonthlySavingUsd.toFixed(2)}/mo saving at ~${Math.round(monthlyCalls)} calls/mo (monolith $${monolithCostPerCallUsd.toFixed(4)}/call \u2192 split $${splitCostPerCallUsd.toFixed(4)}/call)`;
+  }
+  return {
+    appId: stats.appId,
+    archetype: String(stats.archetype),
+    incumbentModel: stats.incumbentModel,
+    template,
+    steps,
+    monolithCostPerCallUsd,
+    splitCostPerCallUsd,
+    savingPerCallUsd,
+    monthlyCalls,
+    projectedMonthlySavingUsd,
+    breakEvenMonthlyCalls,
+    verdict,
+    verdictReason,
+    assumptions
+  };
+}
+
 // src/index.ts
 function compile2(ir, opts) {
   const result = compile(ir, opts);
@@ -6243,11 +6655,15 @@ export {
   ALL_ARCHETYPES,
   ARCHETYPE_FAMILY_FITS,
   ARCHETYPE_FLOOR_DEFAULT,
+  COACH_CFG,
   CallError,
+  DECOMPOSITION_TEMPLATES,
+  DECOMPOSITION_TEMPLATES_VERSION,
   DEFAULT_FINDINGS_ENDPOINT,
   DEFAULT_MEASURED_FAILURE_ENDPOINT,
   DEFAULT_PROMOTIONS_ENDPOINT,
   DIALECT_VERSION,
+  DISCIPLINE_GATES_V1_ALT_HEADER,
   FamilyResolutionError,
   INTENT_ARCHETYPES,
   JUDGE_RUBRICS,
@@ -6257,13 +6673,17 @@ export {
   MEASURED_GROUNDING_MIN_N,
   PRODUCER_OWNED_RULE_CODES,
   PROVIDER_ENV_KEYS,
+  RULE_DISCIPLINE_GATES_V1,
+  RULE_DISCIPLINE_GATES_V1_STRUCTURED,
   RULE_SEQUENTIAL_TOOL_CLIFF,
+  STRATEGY_AUTHORSHIP_LIMITATION,
   TRANSLATOR_FLOOR,
   _testResetMeasuredFailure,
   _testResetPromotions,
   _testWaitForMeasuredFailureRefresh,
   _testWaitForPromotionsRefresh,
   allProfiles,
+  altGatesBlockFor,
   applyArchetypeConvention,
   applySectionRewrites,
   attachCacheControlToStreamTextInput,
@@ -6278,6 +6698,7 @@ export {
   buildShadowProbeRow,
   call,
   captureGoldenIr,
+  classifyStrategyOutcome,
   clearBrain,
   combineOrderSwappedVerdicts,
   compile2 as compile,
@@ -6337,6 +6758,7 @@ export {
   parseGoldenCaptureRate,
   parseJudgeVerdict,
   peekBrainDeadLetter,
+  planDecomposition,
   prefetchMeasuredFailure,
   probeShadow,
   profileToRow,
@@ -6355,8 +6777,11 @@ export {
   rubricFor,
   runAdvisor,
   runGoldenEval,
+  runStrategyEvalWithAttribution,
   setTokenizer,
   shouldCaptureGolden,
   tryGetProfile,
-  wilsonLowerBound
+  wilsonLowerBound,
+  withAltDisciplineContract,
+  withDisciplineContract
 };