@warmdrift/kgauto-compiler 2.0.0-alpha.27 → 2.0.0-alpha.29

package/dist/index.mjs

@@ -9,6 +9,30 @@ import {
   isArchetype,
   learningKey
 } from "./chunk-5TI6PNSK.mjs";
+import {
+  ABSOLUTE_FLOOR,
+  ARCHETYPE_FLOOR_DEFAULT,
+  PROVIDER_ENV_KEYS,
+  configureBrainQuery,
+  createBrainQueryCache,
+  ensureCrossProviderTail,
+  getAllStarterChains,
+  getAllStarterChainsWithGrounding,
+  getDefaultFallbackChain,
+  getDefaultFallbackChainWithGrounding,
+  getModelCompatibility,
+  getPerAxisMetrics,
+  getReachabilityDiagnostic,
+  getSequentialStarterChain,
+  getSequentialStarterChainWithGrounding,
+  getStarterChain,
+  getStarterChainWithGrounding,
+  isBrainQueryActiveFor,
+  isModelReachable,
+  isProviderReachable,
+  loadChainsFromBrain,
+  resolveProviderKey
+} from "./chunk-WXCFWUCN.mjs";
 import {
   ALIASES,
   _setProfileBrainHook,
@@ -451,6 +475,7 @@ function lowerAnthropic(ir, profile, hints) {
   const historyCacheableTokens = markIndex >= 0 ? sumHistoryTokens(history, markIndex) : 0;
   const totalCacheableTokens = cacheableTokens + historyCacheableTokens;
   const cacheSavings = totalCacheableTokens / 1e6 * profile.costInputPer1m * (1 - (profile.lowering.cache.discount ?? 0.1));
+  const toolChoice = hints.wireOverrides?.parallelToolCalls === false && tools && tools.length > 0 ? { type: "auto", disable_parallel_tool_use: true } : void 0;
   return {
     request: {
       provider: "anthropic",
@@ -462,7 +487,8 @@ function lowerAnthropic(ir, profile, hints) {
       // floor surprised every consumer once (PB-Cairn contract-gaps brief, Gap 3).
       // Profile is the single source of truth; consumers wanting a tighter
       // budget can pass providerOverrides.anthropic.max_tokens explicitly.
-      max_tokens: hints.forceTerseOutput ? 200 : profile.maxOutputTokens
+      max_tokens: hints.forceTerseOutput ? 200 : profile.maxOutputTokens,
+      tool_choice: toolChoice
     },
     diagnostics: {
       cacheableTokens,
@@ -656,6 +682,7 @@ function lowerOpenAI(ir, profile, hints) {
   const history = (ir.history ?? []).filter((m) => m.role !== "system");
   const histMarkIndex = resolveHistoryMarkIndex(history.length, ir.historyCachePolicy);
   const historyCacheableTokens = histMarkIndex >= 0 ? sumHistoryTokens(history, histMarkIndex) : 0;
+  const openaiParallelToolCalls = hints.wireOverrides?.parallelToolCalls === false && ir.tools && ir.tools.length > 0 ? false : void 0;
   return {
     request: {
       provider: "openai",
@@ -663,7 +690,8 @@ function lowerOpenAI(ir, profile, hints) {
       messages,
       tools: ir.tools && ir.tools.length > 0 ? toOpenAITools(ir.tools) : void 0,
       response_format: ir.constraints?.structuredOutput ? { type: "json_object" } : void 0,
-      reasoning_effort: hints.forceTerseOutput ? "low" : void 0
+      reasoning_effort: hints.forceTerseOutput ? "low" : void 0,
+      parallel_tool_calls: openaiParallelToolCalls
     },
     diagnostics: {
       cacheableTokens: 0,
@@ -740,177 +768,6 @@ function setNestedField(obj, path, value) {
   cursor[parts[parts.length - 1]] = value;
 }
 
-// src/brain-query.ts
-var FRESH_SNAPSHOT = {
-  data: null,
-  expiresAt: 0,
-  refreshing: false,
-  warned: false
-};
-var snapshot = { ...FRESH_SNAPSHOT };
-var runtime;
-function configureBrainQuery(rt) {
-  runtime = rt;
-  snapshot = { ...FRESH_SNAPSHOT };
-}
-function createBrainQueryCache(opts) {
-  return () => {
-    const rt = runtime;
-    if (!rt || !rt.enabledTables.has(opts.table)) {
-      return opts.bundledFallback();
-    }
-    const now = Date.now();
-    const stale = snapshot.expiresAt <= now;
-    if (stale && !snapshot.refreshing) {
-      snapshot.refreshing = true;
-      void asyncRefresh(rt);
-    }
-    if (snapshot.data) {
-      const rows = snapshot.data[opts.table];
-      if (Array.isArray(rows) && rows.length > 0) {
-        try {
-          return opts.mapRows(rows);
-        } catch {
-          return opts.bundledFallback();
-        }
-      }
-    }
-    return opts.bundledFallback();
-  };
-}
-var pendingRefresh;
-async function asyncRefresh(rt) {
-  const promise = doRefresh(rt);
-  pendingRefresh = promise;
-  try {
-    await promise;
-  } finally {
-    if (pendingRefresh === promise) pendingRefresh = void 0;
-  }
-}
-var DEFAULT_CONFIG_URL = "https://kgauto-dashboard.vercel.app/api/kgauto-v2/config";
-async function doRefresh(rt) {
-  const url = rt.configEndpoint ?? DEFAULT_CONFIG_URL;
-  try {
-    const res = await rt.fetchImpl(url, { method: "GET" });
-    if (!res.ok) {
-      throw new Error(`brain-query ${res.status}: ${res.statusText}`);
-    }
-    const body = await res.json();
-    if (runtime !== rt) return;
-    snapshot = {
-      data: body,
-      expiresAt: Date.now() + rt.ttlMs,
-      refreshing: false,
-      warned: snapshot.warned
-    };
-  } catch (err) {
-    if (runtime !== rt) return;
-    snapshot.refreshing = false;
-    snapshot.expiresAt = Date.now() + rt.ttlMs;
-    if (!snapshot.warned) {
-      snapshot.warned = true;
-      (rt.onError ?? defaultOnError)(err);
-    }
-  }
-}
-function defaultOnError(err) {
-  console.warn("[kgauto] brain-query failed (using bundled fallback):", err);
-}
-function isBrainQueryActiveFor(table) {
-  return runtime !== void 0 && runtime.enabledTables.has(table);
-}
-async function getPerAxisMetrics(opts) {
-  const fetchFn = opts.fetch ?? fetch;
-  const endpoint = opts.endpoint ?? runtime?.endpoint;
-  if (!endpoint) return null;
-  const windowDays = opts.windowDays ?? 30;
-  const body = {
-    p_app_id: opts.appId,
-    p_archetype: opts.archetype,
-    p_model: opts.model,
-    p_window_days: windowDays,
-    p_quality_floor: opts.qualityFloor ?? null
-  };
-  const headers = {
-    Accept: "application/json",
-    "Content-Type": "application/json",
-    ...opts.apiKey ? { Authorization: `Bearer ${opts.apiKey}` } : {}
-  };
-  try {
-    const res = await fetchFn(`${endpoint}/rpc/get_per_axis_metrics`, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(body)
-    });
-    if (!res.ok) return null;
-    const raw = await res.json();
-    return mapPerAxisMetrics(raw, opts.appId, opts.archetype, opts.model, windowDays);
-  } catch {
-    return null;
-  }
-}
-function mapPerAxisMetrics(raw, fallbackAppId, fallbackArchetype, fallbackModel, fallbackWindowDays) {
-  if (raw === null || raw === void 0) return null;
-  if (typeof raw !== "object") return null;
-  const r = raw;
-  if (Array.isArray(raw)) {
-    if (raw.length === 0) return null;
-    return mapPerAxisMetrics(raw[0], fallbackAppId, fallbackArchetype, fallbackModel, fallbackWindowDays);
-  }
-  const num = (v) => {
-    if (v === null || v === void 0) return null;
-    if (typeof v === "number") return Number.isFinite(v) ? v : null;
-    if (typeof v === "string") {
-      const n = Number(v);
-      return Number.isFinite(n) ? n : null;
-    }
-    return null;
-  };
-  const int = (v) => {
-    const n = num(v);
-    return n === null ? 0 : Math.trunc(n);
-  };
-  const bool = (v) => {
-    if (v === null || v === void 0) return null;
-    if (typeof v === "boolean") return v;
-    return null;
-  };
-  const str = (v, fallback) => typeof v === "string" ? v : fallback;
-  const cost = r.cost_efficiency ?? {};
-  const time = r.time_efficiency ?? {};
-  const rel = r.reliability ?? {};
-  return {
-    appId: str(r.app_id, fallbackAppId),
-    archetype: str(r.archetype, fallbackArchetype),
-    model: str(r.model, fallbackModel),
-    windowDays: num(r.window_days) ?? fallbackWindowDays,
-    nRows: int(r.n_rows),
-    nRowsClean: int(r.n_rows_clean),
-    nQualityOutcomes: int(r.n_quality_outcomes),
-    magicRate: num(r.magic_rate),
-    qualityFloorMet: bool(r.quality_floor_met),
-    costEfficiency: {
-      avgCostUsd: num(cost.avg_cost_usd),
-      avgCostUsdClean: num(cost.avg_cost_usd_clean),
-      avgInputTokens: num(cost.avg_input_tokens),
-      avgOutputTokens: num(cost.avg_output_tokens),
-      inputTokenRatio: num(cost.input_token_ratio)
-    },
-    timeEfficiency: {
-      avgLatencyMs: num(time.avg_latency_ms),
-      avgTtftMs: num(time.avg_ttft_ms)
-    },
-    reliability: {
-      successRate: num(rel.success_rate),
-      successRateClean: num(rel.success_rate_clean),
-      emptyRate: num(rel.empty_rate),
-      emptyRateClean: num(rel.empty_rate_clean)
-    },
-    evidenceFreshnessDays: num(r.evidence_freshness_days)
-  };
-}
-
 // src/archetype-perf-brain.ts
 function isPerfRow(x) {
   if (!x || typeof x !== "object") return false;
@@ -984,8 +841,19 @@ function runAdvisor(ir, result, profile, policy, phase2) {
     out.push(...detectModelStaleEvidence(ir, profile));
     out.push(...detectTierDown(ir, profile, phase2));
   }
+  if (!translatorClearedToolCallCliff(phase2)) {
+    out.push(...detectArchetypePerfFloorBreach(ir, profile));
+  }
   return out;
 }
+function translatorClearedToolCallCliff(phase2) {
+  const rewrites = phase2?.sectionRewritesApplied;
+  if (!rewrites || rewrites.length === 0) return false;
+  for (const rw of rewrites) {
+    if (rw.kind === "tool_call_contract") return true;
+  }
+  return false;
+}
 function detectCachingOff(ir, profile) {
   if (profile.provider !== "anthropic") return [];
   const totalChars = ir.sections.reduce((s, sec) => s + sec.text.length, 0);
@@ -1154,6 +1022,77 @@ function detectTierDown(ir, profile, phase2) {
     }
   ];
 }
+function detectArchetypePerfFloorBreach(ir, profile) {
+  const compat = getModelCompatibility(profile.id, {
+    archetype: ir.intent.archetype,
+    toolOrchestration: ir.constraints?.toolOrchestration
+  });
+  if (compat.status === "compatible") return [];
+  if (compat.status === "requires-adapter") {
+    return [
+      {
+        level: "warn",
+        code: "archetype-perf-floor-breach",
+        message: `${profile.id} sits below the archetype floor for ${ir.intent.archetype} (score ${compat.archetypePerf}/10, floor ${6}). A known adapter would lift it: ${compat.adapter.parameter}=${compat.adapter.value}. ${compat.adapter.consequence}`,
+        suggestion: `Pass \`ir.constraints.${compat.adapter.parameter} = '${compat.adapter.value}'\` for this call, OR pick a model whose archetypePerf for ${ir.intent.archetype} already clears the floor (call \`getModelCompatibility(modelId, { archetype: '${ir.intent.archetype}' })\` to check). Estimated post-adapter score: ${compat.archetypePerfWithAdapter}/10.`,
+        recommendationType: "prompt-fix",
+        suggestedAdaptation: compat.adapter,
+        docsUrl: "https://github.com/stue/command-center/blob/main/interfaces/kgauto.md#best-practice-advisories"
+      }
+    ];
+  }
+  return [
+    {
+      level: "critical",
+      code: "archetype-perf-floor-breach",
+      message: `${profile.id} sits below the archetype floor for ${ir.intent.archetype} (score ${compat.archetypePerf}/10, floor ${6}) and no known adapter would lift it. ${compat.reason}`,
+      suggestion: `Swap to a model whose archetypePerf for ${ir.intent.archetype} clears the floor. Use \`getModelCompatibility(candidateId, { archetype: '${ir.intent.archetype}' })\` to vet candidates, or \`getDefaultFallbackChain({ archetype: '${ir.intent.archetype}', posture: 'open' })\` for a library-picked chain that respects the floor by construction.`,
+      recommendationType: "model-swap",
+      docsUrl: "https://github.com/stue/command-center/blob/main/interfaces/kgauto.md#best-practice-advisories"
+    }
+  ];
+}
+
+// src/translator.ts
+var TRANSLATOR_FLOOR = ARCHETYPE_FLOOR_DEFAULT;
+var RULE_SEQUENTIAL_TOOL_CLIFF = "sequential-tool-cliff-below-floor";
+var SEQUENTIAL_TOOL_PREAMBLE = "IMPORTANT: Use one tool call per response. Wait for the tool result before deciding the next tool. Do NOT batch tool calls in parallel.";
+function applySectionRewrites(args) {
+  const { ir, profile, archetype } = args;
+  if (!Array.isArray(ir.sections) || ir.sections.length === 0) {
+    return { rewrittenIR: ir, rewrites: [] };
+  }
+  if (!profile.archetypePerf) {
+    return { rewrittenIR: ir, rewrites: [] };
+  }
+  const archetypeScore = profile.archetypePerf[archetype];
+  const cliffFires = typeof archetypeScore === "number" && archetypeScore < TRANSLATOR_FLOOR;
+  if (!cliffFires) {
+    return { rewrittenIR: ir, rewrites: [] };
+  }
+  const rewrites = [];
+  const newSections = ir.sections.map((section) => {
+    if (section.kind !== "tool_call_contract") return section;
+    const originalText = section.text;
+    const transformedText = `${SEQUENTIAL_TOOL_PREAMBLE}
+
+${originalText}`;
+    rewrites.push({
+      sectionId: section.id,
+      kind: "tool_call_contract",
+      rule: RULE_SEQUENTIAL_TOOL_CLIFF,
+      originalText,
+      transformedText,
+      wireOverrides: { parallelToolCalls: false }
+    });
+    return { ...section, text: transformedText };
+  });
+  if (rewrites.length === 0) {
+    return { rewrittenIR: ir, rewrites: [] };
+  }
+  const rewrittenIR = { ...ir, sections: newSections };
+  return { rewrittenIR, rewrites };
+}
 
 // src/compile.ts
 var counter = 0;
@@ -1198,9 +1137,33 @@ function compile(ir, opts = {}) {
   const cliffs = passApplyCliffs(workingIR, profile, inputTokens);
   workingIR = cliffs.value.ir;
   accumulatedMutations.push(...cliffs.mutations);
+  const translated = applySectionRewrites({
+    ir: workingIR,
+    profile,
+    archetype: ir.intent.archetype
+  });
+  workingIR = translated.rewrittenIR;
+  const sectionRewritesApplied = translated.rewrites;
+  let wireOverrides;
+  for (const rw of sectionRewritesApplied) {
+    if (!rw.wireOverrides) continue;
+    if (!wireOverrides) wireOverrides = {};
+    if (rw.wireOverrides.parallelToolCalls !== void 0) {
+      wireOverrides.parallelToolCalls = rw.wireOverrides.parallelToolCalls;
+    }
+  }
+  for (const rw of sectionRewritesApplied) {
+    accumulatedMutations.push({
+      id: `translator:${rw.rule}:${rw.sectionId}`,
+      source: "translator",
+      passName: "translator",
+      description: `Rewrote section "${rw.sectionId}" (kind=${rw.kind}) via rule "${rw.rule}".`
+    });
+  }
   const lowered = lower(workingIR, profile, {
     forceThinkingZero: cliffs.value.loweringHints.forceThinkingZero,
-    forceTerseOutput: cliffs.value.loweringHints.forceTerseOutput
+    forceTerseOutput: cliffs.value.loweringHints.forceTerseOutput,
+    wireOverrides
   });
   validateFinalFit(workingIR, profile, inputTokens);
   const handle = makeHandle();
@@ -1248,7 +1211,13 @@ function compile(ir, opts = {}) {
     opts.policy,
     {
       fallbackChain,
-      profileResolver: phase2ProfileResolver
+      profileResolver: phase2ProfileResolver,
+      // alpha.29 — feed translator rewrites to the advisor so the
+      // `archetype-perf-floor-breach` rule can suppress when the translator
+      // already cleared the cliff for the same archetype. Without this,
+      // both the rewrite AND the advisory fire — noisy, and the advisory
+      // would mislead consumers into thinking the cliff is unaddressed.
+      sectionRewritesApplied
     }
   );
   return {
@@ -1261,7 +1230,9 @@ function compile(ir, opts = {}) {
     mutationsApplied: accumulatedMutations,
     fallbackChain,
     advisories,
-    diagnostics
+    diagnostics,
+    sectionRewritesApplied,
+    wireOverrides
   };
 }
 function validateIR(ir) {
@@ -1414,6 +1385,9 @@ function registerCompile(appId, archetype, ir, result) {
     tokens
   );
   const shapeKey = `${shape.contextBucket}-${shape.toolCountBucket}-${shape.historyDepth}-${shape.outputMode}`;
+  const toolsCount = result.diagnostics.toolsKept;
+  const historyDepth = Array.isArray(ir.history) ? ir.history.length : 0;
+  const systemPromptChars = estimateSystemPromptChars(ir.sections);
   compileRegistry.set(result.handle, {
     appId,
     archetype,
@@ -1427,9 +1401,28 @@ function registerCompile(appId, archetype, ir, result) {
     historyCacheableTokens: result.diagnostics.historyCacheableTokens,
     historyTokensTotal: result.diagnostics.historyTokensTotal,
     // alpha.20 E3: capture consumer's declared mode for the brain payload.
-    toolOrchestration: result.diagnostics.toolOrchestration
+    toolOrchestration: result.diagnostics.toolOrchestration,
+    // alpha.28: shape fields for Glass-Box renderer.
+    toolsCount,
+    historyDepth,
+    systemPromptChars,
+    // alpha.29: translator activity — persisted on the brain row so
+    // cross-app aggregates can answer "Sonnet narration rule fired N times,
+    // outcome quality lifted to M."
+    sectionRewritesApplied: result.sectionRewritesApplied
   });
 }
+function estimateSystemPromptChars(sections) {
+  if (!Array.isArray(sections) || sections.length === 0) return void 0;
+  let total = 0;
+  for (const s of sections) {
+    if (s && typeof s === "object") {
+      const content = s.content;
+      if (typeof content === "string") total += content.length;
+    }
+  }
+  return total > 0 ? total : void 0;
+}
 async function record(input) {
   const reg = compileRegistry.get(input.handle);
   if (reg) compileRegistry.delete(input.handle);
@@ -1466,7 +1459,7 @@ async function record(input) {
       }
       outcomeId = await tryExtractOutcomeId(res);
     } catch (err) {
-      (config.onError ?? defaultOnError2)(err);
+      (config.onError ?? defaultOnError)(err);
       return;
     }
     const advisories = input.advisories;
@@ -1488,7 +1481,7 @@ async function record(input) {
         throw new Error(`brain advisories ${res.status}: ${text}`);
       }
     } catch (err) {
-      (config.onError ?? defaultOnError2)(err);
+      (config.onError ?? defaultOnError)(err);
     }
   };
   if (config.sync) {
@@ -1497,7 +1490,7 @@ async function record(input) {
     void send();
   }
 }
-function defaultOnError2(err) {
+function defaultOnError(err) {
   console.warn("[kgauto] brain record failed:", err);
 }
 function buildPayload(input, reg) {
@@ -1507,6 +1500,8 @@ function buildPayload(input, reg) {
   const mutationsApplied = input.mutationsApplied ?? reg?.mutationsApplied ?? [];
   const costModel = actual;
   const costUsdActual = costModel ? computeCostUsd(costModel, input.tokensIn, input.tokensOut) : void 0;
+  const fellOverFrom = input.fellOverFrom ?? requested;
+  const fallbackReason = fellOverFrom ? input.fallbackReason : void 0;
   return {
     handle: input.handle,
     app_id: reg?.appId,
@@ -1541,7 +1536,20 @@ function buildPayload(input, reg) {
     // the brain can measure per-mode model perf separately (DeepSeek in
     // sequential vs parallel mode is two different stories — L-040).
     // Null when consumer hadn't adopted the constraint yet.
-    tool_orchestration: reg?.toolOrchestration ?? null
+    tool_orchestration: reg?.toolOrchestration ?? null,
+    // alpha.28 — Glass-Box renderer substrate (migration 018). All optional;
+    // omitted-undefined PostgREST inserts store NULL → renderer renders "—".
+    finish_reason: input.finishReason,
+    total_ms: input.totalMs ?? input.latencyMs,
+    tools_count: input.toolsCount ?? reg?.toolsCount,
+    history_depth: input.historyDepth ?? reg?.historyDepth,
+    system_prompt_chars: input.systemPromptChars ?? reg?.systemPromptChars,
+    fell_over_from: fellOverFrom,
+    fallback_reason: fallbackReason,
+    // alpha.29 — translator activity (migration 019). Send NULL when no
+    // rewrites fired so the brain's "did the translator do anything?"
+    // queries can use `IS NOT NULL` cleanly.
+    section_rewrites_applied: reg?.sectionRewritesApplied && reg.sectionRewritesApplied.length > 0 ? reg.sectionRewritesApplied : null
   };
 }
 function computeCostUsd(modelId, tokensIn, tokensOut) {
@@ -1614,12 +1622,12 @@ async function recordOutcome(input) {
       if (!res.ok) {
         const text = await res.text().catch(() => "<no body>");
         const err = new Error(`brain ${res.status}: ${text}`);
-        (config.onError ?? defaultOnError2)(err);
+        (config.onError ?? defaultOnError)(err);
         return { ok: false, reason: "persistence_failed" };
       }
       return { ok: true };
     } catch (err) {
-      (config.onError ?? defaultOnError2)(err);
+      (config.onError ?? defaultOnError)(err);
       return { ok: false, reason: "persistence_failed" };
     }
   };
@@ -1644,67 +1652,6 @@ var CallError = class extends Error {
   }
 };
 
-// src/env.ts
-var SUPPORTED_PROVIDERS = Object.freeze([
-  "anthropic",
-  "google",
-  "openai",
-  "deepseek"
-]);
-function isSupportedProvider(p) {
-  return SUPPORTED_PROVIDERS.includes(p);
-}
-var PROVIDER_ENV_KEYS = Object.freeze({
-  anthropic: Object.freeze(["ANTHROPIC_API_KEY"]),
-  google: Object.freeze([
-    "GOOGLE_API_KEY",
-    "GEMINI_API_KEY",
-    "GOOGLE_GENERATIVE_AI_API_KEY"
-  ]),
-  openai: Object.freeze(["OPENAI_API_KEY"]),
-  deepseek: Object.freeze(["DEEPSEEK_API_KEY"])
-});
-function defaultEnv() {
-  return typeof process !== "undefined" && process.env ? process.env : {};
-}
-function readKeyValue(raw) {
-  if (raw === void 0) return void 0;
-  const trimmed = raw.trim();
-  return trimmed.length > 0 ? trimmed : void 0;
-}
-function resolveProviderKey(provider, opts = {}) {
-  if (!isSupportedProvider(provider)) return void 0;
-  const explicit = readKeyValue(opts.apiKeys?.[provider]);
-  if (explicit) return explicit;
-  const env = opts.envSource ?? defaultEnv();
-  for (const name of PROVIDER_ENV_KEYS[provider]) {
-    const v = readKeyValue(env[name]);
-    if (v) return v;
-  }
-  return void 0;
-}
-function isProviderReachable(provider, opts = {}) {
-  return resolveProviderKey(provider, opts) !== void 0;
-}
-function isModelReachable(modelId, opts = {}) {
-  const profile = tryGetProfile(modelId);
-  if (!profile) return false;
-  return isProviderReachable(profile.provider, opts);
-}
-function getReachabilityDiagnostic(opts = {}) {
-  const env = opts.envSource ?? defaultEnv();
-  const out = {};
-  for (const provider of SUPPORTED_PROVIDERS) {
-    if (readKeyValue(opts.apiKeys?.[provider])) {
-      out[provider] = { reachable: true, via: "apiKeys" };
-      continue;
-    }
-    const envKeyFound = PROVIDER_ENV_KEYS[provider].find((name) => readKeyValue(env[name]));
-    out[provider] = envKeyFound ? { reachable: true, via: "env", envKeyFound } : { reachable: false, via: null };
-  }
-  return out;
-}
-
 // src/execute.ts
 var ANTHROPIC_URL = "https://api.anthropic.com/v1/messages";
 var OPENAI_URL = "https://api.openai.com/v1/chat/completions";
@@ -1923,344 +1870,6 @@ function tryParseJson(s) {
   }
 }
 
-// src/chains-brain.ts
-function isChainsRow(x) {
-  if (!x || typeof x !== "object") return false;
-  const r = x;
-  return typeof r.archetype === "string" && typeof r.tier === "number" && typeof r.model_id === "string";
-}
-function mapRowsToChains(rows) {
-  const grouped = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    if (!isChainsRow(row)) continue;
-    const list = grouped.get(row.archetype) ?? [];
-    list.push(row);
-    grouped.set(row.archetype, list);
-  }
-  const out = {};
-  for (const [archetype, group] of grouped.entries()) {
-    group.sort((a, b) => a.tier - b.tier);
-    out[archetype] = group.map((r) => r.model_id);
-  }
-  const bundled = getAllStarterChains();
-  for (const archetype of Object.keys(bundled)) {
-    if (!out[archetype]) out[archetype] = bundled[archetype];
-  }
-  return out;
-}
-var loadChainsFromBrain = createBrainQueryCache({
-  table: "kgauto_chains",
-  mapRows: mapRowsToChains,
-  bundledFallback: getAllStarterChains
-});
-
-// src/fallback.ts
-var STARTER_CHAINS_GROUNDED = {
-  // Reasoning floor — never degrade. Walk UP on 429 to Opus → cross-provider.
-  critique: [
-    { id: "claude-opus-4-7", grounding: "judgment", reason: "Highest reasoning bar, no degradation tier \u2014 engineer pick, awaiting measured backing" },
-    { id: "claude-sonnet-4-6", grounding: "judgment", reason: "Same-provider walk-down from Opus on 429" },
-    { id: "gemini-2.5-pro", grounding: "judgment", reason: "Cross-provider anchor in similar quality bracket" },
-    { id: "gpt-5.5", grounding: "judgment", reason: "alpha.16: third-provider frontier-tier floor (archetypePerf=9)" }
-  ],
-  // Reasoning matters — Sonnet primary; walk UP to Opus on 429.
-  plan: [
-    { id: "claude-sonnet-4-6", grounding: "judgment", reason: "Reasoning + cost balance \u2014 engineer pick" },
-    { id: "claude-opus-4-7", grounding: "judgment", reason: 'Same-provider walk-UP on 429 (rare exception to "always cheaper")' },
-    { id: "gemini-2.5-pro", grounding: "judgment", reason: "Cross-provider anchor" },
-    { id: "deepseek-v4-pro", grounding: "judgment", reason: "Tier 3 cost floor \u2014 no brain evidence yet" }
-  ],
-  // Quality + cost match.
-  generate: [
-    { id: "claude-sonnet-4-6", grounding: "judgment", reason: "Quality + cost match \u2014 engineer pick" },
-    { id: "claude-haiku-4-5", grounding: "judgment", reason: "Same-provider step-down" },
-    { id: "gemini-2.5-pro", grounding: "judgment", reason: "Cross-provider anchor" },
-    { id: "gpt-5.4-mini", grounding: "judgment", reason: "alpha.16: third-provider tail (archetypePerf=7) \u2014 closes mono-Anthropic gap" }
-  ],
-  // ask::sonnet — STARTER_CHAINS calls this "Quality + cost match" but
-  // tt-intel s78 prod data showed 27% empty rate. Labeled 'judgment' until
-  // evidence either validates or refutes the placement.
-  ask: [
-    { id: "claude-sonnet-4-6", grounding: "judgment", reason: "Quality + cost match \u2014 engineer pick. NOTE: tt-intel s78 prod showed 27% empty rate; placement awaits measurement validation" },
-    { id: "claude-haiku-4-5", grounding: "judgment", reason: "Same-provider step-down" },
-    { id: "gemini-2.5-pro", grounding: "judgment", reason: "Cross-provider anchor" },
-    { id: "gpt-5.4-mini", grounding: "judgment", reason: "alpha.16: third-provider tail (archetypePerf=7)" }
-  ],
-  // Structured-output archetype — Flash skipped (alpha.8 MAX_TOKENS cliff,
-  // capability-fact); DeepSeek skipped (no brain evidence).
-  extract: [
-    { id: "claude-sonnet-4-6", grounding: "judgment", reason: "Reliable structured-output anchor \u2014 engineer pick" },
-    { id: "claude-haiku-4-5", grounding: "judgment", reason: "Same-provider step-down with native structured output" },
-    { id: "gemini-2.5-pro", grounding: "judgment", reason: "Cross-provider anchor with structured-output support" },
-    { id: "gpt-5.4", grounding: "capability-fact", reason: "alpha.16: third-provider floor \u2014 native structured-output capability (archetypePerf=8)" }
-  ],
-  // Forgiving archetype — Sonnet primary but Flash safely floors it.
-  transform: [
-    { id: "claude-sonnet-4-6", grounding: "judgment", reason: "Quality anchor \u2014 engineer pick" },
-    { id: "claude-haiku-4-5", grounding: "judgment", reason: "Same-provider step-down" },
-    { id: "gemini-2.5-pro", grounding: "judgment", reason: "Cross-provider anchor" },
-    { id: "gemini-2.5-flash", grounding: "judgment", reason: "Cost floor \u2014 forgiving archetype tolerates Flash" }
-  ],
-  // Parallel-tool throughput champion — Flash leads on the L-040 cliff
-  // (capability-fact: Flash 15-75 parallel calls/step vs DeepSeek 7-8).
-  hunt: [
-    { id: "gemini-2.5-flash", grounding: "capability-fact", reason: "L-040 parallel-tool throughput champion (15-75 calls/step)" },
-    { id: "gemini-2.5-pro", grounding: "capability-fact", reason: "Cross-provider tier 1 with strong parallel-tool support" },
-    { id: "claude-sonnet-4-6", grounding: "judgment", reason: "Quality safety net for blocked-Flash case" },
-    { id: "claude-haiku-4-5", grounding: "judgment", reason: "Reduced tool budget \u2014 cliff at 16 fires" }
-  ],
-  // Cost-sensitive + tolerant. DeepSeek brain-evidence tier 1.
-  summarize: [
-    { id: "gemini-2.5-flash", grounding: "judgment", reason: "Cost-sensitive primary \u2014 engineer pick" },
-    { id: "deepseek-v4-flash", grounding: "measured", reason: "Brain-validated tier 1 for cost-sensitive summarize workloads", n: 169 },
-    { id: "claude-haiku-4-5", grounding: "judgment", reason: "Quality safety net" },
-    { id: "gemini-2.5-flash-lite", grounding: "judgment", reason: "Emergency floor \u2014 onboarded s22, no brain evidence yet" }
-  ],
-  // Brain-validated DeepSeek tier 1 (169 rows, 0% empty rate).
-  classify: [
-    { id: "gemini-2.5-flash", grounding: "judgment", reason: "Cost-sensitive primary \u2014 engineer pick" },
-    { id: "deepseek-v4-flash", grounding: "measured", reason: "Brain-validated tier 1 (169 rows, 0% empty rate)", n: 169 },
-    { id: "claude-haiku-4-5", grounding: "judgment", reason: "Quality safety net" },
-    { id: "gemini-2.5-flash-lite", grounding: "judgment", reason: "Cache-discount 10\xD7 floor for repeat-prompt workloads" }
-  ]
-};
-var STARTER_CHAINS = (() => {
-  const out = {};
-  for (const [archetype, entries] of Object.entries(STARTER_CHAINS_GROUNDED)) {
-    out[archetype] = entries.map((e) => e.id);
-  }
-  return out;
-})();
-var STARTER_CHAINS_BY_MODE_GROUNDED = {
-  hunt: {
-    sequential: [
-      {
-        id: "deepseek-v4-pro",
-        grounding: "judgment",
-        reason: "alpha.20 E3: cheap + good reasoning at single-step granularity; L-040 cliff silenced when sequential \u2014 hypothesis not yet measured"
-      },
-      {
-        id: "deepseek-v4-flash",
-        grounding: "judgment",
-        reason: "Cheapest viable; sibling-provider fallback"
-      },
-      {
-        id: "claude-sonnet-4-6",
-        grounding: "judgment",
-        reason: "Cross-provider safety net \u2014 Sonnet handles sequential agentic loops cleanly"
-      },
-      {
-        id: "gemini-2.5-pro",
-        grounding: "judgment",
-        reason: "Third-provider tail when no DeepSeek key reachable"
-      }
-    ]
-  }
-};
-var STARTER_CHAINS_BY_MODE = (() => {
-  const out = {};
-  for (const [archetype, modes] of Object.entries(STARTER_CHAINS_BY_MODE_GROUNDED)) {
-    if (modes?.sequential) {
-      out[archetype] = {
-        sequential: modes.sequential.map((e) => e.id)
-      };
-    }
-  }
-  return out;
-})();
-function resolveStarterForMode(archetype, toolOrchestration, allChains) {
-  if (toolOrchestration === "sequential") {
-    const overlay = STARTER_CHAINS_BY_MODE[archetype]?.sequential;
-    if (overlay) return [...overlay];
-  }
-  return allChains[archetype];
-}
-function getDefaultFallbackChain(opts) {
-  const { archetype, primary, maxDepth = 3, policy, reachability, toolOrchestration } = opts;
-  if (maxDepth < 1) {
-    throw new Error(
-      `getDefaultFallbackChain: maxDepth must be >= 1, got ${maxDepth}`
-    );
-  }
-  const allChains = loadChainsFromBrain();
-  const starter = resolveStarterForMode(archetype, toolOrchestration, allChains);
-  if (!starter) {
-    throw new Error(
-      `getDefaultFallbackChain: unknown archetype "${archetype}". Known: ${Object.keys(allChains).join(", ")}`
-    );
-  }
-  let chain;
-  if (primary) {
-    chain = [primary, ...starter.filter((id) => id !== primary)];
-  } else {
-    chain = [...starter];
-  }
-  if (policy?.blockedModels && policy.blockedModels.length > 0) {
-    const blocked = new Set(policy.blockedModels);
-    chain = chain.filter((id) => !blocked.has(id));
-  }
-  const seen = /* @__PURE__ */ new Set();
-  const deduped = [];
-  for (const id of chain) {
-    if (!seen.has(id)) {
-      seen.add(id);
-      deduped.push(id);
-    }
-  }
-  let filtered = deduped;
-  if (reachability) {
-    filtered = deduped.filter((id) => isModelReachable(id, reachability));
-  }
-  return filtered.slice(0, maxDepth);
-}
-function getStarterChain(archetype) {
-  const chain = STARTER_CHAINS[archetype];
-  if (!chain) {
-    throw new Error(
-      `getStarterChain: unknown archetype "${archetype}"`
-    );
-  }
-  return [...chain];
-}
-function getAllStarterChains() {
-  const out = {};
-  for (const [archetype, chain] of Object.entries(STARTER_CHAINS)) {
-    out[archetype] = [...chain];
-  }
-  return out;
-}
-function getSequentialStarterChain(archetype) {
-  const overlay = STARTER_CHAINS_BY_MODE[archetype]?.sequential;
-  return overlay ? [...overlay] : void 0;
-}
-function copyEntry(e) {
-  const out = { id: e.id, grounding: e.grounding };
-  if (e.reason !== void 0) out.reason = e.reason;
-  if (e.n !== void 0) out.n = e.n;
-  return out;
-}
-function lookupStaticEntry(id, archetype) {
-  const archetypeEntries = STARTER_CHAINS_GROUNDED[archetype];
-  if (archetypeEntries) {
-    const hit = archetypeEntries.find((e) => e.id === id);
-    if (hit) return hit;
-  }
-  const seqOverlay = STARTER_CHAINS_BY_MODE_GROUNDED[archetype]?.sequential;
-  if (seqOverlay) {
-    const hit = seqOverlay.find((e) => e.id === id);
-    if (hit) return hit;
-  }
-  return void 0;
-}
-function resolveGroundedChainForArchetype(archetype, toolOrchestration) {
-  if (toolOrchestration === "sequential") {
-    const overlay = STARTER_CHAINS_BY_MODE_GROUNDED[archetype]?.sequential;
-    if (overlay) return overlay.map(copyEntry);
-  }
-  const allChains = loadChainsFromBrain();
-  const ids = allChains[archetype];
-  if (!ids) return void 0;
-  return ids.map((id) => {
-    const known = lookupStaticEntry(id, archetype);
-    if (known) return copyEntry(known);
-    return { id, grounding: "judgment" };
-  });
-}
-function getDefaultFallbackChainWithGrounding(opts) {
-  const {
-    archetype,
-    primary,
-    maxDepth = 3,
-    policy,
-    reachability,
-    toolOrchestration
-  } = opts;
-  if (maxDepth < 1) {
-    throw new Error(
-      `getDefaultFallbackChainWithGrounding: maxDepth must be >= 1, got ${maxDepth}`
-    );
-  }
-  const starter = resolveGroundedChainForArchetype(archetype, toolOrchestration);
-  if (!starter) {
-    throw new Error(
-      `getDefaultFallbackChainWithGrounding: unknown archetype "${archetype}". Known: ${Object.keys(STARTER_CHAINS_GROUNDED).join(", ")}`
-    );
-  }
-  let chain;
-  if (primary) {
-    const primaryEntry = (() => {
-      const inStarter = starter.find((e) => e.id === primary);
-      if (inStarter) return copyEntry(inStarter);
-      const knownAnywhere = lookupStaticEntry(primary, archetype);
-      if (knownAnywhere) return { ...copyEntry(knownAnywhere), id: primary };
-      return { id: primary, grounding: "judgment" };
-    })();
-    chain = [primaryEntry, ...starter.filter((e) => e.id !== primary)];
-  } else {
-    chain = [...starter];
-  }
-  if (policy?.blockedModels && policy.blockedModels.length > 0) {
-    const blocked = new Set(policy.blockedModels);
-    chain = chain.filter((e) => !blocked.has(e.id));
-  }
-  const seen = /* @__PURE__ */ new Set();
-  const deduped = [];
-  for (const e of chain) {
-    if (!seen.has(e.id)) {
-      seen.add(e.id);
-      deduped.push(e);
-    }
-  }
-  let filtered = deduped;
-  if (reachability) {
-    filtered = deduped.filter((e) => isModelReachable(e.id, reachability));
-  }
-  return filtered.slice(0, maxDepth);
-}
-function getStarterChainWithGrounding(archetype) {
-  const entries = STARTER_CHAINS_GROUNDED[archetype];
-  if (!entries) {
-    throw new Error(
-      `getStarterChainWithGrounding: unknown archetype "${archetype}"`
-    );
-  }
-  return entries.map(copyEntry);
-}
-function getAllStarterChainsWithGrounding() {
-  const out = {};
-  for (const [archetype, entries] of Object.entries(STARTER_CHAINS_GROUNDED)) {
-    out[archetype] = entries.map(copyEntry);
-  }
-  return out;
-}
-function getSequentialStarterChainWithGrounding(archetype) {
-  const overlay = STARTER_CHAINS_BY_MODE_GROUNDED[archetype]?.sequential;
-  return overlay ? overlay.map(copyEntry) : void 0;
-}
-function ensureCrossProviderTail(opts) {
-  const { chain, archetype, apiKeys, envSource } = opts;
-  if (chain.length < 1) return { chain };
-  const providers = /* @__PURE__ */ new Set();
-  for (const t of chain) {
-    const p = tryGetProfile(t);
-    if (p) providers.add(p.provider);
-  }
-  if (providers.size >= 2) return { chain };
-  const existingProvider = providers.values().next().value;
-  if (!existingProvider) return { chain };
-  const allChains = loadChainsFromBrain();
-  const fullChain = allChains[archetype];
-  if (!fullChain) return { chain };
-  for (const candidate of fullChain) {
-    if (chain.includes(candidate)) continue;
-    const cp = tryGetProfile(candidate);
-    if (!cp || cp.provider === existingProvider) continue;
-    if (!isModelReachable(candidate, { apiKeys, envSource })) continue;
-    return { chain: [...chain, candidate], appended: candidate };
-  }
-  return { chain };
-}
-
 // src/call.ts
 async function call(ir, opts = {}) {
   const traceId = generateTraceId();
@@ -2438,6 +2047,8 @@ async function call(ir, opts = {}) {
           latencyMs: latencyMs2
         })
       );
+      const fellOver = targetModel !== initial.target;
+      const fallbackReason = fellOver ? normalizeFallbackReason(attempts) : void 0;
       await record({
         handle: initial.handle,
         tokensIn: validated.response.tokens.input,
@@ -2451,10 +2062,18 @@ async function call(ir, opts = {}) {
         promptPreview: extractPromptPreview(ir),
         responsePreview: validated.response.text.slice(0, 200),
         cacheReadInputTokens: validated.response.tokens.cached,
-        cacheCreationInputTokens: validated.response.tokens.cacheCreated
+        cacheCreationInputTokens: validated.response.tokens.cacheCreated,
+        // alpha.28 — Glass-Box renderer substrate (migration 018). call()
+        // owns the lifecycle so it has direct visibility into finishReason
+        // (from the normalized provider response), totalMs (mirrors latencyMs
+        // for non-streaming; future streaming variant may diverge), and the
+        // fell-over-from / fallback-reason pair (already computed above for
+        // the CallResult return shape).
+        finishReason: validated.response.finishReason,
+        totalMs: latencyMs2,
+        fellOverFrom: fellOver ? initial.target : void 0,
+        fallbackReason
       });
-      const fellOver = targetModel !== initial.target;
-      const fallbackReason = fellOver ? normalizeFallbackReason(attempts) : void 0;
       if (fellOver) {
         const firstFailed = attempts.find((a) => a.status !== "success");
         if (firstFailed) {
@@ -2685,6 +2304,278 @@ function clamp(n) {
   return Math.max(0, Math.min(1, n));
 }
 
+// src/advisories-api.ts
+var SEVERITY_SET = /* @__PURE__ */ new Set(["info", "warn", "critical"]);
+var STATUS_SET = /* @__PURE__ */ new Set(["open", "snoozed", "resolved"]);
+var RESOLUTION_SOURCE_SET = /* @__PURE__ */ new Set([
+  "auto",
+  "consumer-marked",
+  "declined"
+]);
+function asString(v) {
+  return typeof v === "string" && v.length > 0 ? v : void 0;
+}
+function asSeverity(v) {
+  if (typeof v === "string" && SEVERITY_SET.has(v)) {
+    return v;
+  }
+  return "info";
+}
+function asStatus(v) {
+  if (typeof v === "string" && STATUS_SET.has(v)) {
+    return v;
+  }
+  return "open";
+}
+function asResolutionSource(v) {
+  if (typeof v === "string" && RESOLUTION_SOURCE_SET.has(v)) {
+    return v;
+  }
+  return void 0;
+}
+function rowToAdvisory(row) {
+  const archetype = asString(row.applies_to_archetype);
+  const model = asString(row.applies_to_model);
+  const docsLink = asString(row.docs_url);
+  const suggestion = asString(row.suggestion);
+  let suggestedFix = null;
+  if (docsLink || suggestion) {
+    suggestedFix = { type: "manual" };
+    if (docsLink) suggestedFix.docsLink = docsLink;
+    if (suggestion) suggestedFix.before = suggestion;
+  }
+  const out = {
+    id: typeof row.id === "string" ? row.id : "",
+    rule: typeof row.rule === "string" ? row.rule : "",
+    severity: asSeverity(row.severity),
+    openedAt: typeof row.opened_at === "string" ? row.opened_at : "",
+    lastObservedAt: typeof row.last_observed_at === "string" ? row.last_observed_at : "",
+    observationCount: typeof row.observation_count === "number" ? row.observation_count : 0,
+    appliesTo: {
+      ...archetype ? { archetype } : {},
+      ...model ? { model } : {}
+    },
+    message: typeof row.message === "string" ? row.message : "",
+    suggestedFix,
+    autoApplicable: false,
+    // reserved — alpha.30+
+    status: asStatus(row.status)
+  };
+  const resolvedAt = asString(row.resolved_at);
+  if (resolvedAt) out.resolvedAt = resolvedAt;
+  const resolutionSource = asResolutionSource(row.resolution_source);
+  if (resolutionSource) out.resolutionSource = resolutionSource;
+  const resolutionNote = asString(row.resolution_note);
+  if (resolutionNote) out.resolutionNote = resolutionNote;
+  return out;
+}
+function resolveFetch(injected) {
+  return injected ?? ((...args) => globalThis.fetch(...args));
+}
+function normalizeEndpoint(endpoint) {
+  return endpoint.replace(/\/+$/, "");
+}
+async function getActionableAdvisories(opts) {
+  const {
+    appId,
+    severity,
+    status,
+    brainEndpoint,
+    brainJwt,
+    brainAnonKey,
+    fetch: injectedFetch
+  } = opts;
+  if (!appId) {
+    throw new Error("getActionableAdvisories: appId is required");
+  }
+  const doFetch = resolveFetch(injectedFetch);
+  const base = normalizeEndpoint(brainEndpoint);
+  const qs = new URLSearchParams();
+  qs.set("app_id", `eq.${appId}`);
+  if (severity) qs.set("severity", `eq.${severity}`);
+  const effectiveStatus = status ?? "open";
+  if (effectiveStatus !== "all") {
+    qs.set("status", `eq.${effectiveStatus}`);
+  }
+  qs.set("order", "last_observed_at.desc");
+  const url = `${base}/rest/v1/actionable_advisories_v?${qs.toString()}`;
+  let res;
+  try {
+    res = await doFetch(url, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${brainJwt}`,
+        apikey: brainAnonKey,
+        Accept: "application/json"
+      }
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`getActionableAdvisories: network error: ${msg}`);
+  }
+  if (res.status === 401 || res.status === 403) {
+    throw new Error("getActionableAdvisories: brain auth misconfig");
+  }
+  if (res.status >= 500) {
+    throw new Error(`getActionableAdvisories: brain unavailable (${res.status})`);
+  }
+  if (!res.ok) {
+    throw new Error(`getActionableAdvisories: bad request (${res.status})`);
+  }
+  let rows;
+  try {
+    rows = await res.json();
+  } catch {
+    throw new Error("getActionableAdvisories: malformed brain response");
+  }
+  if (!Array.isArray(rows)) {
+    throw new Error("getActionableAdvisories: expected array from brain");
+  }
+  const out = [];
+  for (const raw of rows) {
+    if (raw && typeof raw === "object") {
+      out.push(rowToAdvisory(raw));
+    }
+  }
+  return out;
+}
+async function markAdvisoryResolved(opts) {
+  const {
+    id,
+    resolutionNote,
+    brainEndpoint,
+    brainJwt,
+    brainAnonKey,
+    fetch: injectedFetch
+  } = opts;
+  if (!id) {
+    return { ok: false, reason: "id_required" };
+  }
+  const doFetch = resolveFetch(injectedFetch);
+  const base = normalizeEndpoint(brainEndpoint);
+  const lookupUrl = `${base}/rest/v1/actionable_advisories_v?id=eq.${encodeURIComponent(id)}&select=app_id,rule`;
+  let lookupRes;
+  try {
+    lookupRes = await doFetch(lookupUrl, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${brainJwt}`,
+        apikey: brainAnonKey,
+        Accept: "application/json"
+      }
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { ok: false, reason: `network_error:${msg}` };
+  }
+  if (lookupRes.status === 401 || lookupRes.status === 403) {
+    return { ok: false, reason: "brain_auth_misconfig" };
+  }
+  if (lookupRes.status >= 500) {
+    return { ok: false, reason: "brain_unavailable" };
+  }
+  if (!lookupRes.ok) {
+    return { ok: false, reason: `brain_lookup_failed:${lookupRes.status}` };
+  }
+  let lookupRows;
+  try {
+    lookupRows = await lookupRes.json();
+  } catch {
+    return { ok: false, reason: "brain_lookup_malformed" };
+  }
+  if (!Array.isArray(lookupRows) || lookupRows.length === 0) {
+    return { ok: false, reason: "advisory_not_found" };
+  }
+  const tuple = lookupRows[0];
+  const appId = typeof tuple.app_id === "string" ? tuple.app_id : "";
+  const code = typeof tuple.rule === "string" ? tuple.rule : "";
+  if (!appId || !code) {
+    return { ok: false, reason: "advisory_tuple_invalid" };
+  }
+  const outcomesUrl = `${base}/rest/v1/compile_outcomes?app_id=eq.${encodeURIComponent(appId)}&select=id`;
+  let outcomesRes;
+  try {
+    outcomesRes = await doFetch(outcomesUrl, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${brainJwt}`,
+        apikey: brainAnonKey,
+        Accept: "application/json"
+      }
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { ok: false, reason: `network_error:${msg}` };
+  }
+  if (outcomesRes.status === 401 || outcomesRes.status === 403) {
+    return { ok: false, reason: "brain_auth_misconfig" };
+  }
+  if (outcomesRes.status >= 500) {
+    return { ok: false, reason: "brain_unavailable" };
+  }
+  if (!outcomesRes.ok) {
+    return { ok: false, reason: `brain_lookup_failed:${outcomesRes.status}` };
+  }
+  let outcomeRows;
+  try {
+    outcomeRows = await outcomesRes.json();
+  } catch {
+    return { ok: false, reason: "brain_lookup_malformed" };
+  }
+  if (!Array.isArray(outcomeRows)) {
+    return { ok: false, reason: "brain_lookup_malformed" };
+  }
+  const outcomeIds = [];
+  for (const row of outcomeRows) {
+    if (row && typeof row === "object") {
+      const idVal = row.id;
+      if (typeof idVal === "number" && Number.isFinite(idVal)) {
+        outcomeIds.push(idVal);
+      }
+    }
+  }
+  if (outcomeIds.length === 0) {
+    return { ok: true };
+  }
+  const inList = outcomeIds.join(",");
+  const patchUrl = `${base}/rest/v1/compile_outcome_advisories?outcome_id=in.(${inList})&code=eq.${encodeURIComponent(code)}&resolved_at=is.null`;
+  const patchBody = {
+    resolved_at: (/* @__PURE__ */ new Date()).toISOString(),
+    resolution_source: "consumer-marked"
+  };
+  if (resolutionNote !== void 0) {
+    patchBody.resolution_note = resolutionNote;
+  }
+  let patchRes;
+  try {
+    patchRes = await doFetch(patchUrl, {
+      method: "PATCH",
+      headers: {
+        Authorization: `Bearer ${brainJwt}`,
+        apikey: brainAnonKey,
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        // PostgREST default is no return; we don't need the row back.
+        Prefer: "return=minimal"
+      },
+      body: JSON.stringify(patchBody)
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { ok: false, reason: `network_error:${msg}` };
+  }
+  if (patchRes.status === 401 || patchRes.status === 403) {
+    return { ok: false, reason: "brain_auth_misconfig" };
+  }
+  if (patchRes.status >= 500) {
+    return { ok: false, reason: "brain_unavailable" };
+  }
+  if (!patchRes.ok) {
+    return { ok: false, reason: `patch_failed:${patchRes.status}` };
+  }
+  return { ok: true };
+}
+
 // src/models-brain.ts
 function isModelRow(x) {
   if (!x || typeof x !== "object") return false;
@@ -2811,14 +2702,19 @@ function compile2(ir, opts) {
   return result;
 }
 export {
+  ABSOLUTE_FLOOR,
   ALIASES,
   ALL_ARCHETYPES,
+  ARCHETYPE_FLOOR_DEFAULT,
   CallError,
   DIALECT_VERSION,
   INTENT_ARCHETYPES,
   MEASURED_GROUNDING_MIN_N,
   PROVIDER_ENV_KEYS,
+  RULE_SEQUENTIAL_TOOL_CLIFF,
+  TRANSLATOR_FLOOR,
   allProfiles,
+  applySectionRewrites,
   bucketContext,
   bucketHistory,
   bucketToolCount,
@@ -2829,11 +2725,13 @@ export {
   configureBrain,
   countTokens,
   execute,
+  getActionableAdvisories,
   getAllStarterChains,
   getAllStarterChainsWithGrounding,
   getArchetypePerfScore,
   getDefaultFallbackChain,
   getDefaultFallbackChainWithGrounding,
+  getModelCompatibility,
   getPerAxisMetrics,
   getProfile,
   getReachabilityDiagnostic,
@@ -2853,6 +2751,7 @@ export {
   loadChainsFromBrain,
   loadModelsFromBrain,
   loadPricingFromBrain,
+  markAdvisoryResolved,
   profileToRow,
   profilesByProvider,
   record,