lynkr 9.14.13 → 9.14.15

package/src/routing/affinity-store.js

@@ -77,6 +77,14 @@ function _db() {
           ttl_ms             INTEGER NOT NULL
         );
         CREATE INDEX IF NOT EXISTS idx_cache_state_ts ON session_cache_state(last_request_at);
+        CREATE TABLE IF NOT EXISTS session_task_state (
+          session_id     TEXT PRIMARY KEY,
+          anchor_hash    TEXT,
+          effective_band INTEGER,
+          open           INTEGER,
+          low_streak     INTEGER,
+          updated_at     INTEGER
+        );
       `);
       schemaEnsured = true;
     } catch (err) {
@@ -253,6 +261,122 @@ function loadCacheState(sessionId) {
   }
 }
 
+// TaskBand — per-session task difficulty state. Lives in its OWN table for
+// the same reason as session_cache_state: piggybacking non-pin rows onto
+// session_pins let tier-less rows be served as routing pins (see note above
+// saveCacheState). Falls back to this in-memory Map when the DB is
+// unavailable so continuation floors keep working without persistence.
+const taskStateMem = new Map();
+
+/**
+ * Load TaskBand state for a session. Returns null when absent or on any
+ * DB failure.
+ *
+ * @param {string} sessionId
+ * @returns {{anchorHash:string|null, effectiveBand:number, open:boolean, lowStreak:number}|null}
+ */
+function getTaskState(sessionId) {
+  if (!sessionId) return null;
+  const db = _db();
+  if (!db) {
+    const mem = taskStateMem.get(sessionId);
+    return mem ? { ...mem } : null;
+  }
+  try {
+    const row = _stmt(
+      db,
+      "task_state_load",
+      "SELECT anchor_hash, effective_band, open, low_streak FROM session_task_state WHERE session_id = ?"
+    ).get(sessionId);
+    if (!row) return null;
+    return {
+      anchorHash: row.anchor_hash ?? null,
+      effectiveBand: Number(row.effective_band) || 0,
+      open: !!row.open,
+      lowStreak: Number(row.low_streak) || 0,
+    };
+  } catch (err) {
+    degradation.record("feedback", err);
+    return null;
+  }
+}
+
+/**
+ * Upsert TaskBand state. effective_band is MAX-merged only while the stored
+ * anchor matches — a new anchor means a new task, whose band must not
+ * inherit the old peak, so the whole row is overwritten instead.
+ *
+ * @param {string} sessionId
+ * @param {{anchorHash:string|null, effectiveBand:number, open:boolean, lowStreak?:number}} state
+ */
+function setTaskState(sessionId, state) {
+  if (!sessionId || !state) return;
+  const next = {
+    anchorHash: state.anchorHash ?? null,
+    effectiveBand: Number.isFinite(state.effectiveBand) ? state.effectiveBand : 0,
+    open: state.open ? 1 : 0,
+    lowStreak: Number.isFinite(state.lowStreak) ? state.lowStreak : 0,
+  };
+  const db = _db();
+  if (!db) {
+    const prev = taskStateMem.get(sessionId);
+    if (prev && prev.anchorHash === next.anchorHash) {
+      next.effectiveBand = Math.max(prev.effectiveBand, next.effectiveBand);
+    }
+    taskStateMem.set(sessionId, {
+      anchorHash: next.anchorHash,
+      effectiveBand: next.effectiveBand,
+      open: !!next.open,
+      lowStreak: next.lowStreak,
+    });
+    return;
+  }
+  try {
+    _stmt(
+      db,
+      "task_state_upsert",
+      // IS (not =) so a null↔null anchor comparison still MAX-merges. All
+      // SET expressions see the pre-update row, so assignment order below
+      // doesn't affect the CASE.
+      `INSERT INTO session_task_state (session_id, anchor_hash, effective_band, open, low_streak, updated_at)
+       VALUES (@session_id, @anchor_hash, @effective_band, @open, @low_streak, @updated_at)
+       ON CONFLICT(session_id) DO UPDATE SET
+         effective_band = CASE WHEN anchor_hash IS excluded.anchor_hash
+           THEN MAX(effective_band, excluded.effective_band)
+           ELSE excluded.effective_band END,
+         anchor_hash = excluded.anchor_hash,
+         open = excluded.open,
+         low_streak = excluded.low_streak,
+         updated_at = excluded.updated_at`
+    ).run({
+      session_id: sessionId,
+      anchor_hash: next.anchorHash,
+      effective_band: next.effectiveBand,
+      open: next.open,
+      low_streak: next.lowStreak,
+      updated_at: Date.now(),
+    });
+  } catch (err) {
+    degradation.record("feedback", err);
+  }
+}
+
+/**
+ * Remove TaskBand state for a session.
+ * @param {string} sessionId
+ */
+function clearTaskState(sessionId) {
+  if (!sessionId) return;
+  taskStateMem.delete(sessionId);
+  const db = _db();
+  if (!db) return;
+  try {
+    _stmt(db, "task_state_delete", "DELETE FROM session_task_state WHERE session_id = ?").run(sessionId);
+  } catch (err) {
+    degradation.record("feedback", err);
+  }
+}
+
 /**
  * Remove a pin.
  * @param {string} sessionId
@@ -298,4 +422,15 @@ function _clear() {
   } catch { /* best-effort */ }
 }
 
-module.exports = { load, save, remove, cleanup, saveCacheState, loadCacheState, _clear };
+module.exports = {
+  load,
+  save,
+  remove,
+  cleanup,
+  saveCacheState,
+  loadCacheState,
+  getTaskState,
+  setTaskState,
+  clearTaskState,
+  _clear,
+};

package/src/routing/index.js

@@ -625,7 +625,16 @@ async function checkPinScoreDrift(pin, payload) {
     // ceiling+margin comparisons are meaningless.
     let freshScore = null;
     if (intentScoreMode() !== 'legacy') {
-      const intent = await scoreIntent({ messages: [{ role: 'user', content: text }] });
+      // TaskBand: same judge context + memo identity as the fresh-decision
+      // scoring of this ask (the router stamps these on the body) — drift
+      // must compare scores produced from identical inputs.
+      const intent = await scoreIntent({
+        messages: [{ role: 'user', content: text }],
+        _conversationContext: typeof payload?._conversationContext === 'string'
+          ? payload._conversationContext : null,
+        _taskAnchorHash: payload?._taskAnchorHash ?? null,
+        _isContinuation: !!payload?._isContinuation,
+      });
       if (intent && Number.isFinite(intent.score)) freshScore = intent.score;
     }
     if (freshScore === null) {
@@ -872,6 +881,18 @@ function writeSessionPin(sessionId, decision, payload) {
     }, '[Routing] Risk-forced decision — pin write skipped');
     return;
   }
+  // Continuation-floored tiers are inherited, not scored — pinning one would
+  // fossilize the floor past its decay window (same one-way ratchet as risk
+  // above; the floor re-derives on every turn that still earns it).
+  if (method.includes('+continuation_inherit')) {
+    logger.debug({
+      sessionId,
+      provider: decision.provider,
+      tier: decision.tier,
+      method,
+    }, '[Routing] Continuation-floored decision — pin write skipped');
+    return;
+  }
   const messageCount = Array.isArray(payload?.messages) ? payload.messages.length : 0;
   // Opener-only sessions (≤2 messages) never pin: a bare opener has nothing
   // to stabilize, and identical openers share a fingerprint for the 6h TTL,
@@ -1106,11 +1127,20 @@ async function _determineProviderSmartInner(payload, options = {}) {
       analysis.score = intent.score;
       analysis.scoreMode = intent.mode; // 'anchor' | 'lexical' (clean-text fallback)
       analysis.anchorClass = intent.class ?? null;
+      // Pure anchor score BEFORE classifier reconciliation — the Jev
+      // override cap derives its base tier from this, so the judge can
+      // never stack a second band on top of a reconcile lift.
+      analysis.anchorScore = Number.isFinite(intent.anchorScore) ? intent.anchorScore : 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;
+      // How _reconcile disposed of the verdict ('down_capped' means a weak
+      // context-fed downward verdict was floored at one band below the
+      // anchor) — the override below must honor that gate, not re-apply
+      // the raw verdict.
+      analysis.reconciled = intent.reconciled ?? false;
       intentScored = true;
       logger.debug({
         score: intent.score,
@@ -1230,6 +1260,8 @@ async function _determineProviderSmartInner(payload, options = {}) {
   let baseTier = null;
   const escalations = [];
   let _jevOverrode = false;
+  let _jevCapChanged = false;
+  let _jevCapBaseTier = null;
   if (config.modelTiers?.enabled) {
     try {
       const selector = getModelTierSelector();
@@ -1244,11 +1276,32 @@ async function _determineProviderSmartInner(payload, options = {}) {
       // badges and telemetry stay coherent with the decided tier.
       try {
         const { jevTierOverride } = require('./jev-router');
-        const _ov = jevTierOverride({
-          baseTier,
+        // Cap base for upward verdicts: the stronger of the pure anchor
+        // tier and any inherited continuation floor the request carries.
+        // The judge may lift one band above THAT and no further (live bug:
+        // uncapped verdicts catapulted follow-ups straight to REASONING).
+        _jevCapBaseTier = Number.isFinite(analysis.anchorScore)
+          ? selector.getTier(analysis.anchorScore)
+          : baseTier;
+        const _inheritedFloor = payload?._inheritedFloorTier;
+        if (_inheritedFloor && (TIER_DEFINITIONS[_inheritedFloor]?.priority ?? -1)
+          > (TIER_DEFINITIONS[_jevCapBaseTier]?.priority ?? -1)) {
+          _jevCapBaseTier = _inheritedFloor;
+        }
+        const _jevArgs = {
           jevTier: analysis.jev?.tier,
           jevConfidence: analysis.jev?.confidence,
-        });
+        };
+        // 'down_capped' means _reconcile already floored this exact verdict
+        // at one band below the anchor (weak, context-fed); the verdict sits
+        // strictly below baseTier, so only the uncapped downward leg could
+        // fire here — landing the full drop the reconcile gate prevented.
+        const _downCapped = analysis.reconciled === 'down_capped';
+        const _ov = _downCapped ? null : jevTierOverride(_jevArgs, baseTier, _jevCapBaseTier);
+        // REASONING cap = the full range: the delta against it is exactly
+        // "did the cap change the outcome" for the method/ledger marker.
+        const _ovUncapped = _downCapped ? null : jevTierOverride(_jevArgs, baseTier, 'REASONING');
+        if ((_ovUncapped?.tier ?? null) !== (_ov?.tier ?? null)) _jevCapChanged = true;
         if (_ov) {
           escalations.push({
             source: 'jev_override',
@@ -1323,6 +1376,7 @@ async function _determineProviderSmartInner(payload, options = {}) {
   // but Phase 1.2 lets the cost-optimizer pick a cheaper qualifying model when safe).
   let provider;
   let method = _jevOverrode ? 'tier_config+jev_override' : 'tier_config';
+  if (_jevCapChanged) method += '+jev_override_capped';
   let costOptimized = false;
 
   const selector = getModelTierSelector();
@@ -1426,14 +1480,24 @@ async function _determineProviderSmartInner(payload, options = {}) {
   // any other decision.
   try {
     const { jevFloorTarget } = require('./jev-router');
-    const _floorTier = shortfallInfo && shortfallInfo.legacy
-      ? jevFloorTarget({
+    const _floorArgs = shortfallInfo && shortfallInfo.legacy
+      ? {
         selectedTier: tier,
         legacyTier: shortfallInfo.legacy.tier,
         jevTier: analysis.jev?.tier,
         jevConfidence: analysis.jev?.confidence,
-      })
+      }
       : null;
+    // Same cap as the override above: the judged floor can't hold a tier
+    // more than one band above the anchor/inherited-floor base.
+    const _floorTier = _floorArgs ? jevFloorTarget(_floorArgs, _jevCapBaseTier) : null;
+    if (_floorArgs) {
+      const _floorUncapped = jevFloorTarget(_floorArgs, null);
+      if ((_floorUncapped ?? null) !== (_floorTier ?? null)
+        && !method.includes('+jev_override_capped')) {
+        method = method + '+jev_override_capped';
+      }
+    }
     if (_floorTier) {
       const _floorSel = selector.selectModel(_floorTier, null);
       if (_floorSel && _floorSel.provider && _floorSel.model) {

package/src/routing/intent-score.js

@@ -96,53 +96,29 @@ function intentScoreMode() {
 /**
  * Extract the text the USER actually authored this turn: the latest user
  * message that has real text after stripping harness-injected content.
- * Returns null when there is nothing to score (e.g. tool-result-only turn).
+ * Returns {text:null, index:-1} when there is nothing to score (e.g.
+ * tool-result-only turn). Per-message cleaning delegates to jev-router's
+ * shared cleaner (wrapper/command tags, line-start unclosed-tag rule,
+ * whole-message harness content) so the anchor scorer, the judge and the
+ * task ledger all read the same user text.
  */
-function extractCleanUserText(payload) {
+function _latestUserAsk(payload) {
   const msgs = payload?.messages;
-  if (!Array.isArray(msgs)) return null;
+  if (!Array.isArray(msgs)) return { text: null, index: -1 };
+  const { cleanUserText } = require('./jev-router');
   for (let i = msgs.length - 1; i >= 0; i--) {
     const msg = msgs[i];
     if (msg?.role !== 'user') continue;
-    let text = null;
-    if (typeof msg.content === 'string') {
-      text = msg.content;
-    } else if (Array.isArray(msg.content)) {
-      text = msg.content
-        .filter((b) => b?.type === 'text' && typeof b.text === 'string')
-        .map((b) => b.text)
-        .join(' ');
-    }
-    if (text == null) continue;
-    text = text
-      .replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, '')
-      // Harness task/background-agent notifications — not user-authored.
-      .replace(/<task-notification>[\s\S]*?<\/task-notification>/g, '')
-      // Codex harness blocks (merged into the typed text upstream):
-      // sandbox/permission profile and AGENTS.md contents.
-      .replace(/<environment_context>[\s\S]*?<\/environment_context>/g, '')
-      .replace(/<user_instructions>[\s\S]*?<\/user_instructions>/g, '')
-      // Goose harness block wrapping every typed message (time, cwd, todo
-      // notes) — its "tasks"/"update"/"requirements" vocabulary scored a
-      // bare "Hi" as substantive/MEDIUM.
-      .replace(/<turn-context>[\s\S]*?<\/turn-context>/g, '')
-      // Lynkr's own injected notices (quota banners, badges) start with the
-      // [Lynkr] marker — the user didn't type those.
-      .replace(/^\s*\[Lynkr\][^\n]*$/gm, '')
-      .trim();
-    // Whole-message harness content: compaction/continuation summaries and
-    // system notifications arrive as user-role messages the user never
-    // typed. Treat as empty and keep walking back.
-    if (/^\s*(\[SYSTEM NOTIFICATION|<conversation[\s>]|<session[\s>]|\[Request interrupted|This session is being continued from a previous conversation)/i.test(text)) {
-      // Continuation summaries PARAPHRASE the prior session, so they carry
-      // force-phrase vocabulary the user typed hours ago.
-      text = '';
-    }
-    if (text) return text;
+    const text = cleanUserText(msg);
+    if (text) return { text, index: i };
     // A user message that was ALL injected content (or all tool_results)
     // doesn't end the search — keep walking back for the real user turn.
   }
-  return null;
+  return { text: null, index: -1 };
+}
+
+function extractCleanUserText(payload) {
+  return _latestUserAsk(payload).text;
 }
 
 function cosine(a, b) {
@@ -317,13 +293,21 @@ function _lexicalCleanScore(text) {
 // - Agreement → keep anchor score as-is.
 // - Classifier lower than anchor → trust classifier (catches embedding
 //   false-positives like "list exports" scoring REASONING). Position
-//   score at midpoint of classifier's target band.
-// - Classifier higher than anchor → safety-gate: require confidence≥0.8
+//   score at midpoint of classifier's target band. When the verdict was
+//   produced WITH conversation_context at confidence < 0.6, the drop is
+//   capped at one band below the anchor: background-thread context reads
+//   follow-ups as small asks, and a weak context-fed verdict must not
+//   collapse a heavyweight anchor to SIMPLE.
+// - Classifier higher than anchor → safety-gate: require confidence≥0.3
+//   (set 2026-09-22 — see JEV_PROMOTE_CONFIDENCE note)
 //   before trusting an escalation to a more expensive tier. Below that,
 //   keep the cheaper anchor decision.
-function _reconcile(anchorScore, anchorClass, classifierResult) {
+function _reconcile(anchorScore, anchorClass, classifierResult, hasContext = false) {
   if (!classifierResult) return { score: anchorScore, reconciled: false };
-  if (classifierResult.confidence < 0.6) return { score: anchorScore, reconciled: false };
+  // Single 0.3 cut (set 2026-09-22): below it the verdict is noise in both
+  // directions. Note this also lets 0.3+ verdicts pull DOWN a band —
+  // the price of trusting the judge symmetrically.
+  if (classifierResult.confidence < 0.3) return { score: anchorScore, reconciled: false };
 
   // Anchor class → implied tier (matches model-tiers.js band definitions).
   const anchorTier = anchorScore <= 19 ? 'SIMPLE'
@@ -343,6 +327,13 @@ function _reconcile(anchorScore, anchorClass, classifierResult) {
 
   if (classifierIdx < anchorIdx) {
     // Classifier says LOWER tier — trust it. Fixes over-routing.
+    if (hasContext && classifierResult.confidence < 0.6) {
+      const flooredIdx = Math.max(classifierIdx, anchorIdx - 1);
+      return {
+        score: TIER_MIDPOINT[TIER_ORDER[flooredIdx]],
+        reconciled: flooredIdx > classifierIdx ? 'down_capped' : 'down',
+      };
+    }
     return { score: TIER_MIDPOINT[classifierTier], reconciled: 'down' };
   }
   // Classifier says HIGHER tier — gate on confidence, and cap the jump at
@@ -354,7 +345,7 @@ function _reconcile(anchorScore, anchorClass, classifierResult) {
   // the adjacent band now takes consecutive turns that keep re-scoring
   // higher, which is exactly the persistence a genuinely hard conversation
   // exhibits.
-  if (classifierResult.confidence >= 0.8) {
+  if (classifierResult.confidence >= 0.3) {
     const cappedIdx = Math.min(classifierIdx, anchorIdx + 1);
     return {
       score: TIER_MIDPOINT[TIER_ORDER[cappedIdx]],
@@ -364,11 +355,14 @@ function _reconcile(anchorScore, anchorClass, classifierResult) {
   return { score: anchorScore, reconciled: 'up_gated' };
 }
 
-// Memoize the final reconciled score per cleaned text. The classifier leg is
-// live and can time out under load, sending identical text down different
-// fallback paths — which made the same turn score differently between the
-// router and the pin-drift checker (observed: 63 vs 77 for one prompt under
-// suite-wide Ollama contention). First resolution wins for the process life.
+// Memoize the final reconciled score per cleaned text + task identity. The
+// classifier leg is live and can time out under load, sending identical text
+// down different fallback paths — which made the same turn score differently
+// between the router and the pin-drift checker (observed: 63 vs 77 for one
+// prompt under suite-wide Ollama contention). First resolution wins for the
+// process life. The key carries the task anchor hash and continuation flag:
+// the judge's verdict depends on them, so identical text under a different
+// task must not share an entry — a text-only key served stale-context scores.
 const _scoreMemo = new Map();
 const _SCORE_MEMO_MAX = 500;
 
@@ -376,20 +370,36 @@ async function scoreIntent(payload, opts = {}) {
   const mode = opts.mode ?? intentScoreMode();
   if (mode === 'legacy') return null;
 
-  const text = extractCleanUserText(payload);
+  const { text, index: askIdx } = _latestUserAsk(payload);
   if (!text) return null;
 
   // Only memoize plain calls — opts that alter scoring (custom centroids,
-  // embedFn, risk/context inputs) must not share cache entries.
+  // embedFn, risk inputs) must not share cache entries.
   const memoizable = !opts.centroids && !opts.embedFn && !opts.forceMatched
     && !opts.riskLevel && !opts.skipClassifier && !opts.priorTurns;
-  if (memoizable && _scoreMemo.has(text)) return _scoreMemo.get(text);
+
+  // Prior-task ledger (messages BEFORE the current ask): names the task for
+  // the memo key and feeds the judge's context + flat signals. It never
+  // touches the anchor scorer's input — envelope invariance holds.
+  let ledger = null;
+  if (!opts.skipClassifier) {
+    try {
+      const { deriveTaskLedger } = require('./task-ledger');
+      const msgs = Array.isArray(payload?.messages) ? payload.messages : [];
+      ledger = deriveTaskLedger(msgs.slice(0, Math.max(askIdx, 0)));
+    } catch { /* ledger unavailable — task-less key, context-free judge */ }
+  }
+
+  const memoKey = memoizable
+    ? `${text}\0${payload?._taskAnchorHash || ledger?.anchorHash || ''}\0${payload?._isContinuation ? '1' : '0'}`
+    : null;
+  if (memoizable && _scoreMemo.has(memoKey)) return _scoreMemo.get(memoKey);
   const _memoSet = (result) => {
     if (memoizable && result) {
       if (_scoreMemo.size >= _SCORE_MEMO_MAX) {
         _scoreMemo.delete(_scoreMemo.keys().next().value);
       }
-      _scoreMemo.set(text, result);
+      _scoreMemo.set(memoKey, result);
     }
     return result;
   };
@@ -423,27 +433,31 @@ async function scoreIntent(payload, opts = {}) {
         // on NODE_ENV — .env pins it to production in every context.
         let classifierResult = null;
         let jevResult = null;
+        // Task context (anchor + last ask of the prior-task ledger) so the
+        // judge resolves follow-ups. Explicit caller context wins;
+        // single-message payloads yield null (unchanged behavior). Tracked
+        // out here so _reconcile knows whether the verdict was context-fed.
+        let jevContext = typeof payload?._conversationContext === 'string'
+          ? payload._conversationContext
+          : null;
         if (!opts.skipClassifier) {
           try {
             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;
+            let signals = {};
+            try {
+              const { buildTaskContext, buildJevSignals } = require('./task-ledger');
+              if (jevContext === null) jevContext = buildTaskContext(ledger);
+              signals = buildJevSignals({
+                payload,
+                ledger,
+                isContinuation: payload?._isContinuation === true,
+                inheritedFloorIdx: payload?._inheritedFloorIdx ?? null,
+              });
+            } catch { /* ledger unavailable — judge runs on bare signals */ }
             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,
+              context: jevContext,
+              signals,
+              fetchFn: opts.jevFetchFn,
             });
             if (jevResult) {
               classifierResult = { tier: jevResult.tier, confidence: jevResult.confidence };
@@ -453,7 +467,7 @@ async function scoreIntent(payload, opts = {}) {
           }
         }
 
-        const { score, reconciled } = _reconcile(anchorScore, cls, classifierResult);
+        const { score, reconciled } = _reconcile(anchorScore, cls, classifierResult, !!jevContext);
         if (reconciled) {
           logger.debug({
             text: text.slice(0, 80),