@warmdrift/kgauto-compiler 2.0.0-alpha.10

package/dist/index.js

@@ -0,0 +1,2559 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ALIASES: () => ALIASES,
+  ALL_ARCHETYPES: () => ALL_ARCHETYPES,
+  CallError: () => CallError,
+  DIALECT_VERSION: () => DIALECT_VERSION,
+  INTENT_ARCHETYPES: () => INTENT_ARCHETYPES,
+  PROVIDER_ENV_KEYS: () => PROVIDER_ENV_KEYS,
+  allProfiles: () => allProfiles,
+  bucketContext: () => bucketContext,
+  bucketHistory: () => bucketHistory,
+  bucketToolCount: () => bucketToolCount,
+  buildLLMJudge: () => buildLLMJudge,
+  call: () => call,
+  clearBrain: () => clearBrain,
+  compile: () => compile2,
+  configureBrain: () => configureBrain,
+  countTokens: () => countTokens,
+  execute: () => execute,
+  getAllStarterChains: () => getAllStarterChains,
+  getDefaultFallbackChain: () => getDefaultFallbackChain,
+  getProfile: () => getProfile,
+  getReachabilityDiagnostic: () => getReachabilityDiagnostic,
+  getStarterChain: () => getStarterChain,
+  hashShape: () => hashShape,
+  isArchetype: () => isArchetype,
+  isModelReachable: () => isModelReachable,
+  isProviderReachable: () => isProviderReachable,
+  learningKey: () => learningKey,
+  profilesByProvider: () => profilesByProvider,
+  record: () => record,
+  resetTokenizer: () => resetTokenizer,
+  resolveProviderKey: () => resolveProviderKey,
+  runAdvisor: () => runAdvisor,
+  setTokenizer: () => setTokenizer,
+  tryGetProfile: () => tryGetProfile
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/tokenizer.ts
+var tokenizerImpl = defaultCharBasedCounter;
+function defaultCharBasedCounter(text) {
+  if (!text) return 0;
+  return Math.max(1, Math.ceil(text.length / 4));
+}
+function setTokenizer(impl) {
+  tokenizerImpl = impl;
+}
+function resetTokenizer() {
+  tokenizerImpl = defaultCharBasedCounter;
+}
+function countTokens(text) {
+  if (!text) return 0;
+  try {
+    const n = tokenizerImpl(text);
+    return Number.isFinite(n) && n >= 0 ? n : defaultCharBasedCounter(text);
+  } catch {
+    return defaultCharBasedCounter(text);
+  }
+}
+function countToolTokens(tool) {
+  const namePart = countTokens(tool.name);
+  const descPart = tool.description ? countTokens(tool.description) : 0;
+  const paramPart = tool.parameters ? countTokens(JSON.stringify(tool.parameters)) : 0;
+  return namePart + descPart + paramPart + 8;
+}
+function countMessagesTokens(messages) {
+  let total = 0;
+  for (const m of messages) {
+    total += countTokens(m.content) + 4;
+  }
+  return total;
+}
+
+// src/dialect.ts
+var DIALECT_VERSION = "v1";
+var INTENT_ARCHETYPES = {
+  ask: {
+    name: "ask",
+    description: "Filter, search, or interrogate existing data",
+    examples: ["filter creators by criteria", "find docs matching query", "lookup a record"]
+  },
+  hunt: {
+    name: "hunt",
+    description: "Discover new entities not in the current dataset",
+    examples: ["find new prospects", "crawl for unindexed sources", "expand a seed list"]
+  },
+  classify: {
+    name: "classify",
+    description: "Assign a category from a finite set",
+    examples: ["intent detection", "sentiment", "route-to-team"]
+  },
+  summarize: {
+    name: "summarize",
+    description: "Compress text or data while preserving meaning",
+    examples: ["dashboard insight", "meeting notes", "briefing"]
+  },
+  generate: {
+    name: "generate",
+    description: "Produce new content from a prompt or template",
+    examples: ["draft email", "create marketing copy", "co-founder conversation"]
+  },
+  extract: {
+    name: "extract",
+    description: "Pull structured data from unstructured input",
+    examples: ["parse invoice", "extract entities", "transcript \u2192 action items"]
+  },
+  plan: {
+    name: "plan",
+    description: "Multi-step decomposition of a goal",
+    examples: ["build a roadmap", "sequence tasks", "break a feature into steps"]
+  },
+  critique: {
+    name: "critique",
+    description: "Quality assessment, review, or scoring",
+    examples: ["code review", "design feedback", "oracle judgment"]
+  },
+  transform: {
+    name: "transform",
+    description: "Change format or style while preserving content",
+    examples: ["markdown \u2192 html", "formal \u2192 casual", "translate"]
+  }
+};
+var ALL_ARCHETYPES = Object.keys(INTENT_ARCHETYPES);
+function isArchetype(name) {
+  return name in INTENT_ARCHETYPES;
+}
+function bucketContext(tokens) {
+  if (tokens < 1e3) return "tiny";
+  if (tokens < 4e3) return "small";
+  if (tokens < 16e3) return "medium";
+  if (tokens < 64e3) return "large";
+  return "huge";
+}
+function bucketToolCount(count) {
+  if (count === 0) return "none";
+  if (count <= 5) return "few";
+  if (count <= 20) return "many";
+  return "massive";
+}
+function bucketHistory(turnCount) {
+  if (turnCount <= 1) return "single_turn";
+  if (turnCount <= 6) return "short";
+  return "long";
+}
+function hashShape(s) {
+  return [
+    s.contextBucket,
+    s.toolCountBucket,
+    s.historyDepth,
+    s.outputMode,
+    s.hasExamples ? "ex" : "no_ex"
+  ].join("-");
+}
+function learningKey(archetype, model, shape) {
+  return `${DIALECT_VERSION}::${archetype}::${model}::${hashShape(shape)}`;
+}
+
+// src/passes.ts
+function passSlice(ir) {
+  const intent = ir.intent.archetype;
+  const before = ir.sections.length;
+  const kept = ir.sections.filter((s) => !s.intents || s.intents.length === 0 || s.intents.includes(intent));
+  const dropped = before - kept.length;
+  if (dropped === 0) return { value: ir, mutations: [] };
+  return {
+    value: { ...ir, sections: kept },
+    mutations: [
+      {
+        id: `slice-${dropped}`,
+        source: "static_pass",
+        passName: "slice",
+        description: `Dropped ${dropped} of ${before} sections not tagged for intent=${intent}`
+      }
+    ]
+  };
+}
+function passDedupe(ir) {
+  const seen = /* @__PURE__ */ new Map();
+  const order = [];
+  for (const s of ir.sections) {
+    const key = simpleHash(s.text.trim());
+    if (!seen.has(key)) {
+      seen.set(key, s);
+      order.push(key);
+    }
+  }
+  const deduped = order.map((k) => seen.get(k));
+  const dropped = ir.sections.length - deduped.length;
+  if (dropped === 0) return { value: ir, mutations: [] };
+  return {
+    value: { ...ir, sections: deduped },
+    mutations: [
+      {
+        id: `dedupe-${dropped}`,
+        source: "static_pass",
+        passName: "dedupe",
+        description: `Removed ${dropped} duplicate section(s) (by text hash)`
+      }
+    ]
+  };
+}
+function passToolRelevance(ir, opts = {}) {
+  if (!ir.tools || ir.tools.length === 0) return { value: ir, mutations: [] };
+  const threshold = opts.threshold ?? 0.2;
+  const intent = ir.intent.archetype;
+  const scored = ir.tools.map((t) => {
+    const score = t.relevanceByIntent?.[intent] ?? 0.5;
+    return { tool: t, score };
+  });
+  const kept = scored.filter((s) => s.score >= threshold).sort((a, b) => b.score - a.score).map((s) => s.tool);
+  const limited = opts.maxKeep ? kept.slice(0, opts.maxKeep) : kept;
+  const dropped = ir.tools.length - limited.length;
+  if (dropped === 0) return { value: ir, mutations: [] };
+  return {
+    value: { ...ir, tools: limited },
+    mutations: [
+      {
+        id: `tool-relevance-${dropped}`,
+        source: "static_pass",
+        passName: "tool_relevance",
+        description: `Dropped ${dropped} of ${ir.tools.length} tools below relevance ${threshold} for intent=${intent}`
+      }
+    ]
+  };
+}
+function totalHistoryTokens(history) {
+  let total = 0;
+  for (const m of history) {
+    if (typeof m.content === "string") total += countTokens(m.content);
+  }
+  return total;
+}
+function passCompressHistory(ir, opts = {}) {
+  const history = ir.history;
+  if (!history || history.length === 0) {
+    return { value: ir, mutations: [], historyTokensTotal: 0 };
+  }
+  const keepRecent = opts.keepRecent ?? 4;
+  const summarizeOlderThan = opts.summarizeOlderThan ?? 8;
+  const summarizeAboveTokens = opts.summarizeAboveTokens;
+  const historyTokensTotal = totalHistoryTokens(history);
+  const countThresholdHit = history.length > summarizeOlderThan;
+  const tokenThresholdHit = summarizeAboveTokens !== void 0 && historyTokensTotal > summarizeAboveTokens && history.length > keepRecent;
+  if (!countThresholdHit && !tokenThresholdHit) {
+    return { value: ir, mutations: [], historyTokensTotal };
+  }
+  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
+  };
+}
+function passApplyCliffs(ir, profile, estimatedInputTokens) {
+  const mutations = [];
+  const hints = { qualityWarning: [] };
+  let nextIR = ir;
+  for (const cliff of profile.cliffs) {
+    let triggered = false;
+    switch (cliff.metric) {
+      case "input_tokens":
+        triggered = estimatedInputTokens >= cliff.threshold;
+        break;
+      case "tool_count":
+        triggered = (nextIR.tools?.length ?? 0) >= cliff.threshold;
+        break;
+      case "history_turns":
+        triggered = (nextIR.history?.length ?? 0) >= cliff.threshold;
+        break;
+      case "thinking_with_short_output":
+        triggered = !!nextIR.constraints?.expectedShortOutput;
+        break;
+    }
+    if (triggered && cliff.whenIntent && nextIR.intent.archetype !== cliff.whenIntent) {
+      triggered = false;
+    }
+    if (!triggered) continue;
+    switch (cliff.action) {
+      case "drop_to_top_relevant": {
+        const targetCount = Math.min(
+          Math.floor(cliff.threshold * 0.75),
+          Math.max(1, Math.floor((nextIR.tools?.length ?? 0) / 2))
+        );
+        if (nextIR.tools && nextIR.tools.length > targetCount) {
+          const intent = nextIR.intent.archetype;
+          const scored = nextIR.tools.map((t) => ({ tool: t, score: t.relevanceByIntent?.[intent] ?? 0.5 })).sort((a, b) => b.score - a.score).slice(0, targetCount).map((s) => s.tool);
+          nextIR = { ...nextIR, tools: scored };
+          mutations.push({
+            id: `cliff-${cliff.metric}`,
+            source: "cliff_guard",
+            passName: "apply_cliffs",
+            description: `${profile.id}: ${cliff.reason}; trimmed tools to ${targetCount}`
+          });
+        }
+        break;
+      }
+      case "force_thinking_budget_zero":
+        hints.forceThinkingZero = true;
+        mutations.push({
+          id: `cliff-thinking-zero`,
+          source: "cliff_guard",
+          passName: "apply_cliffs",
+          description: `${profile.id}: ${cliff.reason}`
+        });
+        break;
+      case "force_terse_output":
+        hints.forceTerseOutput = true;
+        mutations.push({
+          id: `cliff-terse`,
+          source: "cliff_guard",
+          passName: "apply_cliffs",
+          description: `${profile.id}: ${cliff.reason}`
+        });
+        break;
+      case "downgrade_quality_warning":
+        hints.qualityWarning.push(cliff.reason);
+        mutations.push({
+          id: `cliff-quality-warning`,
+          source: "cliff_guard",
+          passName: "apply_cliffs",
+          description: `${profile.id}: ${cliff.reason}`
+        });
+        break;
+      case "escalate_target":
+        hints.escalateRequested = true;
+        mutations.push({
+          id: `cliff-escalate`,
+          source: "cliff_guard",
+          passName: "apply_cliffs",
+          description: `${profile.id}: ${cliff.reason}`
+        });
+        break;
+      case "strip_tools": {
+        const droppedCount = nextIR.tools?.length ?? 0;
+        if (droppedCount > 0) {
+          nextIR = { ...nextIR, tools: [] };
+          mutations.push({
+            id: `cliff-strip-tools${cliff.whenIntent ? `-${cliff.whenIntent}` : ""}`,
+            source: "cliff_guard",
+            passName: "apply_cliffs",
+            description: `${profile.id}: ${cliff.reason} \u2014 stripped ${droppedCount} tools`
+          });
+        }
+        break;
+      }
+    }
+  }
+  return { value: { ir: nextIR, loweringHints: hints }, mutations };
+}
+function passScoreTargets(ir, opts) {
+  const constraints = ir.constraints ?? {};
+  const policy = opts.policy ?? {};
+  const blockedSet = new Set(policy.blockedModels ?? []);
+  const preferredSet = new Set(policy.preferredModels ?? []);
+  const scores = [];
+  const policyMutations = [];
+  for (const modelId of ir.models) {
+    let profile;
+    try {
+      profile = opts.profilesById(modelId);
+    } catch {
+      scores.push({
+        modelId,
+        estimatedCostUsd: 0,
+        fits: false,
+        rejectReasons: ["unknown_model_id"],
+        qualityScore: 0,
+        rank: -Infinity
+      });
+      continue;
+    }
+    const reasons = [];
+    if (blockedSet.has(modelId)) {
+      reasons.push(`blocked_by_policy (consumer gated this model \u2014 see CompilePolicy.blockedModels)`);
+    }
+    if (opts.estimatedInputTokens > profile.maxContextTokens * 0.9) {
+      reasons.push(`exceeds context budget (${opts.estimatedInputTokens} > 0.9*${profile.maxContextTokens})`);
+    }
+    if ((ir.tools?.length ?? 0) > profile.maxTools) {
+      reasons.push(`exceeds maxTools (${ir.tools?.length} > ${profile.maxTools})`);
+    }
+    if (constraints.structuredOutput && profile.structuredOutput === "none") {
+      reasons.push(`structuredOutput requested but model has none`);
+    }
+    let qualityPenalty = 0;
+    for (const cliff of profile.cliffs) {
+      if (cliff.action !== "downgrade_quality_warning") continue;
+      let triggered = false;
+      if (cliff.metric === "input_tokens") triggered = opts.estimatedInputTokens >= cliff.threshold;
+      if (cliff.metric === "tool_count") triggered = (ir.tools?.length ?? 0) >= cliff.threshold;
+      if (triggered) qualityPenalty += 0.3;
+    }
+    const estimatedCostUsd = opts.estimatedInputTokens / 1e6 * profile.costInputPer1m;
+    if (policy.maxCostPerCallUsd !== void 0 && estimatedCostUsd > policy.maxCostPerCallUsd) {
+      reasons.push(
+        `exceeds_max_cost_per_call (estimated $${estimatedCostUsd.toFixed(4)} > policy ceiling $${policy.maxCostPerCallUsd.toFixed(4)})`
+      );
+    }
+    const baseQuality = profile.strengths.includes("reasoning") ? 0.85 : profile.strengths.includes("quality") ? 0.8 : 0.6;
+    const qualityScore = Math.max(0, baseQuality - qualityPenalty);
+    const callerOrderBoost = (ir.models.length - ir.models.indexOf(modelId)) * 0.1;
+    const costPenalty = estimatedCostUsd * 5;
+    const preferredBoost = preferredSet.has(modelId) ? 0.5 : 0;
+    const rank = qualityScore + callerOrderBoost - costPenalty - reasons.length * 10 + preferredBoost;
+    scores.push({
+      modelId,
+      estimatedCostUsd,
+      fits: reasons.length === 0,
+      rejectReasons: reasons,
+      qualityScore,
+      rank
+    });
+    if (blockedSet.has(modelId)) {
+      policyMutations.push({
+        id: `policy-blocked-${modelId}`,
+        source: "compile_policy",
+        passName: "score_targets",
+        description: `Model ${modelId} excluded by CompilePolicy.blockedModels`
+      });
+    }
+    if (policy.maxCostPerCallUsd !== void 0 && estimatedCostUsd > policy.maxCostPerCallUsd && !blockedSet.has(modelId)) {
+      policyMutations.push({
+        id: `policy-over-cost-${modelId}`,
+        source: "compile_policy",
+        passName: "score_targets",
+        description: `Model ${modelId} excluded \u2014 estimated cost $${estimatedCostUsd.toFixed(4)} exceeds policy ceiling $${policy.maxCostPerCallUsd.toFixed(4)}`
+      });
+    }
+    if (preferredSet.has(modelId) && reasons.length === 0) {
+      policyMutations.push({
+        id: `policy-preferred-${modelId}`,
+        source: "compile_policy",
+        passName: "score_targets",
+        description: `Model ${modelId} rank boosted by CompilePolicy.preferredModels`
+      });
+    }
+  }
+  return { value: scores, mutations: policyMutations };
+}
+function computeShape(ir, estimatedInputTokens) {
+  return {
+    contextBucket: bucketContext(estimatedInputTokens),
+    toolCountBucket: bucketToolCount(ir.tools?.length ?? 0),
+    historyDepth: bucketHistory(ir.history?.length ?? 0),
+    outputMode: ir.constraints?.structuredOutput ? "json" : ir.tools?.length ? "tool_call" : "text",
+    hasExamples: ir.sections.some((s) => /\bexample\b/i.test(s.id))
+  };
+}
+function estimateInputTokens(ir) {
+  const sectionTokens = ir.sections.reduce((sum, s) => sum + countTokens(s.text), 0);
+  const toolTokens = (ir.tools ?? []).reduce((sum, t) => sum + countToolTokens(t), 0);
+  const historyTokens = countMessagesTokens(ir.history ?? []);
+  const turnTokens = ir.currentTurn ? countTokens(ir.currentTurn.content) + 4 : 0;
+  return sectionTokens + toolTokens + historyTokens + turnTokens + 6;
+}
+function simpleHash(s) {
+  let h = 5381;
+  for (let i = 0; i < s.length; i++) {
+    h = (h << 5) + h + s.charCodeAt(i) | 0;
+  }
+  return (h >>> 0).toString(36);
+}
+
+// src/lower.ts
+function lower(ir, profile, hints = {}) {
+  switch (profile.provider) {
+    case "anthropic":
+      return lowerAnthropic(ir, profile, hints);
+    case "google":
+      return lowerGoogle(ir, profile, hints);
+    case "openai":
+      return lowerOpenAI(ir, profile, hints);
+    case "deepseek":
+      return lowerDeepSeek(ir, profile);
+    default:
+      throw new Error(`No lowering implementation for provider: ${profile.provider}`);
+  }
+}
+function lowerAnthropic(ir, profile, hints) {
+  const systemBlocks = buildAnthropicSystemBlocks(ir.sections, profile);
+  const history = (ir.history ?? []).filter((m) => m.role !== "system");
+  const policy = ir.historyCachePolicy;
+  const markIndex = resolveHistoryMarkIndex(history.length, policy);
+  const messages = buildAnthropicMessages(history, ir.currentTurn, markIndex);
+  const tools = ir.tools ? toAnthropicTools(ir.tools) : void 0;
+  const cacheableTokens = computeCacheableTokens(systemBlocks);
+  const historyCacheableTokens = markIndex >= 0 ? sumHistoryTokens(history, markIndex) : 0;
+  const totalCacheableTokens = cacheableTokens + historyCacheableTokens;
+  const cacheSavings = totalCacheableTokens / 1e6 * profile.costInputPer1m * (1 - (profile.lowering.cache.discount ?? 0.1));
+  return {
+    request: {
+      provider: "anthropic",
+      model: profile.id,
+      system: systemBlocks,
+      messages,
+      tools,
+      // alpha.8: trust profile.maxOutputTokens. The historical Math.min(_, 4096)
+      // floor surprised every consumer once (PB-Cairn contract-gaps brief, Gap 3).
+      // Profile is the single source of truth; consumers wanting a tighter
+      // budget can pass providerOverrides.anthropic.max_tokens explicitly.
+      max_tokens: hints.forceTerseOutput ? 200 : profile.maxOutputTokens
+    },
+    diagnostics: {
+      cacheableTokens,
+      historyCacheableTokens,
+      estimatedCacheSavingsUsd: cacheSavings
+    }
+  };
+}
+function buildAnthropicSystemBlocks(sections, profile) {
+  if (sections.length === 0) return [];
+  const ordered = sortSections(sections);
+  const minTokens = profile.lowering.cache.minTokens ?? 1024;
+  const cacheable = [];
+  const dynamic = [];
+  for (const s of ordered) {
+    if (s.cacheable) cacheable.push(s);
+    else dynamic.push(s);
+  }
+  const blocks = [];
+  if (cacheable.length > 0) {
+    const cacheText = cacheable.map((s) => s.text).join("\n\n");
+    const cacheTextTokens = countTokens(cacheText);
+    const block = {
+      type: "text",
+      text: cacheText
+    };
+    if (cacheTextTokens >= minTokens) {
+      block.cache_control = { type: "ephemeral" };
+    }
+    blocks.push(block);
+  }
+  for (const s of dynamic) {
+    blocks.push({ type: "text", text: s.text });
+  }
+  return blocks;
+}
+function buildAnthropicMessages(history, currentTurn, markIndex) {
+  const out = [];
+  for (let i = 0; i < history.length; i++) {
+    const m = history[i];
+    if (m.role === "system") continue;
+    const shouldMark = i === markIndex;
+    out.push({
+      role: m.role,
+      content: shouldMark ? attachAnthropicCacheControl(m) : m.parts ?? m.content
+    });
+  }
+  if (currentTurn && currentTurn.role !== "system") {
+    out.push({ role: currentTurn.role, content: currentTurn.parts ?? currentTurn.content });
+  }
+  return out;
+}
+function attachAnthropicCacheControl(m) {
+  if (Array.isArray(m.parts) && m.parts.length > 0) {
+    const blocks = m.parts;
+    const last = blocks[blocks.length - 1];
+    const withMarker = {
+      ...last,
+      cache_control: { type: "ephemeral" }
+    };
+    return [...blocks.slice(0, -1), withMarker];
+  }
+  return [
+    {
+      type: "text",
+      text: m.content,
+      cache_control: { type: "ephemeral" }
+    }
+  ];
+}
+function resolveHistoryMarkIndex(historyLen, policy) {
+  if (!policy || policy.strategy === "none") return -1;
+  if (historyLen === 0) return -1;
+  if (policy.strategy === "all-but-latest") {
+    return historyLen - 1;
+  }
+  const idx = historyLen - 1 - policy.suffix;
+  return idx >= 0 ? idx : -1;
+}
+function sumHistoryTokens(history, throughIndex) {
+  let total = 0;
+  for (let i = 0; i <= throughIndex && i < history.length; i++) {
+    const m = history[i];
+    if (m.role === "system") continue;
+    if (Array.isArray(m.parts)) {
+      for (const p of m.parts) {
+        if (typeof p.text === "string") total += countTokens(p.text);
+      }
+    } else if (typeof m.content === "string") {
+      total += countTokens(m.content);
+    }
+  }
+  return total;
+}
+function toAnthropicTools(tools) {
+  return tools.map((t) => ({
+    name: t.name,
+    description: t.description ?? "",
+    input_schema: t.parameters ?? { type: "object", properties: {} }
+  }));
+}
+function computeCacheableTokens(blocks) {
+  let total = 0;
+  for (const b of blocks) {
+    if (b.cache_control) total += countTokens(b.text);
+  }
+  return total;
+}
+function lowerGoogle(ir, profile, hints) {
+  const ordered = sortSections(ir.sections);
+  const systemText = ordered.map((s) => s.text).join("\n\n");
+  const generationConfig = {};
+  if (hints.forceThinkingZero && profile.lowering.thinking) {
+    setNestedField(generationConfig, profile.lowering.thinking.field.replace(/^generationConfig\./, ""), 0);
+  }
+  if (hints.forceTerseOutput) {
+    generationConfig.maxOutputTokens = 200;
+  }
+  if (ir.constraints?.structuredOutput && profile.structuredOutput === "native") {
+    generationConfig.responseMimeType = "application/json";
+  }
+  const contents = buildGoogleContents(ir.history ?? [], ir.currentTurn);
+  const tools = ir.tools && ir.tools.length > 0 ? toGoogleTools(ir.tools) : void 0;
+  const cacheable = ordered.filter((s) => s.cacheable);
+  const cacheableTokens = cacheable.reduce((sum, s) => sum + countTokens(s.text), 0);
+  const minTokens = profile.lowering.cache.minTokens ?? 4096;
+  const meetsMin = cacheableTokens >= minTokens;
+  const cacheSavings = meetsMin ? cacheableTokens / 1e6 * profile.costInputPer1m * (1 - (profile.lowering.cache.discount ?? 0.25)) : 0;
+  const history = (ir.history ?? []).filter((m) => m.role !== "system");
+  const histMarkIndex = resolveHistoryMarkIndex(history.length, ir.historyCachePolicy);
+  const historyCacheableTokens = histMarkIndex >= 0 ? sumHistoryTokens(history, histMarkIndex) : 0;
+  return {
+    request: {
+      provider: "google",
+      model: profile.id,
+      systemInstruction: systemText ? { role: "system", parts: [{ text: systemText }] } : void 0,
+      contents,
+      tools,
+      generationConfig: Object.keys(generationConfig).length > 0 ? generationConfig : void 0
+    },
+    diagnostics: {
+      cacheableTokens: meetsMin ? cacheableTokens : 0,
+      historyCacheableTokens,
+      estimatedCacheSavingsUsd: cacheSavings
+    }
+  };
+}
+function buildGoogleContents(history, currentTurn) {
+  const out = [];
+  for (const m of history) {
+    if (m.role === "system") continue;
+    out.push({
+      role: m.role === "assistant" ? "model" : m.role,
+      parts: m.parts ?? [{ text: m.content }]
+    });
+  }
+  if (currentTurn && currentTurn.role !== "system") {
+    out.push({
+      role: currentTurn.role === "assistant" ? "model" : currentTurn.role,
+      parts: currentTurn.parts ?? [{ text: currentTurn.content }]
+    });
+  }
+  return out;
+}
+function toGoogleTools(tools) {
+  return [
+    {
+      functionDeclarations: tools.map((t) => ({
+        name: t.name,
+        description: t.description ?? "",
+        parameters: t.parameters ?? { type: "object", properties: {} }
+      }))
+    }
+  ];
+}
+function lowerOpenAI(ir, profile, hints) {
+  const ordered = sortSections(ir.sections);
+  const systemText = ordered.map((s) => s.text).join("\n\n");
+  const systemRole = profile.systemPromptMode === "as_developer" ? "developer" : "system";
+  const messages = systemText ? [{ role: systemRole, content: systemText }] : [];
+  for (const m of ir.history ?? []) {
+    if (m.role === "system") continue;
+    messages.push({ role: m.role, content: m.parts ?? m.content });
+  }
+  if (ir.currentTurn && ir.currentTurn.role !== "system") {
+    messages.push({
+      role: ir.currentTurn.role,
+      content: ir.currentTurn.parts ?? ir.currentTurn.content
+    });
+  }
+  const history = (ir.history ?? []).filter((m) => m.role !== "system");
+  const histMarkIndex = resolveHistoryMarkIndex(history.length, ir.historyCachePolicy);
+  const historyCacheableTokens = histMarkIndex >= 0 ? sumHistoryTokens(history, histMarkIndex) : 0;
+  return {
+    request: {
+      provider: "openai",
+      model: profile.id,
+      messages,
+      tools: ir.tools && ir.tools.length > 0 ? toOpenAITools(ir.tools) : void 0,
+      response_format: ir.constraints?.structuredOutput ? { type: "json_object" } : void 0,
+      reasoning_effort: hints.forceTerseOutput ? "low" : void 0
+    },
+    diagnostics: {
+      cacheableTokens: 0,
+      historyCacheableTokens,
+      estimatedCacheSavingsUsd: 0
+    }
+  };
+}
+function toOpenAITools(tools) {
+  return tools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.name,
+      description: t.description ?? "",
+      parameters: t.parameters ?? { type: "object", properties: {} }
+    }
+  }));
+}
+function lowerDeepSeek(ir, profile) {
+  const ordered = sortSections(ir.sections);
+  const systemText = ordered.map((s) => s.text).join("\n\n");
+  const messages = systemText ? [{ role: "system", content: systemText }] : [];
+  for (const m of ir.history ?? []) {
+    if (m.role === "system") continue;
+    messages.push({ role: m.role, content: m.parts ?? m.content });
+  }
+  if (ir.currentTurn && ir.currentTurn.role !== "system") {
+    messages.push({
+      role: ir.currentTurn.role,
+      content: ir.currentTurn.parts ?? ir.currentTurn.content
+    });
+  }
+  const history = (ir.history ?? []).filter((m) => m.role !== "system");
+  const histMarkIndex = resolveHistoryMarkIndex(history.length, ir.historyCachePolicy);
+  const historyCacheableTokens = histMarkIndex >= 0 ? sumHistoryTokens(history, histMarkIndex) : 0;
+  return {
+    request: {
+      provider: "deepseek",
+      model: profile.id,
+      messages,
+      tools: ir.tools && ir.tools.length > 0 ? ir.tools.slice(0, 1).map((t) => ({
+        type: "function",
+        function: {
+          name: t.name,
+          description: t.description ?? "",
+          parameters: t.parameters ?? { type: "object", properties: {} }
+        }
+      })) : void 0
+    },
+    diagnostics: {
+      cacheableTokens: 0,
+      historyCacheableTokens,
+      estimatedCacheSavingsUsd: 0
+    }
+  };
+}
+function sortSections(sections) {
+  return [...sections].sort((a, b) => {
+    const wa = a.weight ?? 100;
+    const wb = b.weight ?? 100;
+    return wa - wb;
+  });
+}
+function setNestedField(obj, path, value) {
+  const parts = path.split(".");
+  let cursor = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const key = parts[i];
+    if (!(key in cursor) || typeof cursor[key] !== "object" || cursor[key] === null) {
+      cursor[key] = {};
+    }
+    cursor = cursor[key];
+  }
+  cursor[parts[parts.length - 1]] = value;
+}
+
+// src/profiles.ts
+var ANTHROPIC_LOWERING_BASE = {
+  system: { mode: "inline" },
+  cache: {
+    strategy: "cache_control",
+    minTokens: 1024,
+    discount: 0.1,
+    ttlSeconds: 300
+  },
+  tools: { format: "anthropic" }
+};
+var GOOGLE_LOWERING_BASE = {
+  system: { mode: "separate", field: "systemInstruction" },
+  cache: {
+    strategy: "cachedContent",
+    minTokens: 4096,
+    discount: 0.25,
+    ttlSeconds: 3600
+  },
+  tools: { format: "google" }
+};
+var PROFILES_RAW = [
+  // ── Anthropic ──
+  {
+    id: "claude-opus-4-7",
+    verifiedAgainstDocs: "2026-05-08",
+    provider: "anthropic",
+    status: "current",
+    maxContextTokens: 1e6,
+    maxOutputTokens: 128e3,
+    maxTools: 64,
+    parallelToolCalls: true,
+    structuredOutput: "grammar",
+    systemPromptMode: "inline",
+    streaming: true,
+    cliffs: [],
+    costInputPer1m: 5,
+    costOutputPer1m: 25,
+    lowering: ANTHROPIC_LOWERING_BASE,
+    recovery: [
+      {
+        signal: "rate_limit",
+        action: "escalate",
+        reason: "429 from Anthropic \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", "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.",
+    // 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",
+    verifiedAgainstDocs: "2026-05-08",
+    provider: "anthropic",
+    status: "legacy",
+    maxContextTokens: 1e6,
+    maxOutputTokens: 128e3,
+    maxTools: 64,
+    parallelToolCalls: true,
+    structuredOutput: "grammar",
+    systemPromptMode: "inline",
+    streaming: true,
+    cliffs: [],
+    costInputPer1m: 5,
+    costOutputPer1m: 25,
+    lowering: ANTHROPIC_LOWERING_BASE,
+    recovery: [
+      {
+        signal: "rate_limit",
+        action: "escalate",
+        reason: "429 from Anthropic \u2014 escalate to fallback chain"
+      },
+      {
+        signal: "model_not_found",
+        action: "escalate",
+        reason: "Model deprecated/renamed \u2014 escalate (L-061)"
+      }
+    ],
+    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).",
+    // 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",
+    verifiedAgainstDocs: "2026-05-08",
+    provider: "anthropic",
+    status: "current",
+    maxContextTokens: 1e6,
+    maxOutputTokens: 64e3,
+    maxTools: 64,
+    parallelToolCalls: true,
+    structuredOutput: "grammar",
+    systemPromptMode: "inline",
+    streaming: true,
+    cliffs: [],
+    costInputPer1m: 3,
+    costOutputPer1m: 15,
+    lowering: ANTHROPIC_LOWERING_BASE,
+    recovery: [
+      { signal: "rate_limit", action: "escalate", reason: "429 \u2014 escalate" },
+      { signal: "model_not_found", action: "escalate", reason: "Deprecated \u2014 escalate (L-061)" }
+    ],
+    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.",
+    // 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",
+    verifiedAgainstDocs: "2026-05-08",
+    provider: "anthropic",
+    status: "current",
+    maxContextTokens: 2e5,
+    maxOutputTokens: 64e3,
+    maxTools: 32,
+    parallelToolCalls: true,
+    structuredOutput: "grammar",
+    systemPromptMode: "inline",
+    streaming: true,
+    cliffs: [
+      {
+        metric: "tool_count",
+        threshold: 16,
+        action: "drop_to_top_relevant",
+        reason: "Haiku reliability degrades above ~16 tools"
+      }
+    ],
+    costInputPer1m: 1,
+    costOutputPer1m: 5,
+    lowering: ANTHROPIC_LOWERING_BASE,
+    recovery: [
+      { signal: "rate_limit", action: "escalate", reason: "429 \u2014 escalate to Sonnet" }
+    ],
+    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`.",
+    // 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 ──
+  {
+    id: "gemini-2.5-flash",
+    verifiedAgainstDocs: "2026-05-08",
+    provider: "google",
+    status: "current",
+    maxContextTokens: 1048576,
+    maxOutputTokens: 65535,
+    maxTools: 128,
+    parallelToolCalls: true,
+    structuredOutput: "native",
+    systemPromptMode: "separate",
+    streaming: true,
+    cliffs: [
+      {
+        metric: "input_tokens",
+        threshold: 8e3,
+        action: "downgrade_quality_warning",
+        reason: "Quality degrades significantly above ~8K context tokens"
+      },
+      {
+        metric: "tool_count",
+        threshold: 20,
+        action: "drop_to_top_relevant",
+        reason: "Tool reliability drops above ~20 tools (despite 128 hard limit)"
+      },
+      {
+        metric: "thinking_with_short_output",
+        threshold: 1,
+        action: "force_thinking_budget_zero",
+        reason: "Thinking tokens consume maxOutputTokens \u2014 empty response if drained"
+      },
+      {
+        // s11 trust artifact (2026-05-02): brain showed 5/5 empty rate on
+        // tt-intelligence/summarize/gemini-2.5-flash with tools offered.
+        // v1's disable_thinking_for_short_output already fired and didn't
+        // help — disabling thinking is necessary but not sufficient. Tools
+        // present + summarize intent confuses Flash into a no-output state
+        // (likely tool-decision purgatory). Strip tools entirely for this
+        // archetype on this model.
+        metric: "tool_count",
+        threshold: 1,
+        whenIntent: "summarize",
+        action: "strip_tools",
+        reason: "Gemini Flash returns empty when summarize intent has tools offered (5/5 empty rate observed in v1 prod 2026-04-19, replayed into v2 brain 2026-04-29)"
+      }
+    ],
+    costInputPer1m: 0.3,
+    costOutputPer1m: 2.5,
+    lowering: {
+      ...GOOGLE_LOWERING_BASE,
+      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: "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",
+    verifiedAgainstDocs: "2026-05-08",
+    provider: "google",
+    status: "current",
+    maxContextTokens: 1048576,
+    maxOutputTokens: 65535,
+    maxTools: 128,
+    parallelToolCalls: true,
+    structuredOutput: "native",
+    systemPromptMode: "separate",
+    streaming: true,
+    cliffs: [
+      {
+        metric: "input_tokens",
+        threshold: 2e5,
+        action: "downgrade_quality_warning",
+        reason: "Pricing doubles above 200K: input $1.25\u2192$2.50/M, output $10\u2192$15/M"
+      }
+    ],
+    costInputPer1m: 1.25,
+    costOutputPer1m: 10,
+    lowering: {
+      ...GOOGLE_LOWERING_BASE,
+      thinking: { field: "generationConfig.thinkingConfig.thinkingBudget", default: "auto" }
+    },
+    recovery: [
+      {
+        signal: "malformed_function_call",
+        action: "escalate",
+        reason: "MALFORMED_FUNCTION_CALL \u2014 escalate"
+      }
+    ],
+    strengths: ["reasoning", "1m_context", "structured_output", "tool_use"],
+    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",
+    verifiedAgainstDocs: "2026-05-08",
+    provider: "google",
+    status: "preview",
+    maxContextTokens: 1048576,
+    maxOutputTokens: 65535,
+    maxTools: 128,
+    parallelToolCalls: true,
+    structuredOutput: "native",
+    systemPromptMode: "separate",
+    streaming: true,
+    cliffs: [
+      {
+        metric: "input_tokens",
+        threshold: 2e5,
+        action: "downgrade_quality_warning",
+        reason: "Pricing doubles above 200K: input $2\u2192$4/M, output $12\u2192$18/M"
+      }
+    ],
+    costInputPer1m: 2,
+    costOutputPer1m: 12,
+    lowering: {
+      ...GOOGLE_LOWERING_BASE,
+      cache: { ...GOOGLE_LOWERING_BASE.cache, discount: 0.1 },
+      thinking: { field: "generationConfig.thinkingConfig.thinkingBudget", default: "auto" }
+    },
+    recovery: [
+      {
+        signal: "malformed_function_call",
+        action: "escalate",
+        reason: "MALFORMED_FUNCTION_CALL \u2014 escalate"
+      }
+    ],
+    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.",
+    // 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
+  // to `deepseek-v4-flash` non-thinking mode. Old kgauto profile claimed 64k
+  // context + $0.27/$1.10 — actual is 1M context + $0.14/$0.28. Now modeled
+  // as: V4-Flash + V4-Pro as canonical profiles; deepseek-chat and
+  // deepseek-reasoner registered as aliases (see ALIASES below).
+  {
+    id: "deepseek-v4-flash",
+    verifiedAgainstDocs: "2026-05-08",
+    provider: "deepseek",
+    status: "current",
+    maxContextTokens: 1e6,
+    maxOutputTokens: 384e3,
+    maxTools: 16,
+    parallelToolCalls: false,
+    structuredOutput: "native",
+    systemPromptMode: "inline",
+    streaming: true,
+    cliffs: [
+      {
+        metric: "tool_count",
+        threshold: 1,
+        action: "drop_to_top_relevant",
+        reason: "Sequential tool calls only \u2014 L-040"
+      }
+    ],
+    costInputPer1m: 0.14,
+    costOutputPer1m: 0.28,
+    lowering: {
+      system: { mode: "inline" },
+      cache: { strategy: "unsupported" },
+      tools: { format: "deepseek" }
+    },
+    recovery: [
+      { signal: "rate_limit", action: "escalate", reason: "429 \u2014 escalate" }
+    ],
+    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.",
+    // 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",
+    verifiedAgainstDocs: "2026-05-08",
+    provider: "deepseek",
+    status: "current",
+    maxContextTokens: 1e6,
+    maxOutputTokens: 384e3,
+    maxTools: 16,
+    parallelToolCalls: false,
+    structuredOutput: "native",
+    systemPromptMode: "inline",
+    streaming: true,
+    cliffs: [
+      {
+        metric: "tool_count",
+        threshold: 1,
+        action: "drop_to_top_relevant",
+        reason: "Sequential tool calls only \u2014 L-040"
+      }
+    ],
+    // Profile carries REGULAR pricing, not the 75%-off promo (ends 2026-05-31).
+    // Under-estimating cost is worse than over-estimating for budget caps.
+    costInputPer1m: 1.74,
+    costOutputPer1m: 3.48,
+    lowering: {
+      system: { mode: "inline" },
+      cache: { strategy: "unsupported" },
+      tools: { format: "deepseek" }
+    },
+    recovery: [
+      { signal: "rate_limit", action: "escalate", reason: "429 \u2014 escalate" }
+    ],
+    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.",
+    // 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
+    }
+  }
+];
+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/advisor.ts
+function runAdvisor(ir, result, profile, policy) {
+  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));
+  return out;
+}
+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"
+    }
+  ];
+}
+
+// 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 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);
+  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
+  };
+  const advisories = runAdvisor(
+    ir,
+    {
+      target: profile.id,
+      provider: profile.provider,
+      tokensIn: inputTokens,
+      diagnostics
+    },
+    profile,
+    opts.policy
+  );
+  return {
+    handle,
+    target: profile.id,
+    provider: profile.provider,
+    request: lowered.request,
+    tokensIn: inputTokens,
+    estimatedCostUsd: target.estimatedCostUsd,
+    mutationsApplied: accumulatedMutations,
+    fallbackChain,
+    advisories,
+    diagnostics
+  };
+}
+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) {
+    throw new Error(
+      `compile(): final IR has ${ir.tools?.length} tools, exceeds ${profile.id} maxTools (${profile.maxTools})`
+    );
+  }
+}
+
+// src/brain.ts
+var activeConfig;
+function configureBrain(config) {
+  const endpoint = config.endpoint.replace(/\/outcomes\/?$/, "");
+  activeConfig = { ...config, endpoint };
+}
+function clearBrain() {
+  activeConfig = void 0;
+}
+var compileRegistry = /* @__PURE__ */ new Map();
+var REGISTRY_MAX_ENTRIES = 1e4;
+function registerCompile(appId, archetype, ir, result) {
+  if (compileRegistry.size >= REGISTRY_MAX_ENTRIES) {
+    const cutoff = Math.floor(REGISTRY_MAX_ENTRIES * 0.25);
+    let evicted = 0;
+    for (const k of compileRegistry.keys()) {
+      compileRegistry.delete(k);
+      if (++evicted >= cutoff) break;
+    }
+  }
+  const tokens = result.tokensIn;
+  const shape = computeShape(
+    {
+      appId,
+      intent: { name: archetype, archetype },
+      sections: ir.sections,
+      tools: ir.tools,
+      history: ir.history,
+      models: ir.models,
+      constraints: ir.constraints
+    },
+    tokens
+  );
+  const shapeKey = `${shape.contextBucket}-${shape.toolCountBucket}-${shape.historyDepth}-${shape.outputMode}`;
+  compileRegistry.set(result.handle, {
+    appId,
+    archetype,
+    model: result.target,
+    provider: result.provider,
+    shapeKey,
+    learningKey: learningKey(archetype, result.target, shape),
+    estimatedTokensIn: tokens,
+    mutationsApplied: result.mutationsApplied.map((m) => m.id),
+    startedAt: Date.now(),
+    historyCacheableTokens: result.diagnostics.historyCacheableTokens,
+    historyTokensTotal: result.diagnostics.historyTokensTotal
+  });
+}
+async function record(input) {
+  const reg = compileRegistry.get(input.handle);
+  if (reg) compileRegistry.delete(input.handle);
+  if (!activeConfig) {
+    return;
+  }
+  const payload = buildPayload(input, reg);
+  const config = activeConfig;
+  const fetchFn = config.fetchImpl ?? fetch;
+  const send = async () => {
+    try {
+      const res = await fetchFn(`${config.endpoint}/outcomes`, {
+        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>");
+        throw new Error(`brain ${res.status}: ${text}`);
+      }
+    } catch (err) {
+      (config.onError ?? defaultOnError)(err);
+    }
+  };
+  if (config.sync) {
+    await send();
+  } else {
+    void send();
+  }
+}
+function defaultOnError(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;
+  return {
+    handle: input.handle,
+    app_id: reg?.appId,
+    intent_archetype: reg?.archetype,
+    model: actual,
+    requested_model: requested,
+    provider: reg?.provider,
+    shape_key: reg?.shapeKey,
+    learning_key: reg?.learningKey,
+    mutations_applied: mutationsApplied,
+    tokens_in: input.tokensIn,
+    tokens_out: input.tokensOut,
+    estimated_tokens_in: reg?.estimatedTokensIn,
+    latency_ms: input.latencyMs,
+    success: input.success,
+    empty_response: input.emptyResponse ?? input.tokensOut === 0,
+    error_type: input.errorType,
+    tools_called: input.toolsCalled,
+    oracle_score: input.oracleScore?.score,
+    oracle_dimensions: input.oracleScore?.dimensions,
+    oracle_rationale: input.oracleScore?.rationale,
+    prompt_preview: input.promptPreview,
+    response_preview: input.responsePreview,
+    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
+  };
+}
+function computeCostUsd(modelId, tokensIn, tokensOut) {
+  if (tokensIn === 0 && tokensOut === 0) return void 0;
+  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;
+}
+
+// src/ir.ts
+var CallError = class extends Error {
+  attempts;
+  lastErrorCode;
+  lastStatus;
+  constructor(message, attempts, lastStatus, lastErrorCode) {
+    super(message);
+    this.name = "CallError";
+    this.attempts = attempts;
+    this.lastStatus = lastStatus;
+    this.lastErrorCode = lastErrorCode;
+  }
+};
+
+// 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 resolveProviderKey(provider, opts = {}) {
+  if (!isSupportedProvider(provider)) return void 0;
+  const explicit = opts.apiKeys?.[provider];
+  if (explicit) return explicit;
+  const env = opts.envSource ?? defaultEnv();
+  for (const name of PROVIDER_ENV_KEYS[provider]) {
+    const v = 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 (opts.apiKeys?.[provider]) {
+      out[provider] = { reachable: true, via: "apiKeys" };
+      continue;
+    }
+    const envKeyFound = PROVIDER_ENV_KEYS[provider].find((name) => 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";
+var DEEPSEEK_URL = "https://api.deepseek.com/chat/completions";
+async function execute(request, opts = {}) {
+  const merged = applyOverrides(request, opts.providerOverrides);
+  switch (merged.provider) {
+    case "anthropic":
+      return executeAnthropic(merged, opts);
+    case "google":
+      return executeGoogle(merged, opts);
+    case "openai":
+      return executeOpenAI(merged, opts);
+    case "deepseek":
+      return executeDeepSeek(merged, opts);
+    default: {
+      const _exhaustive = merged;
+      throw new Error(`execute(): no executor for provider: ${JSON.stringify(_exhaustive)}`);
+    }
+  }
+}
+async function executeAnthropic(request, opts) {
+  const apiKey = resolveProviderKey("anthropic", { apiKeys: opts.apiKeys });
+  if (!apiKey) {
+    return terminalError(401, "auth", "ANTHROPIC_API_KEY missing");
+  }
+  const { provider: _provider, ...body } = request;
+  const fetchFn = opts.fetchImpl ?? fetch;
+  let res;
+  let json;
+  try {
+    res = await fetchFn(ANTHROPIC_URL, {
+      method: "POST",
+      headers: {
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+        "content-type": "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+    json = await res.json().catch(() => ({}));
+  } catch (err) {
+    return retryableError(0, "network_error", String(err), null);
+  }
+  if (!res.ok) return classifyHttpError(res.status, json);
+  return { ok: true, status: res.status, response: normalizeAnthropic(json) };
+}
+function normalizeAnthropic(raw) {
+  const r = raw;
+  const text = (r.content ?? []).filter((b) => b.type === "text" && typeof b.text === "string").map((b) => b.text).join("");
+  const toolCalls = (r.content ?? []).filter((b) => b.type === "tool_use" && b.name && b.id).map((b) => ({ id: b.id, name: b.name, args: b.input ?? {} }));
+  const tokens = {
+    input: r.usage?.input_tokens ?? 0,
+    output: r.usage?.output_tokens ?? 0,
+    total: (r.usage?.input_tokens ?? 0) + (r.usage?.output_tokens ?? 0),
+    cached: r.usage?.cache_read_input_tokens,
+    cacheCreated: r.usage?.cache_creation_input_tokens
+  };
+  return { text, structuredOutput: null, toolCalls, tokens, finishReason: r.stop_reason, raw };
+}
+async function executeGoogle(request, opts) {
+  const apiKey = resolveProviderKey("google", { apiKeys: opts.apiKeys });
+  if (!apiKey) {
+    return terminalError(401, "auth", "GOOGLE_API_KEY/GEMINI_API_KEY missing");
+  }
+  const { provider: _provider, model, ...body } = request;
+  const url = `https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(model)}:generateContent?key=${encodeURIComponent(apiKey)}`;
+  const fetchFn = opts.fetchImpl ?? fetch;
+  let res;
+  let json;
+  try {
+    res = await fetchFn(url, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    json = await res.json().catch(() => ({}));
+  } catch (err) {
+    return retryableError(0, "network_error", String(err), null);
+  }
+  if (!res.ok) return classifyHttpError(res.status, json);
+  return { ok: true, status: res.status, response: normalizeGoogle(json) };
+}
+function normalizeGoogle(raw) {
+  const r = raw;
+  const candidate = r.candidates?.[0];
+  const parts = candidate?.content?.parts ?? [];
+  const text = parts.filter((p) => typeof p.text === "string").map((p) => p.text).join("");
+  const toolCalls = parts.filter((p) => p.functionCall?.name).map((p, i) => ({
+    id: `gemini-call-${i}`,
+    name: p.functionCall.name,
+    args: p.functionCall.args ?? {}
+  }));
+  const u = r.usageMetadata ?? {};
+  const tokens = {
+    input: u.promptTokenCount ?? 0,
+    output: u.candidatesTokenCount ?? 0,
+    total: u.totalTokenCount ?? (u.promptTokenCount ?? 0) + (u.candidatesTokenCount ?? 0),
+    cached: u.cachedContentTokenCount
+  };
+  return { text, structuredOutput: null, toolCalls, tokens, finishReason: candidate?.finishReason, raw };
+}
+async function executeOpenAI(request, opts) {
+  const apiKey = resolveProviderKey("openai", { apiKeys: opts.apiKeys });
+  if (!apiKey) {
+    return terminalError(401, "auth", "OPENAI_API_KEY missing");
+  }
+  const { provider: _provider, ...body } = request;
+  const fetchFn = opts.fetchImpl ?? fetch;
+  let res;
+  let json;
+  try {
+    res = await fetchFn(OPENAI_URL, {
+      method: "POST",
+      headers: { authorization: `Bearer ${apiKey}`, "content-type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    json = await res.json().catch(() => ({}));
+  } catch (err) {
+    return retryableError(0, "network_error", String(err), null);
+  }
+  if (!res.ok) return classifyHttpError(res.status, json);
+  return { ok: true, status: res.status, response: normalizeOpenAILike(json) };
+}
+async function executeDeepSeek(request, opts) {
+  const apiKey = resolveProviderKey("deepseek", { apiKeys: opts.apiKeys });
+  if (!apiKey) {
+    return terminalError(401, "auth", "DEEPSEEK_API_KEY missing");
+  }
+  const { provider: _provider, ...body } = request;
+  const fetchFn = opts.fetchImpl ?? fetch;
+  let res;
+  let json;
+  try {
+    res = await fetchFn(DEEPSEEK_URL, {
+      method: "POST",
+      headers: { authorization: `Bearer ${apiKey}`, "content-type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    json = await res.json().catch(() => ({}));
+  } catch (err) {
+    return retryableError(0, "network_error", String(err), null);
+  }
+  if (!res.ok) return classifyHttpError(res.status, json);
+  return { ok: true, status: res.status, response: normalizeOpenAILike(json) };
+}
+function normalizeOpenAILike(raw) {
+  const r = raw;
+  const choice = r.choices?.[0];
+  const text = choice?.message?.content ?? "";
+  const toolCalls = (choice?.message?.tool_calls ?? []).filter((tc) => tc.function?.name).map((tc, i) => ({
+    id: tc.id ?? `tc-${i}`,
+    name: tc.function.name,
+    args: tryParseJson(tc.function?.arguments) ?? {}
+  }));
+  const u = r.usage ?? {};
+  const tokens = {
+    input: u.prompt_tokens ?? 0,
+    output: u.completion_tokens ?? 0,
+    total: u.total_tokens ?? (u.prompt_tokens ?? 0) + (u.completion_tokens ?? 0),
+    cached: u.prompt_tokens_details?.cached_tokens
+  };
+  return { text, structuredOutput: null, toolCalls, tokens, finishReason: choice?.finish_reason, raw };
+}
+function applyOverrides(request, overrides) {
+  if (!overrides) return request;
+  const layer = overrides[request.provider];
+  if (!layer) return request;
+  return { ...request, ...layer };
+}
+function classifyHttpError(status, body) {
+  const message = extractErrorMessage(body) ?? `HTTP ${status}`;
+  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 >= 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/call.ts
+async function call(ir, opts = {}) {
+  const initial = compileAndRegister(ir, opts);
+  const start = Date.now();
+  const attempts = [];
+  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"
+      );
+    }
+  }
+  let activeCompile = initial;
+  let lastErr;
+  for (let i = 0; i < targetsToTry.length; i++) {
+    const targetModel = targetsToTry[i];
+    if (targetModel !== initial.target) {
+      try {
+        activeCompile = compileAndRegister(
+          {
+            ...ir,
+            models: ir.models.includes(targetModel) ? ir.models : [targetModel, ...ir.models],
+            constraints: { ...ir.constraints ?? {}, forceModel: targetModel }
+          },
+          opts
+        );
+      } catch (err) {
+        attempts.push({
+          model: targetModel,
+          status: "terminal",
+          errorCode: "compile_error",
+          message: err instanceof Error ? err.message : String(err)
+        });
+        continue;
+      }
+    }
+    const exec = await execute(activeCompile.request, {
+      apiKeys: opts.apiKeys,
+      fetchImpl: opts.fetchImpl,
+      providerOverrides: opts.providerOverrides
+    });
+    const validated = exec.ok ? validateStructuredContract(exec, ir) : exec;
+    if (validated.ok) {
+      attempts.push({ model: targetModel, status: "success" });
+      const latencyMs2 = Date.now() - start;
+      await record({
+        handle: initial.handle,
+        tokensIn: validated.response.tokens.input,
+        tokensOut: validated.response.tokens.output,
+        latencyMs: latencyMs2,
+        success: true,
+        emptyResponse: validated.response.tokens.output === 0,
+        toolsCalled: validated.response.toolCalls.map((tc) => tc.name),
+        actualModel: targetModel !== initial.target ? targetModel : void 0,
+        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
+      });
+      const fellOver = targetModel !== initial.target;
+      return {
+        handle: initial.handle,
+        actualModel: targetModel,
+        requestedModel: initial.target,
+        provider: activeCompile.provider,
+        response: validated.response,
+        latencyMs: latencyMs2,
+        mutationsApplied: activeCompile.mutationsApplied,
+        attempts,
+        servedBy: targetModel,
+        fellOverFrom: fellOver ? initial.target : void 0,
+        fallbackReason: fellOver ? normalizeFallbackReason(attempts) : void 0,
+        unreachableFiltered
+      };
+    }
+    attempts.push({
+      model: targetModel,
+      status: validated.errorType,
+      errorCode: validated.errorCode,
+      message: validated.message
+    });
+    lastErr = validated;
+    if (validated.errorType === "terminal" || opts.noFallback) {
+      break;
+    }
+  }
+  const latencyMs = Date.now() - start;
+  await record({
+    handle: initial.handle,
+    tokensIn: 0,
+    tokensOut: 0,
+    latencyMs,
+    success: false,
+    errorType: lastErr?.errorCode,
+    promptPreview: extractPromptPreview(ir)
+  });
+  const filteredNote = unreachableFiltered && unreachableFiltered.length > 0 ? ` (also auto-filtered: [${unreachableFiltered.join(", ")}] \u2014 no API key)` : "";
+  throw new CallError(
+    `call(): all attempts failed${lastErr ? ` \u2014 ${lastErr.errorCode}: ${lastErr.message}` : ""}${filteredNote}`,
+    attempts,
+    lastErr?.status,
+    lastErr?.errorCode
+  );
+}
+function compileAndRegister(ir, opts) {
+  const result = compile(ir, {
+    policy: opts.policy,
+    toolRelevanceThreshold: opts.toolRelevanceThreshold,
+    compressHistoryAfter: opts.compressHistoryAfter
+  });
+  registerCompile(ir.appId, ir.intent.archetype, ir, result);
+  return result;
+}
+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(exec.response.text);
+    return { ok: true, response: { ...exec.response, structuredOutput: parsed } };
+  } catch (err) {
+    return {
+      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";
+  return "provider_error";
+}
+
+// src/oracle.ts
+var DEFAULT_DIMENSIONS = ["correctness", "completeness", "conciseness", "format"];
+var judgeCallTimes = [];
+function buildLLMJudge(opts) {
+  const dimensions = opts.dimensions ?? DEFAULT_DIMENSIONS;
+  const rateLimit = opts.rateLimitPerMin;
+  return async (ctx) => {
+    if (rateLimit) {
+      const now = Date.now();
+      judgeCallTimes = judgeCallTimes.filter((t) => now - t < 6e4);
+      if (judgeCallTimes.length >= rateLimit) {
+        return { score: 0.5, rationale: "judge rate-limited; default neutral" };
+      }
+      judgeCallTimes.push(now);
+    }
+    const prompt = buildJudgePrompt(ctx, dimensions);
+    let raw;
+    try {
+      raw = await opts.judgeCall(prompt);
+    } catch (err) {
+      return {
+        score: 0.5,
+        rationale: `judge error: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+    return parseJudgeOutput(raw, dimensions);
+  };
+}
+function buildJudgePrompt(ctx, dimensions) {
+  return `You are an oracle scoring an AI response. Output ONLY a JSON object, no other text.
+
+Intent archetype: ${ctx.archetype}
+App: ${ctx.appId} / ${ctx.intentName}
+Tools were involved: ${ctx.hadTools}
+
+User asked:
+${ctx.userTurn ?? "<not provided>"}
+
+Response:
+${ctx.response.slice(0, 4e3)}
+
+Score from 0.0 to 1.0 on each dimension. 1.0 = perfect, 0.5 = mediocre, 0.0 = wrong.
+Be honest \u2014 most responses are 0.5-0.8. Reserve 0.9+ for genuinely excellent.
+
+Respond with this JSON shape:
+{
+  "score": <overall 0..1>,
+  "dimensions": { ${dimensions.map((d) => `"${d}": <0..1>`).join(", ")} },
+  "rationale": "<one sentence>"
+}`;
+}
+function parseJudgeOutput(raw, dimensions) {
+  const cleaned = raw.replace(/^```(?:json)?\s*/i, "").replace(/\s*```\s*$/, "").trim();
+  let parsed;
+  try {
+    parsed = JSON.parse(cleaned);
+  } catch {
+    const match = cleaned.match(/\{[\s\S]*\}/);
+    if (match) {
+      try {
+        parsed = JSON.parse(match[0]);
+      } catch {
+        return { score: 0.5, rationale: "judge output unparseable" };
+      }
+    } else {
+      return { score: 0.5, rationale: "judge output unparseable" };
+    }
+  }
+  if (!parsed || typeof parsed !== "object") {
+    return { score: 0.5, rationale: "judge output not an object" };
+  }
+  const obj = parsed;
+  const score = clamp(typeof obj.score === "number" ? obj.score : 0.5);
+  const dims = {};
+  if (obj.dimensions && typeof obj.dimensions === "object") {
+    for (const d of dimensions) {
+      const v = obj.dimensions[d];
+      dims[d] = clamp(typeof v === "number" ? v : 0.5);
+    }
+  }
+  const rationale = typeof obj.rationale === "string" ? obj.rationale : void 0;
+  return { score, dimensions: Object.keys(dims).length > 0 ? dims : void 0, rationale };
+}
+function clamp(n) {
+  if (!Number.isFinite(n)) return 0.5;
+  return Math.max(0, Math.min(1, n));
+}
+
+// src/fallback.ts
+var STARTER_CHAINS = {
+  // Reasoning floor — never degrade. Walk UP on 429 to Opus → cross-provider.
+  critique: [
+    "claude-opus-4-7",
+    "claude-sonnet-4-6",
+    "gemini-2.5-pro"
+  ],
+  // Reasoning matters — Sonnet primary; walk UP to Opus on 429 (rare exception
+  // to "always cheaper"); cross-provider via Pro; DeepSeek Pro as tier 3 floor.
+  plan: [
+    "claude-sonnet-4-6",
+    "claude-opus-4-7",
+    "gemini-2.5-pro",
+    "deepseek-v4-pro"
+  ],
+  // Quality + cost match. Walk Sonnet → Haiku same-provider, Pro cross,
+  // Flash floor for the open-posture chain.
+  generate: [
+    "claude-sonnet-4-6",
+    "claude-haiku-4-5",
+    "gemini-2.5-pro",
+    "gemini-2.5-flash"
+  ],
+  ask: [
+    "claude-sonnet-4-6",
+    "claude-haiku-4-5",
+    "gemini-2.5-pro",
+    "gemini-2.5-flash"
+  ],
+  // Structured-output archetype — Flash skipped (alpha.8 MAX_TOKENS cliff),
+  // DeepSeek skipped (no brain evidence). Floor at Haiku.
+  extract: [
+    "claude-sonnet-4-6",
+    "claude-haiku-4-5",
+    "gemini-2.5-pro"
+  ],
+  // Forgiving archetype — Sonnet primary but Flash safely floors it.
+  transform: [
+    "claude-sonnet-4-6",
+    "claude-haiku-4-5",
+    "gemini-2.5-pro",
+    "gemini-2.5-flash"
+  ],
+  // Parallel-tool throughput champion (Flash, L-040). Tier 1 cross-provider
+  // Pro; tier 2 Sonnet (quality safety net for blocked-Flash case); tier 3
+  // Haiku (reduced tool budget — cliff at 16 fires).
+  hunt: [
+    "gemini-2.5-flash",
+    "gemini-2.5-pro",
+    "claude-sonnet-4-6",
+    "claude-haiku-4-5"
+  ],
+  // Cost-sensitive + tolerant. DeepSeek brain-evidence tier 1; Haiku tier 2
+  // for quality safety; Flash-Lite emergency floor (onboarded s22).
+  summarize: [
+    "gemini-2.5-flash",
+    "deepseek-v4-flash",
+    "claude-haiku-4-5",
+    "gemini-2.5-flash-lite"
+  ],
+  // Brain-validated DeepSeek tier 1 (169 rows, 0% empty); Haiku tier 2;
+  // Flash-Lite floor for repeat-prompt workloads (cache-discount 10×).
+  classify: [
+    "gemini-2.5-flash",
+    "deepseek-v4-flash",
+    "claude-haiku-4-5",
+    "gemini-2.5-flash-lite"
+  ]
+};
+function getDefaultFallbackChain(opts) {
+  const { archetype, primary, maxDepth = 3, policy, reachability } = opts;
+  if (maxDepth < 1) {
+    throw new Error(
+      `getDefaultFallbackChain: maxDepth must be >= 1, got ${maxDepth}`
+    );
+  }
+  const starter = STARTER_CHAINS[archetype];
+  if (!starter) {
+    throw new Error(
+      `getDefaultFallbackChain: unknown archetype "${archetype}". Known: ${Object.keys(STARTER_CHAINS).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;
+}
+
+// src/index.ts
+function compile2(ir, opts) {
+  const result = compile(ir, opts);
+  registerCompile(ir.appId, ir.intent.archetype, ir, result);
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ALIASES,
+  ALL_ARCHETYPES,
+  CallError,
+  DIALECT_VERSION,
+  INTENT_ARCHETYPES,
+  PROVIDER_ENV_KEYS,
+  allProfiles,
+  bucketContext,
+  bucketHistory,
+  bucketToolCount,
+  buildLLMJudge,
+  call,
+  clearBrain,
+  compile,
+  configureBrain,
+  countTokens,
+  execute,
+  getAllStarterChains,
+  getDefaultFallbackChain,
+  getProfile,
+  getReachabilityDiagnostic,
+  getStarterChain,
+  hashShape,
+  isArchetype,
+  isModelReachable,
+  isProviderReachable,
+  learningKey,
+  profilesByProvider,
+  record,
+  resetTokenizer,
+  resolveProviderKey,
+  runAdvisor,
+  setTokenizer,
+  tryGetProfile
+});