vibeoscore 1.0.2

package/lib/blackbox-rf.js

@@ -0,0 +1,1099 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs"
+import { dirname, resolve } from "node:path"
+import { fileURLToPath } from "node:url"
+import { getDb } from "./db.js"
+import { ResolutionTracker, extractFeatures } from "./blackbox.js"
+import { scoreStress } from "./stress.js"
+import { autoSelectMode } from "./meta-controller.js"
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const MODEL_PATH = process.env.VIBEOS_BLACKBOX_ROUTING_MODEL_PATH || resolve(__dirname, "..", "data", "blackbox-routing-model.json")
+const MODE_CLASSES = ["budget", "audit", "speed", "quality", "longrun"]
+const DEFAULT_CONFIDENCE_THRESHOLD = 0.55
+const DEFAULT_TREE_COUNT = 29
+const DEFAULT_MAX_DEPTH = 7
+const DEFAULT_MIN_SAMPLES_SPLIT = 6
+const DEFAULT_MIN_SAMPLES_LEAF = 2
+const DEFAULT_FEATURE_SUBSAMPLE = 6
+
+let cachedModel = null
+const cachedGateModels = new Map()
+
+function num(v, fallback = 0) {
+  const n = Number(v)
+  return Number.isFinite(n) ? n : fallback
+}
+
+function modePriority(mode) {
+  const normalized = String(mode || "").toLowerCase()
+  const priorities = { budget: 0, audit: 1, speed: 2, longrun: 3, quality: 4 }
+  return priorities[normalized] ?? 0
+}
+
+function clamp(v, min = 0, max = 1) {
+  return Math.min(max, Math.max(min, v))
+}
+
+function loadJsonSafe(raw) {
+  try {
+    if (!raw) return null
+    return typeof raw === "string" ? JSON.parse(raw) : raw
+  } catch {
+    return null
+  }
+}
+
+function loadRecentSessionSignals(projectId, sessionId, lookbackHours = 48, limit = 31) {
+  try {
+    const db = getDb()
+    const cutoff = new Date(Date.now() - lookbackHours * 60 * 60 * 1000).toISOString()
+    const rows = projectId
+      ? db.prepare(
+        "SELECT session_id, state_json, outcome, updated_at FROM blackbox_sessions WHERE updated_at >= ? AND project_id = ? ORDER BY updated_at DESC LIMIT ?"
+      ).all(cutoff, projectId, limit)
+      : db.prepare(
+        "SELECT session_id, state_json, outcome, updated_at FROM blackbox_sessions WHERE updated_at >= ? ORDER BY updated_at DESC LIMIT ?"
+      ).all(cutoff, limit)
+    const sessions = []
+    for (const row of rows) {
+      if (sessionId && row.session_id === sessionId) continue
+      const parsed = loadJsonSafe(row.state_json)
+      const telemetry = parsed?.telemetry || parsed?.history?.slice(-1)[0]?.telemetry || null
+      const signals = telemetry?.signals || {}
+      const input = telemetry?.input || {}
+      const controlVector = telemetry?.control_vector || {}
+      sessions.push({
+        stress: num(input.latest_stress_multiplier ?? input.stress_multiplier ?? input.stress ?? controlVector.stress_multiplier ?? 0),
+        repeatRatio: num(signals.action_consistency ?? 0),
+        loopConsecutive: num(signals.loop_consecutive ?? parsed?.loopCount ?? 0),
+        isLooping: Boolean(signals.is_looping || signals.sub_regime === "LOOPING"),
+        outcome: String(signals.outcome || row.outcome || parsed?.outcome || "").toLowerCase(),
+      })
+    }
+    if (!sessions.length) return null
+    const recent = sessions.slice(0, Math.min(5, sessions.length))
+    const avg = (items, key) => items.reduce((sum, item) => sum + num(item[key]), 0) / Math.max(items.length, 1)
+    const peak = (items, key) => items.reduce((max, item) => Math.max(max, num(item[key])), 0)
+    return {
+      sampleCount: sessions.length,
+      recentStressAvg: avg(recent, "stress"),
+      recentStressPeak: peak(recent, "stress"),
+      repeatRatio: avg(sessions, "repeatRatio"),
+      loopRate: sessions.filter((item) => item.isLooping || item.loopConsecutive >= 3).length / sessions.length,
+      negativeRate: sessions.filter((item) => item.outcome === "negative").length / sessions.length,
+      anomalyRate: sessions.filter((item) => item.stress >= 0.45 || item.isLooping || item.outcome === "negative").length / sessions.length,
+    }
+  } catch {
+    return null
+  }
+}
+
+function stableHash(str) {
+  const s = String(str || "")
+  let hash = 2166136261
+  for (let i = 0; i < s.length; i++) {
+    hash ^= s.charCodeAt(i)
+    hash = Math.imul(hash, 16777619)
+  }
+  return hash >>> 0
+}
+
+function createRng(seed) {
+  let state = seed >>> 0
+  return () => {
+    state = (state + 0x6D2B79F5) | 0
+    let t = Math.imul(state ^ (state >>> 15), 1 | state)
+    t ^= t + Math.imul(t ^ (t >>> 7), 61 | t)
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296
+  }
+}
+
+function shuffleInPlace(items, rng) {
+  for (let i = items.length - 1; i > 0; i--) {
+    const j = Math.floor(rng() * (i + 1))
+    ;[items[i], items[j]] = [items[j], items[i]]
+  }
+  return items
+}
+
+function ensureModelDir() {
+  mkdirSync(dirname(MODEL_PATH), { recursive: true })
+}
+
+function normalizeGateMode(targetMode) {
+  return String(targetMode || "").toLowerCase().trim()
+}
+
+function getModeGatePath(targetMode) {
+  const gateMode = normalizeGateMode(targetMode)
+  return resolve(__dirname, "..", "data", "mode-gates", `${gateMode || "mode"}-gate.json`)
+}
+
+function ensureModeGateDir(targetMode) {
+  mkdirSync(dirname(getModeGatePath(targetMode)), { recursive: true })
+}
+
+function oneHotIndex(value) {
+  const idx = MODE_CLASSES.indexOf(String(value || "").toLowerCase())
+  return idx >= 0 ? idx : 0
+}
+
+function regimeIndex(value) {
+  const map = {
+    INIT: 0,
+    DIVERGENT: 1,
+    EXPLORING: 2,
+    REFINING: 3,
+    CONVERGING: 4,
+    CLOSED: 5,
+    LOOPING: 6,
+  }
+  return map[String(value || "").toUpperCase()] ?? 0
+}
+
+function resolutionIndex(value) {
+  const map = {
+    unresolved: 0,
+    looping: 1,
+    converging: 2,
+    solved: 3,
+  }
+  return map[String(value || "").toLowerCase()] ?? 0
+}
+
+function continuityIndex(value) {
+  const map = {
+    HIGH: 1,
+    MEDIUM: 0.6,
+    LOW: 0.2,
+  }
+  return map[String(value || "").toUpperCase()] ?? 0.5
+}
+
+function loopInterventionIndex(value) {
+  const map = {
+    none: 0,
+    gentle: 1,
+    suggestive: 2,
+    assertive: 3,
+    escalated: 4,
+  }
+  return map[String(value || "").toLowerCase()] ?? 0
+}
+
+function buildPromptSignals(text, explicit = {}) {
+  const raw = extractFeatures(text)
+  const lower = String(text || "").toLowerCase()
+  const words = lower.split(/\s+/).filter(Boolean)
+  const fileMentions = (lower.match(/(?:^|[\s"'(])\.{0,2}\/[a-z0-9._/-]+|\.(?:js|ts|tsx|jsx|py|rs|go|java|cpp|c|h|json|yaml|yml|toml|sql|css|html|md)\b|package\.json|tsconfig\.json|dockerfile|makefile|docker-compose/gi) || []).length
+  const errorSignals = (lower.match(/bug|error|fail|crash|broken|wrong|incorrect|issue|problem|exception|traceback|segfault|race|deadlock|leak|corrupt/gi) || []).length
+  const actionWords = new Set(["check", "find", "list", "search", "look", "count", "show", "get", "read", "grep", "scan", "detect", "inspect", "implement", "refactor", "migrate", "redesign", "optimize", "debug", "fix", "resolve", "patch", "build", "deploy", "integrate", "benchmark", "profile", "secure", "harden", "audit", "design", "create", "generate", "transform", "convert", "setup", "configure", "provision", "bootstrap"])
+  let actionDensity = 0
+  for (const word of words.slice(0, 8)) {
+    if (actionWords.has(word)) actionDensity += 0.15
+  }
+  actionDensity = clamp(actionDensity)
+  const complexityPattern = /multi.*(?:file|module|step|stage|phase|tenant|region|thread|process)|concurrent|async|parallel|distributed|replicated|shard|cluster|microservice|framework|database|schema|migration|backward.*compat|breaking.*change|api.*(?:version|breaking)|protocol|encoding|serializ/i
+  let complexityCount = 0
+  for (const word of words) {
+    if (complexityPattern.test(word)) complexityCount++
+  }
+  const prompt = {
+    length: num(raw.length),
+    word_count: num(raw.word_count),
+    sentence_count: num(raw.sentence_count),
+    avg_word_length: num(raw.avg_word_length),
+    question_ratio: num(raw.question_ratio),
+    code_blocks: num(raw.code_blocks),
+    urgency: num(raw.urgency),
+    repetition: num(raw.repetition),
+    sentiment: num(raw.sentiment),
+    complexity: num(raw.complexity),
+    instruction_density: num(raw.instruction_density),
+    file_mentions: num(explicit.file_mentions ?? fileMentions),
+    error_signals: num(explicit.error_signals ?? errorSignals),
+    action_density: num(explicit.action_density ?? actionDensity),
+    complexity_words: num(explicit.complexity_words ?? complexityCount),
+    stress: num(explicit.stress ?? scoreStress(text)),
+  }
+  return prompt
+}
+
+function buildFeatureVector(text, context = {}) {
+  const prompt = buildPromptSignals(text, context.prompt_features || context.features || {})
+  const state = context.state || {}
+  return [
+    prompt.length,
+    prompt.word_count,
+    prompt.sentence_count,
+    prompt.avg_word_length,
+    prompt.question_ratio,
+    prompt.code_blocks,
+    prompt.urgency,
+    prompt.repetition,
+    prompt.sentiment,
+    prompt.complexity,
+    prompt.instruction_density,
+    prompt.file_mentions,
+    prompt.error_signals,
+    prompt.action_density,
+    prompt.complexity_words,
+    prompt.stress,
+    num(state.momentum),
+    num(state.signals?.action_consistency),
+    num(state.signals?.entropy_trend),
+    num(state.signals?.feature_contradiction),
+    num(state.signals?.embedding_delta),
+    num(state.pivot_score),
+    num(state.n_interactions),
+    num(state.loop_consecutive ?? state.loop_count),
+    regimeIndex(state.sub_regime),
+    resolutionIndex(state.resolution),
+    continuityIndex(state.continuity_state),
+    loopInterventionIndex(state.loop_intervention_level),
+    state.is_looping ? 1 : 0,
+    num(state.outcome === "positive" ? 1 : state.outcome === "negative" ? -1 : 0),
+  ]
+}
+
+function bootstrapSamples() {
+  const scenarios = [
+    { text: "hi", state: { sub_regime: "INIT", resolution: "unresolved", continuity_state: "HIGH", momentum: 0.05, n_interactions: 1 }, mode: "budget" },
+    { text: "just give me the quick answer", state: { sub_regime: "INIT", resolution: "unresolved", continuity_state: "HIGH", momentum: 0.06, n_interactions: 1 }, mode: "budget" },
+    { text: "show me the current status", state: { sub_regime: "EXPLORING", resolution: "unresolved", continuity_state: "HIGH", momentum: 0.18, n_interactions: 2 }, mode: "audit" },
+    { text: "inspect the repo and list files", state: { sub_regime: "EXPLORING", resolution: "unresolved", continuity_state: "HIGH", momentum: 0.14, n_interactions: 2 }, mode: "audit" },
+    { text: "can you inspect this error trace and explain what is wrong?", state: { sub_regime: "REFINING", resolution: "unresolved", continuity_state: "MEDIUM", momentum: 0.42, n_interactions: 3 }, mode: "audit" },
+    { text: "please review the config and compare the current behavior", state: { sub_regime: "EXPLORING", resolution: "unresolved", continuity_state: "HIGH", momentum: 0.16, n_interactions: 2 }, mode: "audit" },
+    { text: "this is broken now fix it immediately", state: { sub_regime: "REFINING", resolution: "unresolved", continuity_state: "MEDIUM", momentum: 0.38, n_interactions: 4 }, mode: "quality" },
+    { text: "help me debug this failing test", state: { sub_regime: "REFINING", resolution: "unresolved", continuity_state: "MEDIUM", momentum: 0.31, n_interactions: 4 }, mode: "quality" },
+    { text: "let's wrap this up and ship the final change", state: { sub_regime: "CONVERGING", resolution: "converging", continuity_state: "MEDIUM", momentum: 0.67, n_interactions: 8 }, mode: "quality" },
+    { text: "finalize the release and verify the patch before closing", state: { sub_regime: "CLOSED", resolution: "solved", continuity_state: "MEDIUM", momentum: 0.74, n_interactions: 9 }, mode: "quality" },
+    { text: "we are repeating the same solution again and again", state: { sub_regime: "LOOPING", resolution: "looping", continuity_state: "LOW", momentum: 0.12, loop_consecutive: 3, is_looping: true, n_interactions: 6 }, mode: "speed" },
+    { text: "why does this keep looping?", state: { sub_regime: "LOOPING", resolution: "looping", continuity_state: "LOW", momentum: 0.09, loop_consecutive: 2, is_looping: true, n_interactions: 5 }, mode: "speed" },
+    { text: "we already tried that, give me a shorter path", state: { sub_regime: "LOOPING", resolution: "looping", continuity_state: "LOW", momentum: 0.11, loop_consecutive: 4, is_looping: true, n_interactions: 7 }, mode: "speed" },
+    { text: "I need a complete investigation with careful reasoning", state: { sub_regime: "RESEARCH", resolution: "unresolved", continuity_state: "HIGH", momentum: 0.24, n_interactions: 5 }, mode: "longrun" },
+    { text: "research the right documentation and compare the API behavior", state: { sub_regime: "RESEARCH", resolution: "unresolved", continuity_state: "HIGH", momentum: 0.22, n_interactions: 5 }, mode: "longrun" },
+    { text: "trace the issue and gather evidence from the logs", state: { sub_regime: "RESEARCH", resolution: "unresolved", continuity_state: "HIGH", momentum: 0.27, n_interactions: 6 }, mode: "longrun" },
+  ]
+  return scenarios.map((scenario) => ({
+    features: buildFeatureVector(scenario.text, { state: scenario.state }),
+    label: scenario.mode,
+    source: "bootstrap",
+  }))
+}
+
+function expandSyntheticSamples(baseSamples, seed = 42, repeats = 4) {
+  const variants = []
+  const rng = createRng(seed)
+  const prefixes = [
+    "",
+    "please ",
+    "can you ",
+    "we need to ",
+    "now ",
+  ]
+  const suffixes = [
+    "",
+    " with the same intent",
+    " and keep the scope narrow",
+    " without changing unrelated files",
+    " with a careful review",
+  ]
+  const actionHints = {
+    budget: ["quickly", "briefly", "lightweight", "simple"],
+    audit: ["inspect", "review", "check", "list"],
+    quality: ["carefully", "thoroughly", "fix", "validate"],
+    speed: ["fast", "short", "concise", "minimal"],
+    longrun: ["investigate", "analyze", "research", "trace"],
+  }
+
+  for (const sample of baseSamples) {
+    variants.push(sample)
+    const state = sample.state || {}
+    const label = sample.label
+    const hints = actionHints[label] || ["review"]
+    for (let i = 0; i < repeats; i++) {
+      const prefix = prefixes[Math.floor(rng() * prefixes.length)]
+      const suffix = suffixes[Math.floor(rng() * suffixes.length)]
+      const hint = hints[Math.floor(rng() * hints.length)]
+      const text = `${prefix}${hint} the task${suffix}`.trim()
+      const syntheticState = {
+        ...state,
+        momentum: clamp(num(state.momentum) + (rng() - 0.5) * 0.08, 0, 1),
+        n_interactions: Math.max(1, Math.round(num(state.n_interactions || 1) + (rng() - 0.5) * 2)),
+        loop_consecutive: Math.max(0, Math.round(num(state.loop_consecutive || 0) + (rng() - 0.5) * 2)),
+      }
+      if (label === "speed") {
+        syntheticState.is_looping = true
+        syntheticState.resolution = "looping"
+        syntheticState.continuity_state = "LOW"
+      } else if (label === "quality") {
+        syntheticState.resolution = "converging"
+        syntheticState.continuity_state = "MEDIUM"
+      } else if (label === "longrun") {
+        syntheticState.resolution = "unresolved"
+        syntheticState.continuity_state = "HIGH"
+      }
+      variants.push({
+        features: buildFeatureVector(text, { state: syntheticState }),
+        label,
+        source: "synthetic",
+      })
+    }
+  }
+  return variants
+}
+
+function splitMetricsBySource(model, samples) {
+  const grouped = {}
+  for (const sample of samples) {
+    const source = sample.source || "unknown"
+    if (!grouped[source]) {
+      grouped[source] = { total: 0, correct: 0 }
+    }
+    const pred = predictBlackboxRoutingModel(model, sample.features)
+    grouped[source].total++
+    if (pred.label === sample.label) grouped[source].correct++
+  }
+  const out = {}
+  for (const [source, bucket] of Object.entries(grouped)) {
+    out[source] = {
+      accuracy: bucket.total > 0 ? bucket.correct / bucket.total : 0,
+      samples: bucket.total,
+    }
+  }
+  return out
+}
+
+function loadJson(filePath) {
+  try {
+    if (!existsSync(filePath)) return null
+    return JSON.parse(readFileSync(filePath, "utf-8"))
+  } catch {
+    return null
+  }
+}
+
+function saveJson(filePath, data) {
+  ensureModelDir()
+  const tmp = `${filePath}.tmp.${Date.now()}`
+  writeFileSync(tmp, JSON.stringify(data, null, 2) + "\n")
+  renameSync(tmp, filePath)
+}
+
+function gini(counts) {
+  const total = counts.reduce((a, b) => a + b, 0)
+  if (total <= 0) return 0
+  let sum = 0
+  for (const c of counts) {
+    const p = c / total
+    sum += p * p
+  }
+  return 1 - sum
+}
+
+function majorityLabel(samples, classes) {
+  const counts = new Array(classes.length).fill(0)
+  for (const sample of samples) {
+    const idx = classes.indexOf(sample.label)
+    if (idx >= 0) counts[idx]++
+  }
+  let best = 0
+  for (let i = 1; i < counts.length; i++) {
+    if (counts[i] > counts[best]) best = i
+  }
+  return classes[best] || classes[0] || "budget"
+}
+
+function classCounts(samples, classes) {
+  const counts = new Array(classes.length).fill(0)
+  for (const sample of samples) {
+    const idx = classes.indexOf(sample.label)
+    if (idx >= 0) counts[idx]++
+  }
+  return counts
+}
+
+function pickFeatureSubset(featureCount, subsetSize, rng) {
+  const indices = [...Array(featureCount).keys()]
+  shuffleInPlace(indices, rng)
+  return indices.slice(0, Math.max(1, Math.min(subsetSize, featureCount)))
+}
+
+function bestSplit(samples, featureIndices, classes) {
+  const parentCounts = classCounts(samples, classes)
+  const parentGini = gini(parentCounts)
+  let best = null
+  for (const featureIndex of featureIndices) {
+    const sorted = samples
+      .map((sample) => ({ value: num(sample.features[featureIndex]), label: sample.label, sample }))
+      .filter((row) => Number.isFinite(row.value))
+      .sort((a, b) => a.value - b.value)
+    if (sorted.length < 2) continue
+    const leftCounts = new Array(classes.length).fill(0)
+    const rightCounts = parentCounts.slice()
+    for (let i = 0; i < sorted.length - 1; i++) {
+      const current = sorted[i]
+      const classIndex = classes.indexOf(current.label)
+      if (classIndex >= 0) {
+        leftCounts[classIndex]++
+        rightCounts[classIndex]--
+      }
+      if (sorted[i].value === sorted[i + 1].value) continue
+      const leftSize = i + 1
+      const rightSize = sorted.length - leftSize
+      if (leftSize < DEFAULT_MIN_SAMPLES_LEAF || rightSize < DEFAULT_MIN_SAMPLES_LEAF) continue
+      const threshold = (sorted[i].value + sorted[i + 1].value) / 2
+      const leftGini = gini(leftCounts)
+      const rightGini = gini(rightCounts)
+      const weighted = (leftSize / sorted.length) * leftGini + (rightSize / sorted.length) * rightGini
+      const gain = parentGini - weighted
+      if (!best || gain > best.gain) {
+        best = {
+          gain,
+          featureIndex,
+          threshold,
+          leftLabels: leftCounts.slice(),
+          rightLabels: rightCounts.slice(),
+        }
+      }
+    }
+  }
+  return best
+}
+
+function buildTree(samples, classes, rng, depth = 0, options = {}) {
+  const maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH
+  const minSamplesSplit = options.minSamplesSplit ?? DEFAULT_MIN_SAMPLES_SPLIT
+  const minSamplesLeaf = options.minSamplesLeaf ?? DEFAULT_MIN_SAMPLES_LEAF
+  const featureSubsample = options.featureSubsample ?? DEFAULT_FEATURE_SUBSAMPLE
+  const counts = classCounts(samples, classes)
+  const label = majorityLabel(samples, classes)
+  const total = samples.length
+  const isPure = counts.some((c) => c === total)
+  if (depth >= maxDepth || total < minSamplesSplit || isPure) {
+    return { leaf: true, label, counts }
+  }
+  const features = pickFeatureSubset(samples[0].features.length, featureSubsample, rng)
+  const split = bestSplit(samples, features, classes)
+  if (!split || split.gain <= 1e-8) {
+    return { leaf: true, label, counts }
+  }
+  const left = []
+  const right = []
+  for (const sample of samples) {
+    const value = num(sample.features[split.featureIndex])
+    if (value <= split.threshold) left.push(sample)
+    else right.push(sample)
+  }
+  if (left.length < minSamplesLeaf || right.length < minSamplesLeaf) {
+    return { leaf: true, label, counts }
+  }
+  return {
+    leaf: false,
+    label,
+    counts,
+    featureIndex: split.featureIndex,
+    threshold: split.threshold,
+    left: buildTree(left, classes, rng, depth + 1, options),
+    right: buildTree(right, classes, rng, depth + 1, options),
+  }
+}
+
+function predictTree(tree, features, classes) {
+  let node = tree
+  while (!node.leaf) {
+    const value = num(features[node.featureIndex])
+    node = value <= node.threshold ? node.left : node.right
+    if (!node) break
+  }
+  const counts = node?.counts || new Array(classes.length).fill(0)
+  const total = counts.reduce((a, b) => a + b, 0)
+  const probs = counts.map((c) => (total > 0 ? c / total : 1 / classes.length))
+  let bestIndex = 0
+  for (let i = 1; i < probs.length; i++) {
+    if (probs[i] > probs[bestIndex]) bestIndex = i
+  }
+  return { label: classes[bestIndex] || classes[0] || "budget", probs }
+}
+
+function toClassLabel(mode) {
+  const normalized = String(mode || "").toLowerCase()
+  if (MODE_CLASSES.includes(normalized)) return normalized
+  return "budget"
+}
+
+function deriveLabelFromState(state, stress) {
+  return toClassLabel(autoSelectMode(state?.sub_regime || "INIT", stress))
+}
+
+function deriveLabelFromTelemetry(telemetry, state, stress) {
+  const candidates = [
+    telemetry?.selection?.optimization_mode,
+    telemetry?.optimization_mode,
+    telemetry?.control_vector?.optimization_mode,
+    telemetry?.selected_mode,
+    telemetry?.mode,
+    telemetry?.label,
+  ]
+  for (const candidate of candidates) {
+    const normalized = String(candidate || "").toLowerCase()
+    if (!normalized || normalized === "auto") continue
+    if (MODE_CLASSES.includes(normalized)) {
+      return toClassLabel(normalized)
+    }
+  }
+  return deriveLabelFromState(state, stress)
+}
+
+function deriveSamplesFromSessionRow(row) {
+  const parsed = loadJsonSafe(row.state_json)
+  if (!parsed || !Array.isArray(parsed.history)) return []
+  const replay = new ResolutionTracker(row.session_id || "session", parsed.maxHistory || 50)
+  const samples = []
+  for (const entry of parsed.history) {
+    const text = String(entry?.text || "")
+    const features = entry?.features && typeof entry.features === "object" && !Array.isArray(entry.features)
+      ? entry.features
+      : extractFeatures(text)
+    const state = replay.update({
+      userText: text,
+      features,
+      action: entry?.action || "explore",
+      entropy: num(entry?.entropy, 1.0),
+      uncertainty: num(entry?.uncertainty, 50),
+      embedding: entry?.embedding || null,
+    })
+    const telemetry = entry?.telemetry || parsed.telemetry || null
+    const stress = scoreStress(text)
+    samples.push({
+      features: buildFeatureVector(text, { state, prompt_features: features, stress }),
+      label: deriveLabelFromTelemetry(telemetry, state, stress),
+      source: "db",
+    })
+  }
+  return samples
+}
+
+export function extractRoutingFeatures(input = {}) {
+  const text = String(input.user_text || input.prompt || "")
+  const features = buildFeatureVector(text, {
+    state: input.state || input,
+    prompt_features: input.features || input.prompt_features || {},
+    stress: input.stress_multiplier ?? input.stress_score ?? input.stress ?? scoreStress(text),
+  })
+  return features
+}
+
+function evaluateModel(model, samples) {
+  if (!samples.length) {
+    return { accuracy: 0, per_class_accuracy: {}, samples: 0, baseline_accuracy: 0 }
+  }
+  let correct = 0
+  const classTotals = Object.fromEntries(model.classes.map((c) => [c, 0]))
+  const classCorrect = Object.fromEntries(model.classes.map((c) => [c, 0]))
+  const majority = model.classes.reduce((best, cls) => (model.classCounts?.[cls] || 0) > (model.classCounts?.[best] || 0) ? cls : best, model.classes[0] || "budget")
+  let baselineCorrect = 0
+  for (const sample of samples) {
+    const pred = predictBlackboxRoutingModel(model, sample.features)
+    if (pred.label === sample.label) {
+      correct++
+      classCorrect[sample.label] = (classCorrect[sample.label] || 0) + 1
+    }
+    classTotals[sample.label] = (classTotals[sample.label] || 0) + 1
+    if (majority === sample.label) baselineCorrect++
+  }
+  const perClassAccuracy = {}
+  for (const cls of model.classes) {
+    perClassAccuracy[cls] = classTotals[cls] ? classCorrect[cls] / classTotals[cls] : 0
+  }
+  return {
+    accuracy: correct / samples.length,
+    per_class_accuracy: perClassAccuracy,
+    samples: samples.length,
+    baseline_accuracy: baselineCorrect / samples.length,
+  }
+}
+
+function trainRandomForestModel(samples, classes, options = {}, labelMapper = (label) => label) {
+  const valid = (Array.isArray(samples) ? samples : [])
+    .filter((sample) => sample && Array.isArray(sample.features) && sample.features.length > 0)
+    .map((sample) => ({
+      features: sample.features.map((v) => num(v)),
+      label: labelMapper(sample.label),
+      source: sample.source || "unknown",
+    }))
+    .filter((sample) => classes.includes(sample.label))
+
+  const rng = createRng(options.seed ?? 42)
+  const shuffled = shuffleInPlace(valid.slice(), rng)
+  const holdoutSize = Math.max(1, Math.floor(shuffled.length * 0.2))
+  const holdout = shuffled.slice(0, holdoutSize)
+  const train = shuffled.slice(holdoutSize)
+  const trees = []
+  const treeCount = options.treeCount ?? DEFAULT_TREE_COUNT
+  const maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH
+  const minSamplesSplit = options.minSamplesSplit ?? DEFAULT_MIN_SAMPLES_SPLIT
+  const minSamplesLeaf = options.minSamplesLeaf ?? DEFAULT_MIN_SAMPLES_LEAF
+  const featureSubsample = options.featureSubsample ?? DEFAULT_FEATURE_SUBSAMPLE
+
+  if (!train.length) {
+    return {
+      trained: false,
+      reason: "insufficient training samples",
+      classes,
+      feature_names: [],
+      trees: [],
+      accuracy: 0,
+      per_class_accuracy: {},
+      samples: 0,
+      baseline_accuracy: 0,
+    }
+  }
+
+  const sourceCounts = valid.reduce((acc, sample) => {
+    acc[sample.source] = (acc[sample.source] || 0) + 1
+    return acc
+  }, {})
+
+  for (let i = 0; i < treeCount; i++) {
+    const treeRng = createRng((options.seed ?? 42) + i * 97 + 1)
+    const bootstrap = []
+    for (let j = 0; j < train.length; j++) {
+      bootstrap.push(train[Math.floor(treeRng() * train.length)])
+    }
+    trees.push(buildTree(bootstrap, classes, treeRng, 0, { maxDepth, minSamplesSplit, minSamplesLeaf, featureSubsample }))
+  }
+
+  const model = {
+    version: 1,
+    trained: true,
+    trained_at: new Date().toISOString(),
+    classes,
+    feature_names: [
+      "length",
+      "word_count",
+      "sentence_count",
+      "avg_word_length",
+      "question_ratio",
+      "code_blocks",
+      "urgency",
+      "repetition",
+      "sentiment",
+      "complexity",
+      "instruction_density",
+      "file_mentions",
+      "error_signals",
+      "action_density",
+      "complexity_words",
+      "stress",
+      "momentum",
+      "action_consistency",
+      "entropy_trend",
+      "feature_contradiction",
+      "embedding_delta",
+      "pivot_score",
+      "n_interactions",
+      "loop_consecutive",
+      "sub_regime",
+      "resolution",
+      "continuity_state",
+      "loop_intervention_level",
+      "is_looping",
+      "outcome",
+    ],
+    params: {
+      tree_count: treeCount,
+      max_depth: maxDepth,
+      min_samples_split: minSamplesSplit,
+      min_samples_leaf: minSamplesLeaf,
+      feature_subsample: featureSubsample,
+      confidence_threshold: options.confidenceThreshold ?? DEFAULT_CONFIDENCE_THRESHOLD,
+      seed: options.seed ?? 42,
+    },
+    trees,
+    classCounts: Object.fromEntries(classes.map((cls) => [cls, 0])),
+  }
+
+  for (const sample of train) {
+    model.classCounts[sample.label] = (model.classCounts[sample.label] || 0) + 1
+  }
+
+  const metrics = evaluateModel(model, holdout)
+  model.metrics = {
+    ...metrics,
+    holdout_accuracy_by_source: splitMetricsBySource(model, holdout),
+    holdout_samples: holdout.length,
+    train_samples: train.length,
+    total_samples: valid.length,
+    source_counts: sourceCounts,
+  }
+  return model
+}
+
+export function trainBlackboxRoutingModel(samples, options = {}) {
+  return trainRandomForestModel(samples, [...MODE_CLASSES], options, (label) => toClassLabel(label))
+}
+
+export function trainModeGateModel(samples, targetMode, options = {}) {
+  const positive = normalizeGateMode(targetMode)
+  const classes = [positive || "target", "other"]
+  return trainRandomForestModel(samples, classes, options, (label) => (normalizeGateMode(label) === positive ? positive : "other"))
+}
+
+export function predictBlackboxRoutingModel(model, features) {
+  if (!model || !Array.isArray(model.trees) || model.trees.length === 0) {
+    return { label: "budget", confidence: 0, probabilities: { budget: 1 }, source: "fallback" }
+  }
+  const vector = Array.isArray(features) ? features.map((v) => num(v)) : extractRoutingFeatures(features)
+  const votes = Object.fromEntries(model.classes.map((cls) => [cls, 0]))
+  for (const tree of model.trees) {
+    const pred = predictTree(tree, vector, model.classes)
+    for (let i = 0; i < model.classes.length; i++) {
+      const cls = model.classes[i]
+      votes[cls] += pred.probs[i] || 0
+    }
+  }
+  const probabilities = {}
+  let bestClass = model.classes[0] || "budget"
+  let bestProb = -1
+  for (const cls of model.classes) {
+    const prob = votes[cls] / model.trees.length
+    probabilities[cls] = prob
+    if (prob > bestProb) {
+      bestProb = prob
+      bestClass = cls
+    }
+  }
+  return {
+    label: bestClass,
+    confidence: clamp(bestProb, 0, 1),
+    probabilities,
+    source: "random_forest",
+  }
+}
+
+export function loadBlackboxRoutingModel({ refresh = false } = {}) {
+  if (!refresh && cachedModel) return cachedModel
+  const loaded = loadJson(MODEL_PATH)
+  if (loaded && loaded.trained && Array.isArray(loaded.trees)) {
+    cachedModel = loaded
+    return cachedModel
+  }
+  return null
+}
+
+export function loadModeGateModel(targetMode, { refresh = false } = {}) {
+  const gateMode = normalizeGateMode(targetMode)
+  if (!gateMode) return null
+  if (!refresh && cachedGateModels.has(gateMode)) return cachedGateModels.get(gateMode)
+  const loaded = loadJson(getModeGatePath(gateMode))
+  if (loaded && loaded.trained && Array.isArray(loaded.trees)) {
+    cachedGateModels.set(gateMode, loaded)
+    return loaded
+  }
+  return null
+}
+
+export function selectModeGate(targetMode, input = {}) {
+  const gateMode = normalizeGateMode(targetMode)
+  if (!gateMode) return null
+
+  const stress = num(input.stress_multiplier ?? input.stress_score ?? input.stress ?? 0)
+  const state = {
+    sub_regime: String(input.sub_regime || input.state?.sub_regime || "INIT").toUpperCase(),
+    resolution: input.resolution || input.resolution_state || input.state?.resolution || null,
+    continuity_state: input.continuity_state || input.state?.continuity_state || null,
+    loop_intervention_level: input.loop_intervention_level || input.state?.loop_intervention_level || null,
+    momentum: num(input.momentum ?? input.state?.momentum ?? 0),
+    n_interactions: num(input.n_interactions ?? input.turn_count ?? input.state?.n_interactions ?? 0),
+    loop_consecutive: num(input.loop_consecutive ?? input.loop_count ?? input.state?.loop_consecutive ?? 0),
+    pivot_score: num(input.pivot_score ?? input.state?.pivot_score ?? 0),
+    is_looping: Boolean(input.is_looping ?? input.state?.is_looping ?? false),
+    outcome: input.outcome || input.state?.outcome || null,
+    signals: input.state?.signals || input.signals || {},
+    user_text: String(input.user_text || input.prompt || input.state?.user_text || ""),
+    prompt: String(input.user_text || input.prompt || input.state?.prompt || ""),
+  }
+  const prompt = String(input.user_text || input.prompt || "")
+  const features = Array.isArray(input.features)
+    ? input.features
+    : extractRoutingFeatures({
+        user_text: prompt,
+        prompt,
+        stress_multiplier: stress,
+        state,
+        features: input.features || input.prompt_features || {},
+      })
+  const model = loadModeGateModel(gateMode)
+  if (!model) return null
+
+  const prediction = predictBlackboxRoutingModel(model, features)
+  const confidenceThreshold = model.params?.confidence_threshold ?? DEFAULT_CONFIDENCE_THRESHOLD
+  if (!prediction || prediction.label !== gateMode || prediction.confidence < confidenceThreshold) {
+    return null
+  }
+
+  return {
+    mode: gateMode,
+    source: "mode_gate",
+    confidence: prediction.confidence,
+    probabilities: prediction.probabilities,
+    prediction,
+    model: getModeGateModelMeta(gateMode),
+    features,
+  }
+}
+
+export function getBlackboxRoutingModelMeta() {
+  const model = loadBlackboxRoutingModel()
+  if (!model) {
+    return {
+      available: false,
+      trained: false,
+      path: MODEL_PATH,
+      message: "no routing model saved yet",
+      confidence_threshold: DEFAULT_CONFIDENCE_THRESHOLD,
+    }
+  }
+  return {
+    available: true,
+    trained: true,
+    path: MODEL_PATH,
+    trained_at: model.trained_at,
+    classes: model.classes,
+    metrics: model.metrics || {},
+    params: model.params || {},
+    confidence_threshold: model.params?.confidence_threshold ?? DEFAULT_CONFIDENCE_THRESHOLD,
+  }
+}
+
+export function getModeGateModelMeta(targetMode) {
+  const gateMode = normalizeGateMode(targetMode)
+  const model = loadModeGateModel(gateMode)
+  const path = getModeGatePath(gateMode)
+  if (!model) {
+    return {
+      available: false,
+      trained: false,
+      path,
+      target_mode: gateMode,
+      message: `no ${gateMode || "mode"} gate model saved yet`,
+      confidence_threshold: DEFAULT_CONFIDENCE_THRESHOLD,
+    }
+  }
+  return {
+    available: true,
+    trained: true,
+    path,
+    target_mode: gateMode,
+    trained_at: model.trained_at,
+    classes: model.classes,
+    metrics: model.metrics || {},
+    params: model.params || {},
+    confidence_threshold: model.params?.confidence_threshold ?? DEFAULT_CONFIDENCE_THRESHOLD,
+  }
+}
+
+export function saveBlackboxRoutingModel(model) {
+  ensureModelDir()
+  const payload = {
+    ...model,
+    saved_at: new Date().toISOString(),
+  }
+  writeFileSync(MODEL_PATH, JSON.stringify(payload, null, 2) + "\n", "utf-8")
+  cachedModel = payload
+  return payload
+}
+
+export function saveModeGateModel(model, targetMode) {
+  const gateMode = normalizeGateMode(targetMode)
+  ensureModeGateDir(gateMode)
+  const payload = {
+    ...model,
+    saved_at: new Date().toISOString(),
+    target_mode: gateMode,
+  }
+  writeFileSync(getModeGatePath(gateMode), JSON.stringify(payload, null, 2) + "\n", "utf-8")
+  cachedGateModels.set(gateMode, payload)
+  return payload
+}
+
+export function buildBlackboxRoutingSamplesFromDb({ projectId = null, limit = 5000 } = {}) {
+  const db = getDb()
+  let rows
+  if (projectId) {
+    rows = db.prepare(
+      "SELECT session_id, project_id, state_json FROM blackbox_sessions WHERE project_id = ? ORDER BY updated_at DESC LIMIT ?"
+    ).all(projectId, limit)
+  } else {
+    rows = db.prepare(
+      "SELECT session_id, project_id, state_json FROM blackbox_sessions ORDER BY updated_at DESC LIMIT ?"
+    ).all(limit)
+  }
+  const samples = []
+  for (const row of rows) {
+    samples.push(...deriveSamplesFromSessionRow(row))
+  }
+  return samples
+}
+
+export function rebuildBlackboxRoutingModel({ projectId = null, limit = 5000, includeBootstrap = true, seed = 42, treeCount = DEFAULT_TREE_COUNT, maxDepth = DEFAULT_MAX_DEPTH, minSamplesSplit = DEFAULT_MIN_SAMPLES_SPLIT, minSamplesLeaf = DEFAULT_MIN_SAMPLES_LEAF, featureSubsample = DEFAULT_FEATURE_SUBSAMPLE, confidenceThreshold = DEFAULT_CONFIDENCE_THRESHOLD } = {}) {
+  const dbSamples = buildBlackboxRoutingSamplesFromDb({ projectId, limit })
+  const bootstrap = includeBootstrap ? expandSyntheticSamples(bootstrapSamples(), seed) : []
+  const samples = dbSamples.concat(bootstrap)
+  const model = trainBlackboxRoutingModel(samples, {
+    seed,
+    treeCount,
+    maxDepth,
+    minSamplesSplit,
+    minSamplesLeaf,
+    featureSubsample,
+    confidenceThreshold,
+  })
+  if (!model.trained) {
+    return {
+      ok: false,
+      model,
+      samples: samples.length,
+      path: MODEL_PATH,
+      message: model.reason || "training failed",
+    }
+  }
+  const saved = saveBlackboxRoutingModel(model)
+  return {
+    ok: true,
+    model: saved,
+    samples: samples.length,
+    synthetic_samples: bootstrap.length,
+    production_samples: dbSamples.length,
+    path: MODEL_PATH,
+    accuracy: model.metrics?.accuracy ?? 0,
+    baseline_accuracy: model.metrics?.baseline_accuracy ?? 0,
+    source_counts: model.metrics?.source_counts || {},
+    holdout_accuracy_by_source: model.metrics?.holdout_accuracy_by_source || {},
+  }
+}
+
+export function rebuildModeGateModel({ targetMode, projectId = null, limit = 5000, includeBootstrap = true, seed = 42, treeCount = DEFAULT_TREE_COUNT, maxDepth = DEFAULT_MAX_DEPTH, minSamplesSplit = DEFAULT_MIN_SAMPLES_SPLIT, minSamplesLeaf = DEFAULT_MIN_SAMPLES_LEAF, featureSubsample = DEFAULT_FEATURE_SUBSAMPLE, confidenceThreshold = DEFAULT_CONFIDENCE_THRESHOLD } = {}) {
+  const gateMode = normalizeGateMode(targetMode)
+  if (!gateMode) {
+    return { ok: false, message: "targetMode is required", path: null, target_mode: null }
+  }
+  const dbSamples = buildBlackboxRoutingSamplesFromDb({ projectId, limit })
+  const bootstrap = includeBootstrap ? expandSyntheticSamples(bootstrapSamples(), seed) : []
+  const samples = dbSamples.concat(bootstrap)
+  const model = trainModeGateModel(samples, gateMode, {
+    seed,
+    treeCount,
+    maxDepth,
+    minSamplesSplit,
+    minSamplesLeaf,
+    featureSubsample,
+    confidenceThreshold,
+  })
+  if (!model.trained) {
+    return {
+      ok: false,
+      model,
+      samples: samples.length,
+      path: getModeGatePath(gateMode),
+      target_mode: gateMode,
+      message: model.reason || "training failed",
+    }
+  }
+  const saved = saveModeGateModel(model, gateMode)
+  return {
+    ok: true,
+    model: saved,
+    samples: samples.length,
+    synthetic_samples: bootstrap.length,
+    production_samples: dbSamples.length,
+    path: getModeGatePath(gateMode),
+    target_mode: gateMode,
+    accuracy: model.metrics?.accuracy ?? 0,
+    baseline_accuracy: model.metrics?.baseline_accuracy ?? 0,
+    source_counts: model.metrics?.source_counts || {},
+    holdout_accuracy_by_source: model.metrics?.holdout_accuracy_by_source || {},
+  }
+}
+
+export function selectBlackboxMode(input = {}) {
+  const stress = num(input.stress_multiplier ?? input.stress_score ?? input.stress ?? 0)
+  const state = {
+    sub_regime: String(input.sub_regime || "INIT").toUpperCase(),
+    resolution: input.resolution || input.resolution_state || null,
+    continuity_state: input.continuity_state || null,
+    loop_intervention_level: input.loop_intervention_level || null,
+    momentum: num(input.momentum ?? input.state?.momentum ?? 0),
+    n_interactions: num(input.n_interactions ?? input.turn_count ?? input.state?.n_interactions ?? 0),
+    loop_consecutive: num(input.loop_consecutive ?? input.loop_count ?? input.state?.loop_consecutive ?? 0),
+    pivot_score: num(input.pivot_score ?? input.state?.pivot_score ?? 0),
+    is_looping: Boolean(input.is_looping ?? input.state?.is_looping ?? false),
+    outcome: input.outcome || null,
+    signals: input.state?.signals || input.signals || {},
+    user_text: String(input.user_text || input.prompt || ""),
+    prompt: String(input.user_text || input.prompt || ""),
+  }
+  const prompt = String(input.user_text || input.prompt || "")
+  const features = Array.isArray(input.features) ? input.features : buildFeatureVector(prompt, { state, prompt_features: input.features || input.prompt_features || {}, stress })
+  const recentSignals = loadRecentSessionSignals(input.project_id || null, input.session_id || null)
+  const heuristic = autoSelectMode(state.sub_regime || "INIT", stress, { state, recentSignals: recentSignals || undefined })
+  const budgetGate = selectModeGate("budget", { ...input, state, features })
+  if (budgetGate) {
+    return {
+      ...budgetGate,
+      model: getBlackboxRoutingModelMeta(),
+      gate_model: budgetGate.model,
+      features,
+    }
+  }
+  const model = loadBlackboxRoutingModel()
+  if (!model) {
+    return {
+      mode: heuristic,
+      source: "heuristic",
+      confidence: 0,
+      probabilities: {},
+      model: getBlackboxRoutingModelMeta(),
+      features,
+    }
+  }
+  const prediction = predictBlackboxRoutingModel(model, features)
+  const confidenceThreshold = model.params?.confidence_threshold ?? DEFAULT_CONFIDENCE_THRESHOLD
+  if (!prediction || prediction.confidence < confidenceThreshold) {
+    return {
+      mode: heuristic,
+      source: "heuristic",
+      confidence: prediction?.confidence ?? 0,
+      probabilities: prediction?.probabilities || {},
+      prediction,
+      model: getBlackboxRoutingModelMeta(),
+      features,
+    }
+  }
+  if (modePriority(prediction.label) < modePriority(heuristic)) {
+    return {
+      mode: heuristic,
+      source: "heuristic",
+      confidence: prediction.confidence,
+      probabilities: prediction.probabilities,
+      prediction,
+      model: getBlackboxRoutingModelMeta(),
+      features,
+    }
+  }
+  return {
+    mode: prediction.label,
+    source: "random_forest",
+    confidence: prediction.confidence,
+    probabilities: prediction.probabilities,
+    model: getBlackboxRoutingModelMeta(),
+    features,
+  }
+}
+
+export function resetBlackboxRoutingModelCache() {
+  cachedModel = null
+  cachedGateModels.clear()
+}