dual-brain 0.2.26 → 0.2.28

package/bin/dual-brain.mjs

@@ -1094,6 +1094,18 @@ async function cmdStatus(args = []) {
       }
     }
   } catch { /* network unavailable — skip */ }
+
+  // Show top recommendation if available
+  try {
+    const { getTopRecommendation } = await import('../src/recommendations.mjs');
+    const rec = getTopRecommendation(process.cwd());
+    if (rec) {
+      console.log('');
+      console.log(`  \x1b[33m💡 ${rec.title}\x1b[0m`);
+      console.log(`     ${rec.description}`);
+      if (rec.action) console.log(`     → ${rec.action}`);
+    }
+  } catch { /* non-blocking */ }
 }
 
 // ─── cmdHot / cmdCool ─────────────────────────────────────────────────────────
@@ -4215,6 +4227,30 @@ async function settingsScreen(rl, ask) {
     return { next: 'diagnostics' };
   }
 
+  // Intelligence settings (routing, think, strategies)
+  if (choice === 'i') {
+    try {
+      const { runSettings } = await import('../src/settings-tui.mjs');
+      await runSettings(cwd);
+    } catch (e) {
+      process.stdout.write(`  Intelligence settings unavailable: ${e.message}\n`);
+      await ask('  Press Enter to continue...');
+    }
+    return { next: 'settings' };
+  }
+
+  // Revert recent changes
+  if (choice === 'u') {
+    try {
+      const { runRevert } = await import('../src/revert.mjs');
+      await runRevert(cwd);
+    } catch (e) {
+      process.stdout.write(`  Revert unavailable: ${e.message}\n`);
+      await ask('  Press Enter to continue...');
+    }
+    return { next: 'settings' };
+  }
+
   if (choice === 'b' || choice === 'back' || raw === '\x1b') { return { next: 'main' }; }
 
   return { next: 'main' };
@@ -6532,6 +6568,18 @@ async function main() {
   }
 
   if (cmd === 'init') {
+    // init --reconfigure: run setup-flow reconfiguration
+    if (args.includes('--reconfigure')) {
+      try {
+        const { runSetup } = await import('../src/setup-flow.mjs');
+        await runSetup(process.cwd(), { reconfigure: true });
+      } catch (e) {
+        console.error('setup-flow.mjs not available — skipping reconfigure');
+        if (process.env.DEBUG) console.error(e.message);
+      }
+      return;
+    }
+
     // init --reset: clear credentials.json and re-run wizard
     if (args.includes('--reset')) {
       const cwd = process.cwd();
@@ -6593,6 +6641,40 @@ async function main() {
     return;
   }
 
+  if (cmd === 'setup') {
+    const { runSetup } = await import('../src/setup-flow.mjs');
+    await runSetup(process.cwd(), { reconfigure: args.includes('--reconfigure') });
+    return;
+  }
+
+  if (cmd === 'advice' || cmd === 'recommend') {
+    const { generateRecommendations, formatRecommendations } = await import('../src/recommendations.mjs');
+    const recs = generateRecommendations(process.cwd());
+    if (recs.length === 0) {
+      console.log('  No recommendations yet. Need 20+ dispatches to generate advice.');
+    } else {
+      console.log(formatRecommendations(recs));
+    }
+    return;
+  }
+
+  if (cmd === 'revert' || cmd === 'undo') {
+    const { runRevert } = await import('../src/revert.mjs');
+    await runRevert(process.cwd());
+    return;
+  }
+
+  if (cmd === 'strategies') {
+    const { listStrategies } = await import('../src/strategy.mjs');
+    const strats = listStrategies();
+    console.log('\n  Available dispatch strategies:\n');
+    for (const s of strats) {
+      console.log(`  ${s.id.padEnd(18)} ${s.description} (${s.cost}x cost)`);
+    }
+    console.log('');
+    return;
+  }
+
   // One-shot commands — run and exit
   if (cmd === 'install') {
     if (args.includes('--global')) { await installGlobal(); return; }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dual-brain",
-  "version": "0.2.26",
+  "version": "0.2.28",
   "description": "AI orchestration across Claude + OpenAI subscriptions — smart routing, budget awareness, and dual-brain collaboration",
   "type": "module",
   "bin": {
@@ -52,7 +52,12 @@
     "./routing-advisor": "./src/routing-advisor.mjs",
     "./subscription": "./src/subscription.mjs",
     "./recommendations": "./src/recommendations.mjs",
-    "./setup-flow": "./src/setup-flow.mjs"
+    "./setup-flow": "./src/setup-flow.mjs",
+    "./self-correct": "./src/self-correct.mjs",
+    "./settings-tui": "./src/settings-tui.mjs",
+    "./revert": "./src/revert.mjs",
+    "./strategy": "./src/strategy.mjs",
+    "./handoff": "./src/handoff.mjs"
   },
   "keywords": [
     "claude-code",
@@ -144,6 +149,11 @@
     "src/subscription.mjs",
     "src/recommendations.mjs",
     "src/setup-flow.mjs",
+    "src/self-correct.mjs",
+    "src/settings-tui.mjs",
+    "src/revert.mjs",
+    "src/strategy.mjs",
+    "src/handoff.mjs",
     "bin/*.mjs",
     "hooks/enforce-tier.mjs",
     "hooks/cost-logger.mjs",

package/src/decide.mjs

@@ -49,6 +49,28 @@ function _loadModelRegistry() {
 // Kick off the load immediately so it is ready before the first routing call.
 _loadModelRegistry();
 
+// ─── Routing Advisor (optional, lazy-loaded) ──────────────────────────────────
+
+/**
+ * Cached reference to routing-advisor.mjs exports. Populated on first import.
+ * Remains null if unavailable — decideRoute skips advisor consultation in that case.
+ */
+let routingAdvisor = null;
+let _advisorLoadAttempted = false;
+
+function _loadRoutingAdvisor() {
+  if (_advisorLoadAttempted) return;
+  _advisorLoadAttempted = true;
+  import('./routing-advisor.mjs').then(mod => {
+    routingAdvisor = mod;
+  }).catch(() => {
+    // routing-advisor.mjs unavailable — skip learned routing
+  });
+}
+
+// Kick off the load immediately so it is ready before the first routing call.
+_loadRoutingAdvisor();
+
 // ─── Work Styles ─────────────────────────────────────────────────────────────
 
 /**
@@ -890,6 +912,28 @@ export function decideRoute({ profile = {}, detection = {}, cwd, thinkResult, se
   // If the pipeline changed the model (downgrade/bias/floor), resolve the new short name to a full ID.
   model = toFullModelId(model, provider, tier);
 
+  // ── Routing advisor: consult learned EMA model for this task type ─────────
+  // Non-blocking: only overrides when advisor has enough observations (confidence > 0.3).
+  // Uses short model names; advisor only covers Claude models (haiku/sonnet/opus).
+  let _advisorOverride = null;
+  if (routingAdvisor && provider === 'claude') {
+    try {
+      const advice = routingAdvisor.adviseModel(
+        { intent: detection.intent, tier, risk: detection.risk },
+        cwd
+      );
+      if (advice.confidence > 0.3 && advice.model) {
+        const advisorShort = advice.model; // advisor returns short names
+        const previousModel = toShortName(model, 'claude');
+        if (advisorShort !== previousModel && available.claude.includes(advisorShort)) {
+          const overrideFullId = toFullModelId(advisorShort, 'claude', tier);
+          _advisorOverride = { from: model, to: overrideFullId, reason: advice.reason, explored: advice.explored };
+          model = overrideFullId;
+        }
+      }
+    } catch { /* non-blocking */ }
+  }
+
   // ── Challenger / dual-brain decision ─────────────────────────────────────
   const hasBothProviders = !!(
     profile?.providers?.claude?.enabled &&
@@ -938,6 +982,7 @@ export function decideRoute({ profile = {}, detection = {}, cwd, thinkResult, se
     explanation: '',
     _healthScores: healthScores,
     _workStyle: workStyle,
+    ...(_advisorOverride   && { _advisorOverride }),
   };
 
   decision.explanation = explainDecision(decision, detection, profileWithEffectiveBias);

package/src/dispatch.mjs

@@ -1181,6 +1181,29 @@ async function dispatch(input = {}) {
       const { recordDispatchOutcome } = await import('./outcome.mjs');
       recordDispatchOutcome(input, nativeResult);
     } catch { /* never block */ }
+
+    // ── Self-correction: intelligent retry after failover exhaustion ──────────
+    if (!success) {
+      const attemptNumber = input._retryAttempt || 1;
+      try {
+        const { shouldRetry } = await import('./self-correct.mjs');
+        const retry = shouldRetry(nativeResult, decision, attemptNumber);
+        if (retry.retry && retry.decision) {
+          if (verbose) process.stderr.write(`[dual-brain] self-correct: ${retry.strategy} (attempt ${attemptNumber + 1}, reason: ${retry.reason})\n`);
+          return dispatch({
+            ...input,
+            decision: retry.decision,
+            _retryAttempt: attemptNumber + 1,
+            _skipPreDispatchThink: retry.strategy !== 'rethink',
+            _skipRelatedContext: true,
+          });
+        } else if (verbose) {
+          process.stderr.write(`[dual-brain] self-correct: giving up (${retry.reason})\n`);
+        }
+      } catch { /* non-blocking — if self-correct fails, return original failure */ }
+    }
+    // ── End self-correction ───────────────────────────────────────────────────
+
     return nativeResult;
   }
 
@@ -1303,6 +1326,29 @@ async function dispatch(input = {}) {
     const { recordDispatchOutcome } = await import('./outcome.mjs');
     recordDispatchOutcome(input, subResult);
   } catch { /* never block */ }
+
+  // ── Self-correction: intelligent retry after failover exhaustion ──────────
+  if (!success) {
+    const attemptNumber = input._retryAttempt || 1;
+    try {
+      const { shouldRetry } = await import('./self-correct.mjs');
+      const retry = shouldRetry(subResult, decision, attemptNumber);
+      if (retry.retry && retry.decision) {
+        if (verbose) process.stderr.write(`[dual-brain] self-correct: ${retry.strategy} (attempt ${attemptNumber + 1}, reason: ${retry.reason})\n`);
+        return dispatch({
+          ...input,
+          decision: retry.decision,
+          _retryAttempt: attemptNumber + 1,
+          _skipPreDispatchThink: retry.strategy !== 'rethink',
+          _skipRelatedContext: true,
+        });
+      } else if (verbose) {
+        process.stderr.write(`[dual-brain] self-correct: giving up (${retry.reason})\n`);
+      }
+    } catch { /* non-blocking — if self-correct fails, return original failure */ }
+  }
+  // ── End self-correction ───────────────────────────────────────────────────
+
   return subResult;
 }
 

package/src/handoff.mjs

@@ -0,0 +1,85 @@
+// handoff.mjs — Typed handoffs between pipeline stages
+import { writeFileSync, readFileSync, existsSync, mkdirSync, renameSync, unlinkSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+export const HANDOFF_TYPES = {
+  'think-to-work':  { required: ['objective', 'files', 'criteria'], optional: ['context', 'confidence'] },
+  'work-to-review': { required: ['filesChanged', 'objective'],      optional: ['diff', 'criteria', 'testsRun'] },
+  'review-to-head': { required: ['pass'],                           optional: ['findings', 'recommendation', 'severity'] },
+};
+
+const hDir  = (cwd) => join(cwd || process.cwd(), '.dualbrain', 'handoffs');
+const hPath = (id, f, t, cwd) => join(hDir(cwd), `${id}_${f}_${t}.json`);
+
+function validate(from, to, data) {
+  const schema = HANDOFF_TYPES[`${from}-to-${to}`];
+  if (!schema) return;
+  for (const f of schema.required) {
+    if (!(f in data)) process.stderr.write(`[handoff] warn: missing required field '${f}' in ${from}-to-${to}\n`);
+  }
+}
+
+export function createHandoff(fromStage, toStage, data, runId, cwd) {
+  try {
+    validate(fromStage, toStage, data);
+    const dir = hDir(cwd);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    const record = { fromStage, toStage, runId, createdAt: new Date().toISOString(), data };
+    const dest = hPath(runId, fromStage, toStage, cwd); const tmp = dest + '.tmp';
+    writeFileSync(tmp, JSON.stringify(record, null, 2), 'utf8');
+    try { renameSync(tmp, dest); } catch { writeFileSync(dest, JSON.stringify(record, null, 2), 'utf8'); }
+    return record;
+  } catch { return null; }
+}
+
+export function consumeHandoff(runId, fromStage, toStage, cwd) {
+  try {
+    const p = hPath(runId, fromStage, toStage, cwd);
+    if (!existsSync(p)) return null;
+    const record = JSON.parse(readFileSync(p, 'utf8'));
+    try { unlinkSync(p); } catch { /* best-effort */ }
+    return record;
+  } catch { return null; }
+}
+
+export function buildHandoffContext(handoff, targetRole) {
+  if (!handoff?.data) return '';
+  const d = handoff.data;
+  const lines = (...parts) => parts.filter(Boolean).join('\n');
+  const list  = (v) => Array.isArray(v) ? v.join(', ') : (v ?? '');
+  const items = (v) => Array.isArray(v) ? v.map(x => `  - ${x}`).join('\n') : (v ?? '');
+
+  if (targetRole === 'worker' && handoff.fromStage === 'thinker') return lines(
+    '## Handoff from Think Stage',
+    `**Objective:** ${d.objective ?? '(none)'}`,
+    `**Files in scope:** ${list(d.files) || 'unspecified'}`,
+    d.criteria  ? `**Acceptance criteria:**\n${items(d.criteria)}` : '',
+    d.context   ? `**Context:** ${d.context}` : '',
+    d.confidence != null ? `**Thinker confidence:** ${d.confidence}` : '',
+  );
+  if (targetRole === 'reviewer' && handoff.fromStage === 'worker') return lines(
+    '## Handoff from Work Stage',
+    `**Objective:** ${d.objective ?? '(none)'}`,
+    `**Files changed:** ${list(d.filesChanged) || 'unknown'}`,
+    d.criteria ? `**Original criteria:** ${Array.isArray(d.criteria) ? d.criteria.join('; ') : d.criteria}` : '',
+    d.testsRun ? `**Tests run:** ${d.testsRun}` : '',
+    d.diff     ? `**Diff summary:**\n\`\`\`\n${d.diff.slice(0, 1200)}\n\`\`\`` : '',
+  );
+  if (targetRole === 'head' && handoff.fromStage === 'reviewer') return lines(
+    `## Review Result: ${d.pass ? 'PASS' : 'FAIL'}`,
+    d.findings       ? `**Findings:**\n${items(d.findings)}` : '',
+    d.recommendation ? `**Recommendation:** ${d.recommendation}` : '',
+    d.severity       ? `**Severity:** ${d.severity}` : '',
+  );
+  return JSON.stringify(handoff.data, null, 2);
+}
+
+export function cleanupHandoffs(runId, cwd) {
+  try {
+    const dir = hDir(cwd);
+    if (!existsSync(dir)) return;
+    for (const name of readdirSync(dir)) {
+      if (name.startsWith(`${runId}_`)) try { unlinkSync(join(dir, name)); } catch { /* best-effort */ }
+    }
+  } catch { /* non-throwing */ }
+}

package/src/outcome.mjs

@@ -45,6 +45,16 @@ function last7DaysFiles(cwd) {
   return files;
 }
 
+const INTENT_KEYWORDS = ['implement', 'fix', 'refactor', 'review', 'search', 'test'];
+
+function deriveIntent(prompt, tier) {
+  const lower = (prompt ?? '').toLowerCase();
+  for (const kw of INTENT_KEYWORDS) {
+    if (lower.includes(kw)) return kw;
+  }
+  return tier ?? 'execute';
+}
+
 export function recordDispatchOutcome(dispatchInput, result) {
   try {
     const cwd = dispatchInput.cwd ?? process.cwd();
@@ -69,6 +79,24 @@ export function recordDispatchOutcome(dispatchInput, result) {
 
     const filePath = join(outcomesDir(cwd), `outcome_${id}.json`);
     writeFileSync(filePath, JSON.stringify(record, null, 2), 'utf8');
+
+    // Score the outcome for the routing advisor (non-blocking)
+    try {
+      import('./signal.mjs').then(({ scoreOutcome }) =>
+        import('./routing-advisor.mjs').then(({ recordReward }) => {
+          const scored = scoreOutcome(record);
+          const intent = deriveIntent(record.prompt, record.tier);
+          const cellKey = `${record.tier}:${intent}`;
+          // Normalize full model ID to short name for the advisor cell
+          const modelId = record.model ?? 'sonnet';
+          const shortModel = /haiku/i.test(modelId) ? 'haiku'
+            : /opus/i.test(modelId) ? 'opus'
+            : 'sonnet';
+          recordReward(cellKey, shortModel, scored.reward, cwd);
+        })
+      ).catch(() => { /* non-blocking */ });
+    } catch { /* non-blocking */ }
+
     return record;
   } catch {
     return null;

package/src/revert.mjs

@@ -0,0 +1,149 @@
+// revert.mjs — Undo recent auto-adjustments and applied recommendations
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { createInterface } from 'node:readline';
+
+function dbDir(cwd) { return join(cwd || process.cwd(), '.dualbrain'); }
+function changesPath(cwd) { return join(dbDir(cwd), 'changes.jsonl'); }
+function configPath(cwd) { return join(dbDir(cwd), 'config.json'); }
+
+function genId() { return 'chg_' + Math.random().toString(36).slice(2, 9); }
+
+function readChanges(cwd) {
+  try {
+    if (!existsSync(changesPath(cwd))) return [];
+    return readFileSync(changesPath(cwd), 'utf8')
+      .split('\n').filter(Boolean).map(l => JSON.parse(l));
+  } catch { return []; }
+}
+
+function writeChanges(records, cwd) {
+  try {
+    mkdirSync(dbDir(cwd), { recursive: true });
+    writeFileSync(changesPath(cwd), records.map(r => JSON.stringify(r)).join('\n') + '\n');
+  } catch {}
+}
+
+function applyRevert(changeRecord, cwd) {
+  let config = {};
+  try { config = JSON.parse(readFileSync(configPath(cwd), 'utf8')); } catch {}
+  Object.assign(config, changeRecord.previousValue);
+  writeFileSync(configPath(cwd), JSON.stringify(config, null, 2) + '\n');
+}
+
+function relativeTime(iso) {
+  const diff = Date.now() - new Date(iso).getTime();
+  const m = Math.floor(diff / 60000);
+  if (m < 60) return `${m}m ago`;
+  const h = Math.floor(m / 60);
+  if (h < 24) return `${h}h ago`;
+  return `${Math.floor(h / 24)}d ago`;
+}
+
+export function formatChange(change) {
+  const badge = change.type === 'auto' ? '(auto)' : change.type === 'recommendation' ? '(rec)' : '(manual)';
+  return `${relativeTime(change.timestamp).padEnd(8)} ${change.description}  ${badge}`;
+}
+
+export function recordChange({ type, category, description, previousValue, newValue }, cwd) {
+  try {
+    mkdirSync(dbDir(cwd), { recursive: true });
+    const record = {
+      id: genId(),
+      timestamp: new Date().toISOString(),
+      type, category, description, previousValue, newValue,
+      reverted: false,
+    };
+    writeFileSync(changesPath(cwd), JSON.stringify(record) + '\n', { flag: 'a' });
+    return record;
+  } catch { return null; }
+}
+
+export function getRecentChanges(cwd, limit = 10) {
+  try {
+    return readChanges(cwd)
+      .filter(r => !r.reverted)
+      .reverse()
+      .slice(0, limit);
+  } catch { return []; }
+}
+
+export function revertChange(changeId, cwd) {
+  try {
+    const records = readChanges(cwd);
+    const idx = records.findIndex(r => r.id === changeId);
+    if (idx === -1) return { success: false, description: 'Change not found' };
+    const record = records[idx];
+    if (record.reverted) return { success: false, description: 'Already reverted' };
+    applyRevert(record, cwd);
+    records[idx] = { ...record, reverted: true };
+    writeChanges(records, cwd);
+    return { success: true, description: record.description };
+  } catch (e) { return { success: false, description: e.message }; }
+}
+
+export function revertAll(since, cwd) {
+  try {
+    const records = readChanges(cwd);
+    const cutoff = since ? new Date(since).getTime() : 0;
+    let count = 0;
+    for (let i = 0; i < records.length; i++) {
+      const r = records[i];
+      if (!r.reverted && new Date(r.timestamp).getTime() >= cutoff) {
+        applyRevert(r, cwd);
+        records[i] = { ...r, reverted: true };
+        count++;
+      }
+    }
+    writeChanges(records, cwd);
+    return { success: true, count };
+  } catch (e) { return { success: false, count: 0, error: e.message }; }
+}
+
+export async function runRevert(cwd) {
+  const changes = getRecentChanges(cwd, 10);
+  const W = 59;
+  const border = '─'.repeat(W - 2);
+  const pad = s => '│ ' + s.padEnd(W - 4) + ' │';
+
+  console.log(`╭${border}╮`);
+  console.log(pad('Recent Changes'));
+  console.log(pad(''));
+  if (!changes.length) {
+    console.log(pad('  No recent changes to revert.'));
+  } else {
+    changes.forEach((c, i) => console.log(pad(`  [${i + 1}] ${formatChange(c)}`)));
+  }
+  console.log(pad(''));
+  console.log(pad('  [number] revert   [a] revert all   [q] quit'));
+  console.log(pad(''));
+  console.log(`╰${border}╯`);
+
+  if (!changes.length) return;
+
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const answer = await new Promise(res => rl.question('> ', res));
+  rl.close();
+
+  const input = answer.trim().toLowerCase();
+  if (input === 'q' || input === '') return;
+  if (input === 'a') {
+    const confirm = await new Promise(res => {
+      const r2 = createInterface({ input: process.stdin, output: process.stdout });
+      r2.question(`Revert all ${changes.length} changes? (y/N) `, ans => { r2.close(); res(ans); });
+    });
+    if (confirm.trim().toLowerCase() === 'y') {
+      const result = revertAll(null, cwd);
+      console.log(result.success ? `Reverted ${result.count} changes.` : `Error: ${result.error}`);
+    }
+    return;
+  }
+  const n = parseInt(input, 10);
+  if (!isNaN(n) && n >= 1 && n <= changes.length) {
+    const target = changes[n - 1];
+    const result = revertChange(target.id, cwd);
+    console.log(result.success ? `Reverted: ${result.description}` : `Error: ${result.description}`);
+  } else {
+    console.log('Invalid selection.');
+  }
+}

package/src/routing-advisor.mjs

@@ -2,6 +2,7 @@
 // Learns which model works best for which task type from outcome signals.
 
 import { readFileSync, writeFileSync, existsSync, mkdirSync, renameSync } from 'node:fs';
+import { checkFileSurvival } from './outcome.mjs';
 import { join } from 'node:path';
 
 const ALPHA = 0.3;
@@ -42,6 +43,19 @@ function saveState(state, cwd) {
   } catch { /* non-throwing */ }
 }
 
+/** Cross-cell bias: average EMA from same-tier cells that have >= 8 observations. */
+function getCrossCellBias(state, cellKey, model) {
+  const [tier] = cellKey.split(':');
+  let biasSum = 0, biasCount = 0;
+  for (const [key, models] of Object.entries(state)) {
+    if (key.startsWith(tier + ':') && key !== cellKey && models[model]) {
+      const entry = models[model];
+      if ((entry.observations ?? 0) >= 8) { biasSum += entry.ema; biasCount++; }
+    }
+  }
+  return biasCount > 0 ? biasSum / biasCount : null;
+}
+
 const staticPrior = (tier, model) => STATIC_PRIORS[`${tier}:${model}`] ?? 0.5;
 const cellObs = (state, key) => Object.values(state[key] ?? {}).reduce((s, m) => s + (m.observations ?? 0), 0);
 const blended = (ema, n, tier, model) =>
@@ -58,9 +72,21 @@ export function adviseModel(taskProfile, cwd) {
 
     const state = loadState(cwd);
     const totalObs = cellObs(state, cellKey);
+    const grandTotal = Object.values(state).reduce((s, cell) =>
+      s + Object.values(cell).reduce((t, e) => t + (e.observations ?? 0), 0), 0);
 
     if (totalObs < MIN_OBSERVATIONS) {
-      // Heuristic: pick highest static prior
+      // When enough global data exists, blend cross-cell bias with static prior
+      if (grandTotal > 100) {
+        let bestModel = models[0], bestScore = -Infinity;
+        for (const m of models) {
+          const xbias = getCrossCellBias(state, cellKey, m);
+          const prior = staticPrior(validTier, m);
+          const score = xbias != null ? (xbias + prior) / 2 : prior;
+          if (score > bestScore) { bestScore = score; bestModel = m; }
+        }
+        return { model: bestModel, reason: 'cross-cell bias', confidence: 0.4, explored: false };
+      }
       const best = models.reduce((a, b) => staticPrior(validTier, a) >= staticPrior(validTier, b) ? a : b);
       return { model: best, reason: 'insufficient data, using heuristic', confidence: 0.3, explored: false };
     }
@@ -129,6 +155,42 @@ export function getRoutingStats(cwd) {
   }
 }
 
+/**
+ * Loads cross-session routing state. If the state was last updated in a prior session,
+ * applies a mild decay (×0.95) to all EMA scores to account for staleness.
+ */
+export function loadCrossSessionPriors(cwd) {
+  try {
+    const state = loadState(cwd);
+    const sessionStart = state._sessionStart;
+    if (!sessionStart) return state; // no prior session marker
+    const lastMs = new Date(sessionStart).getTime();
+    if (isNaN(lastMs)) return state;
+    const stale = (Date.now() - lastMs) > 60_000; // more than 1 min old = different session
+    if (!stale) return state;
+    for (const [cellKey, models] of Object.entries(state)) {
+      if (cellKey.startsWith('_')) continue;
+      for (const entry of Object.values(models)) {
+        if (typeof entry.ema === 'number') entry.ema = entry.ema * 0.95;
+      }
+    }
+    return state;
+  } catch { return {}; }
+}
+
+/**
+ * Records session start timestamp and triggers file survival checks.
+ * Call once at CLI session start.
+ */
+export async function markSessionStart(cwd) {
+  try {
+    const state = loadState(cwd);
+    state._sessionStart = new Date().toISOString();
+    saveState(state, cwd);
+    await checkFileSurvival(cwd).catch(() => {});
+  } catch { /* non-throwing */ }
+}
+
 export function resetAdvisor(cwd) {
   try {
     saveState({}, cwd);