@warmdrift/kgauto-compiler 2.0.0-alpha.45 → 2.0.0-alpha.47

package/dist/{chunk-ZHUD3I52.mjs → chunk-PKOFXEB3.mjs}

@@ -1,4 +1,15 @@
 // src/profiles.ts
+var LATENCY_TIER_MS = {
+  fast: 4e3,
+  medium: 11e3,
+  slow: 24e3
+};
+function latencyTierOf(profile) {
+  if (profile.latencyTier) return profile.latencyTier;
+  if (profile.weaknesses.includes("latency")) return "slow";
+  if (profile.strengths.includes("speed")) return "fast";
+  return "medium";
+}
 var ANTHROPIC_LOWERING_BASE = {
   system: { mode: "inline" },
   cache: {
@@ -545,6 +556,14 @@ var PROFILES_RAW = [
     ],
     strengths: ["cost", "1m_context", "json_output", "code", "reasoning"],
     weaknesses: ["parallel_tools", "large_tool_sets"],
+    // alpha.47 — explicit slow override. Tag derivation would say 'medium'
+    // (no 'latency' weakness, no 'speed' strength), but the alpha.46 shadow
+    // probe MEASURED deepseek-v4-flash at 20485ms served (2026-06-03) — ~2.3×
+    // gemini-2.5-flash on PB's synchronous /api/analyze path. The 'flash' name
+    // is DeepSeek's, not a speed promise. This is the row that, scoring 0.85
+    // baseQuality (it carries 'reasoning') with no latency counterweight,
+    // leapfrogged gemini-2.5-flash as PB's summarize leader once reachable.
+    latencyTier: "slow",
     notes: "Cheap workhorse. 1M context, 384k max output. Cache-hit input $0.0028/M (1/50\xD7 of miss). Aliased as `deepseek-chat` (non-thinking) and `deepseek-reasoner` (thinking) \u2014 see ALIASES.",
     // Master plan §6.2 anchor. Brain-validated tier 1 cross-provider for
     // classify (169 rows, 0% empty). Tier 0 for summarize-with-no-tools.
@@ -612,6 +631,11 @@ var PROFILES_RAW = [
     ],
     strengths: ["quality", "reasoning", "1m_context", "json_output", "code", "extended_thinking"],
     weaknesses: ["parallel_tools", "large_tool_sets"],
+    // alpha.47 — explicit slow override. Measured 47722ms on the alpha.46
+    // shadow probe (2026-06-03) — it's an extended-thinking reasoner, slowest
+    // 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.",
     // Master plan §3.3: tier 3 cross-provider for plan chain. Reasoning
     // bumped one notch over V4-Flash; same parallel-tool ceiling.
@@ -1264,6 +1288,8 @@ function profilesByProvider(provider) {
 }
 
 export {
+  LATENCY_TIER_MS,
+  latencyTierOf,
   ALIASES,
   _setProfileBrainHook,
   getProfile,

package/dist/{chunk-6MSJQCAP.mjs → chunk-SAWTKMD4.mjs}

@@ -1,6 +1,6 @@
 import {
   tryGetProfile
-} from "./chunk-ZHUD3I52.mjs";
+} from "./chunk-PKOFXEB3.mjs";
 
 // src/brain-query.ts
 var FRESH_SNAPSHOT = {

package/dist/glassbox-routes/index.js

@@ -610,6 +610,14 @@ var PROFILES_RAW = [
     ],
     strengths: ["cost", "1m_context", "json_output", "code", "reasoning"],
     weaknesses: ["parallel_tools", "large_tool_sets"],
+    // alpha.47 — explicit slow override. Tag derivation would say 'medium'
+    // (no 'latency' weakness, no 'speed' strength), but the alpha.46 shadow
+    // probe MEASURED deepseek-v4-flash at 20485ms served (2026-06-03) — ~2.3×
+    // gemini-2.5-flash on PB's synchronous /api/analyze path. The 'flash' name
+    // is DeepSeek's, not a speed promise. This is the row that, scoring 0.85
+    // baseQuality (it carries 'reasoning') with no latency counterweight,
+    // leapfrogged gemini-2.5-flash as PB's summarize leader once reachable.
+    latencyTier: "slow",
     notes: "Cheap workhorse. 1M context, 384k max output. Cache-hit input $0.0028/M (1/50\xD7 of miss). Aliased as `deepseek-chat` (non-thinking) and `deepseek-reasoner` (thinking) \u2014 see ALIASES.",
     // Master plan §6.2 anchor. Brain-validated tier 1 cross-provider for
     // classify (169 rows, 0% empty). Tier 0 for summarize-with-no-tools.
@@ -677,6 +685,11 @@ var PROFILES_RAW = [
     ],
     strengths: ["quality", "reasoning", "1m_context", "json_output", "code", "extended_thinking"],
     weaknesses: ["parallel_tools", "large_tool_sets"],
+    // alpha.47 — explicit slow override. Measured 47722ms on the alpha.46
+    // shadow probe (2026-06-03) — it's an extended-thinking reasoner, slowest
+    // 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.",
     // Master plan §3.3: tier 3 cross-provider for plan chain. Reasoning
     // bumped one notch over V4-Flash; same parallel-tool ceiling.

package/dist/glassbox-routes/index.mjs

@@ -1,10 +1,10 @@
 import {
   ARCHETYPE_FLOOR_DEFAULT,
   getDefaultFallbackChain
-} from "../chunk-6MSJQCAP.mjs";
+} from "../chunk-SAWTKMD4.mjs";
 import {
   tryGetProfile
-} from "../chunk-ZHUD3I52.mjs";
+} from "../chunk-PKOFXEB3.mjs";
 import {
   subscribe,
   subscribeApp

package/dist/index.d.mts

@@ -1,7 +1,7 @@
 import { C as CompilePolicy, N as NormalizedResponse, A as ApiKeys, P as ProviderOverrides, a as CompiledRequest, b as PromptIR, c as CallOptions, d as CallResult, S as SystemModelMessage, e as CompileResult, f as SectionRewrite, R as RecordInput, g as RecordOutcomeInput, O as OutcomeResult, h as OracleScore, B as BestPracticeAdvisory, i as Adapter, j as PerAxisMetrics, k as Provider, l as ChainEntry, G as Grounding } from './ir-BBKgsUX7.mjs';
 export { m as CallAttempt, n as CallError, o as ChainModelEntry, p as ChainWithGrounding, q as Constraints, F as FallbackReason, H as HistoryCachePolicy, I as IntentDeclaration, M as Message, r as MutationApplied, s as NormalizedTokens, t as OutcomeKind, u as PerAxisMetricsByModel, v as PromptSection, w as SectionKind, x as ShadowProbeConfig, T as ToolCall, y as ToolDefinition } from './ir-BBKgsUX7.mjs';
 import { ModelProfile, ArchetypeConvention } from './profiles.mjs';
-export { ALIASES, CacheStrategy, CliffRule, LoweringSpec, RecoveryRule, StructuredOutputCapability, SystemPromptMode, allProfiles, getProfile, profilesByProvider, tryGetProfile } from './profiles.mjs';
+export { ALIASES, CacheStrategy, CliffRule, LATENCY_TIER_MS, LatencyTier, LoweringSpec, RecoveryRule, StructuredOutputCapability, SystemPromptMode, allProfiles, getProfile, latencyTierOf, profilesByProvider, tryGetProfile } from './profiles.mjs';
 import { IntentArchetypeName } from './dialect.mjs';
 export { ALL_ARCHETYPES, ContextBucket, DIALECT_VERSION, HistoryDepth, INTENT_ARCHETYPES, OutputMode, ShapeSignature, ToolCountBucket, bucketContext, bucketHistory, bucketToolCount, hashShape, isArchetype, learningKey } from './dialect.mjs';
 
@@ -363,6 +363,15 @@ interface ShadowProbeRecordInput {
     tokensCurrentOut?: number;
     tokensCandidateIn?: number;
     tokensCandidateOut?: number;
+    /**
+     * Wall-clock latency of the served call, ms (alpha.46). The third swap-decision
+     * axis alongside quality + cost — a verdict needs to know the candidate is
+     * slower, not just better/cheaper. Served latency mirrors
+     * `compile_outcomes.latency_ms`; carried here so a probe row is self-contained.
+     */
+    latencyCurrentMs?: number;
+    /** Wall-clock latency of the candidate replay call, ms (alpha.46). */
+    latencyCandidateMs?: number;
 }
 /**
  * Pure builder for the `probe_outcomes` row written by the inline shadow-probe.
@@ -390,6 +399,8 @@ declare function buildShadowProbeRow(input: ShadowProbeRecordInput): {
     tokens_current_out: number | null;
     tokens_candidate_in: number | null;
     tokens_candidate_out: number | null;
+    latency_current_ms: number | null;
+    latency_candidate_ms: number | null;
     prompt_fidelity: number;
     replay_source: 'inline-full-ir';
 };

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { C as CompilePolicy, N as NormalizedResponse, A as ApiKeys, P as ProviderOverrides, a as CompiledRequest, b as PromptIR, c as CallOptions, d as CallResult, S as SystemModelMessage, e as CompileResult, f as SectionRewrite, R as RecordInput, g as RecordOutcomeInput, O as OutcomeResult, h as OracleScore, B as BestPracticeAdvisory, i as Adapter, j as PerAxisMetrics, k as Provider, l as ChainEntry, G as Grounding } from './ir-D3n-pBYI.js';
 export { m as CallAttempt, n as CallError, o as ChainModelEntry, p as ChainWithGrounding, q as Constraints, F as FallbackReason, H as HistoryCachePolicy, I as IntentDeclaration, M as Message, r as MutationApplied, s as NormalizedTokens, t as OutcomeKind, u as PerAxisMetricsByModel, v as PromptSection, w as SectionKind, x as ShadowProbeConfig, T as ToolCall, y as ToolDefinition } from './ir-D3n-pBYI.js';
 import { ModelProfile, ArchetypeConvention } from './profiles.js';
-export { ALIASES, CacheStrategy, CliffRule, LoweringSpec, RecoveryRule, StructuredOutputCapability, SystemPromptMode, allProfiles, getProfile, profilesByProvider, tryGetProfile } from './profiles.js';
+export { ALIASES, CacheStrategy, CliffRule, LATENCY_TIER_MS, LatencyTier, LoweringSpec, RecoveryRule, StructuredOutputCapability, SystemPromptMode, allProfiles, getProfile, latencyTierOf, profilesByProvider, tryGetProfile } from './profiles.js';
 import { IntentArchetypeName } from './dialect.js';
 export { ALL_ARCHETYPES, ContextBucket, DIALECT_VERSION, HistoryDepth, INTENT_ARCHETYPES, OutputMode, ShapeSignature, ToolCountBucket, bucketContext, bucketHistory, bucketToolCount, hashShape, isArchetype, learningKey } from './dialect.js';
 
@@ -363,6 +363,15 @@ interface ShadowProbeRecordInput {
     tokensCurrentOut?: number;
     tokensCandidateIn?: number;
     tokensCandidateOut?: number;
+    /**
+     * Wall-clock latency of the served call, ms (alpha.46). The third swap-decision
+     * axis alongside quality + cost — a verdict needs to know the candidate is
+     * slower, not just better/cheaper. Served latency mirrors
+     * `compile_outcomes.latency_ms`; carried here so a probe row is self-contained.
+     */
+    latencyCurrentMs?: number;
+    /** Wall-clock latency of the candidate replay call, ms (alpha.46). */
+    latencyCandidateMs?: number;
 }
 /**
  * Pure builder for the `probe_outcomes` row written by the inline shadow-probe.
@@ -390,6 +399,8 @@ declare function buildShadowProbeRow(input: ShadowProbeRecordInput): {
     tokens_current_out: number | null;
     tokens_candidate_in: number | null;
     tokens_candidate_out: number | null;
+    latency_current_ms: number | null;
+    latency_candidate_ms: number | null;
     prompt_fidelity: number;
     replay_source: 'inline-full-ir';
 };

package/dist/index.js

@@ -30,6 +30,7 @@ __export(index_exports, {
   DIALECT_VERSION: () => DIALECT_VERSION,
   FamilyResolutionError: () => FamilyResolutionError,
   INTENT_ARCHETYPES: () => INTENT_ARCHETYPES,
+  LATENCY_TIER_MS: () => LATENCY_TIER_MS,
   MEASURED_GROUNDING_MIN_N: () => MEASURED_GROUNDING_MIN_N,
   PRODUCER_OWNED_RULE_CODES: () => PRODUCER_OWNED_RULE_CODES,
   PROVIDER_ENV_KEYS: () => PROVIDER_ENV_KEYS,
@@ -76,6 +77,7 @@ __export(index_exports, {
   isExclusionFindingsBrainActive: () => isExclusionFindingsBrainActive,
   isModelReachable: () => isModelReachable,
   isProviderReachable: () => isProviderReachable,
+  latencyTierOf: () => latencyTierOf,
   learningKey: () => learningKey,
   loadAliasesFromBrain: () => loadAliasesFromBrain,
   loadArchetypePerfFromBrain: () => loadArchetypePerfFromBrain,
@@ -274,6 +276,17 @@ function mapPerAxisMetrics(raw, fallbackAppId, fallbackArchetype, fallbackModel,
 }
 
 // src/profiles.ts
+var LATENCY_TIER_MS = {
+  fast: 4e3,
+  medium: 11e3,
+  slow: 24e3
+};
+function latencyTierOf(profile) {
+  if (profile.latencyTier) return profile.latencyTier;
+  if (profile.weaknesses.includes("latency")) return "slow";
+  if (profile.strengths.includes("speed")) return "fast";
+  return "medium";
+}
 var ANTHROPIC_LOWERING_BASE = {
   system: { mode: "inline" },
   cache: {
@@ -820,6 +833,14 @@ var PROFILES_RAW = [
     ],
     strengths: ["cost", "1m_context", "json_output", "code", "reasoning"],
     weaknesses: ["parallel_tools", "large_tool_sets"],
+    // alpha.47 — explicit slow override. Tag derivation would say 'medium'
+    // (no 'latency' weakness, no 'speed' strength), but the alpha.46 shadow
+    // probe MEASURED deepseek-v4-flash at 20485ms served (2026-06-03) — ~2.3×
+    // gemini-2.5-flash on PB's synchronous /api/analyze path. The 'flash' name
+    // is DeepSeek's, not a speed promise. This is the row that, scoring 0.85
+    // baseQuality (it carries 'reasoning') with no latency counterweight,
+    // leapfrogged gemini-2.5-flash as PB's summarize leader once reachable.
+    latencyTier: "slow",
     notes: "Cheap workhorse. 1M context, 384k max output. Cache-hit input $0.0028/M (1/50\xD7 of miss). Aliased as `deepseek-chat` (non-thinking) and `deepseek-reasoner` (thinking) \u2014 see ALIASES.",
     // Master plan §6.2 anchor. Brain-validated tier 1 cross-provider for
     // classify (169 rows, 0% empty). Tier 0 for summarize-with-no-tools.
@@ -887,6 +908,11 @@ var PROFILES_RAW = [
     ],
     strengths: ["quality", "reasoning", "1m_context", "json_output", "code", "extended_thinking"],
     weaknesses: ["parallel_tools", "large_tool_sets"],
+    // alpha.47 — explicit slow override. Measured 47722ms on the alpha.46
+    // shadow probe (2026-06-03) — it's an extended-thinking reasoner, slowest
+    // 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.",
     // Master plan §3.3: tier 3 cross-provider for plan chain. Reasoning
     // bumped one notch over V4-Flash; same parallel-tool ceiling.
@@ -2360,6 +2386,8 @@ function passApplyCliffs(ir, profile, estimatedInputTokens) {
   }
   return { value: { ir: nextIR, loweringHints: hints }, mutations };
 }
+var LATENCY_OVERAGE_WEIGHT = 0.6;
+var LATENCY_PENALTY_CAP = 1;
 function passScoreTargets(ir, opts) {
   const constraints = ir.constraints ?? {};
   const policy = opts.policy ?? {};
@@ -2415,7 +2443,16 @@ function passScoreTargets(ir, opts) {
     const callerOrderBoost = (modelIds.length - modelIds.indexOf(modelId)) * 0.1;
     const costPenalty = estimatedCostUsd * 5;
     const preferredBoost = preferredSet.has(modelId) ? 0.5 : 0;
-    const rank = qualityScore + callerOrderBoost - costPenalty - reasons.length * 10 + preferredBoost;
+    let latencyPenalty = 0;
+    const maxLatencyMs = constraints.maxLatencyMs;
+    if (typeof maxLatencyMs === "number" && maxLatencyMs > 0) {
+      const tierMs = LATENCY_TIER_MS[latencyTierOf(profile)];
+      if (tierMs > maxLatencyMs) {
+        const overage = (tierMs - maxLatencyMs) / maxLatencyMs;
+        latencyPenalty = Math.min(LATENCY_OVERAGE_WEIGHT * overage, LATENCY_PENALTY_CAP);
+      }
+    }
+    const rank = qualityScore + callerOrderBoost - costPenalty - reasons.length * 10 + preferredBoost - latencyPenalty;
     scores.push({
       modelId,
       estimatedCostUsd,
@@ -2448,6 +2485,15 @@ function passScoreTargets(ir, opts) {
         description: `Model ${modelId} rank boosted by CompilePolicy.preferredModels`
       });
     }
+    if (latencyPenalty > 0) {
+      const tier = latencyTierOf(profile);
+      policyMutations.push({
+        id: `latency-downrank-${modelId}`,
+        source: "latency_guard",
+        passName: "score_targets",
+        description: `Model ${modelId} rank down ${latencyPenalty.toFixed(2)} \u2014 latency tier '${tier}' (~${LATENCY_TIER_MS[tier]}ms) exceeds constraints.maxLatencyMs (${maxLatencyMs}ms)`
+      });
+    }
   }
   return { value: scores, mutations: policyMutations };
 }
@@ -4494,6 +4540,8 @@ function buildShadowProbeRow(input) {
     tokens_current_out: input.tokensCurrentOut ?? null,
     tokens_candidate_in: input.tokensCandidateIn ?? null,
     tokens_candidate_out: input.tokensCandidateOut ?? null,
+    latency_current_ms: input.latencyCurrentMs ?? null,
+    latency_candidate_ms: input.latencyCandidateMs ?? null,
     // 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,
@@ -6014,7 +6062,8 @@ async function call(ir, opts = {}) {
           ir,
           opts,
           servedModel: targetModel,
-          servedResponse: validated.response
+          servedResponse: validated.response,
+          servedLatencyMs: latencyMs2
         });
         if (isBrainSync()) {
           await probe;
@@ -6127,11 +6176,13 @@ async function runShadowProbe(args) {
           },
           args.opts
         );
+        const candStart = Date.now();
         const exec = await execute(candCompile.request, {
           apiKeys: args.opts.apiKeys,
           fetchImpl: args.opts.fetchImpl,
           providerOverrides: args.opts.providerOverrides
         });
+        const candidateLatencyMs = Date.now() - candStart;
         if (!exec.ok) continue;
         await recordShadowProbe({
           appId: args.ir.appId,
@@ -6145,7 +6196,12 @@ async function runShadowProbe(args) {
           tokensCurrentIn: args.servedResponse.tokens.input,
           tokensCurrentOut: args.servedResponse.tokens.output,
           tokensCandidateIn: exec.response.tokens.input,
-          tokensCandidateOut: exec.response.tokens.output
+          tokensCandidateOut: exec.response.tokens.output,
+          // alpha.46 — speed is the third swap-decision axis. Served latency
+          // 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
         });
       } catch {
       }
@@ -6681,6 +6737,7 @@ function compile2(ir, opts) {
   DIALECT_VERSION,
   FamilyResolutionError,
   INTENT_ARCHETYPES,
+  LATENCY_TIER_MS,
   MEASURED_GROUNDING_MIN_N,
   PRODUCER_OWNED_RULE_CODES,
   PROVIDER_ENV_KEYS,
@@ -6727,6 +6784,7 @@ function compile2(ir, opts) {
   isExclusionFindingsBrainActive,
   isModelReachable,
   isProviderReachable,
+  latencyTierOf,
   learningKey,
   loadAliasesFromBrain,
   loadArchetypePerfFromBrain,

package/dist/index.mjs

@@ -33,16 +33,18 @@ import {
   loadChainsFromBrain,
   readBrainReadEnv,
   resolveProviderKey
-} from "./chunk-6MSJQCAP.mjs";
+} from "./chunk-SAWTKMD4.mjs";
 import {
   ALIASES,
+  LATENCY_TIER_MS,
   _setProfileBrainHook,
   allProfiles,
   allProfilesRaw,
   getProfile,
+  latencyTierOf,
   profilesByProvider,
   tryGetProfile
-} from "./chunk-ZHUD3I52.mjs";
+} from "./chunk-PKOFXEB3.mjs";
 import {
   emitAdvisoryFired,
   emitCompileDone,
@@ -710,6 +712,8 @@ function passApplyCliffs(ir, profile, estimatedInputTokens) {
   }
   return { value: { ir: nextIR, loweringHints: hints }, mutations };
 }
+var LATENCY_OVERAGE_WEIGHT = 0.6;
+var LATENCY_PENALTY_CAP = 1;
 function passScoreTargets(ir, opts) {
   const constraints = ir.constraints ?? {};
   const policy = opts.policy ?? {};
@@ -765,7 +769,16 @@ function passScoreTargets(ir, opts) {
     const callerOrderBoost = (modelIds.length - modelIds.indexOf(modelId)) * 0.1;
     const costPenalty = estimatedCostUsd * 5;
     const preferredBoost = preferredSet.has(modelId) ? 0.5 : 0;
-    const rank = qualityScore + callerOrderBoost - costPenalty - reasons.length * 10 + preferredBoost;
+    let latencyPenalty = 0;
+    const maxLatencyMs = constraints.maxLatencyMs;
+    if (typeof maxLatencyMs === "number" && maxLatencyMs > 0) {
+      const tierMs = LATENCY_TIER_MS[latencyTierOf(profile)];
+      if (tierMs > maxLatencyMs) {
+        const overage = (tierMs - maxLatencyMs) / maxLatencyMs;
+        latencyPenalty = Math.min(LATENCY_OVERAGE_WEIGHT * overage, LATENCY_PENALTY_CAP);
+      }
+    }
+    const rank = qualityScore + callerOrderBoost - costPenalty - reasons.length * 10 + preferredBoost - latencyPenalty;
     scores.push({
       modelId,
       estimatedCostUsd,
@@ -798,6 +811,15 @@ function passScoreTargets(ir, opts) {
         description: `Model ${modelId} rank boosted by CompilePolicy.preferredModels`
       });
     }
+    if (latencyPenalty > 0) {
+      const tier = latencyTierOf(profile);
+      policyMutations.push({
+        id: `latency-downrank-${modelId}`,
+        source: "latency_guard",
+        passName: "score_targets",
+        description: `Model ${modelId} rank down ${latencyPenalty.toFixed(2)} \u2014 latency tier '${tier}' (~${LATENCY_TIER_MS[tier]}ms) exceeds constraints.maxLatencyMs (${maxLatencyMs}ms)`
+      });
+    }
   }
   return { value: scores, mutations: policyMutations };
 }
@@ -2844,6 +2866,8 @@ function buildShadowProbeRow(input) {
     tokens_current_out: input.tokensCurrentOut ?? null,
     tokens_candidate_in: input.tokensCandidateIn ?? null,
     tokens_candidate_out: input.tokensCandidateOut ?? null,
+    latency_current_ms: input.latencyCurrentMs ?? null,
+    latency_candidate_ms: input.latencyCandidateMs ?? null,
     // 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,
@@ -3649,7 +3673,8 @@ async function call(ir, opts = {}) {
           ir,
           opts,
           servedModel: targetModel,
-          servedResponse: validated.response
+          servedResponse: validated.response,
+          servedLatencyMs: latencyMs2
         });
         if (isBrainSync()) {
           await probe;
@@ -3762,11 +3787,13 @@ async function runShadowProbe(args) {
           },
           args.opts
         );
+        const candStart = Date.now();
         const exec = await execute(candCompile.request, {
           apiKeys: args.opts.apiKeys,
           fetchImpl: args.opts.fetchImpl,
           providerOverrides: args.opts.providerOverrides
         });
+        const candidateLatencyMs = Date.now() - candStart;
         if (!exec.ok) continue;
         await recordShadowProbe({
           appId: args.ir.appId,
@@ -3780,7 +3807,12 @@ async function runShadowProbe(args) {
           tokensCurrentIn: args.servedResponse.tokens.input,
           tokensCurrentOut: args.servedResponse.tokens.output,
           tokensCandidateIn: exec.response.tokens.input,
-          tokensCandidateOut: exec.response.tokens.output
+          tokensCandidateOut: exec.response.tokens.output,
+          // alpha.46 — speed is the third swap-decision axis. Served latency
+          // 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
         });
       } catch {
       }
@@ -4315,6 +4347,7 @@ export {
   DIALECT_VERSION,
   FamilyResolutionError,
   INTENT_ARCHETYPES,
+  LATENCY_TIER_MS,
   MEASURED_GROUNDING_MIN_N,
   PRODUCER_OWNED_RULE_CODES,
   PROVIDER_ENV_KEYS,
@@ -4361,6 +4394,7 @@ export {
   isExclusionFindingsBrainActive,
   isModelReachable,
   isProviderReachable,
+  latencyTierOf,
   learningKey,
   loadAliasesFromBrain,
   loadArchetypePerfFromBrain,

package/dist/profiles.d.mts

@@ -145,6 +145,14 @@ interface LoweringSpec {
         default?: number | 'auto' | 'off';
     };
 }
+/**
+ * Coarse latency bucket for a model. alpha.47 — the third swap axis
+ * (cost / quality / SPEED). We bucket rather than store per-model ms because
+ * served latency varies with token count; honest precision is the tier, not a
+ * false-precise number. See {@link LATENCY_TIER_MS} for the representative ms
+ * each tier maps to when compared against `constraints.maxLatencyMs`.
+ */
+type LatencyTier = 'fast' | 'medium' | 'slow';
 interface ModelProfile {
     id: string;
     provider: Provider;
@@ -163,6 +171,16 @@ interface ModelProfile {
     recovery: RecoveryRule[];
     strengths: string[];
     weaknesses: string[];
+    /**
+     * alpha.47 — explicit latency bucket. OPTIONAL: when unset, `latencyTierOf`
+     * derives it from the tags above (`weaknesses` includes `'latency'` → slow,
+     * `strengths` includes `'speed'` → fast, else medium). Set this explicitly
+     * ONLY when measured evidence contradicts the tag derivation — e.g.
+     * `deepseek-v4-flash` carries no `'latency'` weakness yet measures ~20s
+     * (alpha.46 shadow-probe). Carry provenance in an inline comment when you
+     * override, same discipline as capability data (step zero / L-081).
+     */
+    latencyTier?: LatencyTier;
     notes?: string;
     verifiedAgainstDocs?: string;
     /**
@@ -236,6 +254,26 @@ interface ModelProfile {
      */
     archetypeConventions?: ArchetypeConvention[];
 }
+/**
+ * Representative p50 latency (ms) per tier. Coarse on purpose — used only to
+ * compare a model against `constraints.maxLatencyMs`, never reported as a
+ * per-model number. Grounded: alpha.46 shadow-probe measured
+ * `deepseek-v4-flash` at 20485ms and `deepseek-v4-pro` at 47722ms (2026-06-03),
+ * both bucket `slow`; gemini-2.5-flash / haiku-4-5 serve in single-digit
+ * seconds → `fast`; mid-tier (sonnet, gemini-pro) → `medium`. Phase 2 can swap
+ * these buckets for measured per-(archetype,model) p50 from
+ * `compile_outcomes.latency_ms` once enough served rows accumulate.
+ */
+declare const LATENCY_TIER_MS: Record<LatencyTier, number>;
+/**
+ * Resolve a model's latency tier. Explicit `profile.latencyTier` wins;
+ * otherwise derive from the tags already on the profile so we don't maintain a
+ * second source of truth that can silently disagree (L-073 family):
+ *   - `weaknesses` includes `'latency'` → `'slow'`
+ *   - `strengths` includes `'speed'`    → `'fast'`
+ *   - else                              → `'medium'`
+ */
+declare function latencyTierOf(profile: ModelProfile): LatencyTier;
 declare const ALIASES: Record<string, string>;
 interface ProfileBrainHook {
     getProfile?: (canonicalId: string) => ModelProfile | undefined;
@@ -251,4 +289,4 @@ declare function allProfiles(): readonly ModelProfile[];
 declare function allProfilesRaw(): readonly ModelProfile[];
 declare function profilesByProvider(provider: Provider): readonly ModelProfile[];
 
-export { ALIASES, type ArchetypeConvention, type CacheStrategy, type CliffRule, type LoweringSpec, type ModelProfile, type RecoveryRule, type StructuredOutputCapability, type SystemPromptMode, _setProfileBrainHook, allProfiles, allProfilesRaw, getProfile, profilesByProvider, tryGetProfile };
+export { ALIASES, type ArchetypeConvention, type CacheStrategy, type CliffRule, LATENCY_TIER_MS, type LatencyTier, type LoweringSpec, type ModelProfile, type RecoveryRule, type StructuredOutputCapability, type SystemPromptMode, _setProfileBrainHook, allProfiles, allProfilesRaw, getProfile, latencyTierOf, profilesByProvider, tryGetProfile };

package/dist/profiles.d.ts

@@ -145,6 +145,14 @@ interface LoweringSpec {
         default?: number | 'auto' | 'off';
     };
 }
+/**
+ * Coarse latency bucket for a model. alpha.47 — the third swap axis
+ * (cost / quality / SPEED). We bucket rather than store per-model ms because
+ * served latency varies with token count; honest precision is the tier, not a
+ * false-precise number. See {@link LATENCY_TIER_MS} for the representative ms
+ * each tier maps to when compared against `constraints.maxLatencyMs`.
+ */
+type LatencyTier = 'fast' | 'medium' | 'slow';
 interface ModelProfile {
     id: string;
     provider: Provider;
@@ -163,6 +171,16 @@ interface ModelProfile {
     recovery: RecoveryRule[];
     strengths: string[];
     weaknesses: string[];
+    /**
+     * alpha.47 — explicit latency bucket. OPTIONAL: when unset, `latencyTierOf`
+     * derives it from the tags above (`weaknesses` includes `'latency'` → slow,
+     * `strengths` includes `'speed'` → fast, else medium). Set this explicitly
+     * ONLY when measured evidence contradicts the tag derivation — e.g.
+     * `deepseek-v4-flash` carries no `'latency'` weakness yet measures ~20s
+     * (alpha.46 shadow-probe). Carry provenance in an inline comment when you
+     * override, same discipline as capability data (step zero / L-081).
+     */
+    latencyTier?: LatencyTier;
     notes?: string;
     verifiedAgainstDocs?: string;
     /**
@@ -236,6 +254,26 @@ interface ModelProfile {
      */
     archetypeConventions?: ArchetypeConvention[];
 }
+/**
+ * Representative p50 latency (ms) per tier. Coarse on purpose — used only to
+ * compare a model against `constraints.maxLatencyMs`, never reported as a
+ * per-model number. Grounded: alpha.46 shadow-probe measured
+ * `deepseek-v4-flash` at 20485ms and `deepseek-v4-pro` at 47722ms (2026-06-03),
+ * both bucket `slow`; gemini-2.5-flash / haiku-4-5 serve in single-digit
+ * seconds → `fast`; mid-tier (sonnet, gemini-pro) → `medium`. Phase 2 can swap
+ * these buckets for measured per-(archetype,model) p50 from
+ * `compile_outcomes.latency_ms` once enough served rows accumulate.
+ */
+declare const LATENCY_TIER_MS: Record<LatencyTier, number>;
+/**
+ * Resolve a model's latency tier. Explicit `profile.latencyTier` wins;
+ * otherwise derive from the tags already on the profile so we don't maintain a
+ * second source of truth that can silently disagree (L-073 family):
+ *   - `weaknesses` includes `'latency'` → `'slow'`
+ *   - `strengths` includes `'speed'`    → `'fast'`
+ *   - else                              → `'medium'`
+ */
+declare function latencyTierOf(profile: ModelProfile): LatencyTier;
 declare const ALIASES: Record<string, string>;
 interface ProfileBrainHook {
     getProfile?: (canonicalId: string) => ModelProfile | undefined;
@@ -251,4 +289,4 @@ declare function allProfiles(): readonly ModelProfile[];
 declare function allProfilesRaw(): readonly ModelProfile[];
 declare function profilesByProvider(provider: Provider): readonly ModelProfile[];
 
-export { ALIASES, type ArchetypeConvention, type CacheStrategy, type CliffRule, type LoweringSpec, type ModelProfile, type RecoveryRule, type StructuredOutputCapability, type SystemPromptMode, _setProfileBrainHook, allProfiles, allProfilesRaw, getProfile, profilesByProvider, tryGetProfile };
+export { ALIASES, type ArchetypeConvention, type CacheStrategy, type CliffRule, LATENCY_TIER_MS, type LatencyTier, type LoweringSpec, type ModelProfile, type RecoveryRule, type StructuredOutputCapability, type SystemPromptMode, _setProfileBrainHook, allProfiles, allProfilesRaw, getProfile, latencyTierOf, profilesByProvider, tryGetProfile };

package/dist/profiles.js

@@ -21,14 +21,27 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var profiles_exports = {};
 __export(profiles_exports, {
   ALIASES: () => ALIASES,
+  LATENCY_TIER_MS: () => LATENCY_TIER_MS,
   _setProfileBrainHook: () => _setProfileBrainHook,
   allProfiles: () => allProfiles,
   allProfilesRaw: () => allProfilesRaw,
   getProfile: () => getProfile,
+  latencyTierOf: () => latencyTierOf,
   profilesByProvider: () => profilesByProvider,
   tryGetProfile: () => tryGetProfile
 });
 module.exports = __toCommonJS(profiles_exports);
+var LATENCY_TIER_MS = {
+  fast: 4e3,
+  medium: 11e3,
+  slow: 24e3
+};
+function latencyTierOf(profile) {
+  if (profile.latencyTier) return profile.latencyTier;
+  if (profile.weaknesses.includes("latency")) return "slow";
+  if (profile.strengths.includes("speed")) return "fast";
+  return "medium";
+}
 var ANTHROPIC_LOWERING_BASE = {
   system: { mode: "inline" },
   cache: {
@@ -575,6 +588,14 @@ var PROFILES_RAW = [
     ],
     strengths: ["cost", "1m_context", "json_output", "code", "reasoning"],
     weaknesses: ["parallel_tools", "large_tool_sets"],
+    // alpha.47 — explicit slow override. Tag derivation would say 'medium'
+    // (no 'latency' weakness, no 'speed' strength), but the alpha.46 shadow
+    // probe MEASURED deepseek-v4-flash at 20485ms served (2026-06-03) — ~2.3×
+    // gemini-2.5-flash on PB's synchronous /api/analyze path. The 'flash' name
+    // is DeepSeek's, not a speed promise. This is the row that, scoring 0.85
+    // baseQuality (it carries 'reasoning') with no latency counterweight,
+    // leapfrogged gemini-2.5-flash as PB's summarize leader once reachable.
+    latencyTier: "slow",
     notes: "Cheap workhorse. 1M context, 384k max output. Cache-hit input $0.0028/M (1/50\xD7 of miss). Aliased as `deepseek-chat` (non-thinking) and `deepseek-reasoner` (thinking) \u2014 see ALIASES.",
     // Master plan §6.2 anchor. Brain-validated tier 1 cross-provider for
     // classify (169 rows, 0% empty). Tier 0 for summarize-with-no-tools.
@@ -642,6 +663,11 @@ var PROFILES_RAW = [
     ],
     strengths: ["quality", "reasoning", "1m_context", "json_output", "code", "extended_thinking"],
     weaknesses: ["parallel_tools", "large_tool_sets"],
+    // alpha.47 — explicit slow override. Measured 47722ms on the alpha.46
+    // shadow probe (2026-06-03) — it's an extended-thinking reasoner, slowest
+    // 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.",
     // Master plan §3.3: tier 3 cross-provider for plan chain. Reasoning
     // bumped one notch over V4-Flash; same parallel-tool ceiling.
@@ -1295,10 +1321,12 @@ function profilesByProvider(provider) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ALIASES,
+  LATENCY_TIER_MS,
   _setProfileBrainHook,
   allProfiles,
   allProfilesRaw,
   getProfile,
+  latencyTierOf,
   profilesByProvider,
   tryGetProfile
 });

package/dist/profiles.mjs

@@ -1,18 +1,22 @@
 import {
   ALIASES,
+  LATENCY_TIER_MS,
   _setProfileBrainHook,
   allProfiles,
   allProfilesRaw,
   getProfile,
+  latencyTierOf,
   profilesByProvider,
   tryGetProfile
-} from "./chunk-ZHUD3I52.mjs";
+} from "./chunk-PKOFXEB3.mjs";
 export {
   ALIASES,
+  LATENCY_TIER_MS,
   _setProfileBrainHook,
   allProfiles,
   allProfilesRaw,
   getProfile,
+  latencyTierOf,
   profilesByProvider,
   tryGetProfile
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@warmdrift/kgauto-compiler",
-  "version": "2.0.0-alpha.45",
+  "version": "2.0.0-alpha.47",
   "description": "Prompt compiler + central learning brain for multi-model AI apps. Swap models without rewriting prompts.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",