@warmdrift/kgauto-compiler 2.0.0-alpha.91 → 2.0.0-alpha.93

package/dist/chunk-BTP5WK3B.mjs

@@ -0,0 +1,3448 @@
+import {
+  ARCHETYPE_FLOOR_DEFAULT,
+  canonicalPolicySet,
+  configFreshness,
+  createBrainQueryCache,
+  estimateChainCostUsd,
+  getArchetypePerfScore,
+  getDefaultFallbackChain,
+  getModelCompatibility,
+  isBrainQueryActiveFor,
+  policySetHas
+} from "./chunk-S4PA2BDB.mjs";
+import {
+  bucketContext,
+  bucketHistory,
+  bucketToolCount,
+  learningKey,
+  resolveOutputMode,
+  routeScopedModel
+} from "./chunk-FEMPY6EC.mjs";
+import {
+  ALIASES,
+  LATENCY_TIER_MS,
+  _setProfileBrainHook,
+  allProfiles,
+  allProfilesRaw,
+  bestEffortProfile,
+  getProfile,
+  inferProviderFromId,
+  latencyTierOf,
+  resolveModelAlias,
+  tryGetProfile
+} from "./chunk-YO2ZLPSD.mjs";
+
+// src/models-brain.ts
+function isModelRow(x) {
+  if (!x || typeof x !== "object") return false;
+  const r = x;
+  return typeof r.model_id === "string" && typeof r.provider === "string";
+}
+function isAliasRow(x) {
+  if (!x || typeof x !== "object") return false;
+  const r = x;
+  return typeof r.alias_id === "string" && typeof r.canonical_id === "string";
+}
+function rowToProfile(row) {
+  try {
+    if (row.cliffs !== void 0 && row.cliffs !== null && !Array.isArray(row.cliffs)) {
+      return null;
+    }
+    if (row.recovery !== void 0 && row.recovery !== null && !Array.isArray(row.recovery)) {
+      return null;
+    }
+    if (row.lowering !== void 0 && row.lowering !== null && (typeof row.lowering !== "object" || Array.isArray(row.lowering))) {
+      return null;
+    }
+    if (row.archetype_conventions !== void 0 && row.archetype_conventions !== null && !Array.isArray(row.archetype_conventions)) {
+      return null;
+    }
+    return {
+      id: row.model_id,
+      provider: row.provider,
+      status: row.status ?? "current",
+      maxContextTokens: row.max_context_tokens ?? 0,
+      maxOutputTokens: row.max_output_tokens ?? 0,
+      maxTools: row.max_tools ?? 0,
+      parallelToolCalls: row.parallel_tool_calls ?? false,
+      structuredOutput: row.structured_output ?? "none",
+      systemPromptMode: row.system_prompt_mode ?? "inline",
+      streaming: row.streaming ?? true,
+      cliffs: row.cliffs ?? [],
+      costInputPer1m: row.cost_input_per_1m ?? 0,
+      costOutputPer1m: row.cost_output_per_1m ?? 0,
+      lowering: row.lowering ?? { system: { mode: "inline" }, cache: { strategy: "unsupported" } },
+      recovery: row.recovery ?? [],
+      strengths: row.strengths ?? [],
+      weaknesses: row.weaknesses ?? [],
+      notes: row.notes ?? void 0,
+      verifiedAgainstDocs: row.verified_against_docs ?? void 0,
+      archetypePerf: row.archetype_perf ?? void 0,
+      // alpha.41 — family-resolution fields. `family` may be null pre-
+      // migration 024; runtime falls back to deriveFamilyFromModelId at
+      // resolution time (see family-resolution.ts, G1).
+      family: row.family ?? void 0,
+      versionAdded: row.version_added ?? void 0,
+      active: row.active ?? void 0,
+      // alpha.49 — executable-knowledge fields (migration 028). Invalid
+      // latency_tier → undefined (latencyTierOf derives from tags; not
+      // safety-critical). archetype_conventions already array-validated above.
+      latencyTier: normalizeLatencyTier(row.latency_tier),
+      archetypeConventions: row.archetype_conventions ?? void 0
+    };
+  } catch {
+    return null;
+  }
+}
+var VALID_LATENCY_TIERS = /* @__PURE__ */ new Set(["fast", "medium", "slow"]);
+function normalizeLatencyTier(v) {
+  return typeof v === "string" && VALID_LATENCY_TIERS.has(v) ? v : void 0;
+}
+function profileToRow(profile, opts = {}) {
+  const row = {
+    model_id: profile.id,
+    provider: profile.provider,
+    status: profile.status,
+    max_context_tokens: profile.maxContextTokens,
+    max_output_tokens: profile.maxOutputTokens,
+    max_tools: profile.maxTools,
+    parallel_tool_calls: profile.parallelToolCalls,
+    structured_output: profile.structuredOutput,
+    system_prompt_mode: profile.systemPromptMode,
+    streaming: profile.streaming,
+    cliffs: profile.cliffs,
+    cost_input_per_1m: profile.costInputPer1m,
+    cost_output_per_1m: profile.costOutputPer1m,
+    lowering: profile.lowering,
+    recovery: profile.recovery,
+    strengths: profile.strengths,
+    weaknesses: profile.weaknesses,
+    notes: profile.notes ?? null,
+    archetype_perf: profile.archetypePerf ?? null,
+    active: opts.active ?? profile.active ?? true,
+    // alpha.41 — round-trip family + version_added when present on profile.
+    // version_added is operator-controlled via opts; profile-side value is
+    // used only when opts didn't override.
+    family: profile.family ?? null,
+    // alpha.49 — round-trip the executable-knowledge fields (migration 028)
+    // so a reseed from bundled profiles makes the latency lever + schema
+    // conventions live warm. Closes the silently-dropped-field gap.
+    latency_tier: profile.latencyTier ?? null,
+    archetype_conventions: profile.archetypeConventions ?? null
+  };
+  if (opts.verifiedAgainstDocs !== void 0) {
+    row.verified_against_docs = opts.verifiedAgainstDocs;
+  } else if (profile.verifiedAgainstDocs !== void 0) {
+    const v = profile.verifiedAgainstDocs;
+    row.verified_against_docs = /^\d{4}-\d{2}-\d{2}/.test(v) ? v : null;
+  }
+  if (opts.versionAdded !== void 0) row.version_added = opts.versionAdded;
+  else if (profile.versionAdded !== void 0) row.version_added = profile.versionAdded;
+  if (opts.versionRemoved !== void 0) row.version_removed = opts.versionRemoved;
+  return row;
+}
+function mapRowsToModels(rows) {
+  const out = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (!isModelRow(row)) continue;
+    const profile = rowToProfile(row);
+    if (profile) out.set(profile.id, profile);
+  }
+  return out;
+}
+function mapRowsToAliases(rows) {
+  const out = {};
+  for (const row of rows) {
+    if (!isAliasRow(row)) continue;
+    out[row.alias_id] = row.canonical_id;
+  }
+  return out;
+}
+function bundledModels() {
+  return new Map(allProfilesRaw().map((p) => [p.id, p]));
+}
+function bundledAliases() {
+  return { ...ALIASES };
+}
+var loadModelsFromBrain = createBrainQueryCache({
+  table: "kgauto_models",
+  mapRows: mapRowsToModels,
+  bundledFallback: bundledModels
+});
+var loadAliasesFromBrain = createBrainQueryCache({
+  table: "kgauto_aliases",
+  mapRows: mapRowsToAliases,
+  bundledFallback: bundledAliases
+});
+_setProfileBrainHook({
+  getProfile: (canonical) => loadModelsFromBrain().get(canonical),
+  resolveAlias: (id) => loadAliasesFromBrain()[id]
+});
+
+// src/exclusion-findings-brain.ts
+function isValidVerdict(v) {
+  return v === "recommend-probe" || v === "unblock" || v === "stay-excluded" || v === "inconclusive";
+}
+function isValidConfidence(v) {
+  return v === "high" || v === "medium" || v === "low";
+}
+function isRawFindingRow(x) {
+  if (!x || typeof x !== "object") return false;
+  const r = x;
+  return typeof r.intent_archetype === "string" && typeof r.excluded_model === "string" && typeof r.excluded_provider === "string" && typeof r.verdict === "string" && typeof r.message === "string" && typeof r.suggestion === "string" && typeof r.confidence === "string";
+}
+function mapRowsToFindings(rows) {
+  const out = [];
+  for (const row of rows) {
+    if (!isRawFindingRow(row)) continue;
+    if (!isValidVerdict(row.verdict)) continue;
+    if (!isValidConfidence(row.confidence)) continue;
+    let savings = null;
+    if (typeof row.estimated_savings_usd_30d === "number") {
+      savings = Number.isFinite(row.estimated_savings_usd_30d) ? row.estimated_savings_usd_30d : null;
+    } else if (typeof row.estimated_savings_usd_30d === "string") {
+      const n = Number(row.estimated_savings_usd_30d);
+      savings = Number.isFinite(n) ? n : null;
+    }
+    out.push({
+      archetype: row.intent_archetype,
+      excludedModel: row.excluded_model,
+      excludedProvider: row.excluded_provider,
+      verdict: row.verdict,
+      estimatedSavingsUsd30d: savings,
+      message: row.message,
+      suggestion: row.suggestion,
+      confidence: row.confidence,
+      evidence: row.evidence && typeof row.evidence === "object" ? row.evidence : void 0
+    });
+  }
+  return out;
+}
+var snapshots = /* @__PURE__ */ new Map();
+function exclusionFindingsFreshness(appId) {
+  return snapshots.get(appId)?.loaded ? "warm" : "cold";
+}
+var runtime;
+var warnedOnce = false;
+var DEFAULT_FINDINGS_ENDPOINT = "https://kgauto-dashboard.vercel.app/api/kgauto-v2/findings/exclusions";
+function configureExclusionFindingsBrain(rt) {
+  runtime = rt;
+  snapshots.clear();
+  warnedOnce = false;
+}
+function isExclusionFindingsBrainActive() {
+  return runtime !== void 0;
+}
+function getStaleExclusionFindings(opts) {
+  const rt = runtime;
+  if (!rt) return [];
+  const appId = opts.appId;
+  if (!appId) return [];
+  let snap = snapshots.get(appId);
+  if (!snap) {
+    snap = { data: [], expiresAt: 0, refreshing: false };
+    snapshots.set(appId, snap);
+  }
+  const now = Date.now();
+  const stale = snap.expiresAt <= now;
+  if (stale && !snap.refreshing) {
+    snap.refreshing = true;
+    void asyncRefresh(rt, appId);
+  }
+  if (opts.archetype) {
+    return snap.data.filter((f) => f.archetype === opts.archetype);
+  }
+  return snap.data;
+}
+var pendingRefreshes = /* @__PURE__ */ new Map();
+async function asyncRefresh(rt, appId) {
+  const promise = doRefresh(rt, appId);
+  pendingRefreshes.set(appId, promise);
+  try {
+    await promise;
+  } finally {
+    if (pendingRefreshes.get(appId) === promise) {
+      pendingRefreshes.delete(appId);
+    }
+  }
+}
+async function doRefresh(rt, appId) {
+  const url = `${rt.endpoint}?app_id=${encodeURIComponent(appId)}`;
+  let snap = snapshots.get(appId);
+  if (!snap) {
+    snap = { data: [], expiresAt: 0, refreshing: false };
+    snapshots.set(appId, snap);
+  }
+  try {
+    const res = await rt.fetchImpl(url, { method: "GET" });
+    if (!res.ok) {
+      throw new Error(`findings ${res.status}: ${res.statusText}`);
+    }
+    const body = await res.json();
+    if (runtime !== rt) return;
+    const rows = Array.isArray(body) ? mapRowsToFindings(body) : [];
+    snap.data = rows;
+    snap.loaded = true;
+    snap.expiresAt = Date.now() + rt.ttlMs;
+    snap.refreshing = false;
+  } catch (err) {
+    if (runtime !== rt) return;
+    snap.refreshing = false;
+    snap.expiresAt = Date.now() + rt.ttlMs;
+    if (!warnedOnce) {
+      warnedOnce = true;
+      (rt.onError ?? defaultOnError)(err);
+    }
+  }
+}
+function defaultOnError(err) {
+  console.warn(
+    "[kgauto] exclusion-findings fetch failed (using empty fallback):",
+    err
+  );
+}
+
+// src/family-resolution.ts
+var FamilyResolutionError = class extends Error {
+  family;
+  cause;
+  constructor(family, cause) {
+    super(
+      `Family "${family}" did not resolve to any current+active model. ${cause}. Pass a literal model id in ir.models, or call getRecommendedPrimary({ family, fallback }) at IR-construction time.`
+    );
+    this.name = "FamilyResolutionError";
+    this.family = family;
+    this.cause = cause;
+  }
+};
+function deriveFamilyFromModelId(modelId) {
+  if (typeof modelId !== "string" || modelId.length === 0) return null;
+  if (modelId.startsWith("claude-opus-")) return "claude-opus";
+  if (modelId.startsWith("claude-sonnet-")) return "claude-sonnet";
+  if (modelId.startsWith("claude-haiku-")) return "claude-haiku";
+  if (modelId.startsWith("gemini-") && modelId.includes("flash-lite")) {
+    return "gemini-flash-lite";
+  }
+  if (modelId.startsWith("gemini-") && modelId.includes("flash")) {
+    return "gemini-flash";
+  }
+  if (modelId.startsWith("gemini-") && modelId.includes("pro")) {
+    return "gemini-pro";
+  }
+  if (modelId.startsWith("deepseek-") && modelId.includes("pro")) {
+    return "deepseek-reasoner";
+  }
+  if (modelId.startsWith("deepseek-")) return "deepseek-chat";
+  if (modelId.startsWith("gpt-")) return "openai-gpt";
+  return null;
+}
+function familyOf(profile) {
+  return profile.family ?? deriveFamilyFromModelId(profile.id);
+}
+function archetypePerfFor(profile, archetype) {
+  if (!archetype) return 0;
+  const score = profile.archetypePerf?.[archetype];
+  return typeof score === "number" ? score : 5;
+}
+function selectCandidates(registry, family, archetype, appId) {
+  const out = [];
+  const excluded = /* @__PURE__ */ new Set();
+  if (appId && archetype) {
+    const findings = getStaleExclusionFindings({ appId, archetype });
+    for (const f of findings) {
+      if (f.verdict === "stay-excluded") excluded.add(f.excludedModel);
+    }
+  }
+  for (const profile of registry.values()) {
+    if (familyOf(profile) !== family) continue;
+    if (profile.status !== "current") continue;
+    if (profile.active === false) continue;
+    if (archetype) {
+      if (archetypePerfFor(profile, archetype) < ARCHETYPE_FLOOR_DEFAULT) continue;
+    }
+    if (excluded.has(profile.id)) continue;
+    out.push(profile);
+  }
+  return out;
+}
+function sortCandidates(candidates, archetype) {
+  const sorted = [...candidates];
+  sorted.sort((a, b) => {
+    const perfA = archetypePerfFor(a, archetype);
+    const perfB = archetypePerfFor(b, archetype);
+    if (perfA !== perfB) return perfB - perfA;
+    const vA = a.versionAdded ?? "";
+    const vB = b.versionAdded ?? "";
+    if (vA !== vB) return vA < vB ? 1 : -1;
+    return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+  });
+  return sorted;
+}
+function getRecommendedPrimary(opts) {
+  if (opts.posture === "locked") return opts.fallback;
+  const registry = loadModelsFromBrain();
+  const candidates = selectCandidates(
+    registry,
+    opts.family,
+    opts.archetype,
+    opts.appId
+  );
+  if (candidates.length === 0) return opts.fallback;
+  const sorted = sortCandidates(candidates, opts.archetype);
+  return sorted[0]?.id ?? opts.fallback;
+}
+function resolveFamilyEntry(family, ctx) {
+  if (typeof family !== "string" || family.length === 0) {
+    throw new FamilyResolutionError(
+      String(family),
+      "Family tag must be a non-empty string"
+    );
+  }
+  const registry = loadModelsFromBrain();
+  const candidates = selectCandidates(
+    registry,
+    family,
+    ctx.archetype,
+    ctx.appId
+  );
+  if (candidates.length === 0) {
+    let anyInFamily = false;
+    for (const profile of registry.values()) {
+      if (familyOf(profile) === family) {
+        anyInFamily = true;
+        break;
+      }
+    }
+    const cause = anyInFamily ? `Family has registered models but none are current+active${ctx.archetype ? ` at archetype-perf >= ${ARCHETYPE_FLOOR_DEFAULT} for "${ctx.archetype}"` : ""}${ctx.appId ? ` and not excluded for app "${ctx.appId}"` : ""}` : `No models in brain registry carry family="${family}". Check the taxonomy table in family-resolution.ts or migration 024`;
+    throw new FamilyResolutionError(family, cause);
+  }
+  const sorted = sortCandidates(candidates, ctx.archetype);
+  const winner = sorted[0];
+  if (!winner) {
+    throw new FamilyResolutionError(
+      family,
+      "Candidates non-empty but sort returned undefined \u2014 internal invariant violation"
+    );
+  }
+  return winner.id;
+}
+
+// src/tokenizer.ts
+var tokenizerImpl = defaultCharBasedCounter;
+function defaultCharBasedCounter(text) {
+  if (!text) return 0;
+  return Math.max(1, Math.ceil(text.length / 4));
+}
+function setTokenizer(impl) {
+  tokenizerImpl = impl;
+}
+function resetTokenizer() {
+  tokenizerImpl = defaultCharBasedCounter;
+}
+function countTokens(text) {
+  if (!text) return 0;
+  try {
+    const n = tokenizerImpl(text);
+    return Number.isFinite(n) && n >= 0 ? n : defaultCharBasedCounter(text);
+  } catch {
+    return defaultCharBasedCounter(text);
+  }
+}
+function countToolTokens(tool) {
+  const namePart = countTokens(tool.name);
+  const descPart = tool.description ? countTokens(tool.description) : 0;
+  const paramPart = tool.parameters ? countTokens(JSON.stringify(tool.parameters)) : 0;
+  return namePart + descPart + paramPart + 8;
+}
+function countMessagesTokens(messages) {
+  let total = 0;
+  for (const m of messages) {
+    total += countTokens(m.content) + 4;
+  }
+  return total;
+}
+
+// src/passes.ts
+function passSlice(ir) {
+  const intent = ir.intent.archetype;
+  const before = ir.sections.length;
+  const kept = ir.sections.filter((s) => !s.intents || s.intents.length === 0 || s.intents.includes(intent));
+  const dropped = before - kept.length;
+  if (dropped === 0) return { value: ir, mutations: [] };
+  return {
+    value: { ...ir, sections: kept },
+    mutations: [
+      {
+        id: `slice-${dropped}`,
+        source: "static_pass",
+        passName: "slice",
+        description: `Dropped ${dropped} of ${before} sections not tagged for intent=${intent}`
+      }
+    ]
+  };
+}
+function passDedupe(ir) {
+  const seen = /* @__PURE__ */ new Map();
+  const order = [];
+  for (const s of ir.sections) {
+    const key = simpleHash(s.text.trim());
+    if (!seen.has(key)) {
+      seen.set(key, s);
+      order.push(key);
+    }
+  }
+  const deduped = order.map((k) => seen.get(k));
+  const dropped = ir.sections.length - deduped.length;
+  if (dropped === 0) return { value: ir, mutations: [] };
+  return {
+    value: { ...ir, sections: deduped },
+    mutations: [
+      {
+        id: `dedupe-${dropped}`,
+        source: "static_pass",
+        passName: "dedupe",
+        description: `Removed ${dropped} duplicate section(s) (by text hash)`
+      }
+    ]
+  };
+}
+function passToolRelevance(ir, opts = {}) {
+  if (!ir.tools || ir.tools.length === 0) return { value: ir, mutations: [] };
+  const threshold = opts.threshold ?? 0.2;
+  const intent = ir.intent.archetype;
+  const scored = ir.tools.map((t) => {
+    const score = t.relevanceByIntent?.[intent] ?? 0.5;
+    return { tool: t, score };
+  });
+  const kept = scored.filter((s) => s.score >= threshold).sort((a, b) => b.score - a.score).map((s) => s.tool);
+  const limited = opts.maxKeep ? kept.slice(0, opts.maxKeep) : kept;
+  const dropped = ir.tools.length - limited.length;
+  if (dropped === 0) return { value: ir, mutations: [] };
+  return {
+    value: { ...ir, tools: limited },
+    mutations: [
+      {
+        id: `tool-relevance-${dropped}`,
+        source: "static_pass",
+        passName: "tool_relevance",
+        description: `Dropped ${dropped} of ${ir.tools.length} tools below relevance ${threshold} for intent=${intent}`
+      }
+    ]
+  };
+}
+function totalHistoryTokens(history) {
+  let total = 0;
+  for (const m of history) {
+    if (typeof m.content === "string") total += countTokens(m.content);
+  }
+  return total;
+}
+function passCompressHistory(ir, opts = {}) {
+  const history = ir.history;
+  if (!history || history.length === 0) {
+    return { value: ir, mutations: [], historyTokensTotal: 0 };
+  }
+  const keepRecent = opts.keepRecent ?? 4;
+  const summarizeOlderThan = opts.summarizeOlderThan ?? 8;
+  const summarizeAboveTokens = opts.summarizeAboveTokens;
+  const historyTokensTotal = totalHistoryTokens(history);
+  const countThresholdHit = history.length > summarizeOlderThan;
+  const tokenThresholdHit = summarizeAboveTokens !== void 0 && historyTokensTotal > summarizeAboveTokens;
+  if (!countThresholdHit && !tokenThresholdHit) {
+    return { value: ir, mutations: [], historyTokensTotal };
+  }
+  if (history.length > keepRecent) {
+    const cutIndex = history.length - keepRecent;
+    const old = history.slice(0, cutIndex);
+    const recent = history.slice(cutIndex);
+    const userTurns = old.filter((m) => m.role === "user");
+    const firstUserLine = userTurns[0]?.content.split("\n")[0]?.slice(0, 200) ?? "";
+    const oldTokens = totalHistoryTokens(old);
+    const trigger = tokenThresholdHit && !countThresholdHit ? "tokens" : "count";
+    const summary = {
+      role: "system",
+      content: `[Earlier conversation: ${old.length} turns omitted (~${oldTokens} tokens). First user message: "${firstUserLine}"]`
+    };
+    return {
+      value: { ...ir, history: [summary, ...recent] },
+      mutations: [
+        {
+          id: `compress-history-${old.length}`,
+          source: "static_pass",
+          passName: "compress_history",
+          description: trigger === "tokens" ? `Compressed ${old.length} old turns (~${oldTokens} tokens) into 1 summary \u2014 token threshold ${summarizeAboveTokens} exceeded (kept ${keepRecent} recent)` : `Compressed ${old.length} old turns into 1 summary (kept ${keepRecent} recent)`
+        }
+      ],
+      historyTokensTotal
+    };
+  }
+  if (tokenThresholdHit) {
+    let fattestIdx = -1;
+    let fattestTokens = 0;
+    for (let i = 0; i < history.length; i++) {
+      const m = history[i];
+      if (!m || typeof m.content !== "string") continue;
+      const t = countTokens(m.content);
+      if (t > fattestTokens) {
+        fattestTokens = t;
+        fattestIdx = i;
+      }
+    }
+    const FAT_DOMINANCE_FLOOR = 0.3;
+    const fattest = fattestIdx >= 0 ? history[fattestIdx] : void 0;
+    if (fattest && historyTokensTotal > 0 && fattestTokens / historyTokensTotal >= FAT_DOMINANCE_FLOOR) {
+      const firstLine = fattest.content.split("\n")[0]?.slice(0, 200) ?? "";
+      const newContent = `[Earlier ${fattest.role} message content omitted: ~${fattestTokens} tokens. Preview: "${firstLine}"]`;
+      const newHistory = history.slice();
+      newHistory[fattestIdx] = { ...fattest, content: newContent };
+      return {
+        value: { ...ir, history: newHistory },
+        mutations: [
+          {
+            id: `compress-fat-message-${fattestIdx}`,
+            source: "static_pass",
+            passName: "compress_history",
+            description: `Replaced fat ${fattest.role} message #${fattestIdx} content (~${fattestTokens} of ${historyTokensTotal} tokens, ${Math.round(fattestTokens / historyTokensTotal * 100)}% of history) with summary stub \u2014 token threshold ${summarizeAboveTokens} exceeded (history.length ${history.length} <= keepRecent ${keepRecent}, slice not possible)`
+          }
+        ],
+        historyTokensTotal
+      };
+    }
+  }
+  return { value: ir, mutations: [], historyTokensTotal };
+}
+function passApplyCliffs(ir, profile, estimatedInputTokens) {
+  const mutations = [];
+  const hints = { qualityWarning: [] };
+  let nextIR = ir;
+  const sequentialMode = nextIR.constraints?.toolOrchestration === "sequential";
+  for (const cliff of profile.cliffs) {
+    if (sequentialMode && cliff.reason.includes("L-040")) {
+      continue;
+    }
+    let triggered = false;
+    switch (cliff.metric) {
+      case "input_tokens":
+        triggered = estimatedInputTokens >= cliff.threshold;
+        break;
+      case "tool_count":
+        triggered = (nextIR.tools?.length ?? 0) >= cliff.threshold;
+        break;
+      case "history_turns":
+        triggered = (nextIR.history?.length ?? 0) >= cliff.threshold;
+        break;
+      case "thinking_with_short_output":
+        triggered = !!nextIR.constraints?.expectedShortOutput;
+        break;
+    }
+    if (triggered && cliff.whenIntent && nextIR.intent.archetype !== cliff.whenIntent) {
+      triggered = false;
+    }
+    if (!triggered) continue;
+    switch (cliff.action) {
+      case "drop_to_top_relevant": {
+        const targetCount = Math.max(
+          1,
+          Math.min(
+            Math.floor(cliff.threshold * 0.75),
+            Math.floor((nextIR.tools?.length ?? 0) / 2)
+          )
+        );
+        if (nextIR.tools && nextIR.tools.length > targetCount) {
+          const intent = nextIR.intent.archetype;
+          const scored = nextIR.tools.map((t) => ({ tool: t, score: t.relevanceByIntent?.[intent] ?? 0.5 })).sort((a, b) => b.score - a.score).slice(0, targetCount).map((s) => s.tool);
+          nextIR = { ...nextIR, tools: scored };
+          mutations.push({
+            id: `cliff-${cliff.metric}`,
+            source: "cliff_guard",
+            passName: "apply_cliffs",
+            description: `${profile.id}: ${cliff.reason}; trimmed tools to ${targetCount}`
+          });
+        }
+        break;
+      }
+      case "force_thinking_budget_zero":
+        hints.forceThinkingZero = true;
+        mutations.push({
+          id: `cliff-thinking-zero`,
+          source: "cliff_guard",
+          passName: "apply_cliffs",
+          description: `${profile.id}: ${cliff.reason}`
+        });
+        break;
+      case "force_terse_output":
+        hints.forceTerseOutput = true;
+        mutations.push({
+          id: `cliff-terse`,
+          source: "cliff_guard",
+          passName: "apply_cliffs",
+          description: `${profile.id}: ${cliff.reason}`
+        });
+        break;
+      case "downgrade_quality_warning":
+        hints.qualityWarning.push(cliff.reason);
+        mutations.push({
+          id: `cliff-quality-warning`,
+          source: "cliff_guard",
+          passName: "apply_cliffs",
+          description: `${profile.id}: ${cliff.reason}`
+        });
+        break;
+      case "escalate_target":
+        hints.escalateRequested = true;
+        mutations.push({
+          id: `cliff-escalate`,
+          source: "cliff_guard",
+          passName: "apply_cliffs",
+          description: `${profile.id}: ${cliff.reason}`
+        });
+        break;
+      case "strip_tools": {
+        const droppedCount = nextIR.tools?.length ?? 0;
+        if (droppedCount > 0) {
+          nextIR = { ...nextIR, tools: [] };
+          mutations.push({
+            id: `cliff-strip-tools${cliff.whenIntent ? `-${cliff.whenIntent}` : ""}`,
+            source: "cliff_guard",
+            passName: "apply_cliffs",
+            description: `${profile.id}: ${cliff.reason} \u2014 stripped ${droppedCount} tools`
+          });
+        }
+        break;
+      }
+    }
+  }
+  return { value: { ir: nextIR, loweringHints: hints }, mutations };
+}
+var LATENCY_OVERAGE_WEIGHT = 0.6;
+var LATENCY_PENALTY_CAP = 1;
+var QUALITY_GATE_PENALTY = 4;
+var PROMOTION_BOOST = 5;
+function effectiveConventions(profile) {
+  const own = profile.archetypeConventions ?? [];
+  if (own.length > 0) return own;
+  const family = profile.family ?? deriveFamilyFromModelId(profile.id);
+  if (!family) return [];
+  const repId = familyRepId(family);
+  if (!repId || repId === profile.id) return [];
+  const rep = tryGetProfile(repId);
+  return rep?.archetypeConventions ?? [];
+}
+function passScoreTargets(ir, opts) {
+  const constraints = ir.constraints ?? {};
+  const policy = opts.policy ?? {};
+  const blockedSet = canonicalPolicySet(policy.blockedModels);
+  const preferredSet = canonicalPolicySet(policy.preferredModels);
+  const scores = [];
+  const policyMutations = [];
+  const rawPromotion = opts.promotion;
+  const promotionDeferred = rawPromotion !== void 0 && (policy.preferredModels?.length ?? 0) > 0;
+  const promotion = promotionDeferred ? void 0 : rawPromotion;
+  const modelIds = ir.models.filter((m) => typeof m === "string");
+  for (const modelId of modelIds) {
+    let profile;
+    try {
+      profile = opts.profilesById(modelId);
+    } catch {
+      scores.push({
+        modelId,
+        estimatedCostUsd: 0,
+        fits: false,
+        rejectReasons: ["unknown_model_id"],
+        qualityScore: 0,
+        rank: -Infinity
+      });
+      continue;
+    }
+    const reasons = [];
+    if (policySetHas(blockedSet, modelId)) {
+      reasons.push(`blocked_by_policy (consumer gated this model \u2014 see CompilePolicy.blockedModels)`);
+    }
+    if (opts.estimatedInputTokens > profile.maxContextTokens * 0.9) {
+      reasons.push(`exceeds context budget (${opts.estimatedInputTokens} > 0.9*${profile.maxContextTokens})`);
+    }
+    if ((ir.tools?.length ?? 0) > profile.maxTools) {
+      reasons.push(`exceeds maxTools (${ir.tools?.length} > ${profile.maxTools})`);
+    }
+    if (constraints.structuredOutput && profile.structuredOutput === "none") {
+      reasons.push(`structuredOutput requested but model has none`);
+    }
+    let qualityPenalty = 0;
+    for (const cliff of profile.cliffs) {
+      if (cliff.action !== "downgrade_quality_warning") continue;
+      let triggered = false;
+      if (cliff.metric === "input_tokens") triggered = opts.estimatedInputTokens >= cliff.threshold;
+      if (cliff.metric === "tool_count") triggered = (ir.tools?.length ?? 0) >= cliff.threshold;
+      if (triggered) qualityPenalty += 0.3;
+    }
+    const estimatedCostUsd = opts.estimatedInputTokens / 1e6 * profile.costInputPer1m;
+    if (policy.maxCostPerCallUsd !== void 0 && estimatedCostUsd > policy.maxCostPerCallUsd) {
+      reasons.push(
+        `exceeds_max_cost_per_call (estimated $${estimatedCostUsd.toFixed(4)} > policy ceiling $${policy.maxCostPerCallUsd.toFixed(4)})`
+      );
+    }
+    const baseQuality = profile.strengths.includes("reasoning") ? 0.85 : profile.strengths.includes("quality") ? 0.8 : 0.6;
+    const qualityScore = Math.max(0, baseQuality - qualityPenalty);
+    const callerOrderBoost = (modelIds.length - modelIds.indexOf(modelId)) * 0.1;
+    const costPenalty = estimatedCostUsd * 5;
+    const preferredBoost = policySetHas(preferredSet, modelId) ? 0.5 : 0;
+    let latencyPenalty = 0;
+    const maxLatencyMs = constraints.maxLatencyMs;
+    if (typeof maxLatencyMs === "number" && maxLatencyMs > 0) {
+      const tierMs = LATENCY_TIER_MS[latencyTierOf(profile)];
+      if (tierMs > maxLatencyMs) {
+        const overage = (tierMs - maxLatencyMs) / maxLatencyMs;
+        latencyPenalty = Math.min(LATENCY_OVERAGE_WEIGHT * overage, LATENCY_PENALTY_CAP);
+      }
+    }
+    let qualityGatePenalty = 0;
+    let structuredCliffGate;
+    if (constraints.structuredOutput) {
+      const schemaWeak = effectiveConventions(profile).some(
+        (c) => c.archetype === ir.intent.archetype && c.structuredOutputHint === "avoid"
+      );
+      if (schemaWeak) qualityGatePenalty = QUALITY_GATE_PENALTY;
+      if (!schemaWeak) {
+        structuredCliffGate = profile.cliffs.find(
+          (c) => c.action === "quality_gate_structured" && (!c.whenIntent || c.whenIntent === ir.intent.archetype) && c.metric === "input_tokens" && opts.estimatedInputTokens >= c.threshold
+        );
+        if (structuredCliffGate) qualityGatePenalty = QUALITY_GATE_PENALTY;
+      }
+    }
+    const measuredGate = opts.measuredFailureGates?.get(modelId);
+    if (measuredGate) qualityGatePenalty = QUALITY_GATE_PENALTY;
+    const isPromoted = promotion?.mode === "downswap" && promotion.promotedModel === modelId;
+    if (isPromoted && promotion.suppressQualityGate && !measuredGate) {
+      qualityGatePenalty = 0;
+    }
+    const promotionNeutralized = isPromoted && !!measuredGate;
+    const promotionBoost = isPromoted && !measuredGate ? PROMOTION_BOOST : 0;
+    const rank = qualityScore + callerOrderBoost - costPenalty - reasons.length * 10 + preferredBoost - latencyPenalty - qualityGatePenalty + promotionBoost;
+    scores.push({
+      modelId,
+      estimatedCostUsd,
+      fits: reasons.length === 0,
+      rejectReasons: reasons,
+      qualityScore,
+      rank
+    });
+    if (blockedSet.has(modelId)) {
+      policyMutations.push({
+        id: `policy-blocked-${modelId}`,
+        source: "compile_policy",
+        passName: "score_targets",
+        description: `Model ${modelId} excluded by CompilePolicy.blockedModels`
+      });
+    }
+    if (policy.maxCostPerCallUsd !== void 0 && estimatedCostUsd > policy.maxCostPerCallUsd && !blockedSet.has(modelId)) {
+      policyMutations.push({
+        id: `policy-over-cost-${modelId}`,
+        source: "compile_policy",
+        passName: "score_targets",
+        description: `Model ${modelId} excluded \u2014 estimated cost $${estimatedCostUsd.toFixed(4)} exceeds policy ceiling $${policy.maxCostPerCallUsd.toFixed(4)}`
+      });
+    }
+    if (policySetHas(preferredSet, modelId) && reasons.length === 0) {
+      policyMutations.push({
+        id: `policy-preferred-${modelId}`,
+        source: "compile_policy",
+        passName: "score_targets",
+        description: `Model ${modelId} rank boosted by CompilePolicy.preferredModels`
+      });
+    }
+    if (latencyPenalty > 0) {
+      const tier = latencyTierOf(profile);
+      policyMutations.push({
+        id: `latency-downrank-${modelId}`,
+        source: "latency_guard",
+        passName: "score_targets",
+        description: `Model ${modelId} rank down ${latencyPenalty.toFixed(2)} \u2014 latency tier '${tier}' (~${LATENCY_TIER_MS[tier]}ms) exceeds constraints.maxLatencyMs (${maxLatencyMs}ms)`
+      });
+    }
+    if (qualityGatePenalty > 0) {
+      const rankBefore = rank + qualityGatePenalty;
+      if (measuredGate) {
+        const pct = (x) => `${(x * 100).toFixed(0)}%`;
+        policyMutations.push({
+          id: `quality-gate-measured-${modelId}`,
+          source: "quality_gate",
+          passName: "score_targets",
+          rankDelta: -qualityGatePenalty,
+          rankBefore,
+          rankAfter: rank,
+          description: `Model ${modelId} gated below the quality floor for archetype '${ir.intent.archetype}' by MEASURED evidence from this app's own outcomes \u2014 ${measuredGate.nFail} of ${measuredGate.n} attempts failed on the quality axis in the trailing window (${pct(measuredGate.rate)}; 95% lower bound ${pct(measuredGate.lowerBound)} > 50%). Rank ${rankBefore.toFixed(2)} \u2192 ${rank.toFixed(2)} (\u2212${qualityGatePenalty.toFixed(2)}). Down-ranked out of leadership; retained as graceful fallback only. The gate is derived, not stored \u2014 it lifts on its own once the failures age out of the window.`
+        });
+      } else if (structuredCliffGate) {
+        policyMutations.push({
+          id: `quality-gate-structured-cliff-${modelId}`,
+          source: "quality_gate",
+          passName: "score_targets",
+          rankDelta: -qualityGatePenalty,
+          rankBefore,
+          rankAfter: rank,
+          description: `Model ${modelId} gated below the quality floor for archetype '${ir.intent.archetype}' \u2014 declared structuredOutput + input_tokens \u2265 ${structuredCliffGate.threshold} trips a measured cliff: ${structuredCliffGate.reason} Rank ${rankBefore.toFixed(2)} \u2192 ${rank.toFixed(2)} (\u2212${qualityGatePenalty.toFixed(2)}). Down-ranked out of leadership; retained as graceful fallback only. Bundled knowledge \u2014 active on cold isolates with no brain.`
+        });
+      } else {
+        policyMutations.push({
+          id: `quality-gate-structured-${modelId}`,
+          source: "quality_gate",
+          passName: "score_targets",
+          rankDelta: -qualityGatePenalty,
+          rankBefore,
+          rankAfter: rank,
+          description: `Model ${modelId} gated below the quality floor for archetype '${ir.intent.archetype}' \u2014 declared structuredOutput + kgauto convention flags it schema-weak for this contract (structuredOutputHint:'avoid'). Rank ${rankBefore.toFixed(2)} \u2192 ${rank.toFixed(2)} (\u2212${qualityGatePenalty.toFixed(2)}). Down-ranked out of leadership; retained as graceful fallback only.`
+        });
+      }
+    }
+    if (promotionNeutralized && reasons.length === 0) {
+      policyMutations.push({
+        id: `promotion-neutralized-${modelId}`,
+        source: "surface_promotion",
+        passName: "score_targets",
+        description: `Active promotion #${promotion.id} for ${modelId} NOT applied \u2014 the surface's own measured evidence contradicts it (${measuredGate.nFail}/${measuredGate.n} attempts failed in the trailing window). A promotion rests on an eval at promote time; this rests on what the surface is doing now, and the fresher evidence wins. The 7-day rollback guard is expected to retire this promotion on its next run.`
+      });
+    } else if (isPromoted && reasons.length === 0) {
+      policyMutations.push({
+        id: `promotion-applied-${modelId}`,
+        source: "surface_promotion",
+        passName: "score_targets",
+        description: `Model ${modelId} boosted to surface leadership by active promotion #${promotion.id} (golden-eval run ${promotion.evalRunId ?? "n/a"}, Stage 2 auto-promote, 7-day rollback guard)` + (promotion.suppressQualityGate ? " \u2014 schema-weak quality gate suppressed for this tuple (eval measured the floor holding on real workload)" : "")
+      });
+    }
+  }
+  if (promotionDeferred && rawPromotion && modelIds.includes(rawPromotion.promotedModel)) {
+    policyMutations.push({
+      id: `promotion-deferred-consumer-preference-${rawPromotion.promotedModel}`,
+      source: "surface_promotion",
+      passName: "score_targets",
+      description: `Active promotion #${rawPromotion.id} for ${rawPromotion.promotedModel} deferred \u2014 CompilePolicy.preferredModels is declared and explicit consumer preference outranks brain evidence.`
+    });
+  }
+  return { value: scores, mutations: policyMutations };
+}
+function computeShape(ir, estimatedInputTokens) {
+  return {
+    contextBucket: bucketContext(estimatedInputTokens),
+    toolCountBucket: bucketToolCount(ir.tools?.length ?? 0),
+    historyDepth: bucketHistory(ir.history?.length ?? 0),
+    outputMode: resolveOutputMode({
+      declared: ir.constraints?.outputMode,
+      structuredOutput: ir.constraints?.structuredOutput,
+      toolCount: ir.tools?.length ?? 0
+    }),
+    hasExamples: ir.sections.some((s) => /\bexample\b/i.test(s.id))
+  };
+}
+function estimateInputTokens(ir) {
+  const sectionTokens = ir.sections.reduce((sum, s) => sum + countTokens(s.text), 0);
+  const toolTokens = (ir.tools ?? []).reduce((sum, t) => sum + countToolTokens(t), 0);
+  const historyTokens = countMessagesTokens(ir.history ?? []);
+  const turnTokens = ir.currentTurn ? countTokens(ir.currentTurn.content) + 4 : 0;
+  return sectionTokens + toolTokens + historyTokens + turnTokens + 6;
+}
+function simpleHash(s) {
+  let h = 5381;
+  for (let i = 0; i < s.length; i++) {
+    h = (h << 5) + h + s.charCodeAt(i) | 0;
+  }
+  return (h >>> 0).toString(36);
+}
+function resolveConventionsForProfile(profile) {
+  const own = profile.archetypeConventions ?? [];
+  const family = profile.family ?? deriveFamilyFromModelId(profile.id);
+  if (!family) return own;
+  return own;
+}
+function applyArchetypeConvention(promptText, archetype, family) {
+  if (typeof promptText !== "string" || promptText.length === 0) return promptText;
+  const repId = familyRepId(family);
+  if (!repId) return promptText;
+  const profile = tryGetProfile(repId);
+  if (!profile || !profile.archetypeConventions) return promptText;
+  const conventions = profile.archetypeConventions.filter((c) => c.archetype === archetype);
+  if (conventions.length === 0) return promptText;
+  let next = promptText;
+  for (const c of conventions) {
+    if (c.promptPrefix) {
+      if (!next.startsWith(c.promptPrefix)) {
+        next = c.promptPrefix + next;
+      }
+    }
+    if (c.promptSuffix) {
+      if (!next.endsWith(c.promptSuffix)) {
+        next = next + c.promptSuffix;
+      }
+    }
+  }
+  return next;
+}
+function familyRepId(family) {
+  switch (family) {
+    case "deepseek-reasoner":
+      return "deepseek-v4-pro";
+    case "deepseek-chat":
+      return "deepseek-v4-flash";
+    default:
+      return void 0;
+  }
+}
+function passApplyConventions(ir, profile) {
+  const mutations = [];
+  const cliffWarnings = [];
+  const structuredOutputHints = [];
+  const own = profile.archetypeConventions ?? [];
+  let effective = own;
+  if (effective.length === 0) {
+    const family2 = profile.family ?? deriveFamilyFromModelId(profile.id);
+    if (family2) {
+      const repId = familyRepId(family2);
+      if (repId && repId !== profile.id) {
+        const repProfile = tryGetProfile(repId);
+        if (repProfile && repProfile.archetypeConventions) {
+          effective = repProfile.archetypeConventions;
+        }
+      }
+    }
+  }
+  if (effective.length === 0) {
+    return {
+      value: { ir, cliffWarnings, structuredOutputHints },
+      mutations
+    };
+  }
+  const archetype = ir.intent.archetype;
+  const matching = effective.filter((c) => c.archetype === archetype);
+  if (matching.length === 0) {
+    return {
+      value: { ir, cliffWarnings, structuredOutputHints },
+      mutations
+    };
+  }
+  const family = profile.family ?? deriveFamilyFromModelId(profile.id) ?? "unknown";
+  let nextIR = ir;
+  for (const convention of matching) {
+    let touched = false;
+    if (convention.promptPrefix) {
+      const sections = nextIR.sections ?? [];
+      const alreadyPresent = sections.some(
+        (s) => s.text.includes(convention.promptPrefix)
+      );
+      if (!alreadyPresent) {
+        const prefixSection = {
+          id: `convention-prefix-${family}-${archetype}`,
+          text: convention.promptPrefix
+        };
+        nextIR = { ...nextIR, sections: [prefixSection, ...sections] };
+        touched = true;
+      }
+    }
+    if (convention.promptSuffix) {
+      const history = nextIR.history ?? [];
+      let lastUserIdx = -1;
+      for (let i = history.length - 1; i >= 0; i--) {
+        if (history[i]?.role === "user") {
+          lastUserIdx = i;
+          break;
+        }
+      }
+      if (lastUserIdx >= 0) {
+        const target = history[lastUserIdx];
+        if (!target.content.endsWith(convention.promptSuffix)) {
+          const newHistory = history.slice();
+          newHistory[lastUserIdx] = {
+            ...target,
+            content: target.content + convention.promptSuffix
+          };
+          nextIR = { ...nextIR, history: newHistory };
+          touched = true;
+        }
+      } else if (nextIR.currentTurn && nextIR.currentTurn.role === "user") {
+        const target = nextIR.currentTurn;
+        if (!target.content.endsWith(convention.promptSuffix)) {
+          nextIR = {
+            ...nextIR,
+            currentTurn: {
+              ...target,
+              content: target.content + convention.promptSuffix
+            }
+          };
+          touched = true;
+        }
+      } else {
+        nextIR = {
+          ...nextIR,
+          currentTurn: {
+            role: "user",
+            content: convention.promptSuffix.trim()
+          }
+        };
+        touched = true;
+      }
+    }
+    if (convention.structuredOutputHint) {
+      const wantsStructured = !!nextIR.constraints?.structuredOutput;
+      const shouldSurface = convention.structuredOutputHint === "avoid" && wantsStructured || convention.structuredOutputHint === "enforce" && !wantsStructured;
+      if (shouldSurface) {
+        structuredOutputHints.push({
+          archetype,
+          hint: convention.structuredOutputHint,
+          reason: convention.reason
+        });
+        if (convention.cliffWarning) {
+          cliffWarnings.push(`${profile.id}: ${convention.cliffWarning}`);
+        }
+        touched = true;
+      }
+    }
+    if (convention.cliffWarning && !convention.structuredOutputHint) {
+      const toolCount = nextIR.tools?.length ?? 0;
+      const thresholdOk = convention.whenToolCountAtLeast === void 0 || toolCount >= convention.whenToolCountAtLeast;
+      if (thresholdOk) {
+        cliffWarnings.push(`${profile.id}: ${convention.cliffWarning}`);
+        touched = true;
+      }
+    }
+    if (touched) {
+      mutations.push({
+        id: `apply-convention-${family}-${archetype}`,
+        source: "archetype_convention",
+        passName: "apply_conventions",
+        description: `${profile.id}: applied ${family}-family convention for archetype=${archetype} \u2014 ${convention.reason}`
+      });
+    }
+  }
+  return {
+    value: { ir: nextIR, cliffWarnings, structuredOutputHints },
+    mutations
+  };
+}
+
+// src/measured-failure-brain.ts
+function coerceCount(v) {
+  if (typeof v === "number") return Number.isFinite(v) ? v : null;
+  if (typeof v === "string") {
+    const n = Number(v);
+    return Number.isFinite(n) ? n : null;
+  }
+  return null;
+}
+function isRawFailureRow(x) {
+  if (!x || typeof x !== "object") return false;
+  const r = x;
+  return typeof r.intent_archetype === "string" && typeof r.model === "string" && (typeof r.n === "number" || typeof r.n === "string");
+}
+function mapRows(rows) {
+  const out = [];
+  for (const row of rows) {
+    if (!isRawFailureRow(row)) continue;
+    const n = coerceCount(row.n);
+    const nFail = coerceCount(row.n_fail) ?? 0;
+    if (n === null || n <= 0) continue;
+    out.push({
+      archetype: row.intent_archetype,
+      model: row.model,
+      n,
+      nFail
+    });
+  }
+  return out;
+}
+var MEASURED_FAILURE_CFG = {
+  /**
+   * Hard minimum attempts before ANY gate may be created. Guards against
+   * pathological tiny samples that the confidence bound alone would let
+   * through in edge cases. At 5-for-5 the bound clears the threshold; at
+   * 3-for-3 it does not, which is the behaviour we want (three failures is
+   * a bad day, five in a row is a pattern).
+   */
+  minSample: 5,
+  /**
+   * Gate when we are 95% confident the model fails MORE OFTEN THAN IT
+   * SUCCEEDS on this surface. Deliberately unarguable rather than tuned —
+   * a model that probably fails the majority of the time has no business
+   * leading a surface, whatever its declared scores say.
+   */
+  lowerBoundThreshold: 0.5,
+  /** 95% one-sided-ish confidence (standard two-sided z at α=0.05). */
+  z: 1.96,
+  /** Must match the view's window. Documented here for the advisory text. */
+  windowDays: 28
+};
+function wilsonLowerBound(failures, n, z = MEASURED_FAILURE_CFG.z) {
+  if (n <= 0) return 0;
+  const p = failures / n;
+  const z2 = z * z;
+  const denom = 1 + z2 / n;
+  const centre = p + z2 / (2 * n);
+  const margin = z * Math.sqrt(p * (1 - p) / n + z2 / (4 * n * n));
+  const lower2 = (centre - margin) / denom;
+  return lower2 < 0 ? 0 : lower2;
+}
+function mapMeasuredFailureRows(rows) {
+  return mapRows(rows);
+}
+function judgeMeasuredFailure(row, cfg = MEASURED_FAILURE_CFG) {
+  if (!row) return void 0;
+  const normalized = "nFail" in row && typeof row.n === "number" ? row : mapRows([row])[0];
+  if (!normalized || normalized.n < cfg.minSample) return void 0;
+  const lowerBound = wilsonLowerBound(normalized.nFail, normalized.n, cfg.z);
+  return {
+    gated: lowerBound > cfg.lowerBoundThreshold,
+    rate: normalized.nFail / normalized.n,
+    lowerBound,
+    n: normalized.n,
+    nFail: normalized.nFail
+  };
+}
+var snapshots2 = /* @__PURE__ */ new Map();
+function measuredFailureFreshness(appId) {
+  return snapshots2.get(appId)?.loaded ? "warm" : "cold";
+}
+var runtime2;
+var warnedOnce2 = false;
+var DEFAULT_MEASURED_FAILURE_ENDPOINT = "https://kgauto-dashboard.vercel.app/api/kgauto-v2/measured-failure";
+function isMeasuredFailureGateEnabledFromEnv(envSource) {
+  const env = envSource ?? (typeof process !== "undefined" && process.env ? process.env : {});
+  const raw = (env.KGAUTO_MEASURED_FAILURE_GATE ?? "").trim().toLowerCase();
+  return !(raw === "0" || raw === "false");
+}
+function configureMeasuredFailureBrain(rt) {
+  runtime2 = rt;
+  snapshots2.clear();
+  warnedOnce2 = false;
+}
+function isMeasuredFailureBrainActive() {
+  return runtime2 !== void 0;
+}
+function prefetchMeasuredFailure(appId) {
+  const rt = runtime2;
+  if (!rt || !appId) return void 0;
+  let snap = snapshots2.get(appId);
+  if (!snap) {
+    snap = { data: [], expiresAt: 0, refreshing: false };
+    snapshots2.set(appId, snap);
+  }
+  if (snap.expiresAt > Date.now()) return void 0;
+  const inflight = pendingRefreshes2.get(appId);
+  if (inflight) return inflight;
+  if (snap.refreshing) return void 0;
+  snap.refreshing = true;
+  void asyncRefresh2(rt, appId);
+  return pendingRefreshes2.get(appId);
+}
+async function awaitMeasuredFailureReady(appId, timeoutMs) {
+  if (!runtime2 || !appId) return;
+  const pending = prefetchMeasuredFailure(appId) ?? pendingRefreshes2.get(appId);
+  if (!(timeoutMs > 0)) return;
+  if (!pending) return;
+  let timer;
+  try {
+    await Promise.race([
+      pending,
+      new Promise((resolve) => {
+        timer = setTimeout(resolve, timeoutMs);
+      })
+    ]);
+  } catch {
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+function getMeasuredFailureVerdict(opts) {
+  const rt = runtime2;
+  if (!rt) return void 0;
+  const { appId, archetype, model } = opts;
+  if (!appId || !archetype || !model) return void 0;
+  let snap = snapshots2.get(appId);
+  if (!snap) {
+    snap = { data: [], expiresAt: 0, refreshing: false };
+    snapshots2.set(appId, snap);
+  }
+  const now = Date.now();
+  if (snap.expiresAt <= now && !snap.refreshing) {
+    snap.refreshing = true;
+    void asyncRefresh2(rt, appId);
+  }
+  const row = snap.data.find(
+    (r) => r.archetype === archetype && r.model === model
+  );
+  return judgeMeasuredFailure(row);
+}
+var pendingRefreshes2 = /* @__PURE__ */ new Map();
+async function asyncRefresh2(rt, appId) {
+  const promise = doRefresh2(rt, appId);
+  pendingRefreshes2.set(appId, promise);
+  try {
+    await promise;
+  } finally {
+    if (pendingRefreshes2.get(appId) === promise) {
+      pendingRefreshes2.delete(appId);
+    }
+  }
+}
+async function doRefresh2(rt, appId) {
+  const url = `${rt.endpoint}?app_id=${encodeURIComponent(appId)}`;
+  let snap = snapshots2.get(appId);
+  if (!snap) {
+    snap = { data: [], expiresAt: 0, refreshing: false };
+    snapshots2.set(appId, snap);
+  }
+  try {
+    const res = await rt.fetchImpl(url, { method: "GET" });
+    if (!res.ok) {
+      throw new Error(`measured-failure ${res.status}: ${res.statusText}`);
+    }
+    const body = await res.json();
+    if (runtime2 !== rt) return;
+    snap.data = Array.isArray(body) ? mapRows(body) : [];
+    snap.loaded = true;
+    snap.expiresAt = Date.now() + rt.ttlMs;
+    snap.refreshing = false;
+  } catch (err) {
+    if (runtime2 !== rt) return;
+    snap.refreshing = false;
+    snap.expiresAt = Date.now() + rt.ttlMs;
+    if (!warnedOnce2) {
+      warnedOnce2 = true;
+      (rt.onError ?? defaultOnError2)(err);
+    }
+  }
+}
+function defaultOnError2(err) {
+  console.warn(
+    "[kgauto] measured-failure fetch failed (gate inactive until next refresh):",
+    err
+  );
+}
+function _testResetMeasuredFailure() {
+  runtime2 = void 0;
+  snapshots2.clear();
+  pendingRefreshes2 = /* @__PURE__ */ new Map();
+  warnedOnce2 = false;
+}
+async function _testWaitForMeasuredFailureRefresh() {
+  const pending = Array.from(pendingRefreshes2.values());
+  if (pending.length > 0) await Promise.all(pending);
+}
+
+// src/promotions-brain.ts
+function isRawPromotionRow(x) {
+  if (!x || typeof x !== "object") return false;
+  const r = x;
+  return (typeof r.id === "number" || typeof r.id === "string") && typeof r.intent_archetype === "string" && typeof r.promoted_model === "string" && typeof r.incumbent_model === "string";
+}
+function coerceId(v) {
+  if (typeof v === "number") return Number.isFinite(v) ? v : null;
+  if (typeof v === "string") {
+    const n = Number(v);
+    return Number.isFinite(n) ? n : null;
+  }
+  return null;
+}
+function mapRowsToPromotions(rows) {
+  const out = [];
+  for (const row of 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),
+      suppressQualityGate: row.suppress_quality_gate === true,
+      promotedAt: typeof row.promoted_at === "string" ? row.promoted_at : "",
+      // Pre-.78 endpoints serve no status column and only active rows —
+      // defaulting to 'active' is exact, not optimistic.
+      status: row.status === "rolled_back" ? "rolled_back" : "active",
+      ...typeof row.rolled_back_at === "string" ? { rolledBackAt: row.rolled_back_at } : {},
+      ...typeof row.rollback_class === "string" ? { rollbackClass: row.rollback_class } : {}
+    });
+  }
+  return out;
+}
+var snapshots3 = /* @__PURE__ */ new Map();
+function promotionsFreshness(appId) {
+  return snapshots3.get(appId)?.loaded ? "warm" : "cold";
+}
+var runtime3;
+var warnedOnce3 = false;
+var DEFAULT_PROMOTIONS_ENDPOINT = "https://kgauto-dashboard.vercel.app/api/kgauto-v2/promotions";
+function isAutoPromoteEnabledFromEnv(envSource) {
+  const env = envSource ?? (typeof process !== "undefined" && process.env ? process.env : {});
+  const raw = (env.KGAUTO_AUTO_PROMOTE ?? "").trim().toLowerCase();
+  return raw === "1" || raw === "true";
+}
+function configurePromotionsBrain(rt) {
+  runtime3 = rt;
+  snapshots3.clear();
+  warnedOnce3 = false;
+}
+function isPromotionsBrainActive() {
+  return runtime3 !== void 0;
+}
+function getApplicablePromotion(opts) {
+  const rt = runtime3;
+  if (!rt) return void 0;
+  const appId = opts.appId;
+  if (!appId || !opts.archetype || !opts.mode) return void 0;
+  let snap = snapshots3.get(appId);
+  if (!snap) {
+    snap = { data: [], expiresAt: 0, refreshing: false };
+    snapshots3.set(appId, snap);
+  }
+  const now = Date.now();
+  const stale = snap.expiresAt <= now;
+  if (stale && !snap.refreshing) {
+    snap.refreshing = true;
+    void asyncRefresh3(rt, appId);
+  }
+  return snap.data.find(
+    (p) => p.status === "active" && p.archetype === opts.archetype && p.mode === opts.mode
+  );
+}
+var ROLLBACK_SUPPRESSION_WINDOW_DAYS = 28;
+function getRecentRollback(opts) {
+  const rt = runtime3;
+  if (!rt) return void 0;
+  if (!opts.appId || !opts.archetype || !opts.model) return void 0;
+  let snap = snapshots3.get(opts.appId);
+  if (!snap) {
+    snap = { data: [], expiresAt: 0, refreshing: false };
+    snapshots3.set(opts.appId, snap);
+  }
+  const now = opts.nowMs ?? Date.now();
+  if (snap.expiresAt <= now && !snap.refreshing) {
+    snap.refreshing = true;
+    void asyncRefresh3(rt, opts.appId);
+  }
+  const windowMs = (opts.windowDays ?? ROLLBACK_SUPPRESSION_WINDOW_DAYS) * 864e5;
+  return snap.data.find(
+    (p) => p.status === "rolled_back" && p.archetype === opts.archetype && p.promotedModel === opts.model && typeof p.rolledBackAt === "string" && now - Date.parse(p.rolledBackAt) <= windowMs
+  );
+}
+var pendingRefreshes3 = /* @__PURE__ */ new Map();
+async function asyncRefresh3(rt, appId) {
+  const promise = doRefresh3(rt, appId);
+  pendingRefreshes3.set(appId, promise);
+  try {
+    await promise;
+  } finally {
+    if (pendingRefreshes3.get(appId) === promise) {
+      pendingRefreshes3.delete(appId);
+    }
+  }
+}
+async function doRefresh3(rt, appId) {
+  const url = `${rt.endpoint}?app_id=${encodeURIComponent(appId)}&with_rollbacks=1`;
+  let snap = snapshots3.get(appId);
+  if (!snap) {
+    snap = { data: [], expiresAt: 0, refreshing: false };
+    snapshots3.set(appId, snap);
+  }
+  try {
+    const res = await rt.fetchImpl(url, { method: "GET" });
+    if (!res.ok) {
+      throw new Error(`promotions ${res.status}: ${res.statusText}`);
+    }
+    const body = await res.json();
+    if (runtime3 !== rt) return;
+    const rows = Array.isArray(body) ? mapRowsToPromotions(body) : [];
+    snap.data = rows;
+    snap.loaded = true;
+    snap.expiresAt = Date.now() + rt.ttlMs;
+    snap.refreshing = false;
+  } catch (err) {
+    if (runtime3 !== rt) return;
+    snap.refreshing = false;
+    snap.expiresAt = Date.now() + rt.ttlMs;
+    if (!warnedOnce3) {
+      warnedOnce3 = true;
+      (rt.onError ?? defaultOnError3)(err);
+    }
+  }
+}
+function defaultOnError3(err) {
+  console.warn(
+    "[kgauto] promotions fetch failed (promotion boost inactive until next refresh):",
+    err
+  );
+}
+function prefetchPromotions(appId) {
+  const rt = runtime3;
+  if (!rt || !appId) return void 0;
+  let snap = snapshots3.get(appId);
+  if (!snap) {
+    snap = { data: [], expiresAt: 0, refreshing: false };
+    snapshots3.set(appId, snap);
+  }
+  if (snap.expiresAt > Date.now()) return void 0;
+  const inflight = pendingRefreshes3.get(appId);
+  if (inflight) return inflight;
+  if (snap.refreshing) return void 0;
+  snap.refreshing = true;
+  void asyncRefresh3(rt, appId);
+  return pendingRefreshes3.get(appId);
+}
+async function awaitPromotionsReady(appId, timeoutMs) {
+  if (!runtime3 || !appId) return;
+  const pending = prefetchPromotions(appId) ?? pendingRefreshes3.get(appId);
+  if (!(timeoutMs > 0)) return;
+  if (!pending) return;
+  let timer;
+  try {
+    await Promise.race([
+      pending,
+      new Promise((resolve) => {
+        timer = setTimeout(resolve, timeoutMs);
+      })
+    ]);
+  } catch {
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+function _testResetPromotions() {
+  runtime3 = void 0;
+  snapshots3.clear();
+  pendingRefreshes3 = /* @__PURE__ */ new Map();
+  warnedOnce3 = false;
+}
+async function _testWaitForPromotionsRefresh() {
+  const pending = Array.from(pendingRefreshes3.values());
+  if (pending.length > 0) await Promise.all(pending);
+}
+
+// src/promote-ready-brain.ts
+function isRawPromoteReadyRow(x) {
+  if (!x || typeof x !== "object") return false;
+  const r = x;
+  return typeof r.intent_archetype === "string" && typeof r.family === "string" && typeof r.candidate_model === "string" && typeof r.current_model === "string" && typeof r.detected_at === "string";
+}
+function coerceNumber(v) {
+  if (typeof v === "number") return Number.isFinite(v) ? v : null;
+  if (typeof v === "string") {
+    const n = Number(v);
+    return Number.isFinite(n) ? n : null;
+  }
+  return null;
+}
+function mapRowsToFindings2(rows) {
+  const out = [];
+  for (const row of rows) {
+    if (!isRawPromoteReadyRow(row)) continue;
+    const sampleN = coerceNumber(row.sample_n);
+    const passRate = coerceNumber(row.judge_pass_rate);
+    const avgScore = coerceNumber(row.judge_avg_score);
+    if (sampleN === null || passRate === null || avgScore === null) continue;
+    out.push({
+      archetype: row.intent_archetype,
+      family: row.family,
+      candidateModel: row.candidate_model,
+      currentModel: row.current_model,
+      sampleN,
+      judgePassRate: passRate,
+      judgeAvgScore: avgScore,
+      costDeltaPct: coerceNumber(row.cost_delta_pct),
+      detectedAt: row.detected_at
+    });
+  }
+  return out;
+}
+var snapshots4 = /* @__PURE__ */ new Map();
+function promoteReadyFreshness(appId) {
+  return snapshots4.get(appId)?.loaded ? "warm" : "cold";
+}
+var runtime4;
+var warnedOnce4 = false;
+function isPromoteReadyBrainActive() {
+  return runtime4 !== void 0;
+}
+function loadPromoteReadyFindings(opts) {
+  const rt = runtime4;
+  if (!rt) return [];
+  const appId = opts.appId;
+  if (!appId) return [];
+  let snap = snapshots4.get(appId);
+  if (!snap) {
+    snap = { data: [], expiresAt: 0, refreshing: false };
+    snapshots4.set(appId, snap);
+  }
+  const now = Date.now();
+  const stale = snap.expiresAt <= now;
+  if (stale && !snap.refreshing) {
+    snap.refreshing = true;
+    void asyncRefresh4(rt, appId);
+  }
+  let rows = snap.data;
+  if (opts.archetype) {
+    rows = rows.filter((f) => f.archetype === opts.archetype);
+  }
+  if (opts.family) {
+    rows = rows.filter((f) => f.family === opts.family);
+  }
+  return rows;
+}
+var pendingRefreshes4 = /* @__PURE__ */ new Map();
+async function asyncRefresh4(rt, appId) {
+  const promise = doRefresh4(rt, appId);
+  pendingRefreshes4.set(appId, promise);
+  try {
+    await promise;
+  } finally {
+    if (pendingRefreshes4.get(appId) === promise) {
+      pendingRefreshes4.delete(appId);
+    }
+  }
+}
+async function doRefresh4(rt, appId) {
+  const url = `${rt.endpoint}?app_id=${encodeURIComponent(appId)}`;
+  let snap = snapshots4.get(appId);
+  if (!snap) {
+    snap = { data: [], expiresAt: 0, refreshing: false };
+    snapshots4.set(appId, snap);
+  }
+  try {
+    const res = await rt.fetchImpl(url, { method: "GET" });
+    if (!res.ok) {
+      throw new Error(`promote-ready ${res.status}: ${res.statusText}`);
+    }
+    const body = await res.json();
+    if (runtime4 !== rt) return;
+    const rows = Array.isArray(body) ? mapRowsToFindings2(body) : [];
+    snap.data = rows;
+    snap.loaded = true;
+    snap.expiresAt = Date.now() + rt.ttlMs;
+    snap.refreshing = false;
+  } catch (err) {
+    if (runtime4 !== rt) return;
+    snap.refreshing = false;
+    snap.expiresAt = Date.now() + rt.ttlMs;
+    if (!warnedOnce4) {
+      warnedOnce4 = true;
+      (rt.onError ?? defaultOnError4)(err);
+    }
+  }
+}
+function defaultOnError4(err) {
+  console.warn(
+    "[kgauto] promote-ready fetch failed (using empty fallback):",
+    err
+  );
+}
+function resolveFetchImpl(injected) {
+  return injected ?? ((...args) => globalThis.fetch(...args));
+}
+function normalizeEndpoint(endpoint) {
+  return endpoint.replace(/\/+$/, "");
+}
+async function markPromoteReadyHandled(opts) {
+  const {
+    appId,
+    archetype,
+    family,
+    resolution,
+    resolutionNote,
+    brainEndpoint,
+    brainJwt,
+    brainAnonKey,
+    fetch: injectedFetch
+  } = opts;
+  if (!appId) return { ok: false, reason: "app_id_required" };
+  if (!archetype) return { ok: false, reason: "archetype_required" };
+  if (!family) return { ok: false, reason: "family_required" };
+  if (resolution !== "promoted" && resolution !== "declined" && resolution !== "still-evaluating") {
+    return { ok: false, reason: "resolution_invalid" };
+  }
+  const doFetch = resolveFetchImpl(injectedFetch);
+  const base = normalizeEndpoint(brainEndpoint);
+  const url = `${base}/rest/v1/promote_ready_findings?app_id=eq.${encodeURIComponent(appId)}&intent_archetype=eq.${encodeURIComponent(archetype)}&family=eq.${encodeURIComponent(family)}&resolved_at=is.null`;
+  const patchBody = {
+    resolved_at: (/* @__PURE__ */ new Date()).toISOString(),
+    resolution
+  };
+  if (resolutionNote !== void 0) {
+    patchBody.resolution_note = resolutionNote;
+  }
+  let res;
+  try {
+    res = await doFetch(url, {
+      method: "PATCH",
+      headers: {
+        Authorization: `Bearer ${brainJwt}`,
+        apikey: brainAnonKey,
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        Prefer: "return=minimal"
+      },
+      body: JSON.stringify(patchBody)
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { ok: false, reason: `network_error:${msg}` };
+  }
+  if (res.status === 401 || res.status === 403) {
+    return { ok: false, reason: "brain_auth_misconfig" };
+  }
+  if (res.status >= 500) {
+    return { ok: false, reason: "brain_unavailable" };
+  }
+  if (!res.ok) {
+    return { ok: false, reason: `patch_failed:${res.status}` };
+  }
+  return { ok: true };
+}
+
+// src/archetype-fits.ts
+var ARCHETYPE_FAMILY_FITS = Object.freeze([
+  {
+    archetype: "plan",
+    betterFitFamily: "deepseek-reasoner",
+    reason: "Plan archetype is reasoning-shaped (multi-step chains, hypothesis-and-check, sub-goal decomposition) \u2014 exactly where reasoner-family models excel. Sonnet/Opus produce plans but at higher cost; reasoners produce equivalent-or-better plans at 7-17x lower cost at current promo pricing (deepseek-v4-pro $0.435/$0.87 per 1M promo through 2026-05-31 vs sonnet $3/$15).",
+    costGuidance: "substantially cheaper at current pricing (deepseek-v4-pro promo: ~7-17x cheaper than sonnet)"
+  },
+  {
+    archetype: "critique",
+    betterFitFamily: "deepseek-reasoner",
+    reason: "Critique archetype rewards epistemic humility and explicit reasoning \u2014 reasoner-family default behavior. Sonnet/Opus over-confident on critique tasks; reasoners surface uncertainty productively.",
+    costGuidance: "comparable or cheaper at current pricing"
+  }
+]);
+function findBetterFit(archetype, currentFamily) {
+  for (const fit of ARCHETYPE_FAMILY_FITS) {
+    if (fit.archetype !== archetype) continue;
+    if (fit.betterFitFamily === currentFamily) return null;
+    return fit;
+  }
+  return null;
+}
+
+// src/advisor-rules/blocked-model-drift.ts
+var BLOCKED_MODEL_NOT_IN_ROSTER_CODE = "blocked-model-not-in-roster";
+var BLOCKED_MODEL_FAMILY_SIBLING_SERVED_CODE = "blocked-model-family-sibling-served";
+var DOCS_URL = "https://github.com/stue/command-center/blob/main/interfaces/kgauto.md#best-practice-advisories";
+function familyOf2(modelId, profile) {
+  return profile?.family ?? deriveFamilyFromModelId(modelId);
+}
+function isOnTheWayOut(status) {
+  return status === "legacy" || status === "deprecated";
+}
+function advisorRuleBlockedModelDrift(ctx) {
+  const blocked = ctx.policy?.blockedModels;
+  if (!blocked || blocked.length === 0) return [];
+  const resolve = ctx.resolveProfile ?? tryGetProfile;
+  const out = [];
+  const entries = [...new Set(blocked)].sort();
+  const selectedProfile = resolve(ctx.selectedModelId);
+  const selectedFamily = familyOf2(ctx.selectedModelId, selectedProfile);
+  const orphans = entries.filter((e) => resolve(e) === void 0);
+  if (orphans.length > 0) {
+    const list = orphans.map((o) => `\`${o}\``).join(", ");
+    const plural = orphans.length === 1 ? "entry" : "entries";
+    const verb = orphans.length === 1 ? "matches" : "match";
+    out.push({
+      level: "warn",
+      code: BLOCKED_MODEL_NOT_IN_ROSTER_CODE,
+      message: `CompilePolicy.blockedModels ${plural} ${list} ${verb} no model in the current roster, so ${orphans.length === 1 ? "it is" : "they are"} inert \u2014 \`blockedModels\` is matched by exact model id, and nothing kgauto can select carries ${orphans.length === 1 ? "that id" : "those ids"}. The block will never fire.`,
+      suggestion: `Check for a typo, or for an id that was retired from the roster since the block was written. This is how a block goes quiet without an error: tt-intel (2026-07-29) carried \`KGAUTO_BLOCKED_MODELS="claude-sonnet-4-6"\` across a roster retarget and the block stopped covering the traffic they believed it covered. Resolve the intended model id against the live roster \u2014 \`getRecommendedPrimary({ family, fallback })\` returns the id the family currently resolves to \u2014 and block that id, or drop the entry if it is no longer needed.`,
+      docsUrl: DOCS_URL
+    });
+  }
+  if (selectedFamily !== null) {
+    const siblings = entries.filter((e) => {
+      if (resolveModelAlias(e) === resolveModelAlias(ctx.selectedModelId)) return false;
+      const p = resolve(e);
+      if (familyOf2(e, p) !== selectedFamily) return false;
+      if (p && selectedProfile && p.provider !== selectedProfile.provider) {
+        return false;
+      }
+      return true;
+    });
+    if (siblings.length > 0) {
+      const list = siblings.map((s) => `\`${s}\``).join(", ");
+      const plural = siblings.length === 1 ? "" : "s";
+      const retargetShaped = siblings.some((s) => {
+        const p = resolve(s);
+        return isOnTheWayOut(p?.status) && selectedProfile?.status === "current";
+      });
+      const retargetNote = retargetShaped ? ` The blocked id${plural} ${siblings.length === 1 ? "is" : "are"} legacy/deprecated while \`${ctx.selectedModelId}\` is current \u2014 that is the signature of a roster lifecycle move rather than a deliberate per-generation block, so this is more likely to be drift than intent.` : "";
+      out.push({
+        level: "warn",
+        code: BLOCKED_MODEL_FAMILY_SIBLING_SERVED_CODE,
+        message: `\`${ctx.selectedModelId}\` was selected for this call. It is in the same family (\`${selectedFamily}\`) as blocked entr${siblings.length === 1 ? "y" : "ies"} ${list}, but its exact id differs \u2014 and \`CompilePolicy.blockedModels\` matches by exact id, so the block does not cover it.${retargetNote}`,
+        suggestion: `Two readings, and kgauto cannot tell them apart: (1) intentional \u2014 you meant to gate that specific id and \`${ctx.selectedModelId}\` is fine, in which case nothing needs doing and you can filter this code; (2) drift \u2014 you meant to gate the family, and a roster change moved traffic to a sibling your block never named. This happened to tt-intel: when the \`claude-sonnet\` family primary retargeted from \`claude-sonnet-4-6\` to \`claude-sonnet-5\`, their literal-id gate stopped matching the family's routed traffic (their fix was local family resolution). If you meant the family, add \`${ctx.selectedModelId}\` to \`blockedModels\` \u2014 kgauto deliberately does NOT widen exact-id blocks into family globs, because that would silently change what every existing block covers.`,
+        docsUrl: DOCS_URL
+      });
+    }
+  }
+  return out;
+}
+
+// src/advisor-rules/promote-ready.ts
+var PROMOTE_READY_THRESHOLDS = {
+  minPassRate: 0.8,
+  minAvgScore: 4
+};
+function shouldFirePromoteReady(finding, resolvedPrimary) {
+  if (finding.currentModel !== resolvedPrimary) return false;
+  if (finding.judgePassRate < PROMOTE_READY_THRESHOLDS.minPassRate) return false;
+  if (finding.judgeAvgScore < PROMOTE_READY_THRESHOLDS.minAvgScore) return false;
+  return true;
+}
+function deriveFamilyLocal(modelId) {
+  if (modelId.startsWith("claude-opus-")) return "claude-opus";
+  if (modelId.startsWith("claude-sonnet-")) return "claude-sonnet";
+  if (modelId.startsWith("claude-haiku-")) return "claude-haiku";
+  if (/^gemini-.*-flash-lite/.test(modelId)) return "gemini-flash-lite";
+  if (/^gemini-.*-flash/.test(modelId)) return "gemini-flash";
+  if (/^gemini-.*-pro/.test(modelId)) return "gemini-pro";
+  if (/^deepseek-.*-pro/.test(modelId)) return "deepseek-reasoner";
+  if (modelId.startsWith("deepseek-")) return "deepseek-chat";
+  if (modelId.startsWith("gpt-")) return "openai-gpt";
+  return null;
+}
+function advisorRulePromoteReady(ctx) {
+  if (!isPromoteReadyBrainActive()) return [];
+  if (!ctx.appId) return [];
+  if (!ctx.resolvedPrimary) return [];
+  const family = deriveFamilyLocal(ctx.resolvedPrimary);
+  if (!family) return [];
+  const findings = loadPromoteReadyFindings({
+    appId: ctx.appId,
+    archetype: ctx.archetype,
+    family
+  });
+  if (findings.length === 0) return [];
+  const qualifying = findings.filter(
+    (f) => shouldFirePromoteReady(f, ctx.resolvedPrimary)
+  );
+  if (qualifying.length === 0) return [];
+  qualifying.sort((a, b) => {
+    if (a.judgeAvgScore !== b.judgeAvgScore) {
+      return b.judgeAvgScore - a.judgeAvgScore;
+    }
+    return b.judgePassRate - a.judgePassRate;
+  });
+  const top = qualifying[0];
+  const pctPass = Math.round(top.judgePassRate * 100);
+  const score = top.judgeAvgScore.toFixed(2);
+  let costClause = "";
+  if (top.costDeltaPct !== null) {
+    const sign = top.costDeltaPct < 0 ? "cheaper" : "more expensive";
+    const magnitude = Math.abs(top.costDeltaPct * 100).toFixed(1);
+    costClause = `, cost ${magnitude}% ${sign}`;
+  }
+  const message = `Probe found ${top.candidateModel} produces equivalent-or-better outputs vs ${top.currentModel} on ${top.sampleN} recent ${top.archetype} prompts (pass rate ${pctPass}%, avg score ${score}/5${costClause}). Consider promoting via markPromoteReadyHandled.`;
+  return [
+    {
+      level: "info",
+      code: "promote-ready",
+      message,
+      suggestion: `Migrate ${top.archetype} traffic from ${top.currentModel} to ${top.candidateModel}, then call markPromoteReadyHandled({ appId, archetype: '${top.archetype}', family: '${top.family}', resolution: 'promoted' }) to silence this advisory.`,
+      // alpha.36 architectural field — not a no-ai-needed case.
+      recommendedArchitecture: void 0,
+      docsUrl: "https://github.com/stue/command-center/blob/main/interfaces/kgauto.md#best-practice-advisories"
+    }
+  ];
+}
+
+// src/advisor-rules/consumer-on-stale-model.ts
+function isStaleStatus(v) {
+  return v === "legacy" || v === "deprecated";
+}
+function asString(v) {
+  return typeof v === "string" && v.length > 0 ? v : void 0;
+}
+function mapRowsToFindings3(rows) {
+  const out = [];
+  for (const raw of rows) {
+    if (!raw || typeof raw !== "object") continue;
+    const r = raw;
+    const archetype = asString(r.intent_archetype) ?? asString(r.applies_to_archetype);
+    const staleModel = asString(r.stale_model) ?? asString(r.applies_to_model);
+    const staleProvider = asString(r.stale_provider);
+    const recommendedModel = asString(r.recommended_model);
+    const family = asString(r.family);
+    const message = asString(r.message);
+    if (!archetype || !staleModel || !recommendedModel || !family || !message) {
+      continue;
+    }
+    if (!isStaleStatus(r.stale_status)) continue;
+    const row = {
+      archetype,
+      staleModel,
+      staleProvider: staleProvider ?? "unknown",
+      staleStatus: r.stale_status,
+      recommendedModel,
+      family,
+      message
+    };
+    const suggestion = asString(r.suggestion);
+    if (suggestion) row.suggestion = suggestion;
+    if (typeof r.observation_count === "number" && Number.isFinite(r.observation_count)) {
+      row.observationCount = r.observation_count;
+    }
+    out.push(row);
+  }
+  return out;
+}
+var snapshots5 = /* @__PURE__ */ new Map();
+var runtime5;
+var warnedOnce5 = false;
+var pendingRefreshes5 = /* @__PURE__ */ new Map();
+function isStaleModelFindingsBrainActive() {
+  return runtime5 !== void 0;
+}
+function getStaleModelFindings(opts) {
+  const rt = runtime5;
+  if (!rt) return [];
+  const appId = opts.appId;
+  if (!appId) return [];
+  let snap = snapshots5.get(appId);
+  if (!snap) {
+    snap = { data: [], expiresAt: 0, refreshing: false };
+    snapshots5.set(appId, snap);
+  }
+  const now = Date.now();
+  const stale = snap.expiresAt <= now;
+  if (stale && !snap.refreshing) {
+    snap.refreshing = true;
+    void asyncRefresh5(rt, appId);
+  }
+  if (opts.archetype) {
+    return snap.data.filter((f) => f.archetype === opts.archetype);
+  }
+  return snap.data;
+}
+async function asyncRefresh5(rt, appId) {
+  const promise = doRefresh5(rt, appId);
+  pendingRefreshes5.set(appId, promise);
+  try {
+    await promise;
+  } finally {
+    if (pendingRefreshes5.get(appId) === promise) {
+      pendingRefreshes5.delete(appId);
+    }
+  }
+}
+async function doRefresh5(rt, appId) {
+  const url = `${rt.endpoint}?app_id=${encodeURIComponent(appId)}`;
+  let snap = snapshots5.get(appId);
+  if (!snap) {
+    snap = { data: [], expiresAt: 0, refreshing: false };
+    snapshots5.set(appId, snap);
+  }
+  try {
+    const res = await rt.fetchImpl(url, { method: "GET" });
+    if (!res.ok) {
+      throw new Error(`stale-model findings ${res.status}: ${res.statusText}`);
+    }
+    const body = await res.json();
+    if (runtime5 !== rt) return;
+    const rows = Array.isArray(body) ? mapRowsToFindings3(body) : [];
+    snap.data = rows;
+    snap.expiresAt = Date.now() + rt.ttlMs;
+    snap.refreshing = false;
+  } catch (err) {
+    if (runtime5 !== rt) return;
+    snap.refreshing = false;
+    snap.expiresAt = Date.now() + rt.ttlMs;
+    if (!warnedOnce5) {
+      warnedOnce5 = true;
+      (rt.onError ?? defaultOnError5)(err);
+    }
+  }
+}
+function defaultOnError5(err) {
+  console.warn(
+    "[kgauto] stale-model findings fetch failed (using empty fallback):",
+    err
+  );
+}
+var CONSUMER_ON_STALE_MODEL_RULE_CODE = "consumer-on-stale-model";
+function advisorRuleConsumerOnStaleModel(ir) {
+  if (!isStaleModelFindingsBrainActive()) return [];
+  if (!ir.appId) return [];
+  const findings = getStaleModelFindings({
+    appId: ir.appId,
+    archetype: ir.intent.archetype
+  });
+  if (findings.length === 0) return [];
+  const ranked = [...findings].sort((a, b) => {
+    if (a.staleStatus !== b.staleStatus) {
+      return a.staleStatus === "deprecated" ? -1 : 1;
+    }
+    return a.staleModel.localeCompare(b.staleModel);
+  });
+  const top = ranked[0];
+  const extraCount = findings.length - 1;
+  const extraNote = extraCount > 0 ? ` (+ ${extraCount} more stale model${extraCount === 1 ? "" : "s"} for this archetype)` : "";
+  return [
+    {
+      level: "warn",
+      code: CONSUMER_ON_STALE_MODEL_RULE_CODE,
+      message: `${top.message}${extraNote}`,
+      suggestion: top.suggestion ?? `Migrate ${top.staleModel} \u2192 ${top.recommendedModel} for archetype "${top.archetype}". The newer model is the current latest in the "${top.family}" family; the stale one is ${top.staleStatus}.`,
+      recommendationType: "model-swap",
+      docsUrl: "https://github.com/stue/command-center/blob/main/interfaces/kgauto.md#best-practice-advisories"
+    }
+  ];
+}
+
+// src/advisor-rules/cross-family-fit.ts
+function familyHasCurrentActiveModel(family) {
+  for (const profile of allProfiles()) {
+    const profileFamily = profile.family ?? deriveFamilyFromModelId(profile.id);
+    if (profileFamily !== family) continue;
+    if (profile.status !== "current") continue;
+    if (profile.active === false) continue;
+    return true;
+  }
+  return false;
+}
+function listCandidatesInFamily(family) {
+  const candidates = [];
+  for (const profile of allProfiles()) {
+    const profileFamily = profile.family ?? deriveFamilyFromModelId(profile.id);
+    if (profileFamily !== family) continue;
+    if (profile.status !== "current") continue;
+    if (profile.active === false) continue;
+    candidates.push(profile.id);
+    if (candidates.length >= 3) break;
+  }
+  return candidates;
+}
+function advisorRuleCrossFamilyFit(ctx) {
+  if (!ctx.resolvedPrimary) return [];
+  const currentFamily = deriveFamilyFromModelId(ctx.resolvedPrimary);
+  if (!currentFamily) return [];
+  const fit = findBetterFit(ctx.archetype, currentFamily);
+  if (!fit) return [];
+  if (!familyHasCurrentActiveModel(fit.betterFitFamily)) return [];
+  const candidates = listCandidatesInFamily(fit.betterFitFamily);
+  if (candidates.length === 0) return [];
+  const candidateStr = candidates.join(", ");
+  const message = `Your ${currentFamily} call on ${ctx.archetype} could shift to ${fit.betterFitFamily} \u2014 typically better quality + ${fit.costGuidance}. Suggested candidates: ${candidateStr}.`;
+  return [
+    {
+      level: "info",
+      code: "cross-family-fit-candidate",
+      ownership: "consumer-actionable",
+      message,
+      suggestion: `Swap the model literal in \`ir.models\` to one of: ${candidateStr}. Or call \`getRecommendedPrimary({ family: '${fit.betterFitFamily}', archetype: '${ctx.archetype}', fallback: { id: '${candidates[0]}', reason: 'cross-family-fit-recommendation' } })\` to let kgauto resolve to the current+active family member.`,
+      recommendationType: "model-swap",
+      docsUrl: "https://github.com/stue/command-center/blob/main/interfaces/kgauto.md#best-practice-advisories"
+    }
+  ];
+}
+
+// src/advisor-rules/preferred-blocked-overlap.ts
+var PREFERRED_MODEL_BLOCKED_CODE = "preferred-model-blocked";
+var DOCS_URL2 = "https://github.com/stue/command-center/blob/main/interfaces/kgauto.md#best-practice-advisories";
+function advisorRulePreferredBlockedOverlap(ctx) {
+  const preferred = ctx.policy?.preferredModels;
+  const blocked = ctx.policy?.blockedModels;
+  if (!preferred?.length || !blocked?.length) return [];
+  const blockedSet = canonicalPolicySet(blocked);
+  const deadPins = [...new Set(preferred)].filter((p) => policySetHas(blockedSet, p)).sort();
+  if (deadPins.length === 0) return [];
+  const list = deadPins.map((p) => `\`${p}\``).join(", ");
+  const one = deadPins.length === 1;
+  const preferredSet = canonicalPolicySet(preferred);
+  const servedIsPinned = policySetHas(preferredSet, ctx.selectedModelId);
+  return [
+    {
+      level: "warn",
+      code: PREFERRED_MODEL_BLOCKED_CODE,
+      message: `CompilePolicy.preferredModels entr${one ? "y" : "ies"} ${list} ${one ? "is" : "are"} also in \`blockedModels\` (matched canonically, aliases included). A blocked model is hard-rejected before preference boosts apply, so ${one ? "this pin" : "these pins"} can never serve. ` + (servedIsPinned ? `This call was served by \`${ctx.selectedModelId}\`, which is itself a live pin \u2014 the dead entr${one ? "y is" : "ies are"} latent, not currently rerouting traffic.` : `Substitution is your steady state: this call landed on \`${ctx.selectedModelId}\`, which you did not pin.`),
+      suggestion: `Two readings, and kgauto cannot tell them apart: (1) intentional \u2014 your spend gate deliberately outranks the pin, in which case nothing needs doing and you can filter this code; (2) misconfiguration \u2014 the pin and the block were written at different times and the overlap is an accident. tt-intel hit reading (2) on 2026-08-01: a summarize site pinned \`claude-sonnet\` while \`KGAUTO_BLOCKED_MODELS\` carried the same family, and every call silently substituted a reasoning model whose reasoning burn exceeded the site's \`maxOutputTokens\` \u2014 100% empty payloads under HTTP 200. If the block should win, remove the pin so the policy says what it does. If the pin should win, remove ${one ? "the blocking entry" : "the blocking entries"} or re-scope the block to the exact ids you mean. Check what the substitute costs at your input shape while you are here \u2014 a spend gate that lands traffic on a pricier model than the one it blocked is a cost inversion, not a saving.`,
+      docsUrl: DOCS_URL2
+    }
+  ];
+}
+
+// src/advisor.ts
+var QUALITY_FLOOR_FOR_RECOMMENDATION = 6;
+var TIER_DOWN_COST_RATIO = 0.5;
+var COST_MISMATCHED_CHOSEN_SCORE_CEILING = 7;
+var PRODUCER_OWNED_RULE_CODES = Object.freeze(
+  /* @__PURE__ */ new Set(["model-stale-evidence", "promote-ready"])
+);
+function deriveOwnership(code, selfDeclared) {
+  if (selfDeclared) return selfDeclared;
+  return PRODUCER_OWNED_RULE_CODES.has(code) ? "producer-owned" : "consumer-actionable";
+}
+function runAdvisor(ir, result, profile, policy, phase2) {
+  const out = [];
+  out.push(...detectCachingOff(ir, profile));
+  out.push(...detectSingleChunkSystem(ir, profile));
+  out.push(...detectToolBloat(ir, result));
+  out.push(...detectHistoryUncached(ir, profile));
+  out.push(...detectSingleModelArray(ir, policy));
+  out.push(
+    ...advisorRuleBlockedModelDrift({
+      policy,
+      selectedModelId: profile.id
+    })
+  );
+  out.push(
+    ...advisorRulePreferredBlockedOverlap({
+      policy,
+      selectedModelId: profile.id
+    })
+  );
+  if (policy?.posture !== "locked") {
+    out.push(...detectCostMismatchedArchetype(ir, profile, phase2));
+    out.push(...detectModelStaleEvidence(ir, profile));
+    out.push(...detectTierDown(ir, profile, phase2));
+  }
+  if (!translatorClearedToolCallCliff(phase2)) {
+    out.push(...detectArchetypePerfFloorBreach(ir, profile));
+  }
+  if (policy?.posture !== "locked") {
+    out.push(...detectStaleExclusionCandidate(ir));
+  }
+  if (policy?.posture !== "locked" && ir.appId) {
+    out.push(
+      ...advisorRulePromoteReady({
+        appId: ir.appId,
+        archetype: ir.intent.archetype,
+        resolvedPrimary: profile.id
+      })
+    );
+    out.push(...advisorRuleConsumerOnStaleModel(ir));
+  }
+  if (policy?.posture !== "locked") {
+    out.push(
+      ...advisorRuleCrossFamilyFit({
+        archetype: ir.intent.archetype,
+        resolvedPrimary: profile.id
+      })
+    );
+  }
+  return out;
+}
+function translatorClearedToolCallCliff(phase2) {
+  const rewrites = phase2?.sectionRewritesApplied;
+  if (!rewrites || rewrites.length === 0) return false;
+  for (const rw of rewrites) {
+    if (rw.kind === "tool_call_contract") return true;
+  }
+  return false;
+}
+function detectCachingOff(ir, profile) {
+  if (profile.provider !== "anthropic") return [];
+  const totalChars = ir.sections.reduce((s, sec) => s + sec.text.length, 0);
+  if (totalChars < 2e3) return [];
+  const anyCacheable = ir.sections.some((s) => s.cacheable === true);
+  if (anyCacheable) return [];
+  return [
+    {
+      level: "warn",
+      code: "caching-off-on-claude",
+      message: `System prompt is ${totalChars} chars on Anthropic but no PromptSection has cacheable=true. Anthropic prompt caching cuts cached-prefix input cost by ~90% on subsequent calls; without it, every turn re-pays full price for the static system context.`,
+      suggestion: "Mark stable system sections (role, persona, tool policy) with `cacheable: true`. The lowering pass concatenates cacheable sections into a single cache-controlled block before the dynamic ones.",
+      docsUrl: "https://github.com/stue/command-center/blob/main/interfaces/kgauto.md#best-practice-advisories"
+    }
+  ];
+}
+function detectSingleChunkSystem(ir, profile) {
+  if (profile.provider !== "anthropic") return [];
+  if (ir.sections.length !== 1) return [];
+  const only = ir.sections[0];
+  if (!only || only.text.length <= 1e3) return [];
+  return [
+    {
+      level: "info",
+      code: "single-chunk-system",
+      message: `System prompt is a single ${only.text.length}-char chunk. Splitting into NamedChunks (static role/persona vs dynamic context) gives the lowering pass a finer cache-marker boundary \u2014 only the static portion needs to be byte-stable for the cache to hit.`,
+      suggestion: "Refactor the system builder to return an array of `PromptSection` shaped { id, text, cacheable?: boolean }. Static chunks (role, persona, tool policy) get `cacheable: true`; dynamic ones (current context, today's date) don't. NOTE: the lowering pass HOISTS cacheable sections ahead of dynamic ones on the Anthropic wire (prefix caching requires it) \u2014 if your prompt has a protected ordering (e.g. a voice/persona block that must precede boilerplate), splitting will reorder the compiled output; declining this advisory is then correct. Also: a cacheable block under ~1024 tokens gets NO cache_control marker (provider minimum), so marking small sections is inert, not harmful.",
+      docsUrl: "https://github.com/stue/command-center/blob/main/interfaces/kgauto.md#best-practice-advisories"
+    }
+  ];
+}
+function detectToolBloat(ir, result) {
+  const SHORT_OUTPUT = /* @__PURE__ */ new Set([
+    "classify",
+    "extract",
+    "summarize",
+    "transform",
+    "critique"
+  ]);
+  if (!ir.tools || ir.tools.length === 0) return [];
+  const toolsKept = result.diagnostics.toolsKept;
+  if (toolsKept <= 10) return [];
+  if (!SHORT_OUTPUT.has(ir.intent.archetype)) return [];
+  return [
+    {
+      level: "warn",
+      code: "tool-bloat",
+      message: `${toolsKept} tools kept after the relevance pass for archetype="${ir.intent.archetype}" (consumer declared ${ir.tools.length}). This archetype is short-output and rarely needs more than 3 tools; each tool definition eats ~350 tokens of context budget.`,
+      suggestion: "Tighten `relevanceByIntent: { [archetype]: 0..1 }` per ToolDefinition. Tools below `toolRelevanceThreshold` (default 0.2) get dropped. Without `relevanceByIntent`, every tool defaults to neutral (0.5) and stays.",
+      docsUrl: "https://github.com/stue/kgauto/blob/main/v2/README.md#tools"
+    }
+  ];
+}
+function detectHistoryUncached(ir, profile) {
+  if (profile.provider !== "anthropic") return [];
+  if (!ir.history || ir.history.length < 2) return [];
+  if (ir.historyCachePolicy && ir.historyCachePolicy.strategy !== "none") {
+    return [];
+  }
+  return [
+    {
+      level: "warn",
+      code: "history-uncached-on-claude",
+      message: `${ir.history.length} history messages on Anthropic with no historyCachePolicy. Every turn re-pays for the full conversation context; with caching, subsequent turns hit the cache at ~10% the input cost.`,
+      suggestion: "Set `historyCachePolicy: { strategy: 'all-but-latest' }` on this IR. The lowering pass marks the message immediately preceding currentTurn with cache_control; subsequent turns whose history prefix matches byte-for-byte hit the cache.",
+      docsUrl: "https://github.com/stue/command-center/blob/main/interfaces/kgauto.md#best-practice-advisories"
+    }
+  ];
+}
+function detectSingleModelArray(ir, policy) {
+  if (ir.models.length !== 1) return [];
+  if (policy?.posture === "locked") return [];
+  const entry = ir.models[0];
+  const only = typeof entry === "string" ? entry : `family:${entry.family}`;
+  const blocked = canonicalPolicySet(policy?.blockedModels);
+  let alternatives = [];
+  try {
+    alternatives = getDefaultFallbackChain({
+      archetype: ir.intent.archetype,
+      primary: only,
+      posture: "preferred",
+      policy
+    }).filter((id) => resolveModelAlias(id) !== resolveModelAlias(only)).filter((id) => !policySetHas(blocked, id)).filter((id) => getModelCompatibility(id, { archetype: ir.intent.archetype }).status !== "reject");
+  } catch {
+  }
+  const hasAlternative = alternatives.length > 0;
+  const remedy = "Widen the chain AND pin your primary: `compile({ ...ir, models: getDefaultFallbackChain({ archetype: ir.intent.archetype, primary: '" + only + "', posture: 'preferred' }) }, { policy: { preferredModels: ['" + only + "'] } })`. The chain is a CANDIDATE SET \u2014 compile() scores it and does not honour its order, so without the `preferredModels` pin the extra entries can retarget your primary (and with it your cost profile). With the pin, `" + only + "` stays primary and the added entries serve only as the safety net. Note `posture` has no effect once `primary` is passed. If you gate models by spend, re-verify `policy.blockedModels` against the widened set before shipping. If single-model is intentional (compliance/brand promise), set `policy.posture = 'locked'` to silence this rule.";
+  return [
+    {
+      level: hasAlternative ? "critical" : "warn",
+      code: "single-model-array",
+      message: hasAlternative ? `\`ir.models\` has length 1 (only "${only}") for archetype "${ir.intent.archetype}" and posture is not 'locked'. A single-model chain has no safety net \u2014 the first 429 / 5xx / cliff hits the user as a failure \u2014 and a compatible, non-blocked alternative exists in the roster today (${alternatives[0]}), so this is critical: the missing safety net is adoptable now.` : `\`ir.models\` has length 1 (only "${only}") for archetype "${ir.intent.archetype}" and posture is not 'locked'. A single-model chain has no safety net \u2014 the first 429 / 5xx / cliff hits the user as a failure. No compatible non-blocked alternative is visible in the roster for this archetype, so this stays a warning.`,
+      suggestion: remedy,
+      docsUrl: "https://github.com/stue/command-center/blob/main/interfaces/kgauto.md#single-model-array"
+    }
+  ];
+}
+function suppressedRecommendationReason(ir, archetype, altProfile) {
+  if (getMeasuredFailureVerdict({ appId: ir.appId, archetype, model: altProfile.id })?.gated === true) {
+    return "measured-failure-gate";
+  }
+  if (ir.constraints?.structuredOutput && effectiveConventions(altProfile).some(
+    (c) => c.archetype === archetype && c.structuredOutputHint === "avoid"
+  )) {
+    return "schema-weakness-convention";
+  }
+  if (getRecentRollback({ appId: ir.appId, archetype, model: altProfile.id }) !== void 0) {
+    return "recent-rollback";
+  }
+  return void 0;
+}
+function openPostureRemedyClause(archetype, recommended, resolveProfile) {
+  const openChain = getDefaultFallbackChain({ archetype, posture: "open" });
+  const openPrimaryId = openChain[0];
+  if (!openPrimaryId) return void 0;
+  const openPrimary = resolveProfile(openPrimaryId);
+  if (!openPrimary) return void 0;
+  const openCost = estimateChainCostUsd(openPrimary);
+  const recommendedCost = estimateChainCostUsd(recommended);
+  if (openCost >= recommendedCost) return void 0;
+  const ratio = recommendedCost / openCost;
+  return ` Relaxing to \`policy.posture = 'open'\` is also viable here \u2014 it selects \`${openPrimaryId}\`, which is ${ratio >= 1.1 ? `about ${ratio.toFixed(1)}x cheaper than` : "priced comparably to"} \`${recommended.id}\` at a reference call shape. Note the library chain is ordered by archetype performance, not cost; it happens to agree with the cost recommendation for this archetype.`;
+}
+function openPostureCostWarningClause(archetype, recommended, resolveProfile) {
+  const openChain = getDefaultFallbackChain({ archetype, posture: "open" });
+  const openPrimaryId = openChain[0];
+  const openPrimary = openPrimaryId ? resolveProfile(openPrimaryId) : void 0;
+  if (!openPrimary || !openPrimaryId) return "";
+  const ratio = estimateChainCostUsd(openPrimary) / estimateChainCostUsd(recommended);
+  if (ratio < 1) return "";
+  return ` Do NOT reach for \`posture = 'open'\` as a cost fix here: the library chain is ordered by archetype performance, not cost, and would select \`${openPrimaryId}\` \u2014 roughly ${ratio.toFixed(1)}x the cost of \`${recommended.id}\`. Pass \`getDefaultFallbackChain({ archetype: '${archetype}', posture: 'open', optimizeFor: 'cost' })\` if you want a library-picked chain that is actually cost-ordered.`;
+}
+function detectCostMismatchedArchetype(ir, profile, phase2) {
+  if (!phase2 || phase2.fallbackChain.length === 0) return [];
+  if (!phase2.profileResolver) return [];
+  const archetype = ir.intent.archetype;
+  const chosenScore = getArchetypePerfScore(profile.id, archetype);
+  const chosenHasRoomToGrow = chosenScore.grounding === "judgment" || chosenScore.score < COST_MISMATCHED_CHOSEN_SCORE_CEILING;
+  if (!chosenHasRoomToGrow) return [];
+  let bestAlt = null;
+  for (const altId of phase2.fallbackChain) {
+    const altProfile = phase2.profileResolver(altId);
+    if (!altProfile) continue;
+    if (altProfile.id === profile.id) continue;
+    const altScore = getArchetypePerfScore(altProfile.id, archetype);
+    if (altScore.score < QUALITY_FLOOR_FOR_RECOMMENDATION) continue;
+    if (altScore.score < chosenScore.score) continue;
+    if (altProfile.costInputPer1m >= profile.costInputPer1m) continue;
+    if (suppressedRecommendationReason(ir, archetype, altProfile)) continue;
+    if (!bestAlt || altScore.score > bestAlt.score.score || altScore.score === bestAlt.score.score && altProfile.costInputPer1m < bestAlt.profile.costInputPer1m) {
+      bestAlt = { id: altId, profile: altProfile, score: altScore };
+    }
+  }
+  if (!bestAlt) return [];
+  const tierDownWouldFire = bestAlt.score.grounding === "measured" && bestAlt.profile.costInputPer1m <= profile.costInputPer1m * TIER_DOWN_COST_RATIO;
+  if (tierDownWouldFire) return [];
+  const chosenGrounding = chosenScore.grounding === "judgment" ? `archetypePerf.${archetype}=judgment` : `archetypePerf.${archetype}=${chosenScore.score}`;
+  const altGrounding = bestAlt.score.grounding === "measured" ? `archetypePerf.${archetype}=${bestAlt.score.score}, measured, n=${bestAlt.score.n}` : `archetypePerf.${archetype}=${bestAlt.score.score}, judgment`;
+  return [
+    {
+      level: "warn",
+      code: "cost-mismatched-archetype",
+      message: `Cost-mismatched-archetype: target=${profile.id} (${chosenGrounding}) selected for ${archetype}. Alternative ${bestAlt.id} (${altGrounding}) is cheaper ($${bestAlt.profile.costInputPer1m}/$${bestAlt.profile.costOutputPer1m} vs $${profile.costInputPer1m}/$${profile.costOutputPer1m} per 1M) at equal-or-better quality.`,
+      // alpha.80 (tt-intel's `chain-builder-and-cost-advisories-give-opposite-answers`):
+      // this field used to offer `posture='open'` unconditionally, alongside
+      // the cheap-model swap, as if the two were equivalent remedies. They
+      // point in opposite directions. Both branches are now computed from
+      // the chain builder rather than assumed.
+      suggestion: `Consider declaring \`${bestAlt.id}\` as the primary model for this archetype.` + (openPostureRemedyClause(archetype, bestAlt.profile, phase2.profileResolver) ?? openPostureCostWarningClause(archetype, bestAlt.profile, phase2.profileResolver)) + ` If the chosen model is required for compliance/brand reasons, set \`policy.posture = 'locked'\` to silence this rule.`,
+      recommendationType: profile.provider === bestAlt.profile.provider ? "tier-down" : "model-swap",
+      docsUrl: "https://github.com/stue/command-center/blob/main/interfaces/kgauto.md#best-practice-advisories"
+    }
+  ];
+}
+function detectModelStaleEvidence(ir, profile) {
+  if (!isBrainQueryActiveFor("kgauto_archetype_perf")) return [];
+  const archetype = ir.intent.archetype;
+  const chosen = getArchetypePerfScore(profile.id, archetype);
+  if (chosen.grounding !== "judgment") return [];
+  return [
+    {
+      level: "info",
+      code: "model-stale-evidence",
+      message: `Model-stale-evidence: target=${profile.id} archetype=${archetype} is judgment-grounded (n=${chosen.n}, cross-app 90d window) despite brain-query mode being active. Fewer than 10 outcomes back this (model, archetype) tuple across ALL consumers \u2014 routing decisions remain pre-measured for this slot.`,
+      suggestion: "Verify that `record()` is being called on every call() outcome. Counts are cross-app (migration 050 view): once ANY consumers accumulate n>=10 rows on this tuple, the score promotes from judgment to measured automatically within the 5-min SWR window. (Before alpha.78 this promotion was advertised but had no implementing mechanism \u2014 n was never populated; if this advisory has been firing for weeks at n=0 despite real traffic, bump to >=alpha.78 and it will clear on its own.)",
+      recommendationType: "prompt-fix",
+      docsUrl: "https://github.com/stue/command-center/blob/main/interfaces/kgauto.md#best-practice-advisories"
+    }
+  ];
+}
+function detectTierDown(ir, profile, phase2) {
+  if (!phase2 || phase2.fallbackChain.length === 0) return [];
+  if (!phase2.profileResolver) return [];
+  const archetype = ir.intent.archetype;
+  const chosenScore = getArchetypePerfScore(profile.id, archetype);
+  const chosenCost = profile.costInputPer1m;
+  let bestAlt = null;
+  for (const altId of phase2.fallbackChain) {
+    const altProfile = phase2.profileResolver(altId);
+    if (!altProfile) continue;
+    if (altProfile.id === profile.id) continue;
+    const altScore = getArchetypePerfScore(altProfile.id, archetype);
+    if (altScore.grounding !== "measured") continue;
+    if (altScore.score < QUALITY_FLOOR_FOR_RECOMMENDATION) continue;
+    if (altScore.score < chosenScore.score) continue;
+    if (altProfile.costInputPer1m > chosenCost * TIER_DOWN_COST_RATIO) continue;
+    if (suppressedRecommendationReason(ir, archetype, altProfile)) continue;
+    if (!bestAlt || altProfile.costInputPer1m < bestAlt.profile.costInputPer1m || altProfile.costInputPer1m === bestAlt.profile.costInputPer1m && altScore.score > bestAlt.score.score) {
+      bestAlt = { id: altId, profile: altProfile, score: altScore };
+    }
+  }
+  if (!bestAlt) return [];
+  const chosenDesc = chosenScore.grounding === "measured" ? `archetypePerf.${archetype}=${chosenScore.score} (measured, n=${chosenScore.n})` : `archetypePerf.${archetype}=${chosenScore.score} (${chosenScore.grounding})`;
+  return [
+    {
+      level: "warn",
+      code: "tier-down",
+      message: `Tier-down: target=${profile.id} (${chosenDesc}) selected for ${archetype}. Brain shows ${bestAlt.id} delivers equal-or-better quality (archetypePerf.${archetype}=${bestAlt.score.score}, measured, n=${bestAlt.score.n}) at $${bestAlt.profile.costInputPer1m}/$${bestAlt.profile.costOutputPer1m} per 1M vs $${profile.costInputPer1m}/$${profile.costOutputPer1m} \u2014 a measured tier-down opportunity.`,
+      suggestion: `Move \`${bestAlt.id}\` to primary for this archetype. The brain has n=${bestAlt.score.n} measured outcomes backing the recommendation; this is data, not opinion. If posture='locked' is required (compliance/brand promise), set it explicitly to silence this rule.`,
+      recommendationType: "tier-down",
+      docsUrl: "https://github.com/stue/command-center/blob/main/interfaces/kgauto.md#best-practice-advisories"
+    }
+  ];
+}
+function detectArchetypePerfFloorBreach(ir, profile) {
+  const compat = getModelCompatibility(profile.id, {
+    archetype: ir.intent.archetype,
+    toolOrchestration: ir.constraints?.toolOrchestration
+  });
+  if (compat.status === "compatible") return [];
+  if (compat.status === "requires-adapter") {
+    return [
+      {
+        level: "warn",
+        code: "archetype-perf-floor-breach",
+        message: `${profile.id} sits below the archetype floor for ${ir.intent.archetype} (score ${compat.archetypePerf}/10, floor ${6}). A known adapter would lift it: ${compat.adapter.parameter}=${compat.adapter.value}. ${compat.adapter.consequence}`,
+        suggestion: `Pass \`ir.constraints.${compat.adapter.parameter} = '${compat.adapter.value}'\` for this call, OR pick a model whose archetypePerf for ${ir.intent.archetype} already clears the floor (call \`getModelCompatibility(modelId, { archetype: '${ir.intent.archetype}' })\` to check). Estimated post-adapter score: ${compat.archetypePerfWithAdapter}/10.`,
+        recommendationType: "prompt-fix",
+        suggestedAdaptation: compat.adapter,
+        docsUrl: "https://github.com/stue/command-center/blob/main/interfaces/kgauto.md#best-practice-advisories"
+      }
+    ];
+  }
+  return [
+    {
+      level: "critical",
+      code: "archetype-perf-floor-breach",
+      message: `${profile.id} sits below the archetype floor for ${ir.intent.archetype} (score ${compat.archetypePerf}/10, floor ${6}) and no known adapter would lift it. ${compat.reason}`,
+      // alpha.80: this rule's advice is correct on the QUALITY axis and was
+      // silent on cost, so a consumer reading it as a general "let the
+      // library pick" endorsement could land on a materially pricier
+      // primary. The floor recommendation stands; the axis is now named,
+      // and the cost-ordered variant is offered alongside it.
+      //
+      // alpha.82 (cc-Cairn 2026-07-29, follow-on 1): the suggestion read as
+      // advice about the ARCHETYPE when it is a fact about ONE CALL. Model
+      // selection is input-size dependent, so a rule that fires on the
+      // small-payload tail of a path whose typical case clears the floor
+      // reads as "your primary is wrong" when the accurate statement is
+      // "this call landed here." Ground truth for the wording: tt-intel's
+      // open critical is `gemini-2.5-flash-lite` (ask, 5/10) selected at
+      // ~2.1K tokens_in, while `claude-opus-5` served the same archetype at
+      // ~22K the same day — cc read the evidence set as self-contradictory
+      // precisely because the text did not say which call it described.
+      suggestion: `This fired for \`${profile.id}\`, the model selected for THIS call \u2014 selection is input-size dependent, so other calls on \`${ir.intent.archetype}\` may pick a different model that clears the floor. Swap to a model whose archetypePerf for ${ir.intent.archetype} clears the floor. Use \`getModelCompatibility(candidateId, { archetype: '${ir.intent.archetype}' })\` to vet candidates, or \`getDefaultFallbackChain({ archetype: '${ir.intent.archetype}', posture: 'open' })\` for a library-picked chain that respects the floor by construction \u2014 note that chain is ordered by archetype performance, NOT cost, so it may select a pricier primary than you run today. Add \`optimizeFor: 'cost'\` for a chain that clears the same floor cheapest-first. To stop this model being selected at all, pass \`policy.blockedModels: ['${profile.id}']\`.`,
+      recommendationType: "model-swap",
+      docsUrl: "https://github.com/stue/command-center/blob/main/interfaces/kgauto.md#best-practice-advisories"
+    }
+  ];
+}
+function detectStaleExclusionCandidate(ir) {
+  if (!isExclusionFindingsBrainActive()) return [];
+  if (!ir.appId) return [];
+  const findings = getStaleExclusionFindings({
+    appId: ir.appId,
+    archetype: ir.intent.archetype
+  });
+  if (findings.length === 0) return [];
+  const ranked = [...findings].sort((a, b) => {
+    const sa = a.estimatedSavingsUsd30d ?? -Infinity;
+    const sb = b.estimatedSavingsUsd30d ?? -Infinity;
+    if (sa !== sb) return sb - sa;
+    return confidenceRank(b.confidence) - confidenceRank(a.confidence);
+  });
+  const top = ranked[0];
+  const extraCount = findings.length - 1;
+  const extraNote = extraCount > 0 ? ` (+ ${extraCount} more excluded model${extraCount === 1 ? "" : "s"} for this archetype)` : "";
+  return [
+    {
+      level: "info",
+      code: "stale-exclusion-candidate",
+      message: `${top.message}${extraNote}`,
+      suggestion: top.suggestion,
+      recommendationType: "tier-down",
+      docsUrl: "https://github.com/stue/command-center/blob/main/interfaces/kgauto.md#best-practice-advisories"
+    }
+  ];
+}
+function confidenceRank(c) {
+  if (c === "high") return 3;
+  if (c === "medium") return 2;
+  return 1;
+}
+
+// src/translator.ts
+var TRANSLATOR_FLOOR = ARCHETYPE_FLOOR_DEFAULT;
+var RULE_SEQUENTIAL_TOOL_CLIFF = "sequential-tool-cliff-below-floor";
+var RULE_NARRATION_DRIFT_ANTHROPIC = "narration-drift-anthropic";
+var RULE_NARRATION_THINKING_LEAK_DEEPSEEK = "narration-thinking-leak-deepseek";
+var SEQUENTIAL_TOOL_PREAMBLE = "IMPORTANT: Use one tool call per response. Wait for the tool result before deciding the next tool. Do NOT batch tool calls in parallel.";
+var NARRATION_DRIFT_ANTHROPIC_PREAMBLE = "Output ONLY the requested content. Do not narrate your thought process. Each line \u2264 12 words.";
+var NARRATION_THINKING_LEAK_DEEPSEEK_PREAMBLE = "Reasoning is internal. Output ONLY the requested content; do not emit <thinking> blocks or internal monologue as user-facing text.";
+var RULE_DISCIPLINE_GATES_V1 = "discipline-gates-v1";
+var DISCIPLINE_GATES_V1_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.
+5. Label each claim: mark it observed, inferred, or assumed.
+6. A surfaced gap beats a guessed answer: flag what you cannot determine rather than fabricating past it.`;
+var DISCIPLINE_GATES_V1_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.
+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",
+  "plan",
+  "critique",
+  "judge"
+]);
+function matchRule(kind, profile, archetype, ctx) {
+  if (kind === "discipline_contract") {
+    if (!DISCIPLINE_ELIGIBLE_ARCHETYPES.has(archetype)) 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
+    };
+  }
+  if (kind === "tool_call_contract") {
+    if (!profile.archetypePerf) return null;
+    const archetypeScore = profile.archetypePerf[archetype];
+    if (typeof archetypeScore !== "number" || archetypeScore >= TRANSLATOR_FLOOR) {
+      return null;
+    }
+    return {
+      id: RULE_SEQUENTIAL_TOOL_CLIFF,
+      preamble: SEQUENTIAL_TOOL_PREAMBLE,
+      wireOverrides: { parallelToolCalls: false }
+    };
+  }
+  if (kind === "narration_contract") {
+    if (profile.provider === "anthropic") {
+      return {
+        id: RULE_NARRATION_DRIFT_ANTHROPIC,
+        preamble: NARRATION_DRIFT_ANTHROPIC_PREAMBLE
+      };
+    }
+    if (profile.provider === "deepseek") {
+      return {
+        id: RULE_NARRATION_THINKING_LEAK_DEEPSEEK,
+        preamble: NARRATION_THINKING_LEAK_DEEPSEEK_PREAMBLE
+      };
+    }
+    return null;
+  }
+  return null;
+}
+function applySectionRewrites(args) {
+  const { ir, profile, archetype } = args;
+  if (!Array.isArray(ir.sections) || ir.sections.length === 0) {
+    return { rewrittenIR: ir, rewrites: [] };
+  }
+  const outputMode = args.outputMode ?? resolveOutputMode({
+    declared: ir.constraints?.outputMode,
+    structuredOutput: ir.constraints?.structuredOutput,
+    toolCount: ir.tools?.length ?? 0
+  });
+  const hasTools = (ir.tools?.length ?? 0) > 0;
+  const ctx = { outputMode, hasTools };
+  const rewrites = [];
+  const newSections = ir.sections.map((section) => {
+    if (!section.kind || section.kind === "arbitrary") return section;
+    const rule = matchRule(section.kind, profile, archetype, ctx);
+    if (!rule) return section;
+    const originalText = section.text;
+    const transformedText = `${rule.preamble}
+
+${originalText}`;
+    rewrites.push({
+      sectionId: section.id,
+      kind: section.kind,
+      rule: rule.id,
+      originalText,
+      transformedText,
+      ...rule.wireOverrides ? { wireOverrides: rule.wireOverrides } : {}
+    });
+    return { ...section, text: transformedText };
+  });
+  if (rewrites.length === 0) {
+    return { rewrittenIR: ir, rewrites: [] };
+  }
+  const rewrittenIR = { ...ir, sections: newSections };
+  return { rewrittenIR, rewrites };
+}
+
+// src/lower.ts
+var OPENROUTER_VENDOR_SLUG = {
+  anthropic: "anthropic",
+  google: "google",
+  openai: "openai",
+  deepseek: "deepseek",
+  zai: "z-ai",
+  moonshot: "moonshotai"
+};
+var OPENROUTER_ID_OVERRIDES = Object.freeze({});
+function openRouterModelId(profile) {
+  const override = OPENROUTER_ID_OVERRIDES[profile.id];
+  if (override) return override;
+  const slug = OPENROUTER_VENDOR_SLUG[profile.provider];
+  if (!slug) throw new Error(`No OpenRouter vendor slug for provider ${profile.provider} (model ${profile.id})`);
+  return `${slug}/${profile.id}`;
+}
+function lower(ir, profile, hints = {}) {
+  if (hints.route === "openrouter") {
+    return lowerOpenRouter(ir, profile);
+  }
+  switch (profile.provider) {
+    case "anthropic":
+      return lowerAnthropic(ir, profile, hints);
+    case "google":
+      return lowerGoogle(ir, profile, hints);
+    case "openai":
+      return lowerOpenAI(ir, profile, hints);
+    case "deepseek":
+      return lowerDeepSeek(ir, profile);
+    case "zai":
+      return lowerZai(ir, profile, hints);
+    case "moonshot":
+      return lowerMoonshot(ir, profile);
+    default:
+      throw new Error(`No lowering implementation for provider: ${profile.provider}`);
+  }
+}
+function lowerAnthropic(ir, profile, hints) {
+  const systemBlocks = buildAnthropicSystemBlocks(ir.sections, profile);
+  if (ir.constraints?.structuredOutput) {
+    systemBlocks.push({
+      type: "text",
+      text: "Respond with a single valid JSON value and nothing else. Do not wrap it in a markdown code fence, and do not add any prose before or after it."
+    });
+  }
+  const history = (ir.history ?? []).filter((m) => m.role !== "system");
+  const policy = ir.historyCachePolicy;
+  const markIndex = resolveHistoryMarkIndex(history.length, policy);
+  const messages = buildAnthropicMessages(history, ir.currentTurn, markIndex);
+  const tools = ir.tools ? toAnthropicTools(ir.tools) : void 0;
+  const cacheableTokens = computeCacheableTokens(systemBlocks);
+  const historyCacheableTokens = markIndex >= 0 ? sumHistoryTokens(history, markIndex) : 0;
+  const totalCacheableTokens = cacheableTokens + historyCacheableTokens;
+  const cacheSavings = totalCacheableTokens / 1e6 * profile.costInputPer1m * (1 - (profile.lowering.cache.discount ?? 0.1));
+  const toolChoice = hints.wireOverrides?.parallelToolCalls === false && tools && tools.length > 0 ? { type: "auto", disable_parallel_tool_use: true } : void 0;
+  return {
+    request: {
+      provider: "anthropic",
+      model: profile.id,
+      system: systemBlocks,
+      messages,
+      tools,
+      // alpha.8: trust profile.maxOutputTokens. The historical Math.min(_, 4096)
+      // floor surprised every consumer once (PB-Cairn contract-gaps brief, Gap 3).
+      // Profile is the single source of truth; consumers wanting a tighter
+      // budget can pass providerOverrides.anthropic.max_tokens explicitly.
+      max_tokens: hints.forceTerseOutput ? 200 : profile.maxOutputTokens,
+      tool_choice: toolChoice
+    },
+    diagnostics: {
+      cacheableTokens,
+      historyCacheableTokens,
+      estimatedCacheSavingsUsd: cacheSavings
+    }
+  };
+}
+function buildAnthropicSystemBlocks(sections, profile) {
+  if (sections.length === 0) return [];
+  const ordered = sortSections(sections);
+  const minTokens = profile.lowering.cache.minTokens ?? 1024;
+  const cacheable = [];
+  const dynamic = [];
+  for (const s of ordered) {
+    if (s.cacheable) cacheable.push(s);
+    else dynamic.push(s);
+  }
+  const blocks = [];
+  if (cacheable.length > 0) {
+    const cacheText = cacheable.map((s) => s.text).join("\n\n");
+    const cacheTextTokens = countTokens(cacheText);
+    const block = {
+      type: "text",
+      text: cacheText
+    };
+    if (cacheTextTokens >= minTokens) {
+      block.cache_control = { type: "ephemeral" };
+    }
+    blocks.push(block);
+  }
+  for (const s of dynamic) {
+    blocks.push({ type: "text", text: s.text });
+  }
+  return blocks;
+}
+function buildAnthropicMessages(history, currentTurn, markIndex) {
+  const out = [];
+  for (let i = 0; i < history.length; i++) {
+    const m = history[i];
+    if (m.role === "system") continue;
+    const shouldMark = i === markIndex;
+    out.push({
+      role: m.role,
+      content: shouldMark ? attachAnthropicCacheControl(m) : m.parts ?? m.content
+    });
+  }
+  if (currentTurn && currentTurn.role !== "system") {
+    out.push({ role: currentTurn.role, content: currentTurn.parts ?? currentTurn.content });
+  }
+  return out;
+}
+function attachAnthropicCacheControl(m) {
+  if (Array.isArray(m.parts) && m.parts.length > 0) {
+    const blocks = m.parts;
+    const last = blocks[blocks.length - 1];
+    const withMarker = {
+      ...last,
+      cache_control: { type: "ephemeral" }
+    };
+    return [...blocks.slice(0, -1), withMarker];
+  }
+  return [
+    {
+      type: "text",
+      text: m.content,
+      cache_control: { type: "ephemeral" }
+    }
+  ];
+}
+function resolveHistoryMarkIndex(historyLen, policy) {
+  if (!policy || policy.strategy === "none") return -1;
+  if (historyLen === 0) return -1;
+  if (policy.strategy === "all-but-latest") {
+    return historyLen - 1;
+  }
+  const idx = historyLen - 1 - policy.suffix;
+  return idx >= 0 ? idx : -1;
+}
+function sumHistoryTokens(history, throughIndex) {
+  let total = 0;
+  for (let i = 0; i <= throughIndex && i < history.length; i++) {
+    const m = history[i];
+    if (m.role === "system") continue;
+    if (Array.isArray(m.parts)) {
+      for (const p of m.parts) {
+        if (typeof p.text === "string") total += countTokens(p.text);
+      }
+    } else if (typeof m.content === "string") {
+      total += countTokens(m.content);
+    }
+  }
+  return total;
+}
+function toAnthropicTools(tools) {
+  return tools.map((t) => ({
+    name: t.name,
+    description: t.description ?? "",
+    input_schema: t.parameters ?? { type: "object", properties: {} }
+  }));
+}
+function computeCacheableTokens(blocks) {
+  let total = 0;
+  for (const b of blocks) {
+    if (b.cache_control) total += countTokens(b.text);
+  }
+  return total;
+}
+function lowerGoogle(ir, profile, hints) {
+  const ordered = sortSections(ir.sections);
+  const systemText = ordered.map((s) => s.text).join("\n\n");
+  const generationConfig = {};
+  if (hints.forceThinkingZero && profile.lowering.thinking) {
+    setNestedField(generationConfig, profile.lowering.thinking.field.replace(/^generationConfig\./, ""), 0);
+  }
+  if (hints.forceTerseOutput) {
+    generationConfig.maxOutputTokens = 200;
+  }
+  if (ir.constraints?.structuredOutput && profile.structuredOutput === "native") {
+    generationConfig.responseMimeType = "application/json";
+  }
+  const contents = buildGoogleContents(ir.history ?? [], ir.currentTurn);
+  const tools = ir.tools && ir.tools.length > 0 ? toGoogleTools(ir.tools) : void 0;
+  const cacheable = ordered.filter((s) => s.cacheable);
+  const cacheableTokens = cacheable.reduce((sum, s) => sum + countTokens(s.text), 0);
+  const minTokens = profile.lowering.cache.minTokens ?? 4096;
+  const meetsMin = cacheableTokens >= minTokens;
+  const cacheSavings = meetsMin ? cacheableTokens / 1e6 * profile.costInputPer1m * (1 - (profile.lowering.cache.discount ?? 0.25)) : 0;
+  const history = (ir.history ?? []).filter((m) => m.role !== "system");
+  const histMarkIndex = resolveHistoryMarkIndex(history.length, ir.historyCachePolicy);
+  const historyCacheableTokens = histMarkIndex >= 0 ? sumHistoryTokens(history, histMarkIndex) : 0;
+  return {
+    request: {
+      provider: "google",
+      model: profile.id,
+      systemInstruction: systemText ? { role: "system", parts: [{ text: systemText }] } : void 0,
+      contents,
+      tools,
+      generationConfig: Object.keys(generationConfig).length > 0 ? generationConfig : void 0
+    },
+    diagnostics: {
+      cacheableTokens: meetsMin ? cacheableTokens : 0,
+      historyCacheableTokens,
+      estimatedCacheSavingsUsd: cacheSavings
+    }
+  };
+}
+function buildGoogleContents(history, currentTurn) {
+  const out = [];
+  for (const m of history) {
+    if (m.role === "system") continue;
+    out.push({
+      role: m.role === "assistant" ? "model" : m.role,
+      parts: m.parts ?? [{ text: m.content }]
+    });
+  }
+  if (currentTurn && currentTurn.role !== "system") {
+    out.push({
+      role: currentTurn.role === "assistant" ? "model" : currentTurn.role,
+      parts: currentTurn.parts ?? [{ text: currentTurn.content }]
+    });
+  }
+  return out;
+}
+function toGoogleTools(tools) {
+  return [
+    {
+      functionDeclarations: tools.map((t) => ({
+        name: t.name,
+        description: t.description ?? "",
+        parameters: t.parameters ?? { type: "object", properties: {} }
+      }))
+    }
+  ];
+}
+function lowerOpenAI(ir, profile, hints) {
+  const ordered = sortSections(ir.sections);
+  const systemText = ordered.map((s) => s.text).join("\n\n");
+  const systemRole = profile.systemPromptMode === "as_developer" ? "developer" : "system";
+  const messages = systemText ? [{ role: systemRole, content: systemText }] : [];
+  for (const m of ir.history ?? []) {
+    if (m.role === "system") continue;
+    messages.push({ role: m.role, content: m.parts ?? m.content });
+  }
+  if (ir.currentTurn && ir.currentTurn.role !== "system") {
+    messages.push({
+      role: ir.currentTurn.role,
+      content: ir.currentTurn.parts ?? ir.currentTurn.content
+    });
+  }
+  const history = (ir.history ?? []).filter((m) => m.role !== "system");
+  const histMarkIndex = resolveHistoryMarkIndex(history.length, ir.historyCachePolicy);
+  const historyCacheableTokens = histMarkIndex >= 0 ? sumHistoryTokens(history, histMarkIndex) : 0;
+  const openaiParallelToolCalls = hints.wireOverrides?.parallelToolCalls === false && ir.tools && ir.tools.length > 0 ? false : void 0;
+  return {
+    request: {
+      provider: "openai",
+      model: profile.id,
+      messages,
+      tools: ir.tools && ir.tools.length > 0 ? toOpenAITools(ir.tools) : void 0,
+      response_format: ir.constraints?.structuredOutput ? { type: "json_object" } : void 0,
+      reasoning_effort: hints.forceTerseOutput ? "low" : void 0,
+      parallel_tool_calls: openaiParallelToolCalls
+    },
+    diagnostics: {
+      cacheableTokens: 0,
+      historyCacheableTokens,
+      estimatedCacheSavingsUsd: 0
+    }
+  };
+}
+function toOpenAITools(tools) {
+  return tools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.name,
+      description: t.description ?? "",
+      parameters: t.parameters ?? { type: "object", properties: {} }
+    }
+  }));
+}
+function lowerDeepSeek(ir, profile) {
+  const ordered = sortSections(ir.sections);
+  const systemText = ordered.map((s) => s.text).join("\n\n");
+  const messages = systemText ? [{ role: "system", content: systemText }] : [];
+  for (const m of ir.history ?? []) {
+    if (m.role === "system") continue;
+    messages.push({ role: m.role, content: m.parts ?? m.content });
+  }
+  if (ir.currentTurn && ir.currentTurn.role !== "system") {
+    messages.push({
+      role: ir.currentTurn.role,
+      content: ir.currentTurn.parts ?? ir.currentTurn.content
+    });
+  }
+  const history = (ir.history ?? []).filter((m) => m.role !== "system");
+  const histMarkIndex = resolveHistoryMarkIndex(history.length, ir.historyCachePolicy);
+  const historyCacheableTokens = histMarkIndex >= 0 ? sumHistoryTokens(history, histMarkIndex) : 0;
+  return {
+    request: {
+      provider: "deepseek",
+      model: profile.id,
+      messages,
+      tools: ir.tools && ir.tools.length > 0 ? ir.tools.slice(0, 1).map((t) => ({
+        type: "function",
+        function: {
+          name: t.name,
+          description: t.description ?? "",
+          parameters: t.parameters ?? { type: "object", properties: {} }
+        }
+      })) : void 0
+    },
+    diagnostics: {
+      cacheableTokens: 0,
+      historyCacheableTokens,
+      estimatedCacheSavingsUsd: 0
+    }
+  };
+}
+function buildOpenAICompatibleParts(ir) {
+  const ordered = sortSections(ir.sections);
+  const systemText = ordered.map((s) => s.text).join("\n\n");
+  const messages = systemText ? [{ role: "system", content: systemText }] : [];
+  for (const m of ir.history ?? []) {
+    if (m.role === "system") continue;
+    messages.push({ role: m.role, content: m.parts ?? m.content });
+  }
+  if (ir.currentTurn && ir.currentTurn.role !== "system") {
+    messages.push({
+      role: ir.currentTurn.role,
+      content: ir.currentTurn.parts ?? ir.currentTurn.content
+    });
+  }
+  const history = (ir.history ?? []).filter((m) => m.role !== "system");
+  const histMarkIndex = resolveHistoryMarkIndex(history.length, ir.historyCachePolicy);
+  const historyCacheableTokens = histMarkIndex >= 0 ? sumHistoryTokens(history, histMarkIndex) : 0;
+  return {
+    messages,
+    tools: ir.tools && ir.tools.length > 0 ? toOpenAITools(ir.tools) : void 0,
+    response_format: ir.constraints?.structuredOutput ? { type: "json_object" } : void 0,
+    historyCacheableTokens
+  };
+}
+function lowerZai(ir, profile, hints) {
+  const parts = buildOpenAICompatibleParts(ir);
+  return {
+    request: {
+      provider: "zai",
+      model: profile.id,
+      messages: parts.messages,
+      tools: parts.tools,
+      response_format: parts.response_format,
+      // Z.ai thinking defaults to enabled server-side; emit an explicit
+      // disable only when a cliff forced thinking off (the GLM analogue of
+      // Gemini's thinkingBudget=0).
+      thinking: hints.forceThinkingZero ? { type: "disabled" } : void 0
+    },
+    diagnostics: {
+      cacheableTokens: 0,
+      historyCacheableTokens: parts.historyCacheableTokens,
+      estimatedCacheSavingsUsd: 0
+    }
+  };
+}
+function lowerOpenRouter(ir, profile) {
+  const parts = buildOpenAICompatibleParts(ir);
+  return {
+    request: {
+      provider: "openrouter",
+      model: openRouterModelId(profile),
+      messages: parts.messages,
+      tools: parts.tools,
+      response_format: parts.response_format
+    },
+    diagnostics: {
+      cacheableTokens: 0,
+      historyCacheableTokens: parts.historyCacheableTokens,
+      estimatedCacheSavingsUsd: 0
+    }
+  };
+}
+function lowerMoonshot(ir, profile) {
+  const parts = buildOpenAICompatibleParts(ir);
+  return {
+    request: {
+      provider: "moonshot",
+      model: profile.id,
+      messages: parts.messages,
+      tools: parts.tools,
+      response_format: parts.response_format
+    },
+    diagnostics: {
+      cacheableTokens: 0,
+      historyCacheableTokens: parts.historyCacheableTokens,
+      estimatedCacheSavingsUsd: 0
+    }
+  };
+}
+function sortSections(sections) {
+  return [...sections].sort((a, b) => {
+    const wa = a.weight ?? 100;
+    const wb = b.weight ?? 100;
+    return wa - wb;
+  });
+}
+function setNestedField(obj, path, value) {
+  const parts = path.split(".");
+  let cursor = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const key = parts[i];
+    if (!(key in cursor) || typeof cursor[key] !== "object" || cursor[key] === null) {
+      cursor[key] = {};
+    }
+    cursor = cursor[key];
+  }
+  cursor[parts[parts.length - 1]] = value;
+}
+
+// src/compile.ts
+var counter = 0;
+function makeHandle() {
+  counter = (counter + 1) % 1e6;
+  return `c${Date.now().toString(36)}-${counter.toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
+}
+function compile(ir, opts = {}) {
+  const baseResolver = opts.profileResolver ?? getProfile;
+  const resolver = opts.policy?.onUnprofiledModel === "best-effort" ? (id) => {
+    try {
+      return baseResolver(id);
+    } catch (err) {
+      const synth = bestEffortProfile(id);
+      if (!synth) throw err;
+      return synth;
+    }
+  } : baseResolver;
+  validateIR(ir);
+  ir = resolveModelEntries(ir);
+  const sliced = passSlice(ir);
+  const deduped = passDedupe(sliced.value);
+  const toolFiltered = passToolRelevance(deduped.value, {
+    threshold: opts.toolRelevanceThreshold
+  });
+  const compressed = passCompressHistory(toolFiltered.value, {
+    summarizeOlderThan: opts.compressHistoryAfter,
+    summarizeAboveTokens: opts.compressHistoryAboveTokens
+  });
+  let workingIR = compressed.value;
+  const accumulatedMutations = [
+    ...sliced.mutations,
+    ...deduped.mutations,
+    ...toolFiltered.mutations,
+    ...compressed.mutations
+  ];
+  const activePromotion = getApplicablePromotion({
+    appId: ir.appId,
+    archetype: ir.intent.archetype,
+    mode: "downswap"
+  });
+  const promotion = activePromotion ? {
+    id: activePromotion.id,
+    mode: activePromotion.mode,
+    promotedModel: activePromotion.promotedModel,
+    evalRunId: activePromotion.evalRunId,
+    suppressQualityGate: activePromotion.suppressQualityGate
+  } : void 0;
+  const measuredFailureGates = /* @__PURE__ */ new Map();
+  for (const entry of workingIR.models ?? []) {
+    const modelId = typeof entry === "string" ? entry : void 0;
+    if (!modelId) continue;
+    const verdict = getMeasuredFailureVerdict({
+      appId: ir.appId,
+      archetype: ir.intent.archetype,
+      model: modelId
+    });
+    if (verdict?.gated) {
+      measuredFailureGates.set(modelId, {
+        rate: verdict.rate,
+        lowerBound: verdict.lowerBound,
+        n: verdict.n,
+        nFail: verdict.nFail
+      });
+    }
+  }
+  const inputTokens = estimateInputTokens(workingIR);
+  const scores = passScoreTargets(workingIR, {
+    estimatedInputTokens: inputTokens,
+    profilesById: resolver,
+    policy: opts.policy,
+    promotion,
+    measuredFailureGates
+  });
+  accumulatedMutations.push(...scores.mutations);
+  const target = pickTarget(workingIR, scores.value);
+  if (!target) {
+    const unknownIds = scores.value.filter((s) => s.rejectReasons?.includes("unknown_model_id")).map((s) => s.modelId);
+    const uninferable = unknownIds.filter((id) => !inferProviderFromId(id));
+    const unknownHint = unknownIds.length > 0 ? ` Unprofiled model id(s): ${unknownIds.join(", ")}. registerProfiles([...]) supplies a full profile; policy.onUnprofiledModel:'best-effort' compiles with guards skipped.` + (uninferable.length > 0 ? ` Note: provider is not inferable from ${uninferable.join(", ")}, so best-effort cannot lower it \u2014 registerProfiles is the only path for those.` : "") : "";
+    throw new Error(
+      `compile(): no allowed model fits the request.${unknownHint} Scores: ${JSON.stringify(scores.value, null, 2)}`
+    );
+  }
+  const profile = resolver(target.modelId);
+  const bestEffortWarnings = [];
+  if (profile.bestEffort) {
+    bestEffortWarnings.push(
+      `best-effort profile in use for "${profile.id}" (provider ${profile.provider} inferred from the id; wire mechanics borrowed). SKIPPED for this model: cliff guards, recovery rules, measured archetype knowledge, structured-output capability (treated as 'none'), parallel tools (treated as sequential). Cost is UNKNOWN and recorded as $0 \u2014 cost gates and cost attribution are meaningless for this model. registerProfiles() restores real guards.`
+    );
+    accumulatedMutations.push({
+      id: `best_effort_profile_${profile.id}`,
+      source: "best_effort",
+      passName: "resolve-profile",
+      description: `Unprofiled model "${profile.id}" compiled under onUnprofiledModel:'best-effort' \u2014 guards skipped, cost unknown. See diagnostics.cliffWarnings for the full list.`
+    });
+  }
+  const fallbackChain = scores.value.filter((s) => s.modelId !== target.modelId && s.fits).sort((a, b) => b.rank - a.rank).map((s) => s.modelId);
+  const cliffs = passApplyCliffs(workingIR, profile, inputTokens);
+  workingIR = cliffs.value.ir;
+  accumulatedMutations.push(...cliffs.mutations);
+  const conventions = passApplyConventions(workingIR, profile);
+  workingIR = conventions.value.ir;
+  accumulatedMutations.push(...conventions.mutations);
+  const outputMode = resolveOutputMode({
+    declared: ir.constraints?.outputMode,
+    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,
+    archetype: ir.intent.archetype,
+    outputMode
+  });
+  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"
+  );
+  const disciplineGateTokens = disciplineRewrite ? countTokens(
+    disciplineRewrite.transformedText.slice(
+      0,
+      disciplineRewrite.transformedText.length - disciplineRewrite.originalText.length
+    )
+  ) : 0;
+  let wireOverrides;
+  for (const rw of sectionRewritesApplied) {
+    if (!rw.wireOverrides) continue;
+    if (!wireOverrides) wireOverrides = {};
+    if (rw.wireOverrides.parallelToolCalls !== void 0) {
+      wireOverrides.parallelToolCalls = rw.wireOverrides.parallelToolCalls;
+    }
+  }
+  for (const rw of sectionRewritesApplied) {
+    accumulatedMutations.push({
+      id: `translator:${rw.rule}:${rw.sectionId}`,
+      source: "translator",
+      passName: "translator",
+      description: `Rewrote section "${rw.sectionId}" (kind=${rw.kind}) via rule "${rw.rule}".`
+    });
+  }
+  const lowered = lower(workingIR, profile, {
+    forceThinkingZero: cliffs.value.loweringHints.forceThinkingZero,
+    forceTerseOutput: cliffs.value.loweringHints.forceTerseOutput,
+    wireOverrides,
+    route: opts.route
+  });
+  validateFinalFit(workingIR, profile, inputTokens);
+  const handle = makeHandle();
+  const finalShape = computeShape(workingIR, inputTokens);
+  const _learningKey = learningKey(ir.intent.archetype, routeScopedModel(profile.id, opts.route), finalShape);
+  const historyCacheMarkIndex = computeHistoryCacheMarkIndex(workingIR);
+  const systemMessages = buildSystemMessages(workingIR, profile.provider);
+  const systemCacheMarkIndex = lastCacheableSystemIndex(systemMessages);
+  const keptSectionIds = new Set(workingIR.sections.map((s) => s.id));
+  const cachePrefixActive = lowered.diagnostics.cacheableTokens > 0;
+  const cacheReadFraction = profile.lowering.cache.discount ?? 0.25;
+  const sectionAttribution = ir.sections.map((s) => {
+    const tokens = countTokens(s.text);
+    const kept = keptSectionIds.has(s.id);
+    const estCostUsdFirstCall = kept ? tokens / 1e6 * profile.costInputPer1m : 0;
+    const inActiveCachePrefix = kept && s.cacheable === true && cachePrefixActive;
+    return {
+      id: s.id,
+      tokens,
+      kept,
+      cacheable: s.cacheable === true,
+      estCostUsdFirstCall,
+      estCostUsdWarm: inActiveCachePrefix ? estCostUsdFirstCall * cacheReadFraction : estCostUsdFirstCall
+    };
+  });
+  const diagnostics = {
+    sectionsKept: workingIR.sections.length,
+    sectionsDropped: ir.sections.length - workingIR.sections.length,
+    toolsKept: workingIR.tools?.length ?? 0,
+    toolsDropped: (ir.tools?.length ?? 0) - (workingIR.tools?.length ?? 0),
+    historyKept: workingIR.history?.length ?? 0,
+    historyDropped: (ir.history?.length ?? 0) - (workingIR.history?.length ?? 0),
+    cacheableTokens: lowered.diagnostics.cacheableTokens,
+    estimatedCacheSavingsUsd: lowered.diagnostics.estimatedCacheSavingsUsd,
+    historyCacheableTokens: lowered.diagnostics.historyCacheableTokens,
+    historyTokensTotal: compressed.historyTokensTotal,
+    // alpha.20 E3: mirror the consumer's declared mode for Glass-Box +
+    // brain observability. Undefined when not declared (pre-alpha.20).
+    toolOrchestration: ir.constraints?.toolOrchestration,
+    // alpha.33 — see top-of-block comment.
+    historyCacheMarkIndex,
+    systemCacheMarkIndex,
+    // alpha.43 — cliff-style warnings emitted by passApplyConventions.
+    // Merge convention-pass cliffWarnings with any cliff-guard quality
+    // warnings the cliff pass surfaced (the same shape — informational
+    // text the consumer can route on without changing behavior).
+    cliffWarnings: [
+      ...cliffs.value.loweringHints.qualityWarning ?? [],
+      ...conventions.value.cliffWarnings,
+      // alpha.87 — best-effort profile in use (loud on EVERY compile).
+      ...bestEffortWarnings
+    ],
+    // alpha.68 / Release A — measured discipline gate-token tax (§5.D). 0 when
+    // the gate didn't fire.
+    disciplineGateTokens,
+    // alpha.87 — per-source freshness stamped at the moment the compile's
+    // reads have all happened, from state each source already tracks (the
+    // "one-line stamp at the point where the source is already known and
+    // discarded" this filing reduced to once alpha.73/.86 warmed the caches).
+    freshness: {
+      config: configFreshness(),
+      measuredFailure: measuredFailureFreshness(ir.appId),
+      promotions: promotionsFreshness(ir.appId),
+      exclusions: exclusionFindingsFreshness(ir.appId),
+      promoteReady: promoteReadyFreshness(ir.appId)
+    },
+    sections: sectionAttribution
+  };
+  if (ir.intent.archetype === "hunt" && ir.constraints?.toolOrchestration === "sequential") {
+    accumulatedMutations.push({
+      id: "sequential-mode-chain-selected",
+      source: "tool_orchestration",
+      passName: "compile",
+      description: "ir.constraints.toolOrchestration='sequential' selected the DeepSeek-tier-0 hunt chain overlay (L-040 parallel-tool cliff doesn't apply at single-step granularity)."
+    });
+  }
+  const phase2ProfileResolver = opts.profileResolver ? (id) => {
+    try {
+      return opts.profileResolver(id);
+    } catch {
+      return void 0;
+    }
+  } : tryGetProfile;
+  const rawAdvisories = runAdvisor(
+    ir,
+    {
+      target: profile.id,
+      provider: profile.provider,
+      tokensIn: inputTokens,
+      diagnostics
+    },
+    profile,
+    opts.policy,
+    {
+      fallbackChain,
+      profileResolver: phase2ProfileResolver,
+      // alpha.29 — feed translator rewrites to the advisor so the
+      // `archetype-perf-floor-breach` rule can suppress when the translator
+      // already cleared the cliff for the same archetype. Without this,
+      // both the rewrite AND the advisory fire — noisy, and the advisory
+      // would mislead consumers into thinking the cliff is unaddressed.
+      sectionRewritesApplied
+    }
+  );
+  if (ir["policy"] !== void 0 && opts.policy === void 0) {
+    rawAdvisories.push({
+      level: "critical",
+      code: "policy-in-ir-ignored",
+      message: "The IR passed to compile() carries a `policy` field. `policy` belongs in the SECOND argument \u2014 `compile(ir, { policy })` \u2014 and inside the IR it is an unknown field that is completely ignored. If that policy names blockedModels, no block is being enforced on this call.",
+      suggestion: "Move it: `compile(ir, { policy: { ... } })`. If you also configure policy correctly elsewhere on this path, remove the IR copy so the next reader is not misled.",
+      docsUrl: "https://github.com/stue/command-center/blob/main/interfaces/kgauto.md#public-api"
+    });
+  }
+  const advisories = rawAdvisories.map((a) => ({
+    ...a,
+    kgautoRequestId: handle,
+    ownership: deriveOwnership(a.code, a.ownership)
+  }));
+  return {
+    handle,
+    target: profile.id,
+    provider: profile.provider,
+    request: lowered.request,
+    tokensIn: inputTokens,
+    estimatedCostUsd: target.estimatedCostUsd,
+    mutationsApplied: accumulatedMutations,
+    fallbackChain,
+    advisories,
+    diagnostics,
+    sectionRewritesApplied,
+    wireOverrides,
+    systemMessages
+  };
+}
+function computeHistoryCacheMarkIndex(ir) {
+  const policy = ir.historyCachePolicy;
+  if (!policy || policy.strategy === "none") return void 0;
+  const historyLen = ir.history?.length ?? 0;
+  if (historyLen === 0) return void 0;
+  if (policy.strategy === "all-but-latest") {
+    return historyLen - 1;
+  }
+  if (policy.strategy === "fixed-suffix") {
+    const idx = historyLen - 1 - policy.suffix;
+    if (idx < 0) return void 0;
+    return idx;
+  }
+  return void 0;
+}
+function buildSystemMessages(ir, provider) {
+  const sections = ir.sections;
+  if (!sections || sections.length === 0) return [];
+  return sections.map((s) => {
+    const base = { role: "system", content: s.text };
+    if (provider === "anthropic" && s.cacheable) {
+      base.providerOptions = { anthropic: { cacheControl: { type: "ephemeral" } } };
+    }
+    return base;
+  });
+}
+function lastCacheableSystemIndex(systemMessages) {
+  for (let i = systemMessages.length - 1; i >= 0; i--) {
+    const entry = systemMessages[i];
+    if (entry && entry.providerOptions?.anthropic?.cacheControl) {
+      return i;
+    }
+  }
+  return void 0;
+}
+function validateIR(ir) {
+  if (!ir.appId) throw new Error("compile(): ir.appId is required");
+  if (!ir.intent || !ir.intent.archetype) {
+    throw new Error("compile(): ir.intent.archetype is required (use a dialect-v1 archetype)");
+  }
+  if (!Array.isArray(ir.models) || ir.models.length === 0) {
+    throw new Error("compile(): ir.models must be a non-empty array");
+  }
+  if (!Array.isArray(ir.sections)) {
+    throw new Error("compile(): ir.sections must be an array");
+  }
+}
+function resolveModelEntries(ir) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of ir.models) {
+    let id;
+    if (typeof entry === "string") {
+      id = entry;
+    } else if (entry && typeof entry === "object" && "family" in entry) {
+      id = resolveFamilyEntry(entry.family, {
+        archetype: ir.intent.archetype,
+        appId: ir.appId
+      });
+    } else {
+      throw new Error(
+        `compile(): ir.models entry must be a string or { family: string }; got ${JSON.stringify(entry)}`
+      );
+    }
+    if (seen.has(id)) continue;
+    seen.add(id);
+    out.push(id);
+  }
+  return { ...ir, models: out };
+}
+function pickTarget(ir, scores) {
+  if (ir.constraints?.forceModel) {
+    const forced = scores.find((s) => s.modelId === ir.constraints.forceModel);
+    if (forced && forced.fits) return forced;
+    if (forced) {
+      throw new Error(
+        `compile(): forceModel="${ir.constraints.forceModel}" does not fit: ${forced.rejectReasons.join("; ")}`
+      );
+    }
+  }
+  const fitting = scores.filter((s) => s.fits).sort((a, b) => b.rank - a.rank);
+  return fitting[0];
+}
+function validateFinalFit(ir, profile, tokens) {
+  if (tokens > profile.maxContextTokens) {
+    throw new Error(
+      `compile(): final IR is ${tokens} tokens, exceeds ${profile.id} context (${profile.maxContextTokens})`
+    );
+  }
+  if ((ir.tools?.length ?? 0) > profile.maxTools) {
+    throw new Error(
+      `compile(): final IR has ${ir.tools?.length} tools, exceeds ${profile.id} maxTools (${profile.maxTools})`
+    );
+  }
+}
+
+export {
+  profileToRow,
+  loadModelsFromBrain,
+  loadAliasesFromBrain,
+  DEFAULT_FINDINGS_ENDPOINT,
+  configureExclusionFindingsBrain,
+  isExclusionFindingsBrainActive,
+  getStaleExclusionFindings,
+  FamilyResolutionError,
+  deriveFamilyFromModelId,
+  getRecommendedPrimary,
+  setTokenizer,
+  resetTokenizer,
+  countTokens,
+  computeShape,
+  resolveConventionsForProfile,
+  applyArchetypeConvention,
+  MEASURED_FAILURE_CFG,
+  wilsonLowerBound,
+  mapMeasuredFailureRows,
+  judgeMeasuredFailure,
+  DEFAULT_MEASURED_FAILURE_ENDPOINT,
+  isMeasuredFailureGateEnabledFromEnv,
+  configureMeasuredFailureBrain,
+  isMeasuredFailureBrainActive,
+  prefetchMeasuredFailure,
+  awaitMeasuredFailureReady,
+  getMeasuredFailureVerdict,
+  _testResetMeasuredFailure,
+  _testWaitForMeasuredFailureRefresh,
+  DEFAULT_PROMOTIONS_ENDPOINT,
+  isAutoPromoteEnabledFromEnv,
+  configurePromotionsBrain,
+  isPromotionsBrainActive,
+  getApplicablePromotion,
+  ROLLBACK_SUPPRESSION_WINDOW_DAYS,
+  getRecentRollback,
+  prefetchPromotions,
+  awaitPromotionsReady,
+  _testResetPromotions,
+  _testWaitForPromotionsRefresh,
+  markPromoteReadyHandled,
+  ARCHETYPE_FAMILY_FITS,
+  findBetterFit,
+  BLOCKED_MODEL_NOT_IN_ROSTER_CODE,
+  BLOCKED_MODEL_FAMILY_SIBLING_SERVED_CODE,
+  PRODUCER_OWNED_RULE_CODES,
+  deriveOwnership,
+  runAdvisor,
+  TRANSLATOR_FLOOR,
+  RULE_SEQUENTIAL_TOOL_CLIFF,
+  RULE_DISCIPLINE_GATES_V1,
+  RULE_DISCIPLINE_GATES_V1_STRUCTURED,
+  applySectionRewrites,
+  compile
+};