lynkr 9.7.2 → 9.9.0

package/src/routing/reward-pipeline.js

@@ -8,19 +8,30 @@
  *
  * Normalisation uses running min/max so we don't need to pre-compute global
  * scales.
+ *
+ * WS5.1 — state persists to data/reward-state.json so the normaliser ranges
+ * survive process restarts. Without this, the first N requests after every
+ * restart get scaled against a re-learned range and produce noisy rewards.
  */
 
+const fs = require('fs');
+const path = require('path');
 const logger = require('../logger');
 
+const STATE_PATH = path.join(__dirname, '../../data/reward-state.json');
 const DEFAULT_LAMBDA = 0.3;
 const DEFAULT_MU = 0.1;
+const SAVE_EVERY = 25;
 
 class RewardPipeline {
-  constructor({ lambda = DEFAULT_LAMBDA, mu = DEFAULT_MU } = {}) {
+  constructor({ lambda = DEFAULT_LAMBDA, mu = DEFAULT_MU, statePath = STATE_PATH } = {}) {
     this.lambda = lambda;
     this.mu = mu;
     this.costRange = { min: Infinity, max: -Infinity };
     this.latencyRange = { min: Infinity, max: -Infinity };
+    this.observations = 0;
+    this.statePath = statePath;
+    this._load();
   }
 
   observe({ cost, latency }) {
@@ -46,11 +57,66 @@ class RewardPipeline {
    */
   reward(obs) {
     this.observe(obs);
+    this.observations++;
+    // Periodic save mirrors bandit.js: cheap enough to write inline every
+    // N observations, no risk of blocking the response path since callers
+    // invoke reward() from setImmediate.
+    if (this.observations % SAVE_EVERY === 0) this._save();
     const q = typeof obs.quality === 'number' ? obs.quality : 50;
     const cn = this._normalize(obs.cost ?? 0, this.costRange);
     const ln = this._normalize(obs.latency ?? 0, this.latencyRange);
     return Math.max(0, Math.min(100, q - this.lambda * cn * 100 - this.mu * ln * 100));
   }
+
+  _save() {
+    try {
+      fs.mkdirSync(path.dirname(this.statePath), { recursive: true });
+      fs.writeFileSync(this.statePath, JSON.stringify({
+        savedAt: Date.now(),
+        lambda: this.lambda,
+        mu: this.mu,
+        observations: this.observations,
+        // Serialise Infinity as null; _load() re-hydrates.
+        costRange: {
+          min: isFinite(this.costRange.min) ? this.costRange.min : null,
+          max: isFinite(this.costRange.max) ? this.costRange.max : null,
+        },
+        latencyRange: {
+          min: isFinite(this.latencyRange.min) ? this.latencyRange.min : null,
+          max: isFinite(this.latencyRange.max) ? this.latencyRange.max : null,
+        },
+      }, null, 0));
+    } catch (err) {
+      logger.debug({ err: err.message }, '[Reward] State save failed');
+    }
+  }
+
+  _load() {
+    try {
+      if (!fs.existsSync(this.statePath)) return;
+      const raw = JSON.parse(fs.readFileSync(this.statePath, 'utf8'));
+      if (raw.costRange) {
+        this.costRange = {
+          min: raw.costRange.min == null ? Infinity : raw.costRange.min,
+          max: raw.costRange.max == null ? -Infinity : raw.costRange.max,
+        };
+      }
+      if (raw.latencyRange) {
+        this.latencyRange = {
+          min: raw.latencyRange.min == null ? Infinity : raw.latencyRange.min,
+          max: raw.latencyRange.max == null ? -Infinity : raw.latencyRange.max,
+        };
+      }
+      this.observations = raw.observations || 0;
+      logger.info({
+        cost: this.costRange,
+        latency: this.latencyRange,
+        observations: this.observations,
+      }, '[Reward] State loaded');
+    } catch (err) {
+      logger.debug({ err: err.message }, '[Reward] State load failed');
+    }
+  }
 }
 
 let _instance = null;
@@ -59,4 +125,4 @@ function getRewardPipeline() {
   return _instance;
 }
 
-module.exports = { RewardPipeline, getRewardPipeline };
+module.exports = { RewardPipeline, getRewardPipeline, SAVE_EVERY };

package/src/routing/risk-analyzer.js

@@ -114,6 +114,34 @@ function findHits(keywords, haystack) {
   return Array.from(hits).sort();
 }
 
+/**
+ * Strip harness-injected <system-reminder> blocks from instruction text
+ * before risk scanning. Claude Code appends these blocks to the latest
+ * user message (CLAUDE.md contents, MCP-server auth notices, tool-search
+ * hints). Their boilerplate routinely contains words like "authentication",
+ * "credential", and "security" — live traffic showed a bare "23+45" turn
+ * force-escalated to COMPLEX on instructionHits ["credential","security"]
+ * that the user never typed. Risk must reflect what the USER is asking,
+ * 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.)
+ * @param {string} text
+ * @returns {string}
+ */
+function stripSystemReminders(text) {
+  if (typeof text !== 'string' || !text) return '';
+  return text
+    .replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, ' ')
+    // Codex harness blocks arrive as user-role messages and get merged into
+    // the typed text by the orchestrator's consecutive-role coalescing.
+    // <environment_context> carries <permission_profile> ("permission" is a
+    // high-risk keyword — live traffic showed every Codex turn, including
+    // "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, ' ');
+}
+
 /**
  * Analyze the risk level of a request.
  *
@@ -131,7 +159,7 @@ function findHits(keywords, haystack) {
  *             paths: string[] }}
  */
 function analyzeRisk(payload) {
-  const instructionText = extractContent(payload) || '';
+  const instructionText = stripSystemReminders(extractContent(payload) || '');
   const lowText = instructionText.toLowerCase();
 
   const textPaths = extractPathsFromText(instructionText);
@@ -193,6 +221,7 @@ module.exports = {
   analyzeRisk,
   PROTECTED_PATH_KEYWORDS,
   HIGH_RISK_INSTRUCTION_KEYWORDS,
+  stripSystemReminders,
   // Exposed for tests
   extractPathsFromText,
   extractPathsFromToolUses,

package/src/routing/risk-classifier.js

@@ -15,7 +15,7 @@
 const fs = require('fs');
 const path = require('path');
 const logger = require('../logger');
-const { analyzeRisk: regexAnalyzeRisk } = require('./risk-analyzer');
+const { analyzeRisk: regexAnalyzeRisk, stripSystemReminders } = require('./risk-analyzer');
 
 const MODEL_PATH = path.join(__dirname, '../../data/risk-classifier.json');
 const DECISION_THRESHOLD = 0.5;
@@ -84,7 +84,10 @@ function analyzeRisk(payload) {
   const model = _loadModel();
   if (!model) return regexResult;
 
-  // Build the text we feed to the classifier: latest user message + tool defs + system fingerprint
+  // Build the text we feed to the classifier: latest user message + system
+  // fingerprint. Harness-injected <system-reminder> blocks are stripped for
+  // the same reason as in the regex analyzer — their boilerplate contains
+  // risk keywords ("authentication", "credential") the user never typed.
   let text = '';
   if (Array.isArray(payload?.messages)) {
     for (let i = payload.messages.length - 1; i >= 0; i--) {
@@ -98,6 +101,7 @@ function analyzeRisk(payload) {
       }
     }
   }
+  text = stripSystemReminders(text);
   if (typeof payload?.system === 'string') text += ' ' + payload.system;
 
   const prob = _predict(text, model);

package/src/routing/session-affinity.js

@@ -9,88 +9,216 @@
  *   Azure: 400 "No tool call found for function call output with call_id …"
  *   Moonshot: 400 "Invalid request: tool_call_id is not found"
  *
- * To prevent that, once a session has chosen a provider we keep subsequent
- * turns on it *while the payload carries tool history*. Fresh turns (no tool
- * state) still route normally, so per-turn tier routing is preserved.
+ * WS1 extends this from a per-turn tool-safety guard into a cache-aware sticky
+ * routing pin: routing decisions are made **once per session** (persisted to
+ * SQLite so restarts don't lose them) and re-evaluated only at explicit
+ * triggers — compaction, guard escalation, provider unavailable, or an
+ * economic downgrade that beats the estimated cold-cache re-read cost.
+ *
+ * The in-memory Map is a read-through cache over `affinity-store` (SQLite);
+ * the store is authoritative across restarts, the Map keeps hot sessions
+ * off the SQLite path.
  *
  * @module routing/session-affinity
  */
 
+const store = require("./affinity-store");
+
 const MAX_ENTRIES = 2000;
-const TTL_MS = 60 * 60 * 1000; // 1 hour
+// 6h TTL — long enough that a working session (dev machine idled overnight)
+// keeps its pin, short enough that abandoned sessions eventually clear.
+// Override with LYNKR_STICKY_TTL_MS.
+function _ttlMs() {
+  const raw = Number(process.env.LYNKR_STICKY_TTL_MS);
+  return Number.isFinite(raw) && raw > 0 ? raw : 6 * 60 * 60 * 1000;
+}
+
+/**
+ * Pin entry shape.
+ * @typedef {Object} Pin
+ * @property {string}  provider
+ * @property {string|null}  model
+ * @property {string|null}  tier
+ * @property {number|null}  score            - decision.score at pin time (so pinned turns can display the original intent score in the badge instead of a misleading full-payload complexity score)
+ * @property {number|null}  messageCount     - payload.messages.length at pin time
+ * @property {number|null}  promptTokensEst  - countPayloadTokens estimate at pin time
+ * @property {number}  ts
+ */
 
-/** @type {Map<string, {provider:string, model:string|null, tier:string|null, ts:number}>} */
+/** @type {Map<string, Pin>} */
 const pins = new Map();
 
 function _evictIfNeeded() {
   if (pins.size <= MAX_ENTRIES) return;
-  // Map preserves insertion order — drop the oldest.
   const oldest = pins.keys().next().value;
   if (oldest !== undefined) pins.delete(oldest);
 }
 
 /**
- * True when the payload contains an in-flight tool exchange — i.e. a prior
- * assistant tool_use or a user tool_result. These are the turns whose
- * tool-call IDs break if the provider changes.
+ * True when the payload is MID tool exchange — the LAST message is
+ * submitting tool_result blocks (or replaying a dangling tool_use). Those
+ * are the frames whose tool-call IDs break if the provider changes.
+ *
+ * COMPLETED tool exchanges earlier in the history are safe to carry across
+ * providers: the tool_use/tool_result pairs are internally consistent and
+ * any Anthropic-format backend accepts them.
+ *
+ * The original implementation matched tool blocks ANYWHERE in history,
+ * which meant one tool call permanently welded the session to its pin:
+ * every subsequent frame — including freshly typed user messages — took
+ * the unconditional serve, silently disabling the risk/context/vision
+ * guards AND the WS1.5 drift check for the rest of the session. Live
+ * symptom (2026-07-07): a heavyweight typed ask displayed
+ * "score 0 · pin@0" because drift never ran after the session's first
+ * tool use.
  * @param {object} payload
  * @returns {boolean}
  */
 function payloadHasToolHistory(payload) {
   const messages = payload?.messages;
-  if (!Array.isArray(messages)) return false;
-  for (const msg of messages) {
-    const content = msg?.content;
-    if (!Array.isArray(content)) continue;
-    for (const block of content) {
-      const t = block?.type;
-      if (t === "tool_use" || t === "tool_result") return true;
-    }
-  }
-  return false;
+  if (!Array.isArray(messages) || messages.length === 0) return false;
+  const content = messages[messages.length - 1]?.content;
+  if (!Array.isArray(content)) return false;
+  return content.some((b) => b?.type === "tool_result" || b?.type === "tool_use");
 }
 
 /**
- * Return the pinned routing decision for a session, or null if none / expired.
+ * Load a pin: memory first, then SQLite. Returns null on TTL expiry or miss.
  * @param {string} sessionId
+ * @returns {Pin|null}
  */
-function getPinned(sessionId) {
+function getPin(sessionId) {
   if (!sessionId) return null;
-  const entry = pins.get(sessionId);
-  if (!entry) return null;
-  if (Date.now() - entry.ts > TTL_MS) {
-    pins.delete(sessionId);
-    return null;
+  const ttl = _ttlMs();
+
+  const inMem = pins.get(sessionId);
+  if (inMem) {
+    if (Date.now() - inMem.ts > ttl) {
+      pins.delete(sessionId);
+      store.remove(sessionId);
+      return null;
+    }
+    return inMem;
   }
-  return entry;
+
+  // Cold cache — read through the store.
+  const fromStore = store.load(sessionId, ttl);
+  if (!fromStore) return null;
+  pins.set(sessionId, fromStore);
+  _evictIfNeeded();
+  return fromStore;
 }
 
 /**
- * Record the provider a session routed to, for reuse on later tool-bearing turns.
+ * Write-through: update the in-memory Map and persist to SQLite.
+ * Accepts a routing decision plus session-scoped stats used by the re-pin
+ * heuristics.
+ *
  * @param {string} sessionId
  * @param {{provider:string, model?:string|null, tier?:string|null}} decision
+ * @param {{messageCount?:number|null, promptTokensEst?:number|null}} [stats]
  */
-function setPinned(sessionId, decision) {
+function setPin(sessionId, decision, stats = {}) {
   if (!sessionId || !decision?.provider) return;
-  // Refresh insertion order so active sessions aren't evicted.
-  pins.delete(sessionId);
-  pins.set(sessionId, {
+  const pin = {
     provider: decision.provider,
     model: decision.model ?? null,
     tier: decision.tier ?? null,
+    score: typeof decision.score === 'number' ? decision.score : null,
+    messageCount: stats.messageCount ?? null,
+    promptTokensEst: stats.promptTokensEst ?? null,
     ts: Date.now(),
-  });
+  };
+  // Refresh insertion order so active sessions aren't evicted.
+  pins.delete(sessionId);
+  pins.set(sessionId, pin);
   _evictIfNeeded();
+  store.save(sessionId, pin);
 }
 
-/** Test/maintenance helper. */
+/**
+ * Decide whether the session should be re-routed from its current pin based
+ * on the incoming payload. Currently detects "compaction" — the client
+ * shrunk its message history (e.g. Claude Code's /compact), which resets
+ * the provider's prompt cache anyway, so we're free to re-route without
+ * incurring an extra cold-cache read.
+ *
+ * @param {Pin|null} pin
+ * @param {object} payload
+ * @returns {{repin: boolean, reason: string|null}}
+ */
+function shouldRepin(pin, payload) {
+  if (!pin) return { repin: true, reason: "no_pin" };
+  const currentMsgCount = Array.isArray(payload?.messages) ? payload.messages.length : 0;
+  const pinnedMsgCount = pin.messageCount ?? null;
+  // A 1-2 message payload against a long-conversation pin is NOT compaction
+  // — it's a new conversation whose opener collided with an old session's
+  // fingerprint (compaction always leaves summary + recent turns, never a
+  // bare opener). Mislabeling it lets the compaction floor pin greetings
+  // to expensive tiers.
+  if (pinnedMsgCount != null && currentMsgCount <= 2 && pinnedMsgCount > 4) {
+    return { repin: true, reason: "new_conversation" };
+  }
+  if (pinnedMsgCount != null && currentMsgCount < pinnedMsgCount - 2) {
+    return { repin: true, reason: "compaction" };
+  }
+  return { repin: false, reason: null };
+}
+
+/** Test/maintenance helper — clear the in-memory Map only. */
 function _clear() {
   pins.clear();
 }
 
+/** Test helper — clear both memory and persistent store. */
+function _clearAll() {
+  pins.clear();
+  store._clear();
+}
+
+// ---------------------------------------------------------------------------
+// Legacy compatibility surface
+//
+// Preserved so existing call sites and tests keep working during the WS1
+// rollout. New code should use getPin/setPin (which record message_count and
+// prompt tokens for the sticky-routing triggers).
+// ---------------------------------------------------------------------------
+
+/** @deprecated use getPin */
+function getPinned(sessionId) {
+  const p = getPin(sessionId);
+  if (!p) return null;
+  return { provider: p.provider, model: p.model, tier: p.tier, ts: p.ts };
+}
+
+/**
+ * Drop a session's pin (memory + store). Used when a mid-tool-exchange
+ * frame carries embedded typed text that trips a trigger (force-cloud /
+ * autonomous): the frame itself must still serve the pin (tool_use ↔
+ * tool_result id linkage breaks on a mid-exchange switch), but the pin
+ * must not survive to the next turn boundary.
+ * @param {string} sessionId
+ */
+function removePin(sessionId) {
+  if (!sessionId) return;
+  pins.delete(sessionId);
+  store.remove(sessionId);
+}
+
+/** @deprecated use setPin */
+function setPinned(sessionId, decision) {
+  setPin(sessionId, decision);
+}
+
 module.exports = {
   payloadHasToolHistory,
+  getPin,
+  setPin,
+  removePin,
+  shouldRepin,
+  // legacy
   getPinned,
   setPinned,
   _clear,
+  _clearAll,
 };