dual-brain 0.2.27 → 0.2.29

package/bin/dual-brain.mjs

@@ -4227,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' };
@@ -6634,6 +6658,23 @@ async function main() {
     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.27",
+  "version": "0.2.29",
   "description": "AI orchestration across Claude + OpenAI subscriptions — smart routing, budget awareness, and dual-brain collaboration",
   "type": "module",
   "bin": {
@@ -53,7 +53,11 @@
     "./subscription": "./src/subscription.mjs",
     "./recommendations": "./src/recommendations.mjs",
     "./setup-flow": "./src/setup-flow.mjs",
-    "./self-correct": "./src/self-correct.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",
@@ -146,6 +150,10 @@
     "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/context-intel.mjs

@@ -3,7 +3,8 @@ import { join, resolve } from 'node:path';
 
 export const MODEL_FORMAT = {
   claude: 'xml', sonnet: 'xml', haiku: 'xml', opus: 'xml',
-  gpt: 'markdown', o3: 'markdown', 'o4-mini': 'markdown',
+  gpt: 'markdown', 'o4-mini': 'markdown',
+  o3: 'prose',
 };
 
 function detectFormat(targetModel, role) {
@@ -14,6 +15,7 @@ function detectFormat(targetModel, role) {
 }
 
 export function selectRelevant(pack, role) {
+  if (!pack) return { intent: '', constraints: [], acceptanceCriteria: [] };
   const { intent, constraints, priorAttempts, repoState, fileSummaries,
           acceptanceCriteria, files } = pack;
   if (role === 'thinker') {
@@ -134,7 +136,7 @@ export function attachOutputSchema(role) {
   return 'Return JSON: { pass: boolean, findings: [{ severity, file, line, issue, fix }] }';
 }
 
-export function shapeForRole(pack, role, targetModel, tokenBudget) {
+export function shapeForRole(pack, role, targetModel = 'sonnet', tokenBudget = 8000) {
   const sections = selectRelevant(pack, role);
 
   if (role === 'worker' && sections.inScope?.length) {

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/recommendations.mjs

@@ -267,7 +267,7 @@ export function formatRecommendations(recs) {
   const line = (content) => `│ ${pad(content)} │`;
 
   const lines = [
-    '╭─ Recommendations ' + '─'.repeat(WIDTH - 19) + '╮',
+    '╭─ Recommendations ' + '─'.repeat(WIDTH - 20) + '╮',
     line(''),
   ];
 

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);

package/src/self-correct.mjs

@@ -78,6 +78,7 @@ export function selectStrategy(failure, originalDecision, attemptNumber) {
         case 'specification':
           return { strategy: 'give-up', reason: 'ambiguous specification; user clarification needed' };
         default: // unknown
+          if (tier >= 3) return { strategy: 'split', newDecision: originalDecision, reason: 'unknown failure at max tier; decomposing' };
           return { strategy: 'escalate', newDecision: originalDecision, reason: 'unknown failure; escalating as precaution' };
       }
     }

package/src/settings-tui.mjs

@@ -0,0 +1,373 @@
+// settings-tui.mjs — Interactive settings menu for `dual-brain settings`
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { createInterface } from 'node:readline';
+
+// ─── ANSI helpers ─────────────────────────────────────────────────────────────
+const c = {
+  bold:   s => `\x1b[1m${s}\x1b[0m`,
+  dim:    s => `\x1b[2m${s}\x1b[0m`,
+  green:  s => `\x1b[32m${s}\x1b[0m`,
+  yellow: s => `\x1b[33m${s}\x1b[0m`,
+  cyan:   s => `\x1b[36m${s}\x1b[0m`,
+  red:    s => `\x1b[31m${s}\x1b[0m`,
+};
+
+// ─── readline helper ──────────────────────────────────────────────────────────
+async function prompt(rl, question) {
+  return new Promise(resolve => rl.question(question, resolve));
+}
+
+// ─── Config helpers ───────────────────────────────────────────────────────────
+function loadCurrentConfig(cwd) {
+  try {
+    const p = join(cwd, '.dualbrain', 'config.json');
+    return existsSync(p) ? JSON.parse(readFileSync(p, 'utf8')) : {};
+  } catch { return {}; }
+}
+
+function saveConfig(cfg, cwd) {
+  const dir = join(cwd, '.dualbrain');
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, 'config.json'), JSON.stringify(cfg, null, 2) + '\n', 'utf8');
+}
+
+// ─── Dial position map ────────────────────────────────────────────────────────
+const DIAL_POSITIONS = {
+  1: { label: 'Frugal',      workStyle: 'frugal',      models: { search: 'haiku', execute: 'haiku',  think: 'sonnet', review: 'sonnet' }, thinkEnabled: false, budget: 3 },
+  2: { label: 'Save Usage',  workStyle: 'conservative', models: { search: 'haiku', execute: 'sonnet', think: 'sonnet', review: 'sonnet' }, thinkEnabled: 'auto', budget: null },
+  3: { label: 'Balanced',    workStyle: 'balanced',     models: { search: 'haiku', execute: 'sonnet', think: 'opus',   review: 'sonnet' }, thinkEnabled: true, budget: null },
+  4: { label: 'Quality',     workStyle: 'quality',      models: { search: 'sonnet',execute: 'sonnet', think: 'opus',   review: 'opus'   }, thinkEnabled: true, budget: null },
+  5: { label: 'Maximum',     workStyle: 'aggressive',   models: { search: 'sonnet',execute: 'opus',   think: 'opus',   review: 'opus'   }, thinkEnabled: true, budget: null },
+};
+
+function saveDialPosition(position, cwd) {
+  const dial = DIAL_POSITIONS[position];
+  if (!dial) return;
+  const cfg = loadCurrentConfig(cwd);
+  cfg.workStyle = dial.workStyle;
+  cfg.models = { ...(cfg.models ?? {}), ...dial.models };
+  cfg.routing = cfg.routing ?? {};
+  cfg.routing.thinkEnabled = dial.thinkEnabled === 'auto' ? true : dial.thinkEnabled;
+  if (dial.budget !== null) {
+    cfg.budget = cfg.budget ?? {};
+    cfg.budget.sessionLimitUsd = dial.budget;
+  } else {
+    if (cfg.budget) delete cfg.budget.sessionLimitUsd;
+  }
+  cfg.dialPosition = position;
+  saveConfig(cfg, cwd);
+}
+
+// ─── Header helpers ───────────────────────────────────────────────────────────
+function inferDialLabel(cfg) {
+  const pos = cfg.dialPosition;
+  if (pos && DIAL_POSITIONS[pos]) return DIAL_POSITIONS[pos].label;
+  const ws = cfg.workStyle ?? '';
+  const map = { frugal: 'Frugal', conservative: 'Save Usage', balanced: 'Balanced', quality: 'Quality', aggressive: 'Maximum' };
+  return map[ws] ?? 'Balanced';
+}
+
+function inferSubLabel(cwd) {
+  try {
+    const p = join(cwd, '.dualbrain', 'subscription.json');
+    if (!existsSync(p)) return 'unknown';
+    const { subscription } = JSON.parse(readFileSync(p, 'utf8'));
+    const labels = {
+      'claude-pro': 'Claude Pro', 'claude-max-5x': 'Claude Max 5x',
+      'claude-max-20x': 'Claude Max 20x', 'chatgpt-plus': 'ChatGPT Plus',
+      'chatgpt-pro': 'ChatGPT Pro', 'dual-pro': 'Both Pro', 'dual-max': 'Both Max',
+    };
+    return labels[subscription] ?? subscription;
+  } catch { return 'unknown'; }
+}
+
+// ─── Subscreens ───────────────────────────────────────────────────────────────
+
+export async function dialScreen(rl, cwd) {
+  const cfg = loadCurrentConfig(cwd);
+  const cur = cfg.dialPosition ?? 3;
+  console.log('');
+  console.log(c.bold('  Routing Dial'));
+  console.log('');
+  console.log(`  Current: ${c.cyan(`[${cur}] ${DIAL_POSITIONS[cur]?.label ?? '?'}`)}`);
+  console.log('');
+  console.log('  1) Frugal        — minimize token usage');
+  console.log('  2) Save Usage    — prefer cheaper models');
+  console.log('  3) Balanced      — smart defaults');
+  console.log('  4) Quality       — best available for each task');
+  console.log('  5) Maximum       — always use most capable');
+  console.log('');
+  const ans = (await prompt(rl, `  Enter number (1-5) or [esc] to cancel: `)).trim();
+  if (ans === '\x1b' || ans === '' || ans === 'esc') return;
+  const n = parseInt(ans, 10);
+  if (n >= 1 && n <= 5) {
+    saveDialPosition(n, cwd);
+    console.log(c.green(`  Dial set to [${n}] ${DIAL_POSITIONS[n].label}`));
+  } else {
+    console.log(c.red('  Invalid choice.'));
+  }
+}
+
+export async function routingScreen(rl, cwd) {
+  const cfg = loadCurrentConfig(cwd);
+  const models = cfg.models ?? {};
+  console.log('');
+  console.log(c.bold('  Tier Assignments'));
+  console.log('');
+  for (const [tier, model] of Object.entries(models)) {
+    console.log(`    ${tier.padEnd(8)}: ${c.cyan(model)}`);
+  }
+  console.log('');
+  console.log(c.bold('  Learned Preferences') + c.dim(' (from routing advisor)'));
+  console.log('');
+  let stats = { topPerformers: [], totalObservations: 0 };
+  try {
+    const { getRoutingStats } = await import('./routing-advisor.mjs');
+    stats = getRoutingStats(cwd);
+  } catch {}
+  if (stats.topPerformers.length === 0) {
+    console.log(c.dim('    No observations yet.'));
+  } else {
+    for (const p of stats.topPerformers.slice(0, 5)) {
+      console.log(`    ${p.cell.padEnd(22)} → ${c.cyan(p.model)} (EMA ${p.ema.toFixed(2)}, n=${p.observations})`);
+    }
+  }
+  console.log('');
+  const ans = (await prompt(rl, '  [o] Override tier   [r] Reset learned data   [esc] back: ')).trim().toLowerCase();
+  if (ans === 'r') {
+    try {
+      const { resetAdvisor } = await import('./routing-advisor.mjs');
+      resetAdvisor(cwd);
+      console.log(c.green('  Routing advisor state cleared.'));
+    } catch { console.log(c.red('  Failed to reset.')); }
+  } else if (ans === 'o') {
+    const tier = (await prompt(rl, '  Tier to override (search/execute/think/review): ')).trim();
+    const model = (await prompt(rl, '  Model (haiku/sonnet/opus): ')).trim();
+    if (tier && model) {
+      const cfg2 = loadCurrentConfig(cwd);
+      cfg2.models = cfg2.models ?? {};
+      cfg2.models[tier] = model;
+      saveConfig(cfg2, cwd);
+      console.log(c.green(`  ${tier} → ${model} saved.`));
+    }
+  }
+}
+
+export async function thinkScreen(rl, cwd) {
+  let metrics = { hits: 0, misses: 0, totalTokens: 0 };
+  try {
+    const p = join(cwd, '.dualbrain', 'think-metrics.json');
+    if (existsSync(p)) metrics = JSON.parse(readFileSync(p, 'utf8'));
+  } catch {}
+  const cfg = loadCurrentConfig(cwd);
+  const enabled = cfg.routing?.thinkEnabled !== false;
+  const total = metrics.hits + metrics.misses;
+  const hitRate = total > 0 ? Math.round((metrics.hits / total) * 100) : 0;
+  console.log('');
+  console.log(c.bold('  Think Pre-flight'));
+  console.log('');
+  console.log(`  Status:     ${enabled ? c.green('enabled') : c.red('disabled')}`);
+  console.log(`  Hit rate:   ${hitRate}% (${metrics.hits} hits / ${metrics.misses} misses)`);
+  console.log(`  Tokens:     ~${((metrics.totalTokens ?? 0) / 1000).toFixed(0)}K`);
+  console.log(`  Auto-disable threshold: 30%`);
+  console.log('');
+  const ans = (await prompt(rl, '  [t] Toggle   [r] Reset metrics   [esc] back: ')).trim().toLowerCase();
+  if (ans === 't') {
+    const cfg2 = loadCurrentConfig(cwd);
+    cfg2.routing = cfg2.routing ?? {};
+    cfg2.routing.thinkEnabled = !enabled;
+    saveConfig(cfg2, cwd);
+    console.log(c.green(`  Think ${!enabled ? 'enabled' : 'disabled'}.`));
+  } else if (ans === 'r') {
+    try {
+      const p = join(cwd, '.dualbrain', 'think-metrics.json');
+      writeFileSync(p, JSON.stringify({ hits: 0, misses: 0, totalTokens: 0 }, null, 2) + '\n');
+      console.log(c.green('  Think metrics reset.'));
+    } catch { console.log(c.red('  Failed to reset.')); }
+  }
+}
+
+async function budgetScreen(rl, cwd) {
+  let budget = { spent: 0, remaining: 10, limit: 10, warning: false };
+  try {
+    const { loadGovernanceState, checkBudget } = await import('./governance.mjs');
+    const cfg = loadCurrentConfig(cwd);
+    budget = checkBudget(cwd, cfg);
+  } catch {}
+  const pct = budget.limit > 0 ? Math.round((budget.spent / budget.limit) * 100) : 0;
+  const cfg = loadCurrentConfig(cwd);
+  const warnAt = cfg.budget?.warnAtPercent ?? 80;
+  console.log('');
+  console.log(c.bold('  Budget'));
+  console.log('');
+  console.log(`  Session limit:   $${budget.limit.toFixed(2)} (estimated)`);
+  console.log(`  Current session: $${budget.spent.toFixed(2)} spent (${pct}%)`);
+  console.log(`  Warning at:      ${warnAt}%`);
+  console.log('');
+  const ans = (await prompt(rl, '  [l] Set limit   [w] Set warning %   [esc] back: ')).trim().toLowerCase();
+  if (ans === 'l') {
+    const val = (await prompt(rl, '  New session limit ($): ')).trim();
+    const n = parseFloat(val);
+    if (!isNaN(n) && n >= 0) {
+      const cfg2 = loadCurrentConfig(cwd);
+      cfg2.budget = cfg2.budget ?? {};
+      cfg2.budget.sessionLimitUsd = n;
+      saveConfig(cfg2, cwd);
+      console.log(c.green(`  Session limit set to $${n}.`));
+    } else { console.log(c.red('  Invalid value.')); }
+  } else if (ans === 'w') {
+    const val = (await prompt(rl, '  Warn at percent (0-100): ')).trim();
+    const n = parseInt(val, 10);
+    if (!isNaN(n) && n >= 0 && n <= 100) {
+      const cfg2 = loadCurrentConfig(cwd);
+      cfg2.budget = cfg2.budget ?? {};
+      cfg2.budget.warnAtPercent = n;
+      saveConfig(cfg2, cwd);
+      console.log(c.green(`  Warning threshold set to ${n}%.`));
+    } else { console.log(c.red('  Invalid value.')); }
+  }
+}
+
+async function subscriptionScreen(rl, cwd) {
+  let curSub = 'unknown';
+  try {
+    const p = join(cwd, '.dualbrain', 'subscription.json');
+    if (existsSync(p)) curSub = JSON.parse(readFileSync(p, 'utf8')).subscription ?? 'unknown';
+  } catch {}
+  const subs = [
+    ['claude-pro',      'Claude Pro ($20/mo)'],
+    ['claude-max-5x',   'Claude Max 5x ($100/mo)'],
+    ['claude-max-20x',  'Claude Max 20x ($200/mo)'],
+    ['chatgpt-plus',    'ChatGPT Plus ($20/mo)'],
+    ['chatgpt-pro',     'ChatGPT Pro ($200/mo)'],
+    ['dual-pro',        'Both Pro tiers'],
+    ['dual-max',        'Both Max tiers'],
+  ];
+  console.log('');
+  console.log(c.bold('  Subscription'));
+  console.log('');
+  console.log(`  Current: ${c.cyan(curSub)}`);
+  console.log('');
+  subs.forEach(([key, label], i) => console.log(`  ${i + 1}) ${label}`));
+  console.log('');
+  const ans = (await prompt(rl, '  Enter number or [esc] to cancel: ')).trim();
+  if (ans === '' || ans === 'esc' || ans === '\x1b') return;
+  const n = parseInt(ans, 10);
+  if (n >= 1 && n <= subs.length) {
+    const [subType, label] = subs[n - 1];
+    try {
+      const { saveUserSubscription } = await import('./subscription.mjs');
+      saveUserSubscription(subType, cwd);
+      console.log(c.green(`  Subscription set to: ${label}`));
+    } catch { console.log(c.red('  Failed to save subscription.')); }
+  } else { console.log(c.red('  Invalid choice.')); }
+}
+
+async function resetScreen(rl, cwd) {
+  let obs = 0;
+  try {
+    const { getRoutingStats } = await import('./routing-advisor.mjs');
+    obs = getRoutingStats(cwd).totalObservations;
+  } catch {}
+  console.log('');
+  console.log(c.bold(c.red('  Reset Learned Data')));
+  console.log('');
+  console.log('  This will clear:');
+  console.log(`  - Routing advisor state (${obs} observations)`);
+  console.log('  - Think metrics');
+  console.log('  - Outcome history');
+  console.log('');
+  const ans = (await prompt(rl, '  Are you sure? (y/N): ')).trim().toLowerCase();
+  if (ans !== 'y') { console.log(c.dim('  Cancelled.')); return; }
+  let cleared = 0;
+  const targets = ['routing-state.json', 'routing-weights.json', 'think-metrics.json', 'outcomes.json'];
+  for (const f of targets) {
+    try {
+      const p = join(cwd, '.dualbrain', f);
+      if (existsSync(p)) { writeFileSync(p, '{}\n'); cleared++; }
+    } catch {}
+  }
+  try {
+    const { resetAdvisor } = await import('./routing-advisor.mjs');
+    resetAdvisor(cwd);
+  } catch {}
+  console.log(c.green(`  Cleared. (${cleared} files reset)`));
+}
+
+// ─── Main menu ────────────────────────────────────────────────────────────────
+export async function runSettings(cwd) {
+  cwd = cwd ?? process.cwd();
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+
+  const box = (lines) => {
+    const W = 65;
+    const hr = '─'.repeat(W - 2);
+    console.log(`╭${hr}╮`);
+    for (const l of lines) {
+      const visible = l.replace(/\x1b\[[0-9;]*m/g, '');
+      const pad = W - 2 - visible.length;
+      console.log(`│ ${l}${' '.repeat(Math.max(0, pad - 1))}│`);
+    }
+    console.log(`╰${hr}╯`);
+  };
+
+  const showMenu = () => {
+    const cfg = loadCurrentConfig(cwd);
+    const profile = inferDialLabel(cfg);
+    const sub = inferSubLabel(cwd);
+    let obs = 0;
+    try {
+      const p = join(cwd, '.dualbrain', 'routing-state.json');
+      if (existsSync(p)) {
+        const state = JSON.parse(readFileSync(p, 'utf8'));
+        for (const models of Object.values(state)) {
+          for (const e of Object.values(models)) obs += e.observations ?? 0;
+        }
+      }
+    } catch {}
+    const learning = cfg.routing?.learningEnabled !== false
+      ? c.green(`active (${obs} observations)`)
+      : c.dim('disabled');
+
+    console.log('');
+    box([
+      c.bold(' dual-brain settings'),
+      '',
+      ` Profile: ${c.cyan(profile.padEnd(20))} Subscription: ${c.cyan(sub)}`,
+      ` Learning: ${learning}`,
+      '',
+      '─'.repeat(63),
+      '',
+      ` ${c.bold('[d]')} Dial         Adjust routing aggression`,
+      ` ${c.bold('[r]')} Routing      Model preferences & learned data`,
+      ` ${c.bold('[t]')} Think        Pre-flight settings & metrics`,
+      ` ${c.bold('[b]')} Budget       Limits and session caps`,
+      ` ${c.bold('[s]')} Subscription Change plan type`,
+      ` ${c.bold('[x]')} Reset        Clear learned data`,
+      '',
+      ` ${c.dim('[q]')} quit`,
+      '',
+    ]);
+  };
+
+  let running = true;
+  while (running) {
+    showMenu();
+    const key = (await prompt(rl, '  > ')).trim().toLowerCase();
+    switch (key) {
+      case 'd': await dialScreen(rl, cwd); break;
+      case 'r': await routingScreen(rl, cwd); break;
+      case 't': await thinkScreen(rl, cwd); break;
+      case 'b': await budgetScreen(rl, cwd); break;
+      case 's': await subscriptionScreen(rl, cwd); break;
+      case 'x': await resetScreen(rl, cwd); break;
+      case 'q': case '': running = false; break;
+      default: console.log(c.dim('  Unknown option.'));
+    }
+    if (running && key !== '') await prompt(rl, c.dim('\n  Press enter to continue...'));
+  }
+
+  rl.close();
+  console.log(c.dim('\n  Settings closed.\n'));
+}

package/src/signal.mjs

@@ -71,7 +71,7 @@ export function scoreOutcome(outcome, context = {}) {
     // Signal 3: token efficiency (weight 0.25)
     let effVal = null;
     const filesChanged = outcome.filesChanged ?? 0;
-    const fileCount = typeof filesChanged === 'number' ? filesChanged : filesChanged.length;
+    const fileCount = Array.isArray(filesChanged) ? filesChanged.length : (typeof filesChanged === 'number' ? filesChanged : 0);
     if (!(fileCount === 0 && tier === 'think')) {
       const tokensUsed =
         outcome.tokensUsed?.output ??

package/src/strategy.mjs

@@ -0,0 +1,235 @@
+// strategy.mjs — Dispatch strategy library + selection
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+// ─── Strategy definitions ──────────────────────────────────────────────────────
+
+export const STRATEGIES = {
+  direct: {
+    id: 'direct',
+    label: 'Direct dispatch',
+    description: 'Single agent, single task. Best for clear, focused work.',
+    applicability: { maxFiles: 3, maxComplexity: 'moderate', maxRisk: 'medium' },
+    cost: 1.0,
+  },
+  cascade: {
+    id: 'cascade',
+    label: 'Think → Execute cascade',
+    description: 'Cheap thinker refines spec, then worker executes. Best for routine-but-multi-step tasks.',
+    applicability: { minFiles: 1, minComplexity: 'moderate', maxRisk: 'high' },
+    cost: 1.3,
+  },
+  split: {
+    id: 'split',
+    label: 'Decompose → parallel dispatch',
+    description: 'Break into sub-tasks, dispatch each at optimal tier. Best for large multi-file changes.',
+    applicability: { minFiles: 4, minComplexity: 'complex' },
+    cost: 2.0,
+  },
+  'dual-review': {
+    id: 'dual-review',
+    label: 'Execute → adversarial review',
+    description: 'Worker implements, second model reviews. Best for high-risk/security code.',
+    applicability: { minRisk: 'high' },
+    cost: 1.5,
+  },
+  'architect-editor': {
+    id: 'architect-editor',
+    label: 'Architect reasons → editor implements',
+    description: 'Opus/o3 reasons freely, sonnet/haiku formats the edits. Best for complex architecture + implementation.',
+    applicability: { minComplexity: 'complex', minFiles: 3 },
+    cost: 1.8,
+  },
+};
+
+// ─── Helpers ───────────────────────────────────────────────────────────────────
+
+const COMPLEXITY_RANK = { trivial: 0, simple: 1, moderate: 2, complex: 3 };
+const RISK_RANK       = { low: 0, medium: 1, high: 2, critical: 3 };
+
+const COST_CAPS = {
+  frugal:        1.0,
+  'cost-saver':  1.3,
+  balanced:      2.0,
+  'quality-first': 3.0,
+  maximum:       Infinity,
+  aggressive:    Infinity, // maps to maximum behaviour
+  fullpower:     Infinity,
+  fast:          1.3,
+};
+
+const SECURITY_KEYWORDS = /\b(auth|security|billing|payment|credential|secret|token|encrypt|permission|oauth|jwt)\b/i;
+
+function costCap(workStyle) {
+  return COST_CAPS[workStyle] ?? 2.0;
+}
+
+function fileCount(detection) {
+  return detection?.fileCount ?? detection?.files ?? 0;
+}
+
+function complexityRank(detection) {
+  return COMPLEXITY_RANK[detection?.complexity] ?? 1;
+}
+
+function riskRank(detection) {
+  return RISK_RANK[detection?.risk] ?? 0;
+}
+
+function prompt(detection) {
+  return detection?.prompt ?? detection?.description ?? '';
+}
+
+// ─── Scoring ───────────────────────────────────────────────────────────────────
+
+function scoreStrategies(detection, workStyle) {
+  const files  = fileCount(detection);
+  const cRank  = complexityRank(detection);
+  const rRank  = riskRank(detection);
+  const text   = prompt(detection);
+  const frugal = workStyle === 'frugal';
+  const saver  = workStyle === 'cost-saver' || workStyle === 'fast';
+
+  return {
+    direct: 0.5,
+
+    cascade: 0
+      + (cRank >= COMPLEXITY_RANK.moderate ? 0.3 : 0)
+      + (files >= 2 ? 0.2 : 0)
+      - (frugal ? 0.5 : 0),
+
+    split: 0
+      + (files >= 4 ? 0.4 : 0)
+      + (cRank >= COMPLEXITY_RANK.complex ? 0.3 : 0)
+      - (frugal || saver ? 0.5 : 0),
+
+    'dual-review': 0
+      + (rRank >= RISK_RANK.high ? 0.5 : 0)
+      + (SECURITY_KEYWORDS.test(text) ? 0.3 : 0)
+      - (frugal ? 0.3 : 0),
+
+    'architect-editor': 0
+      + (cRank >= COMPLEXITY_RANK.complex && files >= 3 ? 0.4 : 0)
+      - (saver ? 0.3 : 0),
+  };
+}
+
+// ─── Export 1: selectStrategy ─────────────────────────────────────────────────
+
+/**
+ * Select the best dispatch strategy for a task.
+ * @param {object} detection  — from detect.mjs (detectTask output)
+ * @param {object} decision   — from decide.mjs (decideRoute output)
+ * @param {object} profile    — user profile (workStyle, etc.)
+ * @returns {{ strategy: string, reason: string, alternatives: string[] }}
+ */
+export function selectStrategy(detection, decision, profile) {
+  try {
+    const workStyle = profile?.workStyle ?? profile?.bias ?? 'balanced';
+    const cap       = costCap(workStyle);
+    const scores    = scoreStrategies(detection, workStyle);
+
+    // Filter by cost cap, then rank
+    const ranked = Object.entries(scores)
+      .filter(([id]) => STRATEGIES[id].cost <= cap)
+      .sort(([, a], [, b]) => b - a);
+
+    if (!ranked.length) {
+      // Fallback — always allow direct
+      return { strategy: 'direct', reason: 'Cost cap allows only direct dispatch.', alternatives: [] };
+    }
+
+    const [bestId] = ranked[0];
+    const alternatives = ranked.slice(1).map(([id]) => id);
+
+    const reasons = {
+      direct:           'Clear, focused task within single-agent scope.',
+      cascade:          'Multi-step task benefits from spec refinement before execution.',
+      split:            'Large file count warrants decomposition into parallel sub-tasks.',
+      'dual-review':    'High-risk or security-sensitive work requires adversarial review.',
+      'architect-editor': 'Complex architecture + implementation benefits from dual-model reasoning.',
+    };
+
+    return {
+      strategy:     bestId,
+      reason:       reasons[bestId] ?? 'Best match for task profile.',
+      alternatives,
+    };
+  } catch {
+    return { strategy: 'direct', reason: 'Fallback to direct dispatch.', alternatives: [] };
+  }
+}
+
+// ─── Export 2: describeStrategy ───────────────────────────────────────────────
+
+/**
+ * Human-readable description of a strategy.
+ * @param {string} strategyId
+ * @returns {string}
+ */
+export function describeStrategy(strategyId) {
+  const s = STRATEGIES[strategyId];
+  if (!s) return `Unknown strategy: ${strategyId}`;
+  return `${s.label} (cost ×${s.cost})\n${s.description}`;
+}
+
+// ─── Export 3: getStrategyForTask ─────────────────────────────────────────────
+
+/**
+ * Convenience: load profile + decision context, select strategy, return with execution plan.
+ * @param {object} detection  — from detect.mjs
+ * @param {string} [cwd]      — working directory (for profile loading)
+ * @returns {{ strategy: string, reason: string, alternatives: string[], plan: { steps: object[] } }}
+ */
+export function getStrategyForTask(detection, cwd) {
+  const dir = cwd ?? process.cwd();
+  let profile = {};
+  try {
+    const p = join(dir, '.dualbrain', 'config.json');
+    if (existsSync(p)) profile = JSON.parse(readFileSync(p, 'utf8'));
+  } catch { /* non-throwing */ }
+
+  // Minimal decision stub (model resolved from profile if available)
+  const decision = { model: profile?.models?.execute ?? 'sonnet' };
+  const selected = selectStrategy(detection, decision, profile);
+
+  return { ...selected, plan: buildPlan(selected.strategy, decision) };
+}
+
+// ─── Plan builder ─────────────────────────────────────────────────────────────
+
+function buildPlan(strategyId, decision) {
+  const m = decision?.model ?? 'sonnet';
+  const plans = {
+    direct: [
+      { role: 'worker',    model: m,            description: 'Execute task' },
+    ],
+    cascade: [
+      { role: 'thinker',  model: 'sonnet',      description: 'Refine spec' },
+      { role: 'worker',   model: 'from-think',  description: 'Execute refined spec' },
+    ],
+    split: [
+      { role: 'thinker',  model: 'sonnet',      description: 'Decompose into sub-tasks' },
+      { role: 'worker',   model: 'varies',       description: 'Execute each sub-task' },
+    ],
+    'dual-review': [
+      { role: 'worker',   model: m,             description: 'Implement' },
+      { role: 'reviewer', model: 'sonnet',      description: 'Adversarial review' },
+    ],
+    'architect-editor': [
+      { role: 'thinker',  model: 'opus',        description: 'Architect solution' },
+      { role: 'worker',   model: 'haiku',       description: 'Format edits' },
+    ],
+  };
+  return { steps: plans[strategyId] ?? plans.direct };
+}
+
+// ─── Export 4: listStrategies ─────────────────────────────────────────────────
+
+/**
+ * List all strategies for display.
+ * @returns {{ id: string, label: string, description: string, cost: number }[]}
+ */
+export function listStrategies() {
+  return Object.values(STRATEGIES).map(({ id, label, description, cost }) => ({ id, label, description, cost }));
+}