lynkr 9.14.11 → 9.14.13

package/src/routing/quota-ledger.js

@@ -0,0 +1,110 @@
+/**
+ * Subscription quota ledger (Phase 4 — quota-aware descents).
+ *
+ * Flat-fee subscriptions have no dollar price per token, but they do have a
+ * quota bucket: sustained Opus serving drains weekly runway several times
+ * faster than Haiku. This module tracks per-session burn in QUOTA UNITS so
+ * the downgrade gate can shorten its horizon under pressure (see
+ * cache-switch-cost.js `sessionBurnPressure`): high burn → fewer effective
+ * remaining turns → holds collapse → descents clear sooner.
+ *
+ * Units: 1 quota unit = 1000 Haiku-class tokens (input+output blended).
+ * Model weight = (inputPerM + outputPerM) / (haiku input+output), resolved
+ * via cache-economics with a fail-to-middle default (2.0) for unpriced ids —
+ * unknown models should exert middling pressure, never zero, never Opus.
+ * Today's registry: haiku 1.0, sonnet-5 2.0, opus-4-8 5.0.
+ *
+ * Pressure = min(1, windowBurn / BURN_WINDOW_QUOTA) over the trailing window
+ * (default 10 turns). BURN_WINDOW_QUOTA is a heuristic constant: ~ten sustained
+ * full-context Opus turns. It is deliberately coarse — pressure only shortens
+ * the hold horizon, it never forces a descent past the gate's own math, and
+ * upgrades/tool-loops/compaction-floors bypass the gate entirely.
+ *
+ * Pure except for the in-memory session map (no I/O, no DB). Never throws.
+ */
+
+const BURN_WINDOW_TURNS = 10;
+// ~10 sustained 10k-token Opus turns (10 × 10 × 5.0). Sustained peaks pin
+// pressure at 1; occasional upgrades barely register. Heuristic — see above.
+const BURN_WINDOW_QUOTA = 500;
+const MAX_SESSIONS = 500;
+const UNKNOWN_MODEL_WEIGHT = 2.0;
+const HAIKU_BASELINE_PER_M = 6; // claude-haiku-4-5-20251001: 1 input + 5 output
+
+const _windows = new Map(); // sessionId -> number[] (recent turn burns)
+
+function _evictIfNeeded() {
+  while (_windows.size > MAX_SESSIONS) {
+    const oldest = _windows.keys().next();
+    if (oldest.done) break;
+    _windows.delete(oldest.value);
+  }
+}
+
+/**
+ * Quota weight for a model id: output+input price relative to Haiku baseline.
+ * @param {string|null} model
+ * @param {function|null} [resolveFn] - (provider, model) => {inputPerM, outputPerM} (tests)
+ */
+function modelWeight(model, resolveFn = null) {
+  try {
+    const resolve = resolveFn || require('./cache-economics').resolveCacheEconomics;
+    const econ = resolve('azure-anthropic', model);
+    if (!econ || typeof econ.inputPerM !== 'number' || typeof econ.outputPerM !== 'number') {
+      return UNKNOWN_MODEL_WEIGHT;
+    }
+    if (econ.unknownPricing) return UNKNOWN_MODEL_WEIGHT;
+    return (econ.inputPerM + econ.outputPerM) / HAIKU_BASELINE_PER_M;
+  } catch {
+    return UNKNOWN_MODEL_WEIGHT;
+  }
+}
+
+/**
+ * Record one served turn.
+ * @param {string|null} sessionId
+ * @param {object} usage - {model, inputTokens, outputTokens}
+ * @param {function|null} [resolveFn] - test injection for modelWeight
+ */
+function record(sessionId, usage = {}, resolveFn = null) {
+  if (!sessionId) return;
+  const input = Number(usage.inputTokens) || 0;
+  const output = Number(usage.outputTokens) || 0;
+  if (input <= 0 && output <= 0) return;
+  const burn = ((input + output) / 1000) * modelWeight(usage.model, resolveFn);
+  let window = _windows.get(sessionId);
+  if (!window) {
+    window = [];
+    _windows.set(sessionId, window);
+  }
+  window.push(burn);
+  while (window.length > BURN_WINDOW_TURNS) window.shift();
+  _evictIfNeeded();
+}
+
+/**
+ * Current burn pressure for a session: 0 (idle/cheap) → 1 (sustained peaks).
+ */
+function pressure(sessionId) {
+  const window = _windows.get(sessionId);
+  if (!window || window.length === 0) return 0;
+  const burn = window.reduce((a, b) => a + b, 0);
+  return Math.max(0, Math.min(1, burn / BURN_WINDOW_QUOTA));
+}
+
+/** Test/ops helpers. */
+function _reset() { _windows.clear(); }
+function _windowBurn(sessionId) {
+  const window = _windows.get(sessionId);
+  return window ? window.reduce((a, b) => a + b, 0) : 0;
+}
+
+module.exports = {
+  record,
+  pressure,
+  modelWeight,
+  BURN_WINDOW_TURNS,
+  BURN_WINDOW_QUOTA,
+  _reset,
+  _windowBurn,
+};

package/src/routing/risk-analyzer.js

@@ -125,9 +125,22 @@ function findHits(keywords, haystack) {
  * not what the harness injected; genuinely risky asks live in the typed
  * text and still fire. (The intent scorers have stripped these blocks
  * since WS3 — this brings the risk scan in line.)
+ *
+ * Bare-line MCP boilerplate (HARNESS_BOILERPLATE_LINE) gets the same
+ * treatment: auth notices also arrive as PLAIN text outside any tags.
  * @param {string} text
  * @returns {string}
  */
+// Bare-line harness boilerplate that escapes the tag stripping above: MCP
+// auth notices also arrive as PLAIN text (tool results, echoed banners),
+// where the same credential-flavored words detonate the keyword scan —
+// live 2026-09-18: "Can you pull sprint stories…" + an "Authentication
+// successful. Connected to claude.ai BT1_MCP" notice routed REASONING on
+// instructionHits ["authentication"] the user never typed. Full-LINE match
+// only: these are fixed harness templates, never user prose — typed risky
+// asks ("disable the authentication check") span the line differently and
+// keep firing. Tool_use inputs are untouched (real activity still counts).
+const HARNESS_BOILERPLATE_LINE = /^\s*(authentication successful[.!]?(\s+connected to .+)?|connected to \S+ MCP\.?|(\d+\s+)?MCP servers? need authentication\b.*|run \/mcp\b.*)\s*$/i;
 function stripSystemReminders(text) {
   if (typeof text !== 'string' || !text) return '';
   return text
@@ -139,7 +152,10 @@ function stripSystemReminders(text) {
     // "Hi", force-escalated to COMPLEX on it) and <user_instructions>
     // carries AGENTS.md contents the user never typed this turn.
     .replace(/<environment_context>[\s\S]*?<\/environment_context>/g, ' ')
-    .replace(/<user_instructions>[\s\S]*?<\/user_instructions>/g, ' ');
+    .replace(/<user_instructions>[\s\S]*?<\/user_instructions>/g, ' ')
+    .split('\n')
+    .filter((line) => !HARNESS_BOILERPLATE_LINE.test(line))
+    .join('\n');
 }
 
 /**

package/src/routing/telemetry.js

@@ -181,6 +181,14 @@ function init() {
       // NULL on rows where the bandit didn't run (deterministic decisions)
       // or recorded before this column existed.
       ["context", "TEXT"],
+      // Jev routing judge — shadow verdict recorded alongside every scored
+      // decision so heuristic/Jev eras stay separable. NULL when Jev didn't
+      // run (pinned serves, side frames, no key) or predates this column.
+      ["jev_verdict", "TEXT"],
+      ["jev_confidence", "REAL"],
+      ["jev_probabilities", "TEXT"],
+      ["jev_model", "TEXT"],
+      ["criteria_hash", "TEXT"],
     ];
     for (const [col, type] of additiveCols) {
       if (!existingCols.has(col)) {
@@ -243,7 +251,8 @@ function record(data) {
           retry_count, circuit_breaker_state, quality_score, tokens_per_second,
           cost_efficiency, request_text, response_text,
           base_tier, escalation_source, propensity, candidates, pinned, switch_reason,
-          cache_decision, cache_read_tokens, cache_creation_tokens, context
+          cache_decision, cache_read_tokens, cache_creation_tokens, context,
+          jev_verdict, jev_confidence, jev_probabilities, jev_model, criteria_hash
         ) VALUES (
           @request_id, @session_id, @timestamp, @complexity_score, @tier,
           @agentic_type, @tool_count, @input_tokens, @message_count, @request_type,
@@ -252,7 +261,8 @@ function record(data) {
           @retry_count, @circuit_breaker_state, @quality_score, @tokens_per_second,
           @cost_efficiency, @request_text, @response_text,
           @base_tier, @escalation_source, @propensity, @candidates, @pinned, @switch_reason,
-          @cache_decision, @cache_read_tokens, @cache_creation_tokens, @context
+          @cache_decision, @cache_read_tokens, @cache_creation_tokens, @context,
+          @jev_verdict, @jev_confidence, @jev_probabilities, @jev_model, @criteria_hash
         )`
       );
       if (!insert) return;
@@ -308,6 +318,13 @@ function record(data) {
         context: data.context == null
           ? null
           : (typeof data.context === "string" ? data.context : JSON.stringify(data.context)),
+        jev_verdict: data.jev_verdict ?? null,
+        jev_confidence: data.jev_confidence ?? null,
+        jev_probabilities: data.jev_probabilities === null || data.jev_probabilities === undefined
+          ? null
+          : (typeof data.jev_probabilities === "string" ? data.jev_probabilities : JSON.stringify(data.jev_probabilities)),
+        jev_model: data.jev_model ?? null,
+        criteria_hash: data.criteria_hash ?? null,
       });
     } catch (err) {
       logger.debug({ err: err.message }, "Telemetry record failed");
@@ -1136,8 +1153,36 @@ function getAnalytics(opts = {}) {
   }
 }
 
+/**
+ * Map a Jev verdict (decision.jev or analysis.jev shape) onto the
+ * jev_* telemetry columns. Null-safe: anything missing yields all-null
+ * fields so call sites spread this unconditionally.
+ */
+function jevFields(src) {
+  const j = (src && typeof src === 'object')
+    ? (src.jev && typeof src.jev === 'object' ? src.jev
+      : (src.analysis && typeof src.analysis === 'object' && src.analysis.jev ? src.analysis.jev : null))
+    : null;
+  if (!j) {
+    return {
+      jev_verdict: null, jev_confidence: null, jev_probabilities: null,
+      jev_model: null, criteria_hash: null,
+    };
+  }
+  return {
+    jev_verdict: j.tier ?? null,
+    jev_confidence: j.confidence ?? null,
+    jev_probabilities: j.probabilities === null || j.probabilities === undefined
+      ? null
+      : (typeof j.probabilities === 'string' ? j.probabilities : JSON.stringify(j.probabilities)),
+    jev_model: j.model ?? null,
+    criteria_hash: j.criteriaHash ?? j.criteria_hash ?? null,
+  };
+}
+
 module.exports = {
   record,
+  jevFields,
   query,
   getStats: getStatsCached,
   getProviderStats: getProviderStatsCached,