lynkr 9.7.3 → 9.9.1

package/src/routing/classifier-setup.js

@@ -0,0 +1,207 @@
+/**
+ * Classifier bootstrap — verifies ollama is installed and the classifier
+ * model is pulled + warm. Called from:
+ *  - `lynkr init` (interactive, prompts user for install, blocks on completion)
+ *  - server boot (non-blocking, logs warnings, never errors out)
+ *
+ * Ollama install is intentionally NOT auto-executed. Silent `curl | sh`
+ * during npm install is a supply-chain footgun; we detect and instruct
+ * instead.
+ *
+ * "Later" work per user directive:
+ *  - Fine-tune qwen2.5:3b on labeled classification data (needs LoRA infra)
+ *  - Canary verification against known-good prompts on every startup
+ */
+
+const { spawn } = require('child_process');
+const os = require('os');
+
+// Reads the classifier model constant from difficulty-classifier.js so this
+// module and the classifier stay in lock-step.
+const { CLASSIFIER_MODEL_INFO } = require('./difficulty-classifier');
+
+/**
+ * Check whether the `ollama` CLI is on PATH.
+ * @returns {Promise<{installed: boolean, version?: string}>}
+ */
+function detectOllama() {
+  return new Promise((resolve) => {
+    const proc = spawn('ollama', ['--version'], { stdio: ['ignore', 'pipe', 'ignore'] });
+    let out = '';
+    proc.stdout?.on('data', (d) => { out += d.toString(); });
+    proc.on('error', () => resolve({ installed: false }));
+    proc.on('close', (code) => {
+      if (code === 0) {
+        resolve({ installed: true, version: out.trim() });
+      } else {
+        resolve({ installed: false });
+      }
+    });
+  });
+}
+
+/**
+ * Check whether a specific ollama model is present locally.
+ * @param {string} model
+ * @returns {Promise<boolean>}
+ */
+function isModelPulled(model) {
+  return new Promise((resolve) => {
+    const proc = spawn('ollama', ['list'], { stdio: ['ignore', 'pipe', 'ignore'] });
+    let out = '';
+    proc.stdout?.on('data', (d) => { out += d.toString(); });
+    proc.on('error', () => resolve(false));
+    proc.on('close', () => {
+      // ollama list prints "NAME ID SIZE MODIFIED" — grep by exact model name
+      const rows = out.split('\n').slice(1);
+      resolve(rows.some((line) => line.startsWith(model + ' ') || line.split(/\s+/)[0] === model));
+    });
+  });
+}
+
+/**
+ * Pull a model, streaming progress to stdout.
+ * @param {string} model
+ * @returns {Promise<void>}
+ */
+function pullModel(model) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn('ollama', ['pull', model], { stdio: 'inherit' });
+    proc.on('error', reject);
+    proc.on('close', (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`ollama pull exited with code ${code}`));
+    });
+  });
+}
+
+/**
+ * Warm the model — one dummy inference so first real call isn't cold.
+ * Best-effort; failure doesn't block.
+ * @param {string} model
+ */
+async function warmModel(model, endpoint = 'http://localhost:11434') {
+  try {
+    const url = `${endpoint.replace(/\/$/, '')}/api/chat`;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 60000);
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        model,
+        messages: [{ role: 'user', content: 'ok' }],
+        stream: false,
+        options: { num_predict: 3 },
+      }),
+      signal: controller.signal,
+    });
+    clearTimeout(timer);
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+/** Instructions to print when ollama is missing. */
+function installInstructions() {
+  const plat = os.platform();
+  const lines = ['Ollama is required for the difficulty classifier and SIMPLE-tier serving.'];
+  if (plat === 'darwin') {
+    lines.push('Install on macOS:');
+    lines.push('  brew install ollama');
+    lines.push('  # or download: https://ollama.com/download');
+  } else if (plat === 'linux') {
+    lines.push('Install on Linux:');
+    lines.push('  curl -fsSL https://ollama.com/install.sh | sh');
+  } else if (plat === 'win32') {
+    lines.push('Install on Windows:');
+    lines.push('  Download the installer from https://ollama.com/download/windows');
+  } else {
+    lines.push('Install from https://ollama.com/download');
+  }
+  lines.push('After installing, re-run `lynkr init` (or restart the server).');
+  return lines.join('\n');
+}
+
+/**
+ * Full bootstrap flow with prompts.
+ * @param {object} opts
+ * @param {'interactive'|'boot'} opts.mode — interactive blocks on failure, boot warns and continues
+ * @param {function} [opts.log] — logger function (defaults to console)
+ * @param {function} [opts.warn] — warn function
+ * @param {function} [opts.prompt] — async prompt(text)→string for interactive install/pull confirmations
+ * @returns {Promise<{ready: boolean, ollama: boolean, model: boolean, reason?: string}>}
+ */
+async function ensureClassifierReady(opts = {}) {
+  const mode = opts.mode || 'boot';
+  const log = opts.log || ((msg) => console.log(msg));
+  const warn = opts.warn || ((msg) => console.warn(msg));
+  const { provider, model, endpoint } = CLASSIFIER_MODEL_INFO;
+
+  if (provider !== 'ollama') {
+    // Non-ollama providers not supported today — bail cleanly.
+    warn(`Classifier provider "${provider}" is not yet auto-provisioned. Ensure ${model} is reachable manually.`);
+    return { ready: false, ollama: false, model: false, reason: 'non_ollama_provider' };
+  }
+
+  // 1. Ollama detection
+  const ollama = await detectOllama();
+  if (!ollama.installed) {
+    const msg = installInstructions();
+    if (mode === 'interactive') {
+      log('');
+      log('⚠ Ollama not found on PATH.');
+      log('');
+      log(msg);
+      log('');
+    } else {
+      warn(`[classifier-setup] Ollama not installed — classifier disabled. ${installInstructions().split('\n')[0]}`);
+    }
+    return { ready: false, ollama: false, model: false, reason: 'ollama_missing' };
+  }
+  if (mode === 'interactive') log(`✓ Ollama detected (${ollama.version || 'unknown version'}).`);
+
+  // 2. Model pull
+  const hasModel = await isModelPulled(model);
+  if (!hasModel) {
+    if (mode === 'interactive') {
+      log('');
+      log(`Classifier model "${model}" not present locally.`);
+      const yes = opts.prompt ? await opts.prompt(`Pull ${model} now? [Y/n] `) : 'y';
+      if (yes.trim().toLowerCase().startsWith('n')) {
+        warn(`Skipped pull — classifier will be disabled until you run: ollama pull ${model}`);
+        return { ready: false, ollama: true, model: false, reason: 'pull_declined' };
+      }
+      log(`Pulling ${model} (this can take a few minutes on first run)...`);
+      try {
+        await pullModel(model);
+        log(`✓ Model ${model} pulled.`);
+      } catch (err) {
+        warn(`✗ Pull failed: ${err.message}`);
+        return { ready: false, ollama: true, model: false, reason: 'pull_failed' };
+      }
+    } else {
+      // Boot mode — don't auto-pull. Log a clear instruction and continue.
+      warn(`[classifier-setup] Classifier model ${model} not pulled. Run: ollama pull ${model}. Classifier will fall back to anchor-only scoring until then.`);
+      return { ready: false, ollama: true, model: false, reason: 'model_missing' };
+    }
+  }
+
+  // 3. Warm-up
+  const warmed = await warmModel(model, endpoint);
+  if (mode === 'interactive') {
+    log(warmed ? `✓ Model warmed (first classification will be fast).` : `⚠ Warm-up call failed — the first classification may be slow.`);
+  }
+
+  return { ready: true, ollama: true, model: true, warmed };
+}
+
+module.exports = {
+  detectOllama,
+  isModelPulled,
+  pullModel,
+  warmModel,
+  installInstructions,
+  ensureClassifierReady,
+};

package/src/routing/client-profiles.js

@@ -0,0 +1,292 @@
+/**
+ * Client Profiles (WS3.1).
+ *
+ * Client harnesses like Claude Code, Cursor, and Codex attach a large
+ * baseline tool loadout to EVERY request (Claude Code sends ~11 tools
+ * unconditionally). The old agentic detector inflated `tool_count` and
+ * `agentic_tool` signals from those baselines, mis-classifying a trivial
+ * "hi" as an agentic COMPLEX-tier workload.
+ *
+ * The `slice(0, 3)` hack in `src/api/router.js` worked around that in one
+ * specific spot for one specific client — but it also discarded real MCP
+ * tools the user had configured, and did nothing for Cursor / Codex.
+ *
+ * This module fixes the root cause. Given a request's `user-agent` header
+ * and its tools list, `detectClient` returns the matching profile (or null),
+ * and `effectiveTools` subtracts the baseline so the agentic detector scores
+ * only tools the user actually added beyond the harness default.
+ *
+ * @module routing/client-profiles
+ */
+
+const fs = require('fs');
+const path = require('path');
+const logger = require('../logger');
+
+/**
+ * Seed profiles. Baseline tool lists must exactly match the tool NAMES the
+ * client sends (case-sensitive) — the agentic detector reads
+ * `t.name || t.function?.name`, so these are the tools that ship in the
+ * harness's default `tools` array.
+ *
+ * Claude Code's default loadout was verified against the live proxy request
+ * shape at time of writing (2026-07). If a future release adds/renames a
+ * tool, add it here (or override via data/client-profiles.json).
+ */
+const PROFILES = {
+  'claude-code': {
+    name: 'claude-code',
+    baselineTools: new Set([
+      'Task', 'Bash', 'Glob', 'Grep', 'Read', 'Edit', 'Write',
+      'NotebookEdit', 'WebFetch', 'WebSearch', 'TodoWrite',
+      'BashOutput', 'KillShell', 'SlashCommand',
+    ]),
+    detect: {
+      // Claude Code CLI actually sends `user-agent: claude-cli/x.y.z` (not
+      // claude-code/x.y.z as the tests assumed). Match every Anthropic-side
+      // subscription client — same set as auth-mode.js's
+      // SUBSCRIPTION_UA_PREFIXES, kept in sync manually since the two files
+      // want slightly different match rules.
+      headerPatterns: [
+        /claude[-_](cli|code|vscode)/i,
+        /anthropic-cli/i,
+      ],
+      minToolFingerprintMatch: 0.8,
+    },
+  },
+  'cursor': {
+    name: 'cursor',
+    baselineTools: new Set([
+      // Cursor's default agent loadout
+      'read_file', 'write_file', 'edit_file', 'delete_file',
+      'run_terminal_command', 'grep_search', 'file_search', 'codebase_search',
+      'web_search', 'list_dir',
+    ]),
+    detect: {
+      headerPatterns: [/cursor/i],
+      minToolFingerprintMatch: 0.8,
+    },
+  },
+  'lynkr-injected': {
+    name: 'lynkr-injected',
+    baselineTools: new Set([
+      // Lynkr's own IDE_SAFE_TOOLS loadout (src/clients/standard-tools.js),
+      // injected by the OpenAI-compat routers when a client sends no tools.
+      // These are Lynkr plumbing, not user intent: without this profile the
+      // agentic detector counts its own injected tools and floors every
+      // tool-less client (e.g. goose's summarizer side-requests) at
+      // ITERATIVE/COMPLEX. Matches claude-code's names plus the four
+      // (MultiEdit, LS, NotebookRead, WebAgent) that keep it from
+      // fingerprinting as claude-code.
+      'Write', 'Read', 'Edit', 'Bash', 'Glob', 'Grep', 'MultiEdit', 'LS',
+      'NotebookRead', 'TodoWrite', 'Task', 'WebSearch', 'WebFetch',
+      'WebAgent', 'NotebookEdit',
+    ]),
+    detect: {
+      headerPatterns: [],
+      minToolFingerprintMatch: 0.8,
+    },
+  },
+  'goose': {
+    name: 'goose',
+    baselineTools: new Set([
+      // Goose CLI 1.41 default loadout — captured live 2026-07-13 against
+      // the OpenAI-compatible endpoint. Goose sends NO user-agent header,
+      // so detection relies entirely on this tool fingerprint. The apps__*,
+      // extensionmanager__* and todo__* names come from goose's default
+      // extensions; the rest are core tools that attach to every request.
+      'analyze', 'delegate', 'edit', 'load', 'load_skill', 'read_image',
+      'shell', 'tree', 'write',
+      'apps__create_app', 'apps__delete_app', 'apps__iterate_app',
+      'apps__list_apps',
+      'extensionmanager__list_resources', 'extensionmanager__manage_extensions',
+      'extensionmanager__read_resource',
+      'extensionmanager__search_available_extensions',
+      'todo__todo_write',
+    ]),
+    detect: {
+      headerPatterns: [/goose/i],
+      // 0.5 rather than the usual 0.8: users can disable goose's default
+      // extensions (apps, extensionmanager, todo), which removes up to 9 of
+      // the 18 baseline names while the 9 core tools still identify goose.
+      // A false-positive match on another harness with this many identical
+      // tool names would subtract only those shared names — harmless.
+      minToolFingerprintMatch: 0.5,
+    },
+  },
+  'openai-codex': {
+    name: 'openai-codex',
+    baselineTools: new Set([
+      // Legacy Codex CLI (and Lynkr's injected fallback names)
+      'shell', 'apply_patch', 'read_file', 'write_file',
+      // Codex v0.142+ (Rust CLI) default loadout — captured live 2026-07-11.
+      // All of these attach to EVERY request, including "Hi": counting them
+      // as agentic intent floored every Codex turn at MEDIUM.
+      'exec_command', 'write_stdin', 'update_plan', 'request_user_input',
+      'view_image', 'get_goal', 'create_goal', 'update_goal',
+      'list_mcp_resources', 'list_mcp_resource_templates', 'read_mcp_resource',
+      'list_available_plugins_to_install', 'request_plugin_install',
+    ]),
+    detect: {
+      headerPatterns: [/codex/i, /openai-cli/i],
+      minToolFingerprintMatch: 0.8,
+    },
+  },
+};
+
+// Union of every baseline tool across all known profiles — used for the
+// "no-profile-but-looks-like-a-harness" heuristic guard.
+let _knownBaselineToolsCache = null;
+function _knownBaselineTools() {
+  if (_knownBaselineToolsCache) return _knownBaselineToolsCache;
+  const s = new Set();
+  for (const p of Object.values(PROFILES)) {
+    for (const t of p.baselineTools) s.add(t);
+  }
+  _knownBaselineToolsCache = s;
+  return s;
+}
+
+// User overrides / additions from data/client-profiles.json — loaded once
+// at first use. Shape: { profileName: { baselineTools: [...], detect: {...} } }
+let _userProfilesLoaded = false;
+function _loadUserProfiles() {
+  if (_userProfilesLoaded) return;
+  _userProfilesLoaded = true;
+  const overridePath = path.join(process.cwd(), 'data', 'client-profiles.json');
+  if (!fs.existsSync(overridePath)) return;
+  try {
+    const raw = JSON.parse(fs.readFileSync(overridePath, 'utf8'));
+    for (const [name, def] of Object.entries(raw || {})) {
+      if (!def || typeof def !== 'object') continue;
+      const baseline = Array.isArray(def.baselineTools)
+        ? new Set(def.baselineTools)
+        : PROFILES[name]?.baselineTools ?? new Set();
+      const patterns = Array.isArray(def.headerPatterns)
+        ? def.headerPatterns.map((p) => new RegExp(p, 'i'))
+        : PROFILES[name]?.detect?.headerPatterns ?? [];
+      PROFILES[name] = {
+        name,
+        baselineTools: baseline,
+        detect: {
+          headerPatterns: patterns,
+          minToolFingerprintMatch: Number.isFinite(def.minToolFingerprintMatch)
+            ? def.minToolFingerprintMatch
+            : 0.8,
+        },
+      };
+    }
+    _knownBaselineToolsCache = null; // recompute after overrides
+    logger.debug({ count: Object.keys(raw).length }, '[ClientProfiles] Loaded user overrides');
+  } catch (err) {
+    logger.debug({ err: err.message }, '[ClientProfiles] Failed to load user overrides');
+  }
+}
+
+function _toolName(t) {
+  return (t && (t.name || t.function?.name)) || null;
+}
+
+/**
+ * Detect the client harness that issued this request.
+ *
+ * Match order:
+ *   1. user-agent header regex — strongest signal, cheap.
+ *   2. Tool-set fingerprint — ≥ minToolFingerprintMatch (default 80%) of the
+ *      profile's baseline tool names must be present in payload.tools.
+ *
+ * @param {Object} args
+ * @param {Object} [args.headers]
+ * @param {Object} [args.payload]
+ * @returns {Object|null} The matched profile or null.
+ */
+function detectClient({ headers = {}, payload = {} } = {}) {
+  _loadUserProfiles();
+
+  const ua = String(headers['user-agent'] || headers['User-Agent'] || '');
+  if (ua) {
+    for (const profile of Object.values(PROFILES)) {
+      for (const pattern of profile.detect.headerPatterns) {
+        if (pattern.test(ua)) return profile;
+      }
+    }
+  }
+
+  const tools = Array.isArray(payload.tools) ? payload.tools : [];
+  if (tools.length === 0) return null;
+
+  const presentNames = new Set(tools.map(_toolName).filter(Boolean));
+  let best = null;
+  let bestRatio = 0;
+  for (const profile of Object.values(PROFILES)) {
+    const baseline = profile.baselineTools;
+    if (baseline.size === 0) continue;
+    let hits = 0;
+    for (const name of baseline) {
+      if (presentNames.has(name)) hits++;
+    }
+    const ratio = hits / baseline.size;
+    if (ratio >= profile.detect.minToolFingerprintMatch && ratio > bestRatio) {
+      best = profile;
+      bestRatio = ratio;
+    }
+  }
+  return best;
+}
+
+/**
+ * Return the tools in `payload.tools` that are NOT part of `profile`'s
+ * baseline loadout — i.e., the tools the user actually configured beyond
+ * the harness default. If profile is null, returns the raw list.
+ *
+ * The array preserves the original tool objects (not just names) so the
+ * agentic detector can still inspect `t.name || t.function?.name`.
+ *
+ * @param {Object} payload
+ * @param {Object|null} profile
+ * @returns {Array}
+ */
+function effectiveTools(payload, profile) {
+  const tools = Array.isArray(payload?.tools) ? payload.tools : [];
+  if (!profile) return tools.slice();
+  const baseline = profile.baselineTools;
+  return tools.filter((t) => {
+    const name = _toolName(t);
+    return name && !baseline.has(name);
+  });
+}
+
+/**
+ * True when every tool name in the payload is present in some known profile's
+ * baseline. Used by the agentic detector's "unknown harness" guard so a
+ * Claude-Code-alike client that omits its user-agent doesn't inflate the
+ * agentic score.
+ *
+ * @param {Object} payload
+ * @returns {boolean}
+ */
+function allToolsAreBaseline(payload) {
+  _loadUserProfiles();
+  const tools = Array.isArray(payload?.tools) ? payload.tools : [];
+  if (tools.length === 0) return false;
+  const known = _knownBaselineTools();
+  for (const t of tools) {
+    const name = _toolName(t);
+    if (!name || !known.has(name)) return false;
+  }
+  return true;
+}
+
+/** Test helper — clear cached override state (unit tests reload from disk). */
+function _resetForTests() {
+  _userProfilesLoaded = false;
+  _knownBaselineToolsCache = null;
+}
+
+module.exports = {
+  PROFILES,
+  detectClient,
+  effectiveTools,
+  allToolsAreBaseline,
+  _resetForTests,
+};

package/src/routing/complexity-analyzer.js

@@ -15,6 +15,26 @@
 const logger = require('../logger');
 const config = require('../config');
 const codeGraph = require('../tools/code-graph');
+const clientProfiles = require('./client-profiles');
+
+/**
+ * Return the tools the user actually added beyond the client harness's
+ * baseline loadout. Same intent as the agentic detector's guard: Claude
+ * Code / Cursor / Codex all attach a fat baseline tools list to every
+ * request, and counting those inflates the complexity score for trivial
+ * turns. If no profile is attached, fall back to the raw list, but zero
+ * it out when every tool is a known-harness-baseline name AND there are
+ * enough of them to look like a harness attaching its default set
+ * (mirrors the "unknown_harness_guard" in agentic-detector.js).
+ */
+function _effectiveTools(payload) {
+  const raw = Array.isArray(payload?.tools) ? payload.tools : [];
+  if (raw.length === 0) return raw;
+  const profile = payload?._clientProfile || null;
+  if (profile) return clientProfiles.effectiveTools(payload, profile);
+  if (raw.length >= 10 && clientProfiles.allToolsAreBaseline(payload)) return [];
+  return raw;
+}
 
 // ============================================================================
 // PHASE 1: Basic Scoring Patterns
@@ -72,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,
@@ -422,10 +456,14 @@ function scoreTokens(payload) {
 }
 
 /**
- * Score based on tool count (0-20 points)
+ * Score based on tool count (0-20 points). Uses the effective tool list —
+ * i.e. tools the user actually added beyond the client harness's baseline
+ * loadout — so a trivial "hi" with 11 Claude Code tools attached doesn't
+ * pick up 16 points of "heavy tools" complexity for something the user
+ * didn't ask for.
  */
 function scoreTools(payload) {
-  const toolCount = Array.isArray(payload?.tools) ? payload.tools.length : 0;
+  const toolCount = _effectiveTools(payload).length;
 
   if (toolCount === 0) return 0;    // No tools
   if (toolCount <= 3) return 4;     // Few tools - local can handle
@@ -441,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' };
@@ -450,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) };
     }
   }
 
@@ -627,21 +671,22 @@ function calculateWeightedScore(payload, content) {
   }
   dimensions.domainSpecificity = Math.min(domainScore, 100);
 
-  // 5. Tool count
-  const toolCount = payload?.tools?.length ?? 0;
+  // 5. Tool count — effective tools only (harness baseline subtracted)
+  const effTools = _effectiveTools(payload);
+  const toolCount = effTools.length;
   dimensions.toolCount = toolCount === 0 ? 0 :
     toolCount <= 3 ? 20 :
     toolCount <= 6 ? 40 :
     toolCount <= 10 ? 60 :
     toolCount <= 15 ? 80 : 100;
 
-  // 6. Tool complexity (weighted by tool types)
-  if (payload?.tools?.length > 0) {
-    const totalWeight = payload.tools.reduce((sum, t) => {
+  // 6. Tool complexity (weighted by tool types) — same effective list
+  if (effTools.length > 0) {
+    const totalWeight = effTools.reduce((sum, t) => {
       const name = t.name || t.function?.name || '';
       return sum + (TOOL_COMPLEXITY_WEIGHTS[name] || TOOL_COMPLEXITY_WEIGHTS.default);
     }, 0);
-    const avgWeight = totalWeight / payload.tools.length;
+    const avgWeight = totalWeight / effTools.length;
     dimensions.toolComplexity = avgWeight * 100;
   } else {
     dimensions.toolComplexity = 0;
@@ -831,7 +876,7 @@ async function analyzeComplexity(payload, options = {}) {
     recommendation,
     breakdown: {
       tokens: { score: tokenScore, estimated: estimateTokens(payload) },
-      tools: { score: toolScore, count: payload?.tools?.length ?? 0 },
+      tools: { score: toolScore, count: _effectiveTools(payload).length },
       taskType: taskTypeResult,
       codeComplexity: codeComplexityResult,
       reasoning: reasoningResult,
@@ -878,7 +923,15 @@ async function analyzeComplexity(payload, options = {}) {
  */
 function shouldForceLocal(payload) {
   const content = extractContent(payload);
-  return FORCE_LOCAL_PATTERNS.some(pattern => pattern.test(content));
+  const matched = FORCE_LOCAL_PATTERNS.find(pattern => pattern.test(content));
+  if (matched) {
+    // Deliberately loud: a force_local misfire routed a subagent's opening
+    // frames to the weakest tier (live 2026-07-09, pattern unidentified at
+    // the time because the wrap gateway had no file logging). This line is
+    // how the next misfire names itself.
+    logger.debug({ pattern: matched.source.slice(0, 50), text: content.slice(0, 100) }, '[Force] force_local matched');
+  }
+  return !!matched;
 }
 
 /**
@@ -886,7 +939,25 @@ function shouldForceLocal(payload) {
  */
 function shouldForceCloud(payload) {
   const content = extractContent(payload);
-  return FORCE_CLOUD_PATTERNS.some(pattern => pattern.test(content));
+  const matched = FORCE_CLOUD_PATTERNS.find(pattern => pattern.test(content));
+  if (matched) {
+    logger.debug({ pattern: matched.source.slice(0, 50), text: content.slice(0, 100) }, '[Force] force_cloud matched');
+  }
+  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;
 }
 
 // ============================================================================
@@ -1004,6 +1075,7 @@ module.exports = {
   // Quick checks
   shouldForceLocal,
   shouldForceCloud,
+  shouldForceReasoning,
 
   // Individual scoring (for testing/debugging)
   scoreTokens,
@@ -1032,6 +1104,7 @@ module.exports = {
   // Constants (for testing)
   PATTERNS,
   ADVANCED_PATTERNS,
+  FORCE_REASONING_PATTERNS,
   FORCE_CLOUD_PATTERNS,
   FORCE_LOCAL_PATTERNS,
   DIMENSION_WEIGHTS,