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

package/dist/index.js

@@ -29,7 +29,10 @@ __export(index_exports, {
   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,
@@ -40,6 +43,7 @@ __export(index_exports, {
   configureBrain: () => configureBrain,
   countTokens: () => countTokens,
   execute: () => execute,
+  getActionableAdvisories: () => getActionableAdvisories,
   getAllStarterChains: () => getAllStarterChains,
   getAllStarterChainsWithGrounding: () => getAllStarterChainsWithGrounding,
   getArchetypePerfScore: () => getArchetypePerfScore,
@@ -65,6 +69,7 @@ __export(index_exports, {
   loadChainsFromBrain: () => loadChainsFromBrain,
   loadModelsFromBrain: () => loadModelsFromBrain,
   loadPricingFromBrain: () => loadPricingFromBrain,
+  markAdvisoryResolved: () => markAdvisoryResolved,
   profileToRow: () => profileToRow,
   profilesByProvider: () => profilesByProvider,
   record: () => record,
@@ -586,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",
@@ -597,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,
@@ -791,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",
@@ -798,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,
@@ -2406,9 +2415,19 @@ function runAdvisor(ir, result, profile, policy, phase2) {
     out.push(...detectModelStaleEvidence(ir, profile));
     out.push(...detectTierDown(ir, profile, phase2));
   }
-  out.push(...detectArchetypePerfFloorBreach(ir, profile));
+  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);
@@ -2608,6 +2627,47 @@ function detectArchetypePerfFloorBreach(ir, profile) {
   ];
 }
 
+// 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;
 function makeHandle() {
@@ -2651,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();
@@ -2701,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 {
@@ -2714,7 +2804,9 @@ function compile(ir, opts = {}) {
     mutationsApplied: accumulatedMutations,
     fallbackChain,
     advisories,
-    diagnostics
+    diagnostics,
+    sectionRewritesApplied,
+    wireOverrides
   };
 }
 function validateIR(ir) {
@@ -2887,7 +2979,11 @@ function registerCompile(appId, archetype, ir, result) {
     // alpha.28: shape fields for Glass-Box renderer.
     toolsCount,
     historyDepth,
-    systemPromptChars
+    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) {
@@ -3023,7 +3119,11 @@ function buildPayload(input, reg) {
     history_depth: input.historyDepth ?? reg?.historyDepth,
     system_prompt_chars: input.systemPromptChars ?? reg?.systemPromptChars,
     fell_over_from: fellOverFrom,
-    fallback_reason: fallbackReason
+    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) {
@@ -4478,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;
@@ -4614,7 +4986,10 @@ function compile2(ir, opts) {
   INTENT_ARCHETYPES,
   MEASURED_GROUNDING_MIN_N,
   PROVIDER_ENV_KEYS,
+  RULE_SEQUENTIAL_TOOL_CLIFF,
+  TRANSLATOR_FLOOR,
   allProfiles,
+  applySectionRewrites,
   bucketContext,
   bucketHistory,
   bucketToolCount,
@@ -4625,6 +5000,7 @@ function compile2(ir, opts) {
   configureBrain,
   countTokens,
   execute,
+  getActionableAdvisories,
   getAllStarterChains,
   getAllStarterChainsWithGrounding,
   getArchetypePerfScore,
@@ -4650,6 +5026,7 @@ function compile2(ir, opts) {
   loadChainsFromBrain,
   loadModelsFromBrain,
   loadPricingFromBrain,
+  markAdvisoryResolved,
   profileToRow,
   profilesByProvider,
   record,