vibeoscore 1.0.2 → 1.0.9

package/lib/blackbox-rf.js

@@ -1,1099 +0,0 @@
-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()
-}