lynkr 9.14.1 → 9.14.3

package/src/routing/capability-seeds/models-dev.js

@@ -0,0 +1,64 @@
+/**
+ * models.dev adapter: boolean capability flags per model (tool_call,
+ * vision/image input, reasoning, context window). Same public endpoint the
+ * pricing registry already consumes (https://models.dev/api.json), same
+ * shape ({ providerId: { models: { modelId: {...} } } }).
+ *
+ * Flags don't set caps — they GATE them: a model with tool_call=false gets
+ * tool_use capped (it can still drive tools via XML extraction, which is why
+ * this is a cap, not a zero). Everything else passes through as provenance
+ * for operator review.
+ *
+ * Fail-soft: { status:'skipped', reason } on any problem.
+ */
+
+const { fetchJson, getCached, setCached, skipped } = require('./sources');
+const { normalizeFamily } = require('./family');
+
+const MODELS_DEV_URL = 'https://models.dev/api.json';
+
+// Conservative ceiling for models without function-calling. XML-extracted
+// tool calls (see xml-tool-extractor.js) keep them usable, hence 0.4 not 0.
+const NO_TOOLCALL_TOOL_USE_CAP = 0.4;
+
+/**
+ * @param {object} [opts] — { refresh:boolean }
+ * @returns {Promise<{ status, flags?:Object<family,{toolCall,vision,reasoning,context}>, reason? }>}
+ */
+async function fetchModelsDevFlags({ refresh = true } = {}) {
+  const parse = (data) => {
+    const out = {};
+    for (const [providerId, providerData] of Object.entries(data || {})) {
+      if (!providerData?.models) continue;
+      for (const [modelId, info] of Object.entries(providerData.models)) {
+        if (!info || typeof info !== 'object') continue;
+        const { family } = normalizeFamily(providerId, modelId);
+        if (family === 'unknown' || out[family]) continue; // first provider wins
+        out[family] = {
+          toolCall: info.tool_call ?? null,
+          vision: Array.isArray(info.input) ? info.input.includes('image') : null,
+          reasoning: info.reasoning ?? null,
+          context: Number(info.context) || null,
+        };
+      }
+    }
+    return out;
+  };
+
+  if (!refresh) {
+    const cached = getCached('modelsdev');
+    if (cached) return { status: 'ok', flags: cached, cached: true };
+    return skipped('no cache (run with --refresh)');
+  }
+  try {
+    const flags = parse(await fetchJson(MODELS_DEV_URL));
+    setCached('modelsdev', flags);
+    return { status: 'ok', flags };
+  } catch (err) {
+    const cached = getCached('modelsdev');
+    if (cached) return { status: 'ok', flags: cached, cached: true, stale: err.message };
+    return skipped(`fetch failed and no cache: ${err.message}`);
+  }
+}
+
+module.exports = { fetchModelsDevFlags, MODELS_DEV_URL, NO_TOOLCALL_TOOL_USE_CAP };

package/src/routing/capability-seeds/normalize.js

@@ -0,0 +1,160 @@
+/**
+ * Score → capability-cap normalization + leaderboard-name → family mapping.
+ *
+ * Anchors (fixed permanently — τ absorbs residual error, consistency matters
+ * more than precision): benchmark fraction 0.8 (≈ flagship SWE-Verified
+ * territory) → caps 0.9; fraction 0 → 0.15 (never zero: even weak models do
+ * trivial turns). Linear between, clamped to [0.15, 0.9].
+ *
+ * Per-head source weights (v1 heuristic, documented):
+ *   debugging = 0.6·swe + 0.4·terminal
+ *   codegen   = 0.5·livecode + 0.3·swe + 0.2·arena
+ *   reasoning = 0.5·swe + 0.3·arena + 0.2·livecode
+ *   tool_use  = 0.6·terminal + 0.4·swe
+ * Missing sources renormalize over the present ones. A pessimistic haircut
+ * (-0.03) applies to all normalized caps: underestimating a new model costs
+ * money (extra escalations), overestimating costs quality.
+ *
+ * Family mapping: order-insensitive token overlap between the normalized
+ * family id and the leaderboard name. Every family token must hit an entry
+ * token exactly or as a version prefix ("4" matches "4.5", "k2" matches
+ * "k2.5" — but "32b" never matches "480b"). Best overlap wins; weak matches
+ * land in `unmapped` for operator review instead of being seeded silently.
+ * Pure functions, never throw.
+ */
+
+const { normalizeFamily } = require('./family');
+
+const CAP_FLOOR = 0.15;
+const CAP_CEIL = 0.9;
+const NORMALIZE_HAIRCUT = 0.03;
+
+// score fraction (0-1) at which caps hit the ceiling — flagship territory.
+const ANCHOR_SCORE = 0.8;
+
+const HEAD_WEIGHTS = {
+  debugging: { swe: 0.6, terminal: 0.4, livecode: 0, arena: 0 },
+  codegen: { swe: 0.3, terminal: 0, livecode: 0.5, arena: 0.2 },
+  reasoning: { swe: 0.5, terminal: 0, livecode: 0.2, arena: 0.3 },
+  tool_use: { swe: 0.4, terminal: 0.6, livecode: 0, arena: 0 },
+};
+
+const STOPWORDS = new Set([
+  'the', 'model', 'preview', 'high', 'medium', 'low',
+  'agent', 'instruct', 'thinking',
+  '2024', '2025', '2026',
+]);
+
+function entryTokens(name) {
+  return String(name || '')
+    .toLowerCase()
+    .split(/[^a-z0-9.]+/)
+    .map((t) => t.replace(/^\.+|\.+$/g, ''))
+    .filter((t) => t && !STOPWORDS.has(t));
+}
+
+function _tokenHit(familyTok, entryToks) {
+  for (const tok of entryToks) {
+    if (tok === familyTok) return true;
+    // version prefix: family "4" hits entry "4.5"; family "k2" hits "k2.5".
+    // The char after the prefix must be a dot (never a letter/digit, so
+    // "32b" can't match "480b" and "gpt-5" can't match "gpt-50").
+    if (tok.length > familyTok.length && tok.startsWith(familyTok) && tok[familyTok.length] === '.') {
+      return true;
+    }
+    // reverse: entry "4" satisfies family "4.5"? No — a bare major never
+    // proves the minor. Skip.
+  }
+  return false;
+}
+
+function familyTokens(family) {
+  return String(family || '')
+    .toLowerCase()
+    .split(/[^a-z0-9.]+/)
+    .map((t) => t.replace(/^\.+|\.+$/g, ''))
+    .filter((t) => t && !STOPWORDS.has(t));
+}
+
+/**
+ * @param {string} entryName — cleaned leaderboard name
+ * @param {string[]} knownFamilies — candidate family ids (seed keys w/o wildcards)
+ * @returns {{ family:string|null, hits:number, of:number }}
+ */
+function mapEntryToFamily(entryName, knownFamilies) {
+  try {
+    const toks = entryTokens(entryName);
+    if (toks.length === 0 || !Array.isArray(knownFamilies)) {
+      return { family: null, hits: 0, of: 0 };
+    }
+    let best = { family: null, hits: 0, of: 0, ratio: 0 };
+    for (const fam of knownFamilies) {
+      const ftoks = familyTokens(fam);
+      if (ftoks.length === 0) continue;
+      let hits = 0;
+      for (const ft of ftoks) {
+        if (_tokenHit(ft, toks)) hits++;
+      }
+      const ratio = hits / ftoks.length;
+      // Full coverage required; ties prefer the more specific family.
+      if (ratio === 1 && (best.family === null || ftoks.length > best.of)) {
+        best = { family: fam, hits, of: ftoks.length, ratio };
+      }
+    }
+    return best.family ? best : { family: null, hits: 0, of: 0 };
+  } catch {
+    return { family: null, hits: 0, of: 0 };
+  }
+}
+
+function scoreToCap(score) {
+  const s = Math.max(0, Math.min(1, Number(score)));
+  if (!Number.isFinite(s)) return null;
+  const cap = CAP_FLOOR + (s / ANCHOR_SCORE) * (CAP_CEIL - CAP_FLOOR);
+  return Math.max(CAP_FLOOR, Math.min(CAP_CEIL, cap));
+}
+
+/**
+ * @param {object} scores — { swe?, terminal?, livecode?, arena? } fractions 0-1
+ * @returns {null | { reasoning, codegen, debugging, tool_use }}
+ */
+function scoresToCaps(scores) {
+  try {
+    if (!scores || typeof scores !== 'object') return null;
+    const present = {};
+    for (const k of ['swe', 'terminal', 'livecode', 'arena']) {
+      const v = Number(scores[k]);
+      if (Number.isFinite(v)) present[k] = Math.max(0, Math.min(1, v));
+    }
+    if (Object.keys(present).length === 0) return null;
+    const caps = {};
+    for (const [head, weights] of Object.entries(HEAD_WEIGHTS)) {
+      let total = 0;
+      let wsum = 0;
+      for (const [src, w] of Object.entries(weights)) {
+        if (present[src] !== undefined && w > 0) {
+          total += scoreToCap(present[src]) * w;
+          wsum += w;
+        }
+      }
+      if (wsum === 0) return null;
+      caps[head] = Math.round((total / wsum - NORMALIZE_HAIRCUT) * 1000) / 1000;
+      caps[head] = Math.max(CAP_FLOOR, Math.min(CAP_CEIL, caps[head]));
+    }
+    return caps;
+  } catch {
+    return null;
+  }
+}
+
+module.exports = {
+  mapEntryToFamily,
+  scoresToCaps,
+  scoreToCap,
+  entryTokens,
+  familyTokens,
+  normalizeFamily,
+  CAP_FLOOR,
+  CAP_CEIL,
+  NORMALIZE_HAIRCUT,
+};

package/src/routing/capability-seeds/registry.js

@@ -0,0 +1,125 @@
+/**
+ * Seed registry: per-FAMILY capability profiles from online-derived data.
+ *
+ * Layers (first hit wins in shortfall.js resolveCapabilities):
+ *   operator modelOverrides (provider:model, manual — supreme, lives in
+ *     model-capabilities.json) → snapshot (data/, fetched, `source:'seed:snapshot'`)
+ *     → shipped (config/, reviewed, `source:'seed:shipped'`) → family
+ *     heuristic (`source:'family'`) → tier slot (`source:'tier'`).
+ *
+ * Keys are normalized family ids (see family.js), lowercased, with optional
+ * trailing `*` wildcards matched longest-first (gpt-5* , qwen3-*). Provider
+ * never appears in keys — zai/baidu/ollama servings of glm-5.2 share one entry.
+ *
+ * File lifecycles mirror model-tiers.json: read once at boot, restart to
+ * pick up edits. data/ is gitignored (operator-local), config/ is versioned.
+ * Pure lookups after load; load never throws (missing/malformed → empty).
+ */
+
+const fs = require('fs');
+const path = require('path');
+const logger = require('../../logger');
+const { HEADS } = require('../capabilities');
+
+const SHIPPED_PATH = path.join(__dirname, '../../../config/model-capability-seeds.json');
+const SNAPSHOT_PATH = path.join(__dirname, '../../../data/capability-seeds.snapshot.json');
+
+let _cache = null;
+
+function sanitizeCaps(raw) {
+  const caps = {};
+  for (const h of HEADS) {
+    const v = Number(raw?.[h]);
+    caps[h] = Number.isFinite(v) ? Math.max(0, Math.min(1, v)) : 0.5;
+  }
+  return caps;
+}
+
+function _loadSeedsFile(filePath, label) {
+  try {
+    if (!fs.existsSync(filePath)) return {};
+    const raw = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    const seeds = raw?.seeds && typeof raw.seeds === 'object' ? raw.seeds : {};
+    const out = {};
+    for (const [key, entry] of Object.entries(seeds)) {
+      const caps = entry?.caps && typeof entry.caps === 'object' ? entry.caps : entry;
+      if (!caps || typeof caps !== 'object') continue;
+      out[String(key).toLowerCase()] = {
+        caps: sanitizeCaps(caps),
+        sources: Array.isArray(entry?.sources) ? entry.sources : [],
+        note: typeof entry?.note === 'string' ? entry.note : '',
+      };
+    }
+    return out;
+  } catch (err) {
+    logger.debug({ err: err.message, label }, '[SeedRegistry] seed file load failed — skipping layer');
+    return {};
+  }
+}
+
+function loadSeedLayers() {
+  if (_cache) return _cache;
+  _cache = {
+    snapshot: _loadSeedsFile(SNAPSHOT_PATH, 'snapshot'),
+    shipped: _loadSeedsFile(SHIPPED_PATH, 'shipped'),
+  };
+  return _cache;
+}
+
+function _resetSeedsCache() {
+  _cache = null;
+}
+
+// Test hook: inject layers directly (Operations on the same cached object
+// the resolver reads).
+function _setSeedsForTests({ snapshot, shipped } = {}) {
+  const base = loadSeedLayers();
+  _cache = {
+    snapshot: snapshot ?? base.snapshot,
+    shipped: shipped ?? base.shipped,
+  };
+  return _cache;
+}
+
+function _matchWildcard(layer, family) {
+  let best = null;
+  for (const [key, entry] of Object.entries(layer)) {
+    if (!key.endsWith('*')) continue;
+    const prefix = key.slice(0, -1);
+    if (prefix && family.startsWith(prefix) && (!best || prefix.length > best.prefix.length)) {
+      best = { prefix, entry };
+    }
+  }
+  return best?.entry ?? null;
+}
+
+/**
+ * @param {string} family — normalized family id
+ * @returns {null | { caps, source:'seed:snapshot'|'seed:shipped', sources, note }}
+ */
+function resolveSeedCaps(family) {
+  try {
+    const f = String(family || '').toLowerCase().trim();
+    if (!f || f === 'unknown') return null;
+    const { snapshot, shipped } = loadSeedLayers();
+    if (snapshot[f]) return { ...snapshot[f], source: 'seed:snapshot' };
+    if (shipped[f]) return { ...shipped[f], source: 'seed:shipped' };
+    const snapWild = _matchWildcard(snapshot, f);
+    if (snapWild) return { ...snapWild, source: 'seed:snapshot' };
+    const shipWild = _matchWildcard(shipped, f);
+    if (shipWild) return { ...shipWild, source: 'seed:shipped' };
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+module.exports = {
+  loadSeedLayers,
+  _resetSeedsCache,
+  _setSeedsForTests,
+  resolveSeedCaps,
+  sanitizeCaps,
+  SHIPPED_PATH,
+  SNAPSHOT_PATH,
+};

package/src/routing/capability-seeds/sources.js

@@ -0,0 +1,69 @@
+/**
+ * Shared plumbing for capability-seed sources (online benchmark data).
+ *
+ * Every adapter is optional and fail-soft: no network, bad payload, or
+ * unknown shape → { status:'skipped', reason } — never throws, never blocks
+ * the script, and never touches request-path routing (this only runs in
+ * scripts/seed-capabilities.js). Fetched payloads are cached under
+ * data/capability-sources-cache.json with a 7-day TTL so refreshes are
+ * cheap and CI stays hermetic (tests use fixtures, never the network).
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const CACHE_PATH = path.join(__dirname, '../../../data/capability-sources-cache.json');
+const CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+const FETCH_TIMEOUT_MS = 20000;
+
+function _readCache() {
+  try {
+    if (!fs.existsSync(CACHE_PATH)) return {};
+    return JSON.parse(fs.readFileSync(CACHE_PATH, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function _writeCache(cache) {
+  try {
+    fs.mkdirSync(path.dirname(CACHE_PATH), { recursive: true });
+    fs.writeFileSync(CACHE_PATH, JSON.stringify(cache, null, 2));
+  } catch {
+    // cache is best-effort; a failed write must not fail seeding
+  }
+}
+
+function getCached(source) {
+  const cache = _readCache();
+  const entry = cache[source];
+  if (!entry || typeof entry !== 'object') return null;
+  if (Date.now() - (entry.fetchedAt || 0) > CACHE_TTL_MS) return null;
+  return entry.payload ?? null;
+}
+
+function setCached(source, payload) {
+  const cache = _readCache();
+  cache[source] = { fetchedAt: Date.now(), payload };
+  _writeCache(cache);
+}
+
+async function fetchJson(url, { timeoutMs = FETCH_TIMEOUT_MS } = {}) {
+  const response = await fetch(url, {
+    signal: AbortSignal.timeout(timeoutMs),
+    headers: { Accept: 'application/json' },
+  });
+  if (!response.ok) throw new Error(`HTTP ${response.status}`);
+  return response.json();
+}
+
+const skipped = (reason) => ({ status: 'skipped', reason });
+
+module.exports = {
+  CACHE_PATH,
+  CACHE_TTL_MS,
+  getCached,
+  setCached,
+  fetchJson,
+  skipped,
+};

package/src/routing/capability-seeds/swebench.js

@@ -0,0 +1,66 @@
+/**
+ * SWE-Bench Verified adapter: per-model % resolved from the public
+ * leaderboard raw data.
+ *
+ * Source: https://raw.githubusercontent.com/SWE-bench/swe-bench.github.io/master/data/leaderboards.json
+ * Shape: { leaderboards: [{ name: "Verified"|"Lite"|..., results: [{ name, resolved, date, ... }] }] }
+ * Entry names look like "Claude 4.5 Opus (high) · mini-SWE-agent · 2026-02-17"
+ * (model + effort qualifier + scaffold + date). We keep the best resolved%
+ * per cleaned model name; family mapping happens in normalize.js
+ * (token-overlap against known families, unmapped surfaced for review).
+ *
+ * Fail-soft: any fetch/parse problem → { status:'skipped', reason }.
+ */
+
+const { fetchJson, getCached, setCached, skipped } = require('./sources');
+
+const LEADERBOARDS_URL = 'https://raw.githubusercontent.com/SWE-bench/swe-bench.github.io/master/data/leaderboards.json';
+const BOARD = 'Verified';
+
+function cleanName(name) {
+  return String(name || '')
+    .split('·')[0] // drop scaffold + date segments
+    .replace(/\((high|medium|low)\)/gi, '') // effort qualifier (we keep max across them)
+    .trim()
+    .replace(/\s+/g, ' ')
+    .toLowerCase();
+}
+
+/**
+ * @param {object} [opts] — { refresh:boolean } (false = cache-only)
+ * @returns {Promise<{ status, board?, entries?:Array<{name,resolved,date}>, reason? }>}
+ */
+async function fetchSweBench({ refresh = true } = {}) {
+  if (!refresh) {
+    const cached = getCached('swebench');
+    if (cached) return { status: 'ok', board: BOARD, entries: cached, cached: true };
+    return skipped('no cache (run with --refresh)');
+  }
+  try {
+    const data = await fetchJson(LEADERBOARDS_URL);
+    const boards = Array.isArray(data?.leaderboards) ? data.leaderboards : [];
+    const verified = boards.find((b) => String(b?.name || '').toLowerCase() === BOARD.toLowerCase());
+    if (!verified || !Array.isArray(verified.results)) {
+      return skipped(`board "${BOARD}" not found in payload`);
+    }
+    const best = new Map();
+    for (const r of verified.results) {
+      const name = cleanName(r?.name);
+      const resolved = Number(r?.resolved);
+      if (!name || !Number.isFinite(resolved)) continue;
+      const prev = best.get(name);
+      if (!prev || resolved > prev.resolved) {
+        best.set(name, { name, resolved, date: r?.date ?? null });
+      }
+    }
+    const entries = [...best.values()];
+    setCached('swebench', entries);
+    return { status: 'ok', board: BOARD, entries };
+  } catch (err) {
+    const cached = getCached('swebench');
+    if (cached) return { status: 'ok', board: BOARD, entries: cached, cached: true, stale: err.message };
+    return skipped(`fetch failed and no cache: ${err.message}`);
+  }
+}
+
+module.exports = { fetchSweBench, cleanName, LEADERBOARDS_URL, BOARD };

package/src/routing/client-profiles.js

@@ -114,6 +114,32 @@ const PROFILES = {
       minToolFingerprintMatch: 0.5,
     },
   },
+  'opencode': {
+    name: 'opencode',
+    baselineTools: new Set([
+      // OpenCode 1.18.x default loadout — captured live 2026-08-22 from
+      // Lynkr logs (user-agent `opencode/1.18.21 ai-sdk/provider-utils/…`).
+      // All of these attach to every request; counting them as intent
+      // scored every OpenCode turn ~80 → REASONING band → session pin
+      // locked the whole session there (2026-08-22: 1163/1203 REASONING
+      // routings were pin-inherited from a floored first turn).
+      'bash', 'edit', 'glob', 'grep', 'question', 'read', 'skill', 'task',
+      'todowrite', 'webfetch', 'write',
+      // Per opencode.ai/docs/tools — enabled-by-default or common-config
+      // names not seen in our capture; harmless if absent (subtraction
+      // only removes names actually present).
+      'list', 'todoread', 'websearch',
+    ]),
+    detect: {
+      headerPatterns: [/opencode/i],
+      // 0.5 (like goose): `question`/`skill`/`todo*` vary with user config,
+      // so a minimal loadout matches ~8 of 14 baseline names. The lowercase
+      // set is disjoint from claude-code's capitalized and cursor's
+      // snake_case names, and opencode always sends its user-agent, so the
+      // header pattern is the primary detector anyway.
+      minToolFingerprintMatch: 0.5,
+    },
+  },
   'openai-codex': {
     name: 'openai-codex',
     baselineTools: new Set([

package/src/routing/complexity-analyzer.js

@@ -44,7 +44,7 @@ function _effectiveTools(payload) {
 // Pre-compiled regex patterns for performance
 const PATTERNS = {
   // Greetings - always local
-  greeting: /^(hi|hello|hey|good\s*(morning|afternoon|evening)|howdy|greetings|sup|yo|thanks?|thank\s*you)[\s\.\!\?,]*$/i,
+  greeting: /^(hi|hello|hey|good\s*(morning|afternoon|evening)|howdy|greetings|sup|yo|thanks?|thank\s*you)[\s.!?,]*$/i,
 
   // Simple questions - likely local
   simpleQuestion: /^(what\s+is|what's|define|who\s+is|when\s+was|where\s+is)\s+\w/i,
@@ -56,7 +56,7 @@ const PATTERNS = {
   technical: /\b(code|function|class|method|variable|api|database|server|client|module|import|export|async|await|promise|component|interface|type|struct|enum)\b/i,
 
   // File/path references
-  fileReference: /\b(\w+\.(js|ts|py|rb|go|rs|java|cpp|c|h|jsx|tsx|vue|svelte|md|json|yaml|yml|toml|sql|sh|bash))\b|[\.\/]\w+\//i,
+  fileReference: /\b(\w+\.(js|ts|py|rb|go|rs|java|cpp|c|h|jsx|tsx|vue|svelte|md|json|yaml|yml|toml|sql|sh|bash))\b|[./]\w+\//i,
 };
 
 // ============================================================================
@@ -119,10 +119,10 @@ const FORCE_CLOUD_PATTERNS = [
 
 // Force local patterns - always route to local regardless of score
 const FORCE_LOCAL_PATTERNS = [
-  /^(hi|hello|hey|thanks?|thank\s*you|bye|goodbye)[\s\.\!\?]*$/i,
+  /^(hi|hello|hey|thanks?|thank\s*you|bye|goodbye)[\s.!?]*$/i,
   /^what\s+(time|day|date)\s+is\s+it/i,
-  /^(yes|no|ok|okay|sure|got\s+it|understood)[\s\.\!\?]*$/i,
-  /^(help|menu|commands?|options?)[\s\.\!\?]*$/i,
+  /^(yes|no|ok|okay|sure|got\s+it|understood)[\s.!?]*$/i,
+  /^(help|menu|commands?|options?)[\s.!?]*$/i,
 ];
 
 // Weighted Scoring (15 Dimensions)
@@ -478,8 +478,6 @@ function scoreTools(payload) {
  * Score based on task type (0-25 points)
  */
 function scoreTaskType(content) {
-  const contentLower = content.toLowerCase();
-
   // Check force patterns first (priority: REASONING > cloud > local)
   for (const pattern of FORCE_REASONING_PATTERNS) {
     if (pattern.test(content)) {
@@ -796,7 +794,6 @@ async function analyzeComplexity(payload, options = {}) {
   if (useWeighted) {
     const weighted = calculateWeightedScore(workingPayload, content);
     const threshold = getThreshold();
-    const mode = config.smartToolSelection?.mode ?? 'heuristic';
 
     // Check force patterns
     const taskTypeResult = scoreTaskType(content);

package/src/routing/confidence-scorer.js

@@ -82,8 +82,8 @@ function scoreCode(response) {
   const fenced = (text.match(/```[\s\S]*?```/g) || []).join('\n');
   if (!fenced) return 0.6; // Code-gen request without code is suspicious
   // Very basic balance check
-  const opens = (fenced.match(/[\{\[\(]/g) || []).length;
-  const closes = (fenced.match(/[\}\]\)]/g) || []).length;
+  const opens = (fenced.match(/[{[(]/g) || []).length;
+  const closes = (fenced.match(/[}\])]/g) || []).length;
   if (Math.abs(opens - closes) > 2) return 0.5;
   return 0.9;
 }

package/src/routing/cost-optimizer.js

@@ -5,9 +5,8 @@
  */
 
 const logger = require('../logger');
-const config = require('../config');
 const { getModelRegistry, getModelRegistrySync } = require('./model-registry');
-const { getModelTierSelector, TIER_DEFINITIONS } = require('./model-tiers');
+const { getModelTierSelector } = require('./model-tiers');
 const { ratioFor } = require('./output-ratios');
 
 // Session cost tracking (in-memory)