@warmdrift/kgauto-compiler 2.0.0-alpha.85 → 2.0.0-alpha.87

package/dist/index.mjs

@@ -19,7 +19,7 @@ import {
   LIBRARY_VERSION,
   createKeyHealthRoute,
   keyFingerprint
-} from "./chunk-WXN7FNXP.mjs";
+} from "./chunk-GMZT4ZXD.mjs";
 import {
   ABSOLUTE_FLOOR,
   ARCHETYPE_FLOOR_DEFAULT,
@@ -29,6 +29,7 @@ import {
   PROVIDER_ENV_KEYS,
   canonicalPolicySet,
   chainProviderSpread,
+  configFreshness,
   configureBrainQuery,
   createBrainQueryCache,
   ensureCrossProviderTail,
@@ -56,19 +57,23 @@ import {
   policySetHas,
   readBrainReadEnv,
   resolveProviderKey
-} from "./chunk-LO2JXTGG.mjs";
+} from "./chunk-G3MKT7IR.mjs";
 import {
   ALIASES,
   LATENCY_TIER_MS,
   _setProfileBrainHook,
+  _testClearConsumerProfiles,
   allProfiles,
   allProfilesRaw,
+  bestEffortProfile,
   getProfile,
+  inferProviderFromId,
   latencyTierOf,
   profilesByProvider,
+  registerProfiles,
   resolveModelAlias,
   tryGetProfile
-} from "./chunk-FD3NFXDC.mjs";
+} from "./chunk-YVKTTTTB.mjs";
 import {
   emitAdvisoryFired,
   emitCompileDone,
@@ -265,6 +270,9 @@ function mapRowsToFindings(rows) {
   return out;
 }
 var snapshots = /* @__PURE__ */ new Map();
+function exclusionFindingsFreshness(appId) {
+  return snapshots.get(appId)?.loaded ? "warm" : "cold";
+}
 var runtime;
 var warnedOnce = false;
 var DEFAULT_FINDINGS_ENDPOINT = "https://kgauto-dashboard.vercel.app/api/kgauto-v2/findings/exclusions";
@@ -325,6 +333,7 @@ async function doRefresh(rt, appId) {
     if (runtime !== rt) return;
     const rows = Array.isArray(body) ? mapRowsToFindings(body) : [];
     snap.data = rows;
+    snap.loaded = true;
     snap.expiresAt = Date.now() + rt.ttlMs;
     snap.refreshing = false;
   } catch (err) {
@@ -683,9 +692,12 @@ function passApplyCliffs(ir, profile, estimatedInputTokens) {
     if (!triggered) continue;
     switch (cliff.action) {
       case "drop_to_top_relevant": {
-        const targetCount = Math.min(
-          Math.floor(cliff.threshold * 0.75),
-          Math.max(1, Math.floor((nextIR.tools?.length ?? 0) / 2))
+        const targetCount = Math.max(
+          1,
+          Math.min(
+            Math.floor(cliff.threshold * 0.75),
+            Math.floor((nextIR.tools?.length ?? 0) / 2)
+          )
         );
         if (nextIR.tools && nextIR.tools.length > targetCount) {
           const intent = nextIR.intent.archetype;
@@ -1625,6 +1637,9 @@ function judgeMeasuredFailure(row, cfg = MEASURED_FAILURE_CFG) {
   };
 }
 var snapshots2 = /* @__PURE__ */ new Map();
+function measuredFailureFreshness(appId) {
+  return snapshots2.get(appId)?.loaded ? "warm" : "cold";
+}
 var runtime2;
 var warnedOnce2 = false;
 var DEFAULT_MEASURED_FAILURE_ENDPOINT = "https://kgauto-dashboard.vercel.app/api/kgauto-v2/measured-failure";
@@ -1722,6 +1737,7 @@ async function doRefresh2(rt, appId) {
     const body = await res.json();
     if (runtime2 !== rt) return;
     snap.data = Array.isArray(body) ? mapRows(body) : [];
+    snap.loaded = true;
     snap.expiresAt = Date.now() + rt.ttlMs;
     snap.refreshing = false;
   } catch (err) {
@@ -1793,6 +1809,9 @@ function mapRowsToPromotions(rows) {
   return out;
 }
 var snapshots3 = /* @__PURE__ */ new Map();
+function promotionsFreshness(appId) {
+  return snapshots3.get(appId)?.loaded ? "warm" : "cold";
+}
 var runtime3;
 var warnedOnce3 = false;
 var DEFAULT_PROMOTIONS_ENDPOINT = "https://kgauto-dashboard.vercel.app/api/kgauto-v2/promotions";
@@ -1877,6 +1896,7 @@ async function doRefresh3(rt, appId) {
     if (runtime3 !== rt) return;
     const rows = Array.isArray(body) ? mapRowsToPromotions(body) : [];
     snap.data = rows;
+    snap.loaded = true;
     snap.expiresAt = Date.now() + rt.ttlMs;
     snap.refreshing = false;
   } catch (err) {
@@ -1895,6 +1915,40 @@ function defaultOnError3(err) {
     err
   );
 }
+function prefetchPromotions(appId) {
+  const rt = runtime3;
+  if (!rt || !appId) return void 0;
+  let snap = snapshots3.get(appId);
+  if (!snap) {
+    snap = { data: [], expiresAt: 0, refreshing: false };
+    snapshots3.set(appId, snap);
+  }
+  if (snap.expiresAt > Date.now()) return void 0;
+  const inflight = pendingRefreshes3.get(appId);
+  if (inflight) return inflight;
+  if (snap.refreshing) return void 0;
+  snap.refreshing = true;
+  void asyncRefresh3(rt, appId);
+  return pendingRefreshes3.get(appId);
+}
+async function awaitPromotionsReady(appId, timeoutMs) {
+  if (!runtime3 || !appId) return;
+  const pending = prefetchPromotions(appId) ?? pendingRefreshes3.get(appId);
+  if (!(timeoutMs > 0)) return;
+  if (!pending) return;
+  let timer;
+  try {
+    await Promise.race([
+      pending,
+      new Promise((resolve) => {
+        timer = setTimeout(resolve, timeoutMs);
+      })
+    ]);
+  } catch {
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
 function _testResetPromotions() {
   runtime3 = void 0;
   snapshots3.clear();
@@ -1943,6 +1997,9 @@ function mapRowsToFindings2(rows) {
   return out;
 }
 var snapshots4 = /* @__PURE__ */ new Map();
+function promoteReadyFreshness(appId) {
+  return snapshots4.get(appId)?.loaded ? "warm" : "cold";
+}
 var runtime4;
 var warnedOnce4 = false;
 function isPromoteReadyBrainActive() {
@@ -2001,6 +2058,7 @@ async function doRefresh4(rt, appId) {
     if (runtime4 !== rt) return;
     const rows = Array.isArray(body) ? mapRowsToFindings2(body) : [];
     snap.data = rows;
+    snap.loaded = true;
     snap.expiresAt = Date.now() + rt.ttlMs;
     snap.refreshing = false;
   } catch (err) {
@@ -2425,6 +2483,31 @@ function advisorRuleBlockedModelDrift(ctx) {
   return out;
 }
 
+// src/advisor-rules/preferred-blocked-overlap.ts
+var PREFERRED_MODEL_BLOCKED_CODE = "preferred-model-blocked";
+var DOCS_URL2 = "https://github.com/stue/command-center/blob/main/interfaces/kgauto.md#best-practice-advisories";
+function advisorRulePreferredBlockedOverlap(ctx) {
+  const preferred = ctx.policy?.preferredModels;
+  const blocked = ctx.policy?.blockedModels;
+  if (!preferred?.length || !blocked?.length) return [];
+  const blockedSet = canonicalPolicySet(blocked);
+  const deadPins = [...new Set(preferred)].filter((p) => policySetHas(blockedSet, p)).sort();
+  if (deadPins.length === 0) return [];
+  const list = deadPins.map((p) => `\`${p}\``).join(", ");
+  const one = deadPins.length === 1;
+  const preferredSet = canonicalPolicySet(preferred);
+  const servedIsPinned = policySetHas(preferredSet, ctx.selectedModelId);
+  return [
+    {
+      level: "warn",
+      code: PREFERRED_MODEL_BLOCKED_CODE,
+      message: `CompilePolicy.preferredModels entr${one ? "y" : "ies"} ${list} ${one ? "is" : "are"} also in \`blockedModels\` (matched canonically, aliases included). A blocked model is hard-rejected before preference boosts apply, so ${one ? "this pin" : "these pins"} can never serve. ` + (servedIsPinned ? `This call was served by \`${ctx.selectedModelId}\`, which is itself a live pin \u2014 the dead entr${one ? "y is" : "ies are"} latent, not currently rerouting traffic.` : `Substitution is your steady state: this call landed on \`${ctx.selectedModelId}\`, which you did not pin.`),
+      suggestion: `Two readings, and kgauto cannot tell them apart: (1) intentional \u2014 your spend gate deliberately outranks the pin, in which case nothing needs doing and you can filter this code; (2) misconfiguration \u2014 the pin and the block were written at different times and the overlap is an accident. tt-intel hit reading (2) on 2026-08-01: a summarize site pinned \`claude-sonnet\` while \`KGAUTO_BLOCKED_MODELS\` carried the same family, and every call silently substituted a reasoning model whose reasoning burn exceeded the site's \`maxOutputTokens\` \u2014 100% empty payloads under HTTP 200. If the block should win, remove the pin so the policy says what it does. If the pin should win, remove ${one ? "the blocking entry" : "the blocking entries"} or re-scope the block to the exact ids you mean. Check what the substitute costs at your input shape while you are here \u2014 a spend gate that lands traffic on a pricier model than the one it blocked is a cost inversion, not a saving.`,
+      docsUrl: DOCS_URL2
+    }
+  ];
+}
+
 // src/advisor.ts
 var QUALITY_FLOOR_FOR_RECOMMENDATION = 6;
 var TIER_DOWN_COST_RATIO = 0.5;
@@ -2449,6 +2532,12 @@ function runAdvisor(ir, result, profile, policy, phase2) {
       selectedModelId: profile.id
     })
   );
+  out.push(
+    ...advisorRulePreferredBlockedOverlap({
+      policy,
+      selectedModelId: profile.id
+    })
+  );
   if (policy?.posture !== "locked") {
     out.push(...detectCostMismatchedArchetype(ir, profile, phase2));
     out.push(...detectModelStaleEvidence(ir, profile));
@@ -2919,7 +3008,16 @@ function makeHandle() {
   return `c${Date.now().toString(36)}-${counter.toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
 }
 function compile(ir, opts = {}) {
-  const resolver = opts.profileResolver ?? getProfile;
+  const baseResolver = opts.profileResolver ?? getProfile;
+  const resolver = opts.policy?.onUnprofiledModel === "best-effort" ? (id) => {
+    try {
+      return baseResolver(id);
+    } catch (err) {
+      const synth = bestEffortProfile(id);
+      if (!synth) throw err;
+      return synth;
+    }
+  } : baseResolver;
   validateIR(ir);
   ir = resolveModelEntries(ir);
   const sliced = passSlice(ir);
@@ -2979,11 +3077,26 @@ function compile(ir, opts = {}) {
   accumulatedMutations.push(...scores.mutations);
   const target = pickTarget(workingIR, scores.value);
   if (!target) {
+    const unknownIds = scores.value.filter((s) => s.rejectReasons?.includes("unknown_model_id")).map((s) => s.modelId);
+    const uninferable = unknownIds.filter((id) => !inferProviderFromId(id));
+    const unknownHint = unknownIds.length > 0 ? ` Unprofiled model id(s): ${unknownIds.join(", ")}. registerProfiles([...]) supplies a full profile; policy.onUnprofiledModel:'best-effort' compiles with guards skipped.` + (uninferable.length > 0 ? ` Note: provider is not inferable from ${uninferable.join(", ")}, so best-effort cannot lower it \u2014 registerProfiles is the only path for those.` : "") : "";
     throw new Error(
-      `compile(): no allowed model fits the request. Scores: ${JSON.stringify(scores.value, null, 2)}`
+      `compile(): no allowed model fits the request.${unknownHint} Scores: ${JSON.stringify(scores.value, null, 2)}`
     );
   }
   const profile = resolver(target.modelId);
+  const bestEffortWarnings = [];
+  if (profile.bestEffort) {
+    bestEffortWarnings.push(
+      `best-effort profile in use for "${profile.id}" (provider ${profile.provider} inferred from the id; wire mechanics borrowed). SKIPPED for this model: cliff guards, recovery rules, measured archetype knowledge, structured-output capability (treated as 'none'), parallel tools (treated as sequential). Cost is UNKNOWN and recorded as $0 \u2014 cost gates and cost attribution are meaningless for this model. registerProfiles() restores real guards.`
+    );
+    accumulatedMutations.push({
+      id: `best_effort_profile_${profile.id}`,
+      source: "best_effort",
+      passName: "resolve-profile",
+      description: `Unprofiled model "${profile.id}" compiled under onUnprofiledModel:'best-effort' \u2014 guards skipped, cost unknown. See diagnostics.cliffWarnings for the full list.`
+    });
+  }
   const fallbackChain = scores.value.filter((s) => s.modelId !== target.modelId && s.fits).sort((a, b) => b.rank - a.rank).map((s) => s.modelId);
   const cliffs = passApplyCliffs(workingIR, profile, inputTokens);
   workingIR = cliffs.value.ir;
@@ -3069,6 +3182,23 @@ function compile(ir, opts = {}) {
   const historyCacheMarkIndex = computeHistoryCacheMarkIndex(workingIR);
   const systemMessages = buildSystemMessages(workingIR, profile.provider);
   const systemCacheMarkIndex = lastCacheableSystemIndex(systemMessages);
+  const keptSectionIds = new Set(workingIR.sections.map((s) => s.id));
+  const cachePrefixActive = lowered.diagnostics.cacheableTokens > 0;
+  const cacheReadFraction = profile.lowering.cache.discount ?? 0.25;
+  const sectionAttribution = ir.sections.map((s) => {
+    const tokens = countTokens(s.text);
+    const kept = keptSectionIds.has(s.id);
+    const estCostUsdFirstCall = kept ? tokens / 1e6 * profile.costInputPer1m : 0;
+    const inActiveCachePrefix = kept && s.cacheable === true && cachePrefixActive;
+    return {
+      id: s.id,
+      tokens,
+      kept,
+      cacheable: s.cacheable === true,
+      estCostUsdFirstCall,
+      estCostUsdWarm: inActiveCachePrefix ? estCostUsdFirstCall * cacheReadFraction : estCostUsdFirstCall
+    };
+  });
   const diagnostics = {
     sectionsKept: workingIR.sections.length,
     sectionsDropped: ir.sections.length - workingIR.sections.length,
@@ -3092,11 +3222,25 @@ function compile(ir, opts = {}) {
     // text the consumer can route on without changing behavior).
     cliffWarnings: [
       ...cliffs.value.loweringHints.qualityWarning ?? [],
-      ...conventions.value.cliffWarnings
+      ...conventions.value.cliffWarnings,
+      // alpha.87 — best-effort profile in use (loud on EVERY compile).
+      ...bestEffortWarnings
     ],
     // alpha.68 / Release A — measured discipline gate-token tax (§5.D). 0 when
     // the gate didn't fire.
-    disciplineGateTokens
+    disciplineGateTokens,
+    // alpha.87 — per-source freshness stamped at the moment the compile's
+    // reads have all happened, from state each source already tracks (the
+    // "one-line stamp at the point where the source is already known and
+    // discarded" this filing reduced to once alpha.73/.86 warmed the caches).
+    freshness: {
+      config: configFreshness(),
+      measuredFailure: measuredFailureFreshness(ir.appId),
+      promotions: promotionsFreshness(ir.appId),
+      exclusions: exclusionFindingsFreshness(ir.appId),
+      promoteReady: promoteReadyFreshness(ir.appId)
+    },
+    sections: sectionAttribution
   };
   if (ir.intent.archetype === "hunt" && ir.constraints?.toolOrchestration === "sequential") {
     accumulatedMutations.push({
@@ -3369,6 +3513,12 @@ function configureBrain(config) {
       fetchImpl: config.fetchImpl ?? fetch,
       onError: config.onError
     });
+    if (config.appId) {
+      try {
+        void prefetchPromotions(config.appId);
+      } catch {
+      }
+    }
   } else {
     configurePromotionsBrain(void 0);
   }
@@ -3626,6 +3776,26 @@ function maybeWarnDiscardedCompile(reg, handle) {
     `[kgauto] compile-then-discard: compileForAISDKv6() output for handle ${handle} (archetype=${reg.archetype}, model=${reg.model}) was recorded but neither .system, .model, nor .raw was read before record(). The brain row's mutations_applied / estimated_tokens_in / system_prompt_chars describe a compile that did NOT shape the served call. Pass compiled.system + compiled.model into your generateText/streamText (or use call()). Silence via configureBrain({ warnOnDiscardedCompile: false }).`
   );
 }
+var OUTCOME_SOURCES = ["canary", "smoke", "eval", "probe", "synthetic"];
+var warnedInvalidEnvSource = false;
+function resolveOutcomeSource(explicit) {
+  if (explicit) return explicit;
+  const raw = typeof process !== "undefined" ? process.env?.KGAUTO_SOURCE : void 0;
+  if (!raw) return void 0;
+  const trimmed = raw.trim();
+  if (!trimmed) return void 0;
+  if (OUTCOME_SOURCES.includes(trimmed)) return trimmed;
+  if (!warnedInvalidEnvSource) {
+    warnedInvalidEnvSource = true;
+    console.warn(
+      `[kgauto] KGAUTO_SOURCE="${trimmed}" is not one of ${OUTCOME_SOURCES.join("|")} \u2014 recording as 'synthetic' so the row survives the brain's CHECK constraint and stays out of organic-liveness stats.`
+    );
+  }
+  return "synthetic";
+}
+function _testResetOutcomeSourceWarning() {
+  warnedInvalidEnvSource = false;
+}
 async function record(input) {
   const reg = compileRegistry.get(input.handle);
   if (reg) {
@@ -3740,6 +3910,9 @@ function buildPayload(input, reg) {
     latency_ms: input.latencyMs,
     success: input.success,
     empty_response: input.emptyResponse ?? input.tokensOut === 0,
+    // alpha.87 — explicit source wins; KGAUTO_SOURCE env fills the gap (the
+    // zero-code synthetic self-mark for harness/smoke processes).
+    source: resolveOutcomeSource(input.source),
     error_type: input.errorType,
     tools_called: input.toolsCalled,
     oracle_score: input.oracleScore?.score,
@@ -4838,7 +5011,11 @@ async function call(ir, opts = {}) {
       )
     })
   );
-  await awaitMeasuredFailureReady(ir.appId, resolveGateWarmupMs(opts));
+  const warmupMs = resolveGateWarmupMs(opts);
+  await Promise.all([
+    awaitMeasuredFailureReady(ir.appId, warmupMs),
+    awaitPromotionsReady(ir.appId, warmupMs)
+  ]);
   const initial = compileAndRegister(ir, opts);
   safeEmit(
     () => emitCompileDone(traceId, ir.appId, {
@@ -4878,6 +5055,7 @@ async function call(ir, opts = {}) {
       const latencyMs2 = Date.now() - start;
       await record({
         handle: initial.handle,
+        source: opts.source,
         tokensIn: 0,
         tokensOut: 0,
         latencyMs: latencyMs2,
@@ -4930,6 +5108,7 @@ async function call(ir, opts = {}) {
       const latencyMs2 = Date.now() - start;
       await record({
         handle: initial.handle,
+        source: opts.source,
         tokensIn: 0,
         tokensOut: 0,
         latencyMs: latencyMs2,
@@ -5071,6 +5250,7 @@ async function call(ir, opts = {}) {
       const goldenShapeKey = goldenRate > 0 ? peekRegisteredShapeKey(initial.handle) : void 0;
       await record({
         handle: initial.handle,
+        source: opts.source,
         tokensIn: validated.response.tokens.input,
         tokensOut: validated.response.tokens.output,
         latencyMs: latencyMs2,
@@ -5193,6 +5373,7 @@ async function call(ir, opts = {}) {
   const latencyMs = Date.now() - start;
   await record({
     handle: initial.handle,
+    source: opts.source,
     tokensIn: lastErr?.tokens?.input ?? 0,
     tokensOut: lastErr?.tokens?.output ?? 0,
     latencyMs,
@@ -7346,7 +7527,9 @@ export {
   STRATEGY_AUTHORSHIP_INDEPENDENT,
   STRATEGY_AUTHORSHIP_LIMITATION,
   TRANSLATOR_FLOOR,
+  _testClearConsumerProfiles,
   _testResetMeasuredFailure,
+  _testResetOutcomeSourceWarning,
   _testResetPromotions,
   _testWaitForMeasuredFailureRefresh,
   _testWaitForPromotionsRefresh,
@@ -7357,6 +7540,8 @@ export {
   applySectionRewrites,
   attachCacheControlToStreamTextInput,
   awaitMeasuredFailureReady,
+  awaitPromotionsReady,
+  bestEffortProfile,
   brainHealth,
   bucketContext,
   bucketHistory,
@@ -7411,6 +7596,7 @@ export {
   getStarterChainWithGrounding,
   hasMutation,
   hashShape,
+  inferProviderFromId,
   isAltStrategy,
   isArchetype,
   isAutoPromoteEnabledFromEnv,
@@ -7443,6 +7629,7 @@ export {
   peekBrainDeadLetter,
   planDecomposition,
   prefetchMeasuredFailure,
+  prefetchPromotions,
   probeShadow,
   profileToRow,
   profilesByProvider,
@@ -7451,11 +7638,13 @@ export {
   recordGoldenIr,
   recordOutcome,
   recordShadowProbe,
+  registerProfiles,
   renderIrForJudge,
   resetTokenizer,
   resolveConventionsForProfile,
   resolveGoldenCaptureRate,
   resolveModelAlias,
+  resolveOutcomeSource,
   resolvePricingAt,
   resolveProviderKey,
   rowToAdvisory,

package/dist/{ir-JUoybVM-.d.mts → ir-P3NEU8z4.d.mts}

@@ -363,6 +363,26 @@ interface CompilePolicy {
      * advisor; otherwise unspecified.
      */
     posture?: 'locked' | 'preferred' | 'open';
+    /**
+     * alpha.87 — what compile() does with a model id no profile covers
+     * (gateway review §6; both cold readers hit this wall).
+     *
+     *   - `'refuse'` (default) — throw, naming `registerProfiles()` and this
+     *     option. The fleet's safety posture, unchanged: guards can only be
+     *     honest about models kgauto knows.
+     *   - `'best-effort'` — synthesize a conservative profile (provider
+     *     inferred from the id prefix; wire mechanics borrowed from a bundled
+     *     profile of that provider; NO cliffs, NO measured knowledge, cost
+     *     UNKNOWN and recorded as 0) and compile anyway, with a loud
+     *     `cliffWarnings` entry + `best_effort_profile` mutation naming
+     *     every guard that is skipped. If the provider cannot be inferred,
+     *     refusal still applies — best-effort cannot lower a wire format it
+     *     cannot name.
+     *
+     * The option converts "wait for the maintainer's weekend" into a
+     * consumer's informed choice; it does not make the unknown model safe.
+     */
+    onUnprofiledModel?: 'refuse' | 'best-effort';
 }
 /**
  * alpha.41 — entry in `PromptIR.models[]`. Either a literal model id (the
@@ -899,6 +919,69 @@ interface CompileResult {
          * number the cost-watcher can weigh against the lift.
          */
         disciplineGateTokens: number;
+        /**
+         * alpha.87 — which world answered THIS compile, per data source (the
+         * `per-source-freshness-marker-on-callresult` ask, PB s76). kgauto
+         * legitimately ranks on bundled profiles when cold and brain-re-ranked
+         * profiles when warm, and before this field the response said nothing
+         * about which had answered — PB drew three wrong conclusions across
+         * s74–s76 from observations taken at unknown temperature. A FLAT marker
+         * was rejected in the s76 consult: the app-scoped gates (measured
+         * failure, promotions, exclusions, promote-ready) carry cache state
+         * independent of the shared config snapshot, and a config-derived
+         * marker would read 'brain' in exactly the window where the
+         * measured-failure gate is still cold.
+         *
+         * Semantics: `config` is `'brain'` iff the shared `/v2/config` snapshot
+         * held fetched data at compile time (else `'bundled'`). The per-gate
+         * fields are `'warm'` iff a successful app-scoped load had completed in
+         * this process — `'cold'` covers never-loaded, load-failed, and
+         * feature-disabled alike, because in all three the gate read no data.
+         * With alpha.73/.86 prefetch + `gateWarmupMs`, a `call()` after warmup
+         * should read all-warm; a cold isolate's first compile may not.
+         */
+        freshness: {
+            config: 'bundled' | 'brain';
+            measuredFailure: 'cold' | 'warm';
+            promotions: 'cold' | 'warm';
+            exclusions: 'cold' | 'warm';
+            promoteReady: 'cold' | 'warm';
+        };
+        /**
+         * alpha.87 — per-section cost attribution (cc's
+         * `per-section-cost-attribution-in-diagnostics` ask, from Sacha's
+         * oracle read). `compile()` already receives sections IDed by the
+         * consumer, so this itemization is arithmetic on values the compiler
+         * computes anyway: zero model calls, no brain write, counts and IDs
+         * only — never section text (G3-compatible by construction). Always-on:
+         * an itemization nobody remembers to ask for is absent at the moment
+         * it is needed, and the payload is one small object per section.
+         *
+         * One row per INPUT section, in input order — dropped sections appear
+         * with `kept: false` and zero cost so a consumer can see what a pass
+         * removed and what it was worth.
+         *
+         * The cacheable interaction is deliberately two explicit columns
+         * rather than one blended number or a compile-time `cacheState` guess:
+         * whether a given call pays the first-call or the warm price is decided
+         * at the provider AFTER compile, so the honest compile-time statement
+         * is both prices. `estCostUsdFirstCall` is the section's tokens at the
+         * selected model's uncached input price (provider cache-WRITE
+         * surcharges, e.g. Anthropic's 1.25×, are not modeled — this
+         * understates first-call cost slightly). `estCostUsdWarm` applies the
+         * profile's cache-read discount when the section sits in an ACTIVE
+         * cacheable prefix (cacheable, and the prefix met the provider's
+         * minimum); otherwise it equals `estCostUsdFirstCall` — for a
+         * non-cached section the two worlds cost the same.
+         */
+        sections: Array<{
+            id: string;
+            tokens: number;
+            kept: boolean;
+            cacheable: boolean;
+            estCostUsdFirstCall: number;
+            estCostUsdWarm: number;
+        }>;
     };
     /**
      * alpha.33. Structured `system` for AI-SDK `streamText({ system })`
@@ -1084,6 +1167,13 @@ interface ShadowProbeConfig {
     skipSlowTierInSync?: boolean;
 }
 interface CallOptions {
+    /**
+     * alpha.86 — self-mark for synthetic callers (canaries, smokes, eval
+     * replays, probes). Passed through to every outcome row this call
+     * records, including failure rows. OMIT for real traffic. See
+     * {@link OutcomeSource}.
+     */
+    source?: OutcomeSource;
     /**
      * alpha.84 — fires once per FAILED attempt during the fallback walk, before
      * the walk continues. IC-Cairn's filing, 2026-07-29.
@@ -1458,9 +1548,34 @@ interface OracleScore {
     /** Free-form explanation for debugging. */
     rationale?: string;
 }
+/**
+ * alpha.86 — who originated an outcome row (migration 056).
+ *
+ * Absent/undefined means ORGANIC: a real consumer call on behalf of a real
+ * user. Consumers change nothing. Synthetic writers — canaries, smoke
+ * gates, eval replays, probe harnesses — self-mark, so liveness and volume
+ * rules can compute over consumer-originated rows only.
+ *
+ * The incident this closes (cost-watch 2026-08-06 → 08-08): playbacksam's
+ * daily canary wrote exactly 8 rows/day for 13 straight days while PB's
+ * organic traffic was near-zero, and the liveness rule scored PB the
+ * healthiest consumer in the portfolio. On 08-08 EVERY row the brain
+ * received in 24h was canary, and no rule could say so — distinguishing a
+ * replay from real traffic took a hand-reconstructed time-window +
+ * token-fingerprint argument, three mornings running. A consumer whose
+ * only rows are written by kgauto's own machinery is dark, not healthy;
+ * this column is what lets a rule print that sentence.
+ */
+type OutcomeSource = 'canary' | 'smoke' | 'eval' | 'probe' | 'synthetic';
 interface RecordInput {
     /** Handle from CompileResult. */
     handle: string;
+    /**
+     * alpha.86 — self-mark for synthetic writers (migration 056). OMIT for
+     * real traffic; never write an explicit "organic" value. See
+     * {@link OutcomeSource}.
+     */
+    source?: OutcomeSource;
     /** Actual tokens consumed (post-call). */
     tokensIn: number;
     tokensOut: number;
@@ -1753,4 +1868,4 @@ interface PerAxisMetrics {
 /** Per-axis metrics keyed by model — used for chain-comparison views. */
 type PerAxisMetricsByModel = Record<string, PerAxisMetrics>;
 
-export { type ApiKeys as A, type BestPracticeAdvisory as B, type CompilePolicy as C, captureGoldenIr as D, type EffortLevel as E, type FallbackReason as F, type Grounding as G, type HistoryCachePolicy as H, type IntentDeclaration as I, hasMutation as J, mutationId as K, parseGoldenCaptureRate as L, type Message as M, type NormalizedResponse as N, type OutcomeResult as O, type ProviderOverrides as P, resolveGoldenCaptureRate as Q, type RecordInput as R, type SystemModelMessage as S, type ToolCall as T, shouldCaptureGolden as U, type CompiledRequest as a, type PromptIR as b, type CallOptions as c, type CallResult as d, type CompileResult as e, type SectionRewrite as f, type RecordOutcomeInput as g, type OracleScore as h, type Adapter as i, type PerAxisMetrics as j, type Provider as k, type ChainEntry as l, type CallAttempt as m, CallError as n, type ChainModelEntry as o, type ChainWithGrounding as p, type Constraints as q, type GoldenCaptureOptions as r, type MutationApplied as s, type NormalizedTokens as t, type OutcomeKind as u, type PerAxisMetricsByModel as v, type PromptSection as w, type SectionKind as x, type ShadowProbeConfig as y, type ToolDefinition as z };
+export { type ApiKeys as A, type BestPracticeAdvisory as B, type CompilePolicy as C, type ToolDefinition as D, type EffortLevel as E, type FallbackReason as F, type Grounding as G, type HistoryCachePolicy as H, type IntentDeclaration as I, captureGoldenIr as J, hasMutation as K, mutationId as L, type Message as M, type NormalizedResponse as N, type OutcomeResult as O, type ProviderOverrides as P, parseGoldenCaptureRate as Q, type RecordInput as R, type SystemModelMessage as S, type ToolCall as T, resolveGoldenCaptureRate as U, shouldCaptureGolden as V, type CompiledRequest as a, type PromptIR as b, type CallOptions as c, type CallResult as d, type CompileResult as e, type SectionRewrite as f, type RecordOutcomeInput as g, type OutcomeSource as h, type OracleScore as i, type Adapter as j, type PerAxisMetrics as k, type Provider as l, type ChainEntry as m, type CallAttempt as n, CallError as o, type ChainModelEntry as p, type ChainWithGrounding as q, type Constraints as r, type GoldenCaptureOptions as s, type MutationApplied as t, type NormalizedTokens as u, type OutcomeKind as v, type PerAxisMetricsByModel as w, type PromptSection as x, type SectionKind as y, type ShadowProbeConfig as z };