@warmdrift/kgauto-compiler 2.0.0-alpha.74 → 2.0.0-alpha.76

package/dist/{chunk-EB2YR7HL.mjs → chunk-WZZCW6NA.mjs}

@@ -1,5 +1,5 @@
 // src/version.ts
-var LIBRARY_VERSION = "2.0.0-alpha.74";
+var LIBRARY_VERSION = "2.0.0-alpha.76";
 
 // src/key-health.ts
 var JSON_HEADERS = { "Content-Type": "application/json" };

package/dist/index.d.mts

@@ -927,10 +927,39 @@ declare function parseJudgeVerdict(raw: string): {
  * noise reads as a tie, never as a win).
  */
 declare function combineOrderSwappedVerdicts(run1: 'candidate-better' | 'current-better' | 'tied', run2: 'candidate-better' | 'current-better' | 'tied'): 'candidate-better' | 'current-better' | 'tied';
+/**
+ * Release B — the eval's comparison primitive is arm-agnostic: a MODEL
+ * comparison varies `model` and holds `ir`; a STRATEGY comparison varies
+ * `ir` and holds `model`. Same replay, same judge, same order-swap, same
+ * floors.
+ */
+type GoldenEvalAxis = 'model' | 'strategy';
+/** Strategies the eval can measure. Closed set — a strategy is only
+ * measurable against its exact frozen bytes. The `-alt` wording is
+ * EVAL-ONLY: it exists to attribute a v1 loss to wording vs mechanism
+ * (§6) and never ships in a production compile. */
+type GoldenEvalStrategyId = 'discipline-gates-v1' | 'discipline-gates-v1-alt';
 interface GoldenEvalOptions {
     appId: string;
     archetype: string;
-    candidateModel: string;
+    /**
+     * Release B — comparison axis. Default 'model' (alpha.62 behavior,
+     * unchanged). On 'strategy': arm A = the golden IR as stored (gates-off),
+     * arm B = the same IR with a `discipline_contract` section appended
+     * (gates-on), both replayed on ONE model (`strategyModel` or the resolved
+     * incumbent). `candidateModel` is ignored on the strategy axis;
+     * `strategy` is required.
+     */
+    axis?: GoldenEvalAxis;
+    /** Required when axis==='strategy': the strategy under measurement. */
+    strategy?: GoldenEvalStrategyId;
+    /**
+     * axis==='strategy' only: the model both arms run on. Default: the
+     * resolved incumbent (most-captured model in the golden set).
+     */
+    strategyModel?: string;
+    /** Required when axis is 'model' (the default). */
+    candidateModel?: string;
     /**
      * Incumbent to compare against. Default: the most frequent incumbent_model
      * across the loaded golden set (the surface's de-facto leader).
@@ -961,6 +990,18 @@ interface GoldenEvalOptions {
 interface GoldenEvalCase {
     goldenIrId: number;
     verdict: 'candidate-better' | 'tied' | 'current-better' | 'inconclusive';
+    /**
+     * Release B — the RAW order-swapped pair, in incumbent/candidate terms,
+     * BEFORE `combineOrderSwappedVerdicts` folds disagreement into 'tied'.
+     * The fold is public API and unchanged; this records what it discards,
+     * because positional DISAGREEMENT RATE is an objective reliability metric
+     * needing no ground truth (§4.0 — the strategy experiment's primary
+     * metric is positional consistency, not judge quality).
+     */
+    orderVerdicts?: {
+        run1: 'candidate-better' | 'current-better' | 'tied';
+        run2: 'candidate-better' | 'current-better' | 'tied';
+    };
     judgeRationale?: string;
     /** Hard-floor violations on the candidate side for this case. */
     floorViolations: Array<'empty' | 'schema' | 'candidate_error'>;
@@ -983,6 +1024,15 @@ interface GoldenEvalCase {
 interface GoldenEvalRunResult {
     verdict: 'promote-ready' | 'not-inferior' | 'inconclusive';
     runId?: number;
+    /**
+     * Release B — which axis produced this verdict. Load-bearing, not
+     * cosmetic: a results table that can't tell you which axis produced a
+     * verdict is a false-attribution engine. On 'strategy',
+     * incumbentModel === candidateModel (the model held constant) and
+     * `strategy` names the arm-B mutation.
+     */
+    axis: GoldenEvalAxis;
+    strategy?: GoldenEvalStrategyId;
     appId: string;
     archetype: string;
     incumbentModel: string;
@@ -1002,7 +1052,59 @@ interface GoldenEvalRunResult {
     cases: GoldenEvalCase[];
     notes: string[];
 }
+declare function withDisciplineContract(ir: PromptIR): PromptIR;
+declare const DISCIPLINE_GATES_V1_ALT_HEADER = "Before stating any conclusion, run this check:";
+declare function altGatesBlockFor(args: {
+    outputMode: 'text' | 'json' | 'tool_call';
+    hasTools: boolean;
+}): string;
+/**
+ * The alt arm injects its block DIRECTLY as an untagged section — it must
+ * not carry `kind: 'discipline_contract'`, or the translator would prepend
+ * the v1 bytes on top and the arm would measure both wordings at once. The
+ * variant choice mirrors matchRule()'s exactly (same outputMode + hasTools
+ * inputs), so the alt arm no-ops nowhere v1 fires and fires nowhere v1
+ * no-ops — the attribution is about WORDING, and everything else is held.
+ */
+declare function withAltDisciplineContract(ir: PromptIR): PromptIR;
 declare function runGoldenEval(opts: GoldenEvalOptions): Promise<GoldenEvalRunResult>;
+/**
+ * Aggregate outcome of one strategy run, in gates-on terms. 'loses' is the
+ * only branch that costs a third replay — and the only one where wording
+ * attribution matters.
+ */
+type StrategyOutcome = 'wins' | 'ties' | 'loses' | 'inconclusive';
+declare function classifyStrategyOutcome(r: GoldenEvalRunResult): StrategyOutcome;
+/**
+ * The §6 attribution matrix. The load-bearing distinction: a WORDING failure
+ * recorded as a mechanism failure would let Factor B permanently disable a
+ * real capability on evidence about one author's prose.
+ *
+ *   v1 vs off | alt vs off | attribution
+ *   ----------+------------+----------------------------------------------
+ *   wins      | (not run)  | mechanism-works — ship
+ *   ties      | (not run)  | no-lift — inconclusive at this n, re-eval later
+ *   loses     | wins       | wording-failure — do NOT disable the mechanism
+ *   loses     | loses      | mechanism-failure — well-evidenced; Factor B may disable
+ *   loses     | ties/inc.  | wording-inconclusive — no disable on ambiguity
+ */
+type StrategyAttribution = 'mechanism-works' | 'no-lift' | 'wording-failure' | 'mechanism-failure' | 'wording-inconclusive' | 'inconclusive';
+interface StrategyAttributionResult {
+    attribution: StrategyAttribution;
+    primary: GoldenEvalRunResult;
+    /** Present ONLY when the primary lost (the loss-triggered third arm). */
+    alt?: GoldenEvalRunResult;
+    /** The authorship limitation, restated on every result so no downstream
+     * reader can cite an attribution without it. */
+    limitation: string;
+}
+declare const STRATEGY_AUTHORSHIP_LIMITATION: string;
+/**
+ * Run the strategy eval with loss-triggered wording attribution: v1 first;
+ * the alt arm replays ONLY on a v1 loss (mirrors the engine's retry
+ * posture — don't pay for extra evidence until a result demands it).
+ */
+declare function runStrategyEvalWithAttribution(opts: Omit<GoldenEvalOptions, 'axis' | 'strategy' | 'candidateModel'>): Promise<StrategyAttributionResult>;
 
 /**
  * alpha.60 — the library's own version, baked as a constant so Edge/Worker
@@ -1017,7 +1119,7 @@ declare function runGoldenEval(opts: GoldenEvalOptions): Promise<GoldenEvalRunRe
  * guard in `tests/version.test.ts` fails the suite (and therefore
  * `prepublishOnly`) when they diverge — a stale constant cannot reach npm.
  */
-declare const LIBRARY_VERSION = "2.0.0-alpha.74";
+declare const LIBRARY_VERSION = "2.0.0-alpha.76";
 
 /**
  * Oracle contract — how an app tells the brain whether a response was good.
@@ -1351,6 +1453,32 @@ declare const TRANSLATOR_FLOOR = 6;
  * fingerprint — both stay byte-stable across releases.
  */
 declare const RULE_SEQUENTIAL_TOOL_CLIFF = "sequential-tool-cliff-below-floor";
+/**
+ * alpha.68 / Release A — stable identifier of the discipline-gates rule.
+ * Fires on `discipline_contract` sections that pass the two-factor eligibility
+ * screen (Factor A archetype + Factor C output-shape). Surfaces on
+ * `SectionRewrite.rule` and in brain aggregates.
+ *
+ * Versioned (`v1`) deliberately: Factor B evidence (Release B) is only valid
+ * against the EXACT bytes that produced it, so a silent gate edit would
+ * invalidate every standing verdict. A real gate change bumps this to `v2` and
+ * resets Factor B to unmeasured for every tuple.
+ */
+declare const RULE_DISCIPLINE_GATES_V1 = "discipline-gates-v1";
+/**
+ * Release B — stable identifier of the STRUCTURED-SAFE discipline-gates
+ * variant (design contract §5.D second clause, discharged via §4.0's merge:
+ * "the judge must run gates 1–4 only — which IS Path 1's structured-safe
+ * variant, arrived at as a subset-drop of frozen bytes rather than new
+ * prose"). Fires where the full block is Factor-C-forbidden: `json` and
+ * `tool_call` surfaces, where gates 5+6 are shape-altering and would
+ * manufacture the structured-output violations alpha.66 retries.
+ *
+ * Versioned with the SAME v1 stamp as its parent: its bytes are a strict
+ * subset of `discipline-gates-v1`'s, so a v1 wording change is a variant
+ * wording change by construction, and both bump together.
+ */
+declare const RULE_DISCIPLINE_GATES_V1_STRUCTURED = "discipline-gates-v1-structured";
 interface ApplySectionRewritesArgs {
     ir: PromptIR;
     profile: ModelProfile;
@@ -2807,11 +2935,40 @@ declare function markPromoteReadyHandled(opts: MarkPromoteReadyHandledOptions):
  * One active surface promotion, camelCase-mapped at the boundary from the
  * snake_case endpoint row (typed-boundary-transformer convention).
  */
+/**
+ * Release B (alpha.75): `kgauto_promotions` carries two logical channels
+ * sharing one table and one lifecycle (migration 047). `mode` is the
+ * discriminator, and each mode has exactly ONE consumption site:
+ *
+ *   mode        reader                              effect
+ *   ----------  ----------------------------------  -------------------
+ *   downswap    passScoreTargets (compile pass 5)   which MODEL runs
+ *   strategy    applySectionRewrites (pass 6.5)     which IR runs
+ *
+ * The resolver is mode-filtered and no unfiltered accessor exists — an
+ * unfiltered `.find()` was the §7 read-path bug: a strategy row has
+ * promoted_model === incumbent_model, so one reaching the model-boost code
+ * would boost the incumbent and could suppress the alpha.49 quality gate on
+ * evidence that was never about quality-gating.
+ */
+type PromotionMode = 'downswap' | 'strategy';
 interface PromotionRow {
     /** Brain row id — cited in the `promotion-applied` mutation for Glass-Box. */
     id: number;
     /** Intent archetype the promotion applies to. */
     archetype: string;
+    /**
+     * Channel discriminator (migration 047). Rows from a pre-047 endpoint
+     * carry no `mode` on the wire and map to 'downswap' — every pre-047 row
+     * IS a downswap, and strategy rows can only be written by post-047 code
+     * whose endpoint serves the column.
+     */
+    mode: PromotionMode;
+    /**
+     * The strategy id for mode='strategy' rows (e.g. 'discipline-gates-v1');
+     * null on downswaps. DB CHECK: (mode='strategy') = (strategy IS NOT NULL).
+     */
+    strategy: string | null;
     /** The model this surface now routes to. */
     promotedModel: string;
     /** The model it replaced (the eval's incumbent). */
@@ -2821,7 +2978,8 @@ interface PromotionRow {
     /**
      * Evidence-supersedes-judgment: skip the alpha.49 schema-weak
      * quality-gate penalty for the promoted model on this surface (the eval
-     * measured the schema floor holding on real workload).
+     * measured the schema floor holding on real workload). Always false on
+     * strategy rows (DB CHECK kgauto_promotions_strategy_no_suppress).
      */
     suppressQualityGate: boolean;
     /** ISO timestamp the promotion went active. */
@@ -2861,13 +3019,21 @@ interface GetApplicablePromotionOpts {
     appId: string;
     /** Archetype of the compile in flight. Required. */
     archetype: IntentArchetypeName | string;
+    /**
+     * Channel to read (migration 047). Required — there is deliberately no
+     * unfiltered accessor: with one active row per (surface, mode) legal, an
+     * unfiltered first-match-wins `.find()` returns an arbitrary channel's
+     * row, and a strategy row reaching the model-boost reader is the §7
+     * read-path bug.
+     */
+    mode: PromotionMode;
 }
 /**
- * Sync reader. Returns the active promotion for `(appId, archetype)` or
- * undefined. First call returns undefined and triggers async refresh;
+ * Sync reader. Returns the active promotion for `(appId, archetype, mode)`
+ * or undefined. First call returns undefined and triggers async refresh;
  * subsequent calls within TTL return brain data. The brain enforces one
- * active promotion per surface (partial unique index), so at most one row
- * matches.
+ * active promotion per (surface, mode) (partial unique index), so at most
+ * one row matches.
  *
  * NEVER throws. Not configured / brain down / cold → undefined.
  */
@@ -3056,6 +3222,142 @@ declare function getMeasuredFailureVerdict(opts: GetMeasuredFailureOpts): Measur
 declare function _testResetMeasuredFailure(): void;
 declare function _testWaitForMeasuredFailureRefresh(): Promise<void>;
 
+/**
+ * Release C (Rung 1) — the decomposition coach's planning engine.
+ *
+ * Design contract §5.1: evidence-backed advisories on the existing surface —
+ * "you're paying frontier prices for grunt work; here's the measured split."
+ * No contract change; nothing here executes a fan-out. This module is PURE:
+ * templates + arithmetic. The operator script feeds it measured surface
+ * stats and evidence-picked executors; Release D's `delegate` primitive will
+ * consume the SAME templates, so they live in the library, versioned.
+ *
+ * Honesty posture (the roster-with-receipts rule, applied to ourselves):
+ *
+ *   - The per-step token SHARES are JUDGMENT v1 numbers — labelled as such
+ *     in every plan (`assumptions[]`), versioned so a future measured
+ *     replacement invalidates nothing silently. No consumer has fan-out
+ *     traffic yet (R0 shipped alpha.68, zero adopters), so there is nothing
+ *     to measure them from; the moment branch traffic exists, these
+ *     graduate per surface.
+ *   - Executor grounding is carried per step: 'measured' when the portfolio
+ *     corpus has real outcomes for (model, sub-archetype), 'judgment' when
+ *     the roster's archetypePerf is all we have.
+ *   - The coach's most credible output at low volume is "KEEP THE MONOLITH"
+ *     with the break-even volume stated — the never-worse floor in coach
+ *     form. The advisory only files when the split is MATERIAL (same $5/mo
+ *     felt-utility floor as promotions); the demo report renders every
+ *     analysis either way.
+ */
+
+declare const DECOMPOSITION_TEMPLATES_VERSION = "decomposition-templates-v1";
+interface DecompositionStep {
+    /** Human-readable step name (stable — appears in advisories/recipes). */
+    role: string;
+    /** The sub-archetype this step runs as (its own learning_key downstream). */
+    archetype: IntentArchetypeName;
+    /**
+     * Which tier runs the step. 'delegate' steps are the grunt work the coach
+     * proposes moving to a cheap executor; 'anchor' steps stay on the
+     * incumbent (composition is where fan-outs die — §7a — so the composer
+     * anchors on the strong model by design).
+     */
+    tier: 'delegate' | 'anchor';
+    /** Share of the monolith's INPUT tokens this step reads. JUDGMENT v1. */
+    inputShare: number;
+    /**
+     * Tokens this step EMITS, as a share of the monolith's input (for
+     * intermediate artifacts like extraction notes) — the next anchor step
+     * reads these instead of the raw input. JUDGMENT v1.
+     */
+    emitsShareOfInput: number;
+    /** Share of the monolith's OUTPUT tokens this step produces (0 for
+     * intermediate steps; the anchor composer typically carries 1). */
+    outputShare: number;
+}
+interface DecompositionTemplate {
+    archetype: IntentArchetypeName;
+    steps: DecompositionStep[];
+    rationale: string;
+    version: typeof DECOMPOSITION_TEMPLATES_VERSION;
+}
+/**
+ * v1 covers the three judgment-heavy archetypes with a clear split shape.
+ * Every share number below is a judgment estimate, stated in the plan's
+ * assumptions — they exist to make the ARITHMETIC honest, not to claim
+ * precision the corpus doesn't have yet.
+ */
+declare const DECOMPOSITION_TEMPLATES: Partial<Record<IntentArchetypeName, DecompositionTemplate>>;
+interface SurfaceStats {
+    appId: string;
+    archetype: IntentArchetypeName | string;
+    /** The model serving the monolith today (most-served in the window). */
+    incumbentModel: string;
+    nCalls: number;
+    windowDays: number;
+    avgTokensIn: number;
+    avgTokensOut: number;
+}
+interface ExecutorCandidate {
+    modelId: string;
+    /** archetypePerf score on the STEP's archetype. */
+    perfScore: number;
+    grounding: 'measured' | 'judgment';
+    costInputPer1m: number;
+    costOutputPer1m: number;
+}
+interface ModelPricing {
+    costInputPer1m: number;
+    costOutputPer1m: number;
+}
+interface PlannedStep extends DecompositionStep {
+    /** The picked executor ('delegate' steps) or the incumbent ('anchor'). */
+    executorModel: string;
+    executorGrounding: 'measured' | 'judgment';
+    executorPerfScore: number | null;
+    projectedCostPerCallUsd: number;
+}
+interface DecompositionPlan {
+    appId: string;
+    archetype: string;
+    incumbentModel: string;
+    template: DecompositionTemplate;
+    steps: PlannedStep[];
+    monolithCostPerCallUsd: number;
+    splitCostPerCallUsd: number;
+    savingPerCallUsd: number;
+    monthlyCalls: number;
+    projectedMonthlySavingUsd: number;
+    /** Monthly calls at which the split clears the materiality floor. null
+     * when the split doesn't save per-call at all (then no volume helps). */
+    breakEvenMonthlyCalls: number | null;
+    verdict: 'split-pays' | 'keep-monolith';
+    verdictReason: string;
+    /** Judgment inputs, stated. Every number that is not measured is here. */
+    assumptions: string[];
+}
+declare const COACH_CFG: {
+    /** Same felt-utility floor as promotions (alpha.67 family). */
+    minMonthlySavingUsd: number;
+    /** Executor must clear this archetypePerf on the step's archetype —
+     * same floor as the translator/advisor (ARCHETYPE_FLOOR_DEFAULT). */
+    executorPerfFloor: number;
+    daysPerMonth: number;
+};
+interface PlanDecompositionArgs {
+    stats: SurfaceStats;
+    incumbentPricing: ModelPricing;
+    /**
+     * Evidence-picked executor per step archetype. Return undefined when no
+     * candidate clears the perf floor — the plan then keeps that step on the
+     * incumbent and says so (a coach must not route grunt work to a model
+     * that can't do it just because it is cheap).
+     */
+    pickExecutor: (archetype: IntentArchetypeName) => ExecutorCandidate | undefined;
+    cfg?: Partial<typeof COACH_CFG>;
+}
+declare function planDecomposition(args: PlanDecompositionArgs): DecompositionPlan | undefined;
+
 /**
  * @warmdrift/kgauto v2 — prompt compiler + central learning brain.
  *
@@ -3102,4 +3404,4 @@ declare function _testWaitForMeasuredFailureRefresh(): Promise<void>;
  */
 declare function compile(ir: PromptIR, opts?: CompileOptions): CompileResult;
 
-export { ABSOLUTE_FLOOR, type AISDKConvertedMessage, ARCHETYPE_FAMILY_FITS, ARCHETYPE_FLOOR_DEFAULT, type ActionableAdvisory, Adapter, type AdvisoryResolutionSource, type AdvisorySeverity, type AdvisoryStatus, type AdvisorySuggestedFix, ApiKeys, type AppOracle, type ApplySectionRewritesArgs, type ApplySectionRewritesResult, ArchetypeConvention, type ArchetypeFamilyFit, type ArchetypePerfMap, type ArchetypePerfNMap, type ArchetypePerfScoreResult, type AttachCacheControlResult, BestPracticeAdvisory, type BrainConfig, type BrainDeadLetterEntry, type BrainHealthSnapshot, type BrainQueryConfig, type BrainReadEnv, CallOptions, CallResult, ChainEntry, type CompatibilityIntent, type CompileForAISDKv6Result, type CompileOptions, CompilePolicy, CompileResult, CompiledRequest, DEFAULT_FINDINGS_ENDPOINT, DEFAULT_MEASURED_FAILURE_ENDPOINT, DEFAULT_PROMOTIONS_ENDPOINT, type ExclusionFindingRow, type ExclusionResolutionSource, type ExecuteErr, type ExecuteOk, type ExecuteOptions, type ExecuteResult, type FallbackPosture, FamilyResolutionError, type GetActionableAdvisoriesOptions, type GetApplicablePromotionOpts, type GetDefaultFallbackChainOpts, type GetMeasuredFailureOpts, type GetPerAxisMetricsOpts, type GetRecommendedPrimaryOptions, type GoldenEvalCase, type GoldenEvalOptions, type GoldenEvalRunResult, type GoldenIrRecordInput, Grounding, IntentArchetypeName, JUDGE_RUBRICS, LIBRARY_VERSION, type LLMJudgeOptions, MEASURED_FAILURE_CFG, MEASURED_GROUNDING_MIN_N, type MarkAdvisoryResolvedOptions, type MarkExclusionFindingHandledOptions, type MarkPromoteReadyHandledOptions, type MeasuredFailureRuntime, type MeasuredFailureVerdict, type ModelBrainRow, type ModelCompatibility, ModelProfile, NormalizedResponse, type OracleContext, OracleScore, type OutcomePayload, OutcomeResult, OutputMode, PRODUCER_OWNED_RULE_CODES, PROVIDER_ENV_KEYS, PerAxisMetrics, type PricingRow, type ProbeShadowOptions, type ProbeShadowServed, type ProfileToRowOptions, type PromoteReadyFindingRow, type PromoteReadyResolution, type PromotionRow, type PromotionsRuntime, PromptIR, Provider, ProviderOverrides, type ProviderReachability, RULE_SEQUENTIAL_TOOL_CLIFF, type ReachabilityOpts, RecordInput, RecordOutcomeInput, type RunAdvisorPhase2Context, SectionRewrite, type ShadowProbeRecordInput, type SupportedProvider, type SurfaceFailureRow, SystemModelMessage, TRANSLATOR_FLOOR, _testResetMeasuredFailure, _testResetPromotions, _testWaitForMeasuredFailureRefresh, _testWaitForPromotionsRefresh, applyArchetypeConvention, applySectionRewrites, attachCacheControlToStreamTextInput, awaitMeasuredFailureReady, brainHealth, buildGoldenIrRow, buildLLMJudge, buildPairwiseJudgePrompt, buildShadowProbeRow, call, clearBrain, combineOrderSwappedVerdicts, compile, compileForAISDKv6, configureBrain, configureMeasuredFailureBrain, configurePromotionsBrain, countTokens, deriveFamilyFromModelId, deriveOwnership, execute, findBetterFit, flushBrainDeadLetter, getActionableAdvisories, getAllStarterChains, getAllStarterChainsWithGrounding, getApplicablePromotion, getArchetypePerfScore, getDefaultFallbackChain, getDefaultFallbackChainWithGrounding, getMeasuredFailureVerdict, getModelCompatibility, getPerAxisMetrics, getReachabilityDiagnostic, getRecommendedPrimary, getSequentialStarterChain, getSequentialStarterChainWithGrounding, getStaleExclusionFindings, getStarterChain, getStarterChainWithGrounding, isAutoPromoteEnabledFromEnv, isBrainQueryActiveFor, isBrainSync, isExclusionFindingsBrainActive, isMeasuredFailureBrainActive, isMeasuredFailureGateEnabledFromEnv, isModelReachable, isPromotionsBrainActive, isProviderReachable, judgeMeasuredFailure, loadAliasesFromBrain, loadArchetypePerfFromBrain, loadArchetypePerfNFromBrain, loadChainsFromBrain, loadModelsFromBrain, loadPricingFromBrain, markAdvisoryResolved, markExclusionFindingHandled, markPromoteReadyHandled, parseJudgeVerdict, peekBrainDeadLetter, prefetchMeasuredFailure, probeShadow, profileToRow, readBrainReadEnv, record, recordGoldenIr, recordOutcome, recordShadowProbe, renderIrForJudge, resetTokenizer, resolveConventionsForProfile, resolvePricingAt, resolveProviderKey, rubricFor, runAdvisor, runGoldenEval, setTokenizer, wilsonLowerBound };
+export { ABSOLUTE_FLOOR, type AISDKConvertedMessage, ARCHETYPE_FAMILY_FITS, ARCHETYPE_FLOOR_DEFAULT, type ActionableAdvisory, Adapter, type AdvisoryResolutionSource, type AdvisorySeverity, type AdvisoryStatus, type AdvisorySuggestedFix, ApiKeys, type AppOracle, type ApplySectionRewritesArgs, type ApplySectionRewritesResult, ArchetypeConvention, type ArchetypeFamilyFit, type ArchetypePerfMap, type ArchetypePerfNMap, type ArchetypePerfScoreResult, type AttachCacheControlResult, BestPracticeAdvisory, type BrainConfig, type BrainDeadLetterEntry, type BrainHealthSnapshot, type BrainQueryConfig, type BrainReadEnv, COACH_CFG, CallOptions, CallResult, ChainEntry, type CompatibilityIntent, type CompileForAISDKv6Result, type CompileOptions, CompilePolicy, CompileResult, CompiledRequest, DECOMPOSITION_TEMPLATES, DECOMPOSITION_TEMPLATES_VERSION, DEFAULT_FINDINGS_ENDPOINT, DEFAULT_MEASURED_FAILURE_ENDPOINT, DEFAULT_PROMOTIONS_ENDPOINT, DISCIPLINE_GATES_V1_ALT_HEADER, type DecompositionPlan, type DecompositionStep, type DecompositionTemplate, type ExclusionFindingRow, type ExclusionResolutionSource, type ExecuteErr, type ExecuteOk, type ExecuteOptions, type ExecuteResult, type ExecutorCandidate, type FallbackPosture, FamilyResolutionError, type GetActionableAdvisoriesOptions, type GetApplicablePromotionOpts, type GetDefaultFallbackChainOpts, type GetMeasuredFailureOpts, type GetPerAxisMetricsOpts, type GetRecommendedPrimaryOptions, type GoldenEvalAxis, type GoldenEvalCase, type GoldenEvalOptions, type GoldenEvalRunResult, type GoldenEvalStrategyId, type GoldenIrRecordInput, Grounding, IntentArchetypeName, JUDGE_RUBRICS, LIBRARY_VERSION, type LLMJudgeOptions, MEASURED_FAILURE_CFG, MEASURED_GROUNDING_MIN_N, type MarkAdvisoryResolvedOptions, type MarkExclusionFindingHandledOptions, type MarkPromoteReadyHandledOptions, type MeasuredFailureRuntime, type MeasuredFailureVerdict, type ModelBrainRow, type ModelCompatibility, ModelProfile, NormalizedResponse, type OracleContext, OracleScore, type OutcomePayload, OutcomeResult, OutputMode, PRODUCER_OWNED_RULE_CODES, PROVIDER_ENV_KEYS, PerAxisMetrics, type PlannedStep, type PricingRow, type ProbeShadowOptions, type ProbeShadowServed, type ProfileToRowOptions, type PromoteReadyFindingRow, type PromoteReadyResolution, type PromotionRow, type PromotionsRuntime, PromptIR, Provider, ProviderOverrides, type ProviderReachability, RULE_DISCIPLINE_GATES_V1, RULE_DISCIPLINE_GATES_V1_STRUCTURED, RULE_SEQUENTIAL_TOOL_CLIFF, type ReachabilityOpts, RecordInput, RecordOutcomeInput, type RunAdvisorPhase2Context, STRATEGY_AUTHORSHIP_LIMITATION, SectionRewrite, type ShadowProbeRecordInput, type StrategyAttribution, type StrategyAttributionResult, type StrategyOutcome, type SupportedProvider, type SurfaceFailureRow, type SurfaceStats, SystemModelMessage, TRANSLATOR_FLOOR, _testResetMeasuredFailure, _testResetPromotions, _testWaitForMeasuredFailureRefresh, _testWaitForPromotionsRefresh, altGatesBlockFor, applyArchetypeConvention, applySectionRewrites, attachCacheControlToStreamTextInput, awaitMeasuredFailureReady, brainHealth, buildGoldenIrRow, buildLLMJudge, buildPairwiseJudgePrompt, buildShadowProbeRow, call, classifyStrategyOutcome, clearBrain, combineOrderSwappedVerdicts, compile, compileForAISDKv6, configureBrain, configureMeasuredFailureBrain, configurePromotionsBrain, countTokens, deriveFamilyFromModelId, deriveOwnership, execute, findBetterFit, flushBrainDeadLetter, getActionableAdvisories, getAllStarterChains, getAllStarterChainsWithGrounding, getApplicablePromotion, getArchetypePerfScore, getDefaultFallbackChain, getDefaultFallbackChainWithGrounding, getMeasuredFailureVerdict, getModelCompatibility, getPerAxisMetrics, getReachabilityDiagnostic, getRecommendedPrimary, getSequentialStarterChain, getSequentialStarterChainWithGrounding, getStaleExclusionFindings, getStarterChain, getStarterChainWithGrounding, isAutoPromoteEnabledFromEnv, isBrainQueryActiveFor, isBrainSync, isExclusionFindingsBrainActive, isMeasuredFailureBrainActive, isMeasuredFailureGateEnabledFromEnv, isModelReachable, isPromotionsBrainActive, isProviderReachable, judgeMeasuredFailure, loadAliasesFromBrain, loadArchetypePerfFromBrain, loadArchetypePerfNFromBrain, loadChainsFromBrain, loadModelsFromBrain, loadPricingFromBrain, markAdvisoryResolved, markExclusionFindingHandled, markPromoteReadyHandled, parseJudgeVerdict, peekBrainDeadLetter, planDecomposition, prefetchMeasuredFailure, probeShadow, profileToRow, readBrainReadEnv, record, recordGoldenIr, recordOutcome, recordShadowProbe, renderIrForJudge, resetTokenizer, resolveConventionsForProfile, resolvePricingAt, resolveProviderKey, rubricFor, runAdvisor, runGoldenEval, runStrategyEvalWithAttribution, setTokenizer, wilsonLowerBound, withAltDisciplineContract, withDisciplineContract };