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

package/dist/index.js

@@ -20,14 +20,19 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  ABSOLUTE_FLOOR: () => ABSOLUTE_FLOOR,
   ALIASES: () => ALIASES,
   ALL_ARCHETYPES: () => ALL_ARCHETYPES,
+  ARCHETYPE_FLOOR_DEFAULT: () => ARCHETYPE_FLOOR_DEFAULT,
   CallError: () => CallError,
   DIALECT_VERSION: () => DIALECT_VERSION,
   INTENT_ARCHETYPES: () => INTENT_ARCHETYPES,
   MEASURED_GROUNDING_MIN_N: () => MEASURED_GROUNDING_MIN_N,
   PROVIDER_ENV_KEYS: () => PROVIDER_ENV_KEYS,
+  RULE_SEQUENTIAL_TOOL_CLIFF: () => RULE_SEQUENTIAL_TOOL_CLIFF,
+  TRANSLATOR_FLOOR: () => TRANSLATOR_FLOOR,
   allProfiles: () => allProfiles,
+  applySectionRewrites: () => applySectionRewrites,
   bucketContext: () => bucketContext,
   bucketHistory: () => bucketHistory,
   bucketToolCount: () => bucketToolCount,
@@ -38,11 +43,13 @@ __export(index_exports, {
   configureBrain: () => configureBrain,
   countTokens: () => countTokens,
   execute: () => execute,
+  getActionableAdvisories: () => getActionableAdvisories,
   getAllStarterChains: () => getAllStarterChains,
   getAllStarterChainsWithGrounding: () => getAllStarterChainsWithGrounding,
   getArchetypePerfScore: () => getArchetypePerfScore,
   getDefaultFallbackChain: () => getDefaultFallbackChain,
   getDefaultFallbackChainWithGrounding: () => getDefaultFallbackChainWithGrounding,
+  getModelCompatibility: () => getModelCompatibility,
   getPerAxisMetrics: () => getPerAxisMetrics,
   getProfile: () => getProfile,
   getReachabilityDiagnostic: () => getReachabilityDiagnostic,
@@ -62,6 +69,7 @@ __export(index_exports, {
   loadChainsFromBrain: () => loadChainsFromBrain,
   loadModelsFromBrain: () => loadModelsFromBrain,
   loadPricingFromBrain: () => loadPricingFromBrain,
+  markAdvisoryResolved: () => markAdvisoryResolved,
   profileToRow: () => profileToRow,
   profilesByProvider: () => profilesByProvider,
   record: () => record,
@@ -583,6 +591,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",
@@ -594,7 +603,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,
@@ -788,6 +798,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",
@@ -795,7 +806,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,
@@ -2307,6 +2319,86 @@ function getArchetypePerfScore(modelId, archetype) {
   return { score, n, grounding };
 }
 
+// src/compatibility.ts
+var ARCHETYPE_FLOOR_DEFAULT = 6;
+var ABSOLUTE_FLOOR = 4;
+function rawArchetypePerf(profile, archetype) {
+  return profile.archetypePerf?.[archetype] ?? 5;
+}
+function hasSequentialToolCliffForHunt(profile) {
+  if (profile.parallelToolCalls !== false) return false;
+  const huntScore = profile.archetypePerf?.hunt ?? 5;
+  return huntScore < ARCHETYPE_FLOOR_DEFAULT;
+}
+function adapterForCliff(profile, archetype) {
+  if (archetype === "hunt" && hasSequentialToolCliffForHunt(profile)) {
+    const otherScores = [];
+    if (profile.archetypePerf) {
+      for (const [k, v] of Object.entries(profile.archetypePerf)) {
+        if (k === "hunt") continue;
+        if (typeof v === "number") otherScores.push(v);
+      }
+    }
+    const sorted = [...otherScores].sort((a, b) => a - b);
+    const median = sorted.length === 0 ? ARCHETYPE_FLOOR_DEFAULT + 1 : sorted[Math.floor(sorted.length / 2)] ?? ARCHETYPE_FLOOR_DEFAULT + 1;
+    const estimated = Math.max(ARCHETYPE_FLOOR_DEFAULT + 1, median);
+    return {
+      adapter: {
+        parameter: "toolOrchestration",
+        value: "sequential",
+        consequence: "Tool calls run one at a time instead of in parallel \u2014 slower per step but reliable for this model."
+      },
+      estimatedScoreWithAdapter: estimated
+    };
+  }
+  return void 0;
+}
+function archetypeDescriptor(archetype) {
+  return archetype;
+}
+function getModelCompatibility(modelId, intent) {
+  const profile = tryGetProfile(modelId);
+  if (!profile) {
+    return {
+      status: "reject",
+      reason: `Model "${modelId}" is not registered with kgauto \u2014 no compatibility data available.`,
+      archetypePerf: 0
+    };
+  }
+  const { archetype, toolOrchestration } = intent;
+  const rawScore = rawArchetypePerf(profile, archetype);
+  const descriptor = archetypeDescriptor(archetype);
+  const adapterMatch = adapterForCliff(profile, archetype);
+  if (toolOrchestration === "sequential" && adapterMatch && adapterMatch.adapter.parameter === "toolOrchestration" && adapterMatch.adapter.value === "sequential") {
+    return {
+      status: "compatible",
+      reason: `Suited for ${descriptor} with sequential tool calls.`,
+      archetypePerf: rawScore
+    };
+  }
+  if (rawScore >= ARCHETYPE_FLOOR_DEFAULT) {
+    return {
+      status: "compatible",
+      reason: `Suited for ${descriptor}.`,
+      archetypePerf: rawScore
+    };
+  }
+  if (adapterMatch) {
+    return {
+      status: "requires-adapter",
+      reason: `Best with ${adapterMatch.adapter.value} ${adapterMatch.adapter.parameter === "toolOrchestration" ? "tool calls" : adapterMatch.adapter.parameter} for ${descriptor} \u2014 slower but works.`,
+      archetypePerf: rawScore,
+      archetypePerfWithAdapter: adapterMatch.estimatedScoreWithAdapter,
+      adapter: adapterMatch.adapter
+    };
+  }
+  return {
+    status: "reject",
+    reason: `Not suited for ${descriptor} \u2014 would underperform significantly.`,
+    archetypePerf: rawScore
+  };
+}
+
 // src/advisor.ts
 var QUALITY_FLOOR_FOR_RECOMMENDATION = 6;
 var TIER_DOWN_COST_RATIO = 0.5;
@@ -2323,8 +2415,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);
@@ -2493,6 +2596,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;
@@ -2537,9 +2711,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();
@@ -2587,7 +2785,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 {
@@ -2600,7 +2804,9 @@ function compile(ir, opts = {}) {
     mutationsApplied: accumulatedMutations,
     fallbackChain,
     advisories,
-    diagnostics
+    diagnostics,
+    sectionRewritesApplied,
+    wireOverrides
   };
 }
 function validateIR(ir) {
@@ -2753,6 +2959,9 @@ function registerCompile(appId, archetype, ir, result) {
     tokens
   );
   const shapeKey = `${shape.contextBucket}-${shape.toolCountBucket}-${shape.historyDepth}-${shape.outputMode}`;
+  const toolsCount = result.diagnostics.toolsKept;
+  const historyDepth = Array.isArray(ir.history) ? ir.history.length : 0;
+  const systemPromptChars = estimateSystemPromptChars(ir.sections);
   compileRegistry.set(result.handle, {
     appId,
     archetype,
@@ -2766,9 +2975,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);
@@ -2846,6 +3074,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,
@@ -2880,7 +3110,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) {
@@ -4078,6 +4321,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,
@@ -4091,10 +4336,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) {
@@ -4325,6 +4578,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;
@@ -4452,14 +4977,19 @@ function compile2(ir, opts) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ABSOLUTE_FLOOR,
   ALIASES,
   ALL_ARCHETYPES,
+  ARCHETYPE_FLOOR_DEFAULT,
   CallError,
   DIALECT_VERSION,
   INTENT_ARCHETYPES,
   MEASURED_GROUNDING_MIN_N,
   PROVIDER_ENV_KEYS,
+  RULE_SEQUENTIAL_TOOL_CLIFF,
+  TRANSLATOR_FLOOR,
   allProfiles,
+  applySectionRewrites,
   bucketContext,
   bucketHistory,
   bucketToolCount,
@@ -4470,11 +5000,13 @@ function compile2(ir, opts) {
   configureBrain,
   countTokens,
   execute,
+  getActionableAdvisories,
   getAllStarterChains,
   getAllStarterChainsWithGrounding,
   getArchetypePerfScore,
   getDefaultFallbackChain,
   getDefaultFallbackChainWithGrounding,
+  getModelCompatibility,
   getPerAxisMetrics,
   getProfile,
   getReachabilityDiagnostic,
@@ -4494,6 +5026,7 @@ function compile2(ir, opts) {
   loadChainsFromBrain,
   loadModelsFromBrain,
   loadPricingFromBrain,
+  markAdvisoryResolved,
   profileToRow,
   profilesByProvider,
   record,