lynkr 9.14.11 → 9.14.13

package/src/prompts/system.js

@@ -73,61 +73,53 @@ function compressToolDescriptions(tools, mode = null) {
   // Normalize to Anthropic shape: OpenAI-format callers (OpenWorker, aisuite,
   // any OpenAI SDK) send {type:"function", function:{name, description, parameters}}.
   // Unwrap once here so the compression logic below can assume input_schema exists.
-  tools = tools.map(tool =>
-    tool?.type === "function" && tool.function
-      ? {
-          name: tool.function.name,
-          description: tool.function.description,
-          input_schema: tool.function.parameters || { type: "object", properties: {} },
-        }
-      : tool
-  );
-
-  return tools.map(tool => {
-    const input_schema = tool.input_schema || { type: "object", properties: {} };
-    const compressed = {
-      name: tool.name,
-      input_schema: {
-        type: input_schema.type || "object",
-        properties: {},
-        required: input_schema.required || [],
-      }
+  // Every other key on the function object (strict, and any future keywords)
+  // passes through untouched — an allowlist here silently drops enforceable
+  // constraints (issue #116).
+  tools = tools.map(tool => {
+    if (tool?.type !== "function" || !tool.function) return tool;
+    const { parameters, ...kept } = tool.function;
+    return {
+      ...kept,
+      input_schema: parameters || { type: "object", properties: {} },
     };
+  });
 
-    // Add minimal description only if it exists
-    if (tool.description) {
-      compressed.description = compressText(tool.description, 50);
+  return tools.map(tool => {
+    // Copy everything through; compression below targets description TEXT
+    // only, never schema shape (issue #116: an allowlist rebuild silently
+    // dropped strict/pattern/const/oneOf and misleveled additionalProperties).
+    const out = { ...tool };
+    if (typeof out.description === 'string' && out.description) {
+      out.description = compressText(out.description, 50);
     }
-
-    // Compress property descriptions
-    if (input_schema.properties) {
-      for (const [key, value] of Object.entries(input_schema.properties)) {
-        compressed.input_schema.properties[key] = {
-          type: value.type,
-        };
-
-        // Only include description if it's critical
-        if (value.description && !isObviousFromName(key)) {
-          compressed.input_schema.properties[key].description = compressText(value.description, 30);
-        }
-
-        // Preserve enum, format, and other critical constraints
-        if (value.enum) compressed.input_schema.properties[key].enum = value.enum;
-        if (value.format) compressed.input_schema.properties[key].format = value.format;
-        if (value.items) compressed.input_schema.properties[key].items = value.items;
-        if (value.additionalProperties !== undefined) {
-          compressed.input_schema.properties[key].additionalProperties = value.additionalProperties;
-        }
-      }
+    if (out.input_schema && typeof out.input_schema === 'object') {
+      out.input_schema = compressSchemaDescriptions(out.input_schema, null);
     }
+    return out;
+  });
+}
 
-    // Preserve additionalProperties if set
-    if (input_schema.additionalProperties !== undefined) {
-      compressed.input_schema.additionalProperties = input_schema.additionalProperties;
+/**
+ * Recursively compress `description` strings in a JSON Schema, preserving
+ * every other keyword byte-for-byte in shape. Descriptions obvious from the
+ * property name are dropped, the rest truncated — matching the historical
+ * minimal-mode behavior without an allowlist that lags the spec.
+ */
+function compressSchemaDescriptions(node, key) {
+  if (Array.isArray(node)) return node.map((v) => compressSchemaDescriptions(v, key));
+  if (node && typeof node === 'object') {
+    const out = {};
+    for (const [k, v] of Object.entries(node)) {
+      if (k === 'description' && typeof v === 'string') {
+        if (!isObviousFromName(key)) out[k] = compressText(v, 30);
+      } else {
+        out[k] = compressSchemaDescriptions(v, k);
+      }
     }
-
-    return compressed;
-  });
+    return out;
+  }
+  return node;
 }
 
 /**

package/src/routing/affinity-store.js

@@ -59,9 +59,25 @@ function _db() {
       // Additive migration for cache-aware routing (Phase 1): JSON blob
       // holding {warmPrefixTokens, provider, model, lastRequestAt, ttlMs},
       // updated after every upstream response that reports cache usage.
+      // NOTE (2026-09-18): superseded by the dedicated session_cache_state
+      // table below. The column stays (and old blobs stay readable nowhere —
+      // loadCacheState reads the new table), but NOTHING writes it anymore:
+      // sharing the pins table let cache-only rows (no tier) be served as
+      // routing pins, permanently locking sessions with no escalation path.
       if (!cols.has("cache_state")) {
         db.exec("ALTER TABLE session_pins ADD COLUMN cache_state TEXT");
       }
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS session_cache_state (
+          session_id         TEXT PRIMARY KEY,
+          warm_prefix_tokens INTEGER NOT NULL,
+          provider           TEXT NOT NULL,
+          model              TEXT,
+          last_request_at    INTEGER NOT NULL,
+          ttl_ms             INTEGER NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS idx_cache_state_ts ON session_cache_state(last_request_at);
+      `);
       schemaEnsured = true;
     } catch (err) {
       degradation.record("feedback", err);
@@ -168,9 +184,10 @@ function save(sessionId, pin) {
 
 /**
  * Persist per-session prompt-cache state (Phase 1, cache-aware routing).
- * Piggybacks on the session_pins row; creates a minimal row when the session
- * has no pin yet (possible when sticky sessions are disabled but tracking
- * is on). Best-effort like everything else in this module.
+ * Lives in its OWN table (session_cache_state), deliberately separate from
+ * session_pins: the old piggyback design wrote tier-less rows that got
+ * served as routing pins, locking sessions with no escalation path.
+ * Best-effort like everything else in this module.
  *
  * @param {string} sessionId
  * @param {{warmPrefixTokens:number, provider:string, model:string|null, lastRequestAt:number, ttlMs:number}} state
@@ -180,21 +197,25 @@ function saveCacheState(sessionId, state) {
   const db = _db();
   if (!db) return;
   try {
-    const json = JSON.stringify(state);
-    const res = _stmt(
+    _stmt(
       db,
-      "cache_state_update",
-      "UPDATE session_pins SET cache_state = ? WHERE session_id = ?"
-    ).run(json, sessionId);
-    if (res.changes === 0) {
-      _stmt(
-        db,
-        "cache_state_insert",
-        `INSERT INTO session_pins (session_id, provider, model, ts, cache_state)
-         VALUES (?, ?, ?, ?, ?)
-         ON CONFLICT(session_id) DO UPDATE SET cache_state = excluded.cache_state`
-      ).run(sessionId, state.provider, state.model ?? null, Date.now(), json);
-    }
+      "cache_state_upsert",
+      `INSERT INTO session_cache_state (session_id, warm_prefix_tokens, provider, model, last_request_at, ttl_ms)
+       VALUES (?, ?, ?, ?, ?, ?)
+       ON CONFLICT(session_id) DO UPDATE SET
+         warm_prefix_tokens = excluded.warm_prefix_tokens,
+         provider = excluded.provider,
+         model = excluded.model,
+         last_request_at = excluded.last_request_at,
+         ttl_ms = excluded.ttl_ms`
+    ).run(
+      sessionId,
+      state.warmPrefixTokens ?? 0,
+      state.provider,
+      state.model ?? null,
+      state.lastRequestAt ?? Date.now(),
+      state.ttlMs ?? 5 * 60 * 1000
+    );
   } catch (err) {
     degradation.record("feedback", err);
   }
@@ -216,11 +237,16 @@ function loadCacheState(sessionId) {
     const row = _stmt(
       db,
       "cache_state_load",
-      "SELECT cache_state FROM session_pins WHERE session_id = ?"
+      "SELECT warm_prefix_tokens, provider, model, last_request_at, ttl_ms FROM session_cache_state WHERE session_id = ?"
     ).get(sessionId);
-    if (!row?.cache_state) return null;
-    const parsed = JSON.parse(row.cache_state);
-    return parsed && typeof parsed === "object" ? parsed : null;
+    if (!row) return null;
+    return {
+      warmPrefixTokens: Number(row.warm_prefix_tokens) || 0,
+      provider: row.provider,
+      model: row.model ?? null,
+      lastRequestAt: Number(row.last_request_at) || 0,
+      ttlMs: Number(row.ttl_ms) || 5 * 60 * 1000,
+    };
   } catch (err) {
     degradation.record("feedback", err);
     return null;

package/src/routing/cache-economics.js

@@ -47,6 +47,7 @@ const PROVIDER_CACHE_DEFAULTS = {
   moonshot:   { readMult: 0.1,  writeMult: 0, ttlMs: 5 * 60 * 1000, mechanism: 'automatic' },
   openrouter: { readMult: 0.1,  writeMult: 0, ttlMs: 5 * 60 * 1000, mechanism: 'automatic' },
   edenai:     { readMult: 0.1,  writeMult: 0, ttlMs: 5 * 60 * 1000, mechanism: 'automatic' },
+  orcarouter: { readMult: 0.1,  writeMult: 0, ttlMs: 5 * 60 * 1000, mechanism: 'automatic' },
   // DeepSeek direct (via aggregators today, kept for model-level matches):
   deepseek:   { readMult: 0.02, writeMult: 0, ttlMs: 5 * 60 * 1000, mechanism: 'automatic' },
 

package/src/routing/cache-switch-cost.js

@@ -61,12 +61,23 @@ function _cfg() {
  * @param {number} [args.outputTokensPerTurn] - est. output tokens per turn.
  * @param {number|null} [args.expectedRemainingTurns] - median remaining
  *   turns; falls back to the conservative config default when null.
+ * @param {number|null} [args.sessionBurnPressure] - 0..1 quota pressure from
+ *   quota-ledger.js (sustained expensive serving on a flat subscription).
+ *   Enables a parallel QUOTA break-even leg: while dollar math prices the
+ *   rebuild in USD, quota math prices it in ledger units (model weight ×
+ *   tokens, Haiku = 1.0). Either leg clearing allows the switch, so high
+ *   burn opens descents the dollar leg alone would hold. Null/0 disables
+ *   the quota leg entirely — pure dollar behavior, byte-for-byte backward
+ *   compatible. Upgrades never route through this gate, so pressure can
+ *   only accelerate descents, never block capability.
  * @param {Object} [args.deps] - test injection: {resolveCacheEconomics}.
  * @returns {{
  *   switchAllowed: boolean,
  *   reason: string,
  *   breakEvenTurns: number|null,
  *   expectedRemainingTurns: number,
+ *   quotaBreakEvenTurns: number|null,
+ *   burnPressureApplied: number,
  *   warmPrefixTokens: number,
  *   switchOnceUsd: number|null,
  *   stayPerTurnUsd: number|null,
@@ -81,18 +92,24 @@ function evaluateSwitch({
   newTokensPerTurn,
   outputTokensPerTurn,
   expectedRemainingTurns,
+  sessionBurnPressure = null,
   deps = {},
 } = {}) {
   const cfg = _cfg();
   const remaining = Number.isFinite(expectedRemainingTurns) && expectedRemainingTurns > 0
     ? expectedRemainingTurns
     : cfg.defaultRemainingTurns;
+  const burnPressure = Number.isFinite(sessionBurnPressure)
+    ? Math.max(0, Math.min(1, sessionBurnPressure))
+    : 0;
 
   const base = {
     switchAllowed: true,
     reason: 'no_cache_state',
     breakEvenTurns: null,
     expectedRemainingTurns: remaining,
+    quotaBreakEvenTurns: null,
+    burnPressureApplied: burnPressure,
     warmPrefixTokens: cacheState?.warmPrefixTokens ?? 0,
     switchOnceUsd: null,
     stayPerTurnUsd: null,
@@ -174,19 +191,46 @@ function evaluateSwitch({
   const breakEvenTurns = switchOnce / savingsPerTurn;
   const allowed = breakEvenTurns <= remaining;
 
+  // Quota leg (flat subscriptions): re-run the same break-even in ledger
+  // units when the session is burning. Model weight = (input+output $/M) /
+  // Haiku baseline — quota burn tracks price ratios, which is exactly what
+  // the ledger records. A rebuild that never pays in dollars can still pay
+  // in runway when every held turn burns 5x the units a descent would.
+  let quotaBreakEvenTurns = null;
+  let quotaAllowed = false;
+  if (burnPressure > 0) {
+    const wCur = (econCur.inputPerM + econCur.outputPerM) / 6;
+    const wTgt = (econTgt.inputPerM + econTgt.outputPerM) / 6;
+    if (wCur > wTgt) {
+      const perTurnTokens = (W + N + O) / 1000;
+      const quotaSavingsPerTurn = perTurnTokens * (wCur - wTgt);
+      if (quotaSavingsPerTurn > 0) {
+        quotaBreakEvenTurns = ((W + N) / 1000) * wTgt / quotaSavingsPerTurn;
+        quotaAllowed = quotaBreakEvenTurns <= remaining;
+      }
+    }
+  }
+  const finalAllowed = allowed || quotaAllowed;
+
   logger.debug({
     current: `${current.provider}:${current.model}`,
     target: `${target.provider}:${target.model}`,
     warmPrefixTokens: W,
     breakEvenTurns: Number(breakEvenTurns.toFixed(2)),
     expectedRemainingTurns: remaining,
+    quotaBreakEvenTurns: quotaBreakEvenTurns === null ? null : Number(quotaBreakEvenTurns.toFixed(2)),
+    burnPressureApplied: burnPressure,
     allowed,
+    quotaAllowed,
   }, '[CacheSwitchCost] break-even evaluated');
 
   return {
     ...priced,
-    switchAllowed: allowed,
-    reason: allowed ? 'break_even_cleared' : 'break_even_blocked',
+    quotaBreakEvenTurns,
+    switchAllowed: finalAllowed,
+    reason: finalAllowed
+      ? (allowed ? 'break_even_cleared' : 'quota_break_even_cleared')
+      : 'break_even_blocked',
     breakEvenTurns,
   };
 }

package/src/routing/complexity-analyzer.js

@@ -104,16 +104,28 @@ const FORCE_REASONING_PATTERNS = [
   /\b(prove|proof|formal\s+proof|verify|verification)\b/i,
   /\b(from\s+first\s+principles)\b/i,
   /\b(reason\s+(through|about|from)\s+(the|this))/i,
+  // Frontier planning: asking FOR a plan/strategy/design of technical work
+  // (not asking about one). Two-sided lookahead — a plan word AND a technical
+  // scope word must both be present, so "plan my vacation", "lesson plan"
+  // and "business plan" stay quiet while "give me a plan to refactor X",
+  // "draft an RFC to redesign Y" and "migration strategy for Z" escalate.
+  // Deliberately excludes bare "give me a plan" (nothing technical to plan)
+  // and generic nouns (module/api/database) that misfire on non-technical
+  // asks. Known overlap: "explain the deployment plan" fires — accepted,
+  // deployment planning benefits from the strong model anyway.
+  /(?=.*\b(plans?|roadmaps?|strateg(y|ies)|blueprints?|proposals?|rfcs?|design\s+docs?)\b)(?=.*\b(refactor\w*|implement\w*|migrat\w+|architect\w+|redesign\w*|restructur\w+|rewrit\w+|overhaul\w*|codebases?|infrastructure|pipelines?|deploy\w*|systems?)\b)/i,
 ];
 
 // Force COMPLEX patterns - route to COMPLEX (GLM in config B) regardless of
 // score. Architecture/refactor/code-review are substantial but not
 // security-critical, so GLM is appropriate.
 const FORCE_CLOUD_PATTERNS = [
-  /\b(architect(ure)?\s+(review|design|diagram)|system\s+design)\b/i,
+  /\b(architect\w*\s+(review|design|diagram)|system\s+design)\b/i,
   /\b(refactor\s+(entire|whole|all|the\s+entire)|complete\s+rewrite)\b/i,
   /\b(code\s+review|pr\s+review|pull\s+request\s+review)\b/i,
-  /\b(debug(ging)?\s+(complex|difficult|hard|tricky))\b/i,
+  // "debug this tricky race" reads naturally but the adjectives rarely sit
+  // adjacent to the verb, so up to two words may intervene.
+  /\bdebug(?:ging)?\s+(?:\w+\s+){0,2}(complex|difficult|hard|tricky)\b/i,
   /\b(production\s+(issue|bug|incident|outage))\b/i,
 ];
 
@@ -655,8 +667,13 @@ function calculateWeightedScore(payload, content) {
   const avgLength = content.length / Math.max(sentences.length, 1);
   dimensions.promptComplexity = Math.min(avgLength / 2, 100);
 
-  // 3. Technical depth (keyword density)
-  const techMatches = (content.match(PATTERNS.technical) || []).length;
+  // 3. Technical depth (keyword density). NOTE: uses a local global-flag
+  // copy — the shared PATTERNS.technical must stay flag-less because .test()
+  // callers above depend on stateless matching (a shared /g regex carries
+  // lastIndex between calls). String.match with a non-global regex returns
+  // at most one hit, which used to cap this dimension at 15 regardless of
+  // density and starved COMPLEX-tier scores of their strongest signal.
+  const techMatches = (content.match(new RegExp(PATTERNS.technical.source, 'gi')) || []).length;
   dimensions.technicalDepth = Math.min(techMatches * 15, 100);
 
   // 4. Domain specificity (how many domains are touched)

package/src/routing/index.js

@@ -94,6 +94,7 @@ function _enabledProviders() {
   if (config.openai?.apiKey) out.push('openai');
   if (config.atlas?.apiKey) out.push('atlas');
   if (config.azureOpenAI?.endpoint && config.azureOpenAI?.apiKey) out.push('azure-openai');
+  if (config.orcarouter?.apiKey) out.push('orcarouter');
   if (config.ollama?.endpoint) out.push('ollama');
   if (config.llamacpp?.endpoint) out.push('llamacpp');
   if (config.lmstudio?.endpoint) out.push('lmstudio');
@@ -137,6 +138,7 @@ function getBestCloudProvider() {
   if (config.openai?.apiKey) return 'openai';
   if (config.atlas?.apiKey) return 'atlas';
   if (config.azureOpenAI?.endpoint && config.azureOpenAI?.apiKey) return 'azure-openai';
+  if (config.orcarouter?.apiKey) return 'orcarouter';
 
   return getFallbackProvider();
 }
@@ -803,6 +805,17 @@ function checkSessionPin(payload, options = {}) {
   const guards = _runPinGuards(payload, pin);
   if (!guards.ok) return { serve: false, pin, sessionId, reason: guards.reason };
 
+  // Tier-less pins (legacy cache-only rows predating the session_cache_state
+  // split) must not drive tier decisions: drift math on a null tier never
+  // fires, so serving them locks the session with no escalation path.
+  // Exempted when ANY tool blocks exist anywhere in the payload: an
+  // unresolved tool_use breaks if the provider switches, so provider
+  // stickiness wins there (same safety rationale as the tool_history path
+  // above, which returns before reaching this check).
+  if (!pin.tier && !_payloadHasAnyToolBlocks(payload)) {
+    return { serve: false, pin, sessionId, reason: 'tierless_pin' };
+  }
+
   if (refreshOk) {
     sessionAffinity.setPin(sessionId, pin, {
       messageCount: Math.max(messageCount, pin.messageCount ?? 0),
@@ -1093,6 +1106,11 @@ async function _determineProviderSmartInner(payload, options = {}) {
       analysis.score = intent.score;
       analysis.scoreMode = intent.mode; // 'anchor' | 'lexical' (clean-text fallback)
       analysis.anchorClass = intent.class ?? null;
+      // Jev verdict rides alongside the score so the shortfall floor,
+      // risk corroboration and telemetry can consume it downstream.
+      // Null unless the Jev leg ran (pinned serves, side frames and
+      // classifier skips leave no verdict — same as classifierResult).
+      if (intent.jev && typeof intent.jev === 'object') analysis.jev = intent.jev;
       intentScored = true;
       logger.debug({
         score: intent.score,
@@ -1211,12 +1229,47 @@ async function _determineProviderSmartInner(payload, options = {}) {
   // (agentic minTier, context, vision, kNN-ambiguous) for telemetry.
   let baseTier = null;
   const escalations = [];
+  let _jevOverrode = false;
   if (config.modelTiers?.enabled) {
     try {
       const selector = getModelTierSelector();
       tier = selector.getTier(analysis.score);
       baseTier = tier;
 
+      // Jev tier override: a high-confidence measured verdict replaces the
+      // score-band tier in either direction (score bands stay the fallback
+      // for Jev-null/low-confidence). Runs BEFORE agentic floors and risk
+      // lifts so structural guarantees can still lift above the verdict —
+      // never below it. Score is set to the tier midpoint so drift math,
+      // badges and telemetry stay coherent with the decided tier.
+      try {
+        const { jevTierOverride } = require('./jev-router');
+        const _ov = jevTierOverride({
+          baseTier,
+          jevTier: analysis.jev?.tier,
+          jevConfidence: analysis.jev?.confidence,
+        });
+        if (_ov) {
+          escalations.push({
+            source: 'jev_override',
+            fromTier: tier,
+            toTier: _ov.tier,
+            fromModel: null,
+            toModel: null,
+          });
+          logger.debug({
+            fromTier: tier,
+            toTier: _ov.tier,
+            jevConfidence: analysis.jev?.confidence ?? null,
+          }, '[Routing] Jev tier override');
+          tier = _ov.tier;
+          if (typeof _ov.score === 'number') analysis.score = _ov.score;
+          _jevOverrode = true;
+        }
+      } catch (err) {
+        degradation.record('tier_select', err);
+      }
+
       // Check if agentic detection requires a higher tier
       if (agenticResult?.minTier) {
         const agenticTierPriority = TIER_DEFINITIONS[agenticResult.minTier]?.priority || 0;
@@ -1235,6 +1288,30 @@ async function _determineProviderSmartInner(payload, options = {}) {
         }
       }
 
+      // Jev risk corroboration (escalate-only): a high Noul on auth /
+      // secrets / production / destructive content lifts SIMPLE/MEDIUM one
+      // band when the keyword analyzer stayed quiet. Never clears a keyword
+      // hit (that path returned far above), never jumps two bands, never
+      // fires without a verdict (fail-soft null skips silently). Mirrors the
+      // kNN-ambiguous escalate pattern with a ledger entry.
+      try {
+        const { jevRiskLift } = require('./jev-router');
+        const _lifted = jevRiskLift({ tier, risky: analysis.jev?.risky, riskLevel: risk?.level });
+        if (_lifted) {
+          escalations.push({
+            source: 'jev_risk',
+            fromTier: tier,
+            toTier: _lifted,
+            fromModel: null,
+            toModel: null,
+          });
+          logger.debug({ fromTier: tier, toTier: _lifted, risky: analysis.jev.risky }, '[Routing] Jev risk corroboration — one-band lift');
+          tier = _lifted;
+        }
+      } catch (err) {
+        degradation.record('tier_select', err);
+      }
+
       // Select model for the tier (will be applied after provider selection)
       analysis.tier = tier;
     } catch (err) {
@@ -1245,7 +1322,7 @@ async function _determineProviderSmartInner(payload, options = {}) {
   // Apply routing decision based on tier config (TIER_* env vars take precedence
   // but Phase 1.2 lets the cost-optimizer pick a cheaper qualifying model when safe).
   let provider;
-  let method = 'tier_config';
+  let method = _jevOverrode ? 'tier_config+jev_override' : 'tier_config';
   let costOptimized = false;
 
   const selector = getModelTierSelector();
@@ -1340,6 +1417,51 @@ async function _determineProviderSmartInner(payload, options = {}) {
     degradation.record('shortfall', err);
   }
 
+  // Jev shortfall floor: a high-confidence Jev tier is a measured verdict,
+  // not a heuristic guess — cheapest-covering must not demote below it.
+  // Floor target is the stronger of (scored legacy pick, Jev verdict):
+  // score-derived highs are never talked down by the judge, and judged
+  // highs are never talked down by the price optimizer (see jevFloorTarget).
+  // De-escalation below still runs after this, so evidence gates apply like
+  // any other decision.
+  try {
+    const { jevFloorTarget } = require('./jev-router');
+    const _floorTier = shortfallInfo && shortfallInfo.legacy
+      ? jevFloorTarget({
+        selectedTier: tier,
+        legacyTier: shortfallInfo.legacy.tier,
+        jevTier: analysis.jev?.tier,
+        jevConfidence: analysis.jev?.confidence,
+      })
+      : null;
+    if (_floorTier) {
+      const _floorSel = selector.selectModel(_floorTier, null);
+      if (_floorSel && _floorSel.provider && _floorSel.model) {
+        const _fromTier = tier;
+        const _fromModel = selectedModel;
+        provider = _floorSel.provider;
+        selectedModel = _floorSel.model;
+        tier = _floorTier;
+        analysis.tier = tier;
+        method = method + '+jev_floor_hold';
+        escalations.push({
+          source: 'jev_floor',
+          fromTier: _fromTier,
+          toTier: tier,
+          fromModel: _fromModel,
+          toModel: selectedModel,
+        });
+        logger.info({
+          from: `${_fromTier}:${_fromModel}`,
+          to: `${tier}:${selectedModel}`,
+          jevConfidence: analysis.jev?.confidence ?? null,
+        }, '[Routing] Jev floor hold — shortfall demotion refused');
+      }
+    }
+  } catch (err) {
+    degradation.record('shortfall', err);
+  }
+
   // WS2.3 — evidence-based de-escalation.
   //
   // The check is intentionally gated by evidence, not a feature flag: the

package/src/routing/intent-score.js

@@ -338,9 +338,8 @@ function _reconcile(anchorScore, anchorClass, classifierResult) {
   const anchorIdx = TIER_ORDER.indexOf(anchorTier);
   const classifierIdx = TIER_ORDER.indexOf(classifierTier);
 
-  // Midpoints of each tier band (from model-tiers.js defaults):
-  //   SIMPLE 0-19 → 10, MEDIUM 20-50 → 35, COMPLEX 51-75 → 63, REASONING 76-100 → 88
-  const TIER_MIDPOINT = { SIMPLE: 10, MEDIUM: 35, COMPLEX: 63, REASONING: 88 };
+  // Midpoints live in model-tiers.js (single source of truth).
+  const { TIER_MIDPOINT } = require('./model-tiers');
 
   if (classifierIdx < anchorIdx) {
     // Classifier says LOWER tier — trust it. Fixes over-routing.
@@ -410,24 +409,47 @@ async function scoreIntent(payload, opts = {}) {
         const [lo, hi] = CLASS_BANDS[cls];
         const anchorScore = Math.max(lo, Math.min(hi, blendScore(sims)));
 
-        // LLM classifier — second opinion. Skipped in tests (opts.skipClassifier)
-        // to keep unit tests hermetic. Runs live otherwise.
+        // Jev routing judge — second opinion. Skipped in tests (opts.skipClassifier)
+        // to keep unit tests hermetic (or stubbed via opts.jevFetchFn). Runs live
+        // otherwise. Replaces the qwen difficulty classifier in the same result
+        // shape ({tier, confidence}) so _reconcile semantics are unchanged;
+        // Jev extras (probabilities, risky, model, criteriaHash) ride along
+        // for telemetry and the shortfall floor. Fail-soft null preserves the
+        // anchor-only path exactly.
+        //
+        // Hermeticity note: suites asserting deterministic routing scrub
+        // TYPESAFE_API_KEY (no key → Jev leg returns null before any fetch),
+        // the same posture as the repo's live-Ollama tolerance. Never gate
+        // on NODE_ENV — .env pins it to production in every context.
         let classifierResult = null;
+        let jevResult = null;
         if (!opts.skipClassifier) {
           try {
-            const { classifyDifficulty } = require('./difficulty-classifier');
-            classifierResult = await classifyDifficulty(text, {
-              forceMatched: opts.forceMatched,
-              riskLevel: opts.riskLevel,
-              // Condensed prior turns, threaded by the router's window loop.
-              // Without it a short follow-up ("Who kills him ?") is
-              // unclassifiable in isolation.
+            const { classifyJev } = require('./jev-router');
+            const msgs = Array.isArray(payload?.messages) ? payload.messages : [];
+            const toolDefs = Array.isArray(payload?.tools) ? payload.tools : [];
+            const toolResults = msgs.filter((m) =>
+              m?.role === 'user' && Array.isArray(m.content) && m.content.some((c) => c?.type === 'tool_result')
+            ).length;
+            const jevFetchFn = opts.jevFetchFn;
+            jevResult = await classifyJev(text, {
               context: typeof payload?._conversationContext === 'string'
                 ? payload._conversationContext
                 : null,
+              signals: {
+                message_count: msgs.length,
+                tools_attached: toolDefs.length,
+                effective_tools: toolDefs.length,
+                has_tool_history: toolResults > 0,
+                session_turn: Math.max(1, Math.ceil(msgs.length / 2)),
+              },
+              fetchFn: jevFetchFn,
             });
+            if (jevResult) {
+              classifierResult = { tier: jevResult.tier, confidence: jevResult.confidence };
+            }
           } catch (err) {
-            logger.debug({ err: err.message }, '[IntentScore] classifier failed — anchor only');
+            logger.debug({ err: err.message }, '[IntentScore] Jev classifier failed — anchor only');
           }
         }
 
@@ -453,6 +475,19 @@ async function scoreIntent(payload, opts = {}) {
           classifierTier: classifierResult?.tier ?? null,
           classifierConfidence: classifierResult?.confidence ?? null,
           reconciled,
+          // Jev verdict details for telemetry + shortfall floor downstream.
+          // Null unless the Jev leg ran (same conditions as classifierResult,
+          // plus LRU-cached repeats which still carry the original extras).
+          jev: jevResult ? {
+            tier: jevResult.tier,
+            confidence: jevResult.confidence,
+            probabilities: jevResult.probabilities ?? null,
+            risky: jevResult.risky ?? null,
+            model: jevResult.model ?? null,
+            criteriaHash: jevResult.criteriaHash ?? null,
+            latencyMs: jevResult.latencyMs ?? null,
+            cached: !!jevResult.cached,
+          } : null,
         });
       }
     }