@warmdrift/kgauto-compiler 2.0.0-alpha.49 → 2.0.0-alpha.51

package/dist/index.js

@@ -310,6 +310,115 @@ var GOOGLE_LOWERING_BASE = {
 };
 var PROFILES_RAW = [
   // ── Anthropic ──
+  {
+    // VERIFIED 2026-06-21 against the claude-api reference. Claude Fable 5 is
+    // Anthropic's most capable model — a NEW tier ABOVE the opus/sonnet/haiku
+    // line (the id has no MAJOR-MINOR version, just `-5`) at 2× Opus pricing
+    // ($10/$50 vs $5/$25). Hand-authored, not cloned: the onboarder regex can't
+    // match this shape (new family + single-segment version), AND a clone would
+    // carry the wrong (opus) pricing. status:'preview' — no brain evidence yet;
+    // it earns per-archetype placement through the machinery like any model, and
+    // at 2× Opus the quality-floor + cost gates do real work before it leads.
+    // API quirk (claude-api ref): an explicit `thinking:{type:"disabled"}` 400s
+    // on Fable 5 (omit instead) — MOOT here: ANTHROPIC_LOWERING_BASE carries no
+    // `thinking` field, so kgauto never sends the param. (L-049/L-081.)
+    id: "claude-fable-5",
+    verifiedAgainstDocs: "2026-06-21",
+    provider: "anthropic",
+    status: "preview",
+    maxContextTokens: 1e6,
+    maxOutputTokens: 128e3,
+    maxTools: 64,
+    parallelToolCalls: true,
+    structuredOutput: "grammar",
+    systemPromptMode: "inline",
+    streaming: true,
+    cliffs: [],
+    costInputPer1m: 10,
+    costOutputPer1m: 50,
+    lowering: ANTHROPIC_LOWERING_BASE,
+    recovery: [
+      {
+        signal: "rate_limit",
+        action: "escalate",
+        reason: "429 from Anthropic \u2014 escalate to fallback chain"
+      },
+      {
+        signal: "model_not_found",
+        action: "escalate",
+        reason: "Model deprecated/renamed \u2014 escalate (L-061)"
+      }
+    ],
+    strengths: ["reasoning", "agentic_coding", "long_context", "reliable_tool_use", "structured_output"],
+    weaknesses: ["cost", "latency"],
+    notes: "Most capable Anthropic model (2026-06); a new tier ABOVE Opus at 2\xD7 pricing ($10/$50). 1M ctx, 128k out. Verified 2026-06-21 against the claude-api reference. status:preview \u2014 no brain evidence yet; earns placement via the machinery (cost + quality-floor gates govern). latencyTier derives `slow` (weaknesses includes latency \u2014 minutes-long turns on hard tasks). The thinking-disabled-400 API quirk is moot for kgauto (Anthropic lowering emits no thinking param).",
+    // archetypePerf cloned from claude-opus-4-8 as a conservative estimate
+    // (Fable >= Opus in capability, but unmeasured — no fabricated superiority).
+    // Re-rank once brain rows exist.
+    archetypePerf: {
+      critique: 10,
+      plan: 10,
+      generate: 9,
+      ask: 9,
+      extract: 9,
+      transform: 9,
+      hunt: 8,
+      summarize: 8,
+      classify: 8
+    }
+  },
+  {
+    // Auto-onboarded 2026-06-04 from `claude-opus-4-7`; VERIFIED 2026-06-21
+    // against the claude-api reference. Opus 4.8 shares 4.7's surface exactly —
+    // 1M ctx, 128k out, $5/$25, no new breaking changes — so the clone's
+    // capability data was accurate (confirmed field-by-field). archetypePerf is
+    // still cloned from 4.7 (a sound estimate: 4.8 >= 4.7) — re-rank once brain
+    // rows exist. Promoted to status:'current' 2026-06-21 (Sacha: "include Claude
+    // Opus 4.8") — now live-selectable. Ties with the still-current claude-opus-4-7
+    // (identical $5/$25 + cloned perf) resolve to 4-8 by array order. (L-049/L-081.)
+    id: "claude-opus-4-8",
+    verifiedAgainstDocs: "2026-06-21",
+    provider: "anthropic",
+    status: "current",
+    maxContextTokens: 1e6,
+    maxOutputTokens: 128e3,
+    maxTools: 64,
+    parallelToolCalls: true,
+    structuredOutput: "grammar",
+    systemPromptMode: "inline",
+    streaming: true,
+    cliffs: [],
+    costInputPer1m: 5,
+    costOutputPer1m: 25,
+    lowering: ANTHROPIC_LOWERING_BASE,
+    recovery: [
+      {
+        signal: "rate_limit",
+        action: "escalate",
+        reason: "429 from Anthropic \u2014 escalate to fallback chain"
+      },
+      {
+        signal: "model_not_found",
+        action: "escalate",
+        reason: "Model deprecated/renamed \u2014 escalate (L-061)"
+      }
+    ],
+    strengths: ["reasoning", "agentic_coding", "long_context", "reliable_tool_use", "structured_output"],
+    weaknesses: ["cost", "latency"],
+    notes: "Frontier Opus (2026-06), the current recommended Opus-tier default. Verified 2026-06-21 against the claude-api reference: 1M ctx, 128k out, $5/$25 \u2014 identical surface to 4.7, no new breaking changes. Promoted to status:current 2026-06-21 (live-selectable); coexists with claude-opus-4-7 (still current).",
+    // Cloned archetypePerf from claude-opus-4-7 — re-evaluate once brain rows exist.
+    archetypePerf: {
+      critique: 10,
+      plan: 10,
+      generate: 9,
+      ask: 9,
+      extract: 9,
+      transform: 9,
+      hunt: 8,
+      summarize: 8,
+      classify: 8
+    }
+  },
   {
     id: "claude-opus-4-7",
     verifiedAgainstDocs: "2026-05-08",
@@ -877,7 +986,7 @@ var PROFILES_RAW = [
   },
   {
     id: "deepseek-v4-pro",
-    verifiedAgainstDocs: "2026-05-08",
+    verifiedAgainstDocs: "2026-06-22",
     provider: "deepseek",
     status: "current",
     maxContextTokens: 1e6,
@@ -895,10 +1004,14 @@ var PROFILES_RAW = [
         reason: "Sequential tool calls only \u2014 L-040"
       }
     ],
-    // Profile carries REGULAR pricing, not the 75%-off promo (ends 2026-05-31).
-    // Under-estimating cost is worse than over-estimating for budget caps.
-    costInputPer1m: 1.74,
-    costOutputPer1m: 3.48,
+    // Verified against the live DeepSeek pricing page 2026-06-22: the 75%-off
+    // launch "promo" ($0.435/$0.87) did NOT revert on 2026-05-31 — it became the
+    // standing price (docs show $0.435 in / $0.87 out cache-miss, $0.003625
+    // cache-hit in; no promo caveat). The old $1.74/$3.48 "regular post-promo"
+    // was a projected revert that never happened (L-073/L-081) — it 4×-overstated
+    // cost and suppressed V4-Pro in cost-aware ranking.
+    costInputPer1m: 0.435,
+    costOutputPer1m: 0.87,
     lowering: {
       system: { mode: "inline" },
       cache: { strategy: "unsupported" },
@@ -914,7 +1027,7 @@ var PROFILES_RAW = [
     // of the served set. Tag derivation would say 'medium'; the measurement says
     // otherwise.
     latencyTier: "slow",
-    notes: "Pro tier. 1M context, 384k max output. Regular pricing $1.74/$3.48; 75% promo through 2026-05-31 ($0.435/$0.87). Default mode = thinking.",
+    notes: "Pro tier. 1M context, 384k max output. $0.435/$0.87 per 1M (cache-hit in $0.003625) \u2014 verified live 2026-06-22; the launch promo became the standing price (no revert). Default mode = thinking.",
     // Master plan §3.3: tier 3 cross-provider for plan chain. Reasoning
     // bumped one notch over V4-Flash; same parallel-tool ceiling.
     archetypePerf: {
@@ -4589,7 +4702,10 @@ function buildShadowProbeRow(input) {
     // Full IR was replayed (not a truncated preview), so fidelity is 1.0 — the
     // prompt-fidelity guard never fires on these rows.
     prompt_fidelity: 1,
-    replay_source: "inline-full-ir"
+    replay_source: "inline-full-ir",
+    // alpha — migration 029. 'completed' is the default completed-probe shape;
+    // diagnostic rows (aborted/skipped) pass the explicit class.
+    outcome: input.outcome ?? "completed"
   };
 }
 async function recordShadowProbe(input) {
@@ -6201,15 +6317,54 @@ function hashForProbe(s) {
   for (let i = 0; i < s.length; i++) h = (h << 5) - h + s.charCodeAt(i) | 0;
   return `h${(h >>> 0).toString(16)}`;
 }
+var DEFAULT_PROBE_MAX_LATENCY_MS = 15e3;
+function isSlowTierCandidate(candidate) {
+  const profile = tryGetProfile(candidate);
+  if (!profile) return false;
+  return latencyTierOf(profile) === "slow";
+}
 async function runProbeCandidates(args) {
   try {
     if (!shouldSampleProbe(args.cfg.sampleRate ?? 0.05)) return;
     const candidates = normalizeProbeCandidates(args.cfg.candidates);
     const promptHash = hashForProbe(args.ir.currentTurn?.content ?? "");
+    const budgetMs = args.cfg.maxLatencyMs ?? DEFAULT_PROBE_MAX_LATENCY_MS;
+    const deadline = args.sync ? Date.now() + budgetMs : Number.POSITIVE_INFINITY;
+    const skipSlow = args.sync && (args.cfg.skipSlowTierInSync ?? true);
+    const recordDiagnostic = async (candidate, outcome) => {
+      await recordShadowProbe({
+        appId: args.ir.appId,
+        archetype: args.ir.intent.archetype,
+        family: deriveFamilyFromModelId(candidate) ?? "unknown",
+        candidateModel: candidate,
+        currentModel: args.servedModel,
+        promptHash,
+        // Served leg only — the candidate never produced a comparable response.
+        currentResponsePreview: args.servedResponse.text.slice(0, 2e3),
+        tokensCurrentIn: args.servedResponse.tokens.input,
+        tokensCurrentOut: args.servedResponse.tokens.output,
+        latencyCurrentMs: args.servedLatencyMs,
+        outcome
+      });
+    };
     for (const candidate of candidates) {
       if (candidate === args.servedModel) continue;
       if (deriveFamilyFromModelId(candidate) === "claude-opus") continue;
       if (!isModelReachable(candidate, { apiKeys: args.exec.apiKeys })) continue;
+      if (skipSlow && isSlowTierCandidate(candidate)) {
+        try {
+          await recordDiagnostic(candidate, "skipped_slow_tier_sync");
+        } catch {
+        }
+        continue;
+      }
+      if (args.sync && Date.now() >= deadline) {
+        try {
+          await recordDiagnostic(candidate, "aborted_latency_budget");
+        } catch {
+        }
+        break;
+      }
       try {
         const candCompile = compileAndRegister(
           {
@@ -6220,11 +6375,32 @@ async function runProbeCandidates(args) {
           args.exec
         );
         const candStart = Date.now();
-        const exec = await execute(candCompile.request, {
+        let timer;
+        const execPromise = execute(candCompile.request, {
           apiKeys: args.exec.apiKeys,
           fetchImpl: args.exec.fetchImpl,
           providerOverrides: args.exec.providerOverrides
-        });
+        }).then((exec2) => ({ kind: "exec", exec: exec2 })).catch(() => ({ kind: "failed" }));
+        let raced;
+        if (args.sync) {
+          const remaining = Math.max(0, deadline - Date.now());
+          const timeoutPromise = new Promise((resolve) => {
+            timer = setTimeout(() => resolve({ kind: "timeout" }), remaining);
+          });
+          raced = await Promise.race([execPromise, timeoutPromise]);
+          if (timer) clearTimeout(timer);
+        } else {
+          raced = await execPromise;
+        }
+        if (raced.kind === "timeout") {
+          try {
+            await recordDiagnostic(candidate, "aborted_latency_budget");
+          } catch {
+          }
+          break;
+        }
+        if (raced.kind === "failed") continue;
+        const exec = raced.exec;
         const candidateLatencyMs = Date.now() - candStart;
         if (!exec.ok) continue;
         await recordShadowProbe({
@@ -6244,7 +6420,8 @@ async function runProbeCandidates(args) {
           // mirrors the user's actual wait; candidate latency is measured only
           // here and stored nowhere else (irrecoverable if not captured now).
           latencyCurrentMs: args.servedLatencyMs,
-          latencyCandidateMs: candidateLatencyMs
+          latencyCandidateMs: candidateLatencyMs,
+          outcome: "completed"
         });
       } catch {
       }
@@ -6262,7 +6439,11 @@ async function runShadowProbe(args) {
     servedResponse: args.servedResponse,
     servedLatencyMs: args.servedLatencyMs,
     // CallOptions is a structural superset of ProbeExecOpts.
-    exec: args.opts
+    exec: args.opts,
+    // alpha — the call()-inline path is on the user's critical path exactly when
+    // BrainConfig.sync is set (call() awaits the probe before returning). That's
+    // the only case where the latency budget + slow-tier skip must fire.
+    sync: isBrainSync()
   });
 }
 async function probeShadow(ir, opts) {
@@ -6295,7 +6476,15 @@ async function probeShadow(ir, opts) {
         apiKeys: opts.apiKeys,
         fetchImpl: opts.fetchImpl,
         providerOverrides: opts.providerOverrides
-      }
+      },
+      // alpha — probeShadow() is ALWAYS off the user-facing critical path: the
+      // consumer fires it from `onFinish` wrapped in `after()`/`waitUntil()`,
+      // after the response is flushed. So the sync-mode latency budget +
+      // slow-tier skip are no-ops here — slow candidates run to completion (this
+      // is in fact the right place to evaluate a slow reasoner). The
+      // maxLatencyMs/skipSlowTierInSync knobs aren't even exposed on
+      // ProbeShadowOptions for that reason.
+      sync: false
     });
   } catch {
   }

package/dist/index.mjs

@@ -33,7 +33,7 @@ import {
   loadChainsFromBrain,
   readBrainReadEnv,
   resolveProviderKey
-} from "./chunk-SAWTKMD4.mjs";
+} from "./chunk-HHWBB46W.mjs";
 import {
   ALIASES,
   LATENCY_TIER_MS,
@@ -44,7 +44,7 @@ import {
   latencyTierOf,
   profilesByProvider,
   tryGetProfile
-} from "./chunk-PKOFXEB3.mjs";
+} from "./chunk-CXH7KC4D.mjs";
 import {
   emitAdvisoryFired,
   emitCompileDone,
@@ -2914,7 +2914,10 @@ function buildShadowProbeRow(input) {
     // Full IR was replayed (not a truncated preview), so fidelity is 1.0 — the
     // prompt-fidelity guard never fires on these rows.
     prompt_fidelity: 1,
-    replay_source: "inline-full-ir"
+    replay_source: "inline-full-ir",
+    // alpha — migration 029. 'completed' is the default completed-probe shape;
+    // diagnostic rows (aborted/skipped) pass the explicit class.
+    outcome: input.outcome ?? "completed"
   };
 }
 async function recordShadowProbe(input) {
@@ -3811,15 +3814,54 @@ function hashForProbe(s) {
   for (let i = 0; i < s.length; i++) h = (h << 5) - h + s.charCodeAt(i) | 0;
   return `h${(h >>> 0).toString(16)}`;
 }
+var DEFAULT_PROBE_MAX_LATENCY_MS = 15e3;
+function isSlowTierCandidate(candidate) {
+  const profile = tryGetProfile(candidate);
+  if (!profile) return false;
+  return latencyTierOf(profile) === "slow";
+}
 async function runProbeCandidates(args) {
   try {
     if (!shouldSampleProbe(args.cfg.sampleRate ?? 0.05)) return;
     const candidates = normalizeProbeCandidates(args.cfg.candidates);
     const promptHash = hashForProbe(args.ir.currentTurn?.content ?? "");
+    const budgetMs = args.cfg.maxLatencyMs ?? DEFAULT_PROBE_MAX_LATENCY_MS;
+    const deadline = args.sync ? Date.now() + budgetMs : Number.POSITIVE_INFINITY;
+    const skipSlow = args.sync && (args.cfg.skipSlowTierInSync ?? true);
+    const recordDiagnostic = async (candidate, outcome) => {
+      await recordShadowProbe({
+        appId: args.ir.appId,
+        archetype: args.ir.intent.archetype,
+        family: deriveFamilyFromModelId(candidate) ?? "unknown",
+        candidateModel: candidate,
+        currentModel: args.servedModel,
+        promptHash,
+        // Served leg only — the candidate never produced a comparable response.
+        currentResponsePreview: args.servedResponse.text.slice(0, 2e3),
+        tokensCurrentIn: args.servedResponse.tokens.input,
+        tokensCurrentOut: args.servedResponse.tokens.output,
+        latencyCurrentMs: args.servedLatencyMs,
+        outcome
+      });
+    };
     for (const candidate of candidates) {
       if (candidate === args.servedModel) continue;
       if (deriveFamilyFromModelId(candidate) === "claude-opus") continue;
       if (!isModelReachable(candidate, { apiKeys: args.exec.apiKeys })) continue;
+      if (skipSlow && isSlowTierCandidate(candidate)) {
+        try {
+          await recordDiagnostic(candidate, "skipped_slow_tier_sync");
+        } catch {
+        }
+        continue;
+      }
+      if (args.sync && Date.now() >= deadline) {
+        try {
+          await recordDiagnostic(candidate, "aborted_latency_budget");
+        } catch {
+        }
+        break;
+      }
       try {
         const candCompile = compileAndRegister(
           {
@@ -3830,11 +3872,32 @@ async function runProbeCandidates(args) {
           args.exec
         );
         const candStart = Date.now();
-        const exec = await execute(candCompile.request, {
+        let timer;
+        const execPromise = execute(candCompile.request, {
           apiKeys: args.exec.apiKeys,
           fetchImpl: args.exec.fetchImpl,
           providerOverrides: args.exec.providerOverrides
-        });
+        }).then((exec2) => ({ kind: "exec", exec: exec2 })).catch(() => ({ kind: "failed" }));
+        let raced;
+        if (args.sync) {
+          const remaining = Math.max(0, deadline - Date.now());
+          const timeoutPromise = new Promise((resolve) => {
+            timer = setTimeout(() => resolve({ kind: "timeout" }), remaining);
+          });
+          raced = await Promise.race([execPromise, timeoutPromise]);
+          if (timer) clearTimeout(timer);
+        } else {
+          raced = await execPromise;
+        }
+        if (raced.kind === "timeout") {
+          try {
+            await recordDiagnostic(candidate, "aborted_latency_budget");
+          } catch {
+          }
+          break;
+        }
+        if (raced.kind === "failed") continue;
+        const exec = raced.exec;
         const candidateLatencyMs = Date.now() - candStart;
         if (!exec.ok) continue;
         await recordShadowProbe({
@@ -3854,7 +3917,8 @@ async function runProbeCandidates(args) {
           // mirrors the user's actual wait; candidate latency is measured only
           // here and stored nowhere else (irrecoverable if not captured now).
           latencyCurrentMs: args.servedLatencyMs,
-          latencyCandidateMs: candidateLatencyMs
+          latencyCandidateMs: candidateLatencyMs,
+          outcome: "completed"
         });
       } catch {
       }
@@ -3872,7 +3936,11 @@ async function runShadowProbe(args) {
     servedResponse: args.servedResponse,
     servedLatencyMs: args.servedLatencyMs,
     // CallOptions is a structural superset of ProbeExecOpts.
-    exec: args.opts
+    exec: args.opts,
+    // alpha — the call()-inline path is on the user's critical path exactly when
+    // BrainConfig.sync is set (call() awaits the probe before returning). That's
+    // the only case where the latency budget + slow-tier skip must fire.
+    sync: isBrainSync()
   });
 }
 async function probeShadow(ir, opts) {
@@ -3905,7 +3973,15 @@ async function probeShadow(ir, opts) {
         apiKeys: opts.apiKeys,
         fetchImpl: opts.fetchImpl,
         providerOverrides: opts.providerOverrides
-      }
+      },
+      // alpha — probeShadow() is ALWAYS off the user-facing critical path: the
+      // consumer fires it from `onFinish` wrapped in `after()`/`waitUntil()`,
+      // after the response is flushed. So the sync-mode latency budget +
+      // slow-tier skip are no-ops here — slow candidates run to completion (this
+      // is in fact the right place to evaluate a slow reasoner). The
+      // maxLatencyMs/skipSlowTierInSync knobs aren't even exposed on
+      // ProbeShadowOptions for that reason.
+      sync: false
     });
   } catch {
   }

package/dist/{ir-BBKgsUX7.d.mts → ir-dDcG8Pvu.d.mts}

@@ -830,6 +830,49 @@ interface ShadowProbeConfig {
     judge?: 'opus' | 'off';
     /** Per-(appId, archetype, candidate) daily cap. Phase 2 (needs brain-count read). Default 20. */
     maxPerDay?: number;
+    /**
+     * alpha — latency budget (ms) for the probe leg. **Only enforced in sync mode**
+     * (`BrainConfig.sync === true`), where `call()` awaits the probe before returning
+     * the served response (PB-class Edge consumers, L-086) and the candidate's
+     * latency therefore lands on the user-facing critical path.
+     *
+     * The probe path races against this budget: if the candidate(s) don't finish
+     * within `maxLatencyMs`, the probe aborts, `call()` returns the already-served
+     * response immediately, and an `outcome='aborted_latency_budget'` row is
+     * recorded (no verdict, no false quality data). **The user is never delayed
+     * past the budget.** Default `15000`.
+     *
+     * No-op for fire-and-forget consumers (`sync` unset/false, and every
+     * `probeShadow()` caller fired from `after()`/`waitUntil()`) — they don't block
+     * the user, so there's no latency to bound. The probe runs to completion there.
+     *
+     * Root cause this closes (PB s57 dogfood incident, 2026-06-05): PB arms the
+     * probe inline with `sync:true` on a `maxDuration:120` analyze route; arming a
+     * `latency_tier='slow'` candidate (deepseek-v4-pro, ~78–84s) pushed total
+     * handler time past the frontend's patience and the served analysis came back
+     * empty. A sync probe had no latency budget — this field is the budget.
+     */
+    maxLatencyMs?: number;
+    /**
+     * alpha — when true (the default) **in sync mode**, skip a candidate whose
+     * registry `latency_tier === 'slow'` *before starting it*: a slow-tier model
+     * (e.g. deepseek-v4-pro / deepseek-v4-flash, both `slow` = ~24s+ p50) cannot
+     * fit a sane inline budget, so starting it just to abort it wastes a provider
+     * call. An `outcome='skipped_slow_tier_sync'` row is recorded so the offline
+     * rollup can see the skip (not a silent drop, not a false verdict). Fail-safe.
+     *
+     * **The deeper rule (slow-reasoner → offline-mode):** inline shadow-probing is
+     * for FAST candidates only. To evaluate a slow reasoner you need the offline /
+     * async probe path (the Phase-2 batch direction) which runs off the response
+     * entirely — never the inline sync probe. Set this `false` only if you've moved
+     * the budget high enough that a slow candidate genuinely fits (rare), or you're
+     * in a non-sync consumer where this flag is a no-op anyway.
+     *
+     * No-op for fire-and-forget consumers (`sync` unset/false; `probeShadow()`):
+     * there's no user latency to protect, so slow candidates run normally. Default
+     * `true`.
+     */
+    skipSlowTierInSync?: boolean;
 }
 interface CallOptions {
     /** Forwarded to compile(). */

package/dist/{ir-D3n-pBYI.d.ts → ir-rUUojj0s.d.ts}

@@ -830,6 +830,49 @@ interface ShadowProbeConfig {
     judge?: 'opus' | 'off';
     /** Per-(appId, archetype, candidate) daily cap. Phase 2 (needs brain-count read). Default 20. */
     maxPerDay?: number;
+    /**
+     * alpha — latency budget (ms) for the probe leg. **Only enforced in sync mode**
+     * (`BrainConfig.sync === true`), where `call()` awaits the probe before returning
+     * the served response (PB-class Edge consumers, L-086) and the candidate's
+     * latency therefore lands on the user-facing critical path.
+     *
+     * The probe path races against this budget: if the candidate(s) don't finish
+     * within `maxLatencyMs`, the probe aborts, `call()` returns the already-served
+     * response immediately, and an `outcome='aborted_latency_budget'` row is
+     * recorded (no verdict, no false quality data). **The user is never delayed
+     * past the budget.** Default `15000`.
+     *
+     * No-op for fire-and-forget consumers (`sync` unset/false, and every
+     * `probeShadow()` caller fired from `after()`/`waitUntil()`) — they don't block
+     * the user, so there's no latency to bound. The probe runs to completion there.
+     *
+     * Root cause this closes (PB s57 dogfood incident, 2026-06-05): PB arms the
+     * probe inline with `sync:true` on a `maxDuration:120` analyze route; arming a
+     * `latency_tier='slow'` candidate (deepseek-v4-pro, ~78–84s) pushed total
+     * handler time past the frontend's patience and the served analysis came back
+     * empty. A sync probe had no latency budget — this field is the budget.
+     */
+    maxLatencyMs?: number;
+    /**
+     * alpha — when true (the default) **in sync mode**, skip a candidate whose
+     * registry `latency_tier === 'slow'` *before starting it*: a slow-tier model
+     * (e.g. deepseek-v4-pro / deepseek-v4-flash, both `slow` = ~24s+ p50) cannot
+     * fit a sane inline budget, so starting it just to abort it wastes a provider
+     * call. An `outcome='skipped_slow_tier_sync'` row is recorded so the offline
+     * rollup can see the skip (not a silent drop, not a false verdict). Fail-safe.
+     *
+     * **The deeper rule (slow-reasoner → offline-mode):** inline shadow-probing is
+     * for FAST candidates only. To evaluate a slow reasoner you need the offline /
+     * async probe path (the Phase-2 batch direction) which runs off the response
+     * entirely — never the inline sync probe. Set this `false` only if you've moved
+     * the budget high enough that a slow candidate genuinely fits (rare), or you're
+     * in a non-sync consumer where this flag is a no-op anyway.
+     *
+     * No-op for fire-and-forget consumers (`sync` unset/false; `probeShadow()`):
+     * there's no user latency to protect, so slow candidates run normally. Default
+     * `true`.
+     */
+    skipSlowTierInSync?: boolean;
 }
 interface CallOptions {
     /** Forwarded to compile(). */

package/dist/profiles.d.mts

@@ -1,4 +1,4 @@
-import { k as Provider } from './ir-BBKgsUX7.mjs';
+import { k as Provider } from './ir-dDcG8Pvu.mjs';
 import { IntentArchetypeName } from './dialect.mjs';
 
 /**

package/dist/profiles.d.ts

@@ -1,4 +1,4 @@
-import { k as Provider } from './ir-D3n-pBYI.js';
+import { k as Provider } from './ir-rUUojj0s.js';
 import { IntentArchetypeName } from './dialect.js';
 
 /**