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

package/dist/index.js

@@ -20,8 +20,10 @@ 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,
@@ -43,6 +45,7 @@ __export(index_exports, {
   getArchetypePerfScore: () => getArchetypePerfScore,
   getDefaultFallbackChain: () => getDefaultFallbackChain,
   getDefaultFallbackChainWithGrounding: () => getDefaultFallbackChainWithGrounding,
+  getModelCompatibility: () => getModelCompatibility,
   getPerAxisMetrics: () => getPerAxisMetrics,
   getProfile: () => getProfile,
   getReachabilityDiagnostic: () => getReachabilityDiagnostic,
@@ -1703,12 +1706,23 @@ var PROFILES_RAW = [
   // Each entry's pricing/context/cliffs/lowering reflects the template, NOT
   // provider docs. Verify before promoting status to 'current' (L-049/L-081).
   {
+    // s37 (2026-05-21): UNVERIFIED-AUTO-ONBOARD → verified against
+    // ai.google.dev/gemini-api/docs/models/gemini-3-flash-preview +
+    // ai.google.dev/gemini-api/docs/pricing. L-081 catches:
+    //   maxOutputTokens 65_535 → 65_536 (off-by-one)
+    //   costInputPer1m  0.30 → 0.50  (template-cloned from 2.5-flash; actual is 1.67× more expensive)
+    //   costOutputPer1m 2.50 → 3.00  (template-cloned; actual 1.2× more expensive)
+    //   cache discount  default 0.25 → 0.10 (10× discount, $0.05/$0.50 per docs)
+    // Cliffs inherited from 2.5-flash conservatively. The 8K-context-quality
+    // cliff was a 2.5-Flash observation — Google positions Gemini 3 as
+    // sustained-frontier-on-long-context; brain evidence will validate/relax.
+    // Kept as guard for now.
     id: "gemini-3-flash-preview",
-    verifiedAgainstDocs: "UNVERIFIED-AUTO-ONBOARD",
+    verifiedAgainstDocs: "2026-05-21",
     provider: "google",
     status: "preview",
     maxContextTokens: 1048576,
-    maxOutputTokens: 65535,
+    maxOutputTokens: 65536,
     maxTools: 128,
     parallelToolCalls: true,
     structuredOutput: "native",
@@ -1719,13 +1733,13 @@ var PROFILES_RAW = [
         metric: "input_tokens",
         threshold: 8e3,
         action: "downgrade_quality_warning",
-        reason: "Quality degrades significantly above ~8K context tokens"
+        reason: "Inherited from 2.5-flash guard; brain evidence on Gemini 3 long-context quality will validate/relax"
       },
       {
         metric: "tool_count",
         threshold: 20,
         action: "drop_to_top_relevant",
-        reason: "Tool reliability drops above ~20 tools (despite 128 hard limit)"
+        reason: "Tool reliability drops above ~20 tools (despite 128 hard limit) \u2014 inherited from Flash family"
       },
       {
         metric: "thinking_with_short_output",
@@ -1734,24 +1748,22 @@ var PROFILES_RAW = [
         reason: "Thinking tokens consume maxOutputTokens \u2014 empty response if drained"
       },
       {
-        // s11 trust artifact (2026-05-02): brain showed 5/5 empty rate on
-        // tt-intelligence/summarize/gemini-2.5-flash with tools offered.
-        // v1's disable_thinking_for_short_output already fired and didn't
-        // help — disabling thinking is necessary but not sufficient. Tools
-        // present + summarize intent confuses Flash into a no-output state
-        // (likely tool-decision purgatory). Strip tools entirely for this
-        // archetype on this model.
+        // Inherited from gemini-2.5-flash s11 trust artifact. Family-likely
+        // failure mode for Flash architecture. Keep preemptively until brain
+        // evidence on Gemini 3 specifically.
         metric: "tool_count",
         threshold: 1,
         whenIntent: "summarize",
         action: "strip_tools",
-        reason: "Gemini Flash returns empty when summarize intent has tools offered (5/5 empty rate observed in v1 prod 2026-04-19, replayed into v2 brain 2026-04-29)"
+        reason: "Inherited from 2.5-flash s11 cliff: summarize+tools \u2192 empty response. Preemptive guard until brain evidence on 3-flash-preview specifically."
       }
     ],
-    costInputPer1m: 0.3,
-    costOutputPer1m: 2.5,
+    costInputPer1m: 0.5,
+    costOutputPer1m: 3,
     lowering: {
       ...GOOGLE_LOWERING_BASE,
+      // 10× cache discount per Google pricing: $0.05/M cached vs $0.50/M input.
+      cache: { ...GOOGLE_LOWERING_BASE.cache, discount: 0.1 },
       thinking: { field: "generationConfig.thinkingConfig.thinkingBudget", default: "auto" }
     },
     recovery: [
@@ -1777,40 +1789,45 @@ var PROFILES_RAW = [
     ],
     strengths: ["speed", "volume", "classification", "1m_context", "cost"],
     weaknesses: ["complex_schemas", "large_tool_sets", "high_context_quality"],
-    notes: "AUTO-ONBOARDED 2026-05-16 from `gemini-2.5-flash`. Pricing, context, cliffs are template-cloned and UNVERIFIED \u2014 confirm against provider docs before promoting status to 'current'.",
-    // Master plan §6.2 anchor. Tier 0 for hunt (parallel tool throughput
-    // 15-75 calls/step beats Sonnet — L-040), summarize, classify.
+    notes: "Verified s37 (2026-05-21) against Google docs. Step-change positioning vs 2.5-flash on agentic loops per Google's release notes (Dec 2025). Pricing 1.67\xD7/1.2\xD7 higher than 2.5-flash; cache discount 10\xD7 (vs 4\xD7 for 2.5). Status=preview until brain evidence accumulates.",
+    // Anchored to 2.5-flash archetypePerf as starter, with judgment adjustments
+    // for Google's "step-change on agentic" positioning. Brain evidence (zero
+    // rows today) will replace these starter values.
     archetypePerf: {
       hunt: 9,
-      // L-040: parallel tool throughput 15-75/step
+      // Inherits 2.5-flash L-040 parallel-tool tier; Google positions 3 as agentic-loop upgrade
       classify: 7,
-      // brain-validated, 218 rows
+      // Inherits 2.5-flash brain-validated tier (218 rows on 2.5)
       summarize: 7,
-      // brain-validated; cliff strips tools when present
+      // Inherits 2.5-flash; cliff strips tools when present
       transform: 7,
-      ask: 7,
-      generate: 6,
-      plan: 5,
+      ask: 8,
+      // +1 vs 2.5-flash — sustained-frontier positioning
+      generate: 7,
+      // +1 vs 2.5-flash — agentic coding upgrade per Google
+      plan: 6,
+      // +1 vs 2.5-flash — complex iterations per positioning
       extract: 6,
-      // alpha.8 MAX_TOKENS history on structured output
-      critique: 4
-      // reasoning shallower than Sonnet/Opus
+      critique: 5
+      // +1 vs 2.5-flash — but still below Sonnet/Opus reasoning floor
     }
   },
   {
-    // ── Gemini 2.5 Flash-Lite ──
-    // Onboarded 2026-05-13 (s22) after the model-release watcher surfaced
-    // it as a UNREGISTERED + NEW candidate. Released by Google July 2025,
-    // stable. Positioned BELOW Flash on the cost/perf frontier:
-    //   input  $0.10/M (Flash $0.30/M)   — 3× cheaper
-    //   output $0.40/M (Flash $2.50/M)   — 6× cheaper
-    //   cache  $0.01/M                    — 1/10 of input (vs Flash 0.25 discount)
-    // Cliffs are HYPOTHESIZED from Flash's known failure modes — Flash-Lite
-    // is a smaller sibling, so we inherit Flash's cliffs at equal-or-tighter
-    // thresholds. The brain will validate/relax these as evidence accumulates
-    // per (archetype, model) tuple. Currently ZERO brain rows for this model.
+    // ── Gemini 3.1 Flash-Lite ──
+    // Onboarded 2026-05-16 by auto-onboarder; s37 (2026-05-21) verified
+    // against ai.google.dev/gemini-api/docs/pricing.
+    //
+    // L-081 CATCHES (template clone from 2.5-flash-lite was 2.5-3.75× too cheap):
+    //   costInputPer1m  0.10 → 0.25 (template clone undervalued by 2.5×)
+    //   costOutputPer1m 0.40 → 1.50 (template clone undervalued by 3.75×)
+    //
+    // Real 3.1-flash-lite is NOT a cost-equivalent successor to 2.5-flash-lite —
+    // it sits between 2.5-flash-lite ($0.10/$0.40) and 2.5-flash ($0.30/$2.50).
+    // Cache discount 10× verified ($0.025/M cached vs $0.25/M input).
+    //
+    // Cliffs are HYPOTHESIZED from 2.5-flash family; brain evidence pending.
     id: "gemini-3.1-flash-lite",
-    verifiedAgainstDocs: "UNVERIFIED-AUTO-ONBOARD",
+    verifiedAgainstDocs: "2026-05-21",
     provider: "google",
     status: "preview",
     maxContextTokens: 1048576,
@@ -1851,12 +1868,12 @@ var PROFILES_RAW = [
         reason: "Inherited from Flash s11 cliff: summarize+tools \u2192 empty response. Preemptive guard until brain evidence on Flash-Lite specifically."
       }
     ],
-    costInputPer1m: 0.1,
-    costOutputPer1m: 0.4,
+    costInputPer1m: 0.25,
+    costOutputPer1m: 1.5,
     lowering: {
       ...GOOGLE_LOWERING_BASE,
-      // Cache discount 10× (vs Flash 4×) — Google's spec is $0.01/M cache vs
-      // $0.10/M input. Material for repeat-prompt workloads (classify shape).
+      // Cache discount 10× (vs Flash 4×) — Google docs s37: $0.025/M cached vs
+      // $0.25/M input. Material for repeat-prompt workloads (classify shape).
       cache: { ...GOOGLE_LOWERING_BASE.cache, discount: 0.1 },
       thinking: { field: "generationConfig.thinkingConfig.thinkingBudget", default: "auto" }
     },
@@ -1881,13 +1898,13 @@ var PROFILES_RAW = [
         reason: "MALFORMED_FUNCTION_CALL maps to stop \u2014 escalate to next target."
       }
     ],
-    strengths: ["lowest_cost", "speed", "volume", "classification", "summarize", "1m_context", "cache_friendly"],
+    strengths: ["low_cost", "speed", "volume", "classification", "summarize", "1m_context", "cache_friendly"],
     weaknesses: ["complex_reasoning", "large_tool_sets", "complex_schemas", "structured_output_unproven", "long_context_quality"],
-    notes: "AUTO-ONBOARDED 2026-05-16 from `gemini-2.5-flash-lite`. Pricing, context, cliffs are template-cloned and UNVERIFIED \u2014 confirm against provider docs before promoting status to 'current'.",
-    // Tier 3 emergency floor for summarize/classify chains. ZERO brain
-    // rows — all values are starter hypotheses anchored to "smaller
-    // sibling of Flash, at-or-below Flash perf on every archetype." The
-    // first 50 brain rows per archetype will validate or relax these.
+    notes: "Verified s37 (2026-05-21) against Google docs. Sits between 2.5-flash-lite (cheaper) and 2.5-flash (more expensive) on cost frontier; 2.5\xD7 more expensive than initial template-clone. Cliffs hypothesized from Flash family \u2014 brain evidence pending.",
+    // Tier 2-3 floor for summarize/classify chains at the new (verified) price
+    // point. ZERO brain rows — values are starter hypotheses anchored to
+    // "smaller sibling of Flash at higher cost than 2.5-flash-lite." The first
+    // 50 brain rows per archetype will validate or relax these.
     archetypePerf: {
       classify: 6,
       // starter hypothesis — verify (Flash is 7, lite likely ≤)
@@ -1902,6 +1919,125 @@ var PROFILES_RAW = [
       plan: 3,
       critique: 3
     }
+  },
+  // ─────────────────────────────────────────────────────────────────────────
+  // Gemini 3.5 Flash — hand-onboarded s37 (2026-05-21)
+  //
+  // Google positioning ("Most intelligent for sustained frontier performance
+  // on agentic and coding tasks" / "particularly effective for rapid agentic
+  // loops involving complex coding cycles and iterations") suggests this is
+  // the Flash-family upgrade specifically aimed at hunt-shape workloads.
+  // Pricing 5× input / 3.6× output vs 2.5-flash — material cost premium.
+  // archetypePerf adjusted +1 vs 2.5-flash on ask/generate/plan/critique
+  // (sustained-frontier positioning); hunt held at 9 inherited from L-040
+  // family parallel-tool tier; brain evidence will validate within 50 rows.
+  //
+  // Cliffs inherited conservatively from 2.5-flash. Google's "sustained
+  // frontier on long-context" positioning suggests the 8K cliff may not
+  // apply to 3.5 — keep as guard until brain evidence shows otherwise.
+  //
+  // Specs verified against:
+  //   ai.google.dev/gemini-api/docs/models/gemini-3.5-flash
+  //   ai.google.dev/gemini-api/docs/pricing (Standard tier)
+  // ─────────────────────────────────────────────────────────────────────────
+  {
+    id: "gemini-3.5-flash",
+    verifiedAgainstDocs: "2026-05-21",
+    provider: "google",
+    status: "current",
+    maxContextTokens: 1048576,
+    maxOutputTokens: 65536,
+    maxTools: 128,
+    parallelToolCalls: true,
+    structuredOutput: "native",
+    systemPromptMode: "separate",
+    streaming: true,
+    cliffs: [
+      {
+        metric: "input_tokens",
+        threshold: 8e3,
+        action: "downgrade_quality_warning",
+        reason: "Inherited from 2.5-flash guard; Google positions 3.5 as sustained-frontier-on-long-context but brain evidence pending"
+      },
+      {
+        metric: "tool_count",
+        threshold: 20,
+        action: "drop_to_top_relevant",
+        reason: "Inherited from Flash family: tool reliability drops above ~20 (despite 128 hard limit). Validate per (archetype, model) after n\u226520."
+      },
+      {
+        metric: "thinking_with_short_output",
+        threshold: 1,
+        action: "force_thinking_budget_zero",
+        reason: "Thinking mode supported per Google docs; same drain risk as 2.5-flash \u2014 thinking tokens consume maxOutputTokens"
+      },
+      {
+        // Inherited from 2.5-flash s11 trust artifact (5/5 empty rate on
+        // tt-intelligence/summarize/gemini-2.5-flash with tools offered).
+        // Family-likely failure mode for Flash architecture across versions.
+        // Keep preemptively until brain evidence on 3.5-flash specifically.
+        metric: "tool_count",
+        threshold: 1,
+        whenIntent: "summarize",
+        action: "strip_tools",
+        reason: "Inherited from 2.5-flash s11 cliff (kgauto commit 3872832): summarize+tools \u2192 empty response. Preemptive guard until brain evidence on 3.5-flash specifically."
+      }
+    ],
+    costInputPer1m: 1.5,
+    costOutputPer1m: 9,
+    lowering: {
+      ...GOOGLE_LOWERING_BASE,
+      // 10× cache discount per Google pricing: $0.15/M cached vs $1.50/M input.
+      cache: { ...GOOGLE_LOWERING_BASE.cache, discount: 0.1 },
+      thinking: { field: "generationConfig.thinkingConfig.thinkingBudget", default: "auto" }
+    },
+    recovery: [
+      {
+        signal: "empty_response_after_tool",
+        action: "retry_with_params",
+        retryParams: { "generationConfig.thinkingConfig.thinkingBudget": 0 },
+        maxRetries: 1,
+        reason: "Inherited Flash-family pattern: empty after tool result \u2014 retry with thinking off"
+      },
+      {
+        signal: "empty_response",
+        action: "retry_with_params",
+        retryParams: { "generationConfig.thinkingConfig.thinkingBudget": 0 },
+        maxRetries: 1,
+        reason: "Empty response \u2014 try with thinking off"
+      },
+      {
+        signal: "malformed_function_call",
+        action: "escalate",
+        reason: "MALFORMED_FUNCTION_CALL maps to stop \u2014 escalate to next target"
+      }
+    ],
+    strengths: ["agentic_loops", "coding", "1m_context", "parallel_tools", "thinking_mode", "sustained_frontier"],
+    weaknesses: ["cost_vs_2_5_flash", "no_brain_evidence_yet"],
+    notes: "Hand-onboarded s37 (2026-05-21) verified against Google docs. Stable status; positioned as Flash-family upgrade for agentic loops and coding. 5\xD7/3.6\xD7 more expensive than 2.5-flash but Google claims step-change on sustained frontier work. archetypePerf adjustments are judgment-grounded starter hypotheses \u2014 brain evidence will validate within ~50 rows per archetype.",
+    // Starter hypothesis: anchored to 2.5-flash archetypePerf with +1
+    // adjustments where Google's positioning explicitly supports
+    // (agentic/coding/sustained). Hunt held at 9 inherited from L-040 family
+    // parallel-tool tier. Brain evidence will replace.
+    archetypePerf: {
+      hunt: 9,
+      // Inherited from 2.5-flash L-040 parallel-tool tier; Google positions 3.5 as agentic-loop champion
+      classify: 7,
+      // Inherited from 2.5-flash brain-validated tier (218 rows on 2.5)
+      summarize: 7,
+      // Inherited from 2.5-flash; cliff strips tools when present
+      transform: 7,
+      ask: 8,
+      // +1 vs 2.5-flash — sustained-frontier positioning
+      generate: 8,
+      // +1 vs 2.5-flash (6→8) — Google: "complex coding cycles and iterations"
+      plan: 7,
+      // +1 vs 2.5-flash (5→7) — "complex iterations" positioning
+      extract: 7,
+      // +1 vs 2.5-flash — sustained-frontier on structured tasks
+      critique: 5
+      // +1 vs 2.5-flash — but still below Sonnet/Opus reasoning floor
+    }
   }
 ];
 var ALIASES = {
@@ -2174,6 +2310,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;
@@ -2190,6 +2406,7 @@ function runAdvisor(ir, result, profile, policy, phase2) {
     out.push(...detectModelStaleEvidence(ir, profile));
     out.push(...detectTierDown(ir, profile, phase2));
   }
+  out.push(...detectArchetypePerfFloorBreach(ir, profile));
   return out;
 }
 function detectCachingOff(ir, profile) {
@@ -2360,6 +2577,36 @@ 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/compile.ts
 var counter = 0;
@@ -2620,6 +2867,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,
@@ -2633,9 +2883,24 @@ 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
   });
 }
+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);
@@ -2713,6 +2978,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,
@@ -2747,7 +3014,16 @@ 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
   };
 }
 function computeCostUsd(modelId, tokensIn, tokensOut) {
@@ -3945,6 +4221,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,
@@ -3958,10 +4236,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) {
@@ -4319,8 +4605,10 @@ 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,
@@ -4342,6 +4630,7 @@ function compile2(ir, opts) {
   getArchetypePerfScore,
   getDefaultFallbackChain,
   getDefaultFallbackChainWithGrounding,
+  getModelCompatibility,
   getPerAxisMetrics,
   getProfile,
   getReachabilityDiagnostic,