@warmdrift/kgauto-compiler 2.0.0-alpha.7 → 2.0.0-alpha.71

package/dist/chunk-SBFSYCQG.mjs

@@ -0,0 +1,719 @@
+import {
+  tryGetProfile
+} from "./chunk-4UO4CCSP.mjs";
+
+// src/brain-query.ts
+var FRESH_SNAPSHOT = {
+  data: null,
+  expiresAt: 0,
+  refreshing: false,
+  warned: false
+};
+var snapshot = { ...FRESH_SNAPSHOT };
+var runtime;
+function configureBrainQuery(rt) {
+  runtime = rt;
+  snapshot = { ...FRESH_SNAPSHOT };
+}
+function createBrainQueryCache(opts) {
+  return () => {
+    const rt = runtime;
+    if (!rt || !rt.enabledTables.has(opts.table)) {
+      return opts.bundledFallback();
+    }
+    const now = Date.now();
+    const stale = snapshot.expiresAt <= now;
+    if (stale && !snapshot.refreshing) {
+      snapshot.refreshing = true;
+      void asyncRefresh(rt);
+    }
+    if (snapshot.data) {
+      const rows = snapshot.data[opts.table];
+      if (Array.isArray(rows) && rows.length > 0) {
+        try {
+          return opts.mapRows(rows);
+        } catch {
+          return opts.bundledFallback();
+        }
+      }
+    }
+    return opts.bundledFallback();
+  };
+}
+var pendingRefresh;
+async function asyncRefresh(rt) {
+  const promise = doRefresh(rt);
+  pendingRefresh = promise;
+  try {
+    await promise;
+  } finally {
+    if (pendingRefresh === promise) pendingRefresh = void 0;
+  }
+}
+var DEFAULT_CONFIG_URL = "https://kgauto-dashboard.vercel.app/api/kgauto-v2/config";
+async function doRefresh(rt) {
+  const url = rt.configEndpoint ?? DEFAULT_CONFIG_URL;
+  try {
+    const res = await rt.fetchImpl(url, { method: "GET" });
+    if (!res.ok) {
+      throw new Error(`brain-query ${res.status}: ${res.statusText}`);
+    }
+    const body = await res.json();
+    if (runtime !== rt) return;
+    snapshot = {
+      data: body,
+      expiresAt: Date.now() + rt.ttlMs,
+      refreshing: false,
+      warned: snapshot.warned
+    };
+  } catch (err) {
+    if (runtime !== rt) return;
+    snapshot.refreshing = false;
+    snapshot.expiresAt = Date.now() + rt.ttlMs;
+    if (!snapshot.warned) {
+      snapshot.warned = true;
+      (rt.onError ?? defaultOnError)(err);
+    }
+  }
+}
+function defaultOnError(err) {
+  console.warn("[kgauto] brain-query failed (using bundled fallback):", err);
+}
+function isBrainQueryActiveFor(table) {
+  return runtime !== void 0 && runtime.enabledTables.has(table);
+}
+async function getPerAxisMetrics(opts) {
+  const fetchFn = opts.fetch ?? fetch;
+  const endpoint = opts.endpoint ?? runtime?.endpoint;
+  if (!endpoint) return null;
+  const windowDays = opts.windowDays ?? 30;
+  const body = {
+    p_app_id: opts.appId,
+    p_archetype: opts.archetype,
+    p_model: opts.model,
+    p_window_days: windowDays,
+    p_quality_floor: opts.qualityFloor ?? null
+  };
+  const headers = {
+    Accept: "application/json",
+    "Content-Type": "application/json",
+    ...opts.apiKey ? { Authorization: `Bearer ${opts.apiKey}` } : {}
+  };
+  try {
+    const res = await fetchFn(`${endpoint}/rpc/get_per_axis_metrics`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) return null;
+    const raw = await res.json();
+    return mapPerAxisMetrics(raw, opts.appId, opts.archetype, opts.model, windowDays);
+  } catch {
+    return null;
+  }
+}
+function mapPerAxisMetrics(raw, fallbackAppId, fallbackArchetype, fallbackModel, fallbackWindowDays) {
+  if (raw === null || raw === void 0) return null;
+  if (typeof raw !== "object") return null;
+  const r = raw;
+  if (Array.isArray(raw)) {
+    if (raw.length === 0) return null;
+    return mapPerAxisMetrics(raw[0], fallbackAppId, fallbackArchetype, fallbackModel, fallbackWindowDays);
+  }
+  const num = (v) => {
+    if (v === null || v === void 0) return null;
+    if (typeof v === "number") return Number.isFinite(v) ? v : null;
+    if (typeof v === "string") {
+      const n = Number(v);
+      return Number.isFinite(n) ? n : null;
+    }
+    return null;
+  };
+  const int = (v) => {
+    const n = num(v);
+    return n === null ? 0 : Math.trunc(n);
+  };
+  const bool = (v) => {
+    if (v === null || v === void 0) return null;
+    if (typeof v === "boolean") return v;
+    return null;
+  };
+  const str = (v, fallback) => typeof v === "string" ? v : fallback;
+  const cost = r.cost_efficiency ?? {};
+  const time = r.time_efficiency ?? {};
+  const rel = r.reliability ?? {};
+  return {
+    appId: str(r.app_id, fallbackAppId),
+    archetype: str(r.archetype, fallbackArchetype),
+    model: str(r.model, fallbackModel),
+    windowDays: num(r.window_days) ?? fallbackWindowDays,
+    nRows: int(r.n_rows),
+    nRowsClean: int(r.n_rows_clean),
+    nQualityOutcomes: int(r.n_quality_outcomes),
+    magicRate: num(r.magic_rate),
+    qualityFloorMet: bool(r.quality_floor_met),
+    costEfficiency: {
+      avgCostUsd: num(cost.avg_cost_usd),
+      avgCostUsdClean: num(cost.avg_cost_usd_clean),
+      avgInputTokens: num(cost.avg_input_tokens),
+      avgOutputTokens: num(cost.avg_output_tokens),
+      inputTokenRatio: num(cost.input_token_ratio)
+    },
+    timeEfficiency: {
+      avgLatencyMs: num(time.avg_latency_ms),
+      avgTtftMs: num(time.avg_ttft_ms)
+    },
+    reliability: {
+      successRate: num(rel.success_rate),
+      successRateClean: num(rel.success_rate_clean),
+      emptyRate: num(rel.empty_rate),
+      emptyRateClean: num(rel.empty_rate_clean)
+    },
+    evidenceFreshnessDays: num(r.evidence_freshness_days)
+  };
+}
+
+// src/compatibility.ts
+var ARCHETYPE_FLOOR_DEFAULT = 6;
+var ABSOLUTE_FLOOR = 4;
+function rawArchetypePerf(profile, archetype) {
+  return profile.archetypePerf?.[archetype] ?? 5;
+}
+function hasSequentialToolCliffForHunt(profile) {
+  if (profile.parallelToolCalls !== false) return false;
+  const huntScore = profile.archetypePerf?.hunt ?? 5;
+  return huntScore < ARCHETYPE_FLOOR_DEFAULT;
+}
+function adapterForCliff(profile, archetype) {
+  if (archetype === "hunt" && hasSequentialToolCliffForHunt(profile)) {
+    const otherScores = [];
+    if (profile.archetypePerf) {
+      for (const [k, v] of Object.entries(profile.archetypePerf)) {
+        if (k === "hunt") continue;
+        if (typeof v === "number") otherScores.push(v);
+      }
+    }
+    const sorted = [...otherScores].sort((a, b) => a - b);
+    const median = sorted.length === 0 ? ARCHETYPE_FLOOR_DEFAULT + 1 : sorted[Math.floor(sorted.length / 2)] ?? ARCHETYPE_FLOOR_DEFAULT + 1;
+    const estimated = Math.max(ARCHETYPE_FLOOR_DEFAULT + 1, median);
+    return {
+      adapter: {
+        parameter: "toolOrchestration",
+        value: "sequential",
+        consequence: "Tool calls run one at a time instead of in parallel \u2014 slower per step but reliable for this model."
+      },
+      estimatedScoreWithAdapter: estimated
+    };
+  }
+  return void 0;
+}
+function archetypeDescriptor(archetype) {
+  return archetype;
+}
+function getModelCompatibility(modelId, intent) {
+  const profile = tryGetProfile(modelId);
+  if (!profile) {
+    return {
+      status: "reject",
+      reason: `Model "${modelId}" is not registered with kgauto \u2014 no compatibility data available.`,
+      archetypePerf: 0
+    };
+  }
+  const { archetype, toolOrchestration } = intent;
+  const rawScore = rawArchetypePerf(profile, archetype);
+  const descriptor = archetypeDescriptor(archetype);
+  const adapterMatch = adapterForCliff(profile, archetype);
+  if (toolOrchestration === "sequential" && adapterMatch && adapterMatch.adapter.parameter === "toolOrchestration" && adapterMatch.adapter.value === "sequential") {
+    return {
+      status: "compatible",
+      reason: `Suited for ${descriptor} with sequential tool calls.`,
+      archetypePerf: rawScore
+    };
+  }
+  if (rawScore >= ARCHETYPE_FLOOR_DEFAULT) {
+    return {
+      status: "compatible",
+      reason: `Suited for ${descriptor}.`,
+      archetypePerf: rawScore
+    };
+  }
+  if (adapterMatch) {
+    return {
+      status: "requires-adapter",
+      reason: `Best with ${adapterMatch.adapter.value} ${adapterMatch.adapter.parameter === "toolOrchestration" ? "tool calls" : adapterMatch.adapter.parameter} for ${descriptor} \u2014 slower but works.`,
+      archetypePerf: rawScore,
+      archetypePerfWithAdapter: adapterMatch.estimatedScoreWithAdapter,
+      adapter: adapterMatch.adapter
+    };
+  }
+  return {
+    status: "reject",
+    reason: `Not suited for ${descriptor} \u2014 would underperform significantly.`,
+    archetypePerf: rawScore
+  };
+}
+
+// src/env.ts
+var SUPPORTED_PROVIDERS = Object.freeze([
+  "anthropic",
+  "google",
+  "openai",
+  "deepseek",
+  "zai",
+  "moonshot"
+]);
+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"]),
+  // alpha.65 — Z.ai (GLM family). ZAI_API_KEY is the canonical name; the
+  // Z_AI_API_KEY variant covers the underscore convention some tooling uses
+  // for the brand's "Z.ai" spelling.
+  zai: Object.freeze(["ZAI_API_KEY", "Z_AI_API_KEY"]),
+  // alpha.65 — Moonshot AI (Kimi family). MOONSHOT_API_KEY is canonical
+  // (api.moonshot.ai); KIMI_API_KEY covers the platform.kimi.ai rebrand
+  // surface so consumers keyed under either name resolve.
+  moonshot: Object.freeze(["MOONSHOT_API_KEY", "KIMI_API_KEY"])
+});
+function defaultEnv() {
+  return typeof process !== "undefined" && process.env ? process.env : {};
+}
+function readKeyValue(raw) {
+  if (raw === void 0) return void 0;
+  const trimmed = raw.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function resolveProviderKey(provider, opts = {}) {
+  if (!isSupportedProvider(provider)) return void 0;
+  const explicit = readKeyValue(opts.apiKeys?.[provider]);
+  if (explicit) return explicit;
+  const env = opts.envSource ?? defaultEnv();
+  for (const name of PROVIDER_ENV_KEYS[provider]) {
+    const v = readKeyValue(env[name]);
+    if (v) return v;
+  }
+  return void 0;
+}
+function isProviderReachable(provider, opts = {}) {
+  return resolveProviderKey(provider, opts) !== void 0;
+}
+function isModelReachable(modelId, opts = {}) {
+  const profile = tryGetProfile(modelId);
+  if (!profile) return false;
+  return isProviderReachable(profile.provider, opts);
+}
+function getReachabilityDiagnostic(opts = {}) {
+  const env = opts.envSource ?? defaultEnv();
+  const out = {};
+  for (const provider of SUPPORTED_PROVIDERS) {
+    if (readKeyValue(opts.apiKeys?.[provider])) {
+      out[provider] = { reachable: true, via: "apiKeys" };
+      continue;
+    }
+    const envKeyFound = PROVIDER_ENV_KEYS[provider].find((name) => readKeyValue(env[name]));
+    out[provider] = envKeyFound ? { reachable: true, via: "env", envKeyFound } : { reachable: false, via: null };
+  }
+  return out;
+}
+function readBrainReadEnv(envSource = defaultEnv()) {
+  const endpoint = readKeyValue(envSource.KGAUTO_V2_BRAIN_SUPABASE_URL) ?? readKeyValue(envSource.KGAUTO_V2_BRAIN_URL);
+  const jwt = readKeyValue(envSource.KGAUTO_V2_BRAIN_JWT) ?? readKeyValue(envSource.GLASSBOX_BRAIN_JWT);
+  const anonKey = readKeyValue(envSource.KGAUTO_V2_BRAIN_ANON_KEY);
+  const missingEnv = [];
+  if (!endpoint) missingEnv.push("KGAUTO_V2_BRAIN_SUPABASE_URL");
+  if (!jwt) missingEnv.push("KGAUTO_V2_BRAIN_JWT");
+  if (!anonKey) missingEnv.push("KGAUTO_V2_BRAIN_ANON_KEY");
+  return { endpoint, jwt, anonKey, missingEnv };
+}
+function isSameModelRetryEnabledFromEnv(envSource = defaultEnv()) {
+  const raw = (envSource.KGAUTO_SAME_MODEL_RETRY ?? "").trim().toLowerCase();
+  return raw === "1" || raw === "true";
+}
+
+// src/fallback.ts
+var STARTER_CHAINS_GROUNDED = {
+  // Reasoning floor — never degrade. Walk UP on 429 to Opus → cross-provider.
+  critique: [
+    { id: "claude-opus-4-7", grounding: "judgment", reason: "Highest reasoning bar, no degradation tier \u2014 engineer pick, awaiting measured backing" },
+    { id: "claude-sonnet-4-6", grounding: "judgment", reason: "Same-provider walk-down from Opus on 429" },
+    { id: "gemini-2.5-pro", grounding: "judgment", reason: "Cross-provider anchor in similar quality bracket" },
+    { id: "gpt-5.5", grounding: "judgment", reason: "alpha.16: third-provider frontier-tier floor (archetypePerf=9)" }
+  ],
+  // alpha.62 (eval spine) — pairwise output comparison. Same reasoning-floor
+  // posture as critique (a verdict from a weak judge is worse than no
+  // verdict); tier 0 anchored on the CURRENT opus (4-8, s64 roster). Strict
+  // JSON output, so every tier declares native structured output.
+  judge: [
+    { id: "claude-opus-4-8", grounding: "judgment", reason: "Highest reasoning bar for pairwise verdicts \u2014 current opus (s64 roster)" },
+    { id: "claude-sonnet-4-6", grounding: "judgment", reason: "Same-provider walk-down on 429" },
+    { id: "gemini-2.5-pro", grounding: "judgment", reason: "Cross-provider anchor in similar quality bracket" },
+    { id: "gpt-5.5", grounding: "judgment", reason: "Third-provider frontier-tier floor" }
+  ],
+  // Reasoning matters — Sonnet primary; walk UP to Opus on 429.
+  plan: [
+    { id: "claude-sonnet-4-6", grounding: "judgment", reason: "Reasoning + cost balance \u2014 engineer pick" },
+    { id: "claude-opus-4-7", grounding: "judgment", reason: 'Same-provider walk-UP on 429 (rare exception to "always cheaper")' },
+    { id: "gemini-2.5-pro", grounding: "judgment", reason: "Cross-provider anchor" },
+    { id: "deepseek-v4-pro", grounding: "judgment", reason: "Tier 3 cost floor \u2014 no brain evidence yet" },
+    { id: "gpt-5.4", grounding: "judgment", reason: "alpha.33: third-provider tail (archetypePerf=7) \u2014 closes openai-in-default-fallback-chains" }
+  ],
+  // Quality + cost match.
+  generate: [
+    { id: "claude-sonnet-4-6", grounding: "judgment", reason: "Quality + cost match \u2014 engineer pick" },
+    { id: "claude-haiku-4-5", grounding: "judgment", reason: "Same-provider step-down" },
+    { id: "gemini-2.5-pro", grounding: "judgment", reason: "Cross-provider anchor" },
+    { id: "gpt-5.4-mini", grounding: "judgment", reason: "alpha.16: third-provider tail (archetypePerf=7) \u2014 closes mono-Anthropic gap" }
+  ],
+  // ask::sonnet — STARTER_CHAINS calls this "Quality + cost match" but
+  // tt-intel s78 prod data showed 27% empty rate. Labeled 'judgment' until
+  // evidence either validates or refutes the placement.
+  ask: [
+    { id: "claude-sonnet-4-6", grounding: "judgment", reason: "Quality + cost match \u2014 engineer pick. NOTE: tt-intel s78 prod showed 27% empty rate; placement awaits measurement validation" },
+    { id: "claude-haiku-4-5", grounding: "judgment", reason: "Same-provider step-down" },
+    { id: "gemini-2.5-pro", grounding: "judgment", reason: "Cross-provider anchor" },
+    { id: "gpt-5.4-mini", grounding: "judgment", reason: "alpha.16: third-provider tail (archetypePerf=7)" }
+  ],
+  // Structured-output archetype — Flash skipped (alpha.8 MAX_TOKENS cliff,
+  // capability-fact); DeepSeek skipped (no brain evidence).
+  extract: [
+    { id: "claude-sonnet-4-6", grounding: "judgment", reason: "Reliable structured-output anchor \u2014 engineer pick" },
+    { id: "claude-haiku-4-5", grounding: "judgment", reason: "Same-provider step-down with native structured output" },
+    { id: "gemini-2.5-pro", grounding: "judgment", reason: "Cross-provider anchor with structured-output support" },
+    { id: "gpt-5.4", grounding: "capability-fact", reason: "alpha.16: third-provider floor \u2014 native structured-output capability (archetypePerf=8)" }
+  ],
+  // Forgiving archetype — Sonnet primary but Flash safely floors it.
+  transform: [
+    { id: "claude-sonnet-4-6", grounding: "judgment", reason: "Quality anchor \u2014 engineer pick" },
+    { id: "claude-haiku-4-5", grounding: "judgment", reason: "Same-provider step-down" },
+    { id: "gemini-2.5-pro", grounding: "judgment", reason: "Cross-provider anchor" },
+    { id: "gemini-2.5-flash", grounding: "judgment", reason: "Cost floor \u2014 forgiving archetype tolerates Flash" },
+    { id: "gpt-5.4-mini", grounding: "judgment", reason: "alpha.33: third-provider tail (archetypePerf=7) \u2014 closes openai-in-default-fallback-chains" }
+  ],
+  // Parallel-tool throughput champion — Flash leads on the L-040 cliff
+  // (capability-fact: Flash 15-75 parallel calls/step vs DeepSeek 7-8).
+  hunt: [
+    { id: "gemini-2.5-flash", grounding: "capability-fact", reason: "L-040 parallel-tool throughput champion (15-75 calls/step)" },
+    { id: "gemini-2.5-pro", grounding: "capability-fact", reason: "Cross-provider tier 1 with strong parallel-tool support" },
+    { id: "claude-sonnet-4-6", grounding: "judgment", reason: "Quality safety net for blocked-Flash case" },
+    { id: "claude-haiku-4-5", grounding: "judgment", reason: "Reduced tool budget \u2014 cliff at 16 fires" },
+    { id: "gpt-5.4-mini", grounding: "judgment", reason: "alpha.33: third-provider tail \u2014 OpenAI parallel-tool capable archetype" }
+  ],
+  // Cost-sensitive + tolerant. DeepSeek brain-evidence tier 1.
+  summarize: [
+    { id: "gemini-2.5-flash", grounding: "judgment", reason: "Cost-sensitive primary \u2014 engineer pick" },
+    { id: "deepseek-v4-flash", grounding: "measured", reason: "Brain-validated tier 1 for cost-sensitive summarize workloads", n: 169 },
+    { id: "claude-haiku-4-5", grounding: "judgment", reason: "Quality safety net" },
+    { id: "gemini-2.5-flash-lite", grounding: "judgment", reason: "Emergency floor \u2014 onboarded s22, no brain evidence yet" },
+    { id: "gpt-5.4-nano", grounding: "judgment", reason: "alpha.33: third-provider tail (archetypePerf=6) \u2014 cheapest OpenAI, matches summarize cost-band" }
+  ],
+  // Brain-validated DeepSeek tier 1 (169 rows, 0% empty rate).
+  classify: [
+    { id: "gemini-2.5-flash", grounding: "judgment", reason: "Cost-sensitive primary \u2014 engineer pick" },
+    { id: "deepseek-v4-flash", grounding: "measured", reason: "Brain-validated tier 1 (169 rows, 0% empty rate)", n: 169 },
+    { id: "claude-haiku-4-5", grounding: "judgment", reason: "Quality safety net" },
+    { id: "gemini-2.5-flash-lite", grounding: "judgment", reason: "Cache-discount 10\xD7 floor for repeat-prompt workloads" },
+    { id: "gpt-5.4-nano", grounding: "judgment", reason: "alpha.33: third-provider tail (archetypePerf=6) \u2014 cheapest OpenAI for classify" }
+  ]
+};
+var STARTER_CHAINS = (() => {
+  const out = {};
+  for (const [archetype, entries] of Object.entries(STARTER_CHAINS_GROUNDED)) {
+    out[archetype] = entries.map((e) => e.id);
+  }
+  return out;
+})();
+var STARTER_CHAINS_BY_MODE_GROUNDED = {
+  hunt: {
+    sequential: [
+      {
+        id: "deepseek-v4-pro",
+        grounding: "judgment",
+        reason: "alpha.20 E3: cheap + good reasoning at single-step granularity; L-040 cliff silenced when sequential \u2014 hypothesis not yet measured"
+      },
+      {
+        id: "deepseek-v4-flash",
+        grounding: "judgment",
+        reason: "Cheapest viable; sibling-provider fallback"
+      },
+      {
+        id: "claude-sonnet-4-6",
+        grounding: "judgment",
+        reason: "Cross-provider safety net \u2014 Sonnet handles sequential agentic loops cleanly"
+      },
+      {
+        id: "gemini-2.5-pro",
+        grounding: "judgment",
+        reason: "Third-provider tail when no DeepSeek key reachable"
+      }
+    ]
+  }
+};
+var STARTER_CHAINS_BY_MODE = (() => {
+  const out = {};
+  for (const [archetype, modes] of Object.entries(STARTER_CHAINS_BY_MODE_GROUNDED)) {
+    if (modes?.sequential) {
+      out[archetype] = {
+        sequential: modes.sequential.map((e) => e.id)
+      };
+    }
+  }
+  return out;
+})();
+function resolveStarterForMode(archetype, toolOrchestration, allChains) {
+  if (toolOrchestration === "sequential") {
+    const overlay = STARTER_CHAINS_BY_MODE[archetype]?.sequential;
+    if (overlay) return [...overlay];
+  }
+  return allChains[archetype];
+}
+function getDefaultFallbackChain(opts) {
+  const { archetype, primary, maxDepth = 4, policy, reachability, toolOrchestration } = opts;
+  if (maxDepth < 1) {
+    throw new Error(
+      `getDefaultFallbackChain: maxDepth must be >= 1, got ${maxDepth}`
+    );
+  }
+  const allChains = loadChainsFromBrain();
+  const starter = resolveStarterForMode(archetype, toolOrchestration, allChains);
+  if (!starter) {
+    throw new Error(
+      `getDefaultFallbackChain: unknown archetype "${archetype}". Known: ${Object.keys(allChains).join(", ")}`
+    );
+  }
+  let chain;
+  if (primary) {
+    chain = [primary, ...starter.filter((id) => id !== primary)];
+  } else {
+    chain = [...starter];
+  }
+  if (policy?.blockedModels && policy.blockedModels.length > 0) {
+    const blocked = new Set(policy.blockedModels);
+    chain = chain.filter((id) => !blocked.has(id));
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const id of chain) {
+    if (!seen.has(id)) {
+      seen.add(id);
+      deduped.push(id);
+    }
+  }
+  let filtered = deduped;
+  if (reachability) {
+    filtered = deduped.filter((id) => isModelReachable(id, reachability));
+  }
+  return filtered.slice(0, maxDepth);
+}
+function getStarterChain(archetype) {
+  const chain = STARTER_CHAINS[archetype];
+  if (!chain) {
+    throw new Error(
+      `getStarterChain: unknown archetype "${archetype}"`
+    );
+  }
+  return [...chain];
+}
+function getAllStarterChains() {
+  const out = {};
+  for (const [archetype, chain] of Object.entries(STARTER_CHAINS)) {
+    out[archetype] = [...chain];
+  }
+  return out;
+}
+function getSequentialStarterChain(archetype) {
+  const overlay = STARTER_CHAINS_BY_MODE[archetype]?.sequential;
+  return overlay ? [...overlay] : void 0;
+}
+function copyEntry(e) {
+  const out = { id: e.id, grounding: e.grounding };
+  if (e.reason !== void 0) out.reason = e.reason;
+  if (e.n !== void 0) out.n = e.n;
+  return out;
+}
+function lookupStaticEntry(id, archetype) {
+  const archetypeEntries = STARTER_CHAINS_GROUNDED[archetype];
+  if (archetypeEntries) {
+    const hit = archetypeEntries.find((e) => e.id === id);
+    if (hit) return hit;
+  }
+  const seqOverlay = STARTER_CHAINS_BY_MODE_GROUNDED[archetype]?.sequential;
+  if (seqOverlay) {
+    const hit = seqOverlay.find((e) => e.id === id);
+    if (hit) return hit;
+  }
+  return void 0;
+}
+function resolveGroundedChainForArchetype(archetype, toolOrchestration) {
+  if (toolOrchestration === "sequential") {
+    const overlay = STARTER_CHAINS_BY_MODE_GROUNDED[archetype]?.sequential;
+    if (overlay) return overlay.map(copyEntry);
+  }
+  const allChains = loadChainsFromBrain();
+  const ids = allChains[archetype];
+  if (!ids) return void 0;
+  return ids.map((id) => {
+    const known = lookupStaticEntry(id, archetype);
+    if (known) return copyEntry(known);
+    return { id, grounding: "judgment" };
+  });
+}
+function getDefaultFallbackChainWithGrounding(opts) {
+  const {
+    archetype,
+    primary,
+    maxDepth = 3,
+    policy,
+    reachability,
+    toolOrchestration
+  } = opts;
+  if (maxDepth < 1) {
+    throw new Error(
+      `getDefaultFallbackChainWithGrounding: maxDepth must be >= 1, got ${maxDepth}`
+    );
+  }
+  const starter = resolveGroundedChainForArchetype(archetype, toolOrchestration);
+  if (!starter) {
+    throw new Error(
+      `getDefaultFallbackChainWithGrounding: unknown archetype "${archetype}". Known: ${Object.keys(STARTER_CHAINS_GROUNDED).join(", ")}`
+    );
+  }
+  let chain;
+  if (primary) {
+    const primaryEntry = (() => {
+      const inStarter = starter.find((e) => e.id === primary);
+      if (inStarter) return copyEntry(inStarter);
+      const knownAnywhere = lookupStaticEntry(primary, archetype);
+      if (knownAnywhere) return { ...copyEntry(knownAnywhere), id: primary };
+      return { id: primary, grounding: "judgment" };
+    })();
+    chain = [primaryEntry, ...starter.filter((e) => e.id !== primary)];
+  } else {
+    chain = [...starter];
+  }
+  if (policy?.blockedModels && policy.blockedModels.length > 0) {
+    const blocked = new Set(policy.blockedModels);
+    chain = chain.filter((e) => !blocked.has(e.id));
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const e of chain) {
+    if (!seen.has(e.id)) {
+      seen.add(e.id);
+      deduped.push(e);
+    }
+  }
+  let filtered = deduped;
+  if (reachability) {
+    filtered = deduped.filter((e) => isModelReachable(e.id, reachability));
+  }
+  return filtered.slice(0, maxDepth);
+}
+function getStarterChainWithGrounding(archetype) {
+  const entries = STARTER_CHAINS_GROUNDED[archetype];
+  if (!entries) {
+    throw new Error(
+      `getStarterChainWithGrounding: unknown archetype "${archetype}"`
+    );
+  }
+  return entries.map(copyEntry);
+}
+function getAllStarterChainsWithGrounding() {
+  const out = {};
+  for (const [archetype, entries] of Object.entries(STARTER_CHAINS_GROUNDED)) {
+    out[archetype] = entries.map(copyEntry);
+  }
+  return out;
+}
+function getSequentialStarterChainWithGrounding(archetype) {
+  const overlay = STARTER_CHAINS_BY_MODE_GROUNDED[archetype]?.sequential;
+  return overlay ? overlay.map(copyEntry) : void 0;
+}
+function ensureCrossProviderTail(opts) {
+  const { chain, archetype, apiKeys, envSource } = opts;
+  if (chain.length < 1) return { chain };
+  const providers = /* @__PURE__ */ new Set();
+  for (const t of chain) {
+    const p = tryGetProfile(t);
+    if (p) providers.add(p.provider);
+  }
+  if (providers.size >= 2) return { chain };
+  const existingProvider = providers.values().next().value;
+  if (!existingProvider) return { chain };
+  const allChains = loadChainsFromBrain();
+  const fullChain = allChains[archetype];
+  if (!fullChain) return { chain };
+  for (const candidate of fullChain) {
+    if (chain.includes(candidate)) continue;
+    const cp = tryGetProfile(candidate);
+    if (!cp || cp.provider === existingProvider) continue;
+    if (!isModelReachable(candidate, { apiKeys, envSource })) continue;
+    return { chain: [...chain, candidate], appended: candidate };
+  }
+  return { chain };
+}
+
+// src/chains-brain.ts
+function isChainsRow(x) {
+  if (!x || typeof x !== "object") return false;
+  const r = x;
+  return typeof r.archetype === "string" && typeof r.tier === "number" && typeof r.model_id === "string";
+}
+function mapRowsToChains(rows) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (!isChainsRow(row)) continue;
+    const list = grouped.get(row.archetype) ?? [];
+    list.push(row);
+    grouped.set(row.archetype, list);
+  }
+  const out = {};
+  for (const [archetype, group] of grouped.entries()) {
+    group.sort((a, b) => a.tier - b.tier);
+    out[archetype] = group.map((r) => r.model_id);
+  }
+  const bundled = getAllStarterChains();
+  for (const archetype of Object.keys(bundled)) {
+    if (!out[archetype]) out[archetype] = bundled[archetype];
+  }
+  return out;
+}
+var loadChainsFromBrain = createBrainQueryCache({
+  table: "kgauto_chains",
+  mapRows: mapRowsToChains,
+  bundledFallback: getAllStarterChains
+});
+
+export {
+  configureBrainQuery,
+  createBrainQueryCache,
+  isBrainQueryActiveFor,
+  getPerAxisMetrics,
+  ARCHETYPE_FLOOR_DEFAULT,
+  ABSOLUTE_FLOOR,
+  getModelCompatibility,
+  PROVIDER_ENV_KEYS,
+  resolveProviderKey,
+  isProviderReachable,
+  isModelReachable,
+  getReachabilityDiagnostic,
+  readBrainReadEnv,
+  isSameModelRetryEnabledFromEnv,
+  loadChainsFromBrain,
+  getDefaultFallbackChain,
+  getStarterChain,
+  getAllStarterChains,
+  getSequentialStarterChain,
+  getDefaultFallbackChainWithGrounding,
+  getStarterChainWithGrounding,
+  getAllStarterChainsWithGrounding,
+  getSequentialStarterChainWithGrounding,
+  ensureCrossProviderTail
+};