@warmdrift/kgauto-compiler 2.0.0-alpha.3 → 2.0.0-alpha.30

package/dist/index.js

@@ -20,12 +20,19 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  ABSOLUTE_FLOOR: () => ABSOLUTE_FLOOR,
   ALIASES: () => ALIASES,
   ALL_ARCHETYPES: () => ALL_ARCHETYPES,
+  ARCHETYPE_FLOOR_DEFAULT: () => ARCHETYPE_FLOOR_DEFAULT,
   CallError: () => CallError,
   DIALECT_VERSION: () => DIALECT_VERSION,
   INTENT_ARCHETYPES: () => INTENT_ARCHETYPES,
+  MEASURED_GROUNDING_MIN_N: () => MEASURED_GROUNDING_MIN_N,
+  PROVIDER_ENV_KEYS: () => PROVIDER_ENV_KEYS,
+  RULE_SEQUENTIAL_TOOL_CLIFF: () => RULE_SEQUENTIAL_TOOL_CLIFF,
+  TRANSLATOR_FLOOR: () => TRANSLATOR_FLOOR,
   allProfiles: () => allProfiles,
+  applySectionRewrites: () => applySectionRewrites,
   bucketContext: () => bucketContext,
   bucketHistory: () => bucketHistory,
   bucketToolCount: () => bucketToolCount,
@@ -36,13 +43,41 @@ __export(index_exports, {
   configureBrain: () => configureBrain,
   countTokens: () => countTokens,
   execute: () => execute,
+  getActionableAdvisories: () => getActionableAdvisories,
+  getAllStarterChains: () => getAllStarterChains,
+  getAllStarterChainsWithGrounding: () => getAllStarterChainsWithGrounding,
+  getArchetypePerfScore: () => getArchetypePerfScore,
+  getDefaultFallbackChain: () => getDefaultFallbackChain,
+  getDefaultFallbackChainWithGrounding: () => getDefaultFallbackChainWithGrounding,
+  getModelCompatibility: () => getModelCompatibility,
+  getPerAxisMetrics: () => getPerAxisMetrics,
   getProfile: () => getProfile,
+  getReachabilityDiagnostic: () => getReachabilityDiagnostic,
+  getSequentialStarterChain: () => getSequentialStarterChain,
+  getSequentialStarterChainWithGrounding: () => getSequentialStarterChainWithGrounding,
+  getStarterChain: () => getStarterChain,
+  getStarterChainWithGrounding: () => getStarterChainWithGrounding,
   hashShape: () => hashShape,
   isArchetype: () => isArchetype,
+  isBrainQueryActiveFor: () => isBrainQueryActiveFor,
+  isModelReachable: () => isModelReachable,
+  isProviderReachable: () => isProviderReachable,
   learningKey: () => learningKey,
+  loadAliasesFromBrain: () => loadAliasesFromBrain,
+  loadArchetypePerfFromBrain: () => loadArchetypePerfFromBrain,
+  loadArchetypePerfNFromBrain: () => loadArchetypePerfNFromBrain,
+  loadChainsFromBrain: () => loadChainsFromBrain,
+  loadModelsFromBrain: () => loadModelsFromBrain,
+  loadPricingFromBrain: () => loadPricingFromBrain,
+  markAdvisoryResolved: () => markAdvisoryResolved,
+  profileToRow: () => profileToRow,
   profilesByProvider: () => profilesByProvider,
   record: () => record,
+  recordOutcome: () => recordOutcome,
   resetTokenizer: () => resetTokenizer,
+  resolvePricingAt: () => resolvePricingAt,
+  resolveProviderKey: () => resolveProviderKey,
+  runAdvisor: () => runAdvisor,
   setTokenizer: () => setTokenizer,
   tryGetProfile: () => tryGetProfile
 });
@@ -235,38 +270,96 @@ function passToolRelevance(ir, opts = {}) {
     ]
   };
 }
+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: [] };
+  if (!history || history.length === 0) {
+    return { value: ir, mutations: [], historyTokensTotal: 0 };
+  }
   const keepRecent = opts.keepRecent ?? 4;
   const summarizeOlderThan = opts.summarizeOlderThan ?? 8;
-  if (history.length <= summarizeOlderThan) return { value: ir, mutations: [] };
-  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 summary = {
-    role: "system",
-    content: `[Earlier conversation: ${old.length} turns omitted. First user message: "${firstUserLine}"]`
-  };
-  return {
-    value: { ...ir, history: [summary, ...recent] },
-    mutations: [
-      {
-        id: `compress-history-${old.length}`,
-        source: "static_pass",
-        passName: "compress_history",
-        description: `Compressed ${old.length} old turns into 1 summary line (kept ${keepRecent} recent)`
+  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":
@@ -489,10 +582,16 @@ function lower(ir, profile, hints = {}) {
 }
 function lowerAnthropic(ir, profile, hints) {
   const systemBlocks = buildAnthropicSystemBlocks(ir.sections, profile);
-  const messages = buildAnthropicMessages(ir.history ?? [], ir.currentTurn);
+  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 cacheSavings = cacheableTokens / 1e6 * profile.costInputPer1m * (1 - (profile.lowering.cache.discount ?? 0.1));
+  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",
@@ -500,10 +599,16 @@ function lowerAnthropic(ir, profile, hints) {
       system: systemBlocks,
       messages,
       tools,
-      max_tokens: hints.forceTerseOutput ? 200 : Math.min(profile.maxOutputTokens, 4096)
+      // 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
     }
   };
@@ -536,17 +641,64 @@ function buildAnthropicSystemBlocks(sections, profile) {
   }
   return blocks;
 }
-function buildAnthropicMessages(history, currentTurn) {
+function buildAnthropicMessages(history, currentTurn, markIndex) {
   const out = [];
-  for (const m of history) {
+  for (let i = 0; i < history.length; i++) {
+    const m = history[i];
     if (m.role === "system") continue;
-    out.push({ role: m.role, content: m.parts ?? m.content });
+    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,
@@ -581,6 +733,9 @@ function lowerGoogle(ir, profile, hints) {
   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",
@@ -592,6 +747,7 @@ function lowerGoogle(ir, profile, hints) {
     },
     diagnostics: {
       cacheableTokens: meetsMin ? cacheableTokens : 0,
+      historyCacheableTokens,
       estimatedCacheSavingsUsd: cacheSavings
     }
   };
@@ -639,6 +795,10 @@ function lowerOpenAI(ir, profile, hints) {
       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",
@@ -646,9 +806,14 @@ function lowerOpenAI(ir, profile, hints) {
       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
+      reasoning_effort: hints.forceTerseOutput ? "low" : void 0,
+      parallel_tool_calls: openaiParallelToolCalls
     },
-    diagnostics: { cacheableTokens: 0, estimatedCacheSavingsUsd: 0 }
+    diagnostics: {
+      cacheableTokens: 0,
+      historyCacheableTokens,
+      estimatedCacheSavingsUsd: 0
+    }
   };
 }
 function toOpenAITools(tools) {
@@ -675,6 +840,9 @@ function lowerDeepSeek(ir, profile) {
       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",
@@ -689,7 +857,11 @@ function lowerDeepSeek(ir, profile) {
         }
       })) : void 0
     },
-    diagnostics: { cacheableTokens: 0, estimatedCacheSavingsUsd: 0 }
+    diagnostics: {
+      cacheableTokens: 0,
+      historyCacheableTokens,
+      estimatedCacheSavingsUsd: 0
+    }
   };
 }
 function sortSections(sections) {
@@ -765,7 +937,24 @@ var PROFILES_RAW = [
     ],
     strengths: ["reasoning", "agentic_coding", "long_context", "reliable_tool_use", "structured_output"],
     weaknesses: ["cost", "latency"],
-    notes: "Frontier (2026-05). Step-change improvement over 4.6 in agentic coding. Adaptive thinking only \u2014 no extended-thinking toggle. 1M context, 128k max output."
+    notes: "Frontier (2026-05). Step-change improvement over 4.6 in agentic coding. Adaptive thinking only \u2014 no extended-thinking toggle. 1M context, 128k max output.",
+    // Frontier perf. Drops on archetypes where parallel-tool throughput
+    // (hunt) or low-budget cost-sensitivity (classify/summarize) matters
+    // more than reasoning depth.
+    archetypePerf: {
+      critique: 10,
+      plan: 10,
+      generate: 9,
+      ask: 9,
+      extract: 9,
+      transform: 9,
+      hunt: 8,
+      // strong but Flash dominates parallel tool throughput
+      summarize: 8,
+      // overkill for tolerant archetype; cost-out of frontier
+      classify: 8
+      // overkill; brain-validated cheaper models cover this
+    }
   },
   {
     id: "claude-opus-4-6",
@@ -797,7 +986,20 @@ var PROFILES_RAW = [
     ],
     strengths: ["reasoning", "long_context", "reliable_tool_use", "structured_output", "extended_thinking"],
     weaknesses: ["cost", "latency"],
-    notes: "Predecessor to 4.7. Still current in Anthropic legacy table. Same pricing as 4.7 \u2014 choose 4.7 unless you need extended-thinking budget control (4.7 is adaptive-only)."
+    notes: "Predecessor to 4.7. Still current in Anthropic legacy table. Same pricing as 4.7 \u2014 choose 4.7 unless you need extended-thinking budget control (4.7 is adaptive-only).",
+    // One notch below 4.7 across the board — extended-thinking edge does
+    // not flip any archetype ranking. Legacy: chains should prefer 4.7.
+    archetypePerf: {
+      critique: 9,
+      plan: 9,
+      generate: 9,
+      ask: 9,
+      extract: 9,
+      transform: 9,
+      hunt: 7,
+      summarize: 8,
+      classify: 8
+    }
   },
   {
     id: "claude-sonnet-4-6",
@@ -821,7 +1023,23 @@ var PROFILES_RAW = [
     ],
     strengths: ["quality", "tool_use", "long_context", "cache_friendly", "extended_thinking"],
     weaknesses: [],
-    notes: "Workhorse. Best price/quality for most multi-turn agentic work. 1M context, 64k max output."
+    notes: "Workhorse. Best price/quality for most multi-turn agentic work. 1M context, 64k max output.",
+    // Master plan §6.2 anchor. Tier 0 for plan/generate/ask/extract/transform
+    // in starter chains; tier 1 cross-provider for hunt/summarize/classify.
+    archetypePerf: {
+      ask: 9,
+      generate: 9,
+      plan: 9,
+      critique: 9,
+      extract: 9,
+      transform: 9,
+      hunt: 7,
+      // strong but Flash beats on parallel tool throughput
+      summarize: 8,
+      // overkill for tolerant archetype
+      classify: 8
+      // overkill
+    }
   },
   {
     id: "claude-haiku-4-5",
@@ -851,7 +1069,23 @@ var PROFILES_RAW = [
     ],
     strengths: ["speed", "cost", "classification", "cache_friendly", "extended_thinking"],
     weaknesses: ["complex_reasoning", "large_tool_sets"],
-    notes: "Cheapest Anthropic. Great for classify, summarize, ask shapes. 200k context, 64k max output. API alias `claude-haiku-4-5` resolves to dated snapshot `claude-haiku-4-5-20251001`."
+    notes: "Cheapest Anthropic. Great for classify, summarize, ask shapes. 200k context, 64k max output. API alias `claude-haiku-4-5` resolves to dated snapshot `claude-haiku-4-5-20251001`.",
+    // Tier 1 cross-provider anchor for short-output chains (classify/
+    // summarize/extract/transform). Falls off on plan/critique where
+    // reasoning depth matters; competes with Pro on cost+latency.
+    archetypePerf: {
+      classify: 8,
+      summarize: 8,
+      ask: 7,
+      transform: 7,
+      extract: 7,
+      hunt: 6,
+      // tool reliability drops at 16 — cliff guard fires
+      generate: 6,
+      plan: 5,
+      critique: 4
+      // reasoning depth gap vs Sonnet/Opus
+    }
   },
   // ── Google ──
   {
@@ -929,7 +1163,131 @@ var PROFILES_RAW = [
     ],
     strengths: ["speed", "volume", "classification", "1m_context", "cost"],
     weaknesses: ["complex_schemas", "large_tool_sets", "high_context_quality"],
-    notes: "Fast and cheap with 1M context. Quality cliffs at 8K context and 20 tools \u2014 guard with cliffs."
+    notes: "Fast and cheap with 1M context. Quality cliffs at 8K context and 20 tools \u2014 guard with cliffs.",
+    // Master plan §6.2 anchor. Tier 0 for hunt (parallel tool throughput
+    // 15-75 calls/step beats Sonnet — L-040), summarize, classify.
+    archetypePerf: {
+      hunt: 9,
+      // L-040: parallel tool throughput 15-75/step
+      classify: 7,
+      // brain-validated, 218 rows
+      summarize: 7,
+      // brain-validated; cliff strips tools when present
+      transform: 7,
+      ask: 7,
+      generate: 6,
+      plan: 5,
+      extract: 6,
+      // alpha.8 MAX_TOKENS history on structured output
+      critique: 4
+      // reasoning shallower than Sonnet/Opus
+    }
+  },
+  {
+    // ── Gemini 2.5 Flash-Lite ──
+    // Onboarded 2026-05-13 (s22) after the model-release watcher surfaced
+    // it as a UNREGISTERED + NEW candidate. Released by Google July 2025,
+    // stable. Positioned BELOW Flash on the cost/perf frontier:
+    //   input  $0.10/M (Flash $0.30/M)   — 3× cheaper
+    //   output $0.40/M (Flash $2.50/M)   — 6× cheaper
+    //   cache  $0.01/M                    — 1/10 of input (vs Flash 0.25 discount)
+    // Cliffs are HYPOTHESIZED from Flash's known failure modes — Flash-Lite
+    // is a smaller sibling, so we inherit Flash's cliffs at equal-or-tighter
+    // thresholds. The brain will validate/relax these as evidence accumulates
+    // per (archetype, model) tuple. Currently ZERO brain rows for this model.
+    id: "gemini-2.5-flash-lite",
+    verifiedAgainstDocs: "2026-05-13",
+    provider: "google",
+    status: "current",
+    maxContextTokens: 1048576,
+    maxOutputTokens: 65536,
+    maxTools: 128,
+    parallelToolCalls: true,
+    structuredOutput: "native",
+    systemPromptMode: "separate",
+    streaming: true,
+    cliffs: [
+      {
+        metric: "input_tokens",
+        threshold: 8e3,
+        action: "downgrade_quality_warning",
+        reason: "Inherited from Flash: quality degrades above ~8K. Smaller model \u2014 likely degrades faster. Re-tune from brain after n\u226520."
+      },
+      {
+        metric: "tool_count",
+        threshold: 10,
+        action: "drop_to_top_relevant",
+        reason: "Conservative: Flash drops at 20, Flash-Lite is smaller \u2014 assume tighter ceiling until brain proves otherwise."
+      },
+      {
+        metric: "thinking_with_short_output",
+        threshold: 1,
+        action: "force_thinking_budget_zero",
+        reason: "Thinking enabled per Google API (thinking: true). Same drain risk as Flash \u2014 thinking tokens consume maxOutputTokens."
+      },
+      {
+        // Strong prior: Flash hit 5/5 empty rate on summarize+tools (s11
+        // trust artifact, kgauto commit 3872832). Flash-Lite shares the
+        // same architectural family — almost certainly inherits this cliff.
+        // Ship the guard preemptively; brain telemetry confirms or relaxes.
+        metric: "tool_count",
+        threshold: 1,
+        whenIntent: "summarize",
+        action: "strip_tools",
+        reason: "Inherited from Flash s11 cliff: summarize+tools \u2192 empty response. Preemptive guard until brain evidence on Flash-Lite specifically."
+      }
+    ],
+    costInputPer1m: 0.1,
+    costOutputPer1m: 0.4,
+    lowering: {
+      ...GOOGLE_LOWERING_BASE,
+      // Cache discount 10× (vs Flash 4×) — Google's spec is $0.01/M cache vs
+      // $0.10/M input. Material for repeat-prompt workloads (classify shape).
+      cache: { ...GOOGLE_LOWERING_BASE.cache, discount: 0.1 },
+      thinking: { field: "generationConfig.thinkingConfig.thinkingBudget", default: "auto" }
+    },
+    recovery: [
+      {
+        signal: "empty_response_after_tool",
+        action: "retry_with_params",
+        retryParams: { "generationConfig.thinkingConfig.thinkingBudget": 0 },
+        maxRetries: 1,
+        reason: "Known on Flash family: empty after tool result \u2014 retry with thinking off."
+      },
+      {
+        signal: "empty_response",
+        action: "retry_with_params",
+        retryParams: { "generationConfig.thinkingConfig.thinkingBudget": 0 },
+        maxRetries: 1,
+        reason: "Empty response \u2014 try with thinking off."
+      },
+      {
+        signal: "malformed_function_call",
+        action: "escalate",
+        reason: "MALFORMED_FUNCTION_CALL maps to stop \u2014 escalate to next target."
+      }
+    ],
+    strengths: ["lowest_cost", "speed", "volume", "classification", "summarize", "1m_context", "cache_friendly"],
+    weaknesses: ["complex_reasoning", "large_tool_sets", "complex_schemas", "structured_output_unproven", "long_context_quality"],
+    notes: "Bottom-frontier anchor on cost: $0.10/$0.40 per 1M tokens, 1M context, 65K max output. Released July 2025 (stable). Positioned for classify / summarize / transform archetypes where quality bar is forgiving. Cliffs inherited from Flash at equal-or-tighter thresholds \u2014 re-tune per (archetype) once brain has n\u226520 rows. Alpha.8 contract layer handles MAX_TOKENS-on-structured-output via fallback chain, so structuredOutput=native is safe to declare even though Flash had alpha.8 history. Cache discount in spec: $0.01/M = 1/10 of input (richer than Flash 25%) \u2014 meaningful for repeat-prompt workloads.",
+    // Tier 3 emergency floor for summarize/classify chains. ZERO brain
+    // rows — all values are starter hypotheses anchored to "smaller
+    // sibling of Flash, at-or-below Flash perf on every archetype." The
+    // first 50 brain rows per archetype will validate or relax these.
+    archetypePerf: {
+      classify: 6,
+      // starter hypothesis — verify (Flash is 7, lite likely ≤)
+      summarize: 6,
+      // starter hypothesis — verify; cliff strips tools
+      transform: 6,
+      // starter hypothesis — verify
+      ask: 5,
+      hunt: 5,
+      generate: 4,
+      extract: 4,
+      plan: 3,
+      critique: 3
+    }
   },
   {
     id: "gemini-2.5-pro",
@@ -965,7 +1323,21 @@ var PROFILES_RAW = [
       }
     ],
     strengths: ["reasoning", "1m_context", "structured_output", "tool_use"],
-    weaknesses: ["pricing_above_200k"]
+    weaknesses: ["pricing_above_200k"],
+    // Master plan §3.3 anchor: tier-2 cross-provider in almost every chain.
+    // Sits on the frontier at perf-9 — close to Sonnet but cheaper input.
+    archetypePerf: {
+      critique: 9,
+      plan: 9,
+      ask: 8,
+      generate: 8,
+      extract: 8,
+      transform: 8,
+      hunt: 8,
+      // tier 1 cross-provider for hunt chain
+      summarize: 7,
+      classify: 7
+    }
   },
   {
     id: "gemini-3.1-pro-preview",
@@ -1003,7 +1375,23 @@ var PROFILES_RAW = [
     ],
     strengths: ["reasoning", "1m_context", "agentic_coding", "structured_output", "tool_use"],
     weaknesses: ["cost", "preview_status", "pricing_above_200k"],
-    notes: "Frontier Gemini (preview, 2026-Q2). Step-change agentic coding per Google. Cache discount 10\xD7 (vs 4\xD7 for 2.5 Pro). Use status=preview to flag rollback path until GA."
+    notes: "Frontier Gemini (preview, 2026-Q2). Step-change agentic coding per Google. Cache discount 10\xD7 (vs 4\xD7 for 2.5 Pro). Use status=preview to flag rollback path until GA.",
+    // Frontier-Gemini preview — bumped one notch over 2.5 Pro on agentic
+    // coding / reasoning per Google's release notes. Preview status:
+    // chains should stay on 2.5 Pro until GA. Starter hypothesis.
+    archetypePerf: {
+      critique: 10,
+      // Google claims step-change on reasoning
+      plan: 10,
+      ask: 9,
+      generate: 9,
+      extract: 9,
+      transform: 8,
+      hunt: 9,
+      // step-change agentic per Google
+      summarize: 8,
+      classify: 7
+    }
   },
   // ── DeepSeek ──
   // 2026-05-08 audit (L-073): DeepSeek's `deepseek-chat` was silently aliased
@@ -1043,7 +1431,24 @@ var PROFILES_RAW = [
     ],
     strengths: ["cost", "1m_context", "json_output", "code", "reasoning"],
     weaknesses: ["parallel_tools", "large_tool_sets"],
-    notes: "Cheap workhorse. 1M context, 384k max output. Cache-hit input $0.0028/M (1/50\xD7 of miss). Aliased as `deepseek-chat` (non-thinking) and `deepseek-reasoner` (thinking) \u2014 see ALIASES."
+    notes: "Cheap workhorse. 1M context, 384k max output. Cache-hit input $0.0028/M (1/50\xD7 of miss). Aliased as `deepseek-chat` (non-thinking) and `deepseek-reasoner` (thinking) \u2014 see ALIASES.",
+    // Master plan §6.2 anchor. Brain-validated tier 1 cross-provider for
+    // classify (169 rows, 0% empty). Tier 0 for summarize-with-no-tools.
+    // Falls off on hunt (sequential tools — L-040) and reasoning depth.
+    archetypePerf: {
+      classify: 7,
+      // brain-validated, 169 rows
+      summarize: 7,
+      // archetype-tolerant, no brain evidence yet
+      ask: 6,
+      transform: 6,
+      generate: 5,
+      plan: 5,
+      extract: 5,
+      critique: 4,
+      hunt: 4
+      // sequential tool calls only — L-040
+    }
   },
   {
     id: "deepseek-v4-pro",
@@ -1079,141 +1484,1360 @@ var PROFILES_RAW = [
     ],
     strengths: ["quality", "reasoning", "1m_context", "json_output", "code", "extended_thinking"],
     weaknesses: ["parallel_tools", "large_tool_sets"],
-    notes: "Pro tier. 1M context, 384k max output. Regular pricing $1.74/$3.48; 75% promo through 2026-05-31 ($0.435/$0.87). Default mode = thinking."
-  }
-];
-var ALIASES = {
-  // DeepSeek's own model routing — both names served by V4-Flash.
-  "deepseek-chat": "deepseek-v4-flash",
-  "deepseek-reasoner": "deepseek-v4-flash",
-  // Legacy kgauto typo — actual API alias is dash-form (alpha.1 had dot).
-  "claude-haiku-4.5": "claude-haiku-4-5"
-};
-function canonicalId(id) {
-  return ALIASES[id] ?? id;
-}
-var PROFILE_INDEX = new Map(
-  PROFILES_RAW.map((p) => [p.id, p])
-);
-function getProfile(id) {
-  const canonical = canonicalId(id);
-  const p = PROFILE_INDEX.get(canonical);
-  if (!p) {
-    const known = [...PROFILE_INDEX.keys(), ...Object.keys(ALIASES)].join(", ");
-    throw new Error(`Unknown model id: "${id}". Known: ${known}`);
-  }
-  return p;
-}
-function tryGetProfile(id) {
-  return PROFILE_INDEX.get(canonicalId(id));
-}
-function allProfiles() {
-  return PROFILES_RAW;
-}
-function profilesByProvider(provider) {
-  return PROFILES_RAW.filter((p) => p.provider === provider);
-}
-
-// 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 resolver = opts.profileResolver ?? getProfile;
-  validateIR(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
-  });
-  let workingIR = compressed.value;
-  const accumulatedMutations = [
-    ...sliced.mutations,
-    ...deduped.mutations,
-    ...toolFiltered.mutations,
-    ...compressed.mutations
-  ];
-  const inputTokens = estimateInputTokens(workingIR);
-  const scores = passScoreTargets(workingIR, {
-    estimatedInputTokens: inputTokens,
-    profilesById: resolver,
-    policy: opts.policy
-  });
-  accumulatedMutations.push(...scores.mutations);
-  const target = pickTarget(workingIR, scores.value);
-  if (!target) {
-    throw new Error(
-      `compile(): no allowed model fits the request. Scores: ${JSON.stringify(scores.value, null, 2)}`
-    );
-  }
-  const profile = resolver(target.modelId);
-  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 lowered = lower(workingIR, profile, {
-    forceThinkingZero: cliffs.value.loweringHints.forceThinkingZero,
-    forceTerseOutput: cliffs.value.loweringHints.forceTerseOutput
-  });
-  validateFinalFit(workingIR, profile, inputTokens);
-  const handle = makeHandle();
-  const finalShape = computeShape(workingIR, inputTokens);
-  const _learningKey = learningKey(ir.intent.archetype, profile.id, finalShape);
-  return {
-    handle,
-    target: profile.id,
-    provider: profile.provider,
-    request: lowered.request,
-    tokensIn: inputTokens,
-    estimatedCostUsd: target.estimatedCostUsd,
-    mutationsApplied: accumulatedMutations,
-    fallbackChain,
-    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
+    notes: "Pro tier. 1M context, 384k max output. Regular pricing $1.74/$3.48; 75% promo through 2026-05-31 ($0.435/$0.87). Default mode = thinking.",
+    // Master plan §3.3: tier 3 cross-provider for plan chain. Reasoning
+    // bumped one notch over V4-Flash; same parallel-tool ceiling.
+    archetypePerf: {
+      plan: 7,
+      // §3.3 tier 3 for plan
+      critique: 6,
+      ask: 7,
+      generate: 6,
+      classify: 7,
+      summarize: 7,
+      extract: 6,
+      transform: 6,
+      hunt: 4
+      // sequential tools — same as V4-Flash
     }
-  };
-}
-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 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("; ")}`
-      );
+  },
+  // ── OpenAI ──
+  // alpha.16 (2026-05-17): close the half-supported provider gap. env.ts
+  // already registered OPENAI_API_KEY + executeOpenAI + normalizeOpenAILike
+  // + lowerOpenAI all existed; profile entries were missing, so the
+  // alpha.10 auto-filter would mark openai-keyed models reachable but
+  // there were no profiles to filter IN. Half-supported is now fully
+  // supported. PB request `openai-provider-profiles` (2026-05-16).
+  //
+  // Profile data verified against developers.openai.com/api/docs/pricing
+  // + per-model pages 2026-05-17. L-049/L-081 step-zero: no AI-trained
+  // numbers — fetched live from OpenAI's docs. As of 2026-05, OpenAI's
+  // current flagship is gpt-5.5 (2025-12 cutoff); gpt-5.4-{base,mini,nano}
+  // are the workhorse family. gpt-4.1 + gpt-4o are legacy.
+  //
+  // Both 5.5 and 5.4 carry a 272K input-token pricing cliff (2x input,
+  // 1.5x output beyond that). Modeled as a `downgrade_quality_warning`
+  // cliff because it ranks the model down at large-context shapes — the
+  // semantics of "this model is now 2x more expensive" map onto the
+  // existing penalty mechanism. Cost-watcher will catch high-context
+  // spikes empirically; the cliff prevents naive routing into the doubled
+  // pricing zone.
+  {
+    id: "gpt-5.5",
+    verifiedAgainstDocs: "2026-05-17",
+    provider: "openai",
+    status: "current",
+    maxContextTokens: 105e4,
+    maxOutputTokens: 128e3,
+    maxTools: 64,
+    parallelToolCalls: true,
+    structuredOutput: "native",
+    systemPromptMode: "inline",
+    streaming: true,
+    cliffs: [
+      {
+        metric: "input_tokens",
+        threshold: 272e3,
+        action: "downgrade_quality_warning",
+        reason: "OpenAI pricing tier shift: >272K input tokens billed at 2x input + 1.5x output rates"
+      }
+    ],
+    costInputPer1m: 5,
+    costOutputPer1m: 30,
+    lowering: {
+      system: { mode: "inline" },
+      // OpenAI caching is implicit (auto-applied to repeated prefixes
+      // ≥1024 tokens for prompt_tokens_details.cached_tokens). No
+      // wire-format marker. Discount: 10x for cached input ($0.50/$5.00).
+      cache: { strategy: "unsupported", minTokens: 1024, discount: 0.1 },
+      tools: { format: "openai" }
+    },
+    recovery: [
+      { signal: "rate_limit", action: "escalate", reason: "429 \u2014 escalate to fallback chain" },
+      { signal: "model_not_found", action: "escalate", reason: "Model deprecated/renamed \u2014 escalate (L-061)" }
+    ],
+    strengths: ["reasoning", "agentic_coding", "long_context", "structured_output", "reliable_tool_use", "reasoning_effort_knob"],
+    weaknesses: ["cost", "pricing_cliff_at_272k"],
+    notes: "OpenAI frontier (2026-05). 1M context (1.05M total), 128K max output, 2025-12 cutoff. Reasoning effort knob (none/low/medium/high/xhigh). Pricing cliff at 272K input.",
+    // Frontier-tier perf hypothesis. Anchored to Opus 4.7 row (similar
+    // price/positioning). Brain evidence will refine; no telemetry yet.
+    archetypePerf: {
+      critique: 9,
+      plan: 9,
+      generate: 9,
+      ask: 9,
+      extract: 9,
+      transform: 9,
+      hunt: 8,
+      // parallel tool support good but cliff at 272K hurts deep multi-step
+      summarize: 7,
+      // overkill for tolerant archetype
+      classify: 7
+      // overkill; cheaper models cover this
     }
-  }
-  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})`
+  },
+  {
+    id: "gpt-5.4",
+    verifiedAgainstDocs: "2026-05-17",
+    provider: "openai",
+    status: "current",
+    maxContextTokens: 105e4,
+    maxOutputTokens: 128e3,
+    maxTools: 64,
+    parallelToolCalls: true,
+    structuredOutput: "native",
+    systemPromptMode: "inline",
+    streaming: true,
+    cliffs: [
+      {
+        metric: "input_tokens",
+        threshold: 272e3,
+        action: "downgrade_quality_warning",
+        reason: "OpenAI pricing tier shift: >272K input tokens billed at 2x input + 1.5x output rates"
+      }
+    ],
+    costInputPer1m: 2.5,
+    costOutputPer1m: 15,
+    lowering: {
+      system: { mode: "inline" },
+      cache: { strategy: "unsupported", minTokens: 1024, discount: 0.1 },
+      tools: { format: "openai" }
+    },
+    recovery: [
+      { signal: "rate_limit", action: "escalate", reason: "429 \u2014 escalate to fallback chain" },
+      { signal: "model_not_found", action: "escalate", reason: "Model deprecated/renamed \u2014 escalate (L-061)" }
+    ],
+    strengths: ["reasoning", "long_context", "structured_output", "reliable_tool_use"],
+    weaknesses: ["pricing_cliff_at_272k"],
+    notes: "OpenAI workhorse (2026-05). 1M context (1.05M total), 128K max output, 2025-08 cutoff. Pricing cliff at 272K input. Pairs cleanly with Sonnet 4.6 on cost ($2.50/$15.00 vs $3.00/$15.00).",
+    // Anchored to Sonnet 4.6 row (similar price/positioning). Slight
+    // anthropic-side edge on agentic coding per master plan vibe.
+    archetypePerf: {
+      critique: 8,
+      plan: 8,
+      generate: 8,
+      ask: 8,
+      extract: 8,
+      transform: 8,
+      hunt: 7,
+      summarize: 7,
+      classify: 7
+    }
+  },
+  {
+    id: "gpt-5.4-mini",
+    verifiedAgainstDocs: "2026-05-17",
+    provider: "openai",
+    status: "current",
+    maxContextTokens: 4e5,
+    maxOutputTokens: 128e3,
+    maxTools: 64,
+    parallelToolCalls: true,
+    structuredOutput: "native",
+    systemPromptMode: "inline",
+    streaming: true,
+    cliffs: [],
+    costInputPer1m: 0.75,
+    costOutputPer1m: 4.5,
+    lowering: {
+      system: { mode: "inline" },
+      cache: { strategy: "unsupported", minTokens: 1024, discount: 0.1 },
+      tools: { format: "openai" }
+    },
+    recovery: [
+      { signal: "rate_limit", action: "escalate", reason: "429 \u2014 escalate to fallback chain" },
+      { signal: "model_not_found", action: "escalate", reason: "Model deprecated/renamed \u2014 escalate (L-061)" }
+    ],
+    strengths: ["cost", "speed", "agentic_coding", "structured_output", "reliable_tool_use"],
+    weaknesses: ["reasoning_depth"],
+    notes: "OpenAI mini-tier (2026-05). 400K context, 128K max output, 2025-08 cutoff. OpenAI describes as 'strongest mini model for coding, computer use, subagents.' Cache discount 10x ($0.075 input).",
+    // Mini-tier hypothesis. Anchored to Haiku 4.5 + Flash row pricing.
+    // Cost is slightly higher than Haiku ($0.75 vs $0.50 input) but
+    // OpenAI claims strong coding/subagent perf.
+    archetypePerf: {
+      ask: 7,
+      generate: 7,
+      extract: 7,
+      transform: 7,
+      classify: 7,
+      summarize: 7,
+      hunt: 7,
+      plan: 6,
+      critique: 5
+      // reasoning depth gap — frontier models handle this
+    }
+  },
+  {
+    id: "gpt-5.4-nano",
+    verifiedAgainstDocs: "2026-05-17",
+    provider: "openai",
+    status: "current",
+    maxContextTokens: 4e5,
+    maxOutputTokens: 128e3,
+    maxTools: 64,
+    parallelToolCalls: true,
+    structuredOutput: "native",
+    systemPromptMode: "inline",
+    streaming: true,
+    cliffs: [],
+    costInputPer1m: 0.2,
+    costOutputPer1m: 1.25,
+    lowering: {
+      system: { mode: "inline" },
+      cache: { strategy: "unsupported", minTokens: 1024, discount: 0.1 },
+      tools: { format: "openai" }
+    },
+    recovery: [
+      { signal: "rate_limit", action: "escalate", reason: "429 \u2014 escalate to fallback chain" },
+      { signal: "model_not_found", action: "escalate", reason: "Model deprecated/renamed \u2014 escalate (L-061)" }
+    ],
+    strengths: ["cost", "speed", "volume", "structured_output"],
+    weaknesses: ["reasoning_depth", "no_computer_use"],
+    notes: "OpenAI nano-tier (2026-05). 400K context, 128K max output, 2025-08 cutoff. 'Cheapest GPT-5.4-class for simple high-volume tasks.' No fine-tuning, no computer-use tools. Cache discount 10x.",
+    // Nano-tier. Anchored to Flash-Lite row ($0.10/$0.40 vs nano's
+    // $0.20/$1.25). Slightly more expensive than Flash-Lite but with
+    // OpenAI brand reliability. Good fit for classify/summarize floor.
+    archetypePerf: {
+      classify: 7,
+      summarize: 6,
+      ask: 6,
+      transform: 6,
+      extract: 6,
+      generate: 5,
+      hunt: 5,
+      plan: 4,
+      critique: 3
+      // not for reasoning archetypes
+    }
+  },
+  // ── Auto-onboarded (UNVERIFIED) ──
+  // Cloned by scripts/auto-onboard-models.mjs from a same-family template.
+  // Each entry's pricing/context/cliffs/lowering reflects the template, NOT
+  // provider docs. Verify before promoting status to 'current' (L-049/L-081).
+  {
+    // s37 (2026-05-21): UNVERIFIED-AUTO-ONBOARD → verified against
+    // ai.google.dev/gemini-api/docs/models/gemini-3-flash-preview +
+    // ai.google.dev/gemini-api/docs/pricing. L-081 catches:
+    //   maxOutputTokens 65_535 → 65_536 (off-by-one)
+    //   costInputPer1m  0.30 → 0.50  (template-cloned from 2.5-flash; actual is 1.67× more expensive)
+    //   costOutputPer1m 2.50 → 3.00  (template-cloned; actual 1.2× more expensive)
+    //   cache discount  default 0.25 → 0.10 (10× discount, $0.05/$0.50 per docs)
+    // Cliffs inherited from 2.5-flash conservatively. The 8K-context-quality
+    // cliff was a 2.5-Flash observation — Google positions Gemini 3 as
+    // sustained-frontier-on-long-context; brain evidence will validate/relax.
+    // Kept as guard for now.
+    id: "gemini-3-flash-preview",
+    verifiedAgainstDocs: "2026-05-21",
+    provider: "google",
+    status: "preview",
+    maxContextTokens: 1048576,
+    maxOutputTokens: 65536,
+    maxTools: 128,
+    parallelToolCalls: true,
+    structuredOutput: "native",
+    systemPromptMode: "separate",
+    streaming: true,
+    cliffs: [
+      {
+        metric: "input_tokens",
+        threshold: 8e3,
+        action: "downgrade_quality_warning",
+        reason: "Inherited from 2.5-flash guard; brain evidence on Gemini 3 long-context quality will validate/relax"
+      },
+      {
+        metric: "tool_count",
+        threshold: 20,
+        action: "drop_to_top_relevant",
+        reason: "Tool reliability drops above ~20 tools (despite 128 hard limit) \u2014 inherited from Flash family"
+      },
+      {
+        metric: "thinking_with_short_output",
+        threshold: 1,
+        action: "force_thinking_budget_zero",
+        reason: "Thinking tokens consume maxOutputTokens \u2014 empty response if drained"
+      },
+      {
+        // Inherited from gemini-2.5-flash s11 trust artifact. Family-likely
+        // failure mode for Flash architecture. Keep preemptively until brain
+        // evidence on Gemini 3 specifically.
+        metric: "tool_count",
+        threshold: 1,
+        whenIntent: "summarize",
+        action: "strip_tools",
+        reason: "Inherited from 2.5-flash s11 cliff: summarize+tools \u2192 empty response. Preemptive guard until brain evidence on 3-flash-preview specifically."
+      }
+    ],
+    costInputPer1m: 0.5,
+    costOutputPer1m: 3,
+    lowering: {
+      ...GOOGLE_LOWERING_BASE,
+      // 10× cache discount per Google pricing: $0.05/M cached vs $0.50/M input.
+      cache: { ...GOOGLE_LOWERING_BASE.cache, discount: 0.1 },
+      thinking: { field: "generationConfig.thinkingConfig.thinkingBudget", default: "auto" }
+    },
+    recovery: [
+      {
+        signal: "empty_response_after_tool",
+        action: "retry_with_params",
+        retryParams: { "generationConfig.thinkingConfig.thinkingBudget": 0 },
+        maxRetries: 1,
+        reason: "Known: empty after tool result \u2014 retry with thinking off"
+      },
+      {
+        signal: "empty_response",
+        action: "retry_with_params",
+        retryParams: { "generationConfig.thinkingConfig.thinkingBudget": 0 },
+        maxRetries: 1,
+        reason: "Empty response \u2014 try with thinking off"
+      },
+      {
+        signal: "malformed_function_call",
+        action: "escalate",
+        reason: "MALFORMED_FUNCTION_CALL maps to stop \u2014 escalate to next target"
+      }
+    ],
+    strengths: ["speed", "volume", "classification", "1m_context", "cost"],
+    weaknesses: ["complex_schemas", "large_tool_sets", "high_context_quality"],
+    notes: "Verified s37 (2026-05-21) against Google docs. Step-change positioning vs 2.5-flash on agentic loops per Google's release notes (Dec 2025). Pricing 1.67\xD7/1.2\xD7 higher than 2.5-flash; cache discount 10\xD7 (vs 4\xD7 for 2.5). Status=preview until brain evidence accumulates.",
+    // Anchored to 2.5-flash archetypePerf as starter, with judgment adjustments
+    // for Google's "step-change on agentic" positioning. Brain evidence (zero
+    // rows today) will replace these starter values.
+    archetypePerf: {
+      hunt: 9,
+      // Inherits 2.5-flash L-040 parallel-tool tier; Google positions 3 as agentic-loop upgrade
+      classify: 7,
+      // Inherits 2.5-flash brain-validated tier (218 rows on 2.5)
+      summarize: 7,
+      // Inherits 2.5-flash; cliff strips tools when present
+      transform: 7,
+      ask: 8,
+      // +1 vs 2.5-flash — sustained-frontier positioning
+      generate: 7,
+      // +1 vs 2.5-flash — agentic coding upgrade per Google
+      plan: 6,
+      // +1 vs 2.5-flash — complex iterations per positioning
+      extract: 6,
+      critique: 5
+      // +1 vs 2.5-flash — but still below Sonnet/Opus reasoning floor
+    }
+  },
+  {
+    // ── Gemini 3.1 Flash-Lite ──
+    // Onboarded 2026-05-16 by auto-onboarder; s37 (2026-05-21) verified
+    // against ai.google.dev/gemini-api/docs/pricing.
+    //
+    // L-081 CATCHES (template clone from 2.5-flash-lite was 2.5-3.75× too cheap):
+    //   costInputPer1m  0.10 → 0.25 (template clone undervalued by 2.5×)
+    //   costOutputPer1m 0.40 → 1.50 (template clone undervalued by 3.75×)
+    //
+    // Real 3.1-flash-lite is NOT a cost-equivalent successor to 2.5-flash-lite —
+    // it sits between 2.5-flash-lite ($0.10/$0.40) and 2.5-flash ($0.30/$2.50).
+    // Cache discount 10× verified ($0.025/M cached vs $0.25/M input).
+    //
+    // Cliffs are HYPOTHESIZED from 2.5-flash family; brain evidence pending.
+    id: "gemini-3.1-flash-lite",
+    verifiedAgainstDocs: "2026-05-21",
+    provider: "google",
+    status: "preview",
+    maxContextTokens: 1048576,
+    maxOutputTokens: 65536,
+    maxTools: 128,
+    parallelToolCalls: true,
+    structuredOutput: "native",
+    systemPromptMode: "separate",
+    streaming: true,
+    cliffs: [
+      {
+        metric: "input_tokens",
+        threshold: 8e3,
+        action: "downgrade_quality_warning",
+        reason: "Inherited from Flash: quality degrades above ~8K. Smaller model \u2014 likely degrades faster. Re-tune from brain after n\u226520."
+      },
+      {
+        metric: "tool_count",
+        threshold: 10,
+        action: "drop_to_top_relevant",
+        reason: "Conservative: Flash drops at 20, Flash-Lite is smaller \u2014 assume tighter ceiling until brain proves otherwise."
+      },
+      {
+        metric: "thinking_with_short_output",
+        threshold: 1,
+        action: "force_thinking_budget_zero",
+        reason: "Thinking enabled per Google API (thinking: true). Same drain risk as Flash \u2014 thinking tokens consume maxOutputTokens."
+      },
+      {
+        // Strong prior: Flash hit 5/5 empty rate on summarize+tools (s11
+        // trust artifact, kgauto commit 3872832). Flash-Lite shares the
+        // same architectural family — almost certainly inherits this cliff.
+        // Ship the guard preemptively; brain telemetry confirms or relaxes.
+        metric: "tool_count",
+        threshold: 1,
+        whenIntent: "summarize",
+        action: "strip_tools",
+        reason: "Inherited from Flash s11 cliff: summarize+tools \u2192 empty response. Preemptive guard until brain evidence on Flash-Lite specifically."
+      }
+    ],
+    costInputPer1m: 0.25,
+    costOutputPer1m: 1.5,
+    lowering: {
+      ...GOOGLE_LOWERING_BASE,
+      // Cache discount 10× (vs Flash 4×) — Google docs s37: $0.025/M cached vs
+      // $0.25/M input. Material for repeat-prompt workloads (classify shape).
+      cache: { ...GOOGLE_LOWERING_BASE.cache, discount: 0.1 },
+      thinking: { field: "generationConfig.thinkingConfig.thinkingBudget", default: "auto" }
+    },
+    recovery: [
+      {
+        signal: "empty_response_after_tool",
+        action: "retry_with_params",
+        retryParams: { "generationConfig.thinkingConfig.thinkingBudget": 0 },
+        maxRetries: 1,
+        reason: "Known on Flash family: empty after tool result \u2014 retry with thinking off."
+      },
+      {
+        signal: "empty_response",
+        action: "retry_with_params",
+        retryParams: { "generationConfig.thinkingConfig.thinkingBudget": 0 },
+        maxRetries: 1,
+        reason: "Empty response \u2014 try with thinking off."
+      },
+      {
+        signal: "malformed_function_call",
+        action: "escalate",
+        reason: "MALFORMED_FUNCTION_CALL maps to stop \u2014 escalate to next target."
+      }
+    ],
+    strengths: ["low_cost", "speed", "volume", "classification", "summarize", "1m_context", "cache_friendly"],
+    weaknesses: ["complex_reasoning", "large_tool_sets", "complex_schemas", "structured_output_unproven", "long_context_quality"],
+    notes: "Verified s37 (2026-05-21) against Google docs. Sits between 2.5-flash-lite (cheaper) and 2.5-flash (more expensive) on cost frontier; 2.5\xD7 more expensive than initial template-clone. Cliffs hypothesized from Flash family \u2014 brain evidence pending.",
+    // Tier 2-3 floor for summarize/classify chains at the new (verified) price
+    // point. ZERO brain rows — values are starter hypotheses anchored to
+    // "smaller sibling of Flash at higher cost than 2.5-flash-lite." The first
+    // 50 brain rows per archetype will validate or relax these.
+    archetypePerf: {
+      classify: 6,
+      // starter hypothesis — verify (Flash is 7, lite likely ≤)
+      summarize: 6,
+      // starter hypothesis — verify; cliff strips tools
+      transform: 6,
+      // starter hypothesis — verify
+      ask: 5,
+      hunt: 5,
+      generate: 4,
+      extract: 4,
+      plan: 3,
+      critique: 3
+    }
+  },
+  // ─────────────────────────────────────────────────────────────────────────
+  // Gemini 3.5 Flash — hand-onboarded s37 (2026-05-21)
+  //
+  // Google positioning ("Most intelligent for sustained frontier performance
+  // on agentic and coding tasks" / "particularly effective for rapid agentic
+  // loops involving complex coding cycles and iterations") suggests this is
+  // the Flash-family upgrade specifically aimed at hunt-shape workloads.
+  // Pricing 5× input / 3.6× output vs 2.5-flash — material cost premium.
+  // archetypePerf adjusted +1 vs 2.5-flash on ask/generate/plan/critique
+  // (sustained-frontier positioning); hunt held at 9 inherited from L-040
+  // family parallel-tool tier; brain evidence will validate within 50 rows.
+  //
+  // Cliffs inherited conservatively from 2.5-flash. Google's "sustained
+  // frontier on long-context" positioning suggests the 8K cliff may not
+  // apply to 3.5 — keep as guard until brain evidence shows otherwise.
+  //
+  // Specs verified against:
+  //   ai.google.dev/gemini-api/docs/models/gemini-3.5-flash
+  //   ai.google.dev/gemini-api/docs/pricing (Standard tier)
+  // ─────────────────────────────────────────────────────────────────────────
+  {
+    id: "gemini-3.5-flash",
+    verifiedAgainstDocs: "2026-05-21",
+    provider: "google",
+    status: "current",
+    maxContextTokens: 1048576,
+    maxOutputTokens: 65536,
+    maxTools: 128,
+    parallelToolCalls: true,
+    structuredOutput: "native",
+    systemPromptMode: "separate",
+    streaming: true,
+    cliffs: [
+      {
+        metric: "input_tokens",
+        threshold: 8e3,
+        action: "downgrade_quality_warning",
+        reason: "Inherited from 2.5-flash guard; Google positions 3.5 as sustained-frontier-on-long-context but brain evidence pending"
+      },
+      {
+        metric: "tool_count",
+        threshold: 20,
+        action: "drop_to_top_relevant",
+        reason: "Inherited from Flash family: tool reliability drops above ~20 (despite 128 hard limit). Validate per (archetype, model) after n\u226520."
+      },
+      {
+        metric: "thinking_with_short_output",
+        threshold: 1,
+        action: "force_thinking_budget_zero",
+        reason: "Thinking mode supported per Google docs; same drain risk as 2.5-flash \u2014 thinking tokens consume maxOutputTokens"
+      },
+      {
+        // Inherited from 2.5-flash s11 trust artifact (5/5 empty rate on
+        // tt-intelligence/summarize/gemini-2.5-flash with tools offered).
+        // Family-likely failure mode for Flash architecture across versions.
+        // Keep preemptively until brain evidence on 3.5-flash specifically.
+        metric: "tool_count",
+        threshold: 1,
+        whenIntent: "summarize",
+        action: "strip_tools",
+        reason: "Inherited from 2.5-flash s11 cliff (kgauto commit 3872832): summarize+tools \u2192 empty response. Preemptive guard until brain evidence on 3.5-flash specifically."
+      }
+    ],
+    costInputPer1m: 1.5,
+    costOutputPer1m: 9,
+    lowering: {
+      ...GOOGLE_LOWERING_BASE,
+      // 10× cache discount per Google pricing: $0.15/M cached vs $1.50/M input.
+      cache: { ...GOOGLE_LOWERING_BASE.cache, discount: 0.1 },
+      thinking: { field: "generationConfig.thinkingConfig.thinkingBudget", default: "auto" }
+    },
+    recovery: [
+      {
+        signal: "empty_response_after_tool",
+        action: "retry_with_params",
+        retryParams: { "generationConfig.thinkingConfig.thinkingBudget": 0 },
+        maxRetries: 1,
+        reason: "Inherited Flash-family pattern: empty after tool result \u2014 retry with thinking off"
+      },
+      {
+        signal: "empty_response",
+        action: "retry_with_params",
+        retryParams: { "generationConfig.thinkingConfig.thinkingBudget": 0 },
+        maxRetries: 1,
+        reason: "Empty response \u2014 try with thinking off"
+      },
+      {
+        signal: "malformed_function_call",
+        action: "escalate",
+        reason: "MALFORMED_FUNCTION_CALL maps to stop \u2014 escalate to next target"
+      }
+    ],
+    strengths: ["agentic_loops", "coding", "1m_context", "parallel_tools", "thinking_mode", "sustained_frontier"],
+    weaknesses: ["cost_vs_2_5_flash", "no_brain_evidence_yet"],
+    notes: "Hand-onboarded s37 (2026-05-21) verified against Google docs. Stable status; positioned as Flash-family upgrade for agentic loops and coding. 5\xD7/3.6\xD7 more expensive than 2.5-flash but Google claims step-change on sustained frontier work. archetypePerf adjustments are judgment-grounded starter hypotheses \u2014 brain evidence will validate within ~50 rows per archetype.",
+    // Starter hypothesis: anchored to 2.5-flash archetypePerf with +1
+    // adjustments where Google's positioning explicitly supports
+    // (agentic/coding/sustained). Hunt held at 9 inherited from L-040 family
+    // parallel-tool tier. Brain evidence will replace.
+    archetypePerf: {
+      hunt: 9,
+      // Inherited from 2.5-flash L-040 parallel-tool tier; Google positions 3.5 as agentic-loop champion
+      classify: 7,
+      // Inherited from 2.5-flash brain-validated tier (218 rows on 2.5)
+      summarize: 7,
+      // Inherited from 2.5-flash; cliff strips tools when present
+      transform: 7,
+      ask: 8,
+      // +1 vs 2.5-flash — sustained-frontier positioning
+      generate: 8,
+      // +1 vs 2.5-flash (6→8) — Google: "complex coding cycles and iterations"
+      plan: 7,
+      // +1 vs 2.5-flash (5→7) — "complex iterations" positioning
+      extract: 7,
+      // +1 vs 2.5-flash — sustained-frontier on structured tasks
+      critique: 5
+      // +1 vs 2.5-flash — but still below Sonnet/Opus reasoning floor
+    }
+  }
+];
+var ALIASES = {
+  // DeepSeek's own model routing — both names served by V4-Flash.
+  "deepseek-chat": "deepseek-v4-flash",
+  "deepseek-reasoner": "deepseek-v4-flash",
+  // Legacy kgauto typo — actual API alias is dash-form (alpha.1 had dot).
+  "claude-haiku-4.5": "claude-haiku-4-5"
+};
+var brainHook = {};
+function _setProfileBrainHook(hook) {
+  brainHook = hook;
+}
+function canonicalId(id) {
+  return brainHook.resolveAlias?.(id) ?? ALIASES[id] ?? id;
+}
+var PROFILE_INDEX = new Map(
+  PROFILES_RAW.map((p) => [p.id, p])
+);
+function getProfile(id) {
+  const canonical = canonicalId(id);
+  const fromBrain = brainHook.getProfile?.(canonical);
+  if (fromBrain) return fromBrain;
+  const p = PROFILE_INDEX.get(canonical);
+  if (!p) {
+    const known = [...PROFILE_INDEX.keys(), ...Object.keys(ALIASES)].join(", ");
+    throw new Error(`Unknown model id: "${id}". Known: ${known}`);
+  }
+  return p;
+}
+function tryGetProfile(id) {
+  const canonical = canonicalId(id);
+  return brainHook.getProfile?.(canonical) ?? PROFILE_INDEX.get(canonical);
+}
+function allProfiles() {
+  return PROFILES_RAW;
+}
+function allProfilesRaw() {
+  return PROFILES_RAW;
+}
+function profilesByProvider(provider) {
+  return PROFILES_RAW.filter((p) => p.provider === provider);
+}
+
+// src/brain-query.ts
+var FRESH_SNAPSHOT = {
+  data: null,
+  expiresAt: 0,
+  refreshing: false,
+  warned: false
+};
+var snapshot = { ...FRESH_SNAPSHOT };
+var runtime;
+function configureBrainQuery(rt) {
+  runtime = rt;
+  snapshot = { ...FRESH_SNAPSHOT };
+}
+function createBrainQueryCache(opts) {
+  return () => {
+    const rt = runtime;
+    if (!rt || !rt.enabledTables.has(opts.table)) {
+      return opts.bundledFallback();
+    }
+    const now = Date.now();
+    const stale = snapshot.expiresAt <= now;
+    if (stale && !snapshot.refreshing) {
+      snapshot.refreshing = true;
+      void asyncRefresh(rt);
+    }
+    if (snapshot.data) {
+      const rows = snapshot.data[opts.table];
+      if (Array.isArray(rows) && rows.length > 0) {
+        try {
+          return opts.mapRows(rows);
+        } catch {
+          return opts.bundledFallback();
+        }
+      }
+    }
+    return opts.bundledFallback();
+  };
+}
+var pendingRefresh;
+async function asyncRefresh(rt) {
+  const promise = doRefresh(rt);
+  pendingRefresh = promise;
+  try {
+    await promise;
+  } finally {
+    if (pendingRefresh === promise) pendingRefresh = void 0;
+  }
+}
+var DEFAULT_CONFIG_URL = "https://kgauto-dashboard.vercel.app/api/kgauto-v2/config";
+async function doRefresh(rt) {
+  const url = rt.configEndpoint ?? DEFAULT_CONFIG_URL;
+  try {
+    const res = await rt.fetchImpl(url, { method: "GET" });
+    if (!res.ok) {
+      throw new Error(`brain-query ${res.status}: ${res.statusText}`);
+    }
+    const body = await res.json();
+    if (runtime !== rt) return;
+    snapshot = {
+      data: body,
+      expiresAt: Date.now() + rt.ttlMs,
+      refreshing: false,
+      warned: snapshot.warned
+    };
+  } catch (err) {
+    if (runtime !== rt) return;
+    snapshot.refreshing = false;
+    snapshot.expiresAt = Date.now() + rt.ttlMs;
+    if (!snapshot.warned) {
+      snapshot.warned = true;
+      (rt.onError ?? defaultOnError)(err);
+    }
+  }
+}
+function defaultOnError(err) {
+  console.warn("[kgauto] brain-query failed (using bundled fallback):", err);
+}
+function isBrainQueryActiveFor(table) {
+  return runtime !== void 0 && runtime.enabledTables.has(table);
+}
+async function getPerAxisMetrics(opts) {
+  const fetchFn = opts.fetch ?? fetch;
+  const endpoint = opts.endpoint ?? runtime?.endpoint;
+  if (!endpoint) return null;
+  const windowDays = opts.windowDays ?? 30;
+  const body = {
+    p_app_id: opts.appId,
+    p_archetype: opts.archetype,
+    p_model: opts.model,
+    p_window_days: windowDays,
+    p_quality_floor: opts.qualityFloor ?? null
+  };
+  const headers = {
+    Accept: "application/json",
+    "Content-Type": "application/json",
+    ...opts.apiKey ? { Authorization: `Bearer ${opts.apiKey}` } : {}
+  };
+  try {
+    const res = await fetchFn(`${endpoint}/rpc/get_per_axis_metrics`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) return null;
+    const raw = await res.json();
+    return mapPerAxisMetrics(raw, opts.appId, opts.archetype, opts.model, windowDays);
+  } catch {
+    return null;
+  }
+}
+function mapPerAxisMetrics(raw, fallbackAppId, fallbackArchetype, fallbackModel, fallbackWindowDays) {
+  if (raw === null || raw === void 0) return null;
+  if (typeof raw !== "object") return null;
+  const r = raw;
+  if (Array.isArray(raw)) {
+    if (raw.length === 0) return null;
+    return mapPerAxisMetrics(raw[0], fallbackAppId, fallbackArchetype, fallbackModel, fallbackWindowDays);
+  }
+  const num = (v) => {
+    if (v === null || v === void 0) return null;
+    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;
+  };
+  const int = (v) => {
+    const n = num(v);
+    return n === null ? 0 : Math.trunc(n);
+  };
+  const bool = (v) => {
+    if (v === null || v === void 0) return null;
+    if (typeof v === "boolean") return v;
+    return null;
+  };
+  const str = (v, fallback) => typeof v === "string" ? v : fallback;
+  const cost = r.cost_efficiency ?? {};
+  const time = r.time_efficiency ?? {};
+  const rel = r.reliability ?? {};
+  return {
+    appId: str(r.app_id, fallbackAppId),
+    archetype: str(r.archetype, fallbackArchetype),
+    model: str(r.model, fallbackModel),
+    windowDays: num(r.window_days) ?? fallbackWindowDays,
+    nRows: int(r.n_rows),
+    nRowsClean: int(r.n_rows_clean),
+    nQualityOutcomes: int(r.n_quality_outcomes),
+    magicRate: num(r.magic_rate),
+    qualityFloorMet: bool(r.quality_floor_met),
+    costEfficiency: {
+      avgCostUsd: num(cost.avg_cost_usd),
+      avgCostUsdClean: num(cost.avg_cost_usd_clean),
+      avgInputTokens: num(cost.avg_input_tokens),
+      avgOutputTokens: num(cost.avg_output_tokens),
+      inputTokenRatio: num(cost.input_token_ratio)
+    },
+    timeEfficiency: {
+      avgLatencyMs: num(time.avg_latency_ms),
+      avgTtftMs: num(time.avg_ttft_ms)
+    },
+    reliability: {
+      successRate: num(rel.success_rate),
+      successRateClean: num(rel.success_rate_clean),
+      emptyRate: num(rel.empty_rate),
+      emptyRateClean: num(rel.empty_rate_clean)
+    },
+    evidenceFreshnessDays: num(r.evidence_freshness_days)
+  };
+}
+
+// src/archetype-perf-brain.ts
+function isPerfRow(x) {
+  if (!x || typeof x !== "object") return false;
+  const r = x;
+  return typeof r.model_id === "string" && typeof r.archetype === "string" && typeof r.perf_score === "number";
+}
+function mapRowsToPerfMap(rows) {
+  const out = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (!isPerfRow(row)) continue;
+    const existing = out.get(row.model_id) ?? {};
+    existing[row.archetype] = row.perf_score;
+    out.set(row.model_id, existing);
+  }
+  return out;
+}
+function mapRowsToNMap(rows) {
+  const out = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (!isPerfRow(row)) continue;
+    if (typeof row.n !== "number") continue;
+    const existing = out.get(row.model_id) ?? {};
+    existing[row.archetype] = row.n;
+    out.set(row.model_id, existing);
+  }
+  return out;
+}
+function bundledArchetypePerf() {
+  const out = /* @__PURE__ */ new Map();
+  for (const profile of allProfiles()) {
+    if (profile.archetypePerf) out.set(profile.id, profile.archetypePerf);
+  }
+  return out;
+}
+function bundledArchetypePerfN() {
+  return /* @__PURE__ */ new Map();
+}
+var loadArchetypePerfFromBrain = createBrainQueryCache({
+  table: "kgauto_archetype_perf",
+  mapRows: mapRowsToPerfMap,
+  bundledFallback: bundledArchetypePerf
+});
+var loadArchetypePerfNFromBrain = createBrainQueryCache(
+  {
+    table: "kgauto_archetype_perf",
+    mapRows: mapRowsToNMap,
+    bundledFallback: bundledArchetypePerfN
+  }
+);
+var MEASURED_GROUNDING_MIN_N = 10;
+function getArchetypePerfScore(modelId, archetype) {
+  const score = loadArchetypePerfFromBrain().get(modelId)?.[archetype] ?? 5;
+  const n = loadArchetypePerfNFromBrain().get(modelId)?.[archetype] ?? 0;
+  const grounding = n >= MEASURED_GROUNDING_MIN_N ? "measured" : "judgment";
+  return { score, n, grounding };
+}
+
+// src/compatibility.ts
+var ARCHETYPE_FLOOR_DEFAULT = 6;
+var ABSOLUTE_FLOOR = 4;
+function rawArchetypePerf(profile, archetype) {
+  return profile.archetypePerf?.[archetype] ?? 5;
+}
+function hasSequentialToolCliffForHunt(profile) {
+  if (profile.parallelToolCalls !== false) return false;
+  const huntScore = profile.archetypePerf?.hunt ?? 5;
+  return huntScore < ARCHETYPE_FLOOR_DEFAULT;
+}
+function adapterForCliff(profile, archetype) {
+  if (archetype === "hunt" && hasSequentialToolCliffForHunt(profile)) {
+    const otherScores = [];
+    if (profile.archetypePerf) {
+      for (const [k, v] of Object.entries(profile.archetypePerf)) {
+        if (k === "hunt") continue;
+        if (typeof v === "number") otherScores.push(v);
+      }
+    }
+    const sorted = [...otherScores].sort((a, b) => a - b);
+    const median = sorted.length === 0 ? ARCHETYPE_FLOOR_DEFAULT + 1 : sorted[Math.floor(sorted.length / 2)] ?? ARCHETYPE_FLOOR_DEFAULT + 1;
+    const estimated = Math.max(ARCHETYPE_FLOOR_DEFAULT + 1, median);
+    return {
+      adapter: {
+        parameter: "toolOrchestration",
+        value: "sequential",
+        consequence: "Tool calls run one at a time instead of in parallel \u2014 slower per step but reliable for this model."
+      },
+      estimatedScoreWithAdapter: estimated
+    };
+  }
+  return void 0;
+}
+function archetypeDescriptor(archetype) {
+  return archetype;
+}
+function getModelCompatibility(modelId, intent) {
+  const profile = tryGetProfile(modelId);
+  if (!profile) {
+    return {
+      status: "reject",
+      reason: `Model "${modelId}" is not registered with kgauto \u2014 no compatibility data available.`,
+      archetypePerf: 0
+    };
+  }
+  const { archetype, toolOrchestration } = intent;
+  const rawScore = rawArchetypePerf(profile, archetype);
+  const descriptor = archetypeDescriptor(archetype);
+  const adapterMatch = adapterForCliff(profile, archetype);
+  if (toolOrchestration === "sequential" && adapterMatch && adapterMatch.adapter.parameter === "toolOrchestration" && adapterMatch.adapter.value === "sequential") {
+    return {
+      status: "compatible",
+      reason: `Suited for ${descriptor} with sequential tool calls.`,
+      archetypePerf: rawScore
+    };
+  }
+  if (rawScore >= ARCHETYPE_FLOOR_DEFAULT) {
+    return {
+      status: "compatible",
+      reason: `Suited for ${descriptor}.`,
+      archetypePerf: rawScore
+    };
+  }
+  if (adapterMatch) {
+    return {
+      status: "requires-adapter",
+      reason: `Best with ${adapterMatch.adapter.value} ${adapterMatch.adapter.parameter === "toolOrchestration" ? "tool calls" : adapterMatch.adapter.parameter} for ${descriptor} \u2014 slower but works.`,
+      archetypePerf: rawScore,
+      archetypePerfWithAdapter: adapterMatch.estimatedScoreWithAdapter,
+      adapter: adapterMatch.adapter
+    };
+  }
+  return {
+    status: "reject",
+    reason: `Not suited for ${descriptor} \u2014 would underperform significantly.`,
+    archetypePerf: rawScore
+  };
+}
+
+// src/advisor.ts
+var QUALITY_FLOOR_FOR_RECOMMENDATION = 6;
+var TIER_DOWN_COST_RATIO = 0.5;
+var COST_MISMATCHED_CHOSEN_SCORE_CEILING = 7;
+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));
+  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));
+  }
+  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.",
+      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 only = ir.models[0];
+  return [
+    {
+      level: "warn",
+      code: "single-model-array",
+      message: `\`ir.models\` has length 1 (only "${only}") 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. Master plan \xA71.2 closes the reliability gap with a 2-step minimum.`,
+      suggestion: "Use `getDefaultFallbackChain({ archetype: ir.intent.archetype, primary: '" + only + "', posture: 'preferred' })` for a user-anchored chain, or `getDefaultFallbackChain({ archetype, posture: 'open' })` for library-picked. If single-model is intentional (compliance/brand promise), set `policy.posture = 'locked'` to silence this rule.",
+      docsUrl: "https://github.com/stue/command-center/blob/main/interfaces/kgauto.md#single-model-array"
+    }
+  ];
+}
+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 (!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.`,
+      suggestion: `Consider declaring \`${bestAlt.id}\` as the primary model for this archetype, or relax to posture='open' to let kgauto select among the chain. 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}) despite brain-query mode being active. Measurement substrate is wired but the brain hasn't accumulated >=10 outcomes for this (model, archetype) tuple yet \u2014 routing decisions remain pre-measured for this slot.`,
+      suggestion: "Verify that `record()` is being called on every call() outcome with the appropriate `actualModel` and `mutationsApplied` fields. Once the brain accumulates n>=10 rows on this tuple, the score promotes from judgment to measured automatically (5-min SWR cache). No code change required from your side \u2014 this is the substrate signaling the gap.",
+      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 (!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}`,
+      suggestion: `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.`,
+      recommendationType: "model-swap",
+      docsUrl: "https://github.com/stue/command-center/blob/main/interfaces/kgauto.md#best-practice-advisories"
+    }
+  ];
+}
+
+// src/translator.ts
+var TRANSLATOR_FLOOR = ARCHETYPE_FLOOR_DEFAULT;
+var RULE_SEQUENTIAL_TOOL_CLIFF = "sequential-tool-cliff-below-floor";
+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.";
+function applySectionRewrites(args) {
+  const { ir, profile, archetype } = args;
+  if (!Array.isArray(ir.sections) || ir.sections.length === 0) {
+    return { rewrittenIR: ir, rewrites: [] };
+  }
+  if (!profile.archetypePerf) {
+    return { rewrittenIR: ir, rewrites: [] };
+  }
+  const archetypeScore = profile.archetypePerf[archetype];
+  const cliffFires = typeof archetypeScore === "number" && archetypeScore < TRANSLATOR_FLOOR;
+  if (!cliffFires) {
+    return { rewrittenIR: ir, rewrites: [] };
+  }
+  const rewrites = [];
+  const newSections = ir.sections.map((section) => {
+    if (section.kind !== "tool_call_contract") return section;
+    const originalText = section.text;
+    const transformedText = `${SEQUENTIAL_TOOL_PREAMBLE}
+
+${originalText}`;
+    rewrites.push({
+      sectionId: section.id,
+      kind: "tool_call_contract",
+      rule: RULE_SEQUENTIAL_TOOL_CLIFF,
+      originalText,
+      transformedText,
+      wireOverrides: { parallelToolCalls: false }
+    });
+    return { ...section, text: transformedText };
+  });
+  if (rewrites.length === 0) {
+    return { rewrittenIR: ir, rewrites: [] };
+  }
+  const rewrittenIR = { ...ir, sections: newSections };
+  return { rewrittenIR, rewrites };
+}
+
+// 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 resolver = opts.profileResolver ?? getProfile;
+  validateIR(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 inputTokens = estimateInputTokens(workingIR);
+  const scores = passScoreTargets(workingIR, {
+    estimatedInputTokens: inputTokens,
+    profilesById: resolver,
+    policy: opts.policy
+  });
+  accumulatedMutations.push(...scores.mutations);
+  const target = pickTarget(workingIR, scores.value);
+  if (!target) {
+    throw new Error(
+      `compile(): no allowed model fits the request. Scores: ${JSON.stringify(scores.value, null, 2)}`
+    );
+  }
+  const profile = resolver(target.modelId);
+  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 translated = applySectionRewrites({
+    ir: workingIR,
+    profile,
+    archetype: ir.intent.archetype
+  });
+  workingIR = translated.rewrittenIR;
+  const sectionRewritesApplied = translated.rewrites;
+  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
+  });
+  validateFinalFit(workingIR, profile, inputTokens);
+  const handle = makeHandle();
+  const finalShape = computeShape(workingIR, inputTokens);
+  const _learningKey = learningKey(ir.intent.archetype, profile.id, finalShape);
+  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
+  };
+  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 advisories = 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
+    }
+  );
+  return {
+    handle,
+    target: profile.id,
+    provider: profile.provider,
+    request: lowered.request,
+    tokensIn: inputTokens,
+    estimatedCostUsd: target.estimatedCostUsd,
+    mutationsApplied: accumulatedMutations,
+    fallbackChain,
+    advisories,
+    diagnostics,
+    sectionRewritesApplied,
+    wireOverrides
+  };
+}
+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 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) {
@@ -1223,14 +2847,92 @@ function validateFinalFit(ir, profile, tokens) {
   }
 }
 
+// src/pricing-brain.ts
+function isPricingRow(x) {
+  if (!x || typeof x !== "object") return false;
+  const r = x;
+  return typeof r.model_id === "string" && typeof r.cost_input_per_1m === "number" && typeof r.cost_output_per_1m === "number" && typeof r.valid_from === "string";
+}
+function mapRowsToPricing(rows) {
+  const out = [];
+  for (const row of rows) {
+    if (!isPricingRow(row)) continue;
+    out.push({
+      modelId: row.model_id,
+      costInputPer1m: row.cost_input_per_1m,
+      costOutputPer1m: row.cost_output_per_1m,
+      cacheInputPer1m: row.cache_input_per_1m ?? void 0,
+      cacheCreationPer1m: row.cache_creation_per_1m ?? void 0,
+      validFrom: Date.parse(row.valid_from),
+      validUntil: row.valid_until == null ? void 0 : Date.parse(row.valid_until),
+      source: row.source ?? void 0
+    });
+  }
+  return out;
+}
+function bundledPricing() {
+  const out = [];
+  for (const profile of allProfiles()) {
+    out.push({
+      modelId: profile.id,
+      costInputPer1m: profile.costInputPer1m,
+      costOutputPer1m: profile.costOutputPer1m,
+      cacheInputPer1m: profile.lowering.cache.discount !== void 0 && profile.lowering.cache.discount > 0 ? profile.costInputPer1m * profile.lowering.cache.discount : void 0,
+      validFrom: 0,
+      validUntil: void 0,
+      source: "profile_seed"
+    });
+  }
+  return out;
+}
+var loadPricingFromBrain = createBrainQueryCache({
+  table: "kgauto_pricing",
+  mapRows: mapRowsToPricing,
+  bundledFallback: bundledPricing
+});
+function resolvePricingAt(modelId, at = /* @__PURE__ */ new Date()) {
+  const ts = at.getTime();
+  const all = loadPricingFromBrain();
+  let best;
+  for (const row of all) {
+    if (row.modelId !== modelId) continue;
+    if (row.validFrom > ts) continue;
+    if (row.validUntil !== void 0 && row.validUntil <= ts) continue;
+    if (!best || row.validFrom > best.validFrom) best = row;
+  }
+  return best;
+}
+
 // src/brain.ts
 var activeConfig;
 function configureBrain(config) {
   const endpoint = config.endpoint.replace(/\/outcomes\/?$/, "");
   activeConfig = { ...config, endpoint };
+  const bq = config.brainQuery ?? {};
+  const enabledTables = /* @__PURE__ */ new Set();
+  if (bq.chains !== false) enabledTables.add("kgauto_chains");
+  if (bq.perf !== false) enabledTables.add("kgauto_archetype_perf");
+  if (bq.pricing !== false) enabledTables.add("kgauto_pricing");
+  if (bq.models !== false) {
+    enabledTables.add("kgauto_models");
+    enabledTables.add("kgauto_aliases");
+  }
+  if (enabledTables.size === 0) {
+    configureBrainQuery(void 0);
+    return;
+  }
+  configureBrainQuery({
+    endpoint,
+    configEndpoint: bq.configEndpoint,
+    ttlMs: bq.cacheTtlMs ?? 3e5,
+    fetchImpl: config.fetchImpl ?? fetch,
+    enabledTables,
+    onError: config.onError
+  });
 }
 function clearBrain() {
   activeConfig = void 0;
+  configureBrainQuery(void 0);
 }
 var compileRegistry = /* @__PURE__ */ new Map();
 var REGISTRY_MAX_ENTRIES = 1e4;
@@ -1257,6 +2959,9 @@ function registerCompile(appId, archetype, ir, result) {
     tokens
   );
   const shapeKey = `${shape.contextBucket}-${shape.toolCountBucket}-${shape.historyDepth}-${shape.outputMode}`;
+  const toolsCount = result.diagnostics.toolsKept;
+  const historyDepth = Array.isArray(ir.history) ? ir.history.length : 0;
+  const systemPromptChars = estimateSystemPromptChars(ir.sections);
   compileRegistry.set(result.handle, {
     appId,
     archetype,
@@ -1266,9 +2971,35 @@ function registerCompile(appId, archetype, ir, result) {
     learningKey: learningKey(archetype, result.target, shape),
     estimatedTokensIn: tokens,
     mutationsApplied: result.mutationsApplied.map((m) => m.id),
-    startedAt: Date.now()
+    // alpha.30: cache the in-memory advisories so record() can auto-persist
+    // to `compile_outcome_advisories` without consumer-side threading.
+    advisoriesFromCompile: result.advisories ?? [],
+    startedAt: Date.now(),
+    historyCacheableTokens: result.diagnostics.historyCacheableTokens,
+    historyTokensTotal: result.diagnostics.historyTokensTotal,
+    // alpha.20 E3: capture consumer's declared mode for the brain payload.
+    toolOrchestration: result.diagnostics.toolOrchestration,
+    // alpha.28: shape fields for Glass-Box renderer.
+    toolsCount,
+    historyDepth,
+    systemPromptChars,
+    // alpha.29: translator activity — persisted on the brain row so
+    // cross-app aggregates can answer "Sonnet narration rule fired N times,
+    // outcome quality lifted to M."
+    sectionRewritesApplied: result.sectionRewritesApplied
   });
 }
+function estimateSystemPromptChars(sections) {
+  if (!Array.isArray(sections) || sections.length === 0) return void 0;
+  let total = 0;
+  for (const s of sections) {
+    if (s && typeof s === "object") {
+      const content = s.content;
+      if (typeof content === "string") total += content.length;
+    }
+  }
+  return total > 0 ? total : void 0;
+}
 async function record(input) {
   const reg = compileRegistry.get(input.handle);
   if (reg) compileRegistry.delete(input.handle);
@@ -1279,11 +3010,22 @@ async function record(input) {
   const config = activeConfig;
   const fetchFn = config.fetchImpl ?? fetch;
   const send = async () => {
+    let outcomeId;
     try {
       const res = await fetchFn(`${config.endpoint}/outcomes`, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
+          // alpha.20: request the inserted row back so we can JOIN advisories
+          // to it via outcome_id. PostgREST returns the row when
+          // `Prefer: return=representation` is set; proxies that pass the
+          // header through (the recommended `const row = { ...body }` shape
+          // from OutcomePayload's forward-compat rule) will surface
+          // the row id. Proxies that don't (legacy / hand-rolled shapes)
+          // simply produce no parseable id → secondary advisory POST is
+          // skipped silently. Best-effort — primary outcome row is the
+          // load-bearing write.
+          Prefer: "return=representation",
           ...config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {}
         },
         body: JSON.stringify(payload)
@@ -1292,8 +3034,31 @@ async function record(input) {
         const text = await res.text().catch(() => "<no body>");
         throw new Error(`brain ${res.status}: ${text}`);
       }
+      outcomeId = await tryExtractOutcomeId(res);
+    } catch (err) {
+      (config.onError ?? defaultOnError2)(err);
+      return;
+    }
+    const advisories = input.advisories ?? reg?.advisoriesFromCompile;
+    if (!advisories || advisories.length === 0) return;
+    if (outcomeId === void 0) return;
+    try {
+      const advisoryPayload = advisories.map((a) => buildAdvisoryRow(outcomeId, a));
+      const res = await fetchFn(`${config.endpoint}/compile_outcome_advisories`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Prefer: "return=minimal",
+          ...config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {}
+        },
+        body: JSON.stringify(advisoryPayload)
+      });
+      if (!res.ok) {
+        const text = await res.text().catch(() => "<no body>");
+        throw new Error(`brain advisories ${res.status}: ${text}`);
+      }
     } catch (err) {
-      (config.onError ?? defaultOnError)(err);
+      (config.onError ?? defaultOnError2)(err);
     }
   };
   if (config.sync) {
@@ -1302,13 +3067,18 @@ async function record(input) {
     void send();
   }
 }
-function defaultOnError(err) {
+function defaultOnError2(err) {
   console.warn("[kgauto] brain record failed:", err);
 }
 function buildPayload(input, reg) {
   const compileTarget = reg?.model;
   const actual = input.actualModel ?? compileTarget;
   const requested = input.actualModel && compileTarget && input.actualModel !== compileTarget ? compileTarget : void 0;
+  const mutationsApplied = input.mutationsApplied ?? reg?.mutationsApplied ?? [];
+  const costModel = actual;
+  const costUsdActual = costModel ? computeCostUsd(costModel, input.tokensIn, input.tokensOut) : void 0;
+  const fellOverFrom = input.fellOverFrom ?? requested;
+  const fallbackReason = fellOverFrom ? input.fallbackReason : void 0;
   return {
     handle: input.handle,
     app_id: reg?.appId,
@@ -1318,7 +3088,7 @@ function buildPayload(input, reg) {
     provider: reg?.provider,
     shape_key: reg?.shapeKey,
     learning_key: reg?.learningKey,
-    mutations_applied: reg?.mutationsApplied ?? [],
+    mutations_applied: mutationsApplied,
     tokens_in: input.tokensIn,
     tokens_out: input.tokensOut,
     estimated_tokens_in: reg?.estimatedTokensIn,
@@ -1332,8 +3102,117 @@ function buildPayload(input, reg) {
     oracle_rationale: input.oracleScore?.rationale,
     prompt_preview: input.promptPreview,
     response_preview: input.responsePreview,
-    dialect_version: "v1"
+    dialect_version: "v1",
+    cache_read_input_tokens: input.cacheReadInputTokens,
+    cache_creation_input_tokens: input.cacheCreationInputTokens,
+    cost_usd_actual: costUsdActual,
+    ttft_ms: input.ttftMs,
+    history_cacheable_tokens: reg?.historyCacheableTokens,
+    history_tokens_at_compile: reg?.historyTokensTotal,
+    // alpha.20 E3: mirror consumer's declared tool-orchestration mode so
+    // the brain can measure per-mode model perf separately (DeepSeek in
+    // sequential vs parallel mode is two different stories — L-040).
+    // Null when consumer hadn't adopted the constraint yet.
+    tool_orchestration: reg?.toolOrchestration ?? null,
+    // alpha.28 — Glass-Box renderer substrate (migration 018). All optional;
+    // omitted-undefined PostgREST inserts store NULL → renderer renders "—".
+    finish_reason: input.finishReason,
+    total_ms: input.totalMs ?? input.latencyMs,
+    tools_count: input.toolsCount ?? reg?.toolsCount,
+    history_depth: input.historyDepth ?? reg?.historyDepth,
+    system_prompt_chars: input.systemPromptChars ?? reg?.systemPromptChars,
+    fell_over_from: fellOverFrom,
+    fallback_reason: fallbackReason,
+    // alpha.29 — translator activity (migration 019). Send NULL when no
+    // rewrites fired so the brain's "did the translator do anything?"
+    // queries can use `IS NOT NULL` cleanly.
+    section_rewrites_applied: reg?.sectionRewritesApplied && reg.sectionRewritesApplied.length > 0 ? reg.sectionRewritesApplied : null
+  };
+}
+function computeCostUsd(modelId, tokensIn, tokensOut) {
+  if (tokensIn === 0 && tokensOut === 0) return void 0;
+  const brainRow = resolvePricingAt(modelId);
+  if (brainRow && (brainRow.costInputPer1m > 0 || brainRow.costOutputPer1m > 0)) {
+    const inUsd2 = tokensIn / 1e6 * brainRow.costInputPer1m;
+    const outUsd2 = tokensOut / 1e6 * brainRow.costOutputPer1m;
+    return Math.round((inUsd2 + outUsd2) * 1e6) / 1e6;
+  }
+  const profile = tryGetProfile(modelId);
+  if (!profile) return void 0;
+  const inUsd = tokensIn / 1e6 * profile.costInputPer1m;
+  const outUsd = tokensOut / 1e6 * profile.costOutputPer1m;
+  return Math.round((inUsd + outUsd) * 1e6) / 1e6;
+}
+async function tryExtractOutcomeId(res) {
+  try {
+    const ct = res.headers?.get?.("content-type") ?? "";
+    if (ct && !ct.includes("application/json")) return void 0;
+    if (typeof res.json !== "function") return void 0;
+    const body = await res.json();
+    if (Array.isArray(body) && body.length > 0) {
+      const first = body[0];
+      const id = first?.id;
+      if (typeof id === "number") return id;
+    } else if (body && typeof body === "object") {
+      const id = body.id;
+      if (typeof id === "number") return id;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function buildAdvisoryRow(outcomeId, a) {
+  return {
+    outcome_id: outcomeId,
+    code: a.code,
+    level: a.level,
+    message: a.message,
+    ...a.recommendationType ? { recommendation_type: a.recommendationType } : {},
+    ...a.suggestion ? { suggestion: a.suggestion } : {},
+    ...a.docsUrl ? { docs_url: a.docsUrl } : {}
+  };
+}
+async function recordOutcome(input) {
+  if (!activeConfig) {
+    return { ok: false, reason: "brain_not_configured" };
+  }
+  const config = activeConfig;
+  const fetchFn = config.fetchImpl ?? fetch;
+  const payload = {
+    outcome_id: input.outcomeId,
+    outcome: input.outcome,
+    rating: input.rating ?? null,
+    reason: input.reason ?? null,
+    observed_confidence: input.observedConfidence ?? null
+  };
+  const send = async () => {
+    try {
+      const res = await fetchFn(`${config.endpoint}/compile_outcome_quality`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {}
+        },
+        body: JSON.stringify(payload)
+      });
+      if (!res.ok) {
+        const text = await res.text().catch(() => "<no body>");
+        const err = new Error(`brain ${res.status}: ${text}`);
+        (config.onError ?? defaultOnError2)(err);
+        return { ok: false, reason: "persistence_failed" };
+      }
+      return { ok: true };
+    } catch (err) {
+      (config.onError ?? defaultOnError2)(err);
+      return { ok: false, reason: "persistence_failed" };
+    }
   };
+  if (config.sync) {
+    return send();
+  }
+  void send();
+  return { ok: true };
 }
 
 // src/ir.ts
@@ -1350,6 +3229,67 @@ var CallError = class extends Error {
   }
 };
 
+// src/env.ts
+var SUPPORTED_PROVIDERS = Object.freeze([
+  "anthropic",
+  "google",
+  "openai",
+  "deepseek"
+]);
+function isSupportedProvider(p) {
+  return SUPPORTED_PROVIDERS.includes(p);
+}
+var PROVIDER_ENV_KEYS = Object.freeze({
+  anthropic: Object.freeze(["ANTHROPIC_API_KEY"]),
+  google: Object.freeze([
+    "GOOGLE_API_KEY",
+    "GEMINI_API_KEY",
+    "GOOGLE_GENERATIVE_AI_API_KEY"
+  ]),
+  openai: Object.freeze(["OPENAI_API_KEY"]),
+  deepseek: Object.freeze(["DEEPSEEK_API_KEY"])
+});
+function defaultEnv() {
+  return typeof process !== "undefined" && process.env ? process.env : {};
+}
+function readKeyValue(raw) {
+  if (raw === void 0) return void 0;
+  const trimmed = raw.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function resolveProviderKey(provider, opts = {}) {
+  if (!isSupportedProvider(provider)) return void 0;
+  const explicit = readKeyValue(opts.apiKeys?.[provider]);
+  if (explicit) return explicit;
+  const env = opts.envSource ?? defaultEnv();
+  for (const name of PROVIDER_ENV_KEYS[provider]) {
+    const v = readKeyValue(env[name]);
+    if (v) return v;
+  }
+  return void 0;
+}
+function isProviderReachable(provider, opts = {}) {
+  return resolveProviderKey(provider, opts) !== void 0;
+}
+function isModelReachable(modelId, opts = {}) {
+  const profile = tryGetProfile(modelId);
+  if (!profile) return false;
+  return isProviderReachable(profile.provider, opts);
+}
+function getReachabilityDiagnostic(opts = {}) {
+  const env = opts.envSource ?? defaultEnv();
+  const out = {};
+  for (const provider of SUPPORTED_PROVIDERS) {
+    if (readKeyValue(opts.apiKeys?.[provider])) {
+      out[provider] = { reachable: true, via: "apiKeys" };
+      continue;
+    }
+    const envKeyFound = PROVIDER_ENV_KEYS[provider].find((name) => readKeyValue(env[name]));
+    out[provider] = envKeyFound ? { reachable: true, via: "env", envKeyFound } : { reachable: false, via: null };
+  }
+  return out;
+}
+
 // src/execute.ts
 var ANTHROPIC_URL = "https://api.anthropic.com/v1/messages";
 var OPENAI_URL = "https://api.openai.com/v1/chat/completions";
@@ -1372,7 +3312,7 @@ async function execute(request, opts = {}) {
   }
 }
 async function executeAnthropic(request, opts) {
-  const apiKey = opts.apiKeys?.anthropic ?? process.env.ANTHROPIC_API_KEY;
+  const apiKey = resolveProviderKey("anthropic", { apiKeys: opts.apiKeys });
   if (!apiKey) {
     return terminalError(401, "auth", "ANTHROPIC_API_KEY missing");
   }
@@ -1411,7 +3351,7 @@ function normalizeAnthropic(raw) {
   return { text, structuredOutput: null, toolCalls, tokens, finishReason: r.stop_reason, raw };
 }
 async function executeGoogle(request, opts) {
-  const apiKey = opts.apiKeys?.google ?? process.env.GOOGLE_API_KEY ?? process.env.GEMINI_API_KEY;
+  const apiKey = resolveProviderKey("google", { apiKeys: opts.apiKeys });
   if (!apiKey) {
     return terminalError(401, "auth", "GOOGLE_API_KEY/GEMINI_API_KEY missing");
   }
@@ -1453,7 +3393,7 @@ function normalizeGoogle(raw) {
   return { text, structuredOutput: null, toolCalls, tokens, finishReason: candidate?.finishReason, raw };
 }
 async function executeOpenAI(request, opts) {
-  const apiKey = opts.apiKeys?.openai ?? process.env.OPENAI_API_KEY;
+  const apiKey = resolveProviderKey("openai", { apiKeys: opts.apiKeys });
   if (!apiKey) {
     return terminalError(401, "auth", "OPENAI_API_KEY missing");
   }
@@ -1475,7 +3415,7 @@ async function executeOpenAI(request, opts) {
   return { ok: true, status: res.status, response: normalizeOpenAILike(json) };
 }
 async function executeDeepSeek(request, opts) {
-  const apiKey = opts.apiKeys?.deepseek ?? process.env.DEEPSEEK_API_KEY;
+  const apiKey = resolveProviderKey("deepseek", { apiKeys: opts.apiKeys });
   if (!apiKey) {
     return terminalError(401, "auth", "DEEPSEEK_API_KEY missing");
   }
@@ -1525,60 +3465,826 @@ function classifyHttpError(status, body) {
   if (status === 429) {
     return { ok: false, status, errorType: "retryable", errorCode: "rate_limit", message, raw: body };
   }
-  if (status === 408) {
-    return { ok: false, status, errorType: "retryable", errorCode: "timeout", message, raw: body };
+  if (status === 408) {
+    return { ok: false, status, errorType: "retryable", errorCode: "timeout", message, raw: body };
+  }
+  if (status >= 500) {
+    return { ok: false, status, errorType: "retryable", errorCode: "server_error", message, raw: body };
+  }
+  if (status === 404) {
+    return { ok: false, status, errorType: "retryable", errorCode: "model_not_found", message, raw: body };
+  }
+  if (status === 401 || status === 403) {
+    return { ok: false, status, errorType: "terminal", errorCode: "auth", message, raw: body };
+  }
+  if (status === 400) {
+    return { ok: false, status, errorType: "terminal", errorCode: "invalid_request", message, raw: body };
+  }
+  return { ok: false, status, errorType: "terminal", errorCode: "unknown", message, raw: body };
+}
+function extractErrorMessage(body) {
+  if (!body || typeof body !== "object") return void 0;
+  const b = body;
+  if (b.error && typeof b.error === "object") {
+    const e = b.error;
+    if (typeof e.message === "string") return e.message;
+  }
+  if (typeof b.message === "string") return b.message;
+  return void 0;
+}
+function terminalError(status, code, message) {
+  return { ok: false, status, errorType: "terminal", errorCode: code, message, raw: null };
+}
+function retryableError(status, code, message, raw) {
+  return { ok: false, status, errorType: "retryable", errorCode: code, message, raw };
+}
+function tryParseJson(s) {
+  if (typeof s !== "string" || s.length === 0) return void 0;
+  try {
+    const parsed = JSON.parse(s);
+    return typeof parsed === "object" && parsed !== null ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/chains-brain.ts
+function isChainsRow(x) {
+  if (!x || typeof x !== "object") return false;
+  const r = x;
+  return typeof r.archetype === "string" && typeof r.tier === "number" && typeof r.model_id === "string";
+}
+function mapRowsToChains(rows) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (!isChainsRow(row)) continue;
+    const list = grouped.get(row.archetype) ?? [];
+    list.push(row);
+    grouped.set(row.archetype, list);
+  }
+  const out = {};
+  for (const [archetype, group] of grouped.entries()) {
+    group.sort((a, b) => a.tier - b.tier);
+    out[archetype] = group.map((r) => r.model_id);
+  }
+  const bundled = getAllStarterChains();
+  for (const archetype of Object.keys(bundled)) {
+    if (!out[archetype]) out[archetype] = bundled[archetype];
+  }
+  return out;
+}
+var loadChainsFromBrain = createBrainQueryCache({
+  table: "kgauto_chains",
+  mapRows: mapRowsToChains,
+  bundledFallback: getAllStarterChains
+});
+
+// src/fallback.ts
+var STARTER_CHAINS_GROUNDED = {
+  // Reasoning floor — never degrade. Walk UP on 429 to Opus → cross-provider.
+  critique: [
+    { id: "claude-opus-4-7", grounding: "judgment", reason: "Highest reasoning bar, no degradation tier \u2014 engineer pick, awaiting measured backing" },
+    { id: "claude-sonnet-4-6", grounding: "judgment", reason: "Same-provider walk-down from Opus on 429" },
+    { id: "gemini-2.5-pro", grounding: "judgment", reason: "Cross-provider anchor in similar quality bracket" },
+    { id: "gpt-5.5", grounding: "judgment", reason: "alpha.16: third-provider frontier-tier floor (archetypePerf=9)" }
+  ],
+  // Reasoning matters — Sonnet primary; walk UP to Opus on 429.
+  plan: [
+    { id: "claude-sonnet-4-6", grounding: "judgment", reason: "Reasoning + cost balance \u2014 engineer pick" },
+    { id: "claude-opus-4-7", grounding: "judgment", reason: 'Same-provider walk-UP on 429 (rare exception to "always cheaper")' },
+    { id: "gemini-2.5-pro", grounding: "judgment", reason: "Cross-provider anchor" },
+    { id: "deepseek-v4-pro", grounding: "judgment", reason: "Tier 3 cost floor \u2014 no brain evidence yet" }
+  ],
+  // Quality + cost match.
+  generate: [
+    { id: "claude-sonnet-4-6", grounding: "judgment", reason: "Quality + cost match \u2014 engineer pick" },
+    { id: "claude-haiku-4-5", grounding: "judgment", reason: "Same-provider step-down" },
+    { id: "gemini-2.5-pro", grounding: "judgment", reason: "Cross-provider anchor" },
+    { id: "gpt-5.4-mini", grounding: "judgment", reason: "alpha.16: third-provider tail (archetypePerf=7) \u2014 closes mono-Anthropic gap" }
+  ],
+  // ask::sonnet — STARTER_CHAINS calls this "Quality + cost match" but
+  // tt-intel s78 prod data showed 27% empty rate. Labeled 'judgment' until
+  // evidence either validates or refutes the placement.
+  ask: [
+    { id: "claude-sonnet-4-6", grounding: "judgment", reason: "Quality + cost match \u2014 engineer pick. NOTE: tt-intel s78 prod showed 27% empty rate; placement awaits measurement validation" },
+    { id: "claude-haiku-4-5", grounding: "judgment", reason: "Same-provider step-down" },
+    { id: "gemini-2.5-pro", grounding: "judgment", reason: "Cross-provider anchor" },
+    { id: "gpt-5.4-mini", grounding: "judgment", reason: "alpha.16: third-provider tail (archetypePerf=7)" }
+  ],
+  // Structured-output archetype — Flash skipped (alpha.8 MAX_TOKENS cliff,
+  // capability-fact); DeepSeek skipped (no brain evidence).
+  extract: [
+    { id: "claude-sonnet-4-6", grounding: "judgment", reason: "Reliable structured-output anchor \u2014 engineer pick" },
+    { id: "claude-haiku-4-5", grounding: "judgment", reason: "Same-provider step-down with native structured output" },
+    { id: "gemini-2.5-pro", grounding: "judgment", reason: "Cross-provider anchor with structured-output support" },
+    { id: "gpt-5.4", grounding: "capability-fact", reason: "alpha.16: third-provider floor \u2014 native structured-output capability (archetypePerf=8)" }
+  ],
+  // Forgiving archetype — Sonnet primary but Flash safely floors it.
+  transform: [
+    { id: "claude-sonnet-4-6", grounding: "judgment", reason: "Quality anchor \u2014 engineer pick" },
+    { id: "claude-haiku-4-5", grounding: "judgment", reason: "Same-provider step-down" },
+    { id: "gemini-2.5-pro", grounding: "judgment", reason: "Cross-provider anchor" },
+    { id: "gemini-2.5-flash", grounding: "judgment", reason: "Cost floor \u2014 forgiving archetype tolerates Flash" }
+  ],
+  // Parallel-tool throughput champion — Flash leads on the L-040 cliff
+  // (capability-fact: Flash 15-75 parallel calls/step vs DeepSeek 7-8).
+  hunt: [
+    { id: "gemini-2.5-flash", grounding: "capability-fact", reason: "L-040 parallel-tool throughput champion (15-75 calls/step)" },
+    { id: "gemini-2.5-pro", grounding: "capability-fact", reason: "Cross-provider tier 1 with strong parallel-tool support" },
+    { id: "claude-sonnet-4-6", grounding: "judgment", reason: "Quality safety net for blocked-Flash case" },
+    { id: "claude-haiku-4-5", grounding: "judgment", reason: "Reduced tool budget \u2014 cliff at 16 fires" }
+  ],
+  // Cost-sensitive + tolerant. DeepSeek brain-evidence tier 1.
+  summarize: [
+    { id: "gemini-2.5-flash", grounding: "judgment", reason: "Cost-sensitive primary \u2014 engineer pick" },
+    { id: "deepseek-v4-flash", grounding: "measured", reason: "Brain-validated tier 1 for cost-sensitive summarize workloads", n: 169 },
+    { id: "claude-haiku-4-5", grounding: "judgment", reason: "Quality safety net" },
+    { id: "gemini-2.5-flash-lite", grounding: "judgment", reason: "Emergency floor \u2014 onboarded s22, no brain evidence yet" }
+  ],
+  // Brain-validated DeepSeek tier 1 (169 rows, 0% empty rate).
+  classify: [
+    { id: "gemini-2.5-flash", grounding: "judgment", reason: "Cost-sensitive primary \u2014 engineer pick" },
+    { id: "deepseek-v4-flash", grounding: "measured", reason: "Brain-validated tier 1 (169 rows, 0% empty rate)", n: 169 },
+    { id: "claude-haiku-4-5", grounding: "judgment", reason: "Quality safety net" },
+    { id: "gemini-2.5-flash-lite", grounding: "judgment", reason: "Cache-discount 10\xD7 floor for repeat-prompt workloads" }
+  ]
+};
+var STARTER_CHAINS = (() => {
+  const out = {};
+  for (const [archetype, entries] of Object.entries(STARTER_CHAINS_GROUNDED)) {
+    out[archetype] = entries.map((e) => e.id);
+  }
+  return out;
+})();
+var STARTER_CHAINS_BY_MODE_GROUNDED = {
+  hunt: {
+    sequential: [
+      {
+        id: "deepseek-v4-pro",
+        grounding: "judgment",
+        reason: "alpha.20 E3: cheap + good reasoning at single-step granularity; L-040 cliff silenced when sequential \u2014 hypothesis not yet measured"
+      },
+      {
+        id: "deepseek-v4-flash",
+        grounding: "judgment",
+        reason: "Cheapest viable; sibling-provider fallback"
+      },
+      {
+        id: "claude-sonnet-4-6",
+        grounding: "judgment",
+        reason: "Cross-provider safety net \u2014 Sonnet handles sequential agentic loops cleanly"
+      },
+      {
+        id: "gemini-2.5-pro",
+        grounding: "judgment",
+        reason: "Third-provider tail when no DeepSeek key reachable"
+      }
+    ]
+  }
+};
+var STARTER_CHAINS_BY_MODE = (() => {
+  const out = {};
+  for (const [archetype, modes] of Object.entries(STARTER_CHAINS_BY_MODE_GROUNDED)) {
+    if (modes?.sequential) {
+      out[archetype] = {
+        sequential: modes.sequential.map((e) => e.id)
+      };
+    }
+  }
+  return out;
+})();
+function resolveStarterForMode(archetype, toolOrchestration, allChains) {
+  if (toolOrchestration === "sequential") {
+    const overlay = STARTER_CHAINS_BY_MODE[archetype]?.sequential;
+    if (overlay) return [...overlay];
+  }
+  return allChains[archetype];
+}
+function getDefaultFallbackChain(opts) {
+  const { archetype, primary, maxDepth = 3, policy, reachability, toolOrchestration } = opts;
+  if (maxDepth < 1) {
+    throw new Error(
+      `getDefaultFallbackChain: maxDepth must be >= 1, got ${maxDepth}`
+    );
+  }
+  const allChains = loadChainsFromBrain();
+  const starter = resolveStarterForMode(archetype, toolOrchestration, allChains);
+  if (!starter) {
+    throw new Error(
+      `getDefaultFallbackChain: unknown archetype "${archetype}". Known: ${Object.keys(allChains).join(", ")}`
+    );
+  }
+  let chain;
+  if (primary) {
+    chain = [primary, ...starter.filter((id) => id !== primary)];
+  } else {
+    chain = [...starter];
+  }
+  if (policy?.blockedModels && policy.blockedModels.length > 0) {
+    const blocked = new Set(policy.blockedModels);
+    chain = chain.filter((id) => !blocked.has(id));
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const id of chain) {
+    if (!seen.has(id)) {
+      seen.add(id);
+      deduped.push(id);
+    }
+  }
+  let filtered = deduped;
+  if (reachability) {
+    filtered = deduped.filter((id) => isModelReachable(id, reachability));
+  }
+  return filtered.slice(0, maxDepth);
+}
+function getStarterChain(archetype) {
+  const chain = STARTER_CHAINS[archetype];
+  if (!chain) {
+    throw new Error(
+      `getStarterChain: unknown archetype "${archetype}"`
+    );
+  }
+  return [...chain];
+}
+function getAllStarterChains() {
+  const out = {};
+  for (const [archetype, chain] of Object.entries(STARTER_CHAINS)) {
+    out[archetype] = [...chain];
+  }
+  return out;
+}
+function getSequentialStarterChain(archetype) {
+  const overlay = STARTER_CHAINS_BY_MODE[archetype]?.sequential;
+  return overlay ? [...overlay] : void 0;
+}
+function copyEntry(e) {
+  const out = { id: e.id, grounding: e.grounding };
+  if (e.reason !== void 0) out.reason = e.reason;
+  if (e.n !== void 0) out.n = e.n;
+  return out;
+}
+function lookupStaticEntry(id, archetype) {
+  const archetypeEntries = STARTER_CHAINS_GROUNDED[archetype];
+  if (archetypeEntries) {
+    const hit = archetypeEntries.find((e) => e.id === id);
+    if (hit) return hit;
+  }
+  const seqOverlay = STARTER_CHAINS_BY_MODE_GROUNDED[archetype]?.sequential;
+  if (seqOverlay) {
+    const hit = seqOverlay.find((e) => e.id === id);
+    if (hit) return hit;
+  }
+  return void 0;
+}
+function resolveGroundedChainForArchetype(archetype, toolOrchestration) {
+  if (toolOrchestration === "sequential") {
+    const overlay = STARTER_CHAINS_BY_MODE_GROUNDED[archetype]?.sequential;
+    if (overlay) return overlay.map(copyEntry);
+  }
+  const allChains = loadChainsFromBrain();
+  const ids = allChains[archetype];
+  if (!ids) return void 0;
+  return ids.map((id) => {
+    const known = lookupStaticEntry(id, archetype);
+    if (known) return copyEntry(known);
+    return { id, grounding: "judgment" };
+  });
+}
+function getDefaultFallbackChainWithGrounding(opts) {
+  const {
+    archetype,
+    primary,
+    maxDepth = 3,
+    policy,
+    reachability,
+    toolOrchestration
+  } = opts;
+  if (maxDepth < 1) {
+    throw new Error(
+      `getDefaultFallbackChainWithGrounding: maxDepth must be >= 1, got ${maxDepth}`
+    );
+  }
+  const starter = resolveGroundedChainForArchetype(archetype, toolOrchestration);
+  if (!starter) {
+    throw new Error(
+      `getDefaultFallbackChainWithGrounding: unknown archetype "${archetype}". Known: ${Object.keys(STARTER_CHAINS_GROUNDED).join(", ")}`
+    );
+  }
+  let chain;
+  if (primary) {
+    const primaryEntry = (() => {
+      const inStarter = starter.find((e) => e.id === primary);
+      if (inStarter) return copyEntry(inStarter);
+      const knownAnywhere = lookupStaticEntry(primary, archetype);
+      if (knownAnywhere) return { ...copyEntry(knownAnywhere), id: primary };
+      return { id: primary, grounding: "judgment" };
+    })();
+    chain = [primaryEntry, ...starter.filter((e) => e.id !== primary)];
+  } else {
+    chain = [...starter];
+  }
+  if (policy?.blockedModels && policy.blockedModels.length > 0) {
+    const blocked = new Set(policy.blockedModels);
+    chain = chain.filter((e) => !blocked.has(e.id));
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const e of chain) {
+    if (!seen.has(e.id)) {
+      seen.add(e.id);
+      deduped.push(e);
+    }
+  }
+  let filtered = deduped;
+  if (reachability) {
+    filtered = deduped.filter((e) => isModelReachable(e.id, reachability));
+  }
+  return filtered.slice(0, maxDepth);
+}
+function getStarterChainWithGrounding(archetype) {
+  const entries = STARTER_CHAINS_GROUNDED[archetype];
+  if (!entries) {
+    throw new Error(
+      `getStarterChainWithGrounding: unknown archetype "${archetype}"`
+    );
+  }
+  return entries.map(copyEntry);
+}
+function getAllStarterChainsWithGrounding() {
+  const out = {};
+  for (const [archetype, entries] of Object.entries(STARTER_CHAINS_GROUNDED)) {
+    out[archetype] = entries.map(copyEntry);
+  }
+  return out;
+}
+function getSequentialStarterChainWithGrounding(archetype) {
+  const overlay = STARTER_CHAINS_BY_MODE_GROUNDED[archetype]?.sequential;
+  return overlay ? overlay.map(copyEntry) : void 0;
+}
+function ensureCrossProviderTail(opts) {
+  const { chain, archetype, apiKeys, envSource } = opts;
+  if (chain.length < 1) return { chain };
+  const providers = /* @__PURE__ */ new Set();
+  for (const t of chain) {
+    const p = tryGetProfile(t);
+    if (p) providers.add(p.provider);
+  }
+  if (providers.size >= 2) return { chain };
+  const existingProvider = providers.values().next().value;
+  if (!existingProvider) return { chain };
+  const allChains = loadChainsFromBrain();
+  const fullChain = allChains[archetype];
+  if (!fullChain) return { chain };
+  for (const candidate of fullChain) {
+    if (chain.includes(candidate)) continue;
+    const cp = tryGetProfile(candidate);
+    if (!cp || cp.provider === existingProvider) continue;
+    if (!isModelReachable(candidate, { apiKeys, envSource })) continue;
+    return { chain: [...chain, candidate], appended: candidate };
+  }
+  return { chain };
+}
+
+// src/glassbox/types.ts
+var GLASSBOX_STREAM_TTL_MS = 6e4;
+
+// src/glassbox/pubsub-memory.ts
+var MemoryPubSub = class {
+  subscribers = /* @__PURE__ */ new Map();
+  async publish(channelKey, event) {
+    const subs = this.subscribers.get(channelKey);
+    if (!subs || subs.size === 0) return;
+    for (const sub of subs) {
+      if (sub.closed) continue;
+      try {
+        sub.controller.enqueue(event);
+      } catch {
+        sub.closed = true;
+        continue;
+      }
+      this.refreshTtl(channelKey, sub);
+    }
+  }
+  subscribe(channelKey) {
+    const self = this;
+    let sub;
+    return new ReadableStream({
+      start(controller) {
+        sub = {
+          controller,
+          ttlTimer: setTimeout(() => {
+            self.closeSubscriber(channelKey, sub);
+          }, GLASSBOX_STREAM_TTL_MS),
+          closed: false
+        };
+        let set = self.subscribers.get(channelKey);
+        if (!set) {
+          set = /* @__PURE__ */ new Set();
+          self.subscribers.set(channelKey, set);
+        }
+        set.add(sub);
+      },
+      cancel() {
+        if (sub) self.removeSubscriber(channelKey, sub);
+      }
+    });
   }
-  if (status >= 500) {
-    return { ok: false, status, errorType: "retryable", errorCode: "server_error", message, raw: body };
+  /**
+   * Refresh the rolling TTL for a subscriber after an event lands. Replaces
+   * the existing timer with a fresh 60s one.
+   */
+  refreshTtl(channelKey, sub) {
+    clearTimeout(sub.ttlTimer);
+    sub.ttlTimer = setTimeout(() => {
+      this.closeSubscriber(channelKey, sub);
+    }, GLASSBOX_STREAM_TTL_MS);
   }
-  if (status === 404) {
-    return { ok: false, status, errorType: "retryable", errorCode: "model_not_found", message, raw: body };
+  /**
+   * Close the subscriber's stream cleanly and remove from the fan-out set.
+   * Idempotent — safe to call multiple times.
+   */
+  closeSubscriber(channelKey, sub) {
+    if (sub.closed) return;
+    sub.closed = true;
+    clearTimeout(sub.ttlTimer);
+    try {
+      sub.controller.close();
+    } catch {
+    }
+    this.removeSubscriber(channelKey, sub);
   }
-  if (status === 401 || status === 403) {
-    return { ok: false, status, errorType: "terminal", errorCode: "auth", message, raw: body };
+  removeSubscriber(channelKey, sub) {
+    clearTimeout(sub.ttlTimer);
+    const set = this.subscribers.get(channelKey);
+    if (!set) return;
+    set.delete(sub);
+    if (set.size === 0) this.subscribers.delete(channelKey);
   }
-  if (status === 400) {
-    return { ok: false, status, errorType: "terminal", errorCode: "invalid_request", message, raw: body };
+  /**
+   * Test-only reset. Tears down all subscribers, clears all state. Calling
+   * outside of tests is harmless but cancels every active stream.
+   */
+  _reset() {
+    for (const [, set] of this.subscribers) {
+      for (const sub of set) {
+        this.closeSubscriber("", sub);
+      }
+    }
+    this.subscribers.clear();
   }
-  return { ok: false, status, errorType: "terminal", errorCode: "unknown", message, raw: body };
+};
+
+// src/glassbox/pubsub-upstash.ts
+var UpstashPubSub = class {
+  url;
+  token;
+  fetchImpl;
+  blockMs;
+  maxLen;
+  constructor(cfg) {
+    this.url = cfg.url.replace(/\/$/, "");
+    this.token = cfg.token;
+    this.fetchImpl = cfg.fetchImpl ?? globalThis.fetch.bind(globalThis);
+    this.blockMs = cfg.blockMs ?? 100;
+    this.maxLen = cfg.maxLen ?? 100;
+  }
+  async publish(channelKey, event) {
+    const key = channelKey;
+    const payload = JSON.stringify(event);
+    await this.cmd([
+      "XADD",
+      key,
+      "MAXLEN",
+      "~",
+      String(this.maxLen),
+      "*",
+      "event",
+      payload
+    ]);
+    await this.cmd(["EXPIRE", key, String(Math.ceil(GLASSBOX_STREAM_TTL_MS / 1e3))]);
+  }
+  subscribe(channelKey) {
+    const key = channelKey;
+    const self = this;
+    let cursor = "$";
+    let cancelled = false;
+    let ttlDeadline = Date.now() + GLASSBOX_STREAM_TTL_MS;
+    return new ReadableStream({
+      async start(controller) {
+        try {
+          while (!cancelled && Date.now() < ttlDeadline) {
+            const resp = await self.cmd([
+              "XREAD",
+              "BLOCK",
+              String(self.blockMs),
+              "STREAMS",
+              key,
+              cursor
+            ]);
+            if (cancelled) break;
+            const parsed = parseXReadResult(resp.result);
+            if (parsed.entries.length === 0) {
+              continue;
+            }
+            for (const entry of parsed.entries) {
+              const evt = decodeEvent(entry.fields);
+              if (evt) {
+                try {
+                  controller.enqueue(evt);
+                } catch {
+                  cancelled = true;
+                  break;
+                }
+              }
+              cursor = entry.id;
+            }
+            ttlDeadline = Date.now() + GLASSBOX_STREAM_TTL_MS;
+          }
+        } catch (err) {
+          if (!cancelled) {
+            try {
+              controller.error(err);
+            } catch {
+            }
+            return;
+          }
+        }
+        try {
+          controller.close();
+        } catch {
+        }
+      },
+      cancel() {
+        cancelled = true;
+      }
+    });
+  }
+  async cmd(args) {
+    const res = await this.fetchImpl(this.url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(args)
+    });
+    if (!res.ok) {
+      throw new Error(`Upstash ${args[0]} failed: HTTP ${res.status}`);
+    }
+    const json = await res.json();
+    if (json.error) {
+      throw new Error(`Upstash ${args[0]} failed: ${json.error}`);
+    }
+    return json;
+  }
+};
+function traceChannel(traceId) {
+  return `glassbox:trace:${traceId}`;
 }
-function extractErrorMessage(body) {
-  if (!body || typeof body !== "object") return void 0;
-  const b = body;
-  if (b.error && typeof b.error === "object") {
-    const e = b.error;
-    if (typeof e.message === "string") return e.message;
+function appChannel(appId) {
+  return `glassbox:app:${appId}`;
+}
+function decodeEvent(fields) {
+  const raw = fields["event"];
+  if (!raw) return void 0;
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.kind === "string" && typeof parsed.at === "number") {
+      return parsed;
+    }
+    return void 0;
+  } catch {
+    return void 0;
   }
-  if (typeof b.message === "string") return b.message;
-  return void 0;
 }
-function terminalError(status, code, message) {
-  return { ok: false, status, errorType: "terminal", errorCode: code, message, raw: null };
+function parseXReadResult(raw) {
+  if (!Array.isArray(raw)) return { entries: [] };
+  const entries = [];
+  for (const stream of raw) {
+    if (!Array.isArray(stream) || stream.length < 2) continue;
+    const streamEntries = stream[1];
+    if (!Array.isArray(streamEntries)) continue;
+    for (const entry of streamEntries) {
+      if (!Array.isArray(entry) || entry.length < 2) continue;
+      const id = String(entry[0]);
+      const flat = entry[1];
+      if (!Array.isArray(flat)) continue;
+      const fields = {};
+      for (let i = 0; i < flat.length; i += 2) {
+        const k = flat[i];
+        const v = flat[i + 1];
+        if (typeof k === "string") fields[k] = String(v ?? "");
+      }
+      entries.push({ id, fields });
+    }
+  }
+  return { entries };
 }
-function retryableError(status, code, message, raw) {
-  return { ok: false, status, errorType: "retryable", errorCode: code, message, raw };
+
+// src/glassbox/emit.ts
+var activePubSub;
+function getPubSub() {
+  if (activePubSub) return activePubSub;
+  const url = readEnv("UPSTASH_REDIS_URL");
+  const token = readEnv("UPSTASH_REDIS_TOKEN");
+  if (url && token) {
+    activePubSub = new UpstashPubSub({ url, token });
+  } else {
+    activePubSub = new MemoryPubSub();
+  }
+  return activePubSub;
 }
-function tryParseJson(s) {
-  if (typeof s !== "string" || s.length === 0) return void 0;
+function readEnv(key) {
   try {
-    const parsed = JSON.parse(s);
-    return typeof parsed === "object" && parsed !== null ? parsed : void 0;
+    if (typeof process !== "undefined" && process.env) {
+      const v = process.env[key];
+      return v && v.trim() !== "" ? v : void 0;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function emitGlassboxEvent(traceId, appId, kind, data) {
+  if (!traceId) return;
+  const event = { kind, at: Date.now(), data };
+  const ps = getPubSub();
+  try {
+    const p1 = ps.publish(traceChannel(traceId), event);
+    if (p1 && typeof p1.then === "function") {
+      p1.catch(() => {
+      });
+    }
   } catch {
-    return void 0;
   }
+  if (appId) {
+    try {
+      const p2 = ps.publish(appChannel(appId), event);
+      if (p2 && typeof p2.then === "function") {
+        p2.catch(() => {
+        });
+      }
+    } catch {
+    }
+  }
+}
+function emitCompileStart(traceId, appId, data) {
+  emitGlassboxEvent(traceId, appId, "compile.start", data);
+}
+function emitCompileDone(traceId, appId, data) {
+  emitGlassboxEvent(traceId, appId, "compile.done", data);
+}
+function emitExecuteAttempt(traceId, appId, data) {
+  emitGlassboxEvent(traceId, appId, "execute.attempt", data);
+}
+function emitExecuteSuccess(traceId, appId, data) {
+  emitGlassboxEvent(traceId, appId, "execute.success", data);
+}
+function emitAdvisoryFired(traceId, appId, data) {
+  emitGlassboxEvent(traceId, appId, "advisory.fired", data);
+}
+function emitFallbackWalked(traceId, appId, data) {
+  emitGlassboxEvent(traceId, appId, "fallback.walked", data);
 }
 
 // src/call.ts
 async function call(ir, opts = {}) {
+  const traceId = generateTraceId();
+  safeEmit(
+    () => emitCompileStart(traceId, ir.appId, {
+      appId: ir.appId,
+      archetype: ir.intent.archetype,
+      models: ir.models
+    })
+  );
   const initial = compileAndRegister(ir, opts);
+  safeEmit(
+    () => emitCompileDone(traceId, ir.appId, {
+      target: initial.target,
+      provider: initial.provider,
+      fallbackChain: initial.fallbackChain,
+      tokensIn: initial.tokensIn,
+      estimatedCostUsd: initial.estimatedCostUsd,
+      mutationsApplied: initial.mutationsApplied,
+      advisories: initial.advisories
+    })
+  );
+  for (const adv of initial.advisories) {
+    safeEmit(
+      () => emitAdvisoryFired(traceId, ir.appId, { code: adv.code, message: adv.message })
+    );
+  }
   const start = Date.now();
   const attempts = [];
-  const targetsToTry = [initial.target, ...initial.fallbackChain];
+  const rawTargets = [initial.target, ...initial.fallbackChain];
+  let unreachableFiltered;
+  let targetsToTry;
+  if (opts.noAutoFilter) {
+    targetsToTry = rawTargets;
+  } else {
+    const dropped = [];
+    targetsToTry = [];
+    for (const t of rawTargets) {
+      if (isModelReachable(t, { apiKeys: opts.apiKeys })) {
+        targetsToTry.push(t);
+      } else {
+        dropped.push(t);
+      }
+    }
+    unreachableFiltered = dropped;
+    if (targetsToTry.length === 0) {
+      const latencyMs2 = Date.now() - start;
+      await record({
+        handle: initial.handle,
+        tokensIn: 0,
+        tokensOut: 0,
+        latencyMs: latencyMs2,
+        success: false,
+        errorType: "no_reachable_models",
+        promptPreview: extractPromptPreview(ir)
+      });
+      const noReachableAttempts = dropped.map((m) => ({
+        model: m,
+        status: "terminal",
+        errorCode: "unreachable_provider",
+        message: `No API key for ${m}'s provider \u2014 set one of PROVIDER_ENV_KEYS or pass apiKeys`
+      }));
+      throw new CallError(
+        `call(): no reachable models in chain. Filtered: [${dropped.join(", ")}]. Add a key for one provider, or pass apiKeys.`,
+        noReachableAttempts,
+        void 0,
+        "no_reachable_models"
+      );
+    }
+    const archetypeName = ir.intent?.archetype;
+    if (archetypeName) {
+      const ensured = ensureCrossProviderTail({
+        chain: targetsToTry,
+        archetype: archetypeName,
+        apiKeys: opts.apiKeys
+      });
+      if (ensured.appended) {
+        targetsToTry = ensured.chain;
+      }
+    }
+  }
+  let policyBlockedFiltered;
+  if (opts.policy?.blockedModels && opts.policy.blockedModels.length > 0) {
+    const blocked = new Set(opts.policy.blockedModels);
+    const filtered = [];
+    const dropped = [];
+    for (const t of targetsToTry) {
+      if (blocked.has(t)) {
+        dropped.push(t);
+      } else {
+        filtered.push(t);
+      }
+    }
+    if (dropped.length > 0) {
+      policyBlockedFiltered = dropped;
+      targetsToTry = filtered;
+    }
+    if (targetsToTry.length === 0) {
+      const latencyMs2 = Date.now() - start;
+      await record({
+        handle: initial.handle,
+        tokensIn: 0,
+        tokensOut: 0,
+        latencyMs: latencyMs2,
+        success: false,
+        errorType: "all_blocked_by_policy",
+        promptPreview: extractPromptPreview(ir)
+      });
+      const blockedAttempts = dropped.map((m) => ({
+        model: m,
+        status: "terminal",
+        errorCode: "blocked_by_policy",
+        message: `Skipped \u2014 model ${m} is in CompilePolicy.blockedModels`
+      }));
+      throw new CallError(
+        `call(): all chain targets blocked by CompilePolicy.blockedModels: [${dropped.join(", ")}]`,
+        blockedAttempts,
+        void 0,
+        "all_blocked_by_policy"
+      );
+    }
+  }
   let activeCompile = initial;
   let lastErr;
+  const failedProviders = /* @__PURE__ */ new Set();
   for (let i = 0; i < targetsToTry.length; i++) {
     const targetModel = targetsToTry[i];
-    if (i > 0) {
+    const targetProfile = tryGetProfile(targetModel);
+    if (targetProfile && failedProviders.has(targetProfile.provider) && !opts.noFallback) {
+      attempts.push({
+        model: targetModel,
+        status: "terminal",
+        errorCode: "auth_inferred",
+        message: `Skipped \u2014 provider ${targetProfile.provider} returned 401/403 earlier in this call; same key inferred to fail`
+      });
+      continue;
+    }
+    if (targetModel !== initial.target) {
       try {
         activeCompile = compileAndRegister(
           {
@@ -1598,59 +4304,112 @@ async function call(ir, opts = {}) {
         continue;
       }
     }
+    safeEmit(
+      () => emitExecuteAttempt(traceId, ir.appId, { model: targetModel, attemptIndex: i })
+    );
     const exec = await execute(activeCompile.request, {
       apiKeys: opts.apiKeys,
       fetchImpl: opts.fetchImpl,
       providerOverrides: opts.providerOverrides
     });
-    if (exec.ok) {
+    const validated = exec.ok ? validateStructuredContract(exec, ir) : exec;
+    if (validated.ok) {
       attempts.push({ model: targetModel, status: "success" });
       const latencyMs2 = Date.now() - start;
-      const responseWithStructured = withStructuredOutput(exec.response, ir);
-      void record({
+      safeEmit(
+        () => emitExecuteSuccess(traceId, ir.appId, {
+          model: targetModel,
+          tokensIn: validated.response.tokens.input,
+          tokensOut: validated.response.tokens.output,
+          latencyMs: latencyMs2
+        })
+      );
+      const fellOver = targetModel !== initial.target;
+      const fallbackReason = fellOver ? normalizeFallbackReason(attempts) : void 0;
+      await record({
         handle: initial.handle,
-        tokensIn: responseWithStructured.tokens.input,
-        tokensOut: responseWithStructured.tokens.output,
+        tokensIn: validated.response.tokens.input,
+        tokensOut: validated.response.tokens.output,
         latencyMs: latencyMs2,
         success: true,
-        emptyResponse: responseWithStructured.tokens.output === 0,
-        toolsCalled: responseWithStructured.toolCalls.map((tc) => tc.name),
+        emptyResponse: validated.response.tokens.output === 0,
+        toolsCalled: validated.response.toolCalls.map((tc) => tc.name),
         actualModel: targetModel !== initial.target ? targetModel : void 0,
-        responsePreview: responseWithStructured.text.slice(0, 200)
+        mutationsApplied: targetModel !== initial.target ? activeCompile.mutationsApplied.map((m) => m.id) : void 0,
+        promptPreview: extractPromptPreview(ir),
+        responsePreview: validated.response.text.slice(0, 200),
+        cacheReadInputTokens: validated.response.tokens.cached,
+        cacheCreationInputTokens: validated.response.tokens.cacheCreated,
+        // alpha.28 — Glass-Box renderer substrate (migration 018). call()
+        // owns the lifecycle so it has direct visibility into finishReason
+        // (from the normalized provider response), totalMs (mirrors latencyMs
+        // for non-streaming; future streaming variant may diverge), and the
+        // fell-over-from / fallback-reason pair (already computed above for
+        // the CallResult return shape).
+        finishReason: validated.response.finishReason,
+        totalMs: latencyMs2,
+        fellOverFrom: fellOver ? initial.target : void 0,
+        fallbackReason
       });
+      if (fellOver) {
+        const firstFailed = attempts.find((a) => a.status !== "success");
+        if (firstFailed) {
+          safeEmit(
+            () => emitFallbackWalked(traceId, ir.appId, {
+              from: initial.target,
+              to: targetModel,
+              reason: fallbackReason ?? "unknown",
+              attempt: firstFailed
+            })
+          );
+        }
+      }
       return {
         handle: initial.handle,
         actualModel: targetModel,
         requestedModel: initial.target,
         provider: activeCompile.provider,
-        response: responseWithStructured,
+        response: validated.response,
         latencyMs: latencyMs2,
         mutationsApplied: activeCompile.mutationsApplied,
-        attempts
+        attempts,
+        servedBy: targetModel,
+        fellOverFrom: fellOver ? initial.target : void 0,
+        fallbackReason,
+        unreachableFiltered,
+        policyBlockedFiltered,
+        traceId
       };
     }
     attempts.push({
       model: targetModel,
-      status: exec.errorType,
-      errorCode: exec.errorCode,
-      message: exec.message
+      status: validated.errorType,
+      errorCode: validated.errorCode,
+      message: validated.message
     });
-    lastErr = exec;
-    if (exec.errorType === "terminal" || opts.noFallback) {
+    lastErr = validated;
+    if (validated.errorType === "terminal" || opts.noFallback) {
+      if (validated.errorCode === "auth" && !opts.noFallback && activeCompile.provider) {
+        failedProviders.add(activeCompile.provider);
+        continue;
+      }
       break;
     }
   }
   const latencyMs = Date.now() - start;
-  void record({
+  await record({
     handle: initial.handle,
     tokensIn: 0,
     tokensOut: 0,
     latencyMs,
     success: false,
-    errorType: lastErr?.errorCode
+    errorType: lastErr?.errorCode,
+    promptPreview: extractPromptPreview(ir)
   });
+  const filteredNote = unreachableFiltered && unreachableFiltered.length > 0 ? ` (also auto-filtered: [${unreachableFiltered.join(", ")}] \u2014 no API key)` : "";
+  const blockedNote = policyBlockedFiltered && policyBlockedFiltered.length > 0 ? ` (also policy-blocked: [${policyBlockedFiltered.join(", ")}])` : "";
   throw new CallError(
-    `call(): all attempts failed${lastErr ? ` \u2014 ${lastErr.errorCode}: ${lastErr.message}` : ""}`,
+    `call(): all attempts failed${lastErr ? ` \u2014 ${lastErr.errorCode}: ${lastErr.message}` : ""}${filteredNote}${blockedNote}`,
     attempts,
     lastErr?.status,
     lastErr?.errorCode
@@ -1665,20 +4424,74 @@ function compileAndRegister(ir, opts) {
   registerCompile(ir.appId, ir.intent.archetype, ir, result);
   return result;
 }
-function withStructuredOutput(response, ir) {
-  if (!ir.constraints?.structuredOutput) return response;
-  if (!response.text) return response;
+function extractPromptPreview(ir) {
+  const turn = ir.currentTurn?.content;
+  if (turn) return turn.slice(0, 200);
+  const lastHist = ir.history?.[ir.history.length - 1]?.content;
+  if (lastHist) return lastHist.slice(0, 200);
+  return void 0;
+}
+function validateStructuredContract(exec, ir) {
+  if (!ir.constraints?.structuredOutput) {
+    return { ok: true, response: exec.response };
+  }
+  const finish = (exec.response.finishReason ?? "").toLowerCase();
+  if (finish === "max_tokens" || finish === "length") {
+    return {
+      ok: false,
+      status: exec.status,
+      errorType: "retryable",
+      errorCode: "max_tokens_on_structured_output",
+      message: `Provider returned finishReason="${exec.response.finishReason}" on a structured-output call \u2014 output truncated mid-token, JSON cannot be valid`,
+      raw: exec.response.raw
+    };
+  }
+  if (!exec.response.text) {
+    return { ok: true, response: exec.response };
+  }
   try {
-    const parsed = JSON.parse(response.text);
-    return { ...response, structuredOutput: parsed };
+    const parsed = JSON.parse(exec.response.text);
+    return { ok: true, response: { ...exec.response, structuredOutput: parsed } };
   } catch (err) {
     return {
-      ...response,
-      structuredOutput: null,
-      parseError: err instanceof Error ? err.message : String(err)
+      ok: false,
+      status: exec.status,
+      errorType: "retryable",
+      errorCode: "structured_output_parse_failed",
+      message: err instanceof Error ? err.message : String(err),
+      raw: exec.response.raw
     };
   }
 }
+function normalizeFallbackReason(attempts) {
+  const first = attempts.find((a) => a.status !== "success");
+  if (!first) return void 0;
+  const code = first.errorCode ?? "";
+  if (code === "rate_limit_429" || code === "rate_limit") return "rate_limit";
+  if (code === "max_tokens_on_structured_output" || code === "structured_output_parse_failed") {
+    return "cliff";
+  }
+  if (code === "cost_cap_exceeded") return "cost_cap";
+  if (code === "auth" || code === "auth_inferred") return "provider_auth_failed";
+  return "provider_error";
+}
+function generateTraceId() {
+  try {
+    const g = globalThis;
+    if (g.crypto && typeof g.crypto.randomUUID === "function") {
+      return g.crypto.randomUUID();
+    }
+  } catch {
+  }
+  const hex = (n) => Math.floor(Math.random() * Math.pow(16, n)).toString(16).padStart(n, "0");
+  return `${hex(8)}-${hex(4)}-${hex(4)}-${hex(4)}-${hex(12)}`;
+}
+function safeEmit(fn) {
+  try {
+    fn();
+  } catch {
+  }
+}
 
 // src/oracle.ts
 var DEFAULT_DIMENSIONS = ["correctness", "completeness", "conciseness", "format"];
@@ -1768,6 +4581,397 @@ function clamp(n) {
   return Math.max(0, Math.min(1, n));
 }
 
+// src/advisories-api.ts
+var SEVERITY_SET = /* @__PURE__ */ new Set(["info", "warn", "critical"]);
+var STATUS_SET = /* @__PURE__ */ new Set(["open", "snoozed", "resolved"]);
+var RESOLUTION_SOURCE_SET = /* @__PURE__ */ new Set([
+  "auto",
+  "consumer-marked",
+  "declined"
+]);
+function asString(v) {
+  return typeof v === "string" && v.length > 0 ? v : void 0;
+}
+function asSeverity(v) {
+  if (typeof v === "string" && SEVERITY_SET.has(v)) {
+    return v;
+  }
+  return "info";
+}
+function asStatus(v) {
+  if (typeof v === "string" && STATUS_SET.has(v)) {
+    return v;
+  }
+  return "open";
+}
+function asResolutionSource(v) {
+  if (typeof v === "string" && RESOLUTION_SOURCE_SET.has(v)) {
+    return v;
+  }
+  return void 0;
+}
+function rowToAdvisory(row) {
+  const archetype = asString(row.applies_to_archetype);
+  const model = asString(row.applies_to_model);
+  const docsLink = asString(row.docs_url);
+  const suggestion = asString(row.suggestion);
+  let suggestedFix = null;
+  if (docsLink || suggestion) {
+    suggestedFix = { type: "manual" };
+    if (docsLink) suggestedFix.docsLink = docsLink;
+    if (suggestion) suggestedFix.before = suggestion;
+  }
+  const out = {
+    id: typeof row.id === "string" ? row.id : "",
+    rule: typeof row.rule === "string" ? row.rule : "",
+    severity: asSeverity(row.severity),
+    openedAt: typeof row.opened_at === "string" ? row.opened_at : "",
+    lastObservedAt: typeof row.last_observed_at === "string" ? row.last_observed_at : "",
+    observationCount: typeof row.observation_count === "number" ? row.observation_count : 0,
+    appliesTo: {
+      ...archetype ? { archetype } : {},
+      ...model ? { model } : {}
+    },
+    message: typeof row.message === "string" ? row.message : "",
+    suggestedFix,
+    autoApplicable: false,
+    // reserved — alpha.30+
+    status: asStatus(row.status)
+  };
+  const resolvedAt = asString(row.resolved_at);
+  if (resolvedAt) out.resolvedAt = resolvedAt;
+  const resolutionSource = asResolutionSource(row.resolution_source);
+  if (resolutionSource) out.resolutionSource = resolutionSource;
+  const resolutionNote = asString(row.resolution_note);
+  if (resolutionNote) out.resolutionNote = resolutionNote;
+  return out;
+}
+function resolveFetch(injected) {
+  return injected ?? ((...args) => globalThis.fetch(...args));
+}
+function normalizeEndpoint(endpoint) {
+  return endpoint.replace(/\/+$/, "");
+}
+async function getActionableAdvisories(opts) {
+  const {
+    appId,
+    severity,
+    status,
+    brainEndpoint,
+    brainJwt,
+    brainAnonKey,
+    fetch: injectedFetch
+  } = opts;
+  if (!appId) {
+    throw new Error("getActionableAdvisories: appId is required");
+  }
+  const doFetch = resolveFetch(injectedFetch);
+  const base = normalizeEndpoint(brainEndpoint);
+  const qs = new URLSearchParams();
+  qs.set("app_id", `eq.${appId}`);
+  if (severity) qs.set("severity", `eq.${severity}`);
+  const effectiveStatus = status ?? "open";
+  if (effectiveStatus !== "all") {
+    qs.set("status", `eq.${effectiveStatus}`);
+  }
+  qs.set("order", "last_observed_at.desc");
+  const url = `${base}/rest/v1/actionable_advisories_v?${qs.toString()}`;
+  let res;
+  try {
+    res = await doFetch(url, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${brainJwt}`,
+        apikey: brainAnonKey,
+        Accept: "application/json"
+      }
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`getActionableAdvisories: network error: ${msg}`);
+  }
+  if (res.status === 401 || res.status === 403) {
+    throw new Error("getActionableAdvisories: brain auth misconfig");
+  }
+  if (res.status >= 500) {
+    throw new Error(`getActionableAdvisories: brain unavailable (${res.status})`);
+  }
+  if (!res.ok) {
+    throw new Error(`getActionableAdvisories: bad request (${res.status})`);
+  }
+  let rows;
+  try {
+    rows = await res.json();
+  } catch {
+    throw new Error("getActionableAdvisories: malformed brain response");
+  }
+  if (!Array.isArray(rows)) {
+    throw new Error("getActionableAdvisories: expected array from brain");
+  }
+  const out = [];
+  for (const raw of rows) {
+    if (raw && typeof raw === "object") {
+      out.push(rowToAdvisory(raw));
+    }
+  }
+  return out;
+}
+async function markAdvisoryResolved(opts) {
+  const {
+    id,
+    resolutionNote,
+    brainEndpoint,
+    brainJwt,
+    brainAnonKey,
+    fetch: injectedFetch
+  } = opts;
+  if (!id) {
+    return { ok: false, reason: "id_required" };
+  }
+  const doFetch = resolveFetch(injectedFetch);
+  const base = normalizeEndpoint(brainEndpoint);
+  const lookupUrl = `${base}/rest/v1/actionable_advisories_v?id=eq.${encodeURIComponent(id)}&select=app_id,rule`;
+  let lookupRes;
+  try {
+    lookupRes = await doFetch(lookupUrl, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${brainJwt}`,
+        apikey: brainAnonKey,
+        Accept: "application/json"
+      }
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { ok: false, reason: `network_error:${msg}` };
+  }
+  if (lookupRes.status === 401 || lookupRes.status === 403) {
+    return { ok: false, reason: "brain_auth_misconfig" };
+  }
+  if (lookupRes.status >= 500) {
+    return { ok: false, reason: "brain_unavailable" };
+  }
+  if (!lookupRes.ok) {
+    return { ok: false, reason: `brain_lookup_failed:${lookupRes.status}` };
+  }
+  let lookupRows;
+  try {
+    lookupRows = await lookupRes.json();
+  } catch {
+    return { ok: false, reason: "brain_lookup_malformed" };
+  }
+  if (!Array.isArray(lookupRows) || lookupRows.length === 0) {
+    return { ok: false, reason: "advisory_not_found" };
+  }
+  const tuple = lookupRows[0];
+  const appId = typeof tuple.app_id === "string" ? tuple.app_id : "";
+  const code = typeof tuple.rule === "string" ? tuple.rule : "";
+  if (!appId || !code) {
+    return { ok: false, reason: "advisory_tuple_invalid" };
+  }
+  const outcomesUrl = `${base}/rest/v1/compile_outcomes?app_id=eq.${encodeURIComponent(appId)}&select=id`;
+  let outcomesRes;
+  try {
+    outcomesRes = await doFetch(outcomesUrl, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${brainJwt}`,
+        apikey: brainAnonKey,
+        Accept: "application/json"
+      }
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { ok: false, reason: `network_error:${msg}` };
+  }
+  if (outcomesRes.status === 401 || outcomesRes.status === 403) {
+    return { ok: false, reason: "brain_auth_misconfig" };
+  }
+  if (outcomesRes.status >= 500) {
+    return { ok: false, reason: "brain_unavailable" };
+  }
+  if (!outcomesRes.ok) {
+    return { ok: false, reason: `brain_lookup_failed:${outcomesRes.status}` };
+  }
+  let outcomeRows;
+  try {
+    outcomeRows = await outcomesRes.json();
+  } catch {
+    return { ok: false, reason: "brain_lookup_malformed" };
+  }
+  if (!Array.isArray(outcomeRows)) {
+    return { ok: false, reason: "brain_lookup_malformed" };
+  }
+  const outcomeIds = [];
+  for (const row of outcomeRows) {
+    if (row && typeof row === "object") {
+      const idVal = row.id;
+      if (typeof idVal === "number" && Number.isFinite(idVal)) {
+        outcomeIds.push(idVal);
+      }
+    }
+  }
+  if (outcomeIds.length === 0) {
+    return { ok: true };
+  }
+  const inList = outcomeIds.join(",");
+  const patchUrl = `${base}/rest/v1/compile_outcome_advisories?outcome_id=in.(${inList})&code=eq.${encodeURIComponent(code)}&resolved_at=is.null`;
+  const patchBody = {
+    resolved_at: (/* @__PURE__ */ new Date()).toISOString(),
+    resolution_source: "consumer-marked"
+  };
+  if (resolutionNote !== void 0) {
+    patchBody.resolution_note = resolutionNote;
+  }
+  let patchRes;
+  try {
+    patchRes = await doFetch(patchUrl, {
+      method: "PATCH",
+      headers: {
+        Authorization: `Bearer ${brainJwt}`,
+        apikey: brainAnonKey,
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        // PostgREST default is no return; we don't need the row back.
+        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 (patchRes.status === 401 || patchRes.status === 403) {
+    return { ok: false, reason: "brain_auth_misconfig" };
+  }
+  if (patchRes.status >= 500) {
+    return { ok: false, reason: "brain_unavailable" };
+  }
+  if (!patchRes.ok) {
+    return { ok: false, reason: `patch_failed:${patchRes.status}` };
+  }
+  return { ok: true };
+}
+
+// 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;
+    }
+    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
+    };
+  } catch {
+    return null;
+  }
+}
+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 ?? true
+  };
+  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;
+  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/index.ts
 function compile2(ir, opts) {
   const result = compile(ir, opts);
@@ -1776,12 +4980,19 @@ function compile2(ir, opts) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ABSOLUTE_FLOOR,
   ALIASES,
   ALL_ARCHETYPES,
+  ARCHETYPE_FLOOR_DEFAULT,
   CallError,
   DIALECT_VERSION,
   INTENT_ARCHETYPES,
+  MEASURED_GROUNDING_MIN_N,
+  PROVIDER_ENV_KEYS,
+  RULE_SEQUENTIAL_TOOL_CLIFF,
+  TRANSLATOR_FLOOR,
   allProfiles,
+  applySectionRewrites,
   bucketContext,
   bucketHistory,
   bucketToolCount,
@@ -1792,13 +5003,41 @@ function compile2(ir, opts) {
   configureBrain,
   countTokens,
   execute,
+  getActionableAdvisories,
+  getAllStarterChains,
+  getAllStarterChainsWithGrounding,
+  getArchetypePerfScore,
+  getDefaultFallbackChain,
+  getDefaultFallbackChainWithGrounding,
+  getModelCompatibility,
+  getPerAxisMetrics,
   getProfile,
+  getReachabilityDiagnostic,
+  getSequentialStarterChain,
+  getSequentialStarterChainWithGrounding,
+  getStarterChain,
+  getStarterChainWithGrounding,
   hashShape,
   isArchetype,
+  isBrainQueryActiveFor,
+  isModelReachable,
+  isProviderReachable,
   learningKey,
+  loadAliasesFromBrain,
+  loadArchetypePerfFromBrain,
+  loadArchetypePerfNFromBrain,
+  loadChainsFromBrain,
+  loadModelsFromBrain,
+  loadPricingFromBrain,
+  markAdvisoryResolved,
+  profileToRow,
   profilesByProvider,
   record,
+  recordOutcome,
   resetTokenizer,
+  resolvePricingAt,
+  resolveProviderKey,
+  runAdvisor,
   setTokenizer,
   tryGetProfile
 });