lynkr 9.14.16 → 9.14.18

package/src/routing/outcomes.js

@@ -0,0 +1,136 @@
+/**
+ * Turn-outcome attribution.
+ *
+ * When request N+1 of a session arrives, it carries evidence about what
+ * happened after request N: the assistant reply the client kept, the tool
+ * results or terminal output it produced, whether the client retried the
+ * identical conversation (parse/schema failure), whether the same command
+ * batch was issued again. Combined with what the gateway recorded about
+ * request N (provider error, failover, tier fallback), that is enough to
+ * classify N's outcome without any model-as-judge.
+ *
+ * Categories (and whether the MODEL is attributable):
+ *   progress        yes   new tool output, no error markers, no repeat
+ *   no_progress     yes   same command signature twice with the same output
+ *   regression      yes   client retried the identical conversation (parse /
+ *                         schema failure) or repeated a failing command batch
+ *   provider_error  no    upstream 5xx / timeout / failover / tier fallback
+ *   tool_error      no    tool_result is_error or terminal error markers that
+ *                         are clearly environmental (command not found, OOM)
+ *   missing         no    no following turn (filled by a sweeper)
+ *
+ * Only attributable outcomes may train the policy (reward pipeline, kNN,
+ * bandit). Environment noise never does.
+ */
+'use strict';
+
+const crypto = require('crypto');
+
+const RING = 8;
+const TTL_MS = 6 * 60 * 60 * 1000;
+const _sessions = new Map(); // sessionId -> { ts, turns: [] }
+
+const ATTRIBUTABLE = new Set(['progress', 'no_progress', 'regression']);
+const ENV_ERROR_RE = /command not found|No such file or directory|Permission denied|Killed|Out of memory|Connection refused|Temporary failure in name resolution|E: Unable to locate package/i;
+const RUNTIME_ERROR_RE = /Traceback \(most recent call last\)|SyntaxError|TypeError|ReferenceError|error\[E\d+\]|FAILED|AssertionError|exit code [1-9]/;
+
+function _hash(s) { return crypto.createHash('sha1').update(String(s)).digest('hex').slice(0, 16); }
+function _text(msg) {
+  if (!msg) return '';
+  if (typeof msg.content === 'string') return msg.content;
+  if (Array.isArray(msg.content)) return msg.content.filter((b) => b && (b.type === 'text' || b.type === 'tool_result')).map((b) => typeof b.text === 'string' ? b.text : (typeof b.content === 'string' ? b.content : JSON.stringify(b.content || ''))).join('\n');
+  return '';
+}
+function _lastIdx(messages, role) { for (let i = messages.length - 1; i >= 0; i--) if (messages[i]?.role === role) return i; return -1; }
+function _commandSig(text) {
+  const s = text.indexOf('{'), e = text.lastIndexOf('}');
+  if (s === -1 || e <= s) return null;
+  try {
+    const obj = JSON.parse(text.slice(s, e + 1));
+    if (obj && Array.isArray(obj.commands)) return _hash(JSON.stringify(obj.commands.map((c) => String(c?.keystrokes ?? '').replace(/\s+/g, ' ').trim())));
+  } catch { /* not json */ }
+  return null;
+}
+function _toolResultError(msg) {
+  return Array.isArray(msg?.content) && msg.content.some((b) => b && b.type === 'tool_result' && b.is_error === true);
+}
+
+function _get(sessionId) {
+  const now = Date.now();
+  let s = _sessions.get(sessionId);
+  if (s && now - s.ts > TTL_MS) { _sessions.delete(sessionId); s = null; }
+  if (!s) { s = { ts: now, turns: [] }; _sessions.set(sessionId, s); }
+  s.ts = now;
+  if (_sessions.size > 20000) { // crude eviction
+    const oldest = [..._sessions.entries()].sort((a, b) => a[1].ts - b[1].ts).slice(0, 2000);
+    for (const [k] of oldest) _sessions.delete(k);
+  }
+  return s;
+}
+
+/**
+ * Classify the previous turn from the incoming request.
+ * @param {object} args
+ * @param {string} args.sessionId
+ * @param {object} args.payload         incoming request (messages)
+ * @param {object} [args.prevRecord]    what the gateway recorded about the previous turn:
+ *        { statusCode, errorType, failover:boolean, tierFallback:boolean, servedModel, tier }
+ * @returns {{ outcome, attributable, evidence, streak }|null}  null when there is no previous turn
+ */
+function classifyPrevious({ sessionId, payload, prevRecord = null }) {
+  const msgs = Array.isArray(payload?.messages) ? payload.messages : [];
+  const aIdx = _lastIdx(msgs, 'assistant');
+  if (aIdx < 0) return null;
+  const lastA = _text(msgs[aIdx]);
+  const after = msgs.slice(aIdx + 1).filter((m) => m?.role === 'user');
+  const lastU = after.length ? after[after.length - 1] : null;
+  const uText = _text(lastU);
+  const convHash = _hash(msgs.slice(0, aIdx + 1).map((m) => _text(m)).join('\u0000'));
+  const cmdSig = _commandSig(lastA);
+  const s = sessionId ? _get(sessionId) : { turns: [] };
+  const prev = s.turns.length ? s.turns[s.turns.length - 1] : null;
+
+  let outcome, evidence = {};
+  if (prevRecord && (prevRecord.failover || prevRecord.tierFallback || (prevRecord.statusCode && prevRecord.statusCode >= 500) || /timeout|UPSTREAM/i.test(String(prevRecord.errorType || '')))) {
+    outcome = 'provider_error'; evidence = { statusCode: prevRecord.statusCode, errorType: prevRecord.errorType, failover: !!prevRecord.failover };
+  } else if (!lastU) {
+    // Client re-sent the conversation ending in an assistant turn, or no user turn followed yet.
+    outcome = 'missing';
+  } else if (prev && prev.convHash === convHash && prev.outcome !== 'provider_error') {
+    outcome = 'regression'; evidence = { reason: 'identical_conversation_retry' };
+  } else if (_toolResultError(lastU) || ENV_ERROR_RE.test(uText)) {
+    outcome = 'tool_error'; evidence = { reason: _toolResultError(lastU) ? 'tool_result_is_error' : 'environment_error_marker' };
+  } else if (cmdSig && prev && prev.cmdSig === cmdSig) {
+    outcome = (prev.outputHash === _hash(uText)) ? 'no_progress' : 'regression';
+    evidence = { reason: outcome === 'no_progress' ? 'same_commands_same_output' : 'same_commands_different_output' };
+  } else if (RUNTIME_ERROR_RE.test(uText)) {
+    outcome = 'regression'; evidence = { reason: 'runtime_error_in_output' };
+  } else {
+    outcome = 'progress';
+  }
+  const attributable = ATTRIBUTABLE.has(outcome);
+  // Streak of consecutive attributable regressions/no_progress, skipping noise.
+  let streak = 0;
+  if (attributable && outcome !== 'progress') {
+    streak = 1;
+    for (let i = s.turns.length - 1; i >= 0; i--) {
+      const t = s.turns[i];
+      if (!t.attributable) continue;
+      if (t.outcome === 'progress') break;
+      streak++;
+    }
+  }
+  const rec = { ts: Date.now(), outcome, attributable, evidence, streak, convHash, cmdSig, outputHash: _hash(uText), tier: prevRecord?.tier ?? null, servedModel: prevRecord?.servedModel ?? null };
+  if (sessionId) { s.turns.push(rec); if (s.turns.length > RING) s.turns.shift(); }
+  return { outcome, attributable, evidence, streak };
+}
+
+function ring(sessionId) { return sessionId && _sessions.has(sessionId) ? [..._sessions.get(sessionId).turns] : []; }
+/** Reward for the learning loop: null means "do not update" (environment noise). */
+function rewardFor(outcome) {
+  if (!ATTRIBUTABLE.has(outcome)) return null;
+  return outcome === 'progress' ? 1 : outcome === 'no_progress' ? 0.3 : 0;
+}
+function _clear() { _sessions.clear(); }
+
+module.exports = { classifyPrevious, ring, rewardFor, ATTRIBUTABLE, _clear };

package/src/routing/routing-config.js

@@ -0,0 +1,154 @@
+/**
+ * Declarative routing config (signals → decisions).
+ *
+ * Loads config/routing.json (override path: LYNKR_ROUTING_CONFIG). Hot-reloads
+ * on mtime change. Validation is strict about shape and lenient about intent:
+ * an invalid file is logged and the previous good config (or the built-in
+ * default) stays in force — routing must never fail because of a config typo.
+ *
+ * Shape:
+ *   {
+ *     version: 1,
+ *     mode: "observe" | "enforce",         // observe: log what the engine would do
+ *     harness: { patterns: [{ name, preamble, instruction }] },
+ *     signals: { <name>: { type, ...options } },
+ *     decisions: [{ name, priority, rules, tier, effort, hosts, plugins }],
+ *     anchor_bands: { SIMPLE: [0,20], MEDIUM: [20,51], COMPLEX: [51,76], REASONING: [76,101] }
+ *   }
+ * Rule: { operator: "AND"|"OR"|"NOT", conditions: [ cond | rule ] }
+ * Cond: { signal, matched?, equals?, in?, band_in?, tier_in?, min?, max?, min_confidence? }
+ * Tier: "SIMPLE"|"MEDIUM"|"COMPLEX"|"REASONING"|"from:legacy"|"from:anchor"|"from:judge"
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const logger = require('../logger');
+
+const TIERS = ['SIMPLE', 'MEDIUM', 'COMPLEX', 'REASONING'];
+const DEFAULT_PATH = path.join(__dirname, '..', '..', 'config', 'routing.json');
+
+const DEFAULT_CONFIG = {
+  version: 1,
+  mode: 'observe',
+  anchor_bands: { SIMPLE: [0, 20], MEDIUM: [20, 51], COMPLEX: [51, 76], REASONING: [76, 101] },
+  harness: {
+    patterns: [
+      {
+        name: 'terminus',
+        preamble: 'You are an AI assistant tasked with solving command-line tasks',
+        instruction: '(?:^|\\n)Instruction:\\s*\\n([\\s\\S]*?)\\n\\s*\\n(?:Your response must be|Your response|Respond)',
+      },
+    ],
+  },
+  signals: {
+    anchor: { type: 'anchor_score' },
+    judge: { type: 'jev' },
+    harness: { type: 'harness' },
+    structured: { type: 'request_field', any_of: ['output_format', 'response_format'] },
+    tool_count: { type: 'tool_count' },
+    turn: { type: 'session_turn' },
+    phase: { type: 'session_phase' },
+    risk: { type: 'risk' },
+  },
+  decisions: [
+    { name: 'legacy', priority: 0, rules: { operator: 'AND', conditions: [] }, tier: 'from:legacy' },
+  ],
+};
+
+let _cache = { path: null, mtime: 0, config: DEFAULT_CONFIG, source: 'default' };
+
+function configPath() {
+  return process.env.LYNKR_ROUTING_CONFIG ? path.resolve(process.env.LYNKR_ROUTING_CONFIG) : DEFAULT_PATH;
+}
+
+function _isRule(x) { return x && typeof x === 'object' && typeof x.operator === 'string'; }
+
+function validate(cfg) {
+  const errors = [];
+  if (!cfg || typeof cfg !== 'object') return ['config is not an object'];
+  if (cfg.mode && !['observe', 'enforce'].includes(cfg.mode)) errors.push(`mode must be observe|enforce (got ${cfg.mode})`);
+  const signals = cfg.signals || {};
+  for (const [name, s] of Object.entries(signals)) {
+    if (!s || typeof s.type !== 'string') errors.push(`signal ${name}: missing type`);
+  }
+  const decisions = Array.isArray(cfg.decisions) ? cfg.decisions : [];
+  if (decisions.length === 0) errors.push('decisions: at least one decision is required');
+  const seenNames = new Set(), seenPri = new Map();
+  const checkRule = (rule, where) => {
+    if (!_isRule(rule)) { errors.push(`${where}: rules must have operator`); return; }
+    const op = rule.operator.toUpperCase();
+    if (!['AND', 'OR', 'NOT'].includes(op)) errors.push(`${where}: operator must be AND|OR|NOT`);
+    const conds = Array.isArray(rule.conditions) ? rule.conditions : [];
+    if (op === 'NOT' && conds.length !== 1) errors.push(`${where}: NOT takes exactly one condition`);
+    conds.forEach((c, i) => {
+      if (_isRule(c)) return checkRule(c, `${where}.conditions[${i}]`);
+      if (!c || typeof c.signal !== 'string') errors.push(`${where}.conditions[${i}]: missing signal`);
+      else if (!signals[c.signal]) errors.push(`${where}.conditions[${i}]: unknown signal "${c.signal}"`);
+    });
+  };
+  decisions.forEach((d, i) => {
+    const where = `decisions[${i}]${d?.name ? ` (${d.name})` : ''}`;
+    if (!d || typeof d.name !== 'string') errors.push(`${where}: missing name`);
+    else if (seenNames.has(d.name)) errors.push(`${where}: duplicate name`); else seenNames.add(d.name);
+    if (!Number.isFinite(d?.priority)) errors.push(`${where}: priority must be a number`);
+    else if (seenPri.has(d.priority)) errors.push(`${where}: priority ${d.priority} also used by ${seenPri.get(d.priority)}`); else seenPri.set(d.priority, d.name);
+    checkRule(d?.rules, `${where}.rules`);
+    const t = d?.tier;
+    if (t !== undefined && !(TIERS.includes(t) || /^from:(legacy|anchor|judge)$/.test(String(t)))) errors.push(`${where}: tier must be a tier name or from:legacy|anchor|judge`);
+    if (d?.effort !== undefined && !['none', 'low', 'medium', 'high'].includes(d.effort)) errors.push(`${where}: effort must be none|low|medium|high`);
+    if (d?.hosts !== undefined && !Array.isArray(d.hosts)) errors.push(`${where}: hosts must be an array`);
+  });
+  for (const p of (cfg.harness?.patterns || [])) {
+    try { new RegExp(p.preamble, 'i'); if (p.instruction) new RegExp(p.instruction, 'i'); } catch (e) { errors.push(`harness pattern ${p.name}: ${e.message}`); }
+  }
+  return errors;
+}
+
+function load() {
+  if (_cache.source === 'test') return _cache.config;
+  const p = configPath();
+  try {
+    if (!fs.existsSync(p)) {
+      if (_cache.source !== 'default') logger.info({ path: p }, '[RoutingConfig] file missing — using built-in default');
+      _cache = { path: p, mtime: 0, config: DEFAULT_CONFIG, source: 'default' };
+      return _cache.config;
+    }
+    const st = fs.statSync(p);
+    if (_cache.path === p && _cache.mtime === st.mtimeMs) return _cache.config;
+    const raw = JSON.parse(fs.readFileSync(p, 'utf8'));
+    const merged = { ...DEFAULT_CONFIG, ...raw, signals: { ...DEFAULT_CONFIG.signals, ...(raw.signals || {}) } };
+    const errors = validate(merged);
+    if (errors.length) {
+      logger.error({ path: p, errors }, '[RoutingConfig] invalid — keeping previous config');
+      _cache.mtime = st.mtimeMs; // don't re-log every request
+      return _cache.config;
+    }
+    merged.decisions = [...merged.decisions].sort((a, b) => b.priority - a.priority);
+    _cache = { path: p, mtime: st.mtimeMs, config: merged, source: 'file' };
+    logger.info({ path: p, mode: merged.mode, decisions: merged.decisions.map((d) => d.name) }, '[RoutingConfig] loaded');
+    return merged;
+  } catch (err) {
+    logger.error({ path: p, err: err.message }, '[RoutingConfig] load failed — keeping previous config');
+    return _cache.config;
+  }
+}
+
+function mode() { return load().mode === 'enforce' ? 'enforce' : 'observe'; }
+function anchorBandFor(score) {
+  const bands = load().anchor_bands || DEFAULT_CONFIG.anchor_bands;
+  const s = Number(score);
+  if (!Number.isFinite(s)) return null;
+  for (const t of TIERS) { const [lo, hi] = bands[t] || []; if (s >= lo && s < hi) return t; }
+  return s >= 100 ? 'REASONING' : null;
+}
+function harnessPatterns() {
+  return (load().harness?.patterns || []).map((p) => ({
+    name: p.name,
+    preamble: new RegExp(p.preamble, 'i'),
+    instruction: p.instruction ? new RegExp(p.instruction, 'i') : null,
+  }));
+}
+function _resetForTests(cfg) { _cache = { path: null, mtime: 0, config: cfg || DEFAULT_CONFIG, source: cfg ? 'test' : 'default' }; }
+
+module.exports = { TIERS, DEFAULT_CONFIG, load, validate, mode, anchorBandFor, harnessPatterns, configPath, _resetForTests };

package/src/routing/shortfall.js

@@ -78,6 +78,7 @@ function loadProfiles() {
     const weights = _normalizeWeights(raw?.weights);
     _profilesCache = {
       tierProfiles,
+      evaluation: Array.isArray(raw?.evaluation?.records) ? raw.evaluation.records : [],
       modelOverrides,
       enabled: raw?.enabled === true,
       tau: Number.isFinite(tau) && tau >= 0 ? tau : DEFAULT_TAU,
@@ -85,7 +86,7 @@ function loadProfiles() {
     };
   } catch (err) {
     logger.debug({ err: err.message }, '[Shortfall] profiles load failed — disabled with tier fallbacks');
-    _profilesCache = { tierProfiles: {}, modelOverrides: {}, enabled: false, tau: DEFAULT_TAU, weights: _defaultWeights() };
+    _profilesCache = { tierProfiles: {}, modelOverrides: {}, evaluation: [], enabled: false, tau: DEFAULT_TAU, weights: _defaultWeights() };
   }
   return _profilesCache;
 }
@@ -99,6 +100,7 @@ function _setProfilesForTests(profiles) {
   const base = loadProfiles();
   _profilesCache = {
     tierProfiles: profiles?.tierProfiles ?? base.tierProfiles,
+    evaluation: profiles?.evaluation ?? base.evaluation ?? [],
     modelOverrides: profiles?.modelOverrides ?? base.modelOverrides,
     enabled: profiles?.enabled ?? base.enabled,
     tau: profiles?.tau ?? base.tau,
@@ -153,6 +155,14 @@ function isEnabled() {
  *   seed:shipped|family|tier|tier-fallback (telemetry provenance).
  */
 function resolveCapabilitiesWithSource({ provider, model, tier }) {
+  {
+    // Measured evaluation records (written by scripts/calibrate-capabilities.js
+    // --apply) outrank operator overrides and shipped seeds.
+    const _ev = loadProfiles().evaluation;
+    const _key = `${provider}:${model}`.toLowerCase();
+    const _rec = Array.isArray(_ev) ? _ev.find((r) => String(r.model || '').toLowerCase() === _key && r.heads) : null;
+    if (_rec) return { caps: _sanitizeCaps(_rec.heads), source: `evaluation:${_rec.benchmark || 'measured'}` };
+  }
   const { tierProfiles, modelOverrides } = loadProfiles();
   const key = `${String(provider || '').toLowerCase()}:${String(model || '').toLowerCase()}`;
   const wild = `${String(provider || '').toLowerCase()}:*`;
@@ -280,8 +290,87 @@ function selectByShortfall(req, candidates, opts = {}) {
   }
 }
 
+const TIER_MIDPOINTS = [['SIMPLE', 10], ['MEDIUM', 35], ['COMPLEX', 63], ['REASONING', 88]];
+
+function _tierVec(tierProfiles, tier) {
+  const tp = tierProfiles?.[tier];
+  if (!tp) return null;
+  const v = {};
+  for (const h of HEADS) v[h] = Number.isFinite(tp[h]) ? Math.max(0, Math.min(1, tp[h])) : 0;
+  return v;
+}
+
+/** Anchor score (0–100) → head vector interpolated between tier profiles. */
+const _r3 = (v) => Math.round(Math.max(0, Math.min(1, v)) * 1000) / 1000;
+
+function anchorRequirement(anchorScore, tierProfiles = null) {
+  if (anchorScore === null || anchorScore === undefined || anchorScore === '') return null;
+  const s = Number(anchorScore);
+  if (!Number.isFinite(s)) return null;
+  const tps = tierProfiles || loadProfiles().tierProfiles;
+  const pts = TIER_MIDPOINTS.map(([t, mid]) => [mid, _tierVec(tps, t)]).filter(([, v]) => v);
+  if (pts.length === 0) return null;
+  if (s <= pts[0][0]) return pts[0][1];
+  if (s >= pts[pts.length - 1][0]) return pts[pts.length - 1][1];
+  for (let i = 0; i < pts.length - 1; i++) {
+    const [a, va] = pts[i], [b, vb] = pts[i + 1];
+    if (s >= a && s <= b) {
+      const f = (s - a) / (b - a);
+      const v = {};
+      for (const h of HEADS) v[h] = _r3(va[h] + (vb[h] - va[h]) * f);
+      return v;
+    }
+  }
+  return null;
+}
+
+/** Jev verdict { probabilities:{TIER:p} } (or { tier, confidence }) → head vector. */
+function jevRequirement(jev, tierProfiles = null) {
+  if (!jev || typeof jev !== 'object') return null;
+  const tps = tierProfiles || loadProfiles().tierProfiles;
+  let probs = jev.probabilities && typeof jev.probabilities === 'object' ? jev.probabilities : null;
+  if (!probs && jev.tier) probs = { [jev.tier]: Number.isFinite(jev.confidence) ? jev.confidence : 1 };
+  if (!probs) return null;
+  const v = {}; for (const h of HEADS) v[h] = 0;
+  let total = 0;
+  for (const [tier, p] of Object.entries(probs)) {
+    const tv = _tierVec(tps, tier); const w = Number(p);
+    if (!tv || !Number.isFinite(w) || w <= 0) continue;
+    total += w;
+    for (const h of HEADS) v[h] += tv[h] * w;
+  }
+  if (total <= 0) return null;
+  for (const h of HEADS) v[h] = _r3(v[h] / total);
+  return v;
+}
+
+/**
+ * Lift a structural requirement vector with the semantic signals.
+ * @returns {{ req: object, lift: { anchor: object|null, jev: object|null, applied: string[] } }}
+ */
+function liftRequirement(req, { anchorScore = null, jev = null } = {}, tierProfiles = null) {
+  try {
+    const base = {}; for (const h of HEADS) base[h] = Number.isFinite(req?.[h]) ? req[h] : 0;
+    const a = anchorRequirement(anchorScore, tierProfiles);
+    const j = jevRequirement(jev, tierProfiles);
+    const out = { ...base }; const applied = [];
+    for (const h of HEADS) {
+      if (a && a[h] > out[h]) { out[h] = a[h]; if (!applied.includes('anchor')) applied.push('anchor'); }
+      if (j && j[h] > out[h]) { out[h] = j[h]; if (!applied.includes('jev')) applied.push('jev'); }
+      out[h] = Math.round(Math.max(0, Math.min(1, out[h])) * 1000) / 1000;
+    }
+    return { req: out, lift: { anchor: a, jev: j, applied } };
+  } catch (err) {
+    logger.debug({ err: err.message }, '[Shortfall] semantic lift failed — structural vector kept');
+    return { req, lift: { anchor: null, jev: null, applied: [] } };
+  }
+}
+
 module.exports = {
   HEADS,
+  anchorRequirement,
+  jevRequirement,
+  liftRequirement,
   DEFAULT_TAU,
   loadProfiles,
   _resetProfilesCache,

package/src/routing/signals.js

@@ -0,0 +1,179 @@
+/**
+ * Signal registry for declarative routing.
+ *
+ * A signal is a pure function of the request context that returns
+ *   { matched: boolean, value: any, confidence: number|null, detail?: object }
+ * Signals never route; decisions (decisions.js) combine them. Every evaluator
+ * fails open: an exception yields { matched:false, value:null, error }.
+ *
+ * Context (ctx): { payload, analysis, legacy:{tier,provider,model}, risk,
+ *                  agenticResult, sessionId, prevTurns:[] }
+ */
+'use strict';
+
+const logger = require('../logger');
+const rc = require('./routing-config');
+
+const TIER_PRI = { SIMPLE: 1, MEDIUM: 2, COMPLEX: 3, REASONING: 4 };
+
+function _text(msg) {
+  if (!msg) return '';
+  if (typeof msg.content === 'string') return msg.content;
+  if (Array.isArray(msg.content)) return msg.content.filter((b) => b && b.type === 'text' && typeof b.text === 'string').map((b) => b.text).join('\n');
+  return '';
+}
+function _lastOfRole(messages, role) {
+  for (let i = messages.length - 1; i >= 0; i--) if (messages[i]?.role === role) return messages[i];
+  return null;
+}
+function _hasToolResult(msg) {
+  return Array.isArray(msg?.content) && msg.content.some((b) => b && b.type === 'tool_result');
+}
+function _completionClaim(text) {
+  return /"is_task_complete"\s*:\s*true/.test(text) || /\b(task (is )?complete|all done|completed successfully)\b/i.test(text);
+}
+
+const EVALUATORS = {
+  anchor_score(ctx) {
+    const v = ctx.analysis?.anchorScore ?? ctx.analysis?.score ?? null;
+    if (!Number.isFinite(v)) return { matched: false, value: null, confidence: null };
+    return { matched: true, value: v, confidence: null, band: rc.anchorBandFor(v) };
+  },
+  jev(ctx, opt) {
+    const j = ctx.analysis?.jev;
+    if (!j || !j.tier) return { matched: false, value: null, confidence: null };
+    const minC = Number.isFinite(opt.min_confidence) ? opt.min_confidence : 0;
+    return { matched: (j.confidence ?? 0) >= minC, value: j.tier, confidence: j.confidence ?? null, tier: j.tier, probabilities: j.probabilities || null, risky: j.risky ?? null };
+  },
+  harness(ctx) {
+    const { harnessAskFromPayload } = require('./harness-envelope');
+    const ask = harnessAskFromPayload(ctx.payload);
+    return ask ? { matched: true, value: ask.name || 'harness', confidence: 1, detail: { instruction: ask.text.slice(0, 200) } } : { matched: false, value: null, confidence: null };
+  },
+  request_field(ctx, opt) {
+    const keys = Array.isArray(opt.any_of) ? opt.any_of : [];
+    const hit = keys.find((k) => ctx.payload && ctx.payload[k] !== undefined && ctx.payload[k] !== null);
+    return hit ? { matched: true, value: hit, confidence: 1 } : { matched: false, value: null, confidence: null };
+  },
+  tool_count(ctx) {
+    const n = Array.isArray(ctx.payload?.tools) ? ctx.payload.tools.length : 0;
+    return { matched: n > 0, value: n, confidence: 1 };
+  },
+  session_turn(ctx) {
+    const msgs = Array.isArray(ctx.payload?.messages) ? ctx.payload.messages : [];
+    const n = msgs.filter((m) => m?.role === 'assistant').length;
+    return { matched: n > 0, value: n, confidence: 1 };
+  },
+  session_phase(ctx) {
+    const msgs = Array.isArray(ctx.payload?.messages) ? ctx.payload.messages : [];
+    const assistants = msgs.filter((m) => m?.role === 'assistant');
+    if (assistants.length === 0) return { matched: true, value: 'planning', confidence: 0.9 };
+    const lastA = _text(_lastOfRole(msgs, 'assistant'));
+    const lastU = _lastOfRole(msgs, 'user');
+    if (_completionClaim(lastA)) return { matched: true, value: 'done', confidence: 0.8 };
+    if (/\b(pytest|npm test|go test|make test|verify|check that|assert)\b/i.test(lastA)) return { matched: true, value: 'verification', confidence: 0.6 };
+    if (_hasToolResult(lastU) || /\$ |root@|Traceback|error:/i.test(_text(lastU))) return { matched: true, value: 'tool_loop', confidence: 0.7 };
+    return { matched: true, value: 'tool_loop', confidence: 0.4 };
+  },
+  risk(ctx) {
+    const lvl = ctx.risk?.level || null;
+    return { matched: lvl === 'high', value: lvl, confidence: ctx.risk?.score ?? null };
+  },
+  keyword(ctx, opt) {
+    const terms = Array.isArray(opt.terms) ? opt.terms : [];
+    if (!terms.length) return { matched: false, value: null, confidence: null };
+    const { harnessAskFromPayload } = require('./harness-envelope');
+    const ask = harnessAskFromPayload(ctx.payload);
+    const text = (ask ? ask.text : _text(_lastOfRole(ctx.payload?.messages || [], 'user'))).toLowerCase();
+    const method = opt.method || 'any';
+    const hits = terms.filter((t) => opt.regex ? new RegExp(t, 'i').test(text) : text.includes(String(t).toLowerCase()));
+    if (method === 'all') return { matched: hits.length === terms.length, value: hits, confidence: hits.length / terms.length };
+    const thr = Number.isFinite(opt.min_hits) ? opt.min_hits : 1;
+    return { matched: hits.length >= thr, value: hits, confidence: terms.length ? hits.length / terms.length : 0 };
+  },
+  async complexity(ctx, opt) {
+    // Exemplar contrast: sim(hard centroid) − sim(easy centroid), per head,
+    // using the embedder already configured. Exemplars from
+    // config/complexity-exemplars.json (scripts/build-complexity-exemplars.js).
+    const emb = require('../cache/embeddings');
+    const fs = require('fs'), path = require('path');
+    const file = opt.exemplars ? path.resolve(opt.exemplars) : path.join(__dirname, '..', '..', 'config', 'complexity-exemplars.json');
+    if (!fs.existsSync(file)) return { matched: false, value: null, confidence: null, error: 'no exemplars file' };
+    const st = fs.statSync(file);
+    if (!EVALUATORS._cx || EVALUATORS._cx.file !== file || EVALUATORS._cx.mtime !== st.mtimeMs) {
+      const doc = JSON.parse(fs.readFileSync(file, 'utf8'));
+      const centroid = async (texts) => {
+        const vs = []; for (const t of (texts || []).slice(0, 60)) { const v = await emb.generateEmbedding(t); if (Array.isArray(v) && v.length) vs.push(v); }
+        if (!vs.length) return null;
+        const c = new Array(vs[0].length).fill(0); for (const v of vs) for (let i = 0; i < c.length; i++) c[i] += v[i] / vs.length; return c;
+      };
+      const heads = {};
+      for (const [h, sets] of Object.entries(doc.heads || {})) heads[h] = { hard: await centroid(sets.hard), easy: await centroid(sets.easy) };
+      EVALUATORS._cx = { file, mtime: st.mtimeMs, heads };
+    }
+    const { harnessAskFromPayload } = require('./harness-envelope');
+    const ask = harnessAskFromPayload(ctx.payload);
+    const text = ask ? ask.text : _text(_lastOfRole(ctx.payload?.messages || [], 'user'));
+    if (!text) return { matched: false, value: null, confidence: null };
+    const q = await emb.generateEmbedding(text.slice(0, 4000));
+    if (!Array.isArray(q)) return { matched: false, value: null, confidence: null };
+    const perHead = {}; let sum = 0, n = 0;
+    for (const [h, c] of Object.entries(EVALUATORS._cx.heads)) {
+      if (!c.hard || !c.easy) continue;
+      const d = emb.cosineSimilarity(q, c.hard) - emb.cosineSimilarity(q, c.easy); // typically within ±0.3
+      const v = Math.max(0, Math.min(1, 0.5 + d / (2 * (Number(opt.scale) || 0.15))));
+      perHead[h] = Math.round(v * 1000) / 1000; sum += v; n++;
+    }
+    if (!n) return { matched: false, value: null, confidence: null };
+    const value = Math.round((sum / n) * 1000) / 1000;
+    const thr = Number.isFinite(opt.threshold) ? opt.threshold : 0.6;
+    return { matched: value >= thr, value, confidence: Math.abs(value - 0.5) * 2, heads: perHead, band: value >= 0.75 ? 'REASONING' : value >= 0.6 ? 'COMPLEX' : value >= 0.4 ? 'MEDIUM' : 'SIMPLE' };
+  },
+  legacy_tier(ctx) {
+    const t = ctx.legacy?.tier || null;
+    return { matched: !!t, value: t, confidence: 1 };
+  },
+  prev_outcome(ctx) {
+    const last = Array.isArray(ctx.prevTurns) && ctx.prevTurns.length ? ctx.prevTurns[ctx.prevTurns.length - 1] : null;
+    if (!last) return { matched: false, value: null, confidence: null };
+    return { matched: true, value: last.outcome, confidence: 1, attributable: !!last.attributable, streak: last.streak ?? null };
+  },
+};
+
+/** Evaluate every configured signal once. Returns { name: result }. */
+async function evaluateAll(ctx, config) {
+  const cfg = config || rc.load();
+  const out = {};
+  for (const [name, def] of Object.entries(cfg.signals || {})) {
+    const fn = EVALUATORS[def.type];
+    if (!fn) { out[name] = { matched: false, value: null, confidence: null, error: `unknown type ${def.type}` }; continue; }
+    try {
+      const r = await fn(ctx, def);
+      out[name] = { matched: !!r.matched, value: r.value ?? null, confidence: r.confidence ?? null, ...r };
+    } catch (err) {
+      logger.debug({ signal: name, err: err.message }, '[Signals] evaluator failed — treated as unmatched');
+      out[name] = { matched: false, value: null, confidence: null, error: err.message };
+    }
+  }
+  return out;
+}
+
+/** Condition test used by the decision engine. */
+function testCondition(cond, signals) {
+  const s = signals[cond.signal];
+  if (!s) return false;
+  // Default semantics: a condition on a signal requires that signal to have
+  // matched (e.g. a judge below min_confidence must not satisfy tier_in).
+  if (cond.matched === undefined ? !s.matched : (!!s.matched !== !!cond.matched)) return false;
+  if (cond.equals !== undefined && s.value !== cond.equals) return false;
+  if (Array.isArray(cond.in) && !cond.in.includes(s.value)) return false;
+  if (Array.isArray(cond.band_in) && !cond.band_in.includes(s.band)) return false;
+  if (Array.isArray(cond.tier_in) && !cond.tier_in.includes(s.tier ?? s.value)) return false;
+  if (Number.isFinite(cond.min) && !(Number(s.value) >= cond.min)) return false;
+  if (Number.isFinite(cond.max) && !(Number(s.value) <= cond.max)) return false;
+  if (Number.isFinite(cond.min_confidence) && !((s.confidence ?? 0) >= cond.min_confidence)) return false;
+  if (cond.min_tier && !((TIER_PRI[s.tier ?? s.value] || 0) >= (TIER_PRI[cond.min_tier] || 0))) return false;
+  return true;
+}
+
+module.exports = { EVALUATORS, evaluateAll, testCondition, TIER_PRI };