lynkr 9.14.14 → 9.14.16

package/config/difficulty-anchors.json

@@ -28,5 +28,17 @@
     "design a horizontally scalable architecture for this service with failure-mode analysis",
     "Compare how databricks.js and openai-format.js each handle non-2xx upstream responses, then propose a unified error-normalization helper both could share",
     "Code review the PR #84 routing hardening changes"
+  ],
+  "frontier": [
+    "Prove the correctness of this lock-free queue implementation and identify any ABA hazards",
+    "Design a novel conflict-free replicated data type for collaborative rich-text editing and argue its convergence from first principles",
+    "Derive the optimal cache eviction policy for this access distribution and prove its competitive ratio",
+    "Diagnose this heisenbug: a race that only reproduces under load across three services, given these interleaved logs",
+    "Design a Byzantine-fault-tolerant consensus protocol variant that tolerates f faults with 2f+1 replicas by weakening liveness, and analyze exactly which guarantees are lost",
+    "Formally verify that this state machine can never deadlock, or produce a counterexample trace",
+    "Given these profiler traces, determine whether the tail latency is queueing-theoretic or GC-driven, and prove which by constructing a discriminating experiment",
+    "Reason through the security of this key-rotation scheme under an adversary who can observe but not modify traffic, and find the weakest assumption it relies on",
+    "Work out the exact memory ordering constraints this concurrent hashmap needs on ARM, and justify each barrier from the C++ memory model",
+    "Given this failing distributed transaction trace, determine whether the anomaly is write skew or lost update, and design the minimal isolation-level change that eliminates it"
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lynkr",
-  "version": "9.14.14",
+  "version": "9.14.16",
   "files": [
     "index.js",
     "install.sh",
@@ -38,7 +38,7 @@
     "start:supervised": "while true; do node index.js 2>&1 | npx pino-pretty --sync; code=$?; echo \"[supervisor] lynkr exited ($code) — restarting in 3s\"; sleep 3; done",
     "lint": "eslint src index.js",
     "test": "npm run test:unit && npm run test:performance",
-    "test:unit": "LYNKR_KNN_DIR=/tmp/lynkr-test-knn DATABRICKS_API_KEY=test-key DATABRICKS_API_BASE=http://test.com LOG_FILE_ENABLED=false node --test test/routing.test.js test/hybrid-routing-integration.test.js test/retry-logic.test.js test/sse-transformer.test.js test/passthrough-stream.test.js test/passthrough-mode.test.js test/openrouter-error-resilience.test.js test/format-conversion.test.js test/azure-openai-config.test.js test/azure-openai-format-conversion.test.js test/azure-openai-routing.test.js test/azure-openai-streaming.test.js test/azure-openai-error-resilience.test.js test/azure-openai-integration.test.js test/openai-integration.test.js test/atlas-integration.test.js test/toon-compression.test.js test/gcf-compression.test.js test/llamacpp-integration.test.js test/resilience.test.js test/telemetry-routing.test.js test/memory/store.test.js test/memory/surprise.test.js test/memory/extractor.test.js test/memory/search.test.js test/memory/retriever.test.js test/memory/distiller.test.js test/memory/distiller-freeze.test.js test/memory/wiki.test.js test/memory/skills-cache.test.js test/memory/tencentdb-launcher.test.js test/distill.test.js test/large-payload.test.js test/prompt-cache-injection.test.js test/risk-analyzer.test.js test/interaction-block.test.js test/preflight.test.js test/token-reduction.test.js test/session-affinity.test.js test/cache-state.test.js test/cache-switch-cost.test.js test/lens-recommendations.test.js test/model-registry-cost.test.js test/output-format-guard.test.js test/tier-fallback.test.js test/wrap.test.js test/init.test.js test/tool-call-response-metadata.test.js test/degradation.test.js test/routing-telemetry-columns.test.js test/sticky-routing.test.js test/knn-ambiguous-escalate.test.js test/deescalator.test.js test/client-profiles.test.js test/strip-internal-fields.test.js test/complexity-tool-subtraction.test.js test/bandit.test.js test/routing-propensity.test.js test/reward-pipeline.test.js test/knn-cold-start.test.js test/calibration.test.js test/feedback-loop.test.js test/session-fingerprint.test.js test/side-request-guards.test.js test/verifier.test.js test/intent-score.test.js test/difficulty-classifier.test.js test/classifier-setup.test.js test/usage-stats.test.js test/loop-guard.test.js test/moonshot-model-mapping.test.js test/baidu-model-mapping.test.js test/tenant-policy-ingress-parity.test.js test/decide.test.js test/embeddings-degradation.test.js test/health-probe.test.js test/stuck-detector.test.js test/onnx-embedder.test.js test/ope.test.js test/hierarchical-budget.test.js test/token-rate-limit.test.js test/otel-export.test.js test/mcp-broker.test.js test/compression-budget.test.js test/gpt-utils.test.js test/dedup-observe-only.test.js test/context-window-header.test.js test/token-budget-auto.test.js test/opencode-setup.test.js test/auth-mode-first-party.test.js test/jev-router.test.js test/jev-routing.test.js test/force-patterns.test.js test/upstream-fidelity.test.js test/tool-schema-compression.test.js test/passthrough-route.test.js test/quota-ledger.test.js",
+    "test:unit": "LYNKR_KNN_DIR=/tmp/lynkr-test-knn DATABRICKS_API_KEY=test-key DATABRICKS_API_BASE=http://test.com LOG_FILE_ENABLED=false node --test test/routing.test.js test/hybrid-routing-integration.test.js test/retry-logic.test.js test/sse-transformer.test.js test/passthrough-stream.test.js test/passthrough-mode.test.js test/openrouter-error-resilience.test.js test/format-conversion.test.js test/azure-openai-config.test.js test/azure-openai-format-conversion.test.js test/azure-openai-routing.test.js test/azure-openai-streaming.test.js test/azure-openai-error-resilience.test.js test/azure-openai-integration.test.js test/openai-integration.test.js test/atlas-integration.test.js test/toon-compression.test.js test/gcf-compression.test.js test/llamacpp-integration.test.js test/resilience.test.js test/telemetry-routing.test.js test/memory/store.test.js test/memory/surprise.test.js test/memory/extractor.test.js test/memory/search.test.js test/memory/retriever.test.js test/memory/distiller.test.js test/memory/distiller-freeze.test.js test/memory/wiki.test.js test/memory/skills-cache.test.js test/memory/tencentdb-launcher.test.js test/distill.test.js test/large-payload.test.js test/prompt-cache-injection.test.js test/risk-analyzer.test.js test/interaction-block.test.js test/preflight.test.js test/token-reduction.test.js test/session-affinity.test.js test/cache-state.test.js test/cache-switch-cost.test.js test/lens-recommendations.test.js test/model-registry-cost.test.js test/output-format-guard.test.js test/tier-fallback.test.js test/wrap.test.js test/init.test.js test/tool-call-response-metadata.test.js test/degradation.test.js test/routing-telemetry-columns.test.js test/sticky-routing.test.js test/knn-ambiguous-escalate.test.js test/deescalator.test.js test/client-profiles.test.js test/strip-internal-fields.test.js test/complexity-tool-subtraction.test.js test/bandit.test.js test/routing-propensity.test.js test/reward-pipeline.test.js test/knn-cold-start.test.js test/calibration.test.js test/feedback-loop.test.js test/session-fingerprint.test.js test/side-request-guards.test.js test/verifier.test.js test/intent-score.test.js test/difficulty-classifier.test.js test/classifier-setup.test.js test/usage-stats.test.js test/loop-guard.test.js test/moonshot-model-mapping.test.js test/baidu-model-mapping.test.js test/tenant-policy-ingress-parity.test.js test/decide.test.js test/embeddings-degradation.test.js test/health-probe.test.js test/stuck-detector.test.js test/onnx-embedder.test.js test/ope.test.js test/hierarchical-budget.test.js test/token-rate-limit.test.js test/otel-export.test.js test/mcp-broker.test.js test/compression-budget.test.js test/gpt-utils.test.js test/dedup-observe-only.test.js test/context-window-header.test.js test/token-budget-auto.test.js test/opencode-setup.test.js test/auth-mode-first-party.test.js test/harness-envelope.test.js test/task-ledger.test.js test/jev-router.test.js test/jev-routing.test.js test/force-patterns.test.js test/upstream-fidelity.test.js test/tool-schema-compression.test.js test/passthrough-route.test.js test/quota-ledger.test.js",
     "test:memory": "LYNKR_KNN_DIR=/tmp/lynkr-test-knn DATABRICKS_API_KEY=test-key DATABRICKS_API_BASE=http://test.com node --test test/memory/store.test.js test/memory/surprise.test.js test/memory/extractor.test.js test/memory/search.test.js test/memory/retriever.test.js test/memory/distiller.test.js test/memory/distiller-freeze.test.js test/memory/wiki.test.js test/memory/skills-cache.test.js test/memory/tencentdb-launcher.test.js",
     "test:new-features": "LYNKR_KNN_DIR=/tmp/lynkr-test-knn DATABRICKS_API_KEY=test-key DATABRICKS_API_BASE=http://test.com node --test test/passthrough-mode.test.js test/openrouter-error-resilience.test.js test/format-conversion.test.js",
     "test:performance": "LYNKR_KNN_DIR=/tmp/lynkr-test-knn DATABRICKS_API_KEY=test-key DATABRICKS_API_BASE=http://test.com node test/hybrid-routing-performance.test.js && DATABRICKS_API_KEY=test-key DATABRICKS_API_BASE=http://test.com node test/performance-tests.js",

package/scripts/harvest-followup-eval.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+/**
+ * Harvest short follow-up turns from routing telemetry for the TaskBand
+ * continuation-detector eval set.
+ *
+ * Reads <cwd>/.lynkr/telemetry.db (read-only — never mutates production
+ * telemetry), groups rows by session ordered by timestamp, and emits every
+ * turn whose request_text is ≤200 chars: short asks are where "do the same
+ * here" follow-ups live, and where single-message scoring is blindest.
+ * Each line carries up to 3 prior asks from the same session so a labeler
+ * can judge continuation vs. new task without replaying the session.
+ *
+ * Output: data/followup-eval-unlabeled.jsonl (gitignored), one JSON object
+ * per line: {session_id, ts, request_text, prior_asks, chosen_tier,
+ * complexity_score, label: null} — label is filled in by hand.
+ *
+ * Usage: node scripts/harvest-followup-eval.js
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+const MAX_ASK_CHARS = 200;
+const MAX_PRIOR_ASKS = 3;
+const OUT_FILE = path.join(__dirname, "../data/followup-eval-unlabeled.jsonl");
+
+let Database;
+try {
+  Database = require("better-sqlite3");
+} catch {
+  console.error("better-sqlite3 is not installed (it is an optionalDependency) — cannot read telemetry.db.");
+  console.error("Install it with: npm install better-sqlite3");
+  process.exit(1);
+}
+
+function main() {
+  const dbPath = path.join(process.cwd(), ".lynkr", "telemetry.db");
+  if (!fs.existsSync(dbPath)) {
+    console.error(`No telemetry database at ${dbPath} — run the proxy from this directory first to collect telemetry.`);
+    process.exit(1);
+  }
+
+  const db = new Database(dbPath, { readonly: true, fileMustExist: true });
+
+  const rows = db
+    .prepare(
+      `SELECT session_id, timestamp, request_text, tier, complexity_score
+       FROM routing_telemetry
+       WHERE session_id IS NOT NULL AND request_text IS NOT NULL AND request_text != ''
+       ORDER BY session_id, timestamp ASC`
+    )
+    .all();
+  db.close();
+
+  const out = [];
+  let sessions = 0;
+  let prevSession = null;
+  let priorAsks = [];
+
+  for (const row of rows) {
+    if (row.session_id !== prevSession) {
+      prevSession = row.session_id;
+      priorAsks = [];
+      sessions++;
+    }
+    const text = String(row.request_text);
+    if (text.length <= MAX_ASK_CHARS) {
+      out.push(JSON.stringify({
+        session_id: row.session_id,
+        ts: row.timestamp,
+        request_text: text,
+        prior_asks: priorAsks.slice(-MAX_PRIOR_ASKS),
+        chosen_tier: row.tier ?? null,
+        complexity_score: row.complexity_score ?? null,
+        label: null,
+      }));
+    }
+    priorAsks.push(text);
+  }
+
+  fs.mkdirSync(path.dirname(OUT_FILE), { recursive: true });
+  fs.writeFileSync(OUT_FILE, out.length ? out.join("\n") + "\n" : "");
+  console.log(`Scanned ${rows.length} rows across ${sessions} sessions.`);
+  console.log(`Wrote ${OUT_FILE}: ${out.length} candidate follow-up turns (label: null — awaiting hand labels).`);
+}
+
+main();

package/src/api/router.js

@@ -10,6 +10,7 @@ const providersRouter = require("./providers-handler");
 const claudeDesktopGatewayRouter = require("./claude-desktop-gateway");
 const { getRoutingHeaders, getRoutingStats, analyzeComplexity, getModelTierSelector, analyzeRisk, checkSessionPin, writeSessionPin, checkPinScoreDrift } = require("../routing");
 const { resolveTierForModelId } = require("../routing/model-slots");
+const { stripHarnessEnvelope } = require("../routing/harness-envelope");
 
 // Upstream streams can die without a clean end (reader.read() never
 // resolves on a dropped socket), hanging the client forever. Every
@@ -44,6 +45,24 @@ const router = express.Router();
 
 const rateLimiter = createRateLimiter();
 
+// TaskBand holdout: a deterministic slice of sessions never receives the
+// continuation floor, so telemetry keeps a running baseline cohort proving
+// floored sessions aren't quietly doing worse. FNV-1a bucketing mirrors
+// deescalator.isHeldOut; the percentage is task-ledger's hardcoded
+// HOLDOUT_PCT (no env knob by design).
+function _taskbandHoldout(sessionKey, pct) {
+  if (!sessionKey) return false;
+  const cut = Math.round(Math.max(0, Math.min(1, Number(pct) || 0)) * 100);
+  if (cut === 0) return false;
+  let hash = 0x811c9dc5;
+  const s = String(sessionKey);
+  for (let i = 0; i < s.length; i++) {
+    hash ^= s.charCodeAt(i);
+    hash = Math.imul(hash, 0x01000193);
+  }
+  return ((hash >>> 0) % 100) < cut;
+}
+
 /**
  * Decide which tier/provider/model handles an OAuth-subscription request.
  *
@@ -170,45 +189,25 @@ async function pickTierByIntent(body) {
     };
   }
 
-  // Condense a message's text for classifier context: text blocks only,
-  // reminders stripped, whitespace collapsed, hard-capped. Best-effort.
-  const _condenseText = (msg, max = 140) => {
-    if (!msg) return '';
-    let text = '';
-    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(' ');
-    }
-    return stripReminders(text).replace(/\s+/g, ' ').trim().slice(0, max);
-  };
-
-  // Conversation context for the difficulty classifier: the nearest prior
-  // assistant reply and the user turn before it. A bare follow-up ("Who
-  // kills him ?") is unclassifiable in isolation — the single-message
+  // Task-ledger context for the difficulty judge: a slim stable string
+  // (task anchor + last ask) folded from the PREFIX of the thread — the ask
+  // being scored never feeds its own context. A bare follow-up ("Who kills
+  // him ?") is unclassifiable in isolation — the single-message
   // intentPayload below is context-blind BY DESIGN (envelope invariance),
   // so the context travels as a separate condensed string, never as extra
-  // messages that would pollute the anchor score.
-  const _contextBefore = (msg) => {
+  // messages that would pollute the anchor score. The ledger's prefix memo
+  // keeps the per-index derivation O(1) per new ask.
+  let _taskLedgerMod = null;
+  try { _taskLedgerMod = require("../routing/task-ledger"); } catch { /* context degrades to null */ }
+  const _ledgerBefore = (msg) => {
+    if (!_taskLedgerMod) return null;
     const idx = messages.indexOf(msg);
     if (idx <= 0) return null;
-    let assistantText = '';
-    let priorUserText = '';
-    for (let j = idx - 1; j >= 0; j--) {
-      const m = messages[j];
-      if (!assistantText && m?.role === 'assistant') assistantText = _condenseText(m);
-      else if (assistantText && m?.role === 'user') {
-        priorUserText = _condenseText(m);
-        if (priorUserText) break;
-      }
+    try {
+      return _taskLedgerMod.deriveTaskLedger(messages.slice(0, idx));
+    } catch {
+      return null;
     }
-    if (!assistantText && !priorUserText) return null;
-    const parts = [];
-    if (priorUserText) parts.push(`user asked: """${priorUserText}"""`);
-    if (assistantText) parts.push(`assistant replied about: """${assistantText}"""`);
-    return parts.join(' → ');
   };
 
   // Per-message scoring intentionally omits _sessionId so session affinity
@@ -223,6 +222,11 @@ async function pickTierByIntent(body) {
   for (let i = 0; i < windowUserMsgs.length; i++) {
     const age = windowUserMsgs.length - 1 - i; // 0 = latest, length-1 = oldest in window
     const cleaned = cleanMsg(windowUserMsgs[i]);
+    const _msgLedger = _ledgerBefore(windowUserMsgs[i]);
+    let _msgContext = null;
+    try {
+      _msgContext = _msgLedger ? _taskLedgerMod.buildTaskContext(_msgLedger) : null;
+    } catch { /* context degrades to null */ }
     const intentPayload = {
       messages: cleaned ? [cleaned] : [],
       tools: intentTools,
@@ -230,10 +234,17 @@ async function pickTierByIntent(body) {
       // agentic detector inside determineProviderSmart can subtract the
       // harness's baseline tools during intent scoring too.
       _clientProfile: body?._clientProfile || null,
-      // Classifier context (see _contextBefore). Underscored — stripped at
-      // the outbound chokepoint like every internal field.
-      _conversationContext: _contextBefore(windowUserMsgs[i]),
+      // Classifier context + memo identity (see _ledgerBefore). Underscored
+      // — stripped at the outbound chokepoint like every internal field.
+      _conversationContext: _msgContext,
+      _taskAnchorHash: _msgLedger?.anchorHash || null,
     };
+    if (age === 0) {
+      // Continuation detection ran ONCE in the handler, on the latest typed
+      // ask only — windowed history messages must never carry these.
+      if (body?._isContinuation) intentPayload._isContinuation = true;
+      if (body?._inheritedFloorTier) intentPayload._inheritedFloorTier = body._inheritedFloorTier;
+    }
     try {
       const decision = await determineProviderSmart(intentPayload, {
         workspace: body?._workspace || null,
@@ -359,7 +370,9 @@ async function handleOauthPassthrough(req, res, opts = {}) {
   // Strip Lynkr's internal underscore-prefixed fields (_sessionId,
   // _forceProvider, _tierModel, _tierName, _forcedMethod, _baseTier,
   // _escalationSource, _pinnedRoute, _switchReason, _clientProfile,
-  // _workspace, _tenantPolicy, _deadlineMs, _suggestionModeModel). Anthropic
+  // _workspace, _tenantPolicy, _deadlineMs, _suggestionModeModel,
+  // _conversationContext, _taskAnchorHash, _isContinuation,
+  // _inheritedFloorTier, _taskband). Anthropic
   // rejects unknown top-level keys with "Extra inputs are not permitted".
   // The orchestrator's downstream paths whitelist their outbound bodies,
   // but the passthrough sends this body VERBATIM — so we must strip here.
@@ -664,6 +677,7 @@ async function handleOauthPassthrough(req, res, opts = {}) {
         message_count: req.body?.messages?.length || null,
         tool_count: Array.isArray(req.body?.tools) ? req.body.tools.length : 0,
         ...tlm.jevFields(tier),
+        ...tlm.taskbandFields(tier),
         // Inner-decision attribution: the tier label alone can't explain a
         // serve (a COMPLEX label once served Haiku with no trace because the
         // tier object carried a null model). Record the decision's own
@@ -1180,6 +1194,96 @@ router.post("/v1/messages", rateLimiter, async (req, res, next) => {
       req.body._sessionId = req.sessionId;
     }
 
+    // TaskBand — fold the thread (minus the current ask) into a task ledger
+    // and run continuation detection ONCE, on the latest typed ask only.
+    // Stamped on the body so pin-drift checks, the per-message intent loop
+    // and the difficulty judge all score from identical inputs. Best-effort
+    // throughout: any failure leaves routing exactly as before TaskBand.
+    let _taskLedger = null;
+    let _taskCont = null;
+    let _taskFloorTier = null;      // would-be continuation floor (tier name)
+    let _taskFloorHeldOut = false;  // holdout cohort: floor logged, not applied
+    let _taskPreFloorTier = null;   // fresh tier before the floor raised it
+    let _continuationFloored = false;
+    let _taskSideRequest = false;
+    let _jevStatsBefore = null;
+    try { _jevStatsBefore = require("../routing/jev-router").getJevCacheStats(); } catch { /* stamp stays null */ }
+    try {
+      const taskLedgerMod = require("../routing/task-ledger");
+      const { cleanUserText } = require("../routing/jev-router");
+      const _msgs = Array.isArray(req.body?.messages) ? req.body.messages : [];
+      let _askIdx = -1;
+      let _askText = null;
+      for (let i = _msgs.length - 1; i >= 0; i--) {
+        if (_msgs[i]?.role !== 'user') continue;
+        const t = cleanUserText(_msgs[i]);
+        if (t) { _askIdx = i; _askText = t; break; }
+      }
+      if (_askIdx > 0) _taskLedger = taskLedgerMod.deriveTaskLedger(_msgs.slice(0, _askIdx));
+      if (_taskLedger) {
+        const _ctx = taskLedgerMod.buildTaskContext(_taskLedger);
+        if (_ctx) req.body._conversationContext = _ctx;
+        if (_taskLedger.anchorHash) req.body._taskAnchorHash = _taskLedger.anchorHash;
+        const _embedFn = async (t) => {
+          try {
+            return await require("../routing/knn-router").getKnnRouter().embed(t);
+          } catch { return null; }
+        };
+        _taskCont = await taskLedgerMod.detectContinuation(_askText, _taskLedger, _embedFn);
+        if (_taskCont?.isContinuation) req.body._isContinuation = true;
+      }
+      const {
+        FLOOR_ENABLED = true,
+        DECAY_TURNS = 2,
+        HOLDOUT_PCT = 0.10,
+      } = taskLedgerMod;
+      if (FLOOR_ENABLED && _taskCont?.isContinuation && _taskLedger?.anchorHash) {
+        const TIER_ORDER = ['SIMPLE', 'MEDIUM', 'COMPLEX', 'REASONING'];
+        let effIdx = null;
+        let coldFallback = false;
+        const _taskState = req.body._sessionId
+          ? require("../routing/affinity-store").getTaskState(req.body._sessionId)
+          : null;
+        if (_taskState && _taskState.anchorHash === _taskLedger.anchorHash
+          && Number.isInteger(_taskState.effectiveBand)) {
+          effIdx = Math.max(0, Math.min(3, _taskState.effectiveBand));
+        } else if (_taskLedger.anchorText) {
+          // COLD fallback: the task predates its state row (restart, TTL,
+          // anchor change). Anchor-only score of the task's first ask,
+          // capped at MEDIUM — an unproven inheritance must not re-derive
+          // an expensive band from a single string.
+          const { scoreIntent } = require("../routing/intent-score");
+          const anchorIntent = await scoreIntent(
+            { messages: [{ role: 'user', content: _taskLedger.anchorText }] },
+            { skipClassifier: true },
+          );
+          if (anchorIntent && Number.isFinite(anchorIntent.score)) {
+            const t = getModelTierSelector().getTier(anchorIntent.score);
+            effIdx = Math.min(TIER_ORDER.indexOf(t), TIER_ORDER.indexOf('MEDIUM'));
+            coldFallback = true;
+          }
+        }
+        let floorIdx = null;
+        if (effIdx != null && effIdx >= 0) {
+          if (_taskLedger.open) floorIdx = effIdx;
+          else if ((_taskLedger.turnsSinceClose ?? Infinity) <= DECAY_TURNS) floorIdx = effIdx - 1;
+        }
+        if (floorIdx != null && coldFallback) {
+          floorIdx = Math.min(floorIdx, TIER_ORDER.indexOf('COMPLEX'));
+        }
+        if (floorIdx != null && floorIdx >= 0) {
+          _taskFloorTier = TIER_ORDER[floorIdx];
+          _taskFloorHeldOut = _taskbandHoldout(req.body._sessionId, HOLDOUT_PCT);
+          // Held-out sessions must stay floor-free end to end — the judge's
+          // cap widening counts as an application, so the body stamp is
+          // withheld too, keeping the baseline cohort clean.
+          if (!_taskFloorHeldOut) req.body._inheritedFloorTier = _taskFloorTier;
+        }
+      }
+    } catch (err) {
+      logger.debug({ err: err.message }, '[TaskBand] ledger/continuation derivation failed');
+    }
+
     // WS1 — sticky-session reuse. If this session already has a valid pin
     // (guards pass, no compaction), skip pickTierByIntent entirely and reuse
     // the pinned decision. This is the biggest cost win of WS1: repeat turns
@@ -1306,7 +1410,11 @@ router.post("/v1/messages", rateLimiter, async (req, res, next) => {
       }
       return '';
     })();
+    // Suggestion-mode detection reads the RAW text (the marker is itself
+    // wrapper text); the force/risk probes below get envelope-stripped text
+    // so Cursor's <user_info>/<rules> blocks can't fire triggers on "Hi".
     const isSuggestionMode = _lastUserText.includes('[SUGGESTION MODE:');
+    const _lastUserAskClean = stripHarnessEnvelope(_lastUserText);
     // Tool-lessness alone is NOT harness evidence: generic API clients
     // (curl, benchmarks, SDKs) legitimately send bare messages and must get
     // full routing — live regression 2026-07-08: a benchmark's security-
@@ -1358,6 +1466,9 @@ router.post("/v1/messages", rateLimiter, async (req, res, next) => {
       || isBareRequest
       || isFingerprintDrift
       || ((!Array.isArray(req.body?.tools) || req.body.tools.length === 0) && isKnownHarness);
+    // Task state must never see side traffic (hoisted for the upkeep block
+    // at the final-decision site — the model-id-pin branch skips this scope).
+    _taskSideRequest = isSideRequest;
     // Side requests short-circuit to the static SIMPLE tier: no pin read
     // (a COMPLEX-pinned conversation would burn expensive tokens on
     // autocomplete), no pin write, no intent scoring of wrapper text.
@@ -1429,7 +1540,7 @@ router.post("/v1/messages", rateLimiter, async (req, res, next) => {
       let _pinForceBypass = null;
       if (!sideTier && pinCheck.serve && pinCheck.reason === 'guards_passed' && !isSideRequest) {
         try {
-          const _probe = { messages: [{ role: 'user', content: _lastUserText || '' }] };
+          const _probe = { messages: [{ role: 'user', content: _lastUserAskClean || '' }] };
           const ca = require("../routing/complexity-analyzer");
           if (_lastUserText && ca.shouldForceReasoning(_probe)) _pinForceBypass = 'force_reasoning';
           else if (_lastUserText && ca.shouldForceCloud(_probe)) _pinForceBypass = 'force_cloud';
@@ -1521,6 +1632,63 @@ router.post("/v1/messages", rateLimiter, async (req, res, next) => {
           };
         }
       }
+      // TaskBand continuation floor — fresh decisions only, and only to
+      // RAISE. Placement is deliberate: after the compaction floor so the
+      // two floors compose (max wins), before the pin write so a floored
+      // tier can never fossilize into a session pin (writeSessionPin also
+      // refuses '+continuation_inherit', mirroring the risk skip).
+      if (!isSideRequest && _taskFloorTier && tier?.tier) {
+        try {
+          const { TIER_DEFINITIONS } = require("../routing/model-tiers");
+          const pri = (t) => TIER_DEFINITIONS[t]?.priority ?? -1;
+          const wouldRaise = pri(tier.tier) < pri(_taskFloorTier);
+          if (_taskFloorHeldOut && wouldRaise) {
+            tier.method = (tier.method || 'tier_config') + '+continuation_holdout';
+            logger.debug({
+              sessionId: pinCheck.sessionId,
+              freshTier: tier.tier,
+              wouldFloorTo: _taskFloorTier,
+              evidence: _taskCont?.evidence || [],
+            }, "OAuth intent — continuation floor held out (baseline cohort)");
+          } else if (wouldRaise) {
+            const flooredSel = getModelTierSelector().selectModel(_taskFloorTier, null);
+            if (flooredSel?.provider) {
+              const _fromTier = tier.tier;
+              const _fromModel = tier.model || null;
+              _taskPreFloorTier = _fromTier;
+              logger.info({
+                sessionId: pinCheck.sessionId,
+                freshTier: _fromTier,
+                flooredTo: _taskFloorTier,
+                evidence: _taskCont?.evidence || [],
+              }, "OAuth intent — continuation inherits task band");
+              tier = {
+                ...tier,
+                tier: _taskFloorTier,
+                provider: flooredSel.provider,
+                model: flooredSel.model || null,
+                method: (tier.method || 'tier_config') + '+continuation_inherit',
+                switch_reason: tier.switch_reason || 'continuation_inherit',
+                base_tier: tier.base_tier ?? _fromTier,
+                escalation_source: tier.escalation_source ?? 'continuation_inherit',
+                escalations: [
+                  ...(Array.isArray(tier.escalations) ? tier.escalations : []),
+                  {
+                    source: 'continuation_inherit',
+                    fromTier: _fromTier,
+                    toTier: _taskFloorTier,
+                    fromModel: _fromModel,
+                    toModel: flooredSel.model || null,
+                  },
+                ],
+              };
+              _continuationFloored = true;
+            }
+          }
+        } catch (err) {
+          logger.debug({ err: err.message }, '[TaskBand] continuation floor failed — fresh tier stands');
+        }
+      }
       // Persist the fresh decision so the next turn on this session can
       // reuse it. checkSessionPin returned serve=false (or WS1.5 drift fired),
       // so either there was no pin, the pin lost a guard (context/vision/
@@ -1546,6 +1714,104 @@ router.post("/v1/messages", rateLimiter, async (req, res, next) => {
       tier.switch_reason = 'model_pin_drift';
     }
 
+    // TaskBand telemetry stamp — travels on the decision AND (underscored)
+    // on the body, so the forced-provider path can reconstitute it onto the
+    // routingResult that feeds routing_telemetry.
+    try {
+      let _jevCacheHit = null;
+      if (_jevStatsBefore) {
+        const _jevStatsAfter = require("../routing/jev-router").getJevCacheStats();
+        const _missDelta = _jevStatsAfter.misses - _jevStatsBefore.misses;
+        const _hitDelta = _jevStatsAfter.hits - _jevStatsBefore.hits;
+        // Null means the judge never consulted its cache this request
+        // (pin serve, side frame, classifier skip) — "not measured".
+        _jevCacheHit = _missDelta > 0 ? 0 : (_hitDelta > 0 ? 1 : null);
+      }
+      tier.taskband = {
+        isContinuation: _taskCont?.isContinuation ? 1 : 0,
+        inheritedFloor: _taskFloorTier || null,
+        anchorHash: _taskLedger?.anchorHash || null,
+        jevContext: typeof req.body._conversationContext === 'string'
+          ? req.body._conversationContext : null,
+        jevCacheHit: _jevCacheHit,
+      };
+      req.body._taskband = tier.taskband;
+    } catch (err) {
+      logger.debug({ err: err.message }, '[TaskBand] telemetry stamp failed');
+    }
+
+    // TaskBand task-state upkeep — once per request, at the final-decision
+    // site, never inside the per-message scoring loop. Side requests never
+    // touch task state. Pin replays never write: a pinned tier keeps no
+    // provenance of how it was chosen (a force-triggered tier pins like any
+    // scored one), so replaying it must not launder into earned band — the
+    // fresh serve that created the pin already merged. Model-id pins are
+    // explicit client choices, not earned difficulty — no writes either.
+    try {
+      const _sessForTask = req.body._sessionId || null;
+      if (_sessForTask && _taskLedger?.anchorHash && !_taskSideRequest) {
+        const store = require("../routing/affinity-store");
+        let AUTO_CLOSE_LOW_TURNS = 3;
+        try {
+          const _tl = require("../routing/task-ledger");
+          if (Number.isInteger(_tl.AUTO_CLOSE_LOW_TURNS)) AUTO_CLOSE_LOW_TURNS = _tl.AUTO_CLOSE_LOW_TURNS;
+        } catch { /* default stands */ }
+        const TIER_ORDER = ['SIMPLE', 'MEDIUM', 'COMPLEX', 'REASONING'];
+        const _method = tier?.method || '';
+        const _openNow = _taskLedger.open ? 1 : 0;
+        const _row = store.getTaskState(_sessForTask);
+        const _anchorMatches = !!(_row && _row.anchorHash === _taskLedger.anchorHash);
+        if (_method !== 'session_pin' && _method !== 'model_id_pin' && _method !== 'fallback') {
+          // Low-streak decay reads the FRESH-scored tier, not the floored
+          // one — otherwise an applied floor could never auto-close.
+          let _freshTier = _taskPreFloorTier || tier?.tier || null;
+          // A jev-override lift rides a cap the inherited floor may have
+          // widened; only the scored base tier is earned band. Merging the
+          // lifted tier would raise the next turn's floor, which widens the
+          // next cap — the ratchet the one-band-up cap exists to break.
+          if (/(^|\+)jev_override(\+|$)/.test(_method)) {
+            const _scoredIdx = TIER_ORDER.indexOf(tier?.base_tier);
+            if (_scoredIdx >= 0 && _scoredIdx < TIER_ORDER.indexOf(_freshTier)) {
+              _freshTier = tier.base_tier;
+            }
+          }
+          const _freshIdx = TIER_ORDER.indexOf(_freshTier);
+          const _forceOrRisk = /(^|\+)(force|risk)(\+|$)/.test(_method)
+            || tier?.escalation_source === 'risk';
+          if (_freshIdx >= 0) {
+            let _lowStreak = 0;
+            if (_anchorMatches && Number.isInteger(_row.effectiveBand)
+              && _freshIdx <= _row.effectiveBand - 2) {
+              _lowStreak = (_row.lowStreak ?? 0) + 1;
+            }
+            if (_lowStreak >= AUTO_CLOSE_LOW_TURNS) {
+              store.clearTaskState(_sessForTask);
+            } else if (!_continuationFloored && !_forceOrRisk) {
+              // MAX-merge on matching anchor, whole-row overwrite on an
+              // anchor change — both live inside setTaskState.
+              store.setTaskState(_sessForTask, {
+                anchorHash: _taskLedger.anchorHash,
+                effectiveBand: _freshIdx,
+                open: _openNow,
+                lowStreak: _lowStreak,
+              });
+            } else if (_anchorMatches) {
+              // Floored/force/risk serves never merge their band, but the
+              // marker-close and the low streak still have to land.
+              store.setTaskState(_sessForTask, {
+                anchorHash: _row.anchorHash,
+                effectiveBand: Number.isInteger(_row.effectiveBand) ? _row.effectiveBand : _freshIdx,
+                open: _row.open && _openNow ? 1 : 0,
+                lowStreak: _lowStreak,
+              });
+            }
+          }
+        }
+      }
+    } catch (err) {
+      logger.debug({ err: err.message }, '[TaskBand] task-state upkeep failed');
+    }
+
     // Subscription-only fork: byte-for-byte passthrough to api.anthropic.com
     // when the picked tier resolves to azure-anthropic — FIRST-PARTY
     // Anthropic clients only (Claude Code / Claude Desktop wrapping their
@@ -1622,6 +1888,15 @@ router.post("/v1/messages", rateLimiter, async (req, res, next) => {
           tierMethod: tier?.method || null,
           tierPinned: tier?.pinned ?? null,
           cacheState: _pinCacheState,
+          // Mid tool-exchange frames must keep serving the in-flight model
+          // (same invariant as the orchestrator's tool_history pin serves).
+          hasToolHistory: (() => {
+            try { return require("../routing/session-affinity").payloadHasToolHistory(req.body); }
+            catch { return false; }
+          })(),
+          // This branch IS the flat-fee subscription: the gate's dollar
+          // break-even leg has no premium to amortize here.
+          flatRate: true,
           // Quota pressure shortens the hold horizon inside the gate (high
           // sustained burn → descents clear sooner). Zero when the ledger has
           // no history — the gate behaves exactly as before.
@@ -1658,6 +1933,36 @@ router.post("/v1/messages", rateLimiter, async (req, res, next) => {
           logger.debug({ err: err.message }, '[Routing] Pin-hold restore failed (non-fatal)');
         }
       }
+      // Upgrades must persist the SERVED model into the pin, mirroring the
+      // pin_hold restore above — the write at the fresh-decision site stored
+      // the pre-rewrite tier model, and a pin that forgets the upgrade lets
+      // later frames descend below what actually served. Unlike pin_hold,
+      // an upgrade usually happens with no prior pin, so the payload comes
+      // from the fresh tier object. Floored (+continuation_inherit) and
+      // risk-lifted tiers stay unpinned (writeSessionPin re-checks, but the
+      // method is overridden to 'session_pin' here, so guard at the source).
+      if (
+        _passthroughRoute.action === 'upgrade'
+        && _passthroughRoute.model
+        && pinCheck?.sessionId
+        && tier?.provider
+        && !String(tier?.method || '').includes('+continuation_inherit')
+        && tier?.escalation_source !== 'risk'
+      ) {
+        try {
+          const { writeSessionPin } = require("../routing/index");
+          writeSessionPin(pinCheck.sessionId, {
+            provider: tier.provider,
+            model: _passthroughRoute.model,
+            tier: tier.tier,
+            score: tier.score ?? null,
+            method: 'session_pin',
+            reason: 'passthrough_upgrade',
+          }, req.body);
+        } catch (err) {
+          logger.debug({ err: err.message }, '[Routing] Upgrade pin persist failed (non-fatal)');
+        }
+      }
       if (_passthroughRoute.action !== 'verbatim' && _passthroughRoute.model) {
         logger.info({
           from: _passthroughClientModel,