lynkr 9.9.0 → 9.10.0

package/src/routing/complexity-analyzer.js

@@ -92,9 +92,23 @@ const ADVANCED_PATTERNS = {
   },
 };
 
-// Force cloud patterns - always route to cloud regardless of score
-const FORCE_CLOUD_PATTERNS = [
+// Force REASONING patterns - deterministic escalation to top tier (Claude in
+// config B). Checked before force_cloud. Hardcoded constants (no env var).
+// Security/governance asks route to the trusted Claude provider; deep
+// reasoning asks route to extended thinking.
+const FORCE_REASONING_PATTERNS = [
   /\b(security\s+(audit|review|assessment)|penetration\s+test|vulnerability\s+scan)\b/i,
+  /\b(ultrathink|ultra[\s-]?think)\b/i,
+  /\b(think\s+(hard|deeply|carefully|step[\s-]by[\s-]step|through\s+this))/i,
+  /\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,
+];
+
+// 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(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,
@@ -465,7 +479,13 @@ function scoreTools(payload) {
 function scoreTaskType(content) {
   const contentLower = content.toLowerCase();
 
-  // Check force patterns first
+  // Check force patterns first (priority: REASONING > cloud > local)
+  for (const pattern of FORCE_REASONING_PATTERNS) {
+    if (pattern.test(content)) {
+      return { score: 100, reason: 'force_reasoning', pattern: pattern.source.slice(0, 40) };
+    }
+  }
+
   for (const pattern of FORCE_LOCAL_PATTERNS) {
     if (pattern.test(content)) {
       return { score: 0, reason: 'force_local', pattern: 'greeting_or_simple' };
@@ -474,7 +494,7 @@ function scoreTaskType(content) {
 
   for (const pattern of FORCE_CLOUD_PATTERNS) {
     if (pattern.test(content)) {
-      return { score: 25, reason: 'force_cloud', pattern: pattern.source.slice(0, 30) };
+      return { score: 75, reason: 'force_cloud', pattern: pattern.source.slice(0, 30) };
     }
   }
 
@@ -926,6 +946,20 @@ function shouldForceCloud(payload) {
   return !!matched;
 }
 
+/**
+ * Quick check if request should be forced to REASONING tier (Claude in
+ * config B). Matches: ultrathink, think hard/deeply, prove/formal proof,
+ * from first principles, security audit.
+ */
+function shouldForceReasoning(payload) {
+  const content = extractContent(payload);
+  const matched = FORCE_REASONING_PATTERNS.find(pattern => pattern.test(content));
+  if (matched) {
+    logger.debug({ pattern: matched.source.slice(0, 50), text: content.slice(0, 100) }, '[Force] force_reasoning matched');
+  }
+  return !!matched;
+}
+
 // ============================================================================
 // PHASE 4: Embeddings-Based Similarity (Optional Enhancement)
 // ============================================================================
@@ -1041,6 +1075,7 @@ module.exports = {
   // Quick checks
   shouldForceLocal,
   shouldForceCloud,
+  shouldForceReasoning,
 
   // Individual scoring (for testing/debugging)
   scoreTokens,
@@ -1069,6 +1104,7 @@ module.exports = {
   // Constants (for testing)
   PATTERNS,
   ADVANCED_PATTERNS,
+  FORCE_REASONING_PATTERNS,
   FORCE_CLOUD_PATTERNS,
   FORCE_LOCAL_PATTERNS,
   DIMENSION_WEIGHTS,

package/src/routing/difficulty-classifier.js

@@ -0,0 +1,261 @@
+/**
+ * Difficulty classifier — LLM-based 4-way classification of user prompts.
+ *
+ * WHY THIS EXISTS: The anchor-embedding scorer (intent-score.js) measures
+ * *topical* similarity to labeled difficulty exemplars. It confuses "list
+ * the exports from this file" (LOW difficulty, technical vocabulary) with
+ * hard problems. An LLM reading the actual sentence knows better.
+ *
+ * DESIGN:
+ *  - Uses whatever model is configured for the SIMPLE tier (fetched at call
+ *    time via getModelTierSelector). When the user later swaps in a
+ *    fine-tuned classifier as SIMPLE, this picks it up automatically.
+ *  - Structured JSON output; parse failure → null → caller falls back.
+ *  - Hard 2500ms timeout; on timeout → null → caller falls back.
+ *  - LRU cache keyed by sha256(text.trim().toLowerCase()); capacity 500.
+ *  - Skip conditions surface via classifyDifficulty returning null with
+ *    reason=skipped: text.length<15, force-pattern matched, risk=high,
+ *    cache hit is transparent (returns cached).
+ *  - Hardcoded kill-switch CLASSIFIER_ENABLED — no env var per user policy.
+ *
+ * Failure modes are all null: anchor+lexical scoring already handles the
+ * fallback. This module never blocks routing.
+ */
+
+const crypto = require('crypto');
+const logger = require('../logger');
+
+const CLASSIFIER_ENABLED = true;
+// Thinking models (minimax-m2.5) spend 1-4s in <thinking> before emitting
+// JSON — 2.5s is not enough. Raise to 10s and rely on skip conditions +
+// LRU cache to keep amortized latency low.
+const TIMEOUT_MS = 10000;
+const CACHE_CAPACITY = 500;
+const MIN_TEXT_LENGTH = 15;
+
+// Classifier model — decoupled from tier serving so SIMPLE tier can run a
+// more capable model for real traffic while the classifier stays fast and
+// cheap. Chosen 2026-07-19: qwen2.5:3b hit 87.3% hand-labeled accuracy at
+// ~500ms warm latency, zero cost-critical over-routes. Replace with your
+// fine-tuned classifier when you build one. Hardcoded per user directive
+// (no env var).
+const CLASSIFIER_PROVIDER = 'ollama';
+const CLASSIFIER_MODEL = 'qwen2.5:3b';
+
+const VALID_TIERS = ['SIMPLE', 'MEDIUM', 'COMPLEX', 'REASONING'];
+
+// One-shot classification prompt (v2). Kept in a const so drift is diffable.
+// Difficulty framing (not intent) — matches config B routing goals.
+//
+// v2 (2026-07-21): added the follow-up rule, negative examples under
+// REASONING, and casual-question SIMPLE examples after a live incident:
+// qwen2.5:3b read "Who kills him ?" (a Doctor Doom plot question) as
+// REASONING conf 1.0 — v1's REASONING examples were all formal-methods
+// flavored and nothing said surface vocabulary isn't the signal. Baseline
+// on data/difficulty-eval-followups.jsonl: 60% overall, 33% on SIMPLE,
+// 3 SIMPLE→REASONING criticals.
+const CLASSIFY_PROMPT = `You are a classifier for an LLM routing proxy. Classify the difficulty of the CURRENT user prompt into exactly one of four tiers. Reply with ONLY valid JSON on a single line, no other text.
+
+Tiers:
+- SIMPLE: casual acknowledgments, greetings, one-word answers, trivial factual lookups, and short conversational follow-up questions about people, stories, events, or everyday facts. Any tiny model handles.
+  examples: "hi", "ok thanks", "yes continue", "what time is it", "who is doctor doom?", "who kills him?", "why did he do that?", "and then what happened?", "does bleach kill mold?"
+- MEDIUM: one specific mechanical task or a focused explanation. Mid-size local model suffices.
+  examples: "list the exports from this file", "run the unit tests", "fix the linter warnings", "explain this regex", "add error handling to this block", "verify the file exists before reading it"
+- COMPLEX: multi-file design, systemic refactor, architecture review, debugging that requires broad code understanding. Needs a strong general model.
+  examples: "architecture review of the orchestrator", "refactor the entire ingestion pipeline", "debug this complex race condition across three services"
+- REASONING: formal proof, correctness verification, security audit, novel algorithm design, formal reasoning from first principles. Needs a frontier reasoning model.
+  examples: "prove the correctness of this lock-free queue", "security audit the auth middleware", "formally verify this state machine never deadlocks", "derive the optimal eviction policy and prove its competitive ratio"
+  NOT reasoning: casual questions that merely contain words like "prove", "kill", "verify", "audit" — "who kills him?" is SIMPLE, "prove me wrong lol" is SIMPLE, "can you verify the score?" is SIMPLE, "verify the file exists" is MEDIUM.
+
+Rules:
+- Judge the TASK the model must perform, not the vocabulary. Words like kill/prove/verify/audit/security do not make a prompt REASONING unless it demands formal or expert-level analysis.
+- A short follow-up question (pronouns like he/she/it/that referring to the earlier conversation) about a casual topic is SIMPLE. A follow-up that extends a technical task inherits the difficulty of that task.
+
+Reply format (strict): {"tier":"SIMPLE|MEDIUM|COMPLEX|REASONING","confidence":0.0-1.0}
+`;
+
+// Short prompts are where context matters: "Who kills him ?" is
+// unclassifiable in isolation but trivially SIMPLE next to its conversation.
+// Long prompts self-describe, and contextualizing them would only shrink the
+// LRU hit rate and grow latency.
+const CONTEXT_MAX_TEXT_LENGTH = 40;
+const CONTEXT_MAX_CHARS = 300;
+
+function _buildPrompt(text, context) {
+  if (context) {
+    return `${CLASSIFY_PROMPT}
+Conversation so far (context only — classify the CURRENT prompt, inheriting topic difficulty per the rules):
+${context}
+
+CURRENT user prompt: """${text}"""`;
+  }
+  return `${CLASSIFY_PROMPT}
+User prompt: """${text}"""`;
+}
+
+// --- LRU cache --------------------------------------------------------------
+
+class LruCache {
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.map = new Map();
+  }
+  get(key) {
+    if (!this.map.has(key)) return undefined;
+    const val = this.map.get(key);
+    this.map.delete(key);
+    this.map.set(key, val); // move to MRU
+    return val;
+  }
+  set(key, val) {
+    if (this.map.has(key)) this.map.delete(key);
+    else if (this.map.size >= this.capacity) {
+      const oldest = this.map.keys().next().value;
+      this.map.delete(oldest);
+    }
+    this.map.set(key, val);
+  }
+  stats() { return { size: this.map.size, capacity: this.capacity }; }
+}
+
+const _cache = new LruCache(CACHE_CAPACITY);
+
+function _cacheKey(text) {
+  return crypto.createHash('sha256').update(text.trim().toLowerCase()).digest('hex');
+}
+
+// --- Ollama dispatch (only supported provider for the SIMPLE tier today) ----
+
+async function _callOllama(text, context, opts) {
+  const config = require('../config');
+
+  // First cut supports ollama-family classifier only. Other providers can
+  // be wired later; today's classifier is qwen2.5:3b on ollama.
+  if (CLASSIFIER_PROVIDER !== 'ollama') {
+    logger.debug({ provider: CLASSIFIER_PROVIDER, model: CLASSIFIER_MODEL }, '[DifficultyClassifier] non-ollama classifier not yet supported');
+    return null;
+  }
+
+  const endpoint = config.ollama?.endpoint || 'http://localhost:11434';
+  const url = `${endpoint.replace(/\/$/, '')}/api/chat`;
+  const body = {
+    model: CLASSIFIER_MODEL,
+    messages: [{ role: 'user', content: _buildPrompt(text, context) }],
+    stream: false,
+    format: 'json',
+    // num_predict generous because thinking models (minimax-m2.5) burn
+    // budget in message.thinking before producing message.content JSON.
+    options: { temperature: 0, num_predict: 512 },
+  };
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), opts.timeoutMs || TIMEOUT_MS);
+  try {
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify(body),
+      signal: controller.signal,
+    });
+    if (!res.ok) return null;
+    const json = await res.json();
+    // Thinking models put output in message.thinking; regular in message.content.
+    // /api/generate variants use `response`. Try all three, biggest first.
+    const candidates = [
+      json?.message?.content,
+      json?.message?.thinking,
+      json?.response,
+    ].filter(s => typeof s === 'string' && s.length > 0);
+    return candidates.join('\n') || null;
+  } catch (err) {
+    logger.debug({ err: err.message, textPreview: text.slice(0, 60) }, '[DifficultyClassifier] call failed');
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// --- Parse & validate the model's JSON output -------------------------------
+
+function _parseResult(raw) {
+  if (!raw) return null;
+  // Ollama with format:'json' usually gives clean JSON, but the model can
+  // still surround it with junk — extract the first { ... } span.
+  const match = raw.match(/\{[\s\S]*?\}/);
+  if (!match) return null;
+  let obj;
+  try { obj = JSON.parse(match[0]); } catch { return null; }
+  const tier = String(obj.tier || '').toUpperCase().trim();
+  if (!VALID_TIERS.includes(tier)) return null;
+  const rawConf = Number(obj.confidence);
+  const confidence = Number.isFinite(rawConf) ? Math.max(0, Math.min(1, rawConf)) : 0.5;
+  return { tier, confidence };
+}
+
+// --- Public API -------------------------------------------------------------
+
+/**
+ * Classify difficulty of user text.
+ *
+ * @param {string} text — cleaned user prompt
+ * @param {object} [opts]
+ * @param {number} [opts.timeoutMs] — override default 2500ms
+ * @param {boolean} [opts.forceMatched] — caller already matched a FORCE_* pattern; skip classifier
+ * @param {string} [opts.riskLevel] — 'high' | 'medium' | 'low'; skip when 'high'
+ * @param {string} [opts.context] — condensed prior conversation ("user asked:
+ *   ... → assistant replied about: ..."); used only for short prompts, where
+ *   a bare follow-up is unclassifiable in isolation
+ * @returns {Promise<{tier:string,confidence:number,source:'cache'|'model'}|null>}
+ *   null when: disabled, skipped, model failure, parse failure, timeout.
+ */
+async function classifyDifficulty(text, opts = {}) {
+  if (!CLASSIFIER_ENABLED) return null;
+  if (typeof text !== 'string') return null;
+  const trimmed = text.trim();
+  if (trimmed.length < MIN_TEXT_LENGTH) return null;
+  if (opts.forceMatched) return null;
+  if (opts.riskLevel === 'high') return null;
+
+  const context =
+    typeof opts.context === 'string' && opts.context.trim() && trimmed.length <= CONTEXT_MAX_TEXT_LENGTH
+      ? opts.context.trim().slice(0, CONTEXT_MAX_CHARS)
+      : null;
+
+  // Context participates in the cache key: the same follow-up text means
+  // different things in different conversations.
+  const key = _cacheKey(context ? `${trimmed}${context}` : trimmed);
+  const cached = _cache.get(key);
+  if (cached) return { ...cached, source: 'cache' };
+
+  const raw = await _callOllama(trimmed, context, opts);
+  const parsed = _parseResult(raw);
+  if (!parsed) return null;
+  _cache.set(key, parsed);
+  return { ...parsed, source: 'model' };
+}
+
+// --- Test helpers -----------------------------------------------------------
+
+function _clearCacheForTests() { _cache.map.clear(); }
+function _getCacheStats() { return _cache.stats(); }
+
+// Exposed metadata for the bootstrap module — keeps model choice in one file
+// so classifier-setup.js pulls exactly what the classifier will call.
+const CLASSIFIER_MODEL_INFO = Object.freeze({
+  provider: CLASSIFIER_PROVIDER,
+  model: CLASSIFIER_MODEL,
+  endpoint: process.env.OLLAMA_ENDPOINT || 'http://localhost:11434',
+});
+
+module.exports = {
+  classifyDifficulty,
+  CLASSIFIER_ENABLED,
+  CLASSIFIER_MODEL_INFO,
+  VALID_TIERS,
+  // internals for tests only
+  _parseResult,
+  _cacheKey,
+  _buildPrompt,
+  _clearCacheForTests,
+  _getCacheStats,
+};

package/src/routing/index.js

@@ -14,6 +14,7 @@ const {
   analyzeComplexity,
   shouldForceLocal,
   shouldForceCloud,
+  shouldForceReasoning,
   routingMetrics,
   analyzeWithEmbeddings,
 } = require('./complexity-analyzer');
@@ -583,6 +584,8 @@ function checkSessionPin(payload, options = {}) {
         // the new_conversation guard for everyone after it.
         messageCount: Math.max(messageCount, pin.messageCount ?? 0),
         promptTokensEst: pin.promptTokensEst,
+        // We're inside payloadHasToolHistory(payload) — session has committed.
+        hasToolHistory: true,
       });
     }
     return { serve: true, pin, reason: 'tool_history', sessionId };
@@ -598,11 +601,30 @@ function checkSessionPin(payload, options = {}) {
     sessionAffinity.setPin(sessionId, pin, {
       messageCount: Math.max(messageCount, pin.messageCount ?? 0),
       promptTokensEst: guards.promptTokensEst ?? pin.promptTokensEst,
+      // setPin OR-merges with the existing pin's flag, so a plain-text turn
+      // between tool exchanges keeps the sticky-true property.
+      hasToolHistory: _payloadHasAnyToolBlocks(payload),
     });
   }
   return { serve: true, pin, reason: 'guards_passed', sessionId };
 }
 
+/** Whole-payload scan for tool_use/tool_result blocks. Unlike
+ * sessionAffinity.payloadHasToolHistory (last message only), this checks
+ * every message so we correctly flag sessions where the last frame is a
+ * plain text turn but earlier turns carried tools. */
+function _payloadHasAnyToolBlocks(payload) {
+  const msgs = payload?.messages;
+  if (!Array.isArray(msgs)) return false;
+  for (const m of msgs) {
+    if (!Array.isArray(m?.content)) continue;
+    for (const b of m.content) {
+      if (b?.type === 'tool_use' || b?.type === 'tool_result') return true;
+    }
+  }
+  return false;
+}
+
 /**
  * Write-through helper: persist a fresh routing decision as the session's
  * new pin. No-op when sessionId is missing or the decision has no provider.
@@ -641,7 +663,11 @@ function writeSessionPin(sessionId, decision, payload) {
     return;
   }
   const promptTokensEst = _tryCountTokens(payload, decision.model);
-  sessionAffinity.setPin(sessionId, decision, { messageCount, promptTokensEst });
+  sessionAffinity.setPin(sessionId, decision, {
+    messageCount,
+    promptTokensEst,
+    hasToolHistory: _payloadHasAnyToolBlocks(payload),
+  });
 }
 
 async function _determineProviderSmartInner(payload, options = {}) {
@@ -706,11 +732,14 @@ async function _determineProviderSmartInner(payload, options = {}) {
   if (risk?.level === 'high' && isFallbackEnabled()) {
     try {
       const selector = getModelTierSelector();
-      const modelSelection = selector.selectModel('COMPLEX', null);
+      // Config B (local → GLM → Claude): high-risk requests route to the
+      // trusted provider (Claude) via REASONING, not the mid-tier GLM.
+      // Security/auth/middleware changes belong on the governance path.
+      const modelSelection = selector.selectModel('REASONING', null);
       const decision = {
         provider: modelSelection.provider,
         model: modelSelection.model,
-        tier: 'COMPLEX',
+        tier: 'REASONING',
         method: 'risk',
         reason: 'high_risk_forced_tier',
         score: 100,
@@ -719,7 +748,7 @@ async function _determineProviderSmartInner(payload, options = {}) {
         escalations: [{
           source: 'risk',
           fromTier: null,
-          toTier: 'COMPLEX',
+          toTier: 'REASONING',
           fromModel: null,
           toModel: modelSelection.model,
         }],
@@ -731,7 +760,7 @@ async function _determineProviderSmartInner(payload, options = {}) {
       };
       routingMetrics.record(decision);
       logger.debug({
-        tier: 'COMPLEX',
+        tier: 'REASONING',
         provider: decision.provider,
         instructionHits: risk.instructionHits,
         pathHits: risk.pathHits,
@@ -785,6 +814,33 @@ async function _determineProviderSmartInner(payload, options = {}) {
     return decision;
   }
 
+  // Force REASONING (Claude in config B) — checked before force_cloud.
+  // Matches ultrathink/prove/security-audit/first-principles. Deterministic
+  // routing to the top tier regardless of embedding score.
+  if (shouldForceReasoning(payload) && isFallbackEnabled() && config.modelTiers?.enabled) {
+    try {
+      const selector = getModelTierSelector();
+      const modelSelection = selector.selectModel('REASONING', null);
+      const decision = {
+        provider: modelSelection.provider,
+        model: modelSelection.model,
+        tier: 'REASONING',
+        method: 'force',
+        reason: 'force_reasoning_pattern',
+        score: 100,
+        risk,
+        propensity: 1.0,
+        candidates: [{ provider: modelSelection.provider, model: modelSelection.model }],
+        _queryEmbedding: queryEmbedding,
+        _queryText: queryText,
+      };
+      routingMetrics.record(decision);
+      return decision;
+    } catch (err) {
+      degradation.record('tier_select', err);
+    }
+  }
+
   if (shouldForceCloud(payload) && isFallbackEnabled()) {
     // When tier routing is enabled, force-cloud means the COMPLEX tier's
     // configured model — NOT getBestCloudProvider()'s credential-priority
@@ -1057,10 +1113,17 @@ async function _determineProviderSmartInner(payload, options = {}) {
 
   // Phase 1.2 — cost-optimizer override.
   // Only kick in when:
-  //  - feature flag enabled (default true, disable with LYNKR_COST_OPTIMIZE=false)
+  //  - feature flag EXPLICITLY enabled with LYNKR_COST_OPTIMIZE=true (default OFF)
   //  - risk level is not high (high-risk keeps the explicitly-configured model)
   //  - the optimizer finds a meaningfully cheaper qualifying model
-  const costOptimizeEnabled = process.env.LYNKR_COST_OPTIMIZE !== 'false'
+  //
+  // Default changed to OFF (2026-07-20): the optimizer silently overrides
+  // explicit TIER_* config with the cheapest model in the tier pool, which
+  // surprised operators who expected their tier settings to be authoritative
+  // (e.g. TIER_REASONING=azure-anthropic:claude-opus-4.7 was being swapped
+  // for openrouter:deepseek/deepseek-reasoner — which was also a typo that
+  // 400'd upstream). Opt-in only.
+  const costOptimizeEnabled = process.env.LYNKR_COST_OPTIMIZE === 'true'
     && config.routing?.costOptimize !== false;
   if (costOptimizeEnabled && risk?.level !== 'high') {
     try {