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

package/dist/glassbox-routes/index.js

@@ -0,0 +1,3326 @@
+"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/glassbox-routes/index.ts
+var glassbox_routes_exports = {};
+__export(glassbox_routes_exports, {
+  COUNTERFACTUAL_MAX_RESULTS: () => COUNTERFACTUAL_MAX_RESULTS,
+  COUNTERFACTUAL_MIN_SAVINGS_RATIO: () => COUNTERFACTUAL_MIN_SAVINGS_RATIO,
+  computeCounterfactuals: () => computeCounterfactuals,
+  createGlassboxRoutes: () => createGlassboxRoutes,
+  rowToDetail: () => rowToDetail,
+  rowToSummary: () => rowToSummary
+});
+module.exports = __toCommonJS(glassbox_routes_exports);
+
+// src/glassbox-routes/auth.ts
+var JSON_HEADERS = { "Content-Type": "application/json" };
+function jsonError(status, code) {
+  return new Response(JSON.stringify({ error: code }), {
+    status,
+    headers: JSON_HEADERS
+  });
+}
+function tokensEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let mismatch = 0;
+  for (let i = 0; i < a.length; i++) {
+    mismatch |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  }
+  return mismatch === 0;
+}
+function checkAuth(req, config) {
+  const authHeader = req.headers.get("Authorization") ?? "";
+  const match = /^Bearer\s+(.+)$/i.exec(authHeader);
+  const provided = match?.[1]?.trim() ?? "";
+  if (!provided || !tokensEqual(provided, config.installToken)) {
+    return jsonError(401, "unauthorized");
+  }
+  const origin = req.headers.get("Origin") ?? "";
+  const xExtId = req.headers.get("X-Glassbox-Extension-Id") ?? "";
+  const expectedOrigin = `chrome-extension://${config.extensionId}`;
+  const originOk = origin === expectedOrigin;
+  const xExtOk = xExtId.length > 0 && tokensEqual(xExtId, config.extensionId);
+  if (!originOk && !xExtOk) {
+    return jsonError(403, "forbidden_origin");
+  }
+  return null;
+}
+
+// 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 ──
+  {
+    // VERIFIED 2026-06-21 against the claude-api reference. Claude Fable 5 is
+    // Anthropic's most capable model — a NEW tier ABOVE the opus/sonnet/haiku
+    // line (the id has no MAJOR-MINOR version, just `-5`) at 2× Opus pricing
+    // ($10/$50 vs $5/$25). Hand-authored, not cloned: the onboarder regex can't
+    // match this shape (new family + single-segment version), AND a clone would
+    // carry the wrong (opus) pricing. status:'preview' — no brain evidence yet;
+    // it earns per-archetype placement through the machinery like any model, and
+    // at 2× Opus the quality-floor + cost gates do real work before it leads.
+    // API quirk (claude-api ref): an explicit `thinking:{type:"disabled"}` 400s
+    // on Fable 5 (omit instead) — MOOT here: ANTHROPIC_LOWERING_BASE carries no
+    // `thinking` field, so kgauto never sends the param. (L-049/L-081.)
+    id: "claude-fable-5",
+    verifiedAgainstDocs: "2026-06-21",
+    provider: "anthropic",
+    status: "current",
+    // s76 2026-07-25: GA since 2026-06-09 per docs; was preview.
+    maxContextTokens: 1e6,
+    maxOutputTokens: 128e3,
+    maxTools: 64,
+    parallelToolCalls: true,
+    structuredOutput: "grammar",
+    systemPromptMode: "inline",
+    streaming: true,
+    cliffs: [],
+    costInputPer1m: 10,
+    costOutputPer1m: 50,
+    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: "Most capable Anthropic model (2026-06); a new tier ABOVE Opus at 2\xD7 pricing ($10/$50). 1M ctx, 128k out. Verified 2026-06-21 against the claude-api reference. status:preview \u2014 no brain evidence yet; earns placement via the machinery (cost + quality-floor gates govern). latencyTier derives `slow` (weaknesses includes latency \u2014 minutes-long turns on hard tasks). The thinking-disabled-400 API quirk is moot for kgauto (Anthropic lowering emits no thinking param).",
+    // archetypePerf cloned from claude-opus-4-8 as a conservative estimate
+    // (Fable >= Opus in capability, but unmeasured — no fabricated superiority).
+    // Re-rank once brain rows exist.
+    archetypePerf: {
+      critique: 10,
+      plan: 10,
+      generate: 9,
+      ask: 9,
+      extract: 9,
+      transform: 9,
+      hunt: 8,
+      summarize: 8,
+      classify: 8
+    }
+  },
+  {
+    // Auto-onboarded 2026-06-04 from `claude-opus-4-7`; VERIFIED 2026-06-21
+    // against the claude-api reference. Opus 4.8 shares 4.7's surface exactly —
+    // 1M ctx, 128k out, $5/$25, no new breaking changes — so the clone's
+    // capability data was accurate (confirmed field-by-field). archetypePerf is
+    // still cloned from 4.7 (a sound estimate: 4.8 >= 4.7) — re-rank once brain
+    // rows exist. Promoted to status:'current' 2026-06-21 (Sacha: "include Claude
+    // Opus 4.8") — now live-selectable. Ties with the still-current claude-opus-4-7
+    // (identical $5/$25 + cloned perf) resolve to 4-8 by array order. (L-049/L-081.)
+    id: "claude-opus-4-8",
+    verifiedAgainstDocs: "2026-06-21",
+    provider: "anthropic",
+    status: "legacy",
+    // s76 2026-07-25: docs list as LEGACY (Opus 5 generation is 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 Opus (2026-06), the current recommended Opus-tier default. Verified 2026-06-21 against the claude-api reference: 1M ctx, 128k out, $5/$25 \u2014 identical surface to 4.7, no new breaking changes. Promoted to status:current 2026-06-21 (live-selectable); coexists with claude-opus-4-7 (still current).",
+    // Cloned archetypePerf from claude-opus-4-7 — re-evaluate once brain rows exist.
+    archetypePerf: {
+      critique: 10,
+      plan: 10,
+      generate: 9,
+      ask: 9,
+      extract: 9,
+      transform: 9,
+      hunt: 8,
+      summarize: 8,
+      classify: 8
+    }
+  },
+  {
+    // ── Claude Opus 5 — added s76 (2026-07-25, alpha.72) ──────────────────
+    // The model every seat in the portfolio actually runs, absent from the
+    // roster until now. Found by a catalog QA, not by the release watcher:
+    // the watcher detects unknown IDs on a provider's /models endpoint, but
+    // detection was never wired to ingestion, so the gap sat open. (That is
+    // what `scripts/catalog-sync.mjs` exists to close.)
+    //
+    // PROVENANCE — doc-verified 2026-07-25 against
+    // platform.claude.com/docs/en/docs/about-claude/models/overview:
+    //   1M context · 128k max output · $5/$25 per MTok · adaptive thinking YES
+    //   · extended thinking NO · `effort` defaults to 'high' on the Claude API
+    //   · reliable knowledge cutoff May 2026.
+    //
+    // FAMILY-INHERITED (not doc-read): maxTools, parallelToolCalls,
+    // structuredOutput, systemPromptMode, streaming. These are identical
+    // across opus-4-6 / 4-7 / 4-8 / sonnet-5 / fable-5 — five consecutive
+    // models — so they are a structural provider constant rather than a
+    // per-model value. Deliberately distinguished from the gemini-3.1-flash-lite
+    // failure, where a template-clone of PRICE (the field that actually varies,
+    // there by 2.5-3.75x) went unverified for 65 days.
+    id: "claude-opus-5",
+    verifiedAgainstDocs: "2026-07-25",
+    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: "Anthropic frontier for complex agentic coding + enterprise work; the Opus-tier current default as of 2026-07-25, superseding 4.8/4.7/4.6 (all now legacy). Doc-verified 2026-07-25: 1M ctx, 128k out, $5/$25, adaptive thinking (extended thinking NOT supported \u2014 that is Haiku 4.5 only in this generation), `effort` defaults to high on the Claude API. Price is unchanged from 4.5 through 5 \u2014 the tier moved without a cost change.",
+    // COLD-START PRIOR cloned from claude-opus-4-8. Self-labelling: below
+    // MEASURED_GROUNDING_MIN_N (10) brain rows these resolve as
+    // grounding:'judgment', so nothing reads them as measured until they are.
+    archetypePerf: {
+      critique: 10,
+      plan: 10,
+      generate: 9,
+      ask: 9,
+      extract: 9,
+      transform: 9,
+      hunt: 8,
+      summarize: 8,
+      classify: 8
+    }
+  },
+  {
+    id: "claude-opus-4-7",
+    verifiedAgainstDocs: "2026-08-14",
+    provider: "anthropic",
+    status: "legacy",
+    // s76 2026-07-25: docs list as LEGACY (Opus 5 is current). Bundle said current while the brain already said legacy — the two disagreed.
+    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-08-14",
+    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-08-14",
+    provider: "anthropic",
+    status: "legacy",
+    // s76 2026-07-25: docs list as LEGACY (Sonnet 5 is 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-08-14",
+    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"
+      },
+      {
+        // alpha.78 — the declared `structuredOutput: 'grammar'` does NOT
+        // hold on long-input summarize. MEASURED (brain, playbacksam):
+        // 21 disambiguated `structured_output_parse_failed` fallover rows
+        // 2026-07-22..27, tokens_in 12,280–31,450; PB's gate counted 20/20
+        // in-window failures. Clean traffic p50 sits at ~9K tokens_in, so
+        // 12K gates the failing band without touching the working one.
+        // Short-input summarize carries no failure evidence and stays
+        // ungated — this is why it's a cliff, not an archetype-wide
+        // `structuredOutputHint: 'avoid'`.
+        metric: "input_tokens",
+        threshold: 12e3,
+        action: "quality_gate_structured",
+        whenIntent: "summarize",
+        reason: "Structured-output parse failures at 100% in-window on long-input summarize (measured on playbacksam, 2026-07-25..27; haiku only led when input size made price dominate, then failed every time)."
+      }
+    ],
+    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-08-14",
+    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-08-27",
+    provider: "google",
+    // alpha.91 — AVAILABILITY demotion, same class as gemini-2.5-pro below.
+    // Google refuses the model for newer account cohorts: "This model is no
+    // longer available to new users. Please update your code to use
+    // models/gemini-3.5-flash-lite" (tt-intel TT-49 runtime evidence,
+    // 2026-08-26, interfaces/kgauto.md ## Requested). It ranked FIRST in
+    // getFallbackChain('gemini-2.5-pro') — a dead-for-new-accounts model as
+    // the cheapest fallback pick. `legacy` removes it from chains and new
+    // selection; explicit-id consumers still resolve it. Successor is the
+    // one Google's own error names: gemini-3.5-flash-lite (onboarded this
+    // release, same price point).
+    status: "legacy",
+    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-08-08",
+    provider: "google",
+    // alpha.86 — AVAILABILITY demotion, not a provider-lifecycle mirror.
+    // Google's docs still list 2.5-pro as Stable, but the serving layer
+    // disagrees per account cohort: tt-intel measured 4/4 refusals
+    // ("no longer available to new users", 2026-08-02, their bench), and
+    // kgauto's own key 429s on a FreeTier per-day quota (probed
+    // 2026-08-08). A chain anchor that hard-fails for whole account
+    // cohorts is not an anchor; `legacy` removes it from cost-ordered
+    // chains and new selection while keeping the profile resolvable for
+    // consumers who pass it explicitly. Re-promotion is one status flip
+    // if Google restores availability. The registry cannot yet express
+    // account-cohort availability as data — see interfaces/kgauto.md
+    // ## Requested 2026-08-02.
+    status: "legacy",
+    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", "availability_restricted_by_account_cohort"],
+    // 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-08-14",
+    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-08-24",
+    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.44,
+    costOutputPer1m: 1.32,
+    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"],
+    // alpha.47 — explicit slow override. Tag derivation would say 'medium'
+    // (no 'latency' weakness, no 'speed' strength), but the alpha.46 shadow
+    // probe MEASURED deepseek-v4-flash at 20485ms served (2026-06-03) — ~2.3×
+    // gemini-2.5-flash on PB's synchronous /api/analyze path. The 'flash' name
+    // is DeepSeek's, not a speed promise. This is the row that, scoring 0.85
+    // baseQuality (it carries 'reasoning') with no latency counterweight,
+    // leapfrogged gemini-2.5-flash as PB's summarize leader once reachable.
+    latencyTier: "slow",
+    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. PEAK/OFF-PEAK since 2026-08-16 (page fetched 2026-08-24): peak = weekdays 01:00-04:00 + 06:00-10:00 UTC, off-peak = all other hours at HALF peak. Encoded prices ARE the peak rate (conservative: never understate cost); off-peak traffic costs half what the estimate says. alpha.87 was built + verified 2026-08-14 (prices then live), held at the publish gate 10 days, and published 2026-08-24 \u2014 by which time the 08-16 transition had killed them ($0.14/$0.28 flash, $0.435/$0.87 pro); corrected here (alpha.88). Build-then-hold is the mechanism: re-verify prices at publish when publish is not same-session as build. A single price field cannot represent a two-rate schedule; catalog-sync extractions oscillate between the rates day-to-day (peak read 08-21, off-peak read 08-22) \u2014 time-of-day pricing remains unmodeled, roadmap.",
+    // 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
+    },
+    // alpha.43 — family-level conventions for the `deepseek-chat` family
+    // (V4-Flash + future non-thinking-mode members). V4-Flash struggles
+    // with summarize-archetype + structured-output: 3 of 4 schema-attempted
+    // PB calls (2026-05-18 + 2026-05-22) hit `structured_output_parse_failed`.
+    // Surface the friction at compile time so consumers either drop the
+    // schema or route to a more schema-reliable family.
+    archetypeConventions: [
+      {
+        archetype: "summarize",
+        structuredOutputHint: "avoid",
+        cliffWarning: "deepseek-chat family schema compliance on summarize is weak (3 of 4 schema-attempted PB calls hit structured_output_parse_failed). Consider routing summarize+structured-output to a different family (claude-sonnet, gemini-pro, openai-gpt-5.4) or dropping the schema for free-text summaries.",
+        reason: "Brain evidence: PB compile_outcomes 2026-05-18 + 2026-05-22, error_type=structured_output_parse_failed on deepseek-v4-flash + summarize archetype."
+      }
+    ]
+  },
+  {
+    id: "deepseek-v4-pro",
+    verifiedAgainstDocs: "2026-08-24",
+    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"
+      }
+    ],
+    // Verified against the live DeepSeek pricing page 2026-06-22: the 75%-off
+    // launch "promo" ($0.435/$0.87) did NOT revert on 2026-05-31 — it became the
+    // standing price (docs show $0.435 in / $0.87 out cache-miss, $0.003625
+    // cache-hit in; no promo caveat). The old $1.74/$3.48 "regular post-promo"
+    // was a projected revert that never happened (L-073/L-081) — it 4×-overstated
+    // cost and suppressed V4-Pro in cost-aware ranking.
+    costInputPer1m: 1.32,
+    costOutputPer1m: 3.96,
+    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"],
+    // alpha.47 — explicit slow override. Measured 47722ms on the alpha.46
+    // shadow probe (2026-06-03) — it's an extended-thinking reasoner, slowest
+    // of the served set. Tag derivation would say 'medium'; the measurement says
+    // otherwise.
+    latencyTier: "slow",
+    notes: "Pro tier. 1M context, 384k max output. $0.435/$0.87 per 1M (cache-hit in $0.003625) \u2014 verified live 2026-06-22; the launch promo became the standing price (no revert). Default mode = thinking. PEAK/OFF-PEAK since 2026-08-16 (page fetched 2026-08-24): peak = weekdays 01:00-04:00 + 06:00-10:00 UTC, off-peak = all other hours at HALF peak. Encoded prices ARE the peak rate (conservative: never understate cost); off-peak traffic costs half what the estimate says. alpha.87 was built + verified 2026-08-14 (prices then live), held at the publish gate 10 days, and published 2026-08-24 \u2014 by which time the 08-16 transition had killed them ($0.14/$0.28 flash, $0.435/$0.87 pro); corrected here (alpha.88). Build-then-hold is the mechanism: re-verify prices at publish when publish is not same-session as build. A single price field cannot represent a two-rate schedule; catalog-sync extractions oscillate between the rates day-to-day (peak read 08-21, off-peak read 08-22) \u2014 time-of-day pricing remains unmodeled, roadmap.",
+    // 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
+    },
+    // alpha.43 — family-level conventions for the `deepseek-reasoner` family
+    // (V4-Pro is the family rep; future thinking-mode members inherit).
+    //
+    // The decisive-archetype suffix is the load-bearing piece: 2026-05-28
+    // first real V4-Pro probe on tt-intel/classify (exclusion-finding ID 20)
+    // showed 8/10 judge rationales citing "candidate hedges and fails to
+    // commit to a single classification" or "candidate refuses to pick
+    // among the labels." Without the forcing-function suffix, every
+    // reasoner probe on classify/extract/ask verdicts stay-excluded for
+    // model-behavior reasons (epistemic humility is reasoner-shaped),
+    // NOT quality reasons. The suffix re-shapes the contract so the model
+    // is asked for what it's actually being measured on.
+    //
+    // The hunt-archetype cliffWarning is the L-040 architectural reading
+    // surfaced at compile time. Reasoners produce sequential reasoning
+    // chains by design; hunt archetypes with 3+ parallel tools lose
+    // substantial throughput (L-040 + L-041). The L-040 cliff in the
+    // `cliffs` array already trims to top-relevant tools; this warning
+    // tells the consumer the family is wrong for the shape so they can
+    // route to gemini-flash (parallel-strong) instead of accepting trimmed
+    // throughput silently.
+    archetypeConventions: [
+      {
+        archetype: "classify",
+        promptSuffix: "\n\nOutput exactly one classification label. Do not hedge, do not add preamble, do not explain your reasoning. If uncertain, pick the most likely label and commit to it.",
+        reason: "Reasoners (deepseek-reasoner family) hedge on decisive-output archetypes by design. Evidence: 2026-05-28 V4-Pro probe on tt-intel/classify (exclusion-finding ID 20, brain probe_outcomes); 8 of 10 judge rationales cited hedging or refusal-to-commit. Forcing-function suffix converts reasoner output to decisive labels."
+      },
+      {
+        archetype: "extract",
+        promptSuffix: "\n\nOutput exactly the requested structured fields. Do not hedge, do not add preamble, do not explain your reasoning. If a field is unknown, emit the field with a null/empty value and commit to that \u2014 do not refuse to extract.",
+        reason: "Reasoners (deepseek-reasoner family) hedge on decisive-output archetypes by design. Evidence: same family failure shape as classify (exclusion-finding ID 20, 2026-05-28). Forcing-function suffix asks for commitment instead of epistemic-humility hedging."
+      },
+      {
+        archetype: "ask",
+        promptSuffix: "\n\nAnswer the question directly. Do not hedge, do not add preamble, do not explain your reasoning unless explicitly asked. If uncertain, give your best answer and commit to it.",
+        reason: "Reasoners (deepseek-reasoner family) hedge on decisive-output archetypes by design. Evidence: same family failure shape as classify (exclusion-finding ID 20, 2026-05-28). Forcing-function suffix asks for commitment instead of epistemic-humility hedging."
+      },
+      {
+        archetype: "hunt",
+        whenToolCountAtLeast: 3,
+        cliffWarning: "Reasoners (deepseek-reasoner family) produce sequential reasoning chains by design; hunt archetypes with 3+ parallel tools lose substantial throughput. Consider gemini-flash family (parallel-strong) instead \u2014 see L-040 / L-041.",
+        reason: "L-040 + L-041 architectural reading; 2026-05-28 V4-Pro probe evidence (exclusion-finding ID 20) confirms reasoner-family hunt fit is structurally weak."
+      }
+    ]
+  },
+  // ── OpenAI ──
+  // alpha.16 (2026-05-17): close the half-supported provider gap. env.ts
+  // already registered OPENAI_API_KEY + executeOpenAI + normalizeOpenAILike
+  // + lowerOpenAI all existed; profile entries were missing, so the
+  // alpha.10 auto-filter would mark openai-keyed models reachable but
+  // there were no profiles to filter IN. Half-supported is now fully
+  // supported. PB request `openai-provider-profiles` (2026-05-16).
+  //
+  // Profile data verified against developers.openai.com/api/docs/pricing
+  // + per-model pages 2026-05-17. L-049/L-081 step-zero: no AI-trained
+  // numbers — fetched live from OpenAI's docs. As of 2026-05, OpenAI's
+  // current flagship is gpt-5.5 (2025-12 cutoff); gpt-5.4-{base,mini,nano}
+  // are the workhorse family. gpt-4.1 + gpt-4o are legacy.
+  //
+  // Both 5.5 and 5.4 carry a 272K input-token pricing cliff (2x input,
+  // 1.5x output beyond that). Modeled as a `downgrade_quality_warning`
+  // cliff because it ranks the model down at large-context shapes — the
+  // semantics of "this model is now 2x more expensive" map onto the
+  // existing penalty mechanism. Cost-watcher will catch high-context
+  // spikes empirically; the cliff prevents naive routing into the doubled
+  // pricing zone.
+  {
+    id: "gpt-5.5",
+    verifiedAgainstDocs: "2026-05-17",
+    provider: "openai",
+    status: "current",
+    maxContextTokens: 105e4,
+    maxOutputTokens: 128e3,
+    maxTools: 64,
+    parallelToolCalls: true,
+    structuredOutput: "native",
+    systemPromptMode: "inline",
+    streaming: true,
+    cliffs: [
+      {
+        metric: "input_tokens",
+        threshold: 272e3,
+        action: "downgrade_quality_warning",
+        reason: "OpenAI pricing tier shift: >272K input tokens billed at 2x input + 1.5x output rates"
+      }
+    ],
+    costInputPer1m: 5,
+    costOutputPer1m: 30,
+    lowering: {
+      system: { mode: "inline" },
+      // OpenAI caching is implicit (auto-applied to repeated prefixes
+      // ≥1024 tokens for prompt_tokens_details.cached_tokens). No
+      // wire-format marker. Discount: 10x for cached input ($0.50/$5.00).
+      cache: { strategy: "unsupported", minTokens: 1024, discount: 0.1 },
+      tools: { format: "openai" }
+    },
+    recovery: [
+      { signal: "rate_limit", action: "escalate", reason: "429 \u2014 escalate to fallback chain" },
+      { signal: "model_not_found", action: "escalate", reason: "Model deprecated/renamed \u2014 escalate (L-061)" }
+    ],
+    strengths: ["reasoning", "agentic_coding", "long_context", "structured_output", "reliable_tool_use", "reasoning_effort_knob"],
+    weaknesses: ["cost", "pricing_cliff_at_272k"],
+    notes: "OpenAI frontier (2026-05). 1M context (1.05M total), 128K max output, 2025-12 cutoff. Reasoning effort knob (none/low/medium/high/xhigh). Pricing cliff at 272K input.",
+    // Frontier-tier perf hypothesis. Anchored to Opus 4.7 row (similar
+    // price/positioning). Brain evidence will refine; no telemetry yet.
+    archetypePerf: {
+      critique: 9,
+      plan: 9,
+      generate: 9,
+      ask: 9,
+      extract: 9,
+      transform: 9,
+      hunt: 8,
+      // parallel tool support good but cliff at 272K hurts deep multi-step
+      summarize: 7,
+      // overkill for tolerant archetype
+      classify: 7
+      // overkill; cheaper models cover this
+    }
+  },
+  {
+    id: "gpt-5.4",
+    verifiedAgainstDocs: "2026-05-17",
+    provider: "openai",
+    status: "current",
+    maxContextTokens: 105e4,
+    maxOutputTokens: 128e3,
+    maxTools: 64,
+    parallelToolCalls: true,
+    structuredOutput: "native",
+    systemPromptMode: "inline",
+    streaming: true,
+    cliffs: [
+      {
+        metric: "input_tokens",
+        threshold: 272e3,
+        action: "downgrade_quality_warning",
+        reason: "OpenAI pricing tier shift: >272K input tokens billed at 2x input + 1.5x output rates"
+      }
+    ],
+    costInputPer1m: 2.5,
+    costOutputPer1m: 15,
+    lowering: {
+      system: { mode: "inline" },
+      cache: { strategy: "unsupported", minTokens: 1024, discount: 0.1 },
+      tools: { format: "openai" }
+    },
+    recovery: [
+      { signal: "rate_limit", action: "escalate", reason: "429 \u2014 escalate to fallback chain" },
+      { signal: "model_not_found", action: "escalate", reason: "Model deprecated/renamed \u2014 escalate (L-061)" }
+    ],
+    strengths: ["reasoning", "long_context", "structured_output", "reliable_tool_use"],
+    weaknesses: ["pricing_cliff_at_272k"],
+    notes: "OpenAI workhorse (2026-05). 1M context (1.05M total), 128K max output, 2025-08 cutoff. Pricing cliff at 272K input. Pairs cleanly with Sonnet 4.6 on cost ($2.50/$15.00 vs $3.00/$15.00).",
+    // Anchored to Sonnet 4.6 row (similar price/positioning). Slight
+    // anthropic-side edge on agentic coding per master plan vibe.
+    archetypePerf: {
+      critique: 8,
+      plan: 8,
+      generate: 8,
+      ask: 8,
+      extract: 8,
+      transform: 8,
+      hunt: 7,
+      summarize: 7,
+      classify: 7
+    }
+  },
+  {
+    id: "gpt-5.4-mini",
+    verifiedAgainstDocs: "2026-05-17",
+    provider: "openai",
+    status: "current",
+    maxContextTokens: 4e5,
+    maxOutputTokens: 128e3,
+    maxTools: 64,
+    parallelToolCalls: true,
+    structuredOutput: "native",
+    systemPromptMode: "inline",
+    streaming: true,
+    cliffs: [],
+    costInputPer1m: 0.75,
+    costOutputPer1m: 4.5,
+    lowering: {
+      system: { mode: "inline" },
+      cache: { strategy: "unsupported", minTokens: 1024, discount: 0.1 },
+      tools: { format: "openai" }
+    },
+    recovery: [
+      { signal: "rate_limit", action: "escalate", reason: "429 \u2014 escalate to fallback chain" },
+      { signal: "model_not_found", action: "escalate", reason: "Model deprecated/renamed \u2014 escalate (L-061)" }
+    ],
+    strengths: ["cost", "speed", "agentic_coding", "structured_output", "reliable_tool_use"],
+    weaknesses: ["reasoning_depth"],
+    notes: "OpenAI mini-tier (2026-05). 400K context, 128K max output, 2025-08 cutoff. OpenAI describes as 'strongest mini model for coding, computer use, subagents.' Cache discount 10x ($0.075 input).",
+    // Mini-tier hypothesis. Anchored to Haiku 4.5 + Flash row pricing.
+    // Cost is slightly higher than Haiku ($0.75 vs $0.50 input) but
+    // OpenAI claims strong coding/subagent perf.
+    archetypePerf: {
+      ask: 7,
+      generate: 7,
+      extract: 7,
+      transform: 7,
+      classify: 7,
+      summarize: 7,
+      hunt: 7,
+      plan: 6,
+      critique: 5
+      // reasoning depth gap — frontier models handle this
+    }
+  },
+  {
+    id: "gpt-5.4-nano",
+    verifiedAgainstDocs: "2026-05-17",
+    provider: "openai",
+    status: "current",
+    maxContextTokens: 4e5,
+    maxOutputTokens: 128e3,
+    maxTools: 64,
+    parallelToolCalls: true,
+    structuredOutput: "native",
+    systemPromptMode: "inline",
+    streaming: true,
+    cliffs: [],
+    costInputPer1m: 0.2,
+    costOutputPer1m: 1.25,
+    lowering: {
+      system: { mode: "inline" },
+      cache: { strategy: "unsupported", minTokens: 1024, discount: 0.1 },
+      tools: { format: "openai" }
+    },
+    recovery: [
+      { signal: "rate_limit", action: "escalate", reason: "429 \u2014 escalate to fallback chain" },
+      { signal: "model_not_found", action: "escalate", reason: "Model deprecated/renamed \u2014 escalate (L-061)" }
+    ],
+    strengths: ["cost", "speed", "volume", "structured_output"],
+    weaknesses: ["reasoning_depth", "no_computer_use"],
+    notes: "OpenAI nano-tier (2026-05). 400K context, 128K max output, 2025-08 cutoff. 'Cheapest GPT-5.4-class for simple high-volume tasks.' No fine-tuning, no computer-use tools. Cache discount 10x.",
+    // Nano-tier. Anchored to Flash-Lite row ($0.10/$0.40 vs nano's
+    // $0.20/$1.25). Slightly more expensive than Flash-Lite but with
+    // OpenAI brand reliability. Good fit for classify/summarize floor.
+    archetypePerf: {
+      classify: 7,
+      summarize: 6,
+      ask: 6,
+      transform: 6,
+      extract: 6,
+      generate: 5,
+      hunt: 5,
+      plan: 4,
+      critique: 3
+      // not for reasoning archetypes
+    }
+  },
+  // ── Auto-onboarded (UNVERIFIED) ──
+  // Cloned by scripts/auto-onboard-models.mjs from a same-family template.
+  // Each entry's pricing/context/cliffs/lowering reflects the template, NOT
+  // provider docs. Verify before promoting status to 'current' (L-049/L-081).
+  {
+    // s37 (2026-05-21): UNVERIFIED-AUTO-ONBOARD → verified against
+    // ai.google.dev/gemini-api/docs/models/gemini-3-flash-preview +
+    // ai.google.dev/gemini-api/docs/pricing. L-081 catches:
+    //   maxOutputTokens 65_535 → 65_536 (off-by-one)
+    //   costInputPer1m  0.30 → 0.50  (template-cloned from 2.5-flash; actual is 1.67× more expensive)
+    //   costOutputPer1m 2.50 → 3.00  (template-cloned; actual 1.2× more expensive)
+    //   cache discount  default 0.25 → 0.10 (10× discount, $0.05/$0.50 per docs)
+    // Cliffs inherited from 2.5-flash conservatively. The 8K-context-quality
+    // cliff was a 2.5-Flash observation — Google positions Gemini 3 as
+    // sustained-frontier-on-long-context; brain evidence will validate/relax.
+    // Kept as guard for now.
+    id: "gemini-3-flash-preview",
+    verifiedAgainstDocs: "2026-05-21",
+    provider: "google",
+    status: "preview",
+    maxContextTokens: 1048576,
+    maxOutputTokens: 65536,
+    maxTools: 128,
+    parallelToolCalls: true,
+    structuredOutput: "native",
+    systemPromptMode: "separate",
+    streaming: true,
+    cliffs: [
+      {
+        metric: "input_tokens",
+        threshold: 8e3,
+        action: "downgrade_quality_warning",
+        reason: "Inherited from 2.5-flash guard; brain evidence on Gemini 3 long-context quality will validate/relax"
+      },
+      {
+        metric: "tool_count",
+        threshold: 20,
+        action: "drop_to_top_relevant",
+        reason: "Tool reliability drops above ~20 tools (despite 128 hard limit) \u2014 inherited from Flash family"
+      },
+      {
+        metric: "thinking_with_short_output",
+        threshold: 1,
+        action: "force_thinking_budget_zero",
+        reason: "Thinking tokens consume maxOutputTokens \u2014 empty response if drained"
+      },
+      {
+        // Inherited from gemini-2.5-flash s11 trust artifact. Family-likely
+        // failure mode for Flash architecture. Keep preemptively until brain
+        // evidence on Gemini 3 specifically.
+        metric: "tool_count",
+        threshold: 1,
+        whenIntent: "summarize",
+        action: "strip_tools",
+        reason: "Inherited from 2.5-flash s11 cliff: summarize+tools \u2192 empty response. Preemptive guard until brain evidence on 3-flash-preview specifically."
+      }
+    ],
+    costInputPer1m: 0.5,
+    costOutputPer1m: 3,
+    lowering: {
+      ...GOOGLE_LOWERING_BASE,
+      // 10× cache discount per Google pricing: $0.05/M cached vs $0.50/M input.
+      cache: { ...GOOGLE_LOWERING_BASE.cache, discount: 0.1 },
+      thinking: { field: "generationConfig.thinkingConfig.thinkingBudget", default: "auto" }
+    },
+    recovery: [
+      {
+        signal: "empty_response_after_tool",
+        action: "retry_with_params",
+        retryParams: { "generationConfig.thinkingConfig.thinkingBudget": 0 },
+        maxRetries: 1,
+        reason: "Known: empty after tool result \u2014 retry with thinking off"
+      },
+      {
+        signal: "empty_response",
+        action: "retry_with_params",
+        retryParams: { "generationConfig.thinkingConfig.thinkingBudget": 0 },
+        maxRetries: 1,
+        reason: "Empty response \u2014 try with thinking off"
+      },
+      {
+        signal: "malformed_function_call",
+        action: "escalate",
+        reason: "MALFORMED_FUNCTION_CALL maps to stop \u2014 escalate to next target"
+      }
+    ],
+    strengths: ["speed", "volume", "classification", "1m_context", "cost"],
+    weaknesses: ["complex_schemas", "large_tool_sets", "high_context_quality"],
+    notes: "Verified s37 (2026-05-21) against Google docs. Step-change positioning vs 2.5-flash on agentic loops per Google's release notes (Dec 2025). Pricing 1.67\xD7/1.2\xD7 higher than 2.5-flash; cache discount 10\xD7 (vs 4\xD7 for 2.5). Status=preview until brain evidence accumulates.",
+    // Anchored to 2.5-flash archetypePerf as starter, with judgment adjustments
+    // for Google's "step-change on agentic" positioning. Brain evidence (zero
+    // rows today) will replace these starter values.
+    archetypePerf: {
+      hunt: 9,
+      // Inherits 2.5-flash L-040 parallel-tool tier; Google positions 3 as agentic-loop upgrade
+      classify: 7,
+      // Inherits 2.5-flash brain-validated tier (218 rows on 2.5)
+      summarize: 7,
+      // Inherits 2.5-flash; cliff strips tools when present
+      transform: 7,
+      ask: 8,
+      // +1 vs 2.5-flash — sustained-frontier positioning
+      generate: 7,
+      // +1 vs 2.5-flash — agentic coding upgrade per Google
+      plan: 6,
+      // +1 vs 2.5-flash — complex iterations per positioning
+      extract: 6,
+      critique: 5
+      // +1 vs 2.5-flash — but still below Sonnet/Opus reasoning floor
+    }
+  },
+  {
+    // ── Gemini 3.1 Flash-Lite ──
+    // Onboarded 2026-05-16 by auto-onboarder; s37 (2026-05-21) verified
+    // against ai.google.dev/gemini-api/docs/pricing.
+    //
+    // L-081 CATCHES (template clone from 2.5-flash-lite was 2.5-3.75× too cheap):
+    //   costInputPer1m  0.10 → 0.25 (template clone undervalued by 2.5×)
+    //   costOutputPer1m 0.40 → 1.50 (template clone undervalued by 3.75×)
+    //
+    // Real 3.1-flash-lite is NOT a cost-equivalent successor to 2.5-flash-lite —
+    // it sits between 2.5-flash-lite ($0.10/$0.40) and 2.5-flash ($0.30/$2.50).
+    // Cache discount 10× verified ($0.025/M cached vs $0.25/M input).
+    //
+    // Cliffs are HYPOTHESIZED from 2.5-flash family; brain evidence pending.
+    id: "gemini-3.1-flash-lite",
+    verifiedAgainstDocs: "2026-08-27",
+    provider: "google",
+    // alpha.91 — docs page now labels it "Stable" and the brain row has been
+    // `current` since catalog-sync moved it; the bundle lagged (the L-073
+    // layer-parity shape, caught during the TT-49 delisting release).
+    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.25,
+    costOutputPer1m: 1.5,
+    lowering: {
+      ...GOOGLE_LOWERING_BASE,
+      // Cache discount 10× (vs Flash 4×) — Google docs s37: $0.025/M cached vs
+      // $0.25/M input. Material for repeat-prompt workloads (classify shape).
+      cache: { ...GOOGLE_LOWERING_BASE.cache, discount: 0.1 },
+      thinking: { field: "generationConfig.thinkingConfig.thinkingBudget", default: "auto" }
+    },
+    recovery: [
+      {
+        signal: "empty_response_after_tool",
+        action: "retry_with_params",
+        retryParams: { "generationConfig.thinkingConfig.thinkingBudget": 0 },
+        maxRetries: 1,
+        reason: "Known on Flash family: empty after tool result \u2014 retry with thinking off."
+      },
+      {
+        signal: "empty_response",
+        action: "retry_with_params",
+        retryParams: { "generationConfig.thinkingConfig.thinkingBudget": 0 },
+        maxRetries: 1,
+        reason: "Empty response \u2014 try with thinking off."
+      },
+      {
+        signal: "malformed_function_call",
+        action: "escalate",
+        reason: "MALFORMED_FUNCTION_CALL maps to stop \u2014 escalate to next target."
+      }
+    ],
+    strengths: ["low_cost", "speed", "volume", "classification", "summarize", "1m_context", "cache_friendly"],
+    weaknesses: ["complex_reasoning", "large_tool_sets", "complex_schemas", "structured_output_unproven", "long_context_quality"],
+    notes: "Verified s37 (2026-05-21) against Google docs. Sits between 2.5-flash-lite (cheaper) and 2.5-flash (more expensive) on cost frontier; 2.5\xD7 more expensive than initial template-clone. Cliffs hypothesized from Flash family \u2014 brain evidence pending.",
+    // Tier 2-3 floor for summarize/classify chains at the new (verified) price
+    // point. ZERO brain rows — values are starter hypotheses anchored to
+    // "smaller sibling of Flash at higher cost than 2.5-flash-lite." The first
+    // 50 brain rows per archetype will validate or relax these.
+    archetypePerf: {
+      classify: 6,
+      // starter hypothesis — verify (Flash is 7, lite likely ≤)
+      summarize: 6,
+      // starter hypothesis — verify; cliff strips tools
+      transform: 6,
+      // starter hypothesis — verify
+      ask: 5,
+      hunt: 5,
+      generate: 4,
+      extract: 4,
+      plan: 3,
+      critique: 3
+    }
+  },
+  // ─────────────────────────────────────────────────────────────────────────
+  // Gemini 3.5 Flash-Lite — onboarded s91 (2026-08-27)
+  //
+  // The successor Google's own delisting error names: "This model
+  // [gemini-2.5-flash-lite] is no longer available to new users. Please
+  // update your code to use models/gemini-3.5-flash-lite" (tt-intel TT-49,
+  // 2026-08-26). Same price point as the 2.5 Lite rung it replaces in the
+  // summarize/classify starter chains ($0.30/$2.50 vs the old $0.10/$0.40
+  // era pricing), same 1M/65K limits, same 10× cache discount ($0.03 vs
+  // $0.30 input). Positioning: "fastest, most cost-effective 3.5 model for
+  // high-throughput execution … high-volume agentic tasks, translation, and
+  // simple data processing."
+  //
+  // Cliffs + archetypePerf inherited from the Flash-Lite family as starter
+  // hypotheses — ZERO brain rows on this id yet; first 50 rows per archetype
+  // validate or relax.
+  //
+  // Specs verified 2026-08-27 against:
+  //   ai.google.dev/gemini-api/docs/models/gemini-3.5-flash-lite
+  //     (Stable; input limit 1,048,576; output limit 65,536; function
+  //     calling / structured outputs / thinking / caching all Supported)
+  //   ai.google.dev/gemini-api/docs/pricing ($0.30 in / $2.50 out incl.
+  //     thinking tokens; context caching $0.03)
+  // ─────────────────────────────────────────────────────────────────────────
+  {
+    id: "gemini-3.5-flash-lite",
+    verifiedAgainstDocs: "2026-08-27",
+    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 family: quality degrades above ~8K. Lite tier \u2014 assume it degrades at least as fast. Re-tune from brain after n\u226520."
+      },
+      {
+        metric: "tool_count",
+        threshold: 10,
+        action: "drop_to_top_relevant",
+        reason: "Conservative: Flash drops at 20, Lite tier is smaller \u2014 assume tighter ceiling until brain proves otherwise."
+      },
+      {
+        metric: "thinking_with_short_output",
+        threshold: 1,
+        action: "force_thinking_budget_zero",
+        reason: "Thinking Supported per model page \u2014 same drain risk as Flash; thinking tokens consume maxOutputTokens."
+      },
+      {
+        // Strong prior: Flash hit 5/5 empty rate on summarize+tools (s11
+        // trust artifact). Flash-Lite siblings carry the guard preemptively;
+        // brain telemetry confirms or relaxes per id.
+        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 3.5 Flash-Lite specifically."
+      }
+    ],
+    costInputPer1m: 0.3,
+    costOutputPer1m: 2.5,
+    lowering: {
+      ...GOOGLE_LOWERING_BASE,
+      // Cache discount 10× — pricing page: $0.03/M cached vs $0.30/M input.
+      // Material for repeat-prompt workloads (classify shape).
+      cache: { ...GOOGLE_LOWERING_BASE.cache, discount: 0.1 },
+      thinking: { field: "generationConfig.thinkingConfig.thinkingBudget", default: "auto" }
+    },
+    recovery: [
+      {
+        signal: "empty_response_after_tool",
+        action: "retry_with_params",
+        retryParams: { "generationConfig.thinkingConfig.thinkingBudget": 0 },
+        maxRetries: 1,
+        reason: "Known on Flash family: empty after tool result \u2014 retry with thinking off."
+      },
+      {
+        signal: "empty_response",
+        action: "retry_with_params",
+        retryParams: { "generationConfig.thinkingConfig.thinkingBudget": 0 },
+        maxRetries: 1,
+        reason: "Empty response \u2014 try with thinking off."
+      },
+      {
+        signal: "malformed_function_call",
+        action: "escalate",
+        reason: "MALFORMED_FUNCTION_CALL maps to stop \u2014 escalate to next target."
+      }
+    ],
+    strengths: ["low_cost", "speed", "volume", "classification", "summarize", "1m_context", "cache_friendly"],
+    weaknesses: ["complex_reasoning", "large_tool_sets", "complex_schemas", "structured_output_unproven", "long_context_quality"],
+    notes: 'Onboarded s91 (2026-08-27) as the Google-named successor to availability-restricted gemini-2.5-flash-lite. $0.30/$2.50 per 1M, 1M context, 65K max output, cache $0.03/M (10\xD7 discount). "Fastest, most cost-effective 3.5 model for high-throughput execution." Cliffs hypothesized from the Flash family \u2014 brain evidence pending.',
+    // Lite-tier floor for summarize/classify chains. ZERO brain rows — all
+    // values are starter hypotheses anchored to the Flash-Lite family shape.
+    archetypePerf: {
+      classify: 6,
+      // starter hypothesis — verify (Flash is 7, lite likely ≤)
+      summarize: 6,
+      // starter hypothesis — verify; cliff strips tools
+      transform: 6,
+      // starter hypothesis — verify
+      ask: 5,
+      hunt: 5,
+      generate: 4,
+      extract: 4,
+      plan: 3,
+      critique: 3
+    }
+  },
+  // ─────────────────────────────────────────────────────────────────────────
+  // Gemini 3.5 Flash — hand-onboarded s37 (2026-05-21)
+  //
+  // Google positioning ("Most intelligent for sustained frontier performance
+  // on agentic and coding tasks" / "particularly effective for rapid agentic
+  // loops involving complex coding cycles and iterations") suggests this is
+  // the Flash-family upgrade specifically aimed at hunt-shape workloads.
+  // Pricing 5× input / 3.6× output vs 2.5-flash — material cost premium.
+  // archetypePerf adjusted +1 vs 2.5-flash on ask/generate/plan/critique
+  // (sustained-frontier positioning); hunt held at 9 inherited from L-040
+  // family parallel-tool tier; brain evidence will validate within 50 rows.
+  //
+  // Cliffs inherited conservatively from 2.5-flash. Google's "sustained
+  // frontier on long-context" positioning suggests the 8K cliff may not
+  // apply to 3.5 — keep as guard until brain evidence shows otherwise.
+  //
+  // Specs verified against:
+  //   ai.google.dev/gemini-api/docs/models/gemini-3.5-flash
+  //   ai.google.dev/gemini-api/docs/pricing (Standard tier)
+  // ─────────────────────────────────────────────────────────────────────────
+  {
+    id: "gemini-3.5-flash",
+    verifiedAgainstDocs: "2026-05-21",
+    provider: "google",
+    status: "current",
+    maxContextTokens: 1048576,
+    maxOutputTokens: 65536,
+    maxTools: 128,
+    parallelToolCalls: true,
+    structuredOutput: "native",
+    systemPromptMode: "separate",
+    streaming: true,
+    cliffs: [
+      {
+        metric: "input_tokens",
+        threshold: 8e3,
+        action: "downgrade_quality_warning",
+        reason: "Inherited from 2.5-flash guard; Google positions 3.5 as sustained-frontier-on-long-context but brain evidence pending"
+      },
+      {
+        metric: "tool_count",
+        threshold: 20,
+        action: "drop_to_top_relevant",
+        reason: "Inherited from Flash family: tool reliability drops above ~20 (despite 128 hard limit). Validate per (archetype, model) after n\u226520."
+      },
+      {
+        metric: "thinking_with_short_output",
+        threshold: 1,
+        action: "force_thinking_budget_zero",
+        reason: "Thinking mode supported per Google docs; same drain risk as 2.5-flash \u2014 thinking tokens consume maxOutputTokens"
+      },
+      {
+        // Inherited from 2.5-flash s11 trust artifact (5/5 empty rate on
+        // tt-intelligence/summarize/gemini-2.5-flash with tools offered).
+        // Family-likely failure mode for Flash architecture across versions.
+        // Keep preemptively until brain evidence on 3.5-flash specifically.
+        metric: "tool_count",
+        threshold: 1,
+        whenIntent: "summarize",
+        action: "strip_tools",
+        reason: "Inherited from 2.5-flash s11 cliff (kgauto commit 3872832): summarize+tools \u2192 empty response. Preemptive guard until brain evidence on 3.5-flash specifically."
+      }
+    ],
+    costInputPer1m: 1.5,
+    costOutputPer1m: 9,
+    lowering: {
+      ...GOOGLE_LOWERING_BASE,
+      // 10× cache discount per Google pricing: $0.15/M cached vs $1.50/M input.
+      cache: { ...GOOGLE_LOWERING_BASE.cache, discount: 0.1 },
+      thinking: { field: "generationConfig.thinkingConfig.thinkingBudget", default: "auto" }
+    },
+    recovery: [
+      {
+        signal: "empty_response_after_tool",
+        action: "retry_with_params",
+        retryParams: { "generationConfig.thinkingConfig.thinkingBudget": 0 },
+        maxRetries: 1,
+        reason: "Inherited Flash-family pattern: empty after tool result \u2014 retry with thinking off"
+      },
+      {
+        signal: "empty_response",
+        action: "retry_with_params",
+        retryParams: { "generationConfig.thinkingConfig.thinkingBudget": 0 },
+        maxRetries: 1,
+        reason: "Empty response \u2014 try with thinking off"
+      },
+      {
+        signal: "malformed_function_call",
+        action: "escalate",
+        reason: "MALFORMED_FUNCTION_CALL maps to stop \u2014 escalate to next target"
+      }
+    ],
+    strengths: ["agentic_loops", "coding", "1m_context", "parallel_tools", "thinking_mode", "sustained_frontier"],
+    weaknesses: ["cost_vs_2_5_flash", "no_brain_evidence_yet"],
+    notes: "Hand-onboarded s37 (2026-05-21) verified against Google docs. Stable status; positioned as Flash-family upgrade for agentic loops and coding. 5\xD7/3.6\xD7 more expensive than 2.5-flash but Google claims step-change on sustained frontier work. archetypePerf adjustments are judgment-grounded starter hypotheses \u2014 brain evidence will validate within ~50 rows per archetype.",
+    // Starter hypothesis: anchored to 2.5-flash archetypePerf with +1
+    // adjustments where Google's positioning explicitly supports
+    // (agentic/coding/sustained). Hunt held at 9 inherited from L-040 family
+    // parallel-tool tier. Brain evidence will replace.
+    archetypePerf: {
+      hunt: 9,
+      // Inherited from 2.5-flash L-040 parallel-tool tier; Google positions 3.5 as agentic-loop champion
+      classify: 7,
+      // Inherited from 2.5-flash brain-validated tier (218 rows on 2.5)
+      summarize: 7,
+      // Inherited from 2.5-flash; cliff strips tools when present
+      transform: 7,
+      ask: 8,
+      // +1 vs 2.5-flash — sustained-frontier positioning
+      generate: 8,
+      // +1 vs 2.5-flash (6→8) — Google: "complex coding cycles and iterations"
+      plan: 7,
+      // +1 vs 2.5-flash (5→7) — "complex iterations" positioning
+      extract: 7,
+      // +1 vs 2.5-flash — sustained-frontier on structured tasks
+      critique: 5
+      // +1 vs 2.5-flash — but still below Sonnet/Opus reasoning floor
+    }
+  },
+  // ─────────────────────────────────────────────────────────────────────────
+  // gemini-3.6-flash — hand-onboarded s86 (2026-08-14), step-zero against
+  // Google docs (models/gemini-3.6-flash page + pricing via catalog-sync's
+  // two-agreeing-extraction the same day). Docs list it as Stable and call
+  // it "previous-generation Flash" (3.5-flash is now "legacy" in Google's
+  // wording) — but kgauto status is 'preview' per the standing entry rule:
+  // a new model enters on capability data verified only at the docs level,
+  // preview is unreachable by starter chains, and promotion to routing
+  // happens through brain evidence, not through Google's marketing tier.
+  // This also means NO family-primary retarget rides this release.
+  // ─────────────────────────────────────────────────────────────────────────
+  {
+    id: "gemini-3.6-flash",
+    verifiedAgainstDocs: "2026-08-24",
+    versionAdded: "2.0.0-alpha.87",
+    provider: "google",
+    status: "preview",
+    maxContextTokens: 1048576,
+    maxOutputTokens: 65536,
+    maxTools: 128,
+    parallelToolCalls: true,
+    structuredOutput: "native",
+    systemPromptMode: "separate",
+    streaming: true,
+    cliffs: [
+      {
+        metric: "input_tokens",
+        threshold: 8e3,
+        action: "downgrade_quality_warning",
+        reason: "Inherited Flash-family guard (2.5\u21923.5 lineage); no 3.6 brain evidence yet"
+      },
+      {
+        metric: "tool_count",
+        threshold: 20,
+        action: "drop_to_top_relevant",
+        reason: "Inherited from Flash family: tool reliability drops above ~20 (despite 128 hard limit). Validate per (archetype, model) after n\u226520."
+      },
+      {
+        metric: "thinking_with_short_output",
+        threshold: 1,
+        action: "force_thinking_budget_zero",
+        reason: "Thinking supported per Google docs; same drain risk as 2.5/3.5-flash \u2014 thinking tokens consume maxOutputTokens"
+      },
+      {
+        metric: "tool_count",
+        threshold: 1,
+        whenIntent: "summarize",
+        action: "strip_tools",
+        reason: "Inherited from 2.5-flash s11 cliff: summarize+tools \u2192 empty response. Preemptive family guard until brain evidence on 3.6-flash specifically."
+      }
+    ],
+    costInputPer1m: 0.75,
+    // promo through 2026-12-31; $1.50 from 2027-01-01 (TIME_BOUNDED_PRICING_ROWS carries the transition)
+    costOutputPer1m: 3.75,
+    // promo through 2026-12-31; $7.50 from 2027-01-01
+    lowering: {
+      ...GOOGLE_LOWERING_BASE,
+      cache: { ...GOOGLE_LOWERING_BASE.cache, discount: 0.1 },
+      thinking: { field: "generationConfig.thinkingConfig.thinkingBudget", default: "auto" }
+    },
+    recovery: [
+      {
+        signal: "empty_response_after_tool",
+        action: "retry_with_params",
+        retryParams: { "generationConfig.thinkingConfig.thinkingBudget": 0 },
+        maxRetries: 1,
+        reason: "Inherited Flash-family pattern: empty after tool result \u2014 retry with thinking off"
+      },
+      {
+        signal: "empty_response",
+        action: "retry_with_params",
+        retryParams: { "generationConfig.thinkingConfig.thinkingBudget": 0 },
+        maxRetries: 1,
+        reason: "Empty response \u2014 try with thinking off"
+      },
+      {
+        signal: "malformed_function_call",
+        action: "escalate",
+        reason: "MALFORMED_FUNCTION_CALL maps to stop \u2014 escalate to next target"
+      }
+    ],
+    strengths: ["agentic_loops", "coding", "1m_context", "parallel_tools", "thinking_mode"],
+    weaknesses: ["no_brain_evidence_yet"],
+    notes: "Hand-onboarded s86 (2026-08-14), step-zero verified: 1,048,576 ctx / 65,536 out (Google model page). PRICING re-verified 2026-08-24 at publish: $0.75/$3.75 promo through 2026-12-31, $1.50/$7.50 from 2027-01-01 \u2014 the alpha.87 profile carried the post-promo rate as if current; corrected alpha.88. Docs status Stable; enters kgauto as preview per standing rule (availability != lifecycle, promotion via brain evidence). Function calling + structured outputs + thinking per docs; parallel tools assumed per Flash family (docs silent). First flagged by the release watcher s73 (2026-07-24); ~21 days in the onboarding queue (onboarded 2026-08-14).",
+    archetypePerf: {
+      hunt: 9,
+      // Flash-family parallel-tool tier (L-040); inherited from 3.5-flash
+      classify: 7,
+      summarize: 7,
+      transform: 7,
+      ask: 8,
+      generate: 8,
+      plan: 7,
+      extract: 7,
+      critique: 5
+    }
+  },
+  {
+    // Auto-onboarded 2026-07-01 from `claude-sonnet-4-6`; VERIFIED 2026-07-02
+    // against the claude-api reference (cc-portfolio ratification pass). The
+    // clone got context right (1M). PRICING RE-BASED 2026-08-14 (s86): the
+    // introductory $2/$10 was made PERMANENT — Anthropic's pricing page now
+    // states the scheduled Sept-1 increase to $3/$15 "will not occur", so
+    // $2/$10 IS the sticker. (The $3/$15 encoded 07-02 was correct under the
+    // time-bounded-pricing convention at the time; the bound was cancelled.) The clone got max output WRONG:
+    // Sonnet 5 is 128k, not 4-6's 64k — corrected. New tokenizer (~30% more
+    // tokens for the same text vs 4-6): byte-budget consumers should re-baseline.
+    // API quirks (claude-api ref): (a) NON-DEFAULT temperature/top_p/top_k
+    // return 400 — moot for kgauto's own call() path (ANTHROPIC_LOWERING_BASE
+    // emits no sampling params) but a REAL hazard for compileForAISDKv6
+    // consumers that pass temperature themselves (tt-intel scoring uses temp:0
+    // for determinism — that 400s on this model; noted to consumers via the
+    // contract). (b) Omitting `thinking` runs ADAPTIVE by default (4-6 ran
+    // thinking-off) — output spend shifts. (c) Supports effort xhigh. status:
+    // 'preview' per the Fable precedent — no brain evidence yet; promotion to
+    // 'current' is an explicit call. (L-049/L-081.)
+    id: "claude-sonnet-5",
+    verifiedAgainstDocs: "2026-08-14",
+    provider: "anthropic",
+    status: "current",
+    // s76 2026-07-25: GA per docs; was preview.
+    maxContextTokens: 1e6,
+    maxOutputTokens: 128e3,
+    maxTools: 64,
+    parallelToolCalls: true,
+    structuredOutput: "grammar",
+    systemPromptMode: "inline",
+    streaming: true,
+    cliffs: [],
+    costInputPer1m: 2,
+    // 2026-08-24: intro price made PERMANENT (docs: "the previously scheduled increase to $3/$15 on September 1, 2026 will not occur")
+    costOutputPer1m: 10,
+    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: "Sonnet 5 (2026-06): near-Opus quality on coding/agentic work at Sonnet cost. Verified 2026-07-02 against the claude-api reference: 1M ctx, 128k out (clone's 64k corrected), $3/$15 sticker (intro $2/$10 through 2026-08-31). New tokenizer ~30% more tokens vs sonnet-4-6. Consumer hazards: non-default temperature/top_p/top_k 400 (temp:0 rejected \u2014 deterministic-scoring consumers must omit); thinking defaults to adaptive when omitted. status:preview \u2014 no brain evidence yet; earns placement via the machinery.",
+    // 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
+    }
+  },
+  // ── Z.ai (GLM) ──
+  // alpha.65 (2026-07-18): first Z.ai profile, provider `zai` added same
+  // release. Step-zero sources (L-049/L-081, all fetched 2026-07-18):
+  // docs.z.ai/guides/llm/glm-5.2 (capabilities), docs.z.ai api-reference
+  // chat-completion (wire params: thinking.type enabled|disabled default
+  // enabled, reasoning_effort max..none, tool_stream, max output 131072),
+  // docs.z.ai/guides/overview/pricing ($1.4 in / $4.4 out, cached input
+  // $0.26, cache storage limited-time free), vLLM recipe (native ctx
+  // 1,048,576). NO AI-trained numbers.
+  {
+    id: "glm-5.2",
+    verifiedAgainstDocs: "2026-07-18",
+    provider: "zai",
+    status: "preview",
+    maxContextTokens: 1048576,
+    maxOutputTokens: 131072,
+    // No documented tool-count cap — conservative default pending measured
+    // evidence; matches the deepseek posture, not a doc number.
+    maxTools: 16,
+    // Hosted-API docs document tools + tool_choice + tool_stream but say
+    // NOTHING about multiple tool_calls per response. Conservative false so
+    // hunt-shaped ranking doesn't over-promise; flip on doc or probe
+    // evidence (L-081: undocumented ≠ true).
+    parallelToolCalls: false,
+    structuredOutput: "native",
+    systemPromptMode: "inline",
+    streaming: true,
+    cliffs: [],
+    costInputPer1m: 1.4,
+    costOutputPer1m: 4.4,
+    lowering: {
+      system: { mode: "inline" },
+      // Automatic prefix caching ("intelligent caching mechanism") — no wire
+      // marker to emit, DeepSeek-style. Cache-hit input $0.26/M (~0.19× of
+      // miss) tracked in notes; storage limited-time free as of 2026-07-18.
+      cache: { strategy: "unsupported" },
+      tools: { format: "openai" },
+      // thinking.type: 'enabled' (server default) | 'disabled'. lowerZai
+      // emits an explicit disable only on forceThinkingZero cliffs.
+      thinking: { field: "thinking.type", default: "auto" }
+    },
+    recovery: [
+      { signal: "rate_limit", action: "escalate", reason: "429 \u2014 escalate" },
+      { signal: "model_not_found", action: "escalate", reason: "Deprecated \u2014 escalate (L-061)" }
+    ],
+    strengths: ["cost", "1m_context", "code", "tool_use", "json_output", "reasoning"],
+    weaknesses: ["parallel_tools"],
+    notes: "GLM-5.2 (Z.ai, 2026-06): agentic-coding flagship. 1,048,576 ctx / 131,072 max out. $1.40/$4.40 per 1M; cached input $0.26/M (automatic caching, no marker; storage limited-time free as of 2026-07-18). Thinking on by default (`thinking.type`), `reasoning_effort` max..none. Parallel tool calls UNDOCUMENTED on the hosted API \u2014 profile says false until doc or probe evidence. status:preview \u2014 no brain evidence yet; earns placement via the machinery.",
+    // Starter hypotheses — verify with telemetry/probes; NO brain evidence
+    // yet. Anchored on the vendor's agentic-coding positioning at a
+    // mid-cost tier, discounted for the unproven parallel-tool story.
+    archetypePerf: {
+      generate: 7,
+      // agentic-coding positioning — starter hypothesis
+      transform: 7,
+      // starter hypothesis
+      plan: 7,
+      // starter hypothesis
+      summarize: 7,
+      // tolerant archetype — starter hypothesis
+      ask: 6,
+      extract: 6,
+      critique: 6,
+      classify: 6,
+      hunt: 5
+      // tools work; parallel unproven → discounted
+    }
+  },
+  // ── Moonshot (Kimi) ──
+  // alpha.65 (2026-07-18): first Moonshot profile, provider `moonshot` added
+  // same release. Step-zero sources (all fetched 2026-07-18):
+  // platform.kimi.ai/docs/pricing/chat-k3 ($3.00 cache-miss in / $0.30
+  // cache-hit in / $15.00 out; 1,048,576 ctx; ToolCalls + JSON Mode +
+  // Partial Mode), kimi-k3-quickstart (max_completion_tokens default
+  // 131072, up to 1,048,576; base https://api.moonshot.ai/v1; vision via
+  // base64 or ms://file-id, NO public image URLs), models-overview
+  // (temperature FIXED 1.0, top_p FIXED 0.95, n FIXED 1, always reasons,
+  // reasoning_effort 'max' only), tool-calls guide ("can choose to call
+  // multiple tools at once … will tend to call them in parallel").
+  {
+    id: "kimi-k3",
+    verifiedAgainstDocs: "2026-07-18",
+    provider: "moonshot",
+    status: "preview",
+    maxContextTokens: 1048576,
+    // Documented ceiling; default is 131,072 when unset.
+    maxOutputTokens: 1048576,
+    // No hard doc cap; docs recommend dynamic tool loading at "dozens or
+    // hundreds" — 64 matches the frontier-agentic posture (sonnet-5 tier).
+    maxTools: 64,
+    parallelToolCalls: true,
+    structuredOutput: "native",
+    systemPromptMode: "inline",
+    streaming: true,
+    cliffs: [],
+    costInputPer1m: 3,
+    costOutputPer1m: 15,
+    lowering: {
+      system: { mode: "inline" },
+      // Automatic context caching — no wire marker. Cache-hit input $0.30/M
+      // (0.1× of miss) tracked in notes.
+      cache: { strategy: "unsupported" },
+      tools: { format: "openai" }
+      // No thinking knob: reasoning is always-on and reasoning_effort
+      // accepts only 'max' (= the server default). Nothing to lower.
+    },
+    recovery: [
+      { signal: "rate_limit", action: "escalate", reason: "429 \u2014 escalate" },
+      { signal: "model_not_found", action: "escalate", reason: "Deprecated \u2014 escalate (L-061)" }
+    ],
+    strengths: ["quality", "reasoning", "1m_context", "parallel_tools", "tool_use", "code", "vision"],
+    // 'latency' → latencyTierOf derives 'slow': always-on max-effort
+    // reasoner with no off switch; no measured p50 yet, the tag is the
+    // honest prior (reasoner family precedent: deepseek-v4-pro ~48s).
+    weaknesses: ["cost", "latency"],
+    notes: "Kimi K3 (Moonshot, API live 2026-07-16): 2.8T-param open-weight flagship, native vision. 1,048,576 ctx; max_completion_tokens default 131,072, ceiling 1,048,576. $3.00/$15.00 per 1M, cache-hit input $0.30/M (automatic caching). Reasoning ALWAYS ON (reasoning_effort max only, cannot disable; responses may carry reasoning_content). Wire quirks: temperature fixed 1.0 / top_p 0.95 / n 1 (kgauto never emits those); vision input must be base64 or ms://file-id \u2014 public image URLs rejected. status:preview \u2014 earns placement via the machinery.",
+    // Starter hypotheses — verify with telemetry/probes; NO brain evidence
+    // yet. Anchored on documented long-horizon-agentic + parallel-tool
+    // strengths; discounted on terse archetypes where always-on reasoning
+    // bills $15/M output for thinking the archetype doesn't need.
+    archetypePerf: {
+      hunt: 8,
+      // parallel tools + long-horizon agentic — starter hypothesis
+      plan: 8,
+      // starter hypothesis
+      generate: 8,
+      // starter hypothesis
+      critique: 7,
+      ask: 7,
+      extract: 7,
+      transform: 7,
+      summarize: 6,
+      // works, but $15/M output reasoning tax on a tolerant archetype
+      classify: 5
+      // always-on reasoning cost + reasoner hedge risk
+    },
+    // Diagnostics-only (no prompt rewrite): reasoner-family hedge risk on
+    // decisive archetypes, carried as a warning until K3-specific probe
+    // evidence exists. The deepseek-reasoner family showed 8/10 judge
+    // rationales citing hedging on classify (exclusion-finding ID 20,
+    // 2026-05-28); K3 is an always-on reasoner and inherits the risk class,
+    // not the conviction.
+    archetypeConventions: [
+      {
+        archetype: "classify",
+        cliffWarning: "kimi-k3 is an always-on reasoner: decisive archetypes (classify) may hedge, and reasoning tokens bill at $15/M output. Family-prior risk (deepseek-reasoner precedent), not K3-measured \u2014 probe before relying on it for classify.",
+        reason: "Reasoner-family prior (exclusion-finding ID 20, 2026-05-28, deepseek-v4-pro on tt-intel/classify). No K3-specific evidence yet \u2014 warning only, no prompt rewrite."
+      }
+    ]
+  }
+];
+var ALIASES = {
+  // DeepSeek's own model routing — both names served by V4-Flash.
+  "deepseek-chat": "deepseek-v4-flash",
+  "deepseek-reasoner": "deepseek-v4-flash",
+  // Legacy kgauto typo — actual API alias is dash-form (alpha.1 had dot).
+  "claude-haiku-4.5": "claude-haiku-4-5"
+};
+var brainHook = {};
+function canonicalId(id) {
+  return brainHook.resolveAlias?.(id) ?? ALIASES[id] ?? id;
+}
+var CONSUMER_INDEX = /* @__PURE__ */ new Map();
+function resolveModelAlias(id) {
+  return canonicalId(id);
+}
+var PROFILE_INDEX = new Map(
+  PROFILES_RAW.map((p) => [p.id, p])
+);
+function tryGetProfile(id) {
+  const canonical = canonicalId(id);
+  return CONSUMER_INDEX.get(canonical) ?? brainHook.getProfile?.(canonical) ?? PROFILE_INDEX.get(canonical);
+}
+function allProfiles() {
+  return PROFILES_RAW;
+}
+
+// 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);
+}
+
+// src/brain-query.ts
+var FRESH_SNAPSHOT = {
+  data: null,
+  expiresAt: 0,
+  refreshing: false,
+  warned: false
+};
+var snapshot = { ...FRESH_SNAPSHOT };
+var runtime;
+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);
+}
+
+// src/chains-brain.ts
+function isChainsRow(x) {
+  if (!x || typeof x !== "object") return false;
+  const r = x;
+  return typeof r.archetype === "string" && typeof r.tier === "number" && typeof r.model_id === "string";
+}
+function mapRowsToChains(rows) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (!isChainsRow(row)) continue;
+    const list = grouped.get(row.archetype) ?? [];
+    list.push(row);
+    grouped.set(row.archetype, list);
+  }
+  const out = {};
+  for (const [archetype, group] of grouped.entries()) {
+    group.sort((a, b) => a.tier - b.tier);
+    out[archetype] = group.map((r) => r.model_id);
+  }
+  const bundled = getAllStarterChains();
+  for (const archetype of Object.keys(bundled)) {
+    if (!out[archetype]) out[archetype] = bundled[archetype];
+  }
+  return out;
+}
+var loadChainsFromBrain = createBrainQueryCache({
+  table: "kgauto_chains",
+  mapRows: mapRowsToChains,
+  bundledFallback: getAllStarterChains
+});
+
+// src/policy-match.ts
+function canonicalPolicySet(ids) {
+  const set = /* @__PURE__ */ new Set();
+  for (const id of ids ?? []) set.add(resolveModelAlias(id));
+  return set;
+}
+function policySetHas(set, modelId) {
+  if (set.size === 0) return false;
+  return set.has(resolveModelAlias(modelId));
+}
+
+// src/archetype-perf-brain.ts
+function isPerfRow(x) {
+  if (!x || typeof x !== "object") return false;
+  const r = x;
+  return typeof r.model_id === "string" && typeof r.archetype === "string" && typeof r.perf_score === "number";
+}
+function mapRowsToPerfMap(rows) {
+  const out = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (!isPerfRow(row)) continue;
+    const existing = out.get(row.model_id) ?? {};
+    existing[row.archetype] = row.perf_score;
+    out.set(row.model_id, existing);
+  }
+  return out;
+}
+function mapRowsToNMap(rows) {
+  const out = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (!isPerfRow(row)) continue;
+    if (typeof row.n !== "number") continue;
+    const existing = out.get(row.model_id) ?? {};
+    existing[row.archetype] = row.n;
+    out.set(row.model_id, existing);
+  }
+  return out;
+}
+function bundledArchetypePerf() {
+  const out = /* @__PURE__ */ new Map();
+  for (const profile of allProfiles()) {
+    if (profile.archetypePerf) out.set(profile.id, profile.archetypePerf);
+  }
+  return out;
+}
+function bundledArchetypePerfN() {
+  return /* @__PURE__ */ new Map();
+}
+var loadArchetypePerfFromBrain = createBrainQueryCache({
+  table: "kgauto_archetype_perf",
+  mapRows: mapRowsToPerfMap,
+  bundledFallback: bundledArchetypePerf
+});
+var loadArchetypePerfNFromBrain = createBrainQueryCache(
+  {
+    table: "kgauto_archetype_perf",
+    mapRows: mapRowsToNMap,
+    bundledFallback: bundledArchetypePerfN
+  }
+);
+var MEASURED_GROUNDING_MIN_N = 10;
+function getArchetypePerfScore(modelId, archetype) {
+  const score = loadArchetypePerfFromBrain().get(modelId)?.[archetype] ?? 5;
+  const n = loadArchetypePerfNFromBrain().get(modelId)?.[archetype] ?? 0;
+  const grounding = n >= MEASURED_GROUNDING_MIN_N ? "measured" : "judgment";
+  return { score, n, grounding };
+}
+
+// src/compatibility.ts
+var ARCHETYPE_FLOOR_DEFAULT = 6;
+
+// src/fallback.ts
+var COST_RANKING_REFERENCE_SHAPE = {
+  inputTokens: 4e3,
+  outputTokens: 250
+};
+function estimateModelCostUsd(profile, shape = COST_RANKING_REFERENCE_SHAPE) {
+  if (!profile || typeof profile !== "object" || Array.isArray(profile) || typeof profile.costInputPer1m !== "number" || typeof profile.costOutputPer1m !== "number") {
+    throw new TypeError(
+      `estimateModelCostUsd: expected a single ModelProfile, got ${Array.isArray(profile) ? "an array (a chain? map over it)" : typeof profile}. For a chain: chain.map((id) => estimateModelCostUsd(getProfile(id))).`
+    );
+  }
+  return shape.inputTokens / 1e6 * profile.costInputPer1m + shape.outputTokens / 1e6 * profile.costOutputPer1m;
+}
+var estimateChainCostUsd = estimateModelCostUsd;
+function buildCostOrderedChain(archetype) {
+  return allProfiles().filter((p) => p.status === "current").filter(
+    (p) => getArchetypePerfScore(p.id, archetype).score >= ARCHETYPE_FLOOR_DEFAULT
+  ).map((p) => ({ p, cost: estimateChainCostUsd(p) })).sort((a, b) => a.cost - b.cost || a.p.id.localeCompare(b.p.id)).map((e) => e.p.id);
+}
+var STARTER_CHAINS_GROUNDED = {
+  // Reasoning floor — never degrade. Walk UP on 429 to Opus → cross-provider.
+  critique: [
+    { id: "claude-opus-5", grounding: "judgment", reason: "Highest reasoning bar, no degradation tier \u2014 engineer pick, awaiting measured backing. alpha.90: retargeted from legacy claude-opus-4-7 (Opus 5 generation current since 2026-07-25; same drift class as the b3d919b judge default)" },
+    { id: "claude-sonnet-5", grounding: "judgment", reason: "Same-provider walk-down from Opus on 429. alpha.90: retargeted from legacy claude-sonnet-4-6" },
+    // alpha.86: gemini-2.5-pro dropped — availability-restricted (tt-intel
+    // measured 4/4 cohort refusal 2026-08-02; kgauto key free-tier-quota
+    // 429 2026-08-08). No current Google model clears the critique floor
+    // (3.5-flash critique=5; 3.1-pro-preview scores 10 but is preview —
+    // default chains carry promoted models only). deepseek-v4-pro takes the
+    // third-provider tail instead.
+    { id: "gpt-5.5", grounding: "judgment", reason: "alpha.16: third-provider frontier-tier floor (archetypePerf=9)" },
+    { id: "deepseek-v4-pro", grounding: "judgment", reason: "alpha.86: third-provider tail replacing availability-restricted gemini-2.5-pro \u2014 critique=6 clears the floor exactly; last-resort when Anthropic AND OpenAI are down, not a quality peer of the tiers above" }
+  ],
+  // 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-5", grounding: "judgment", reason: "Highest reasoning bar for pairwise verdicts \u2014 current opus. alpha.90: retargeted from legacy claude-opus-4-8, matching DEFAULT_JUDGE_MODEL (moved in b3d919b); verdict comparability preserved by judge_model on every run/case row" },
+    { id: "claude-sonnet-5", grounding: "judgment", reason: "Same-provider walk-down on 429. alpha.90: retargeted from legacy claude-sonnet-4-6" },
+    // alpha.86: gemini-2.5-pro dropped (availability-restricted; see critique
+    // note). gpt-5.5 remains the cross-provider frontier floor for verdicts.
+    { id: "gpt-5.5", grounding: "judgment", reason: "Third-provider frontier-tier floor" },
+    { id: "deepseek-v4-pro", grounding: "judgment", reason: "alpha.86: third-provider tail replacing availability-restricted gemini-2.5-pro \u2014 native structured output per the judge contract; last-resort tier" }
+  ],
+  // Reasoning matters — Sonnet primary; walk UP to Opus on 429.
+  plan: [
+    { id: "claude-sonnet-5", grounding: "judgment", reason: "Reasoning + cost balance \u2014 engineer pick. alpha.90: retargeted from legacy claude-sonnet-4-6" },
+    { id: "claude-opus-5", grounding: "judgment", reason: 'Same-provider walk-UP on 429 (rare exception to "always cheaper"). alpha.90: retargeted from legacy claude-opus-4-7' },
+    { id: "gemini-3.5-flash", grounding: "judgment", reason: "alpha.86: cross-provider anchor \u2014 replaces availability-restricted gemini-2.5-pro (tt-intel 4/4 cohort refusal 2026-08-02; probed serving 200 on kgauto key 2026-08-08)" },
+    { 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-5", grounding: "judgment", reason: "Quality + cost match \u2014 engineer pick. alpha.90: retargeted from legacy claude-sonnet-4-6" },
+    { id: "claude-haiku-4-5", grounding: "judgment", reason: "Same-provider step-down" },
+    { id: "gemini-3.5-flash", grounding: "judgment", reason: "alpha.86: cross-provider anchor \u2014 replaces availability-restricted gemini-2.5-pro (tt-intel 4/4 cohort refusal 2026-08-02; probed serving 200 on kgauto key 2026-08-08)" },
+    { 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-5", grounding: "judgment", reason: "Quality + cost match \u2014 engineer pick. alpha.90: retargeted from legacy claude-sonnet-4-6 (whose tt-intel s78 27% empty rate was never validated; the empty-rate NOTE does not transfer to sonnet-5 \u2014 fresh model, fresh measurement)" },
+    { id: "claude-haiku-4-5", grounding: "judgment", reason: "Same-provider step-down" },
+    { id: "gemini-3.5-flash", grounding: "judgment", reason: "alpha.86: cross-provider anchor \u2014 replaces availability-restricted gemini-2.5-pro (tt-intel 4/4 cohort refusal 2026-08-02; probed serving 200 on kgauto key 2026-08-08)" },
+    { 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-5", grounding: "judgment", reason: "Reliable structured-output anchor \u2014 engineer pick. alpha.90: retargeted from legacy claude-sonnet-4-6 (which served the believe-card endpoint's first real call 2026-08-26 while daily-ops had been advising consumers OFF it for weeks)" },
+    { id: "claude-haiku-4-5", grounding: "judgment", reason: "Same-provider step-down with native structured output" },
+    { id: "gemini-3.5-flash", grounding: "judgment", reason: "alpha.86: cross-provider anchor with native structured output \u2014 replaces availability-restricted gemini-2.5-pro" },
+    { 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-5", grounding: "judgment", reason: "Quality anchor \u2014 engineer pick. alpha.90: retargeted from legacy claude-sonnet-4-6" },
+    { id: "claude-haiku-4-5", grounding: "judgment", reason: "Same-provider step-down" },
+    { id: "gemini-3.5-flash", grounding: "judgment", reason: "alpha.86: cross-provider anchor \u2014 replaces availability-restricted gemini-2.5-pro (tt-intel 4/4 cohort refusal 2026-08-02; probed serving 200 on kgauto key 2026-08-08)" },
+    { 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-3.5-flash", grounding: "capability-fact", reason: "alpha.86: parallel-tool agentic tier (hunt archetypePerf 9, L-040 family) \u2014 replaces availability-restricted gemini-2.5-pro" },
+    { id: "claude-sonnet-5", grounding: "judgment", reason: "Quality safety net for blocked-Flash case. alpha.90: retargeted from legacy claude-sonnet-4-6" },
+    { 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-3.5-flash-lite", grounding: "judgment", reason: "Emergency floor. alpha.91: retargeted from availability-restricted gemini-2.5-flash-lite (Google refuses it for new accounts, TT-49 2026-08-26); 3.5-flash-lite is the successor Google\u2019s own error names" },
+    { 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-3.5-flash-lite", grounding: "judgment", reason: "Cache-discount 10\xD7 floor for repeat-prompt workloads ($0.03/M cached). alpha.91: retargeted from availability-restricted gemini-2.5-flash-lite" },
+    { 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-5",
+        grounding: "judgment",
+        reason: "Cross-provider safety net \u2014 Sonnet handles sequential agentic loops cleanly. alpha.90: retargeted from legacy claude-sonnet-4-6"
+      },
+      {
+        id: "gemini-3.5-flash",
+        grounding: "judgment",
+        reason: "alpha.86: third-provider tail when no DeepSeek key reachable \u2014 replaces availability-restricted gemini-2.5-pro"
+      }
+    ]
+  }
+};
+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,
+    optimizeFor = "quality"
+  } = opts;
+  if (maxDepth < 1) {
+    throw new Error(
+      `getDefaultFallbackChain: maxDepth must be >= 1, got ${maxDepth}`
+    );
+  }
+  const allChains = loadChainsFromBrain();
+  const qualityStarter = resolveStarterForMode(archetype, toolOrchestration, allChains);
+  if (!qualityStarter) {
+    throw new Error(
+      `getDefaultFallbackChain: unknown archetype "${archetype}". Known: ${Object.keys(allChains).join(", ")}`
+    );
+  }
+  const starter = optimizeFor === "cost" ? buildCostOrderedChain(archetype) : qualityStarter;
+  let chain;
+  if (primary) {
+    chain = [primary, ...starter.filter((id) => id !== primary)];
+  } else {
+    chain = [...starter];
+  }
+  if (policy?.blockedModels && policy.blockedModels.length > 0) {
+    const blocked = canonicalPolicySet(policy.blockedModels);
+    chain = chain.filter((id) => !policySetHas(blocked, 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 getAllStarterChains() {
+  const out = {};
+  for (const [archetype, chain] of Object.entries(STARTER_CHAINS)) {
+    out[archetype] = [...chain];
+  }
+  return out;
+}
+
+// src/glassbox-routes/counterfactuals.ts
+var COUNTERFACTUAL_MIN_SAVINGS_RATIO = 0.1;
+var COUNTERFACTUAL_MAX_RESULTS = 2;
+function computeCounterfactuals(args) {
+  const {
+    servedModel,
+    servedCostUsd,
+    archetype,
+    tokensIn,
+    tokensOut,
+    cacheReadInputTokens = 0,
+    toolOrchestration
+  } = args;
+  if (tokensIn <= 0) return [];
+  if (servedCostUsd <= 0) return [];
+  let chain;
+  try {
+    chain = getDefaultFallbackChain({
+      archetype,
+      posture: "open",
+      maxDepth: 10,
+      toolOrchestration
+    });
+  } catch {
+    return [];
+  }
+  const candidates = [];
+  const minSavings = servedCostUsd * COUNTERFACTUAL_MIN_SAVINGS_RATIO;
+  for (const modelId of chain) {
+    if (modelId === servedModel) continue;
+    const profile = tryGetProfile(modelId);
+    if (!profile) continue;
+    const perf = profile.archetypePerf?.[archetype] ?? 5;
+    if (perf < ARCHETYPE_FLOOR_DEFAULT) continue;
+    const estimated = estimateCostUsd({
+      profile,
+      tokensIn,
+      tokensOut,
+      cacheReadInputTokens
+    });
+    if (estimated === void 0) continue;
+    const savings = servedCostUsd - estimated;
+    if (savings < minSavings) continue;
+    const savingsPercent = Math.round(savings / servedCostUsd * 100);
+    const reason = buildReason({
+      modelId,
+      archetype,
+      perf,
+      profile
+    });
+    candidates.push({
+      modelId,
+      estimatedCostUsd: round6(estimated),
+      savingsUsd: round6(savings),
+      savingsPercent,
+      reason
+    });
+  }
+  candidates.sort((a, b) => a.estimatedCostUsd - b.estimatedCostUsd);
+  return candidates.slice(0, COUNTERFACTUAL_MAX_RESULTS);
+}
+function estimateCostUsd(args) {
+  const { profile, tokensIn, tokensOut, cacheReadInputTokens } = args;
+  const cacheableIn = Math.min(cacheReadInputTokens, tokensIn);
+  const nonCachedIn = Math.max(tokensIn - cacheableIn, 0);
+  const discount = profile.lowering.cache.discount ?? 1;
+  const inUsd = nonCachedIn / 1e6 * profile.costInputPer1m + cacheableIn / 1e6 * profile.costInputPer1m * discount;
+  const outUsd = tokensOut / 1e6 * profile.costOutputPer1m;
+  const total = inUsd + outUsd;
+  if (!Number.isFinite(total)) return void 0;
+  if (total < 0) return void 0;
+  return total;
+}
+function round6(n) {
+  return Math.round(n * 1e6) / 1e6;
+}
+function buildReason(args) {
+  const { modelId, archetype, perf, profile } = args;
+  const hook = profile.strengths?.[0];
+  const suffix = hook ? `, ${hook.replace(/_/g, " ")}` : "";
+  return `${modelId} on ${archetype}: archetypePerf=${perf}${suffix}`;
+}
+
+// src/glassbox-routes/projected-cost.ts
+var INSUFFICIENT_VOLUME_THRESHOLD = 5;
+var WINDOW_DAYS = 7;
+async function computeProjectedDailyCost(args) {
+  const {
+    appId,
+    archetype,
+    servedCostUsd,
+    brainEndpoint,
+    brainJwt,
+    brainAnonKey,
+    fetch: fetchImpl
+  } = args;
+  if (!appId || !archetype) return void 0;
+  if (!Number.isFinite(servedCostUsd) || servedCostUsd <= 0) return void 0;
+  const doFetch = fetchImpl ?? ((...a) => globalThis.fetch(...a));
+  const base = brainEndpoint.replace(/\/+$/, "");
+  const cutoffIso = new Date(
+    Date.now() - WINDOW_DAYS * 24 * 60 * 60 * 1e3
+  ).toISOString();
+  const qs = new URLSearchParams();
+  qs.set("app_id", `eq.${appId}`);
+  qs.set("intent_archetype", `eq.${archetype}`);
+  qs.set("created_at", `gte.${cutoffIso}`);
+  qs.set("select", "handle");
+  qs.set("limit", "0");
+  const url = `${base}/rest/v1/compile_outcomes?${qs.toString()}`;
+  let res;
+  try {
+    res = await doFetch(url, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${brainJwt}`,
+        apikey: brainAnonKey,
+        Accept: "application/json",
+        // Triggers PostgREST exact count in Content-Range header.
+        Prefer: "count=exact"
+      }
+    });
+  } catch {
+    return void 0;
+  }
+  if (!res.ok) return void 0;
+  const contentRange = res.headers.get("content-range");
+  const count = parseContentRangeCount(contentRange);
+  if (count === void 0) return void 0;
+  const avgPerDay = count / WINDOW_DAYS;
+  if (avgPerDay < INSUFFICIENT_VOLUME_THRESHOLD) return void 0;
+  const projected = avgPerDay * servedCostUsd;
+  return Math.round(projected * 1e6) / 1e6;
+}
+function parseContentRangeCount(header) {
+  if (!header) return void 0;
+  const slash = header.lastIndexOf("/");
+  if (slash < 0) return void 0;
+  const tail = header.slice(slash + 1).trim();
+  if (tail === "*" || tail === "") return void 0;
+  const n = Number.parseInt(tail, 10);
+  if (!Number.isFinite(n) || n < 0) return void 0;
+  return n;
+}
+
+// src/glassbox-routes/proxy.ts
+var JSON_HEADERS2 = {
+  "Content-Type": "application/json",
+  "Cache-Control": "no-store"
+};
+var DEFAULT_LIMIT = 20;
+var MAX_LIMIT = 100;
+function jsonResponse(status, body) {
+  return new Response(JSON.stringify(body), { status, headers: JSON_HEADERS2 });
+}
+function jsonError2(status, code) {
+  return jsonResponse(status, { error: code });
+}
+function applyScrub(row, scrub) {
+  if (!scrub || row == null || typeof row !== "object") return row;
+  try {
+    return scrub(row);
+  } catch {
+    return row;
+  }
+}
+function parseLimit(raw) {
+  if (!raw) return DEFAULT_LIMIT;
+  const n = Number.parseInt(raw, 10);
+  if (!Number.isFinite(n) || n <= 0) return DEFAULT_LIMIT;
+  return Math.min(n, MAX_LIMIT);
+}
+function rowToSummary(row) {
+  return {
+    traceId: typeof row.handle === "string" ? row.handle : "",
+    appId: typeof row.app_id === "string" ? row.app_id : "",
+    archetype: typeof row.intent_archetype === "string" ? row.intent_archetype : "",
+    target: typeof row.model === "string" ? row.model : "",
+    createdAt: typeof row.created_at === "string" ? row.created_at : "",
+    tokensIn: typeof row.tokens_in === "number" ? row.tokens_in : 0,
+    tokensOut: typeof row.tokens_out === "number" ? row.tokens_out : 0,
+    estimatedCostUsd: typeof row.cost_usd_actual === "number" ? row.cost_usd_actual : 0
+  };
+}
+var INPUT_RATIO_YELLOW = 0.65;
+var INPUT_RATIO_RED = 0.85;
+var CACHE_HEALTH_MIN_TOKENS = 1e3;
+var CACHE_RATIO_GREEN = 0.5;
+var CACHE_RATIO_YELLOW = 0.1;
+var FALLBACK_REASONS = /* @__PURE__ */ new Set([
+  "rate_limit",
+  "provider_auth_failed",
+  "provider_billing_exhausted",
+  "provider_error",
+  "cliff",
+  "cost_cap",
+  "contract_violation"
+]);
+function asString(v) {
+  return typeof v === "string" && v.length > 0 ? v : void 0;
+}
+function asNumber(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : void 0;
+}
+function asNumberOrZero(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : 0;
+}
+function asStringArray(v) {
+  if (!Array.isArray(v)) return [];
+  const out = [];
+  for (const e of v) {
+    if (typeof e === "string") out.push(e);
+  }
+  return out;
+}
+function asFallbackReason(v) {
+  if (typeof v !== "string") return void 0;
+  const candidate = v;
+  if (candidate && FALLBACK_REASONS.has(candidate)) return candidate;
+  return "provider_error";
+}
+function rowToAdvisory(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const r = raw;
+  const level = r.level;
+  const code = r.code;
+  const message = r.message;
+  if (level !== "info" && level !== "warn" && level !== "critical" || typeof code !== "string" || typeof message !== "string") {
+    return void 0;
+  }
+  const out = { level, code, message };
+  const suggestion = asString(r.suggestion);
+  if (suggestion) out.suggestion = suggestion;
+  const docsUrl = asString(r.docs_url ?? r.docsUrl);
+  if (docsUrl) out.docsUrl = docsUrl;
+  const adapter = toAdapter(r.suggested_adaptation ?? r.suggestedAdaptation);
+  if (adapter) out.suggestedAdaptation = adapter;
+  return out;
+}
+var SECTION_KINDS = /* @__PURE__ */ new Set([
+  "role_intro",
+  "tool_call_contract",
+  "narration_contract",
+  "discipline_contract",
+  "user_turn",
+  "reference",
+  "arbitrary"
+]);
+function summarizeSectionRewrite(kind, rule) {
+  if (kind === "tool_call_contract" && rule === "sequential-tool-cliff-below-floor") {
+    return "Sequential tool pattern applied (model cliff cleared at compile time).";
+  }
+  if (kind === "narration_contract" && rule === "narration-drift-anthropic") {
+    return "Narration tightened for Anthropic dialect (terse-log shape preserved).";
+  }
+  if (kind === "narration_contract" && rule === "narration-thinking-leak-deepseek") {
+    return "Thinking-block suppression applied (DeepSeek V4 internal reasoning kept off-wire).";
+  }
+  if (kind === "discipline_contract" && rule === "discipline-gates-v1") {
+    return "Discipline gates applied (surface-scaffolding: evidence-before-reasoning, one-extra-signal, source-labeling).";
+  }
+  return `Translator applied rule "${rule}" to ${kind} section.`;
+}
+function rowToSectionRewrite(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const r = raw;
+  const sectionId = r.sectionId ?? r.section_id;
+  if (typeof sectionId !== "string" || sectionId.length === 0) return void 0;
+  const kind = r.kind;
+  if (typeof kind !== "string" || !SECTION_KINDS.has(kind)) {
+    return void 0;
+  }
+  const rule = r.rule;
+  if (typeof rule !== "string" || rule.length === 0) return void 0;
+  return {
+    sectionId,
+    kind,
+    rule,
+    summary: summarizeSectionRewrite(kind, rule)
+  };
+}
+function toAdapter(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const a = raw;
+  if (a.parameter === "toolOrchestration" && a.value === "sequential" && typeof a.consequence === "string") {
+    return {
+      parameter: "toolOrchestration",
+      value: "sequential",
+      consequence: a.consequence
+    };
+  }
+  return void 0;
+}
+function computeHealth(args) {
+  const {
+    tokensIn,
+    tokensOut,
+    historyCacheableTokens,
+    inputCacheHitRatio,
+    fellOverFrom,
+    target
+  } = args;
+  const total = tokensIn + tokensOut;
+  const ratio = total > 0 ? tokensIn / total : 0;
+  let inputRatioStatus;
+  if (ratio > INPUT_RATIO_RED) inputRatioStatus = "red";
+  else if (ratio > INPUT_RATIO_YELLOW) inputRatioStatus = "yellow";
+  else inputRatioStatus = "green";
+  let cacheStatus;
+  if (historyCacheableTokens <= CACHE_HEALTH_MIN_TOKENS) {
+    cacheStatus = "na";
+  } else if (inputCacheHitRatio >= CACHE_RATIO_GREEN) {
+    cacheStatus = "green";
+  } else if (inputCacheHitRatio >= CACHE_RATIO_YELLOW) {
+    cacheStatus = "yellow";
+  } else {
+    cacheStatus = "red";
+  }
+  const fallbackStatus = fellOverFrom !== void 0 && fellOverFrom !== target ? "red" : "green";
+  return { inputRatioStatus, cacheStatus, fallbackStatus };
+}
+function rowToDetail(row) {
+  const summary = rowToSummary(row);
+  const tokensIn = summary.tokensIn;
+  const tokensOut = summary.tokensOut;
+  const cacheReadInputTokens = asNumberOrZero(row.cache_read_input_tokens);
+  const cacheCreationInputTokens = asNumberOrZero(
+    row.cache_creation_input_tokens
+  );
+  const historyCacheableTokens = asNumberOrZero(row.history_cacheable_tokens);
+  const inputCacheHitRatio = tokensIn > 0 ? cacheReadInputTokens / tokensIn : 0;
+  const fellOverFrom = asString(row.fell_over_from);
+  const fallbackReasonRaw = row.fallback_reason;
+  const fallbackReason = fellOverFrom ? asFallbackReason(fallbackReasonRaw) : void 0;
+  const requestedModel = asString(row.requested_model) ?? fellOverFrom;
+  const advisoriesRaw = Array.isArray(row.advisories) ? row.advisories : [];
+  const advisories = [];
+  for (const a of advisoriesRaw) {
+    const rec = rowToAdvisory(a);
+    if (rec) advisories.push(rec);
+  }
+  const health = computeHealth({
+    tokensIn,
+    tokensOut,
+    cacheReadInputTokens,
+    historyCacheableTokens,
+    inputCacheHitRatio,
+    fellOverFrom,
+    target: summary.target
+  });
+  const sectionRewritesRaw = Array.isArray(row.section_rewrites_applied) ? row.section_rewrites_applied : [];
+  const sectionRewritesApplied = [];
+  for (const e of sectionRewritesRaw) {
+    const rw = rowToSectionRewrite(e);
+    if (rw) sectionRewritesApplied.push(rw);
+  }
+  const detail = {
+    ...summary,
+    mutationsApplied: asStringArray(row.mutations_applied),
+    advisories,
+    rawRequest: asString(row.prompt_preview),
+    rawResponse: asString(row.response_preview),
+    requestedModel,
+    finishReason: asString(row.finish_reason),
+    ttftMs: asNumber(row.ttft_ms),
+    totalMs: asNumber(row.total_ms) ?? asNumber(row.latency_ms),
+    toolsCount: asNumber(row.tools_count),
+    historyDepth: asNumber(row.history_depth),
+    systemPromptChars: asNumber(row.system_prompt_chars),
+    cacheReadInputTokens,
+    cacheCreationInputTokens,
+    historyCacheableTokens,
+    inputCacheHitRatio,
+    fellOverFrom,
+    fallbackReason,
+    sectionRewritesApplied,
+    health
+  };
+  return detail;
+}
+function createProxyHandler(config) {
+  const {
+    installToken,
+    extensionId,
+    brainEndpoint,
+    brainJwt,
+    brainAnonKey,
+    appId,
+    scrub,
+    fetch: fetchImpl
+  } = config;
+  const doFetch = fetchImpl ?? ((...args) => globalThis.fetch(...args));
+  const base = brainEndpoint.replace(/\/+$/, "");
+  return async function proxy(req) {
+    const authFail = checkAuth(req, { installToken, extensionId });
+    if (authFail) return authFail;
+    const url = new URL(req.url);
+    const traceId = url.searchParams.get("traceId");
+    const limit = parseLimit(url.searchParams.get("limit"));
+    const qs = new URLSearchParams();
+    qs.set("app_id", `eq.${appId}`);
+    if (traceId) {
+      qs.set("handle", `eq.${traceId}`);
+    } else {
+      qs.set("order", "created_at.desc");
+      qs.set("limit", String(limit));
+    }
+    const brainUrl = `${base}/rest/v1/compile_outcomes?${qs.toString()}`;
+    let brainRes;
+    try {
+      brainRes = await doFetch(brainUrl, {
+        method: "GET",
+        headers: {
+          // Authorization carries the scoped JWT — drives RLS via app_id claim.
+          Authorization: `Bearer ${brainJwt}`,
+          // apikey MUST be one of the project's known keys (anon or
+          // service_role). Supabase rejects any other JWT here, even when
+          // HS256-signed with the same secret. Pre-alpha.24 this was set to
+          // brainJwt and silently 401'd against real Supabase. See L-117.
+          apikey: brainAnonKey,
+          Accept: "application/json"
+        }
+      });
+    } catch {
+      return jsonError2(502, "brain_unavailable");
+    }
+    if (brainRes.status === 401 || brainRes.status === 403) {
+      return jsonError2(500, "brain_auth_misconfig");
+    }
+    if (brainRes.status >= 500) {
+      return jsonError2(502, "brain_unavailable");
+    }
+    if (!brainRes.ok) {
+      return jsonError2(400, "bad_request");
+    }
+    let rows;
+    try {
+      rows = await brainRes.json();
+    } catch {
+      return jsonError2(502, "brain_unavailable");
+    }
+    if (!Array.isArray(rows)) {
+      return jsonError2(502, "brain_unavailable");
+    }
+    const scrubbed = rows.map(
+      (row) => applyScrub(row, scrub)
+    );
+    if (traceId) {
+      const first = scrubbed[0];
+      if (!first) return jsonError2(404, "not_found");
+      const detail = rowToDetail(first);
+      const counterfactuals = computeCounterfactuals({
+        servedModel: detail.target,
+        servedCostUsd: detail.estimatedCostUsd,
+        archetype: detail.archetype,
+        tokensIn: detail.tokensIn,
+        tokensOut: detail.tokensOut,
+        cacheReadInputTokens: detail.cacheReadInputTokens
+      });
+      detail.counterfactuals = counterfactuals;
+      if (detail.estimatedCostUsd > 0) {
+        const projected = await computeProjectedDailyCost({
+          appId: detail.appId,
+          archetype: detail.archetype,
+          servedCostUsd: detail.estimatedCostUsd,
+          brainEndpoint: base,
+          brainJwt,
+          brainAnonKey,
+          fetch: doFetch
+        });
+        if (projected !== void 0) {
+          detail.projectedDailyCostUsd = projected;
+        }
+      }
+      return jsonResponse(200, detail);
+    }
+    return jsonResponse(200, { traces: scrubbed.map(rowToSummary) });
+  };
+}
+
+// src/glassbox-routes/stream.ts
+var SSE_HEADERS = {
+  "Content-Type": "text/event-stream",
+  "Cache-Control": "no-cache, no-transform",
+  Connection: "keep-alive",
+  "X-Accel-Buffering": "no"
+};
+function applyScrub2(event, scrub) {
+  if (!scrub) return event;
+  try {
+    const out = scrub(event);
+    if (out && typeof out === "object" && typeof out.kind === "string" && typeof out.at === "number") {
+      return out;
+    }
+    return event;
+  } catch {
+    return event;
+  }
+}
+function sseFrame(eventName, data) {
+  const safeName = eventName.replace(/[\r\n]/g, "");
+  return `event: ${safeName}
+data: ${JSON.stringify(data)}
+
+`;
+}
+function createStreamHandler(config, subscribe2, subscribeApp2) {
+  const { installToken, extensionId, appId, scrub } = config;
+  return async function stream(req) {
+    const authFail = checkAuth(req, { installToken, extensionId });
+    if (authFail) return authFail;
+    const url = new URL(req.url);
+    const traceId = url.searchParams.get("traceId");
+    const source = traceId ? subscribe2(traceId) : subscribeApp2({ appId });
+    const encoder = new TextEncoder();
+    let sourceReader;
+    let cancelled = false;
+    const body = new ReadableStream({
+      async start(controller) {
+        controller.enqueue(encoder.encode(sseFrame("ready", {})));
+        sourceReader = source.getReader();
+        const signal = req.signal;
+        if (signal) {
+          if (signal.aborted) {
+            cancelled = true;
+            await sourceReader.cancel();
+            try {
+              controller.close();
+            } catch {
+            }
+            return;
+          }
+          signal.addEventListener(
+            "abort",
+            () => {
+              cancelled = true;
+              sourceReader?.cancel().catch(() => {
+              });
+              try {
+                controller.close();
+              } catch {
+              }
+            },
+            { once: true }
+          );
+        }
+        try {
+          while (!cancelled) {
+            const { value, done } = await sourceReader.read();
+            if (done) break;
+            const scrubbed = applyScrub2(value, scrub);
+            controller.enqueue(
+              encoder.encode(sseFrame(scrubbed.kind, scrubbed))
+            );
+          }
+        } catch {
+        } finally {
+          try {
+            controller.close();
+          } catch {
+          }
+          try {
+            sourceReader?.releaseLock();
+          } catch {
+          }
+        }
+      },
+      cancel() {
+        cancelled = true;
+        sourceReader?.cancel().catch(() => {
+        });
+      }
+    });
+    return new Response(body, { status: 200, headers: SSE_HEADERS });
+  };
+}
+
+// src/glassbox/types.ts
+var GLASSBOX_STREAM_TTL_MS = 6e4;
+
+// src/glassbox/pubsub-memory.ts
+var MemoryPubSub = class {
+  subscribers = /* @__PURE__ */ new Map();
+  async publish(channelKey, event) {
+    const subs = this.subscribers.get(channelKey);
+    if (!subs || subs.size === 0) return;
+    for (const sub of subs) {
+      if (sub.closed) continue;
+      try {
+        sub.controller.enqueue(event);
+      } catch {
+        sub.closed = true;
+        continue;
+      }
+      this.refreshTtl(channelKey, sub);
+    }
+  }
+  subscribe(channelKey) {
+    const self = this;
+    let sub;
+    return new ReadableStream({
+      start(controller) {
+        sub = {
+          controller,
+          ttlTimer: setTimeout(() => {
+            self.closeSubscriber(channelKey, sub);
+          }, GLASSBOX_STREAM_TTL_MS),
+          closed: false
+        };
+        let set = self.subscribers.get(channelKey);
+        if (!set) {
+          set = /* @__PURE__ */ new Set();
+          self.subscribers.set(channelKey, set);
+        }
+        set.add(sub);
+      },
+      cancel() {
+        if (sub) self.removeSubscriber(channelKey, sub);
+      }
+    });
+  }
+  /**
+   * Refresh the rolling TTL for a subscriber after an event lands. Replaces
+   * the existing timer with a fresh 60s one.
+   */
+  refreshTtl(channelKey, sub) {
+    clearTimeout(sub.ttlTimer);
+    sub.ttlTimer = setTimeout(() => {
+      this.closeSubscriber(channelKey, sub);
+    }, GLASSBOX_STREAM_TTL_MS);
+  }
+  /**
+   * Close the subscriber's stream cleanly and remove from the fan-out set.
+   * Idempotent — safe to call multiple times.
+   */
+  closeSubscriber(channelKey, sub) {
+    if (sub.closed) return;
+    sub.closed = true;
+    clearTimeout(sub.ttlTimer);
+    try {
+      sub.controller.close();
+    } catch {
+    }
+    this.removeSubscriber(channelKey, sub);
+  }
+  removeSubscriber(channelKey, sub) {
+    clearTimeout(sub.ttlTimer);
+    const set = this.subscribers.get(channelKey);
+    if (!set) return;
+    set.delete(sub);
+    if (set.size === 0) this.subscribers.delete(channelKey);
+  }
+  /**
+   * Test-only reset. Tears down all subscribers, clears all state. Calling
+   * outside of tests is harmless but cancels every active stream.
+   */
+  _reset() {
+    for (const [, set] of this.subscribers) {
+      for (const sub of set) {
+        this.closeSubscriber("", sub);
+      }
+    }
+    this.subscribers.clear();
+  }
+};
+
+// src/glassbox/pubsub-upstash.ts
+var UpstashPubSub = class {
+  url;
+  token;
+  fetchImpl;
+  blockMs;
+  maxLen;
+  constructor(cfg) {
+    this.url = cfg.url.replace(/\/$/, "");
+    this.token = cfg.token;
+    this.fetchImpl = cfg.fetchImpl ?? globalThis.fetch.bind(globalThis);
+    this.blockMs = cfg.blockMs ?? 100;
+    this.maxLen = cfg.maxLen ?? 100;
+  }
+  async publish(channelKey, event) {
+    const key = channelKey;
+    const payload = JSON.stringify(event);
+    await this.cmd([
+      "XADD",
+      key,
+      "MAXLEN",
+      "~",
+      String(this.maxLen),
+      "*",
+      "event",
+      payload
+    ]);
+    await this.cmd(["EXPIRE", key, String(Math.ceil(GLASSBOX_STREAM_TTL_MS / 1e3))]);
+  }
+  subscribe(channelKey) {
+    const key = channelKey;
+    const self = this;
+    let cursor = "$";
+    let cancelled = false;
+    let ttlDeadline = Date.now() + GLASSBOX_STREAM_TTL_MS;
+    return new ReadableStream({
+      async start(controller) {
+        try {
+          while (!cancelled && Date.now() < ttlDeadline) {
+            const resp = await self.cmd([
+              "XREAD",
+              "BLOCK",
+              String(self.blockMs),
+              "STREAMS",
+              key,
+              cursor
+            ]);
+            if (cancelled) break;
+            const parsed = parseXReadResult(resp.result);
+            if (parsed.entries.length === 0) {
+              continue;
+            }
+            for (const entry of parsed.entries) {
+              const evt = decodeEvent(entry.fields);
+              if (evt) {
+                try {
+                  controller.enqueue(evt);
+                } catch {
+                  cancelled = true;
+                  break;
+                }
+              }
+              cursor = entry.id;
+            }
+            ttlDeadline = Date.now() + GLASSBOX_STREAM_TTL_MS;
+          }
+        } catch (err) {
+          if (!cancelled) {
+            try {
+              controller.error(err);
+            } catch {
+            }
+            return;
+          }
+        }
+        try {
+          controller.close();
+        } catch {
+        }
+      },
+      cancel() {
+        cancelled = true;
+      }
+    });
+  }
+  async cmd(args) {
+    const res = await this.fetchImpl(this.url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(args)
+    });
+    if (!res.ok) {
+      throw new Error(`Upstash ${args[0]} failed: HTTP ${res.status}`);
+    }
+    const json = await res.json();
+    if (json.error) {
+      throw new Error(`Upstash ${args[0]} failed: ${json.error}`);
+    }
+    return json;
+  }
+};
+function traceChannel(traceId) {
+  return `glassbox:trace:${traceId}`;
+}
+function appChannel(appId) {
+  return `glassbox:app:${appId}`;
+}
+function decodeEvent(fields) {
+  const raw = fields["event"];
+  if (!raw) return void 0;
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.kind === "string" && typeof parsed.at === "number") {
+      return parsed;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function parseXReadResult(raw) {
+  if (!Array.isArray(raw)) return { entries: [] };
+  const entries = [];
+  for (const stream of raw) {
+    if (!Array.isArray(stream) || stream.length < 2) continue;
+    const streamEntries = stream[1];
+    if (!Array.isArray(streamEntries)) continue;
+    for (const entry of streamEntries) {
+      if (!Array.isArray(entry) || entry.length < 2) continue;
+      const id = String(entry[0]);
+      const flat = entry[1];
+      if (!Array.isArray(flat)) continue;
+      const fields = {};
+      for (let i = 0; i < flat.length; i += 2) {
+        const k = flat[i];
+        const v = flat[i + 1];
+        if (typeof k === "string") fields[k] = String(v ?? "");
+      }
+      entries.push({ id, fields });
+    }
+  }
+  return { entries };
+}
+
+// src/glassbox/emit.ts
+var activePubSub;
+function getPubSub() {
+  if (activePubSub) return activePubSub;
+  const url = readEnv("UPSTASH_REDIS_URL");
+  const token = readEnv("UPSTASH_REDIS_TOKEN");
+  if (url && token) {
+    activePubSub = new UpstashPubSub({ url, token });
+  } else {
+    activePubSub = new MemoryPubSub();
+  }
+  return activePubSub;
+}
+function readEnv(key) {
+  try {
+    if (typeof process !== "undefined" && process.env) {
+      const v = process.env[key];
+      return v && v.trim() !== "" ? v : void 0;
+    }
+  } catch {
+  }
+  return void 0;
+}
+
+// src/glassbox/subscribe.ts
+function emptyStream() {
+  return new ReadableStream({
+    start(controller) {
+      controller.close();
+    }
+  });
+}
+function subscribe(traceId) {
+  if (!traceId) return emptyStream();
+  return getPubSub().subscribe(traceChannel(traceId));
+}
+function subscribeApp({
+  appId
+}) {
+  if (!appId) return emptyStream();
+  return getPubSub().subscribe(appChannel(appId));
+}
+
+// src/glassbox-routes/index.ts
+function requireString(name, value) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`createGlassboxRoutes: ${name} is required`);
+  }
+  return value;
+}
+function createGlassboxRoutes(config) {
+  const installToken = requireString("installToken", config.installToken);
+  const extensionId = requireString("extensionId", config.extensionId);
+  const brainEndpoint = requireString("brainEndpoint", config.brainEndpoint);
+  const brainJwt = requireString("brainJwt", config.brainJwt);
+  const brainAnonKey = requireString("brainAnonKey", config.brainAnonKey);
+  const appId = requireString("appId", config.appId);
+  const proxy = createProxyHandler({
+    installToken,
+    extensionId,
+    brainEndpoint,
+    brainJwt,
+    brainAnonKey,
+    appId,
+    scrub: config.scrub,
+    fetch: config.fetch
+  });
+  const stream = createStreamHandler(
+    {
+      installToken,
+      extensionId,
+      appId,
+      scrub: config.scrub
+    },
+    config.subscribe ?? subscribe,
+    config.subscribeApp ?? subscribeApp
+  );
+  return { proxy, stream };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  COUNTERFACTUAL_MAX_RESULTS,
+  COUNTERFACTUAL_MIN_SAVINGS_RATIO,
+  computeCounterfactuals,
+  createGlassboxRoutes,
+  rowToDetail,
+  rowToSummary
+});