dual-brain 3.2.0 → 3.3.0

package/CLAUDE.md

@@ -15,7 +15,26 @@ Route subagents by task complexity:
 For isolated or parallel work, dispatch to GPT via Codex CLI:
 
 - `node .claude/hooks/gpt-work-dispatcher.mjs --task "..." --model gpt-5.4` — execution tasks
-- `node .claude/hooks/dual-brain-think.mjs --question "..."` — dual-perspective decisions
+
+## Dual-Brain Collaboration
+
+Dual-brain is a multi-round conversation between Claude and GPT — not a single-shot dispatch.
+
+**Think flow** (architecture decisions):
+1. Round 1: `node .claude/hooks/dual-brain-think.mjs --question "..."`
+   → GPT gives independent analysis
+2. You analyze the same question independently
+3. Round 2: `node .claude/hooks/dual-brain-think.mjs --question "..." --round 2 --claude-says "<your analysis>"`
+   → GPT responds to your points: agreements, pushback, refined recommendation
+4. You synthesize both rounds into a final decision
+
+**Review flow** (code review):
+1. Round 1: `node .claude/hooks/dual-brain-review.mjs`
+   → GPT reviews the diff independently
+2. You review the same diff independently
+3. Round 2: `node .claude/hooks/dual-brain-review.mjs --round 2 --claude-review "<your findings>"`
+   → GPT confirms shared findings, acknowledges misses, disputes false positives
+4. You synthesize into a final review verdict
 
 ## Routing Rules
 

package/hooks/control-panel.mjs

@@ -0,0 +1,489 @@
+#!/usr/bin/env node
+/**
+ * control-panel.mjs — Interactive TUI control panel for Dual-Brain Orchestrator.
+ *
+ * Keyboard-driven dashboard with live-updating pressure, profile switching,
+ * inline budget editing, and routing decision viewer.
+ *
+ * Falls back to static emoji output when not in a TTY.
+ */
+
+import readline from 'readline';
+import { existsSync, readFileSync, renameSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { spawnSync } from 'child_process';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const CONFIG_FILE = join(__dirname, '..', 'orchestrator.json');
+const PROFILE_FILE = join(__dirname, '..', 'dual-brain.profile.json');
+const VERSION = (() => {
+  try { return JSON.parse(readFileSync(join(__dirname, '..', '..', 'dual-brain', 'package.json'), 'utf8')).version; } catch {}
+  try { return JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8')).version; } catch {}
+  return '?';
+})();
+
+// ─── ANSI ──────────────────────────────────────────────────────────────────
+
+const color = !process.env.NO_COLOR;
+const A = {
+  altOn: '\x1b[?1049h', altOff: '\x1b[?1049l',
+  clear: '\x1b[2J', home: '\x1b[H',
+  hide: '\x1b[?25l', show: '\x1b[?25h',
+  reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
+  red: '\x1b[31m', green: '\x1b[32m', yellow: '\x1b[33m',
+  blue: '\x1b[34m', cyan: '\x1b[36m', gray: '\x1b[90m',
+  white: '\x1b[37m',
+};
+const c = (code, s) => color ? `${code}${s}${A.reset}` : s;
+
+// ─── Profiles ──────────────────────────────────────────────────────────────
+
+const PROFILES = {
+  balanced:        { emoji: '⚖️',  label: 'Balanced',      desc: 'Standard routing — best model per tier' },
+  'cost-saver':    { emoji: '💸', label: 'Cost-saver',    desc: 'Minimize spend — prefer cheaper models' },
+  'quality-first': { emoji: '💎', label: 'Quality-first', desc: 'Maximum quality — dual-brain for medium+' },
+};
+
+const PROFILE_BUDGETS = {
+  balanced:        { session_warn_usd: 5, session_limit_usd: 10, daily_warn_usd: 20, daily_limit_usd: 50 },
+  'cost-saver':    { session_warn_usd: 2, session_limit_usd: 5, daily_warn_usd: 8, daily_limit_usd: 20 },
+  'quality-first': { session_warn_usd: 15, session_limit_usd: 30, daily_warn_usd: 50, daily_limit_usd: 100 },
+};
+
+const PROFILE_GATE = {
+  balanced:        { sensitivity_floor: 'medium', dual_brain_minimum: 'high' },
+  'cost-saver':    { sensitivity_floor: 'high', dual_brain_minimum: 'critical' },
+  'quality-first': { sensitivity_floor: 'low', dual_brain_minimum: 'medium' },
+};
+
+// ─── Data Loaders ──────────────────────────────────────────────────────────
+
+function loadConfig() {
+  try { return JSON.parse(readFileSync(CONFIG_FILE, 'utf8')); } catch { return {}; }
+}
+
+function loadProfile() {
+  try {
+    const data = JSON.parse(readFileSync(PROFILE_FILE, 'utf8'));
+    const name = data.active && PROFILES[data.active] ? data.active : 'balanced';
+    const custom = data.custom_overrides || {};
+    return {
+      name,
+      budgets: { ...PROFILE_BUDGETS[name], ...custom.budgets },
+      gate: PROFILE_GATE[name],
+      switched_at: data.switched_at || null,
+    };
+  } catch {
+    return { name: 'balanced', budgets: PROFILE_BUDGETS.balanced, gate: PROFILE_GATE.balanced, switched_at: null };
+  }
+}
+
+function saveProfile(name, customOverrides) {
+  const data = { active: name, switched_at: new Date().toISOString() };
+  if (customOverrides) data.custom_overrides = customOverrides;
+  const tmp = PROFILE_FILE + '.tmp.' + process.pid;
+  writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n');
+  renameSync(tmp, PROFILE_FILE);
+}
+
+function saveBudget(sessionLimit, dailyLimit) {
+  let existing = {};
+  try { existing = JSON.parse(readFileSync(PROFILE_FILE, 'utf8')); } catch {}
+  const custom = existing.custom_overrides || {};
+  custom.budgets = {
+    session_warn_usd: +(sessionLimit * 0.6).toFixed(2),
+    session_limit_usd: sessionLimit,
+    daily_warn_usd: +(dailyLimit * 0.6).toFixed(2),
+    daily_limit_usd: dailyLimit,
+  };
+  const data = { active: existing.active || 'balanced', switched_at: existing.switched_at || new Date().toISOString(), custom_overrides: custom };
+  const tmp = PROFILE_FILE + '.tmp.' + process.pid;
+  writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n');
+  renameSync(tmp, PROFILE_FILE);
+}
+
+function detectProviders() {
+  const claude = { authed: false, models: 'opus / sonnet / haiku' };
+  const codex = { authed: false, installed: false, models: 'gpt-5.5 / gpt-5.4 / gpt-4.1-mini' };
+
+  const credPaths = [
+    join(process.env.HOME || '', '.claude', '.credentials.json'),
+    join(process.env.HOME || '', '.claude', 'credentials.json'),
+  ];
+  for (const p of credPaths) {
+    try {
+      const cred = JSON.parse(readFileSync(p, 'utf8'));
+      if (cred.claudeAiOauth || cred.apiKey || cred.oauth_token) { claude.authed = true; break; }
+    } catch {}
+  }
+  if (!claude.authed) {
+    const r = spawnSync('claude', ['auth', 'status'], { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 5000 });
+    const out = ((r.stdout || '') + (r.stderr || '')).toLowerCase();
+    if (out.includes('logged in') || out.includes('authenticated')) claude.authed = true;
+  }
+
+  const which = spawnSync('which', ['codex'], { encoding: 'utf8', stdio: 'pipe', timeout: 3000 });
+  if (which.status === 0 && which.stdout.trim()) {
+    codex.installed = true;
+    const login = spawnSync(which.stdout.trim(), ['login', 'status'], { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 5000 });
+    const out = ((login.stdout || '') + (login.stderr || '')).toLowerCase();
+    if (login.status === 0 || out.includes('logged in') || out.includes('authenticated')) codex.authed = true;
+  }
+
+  return { claude, codex };
+}
+
+function loadPressure() {
+  try {
+    const today = new Date().toISOString().slice(0, 10);
+    const summaryPath = join(__dirname, `usage-summary-${today}.json`);
+    const summary = JSON.parse(readFileSync(summaryPath, 'utf8'));
+    const cutoff = Date.now() - 5 * 60 * 60 * 1000;
+    const result = {};
+    for (const provider of ['claude', 'openai']) {
+      result[provider] = {};
+      for (const tier of ['think', 'execute', 'search']) {
+        const ts = (summary.pressure?.[provider]?.[tier] || []).filter(t => Date.parse(t) >= cutoff);
+        const BUDGETS = { think: 45, execute: 364, search: 2000 };
+        const calls = ts.length;
+        const pressure = Math.min(1, calls / (BUDGETS[tier] || 364));
+        result[provider][tier] = { calls, pressure };
+      }
+    }
+    return result;
+  } catch {
+    return {
+      claude: { think: { calls: 0, pressure: 0 }, execute: { calls: 0, pressure: 0 }, search: { calls: 0, pressure: 0 } },
+      openai: { think: { calls: 0, pressure: 0 }, execute: { calls: 0, pressure: 0 }, search: { calls: 0, pressure: 0 } },
+    };
+  }
+}
+
+function loadTodayCost() {
+  try {
+    const today = new Date().toISOString().slice(0, 10);
+    const summary = JSON.parse(readFileSync(join(__dirname, `usage-summary-${today}.json`), 'utf8'));
+    return summary.totals?.cost_estimate || 0;
+  } catch { return 0; }
+}
+
+function loadLastDecision() {
+  const today = new Date().toISOString().slice(0, 10);
+  const logFile = join(__dirname, `usage-${today}.jsonl`);
+  if (!existsSync(logFile)) return null;
+  try {
+    const lines = readFileSync(logFile, 'utf8').split('\n').filter(Boolean);
+    for (let i = lines.length - 1; i >= 0; i--) {
+      try {
+        const e = JSON.parse(lines[i]);
+        if (e.type === 'tier_recommendation') return e;
+      } catch {}
+    }
+  } catch {}
+  return null;
+}
+
+// ─── Rendering ─────────────────────────────────────────────────────────────
+
+function pressureBar(p, w = 10) {
+  const filled = Math.min(w, Math.round(p * w));
+  const bar = '▓'.repeat(filled) + '░'.repeat(w - filled);
+  const pct = String(Math.round(p * 100)).padStart(3) + '%';
+  let stateEmoji, stateLabel;
+  if (p >= 0.95)      { stateEmoji = '🛑'; stateLabel = c(A.red + A.bold, 'throttled'); }
+  else if (p >= 0.82) { stateEmoji = '🔥'; stateLabel = c(A.red, 'hot'); }
+  else if (p >= 0.65) { stateEmoji = '🟡'; stateLabel = c(A.yellow, 'warm'); }
+  else                { stateEmoji = '🟢'; stateLabel = c(A.green, 'healthy'); }
+  const barColored = p >= 0.82 ? c(A.red, bar) : p >= 0.65 ? c(A.yellow, bar) : c(A.green, bar);
+  return `${barColored}  ${pct}  ${stateEmoji} ${stateLabel}`;
+}
+
+function renderDashboard(state) {
+  const { profile, providers, pressure, cost, flash } = state;
+  const pf = PROFILES[profile.name];
+  const time = new Date().toLocaleTimeString('en-US', { hour12: false });
+  const mode = (providers.claude.authed && providers.codex.authed) ? '🧠 Dual brain active' :
+               providers.claude.authed ? '🟠 Claude only' :
+               providers.codex.authed ? '🟢 OpenAI only' : '🔎 No providers';
+
+  const lines = [];
+  lines.push('');
+  lines.push(c(A.bold, `  🧠 Dual-Brain Control Panel v${VERSION}`) + `                   ${c(A.green, '🟢 Live')}  ${c(A.dim, time)}`);
+  lines.push('');
+  lines.push(`  ${mode}`);
+  lines.push(`  🎛️  Profile     ${pf.emoji}  ${c(A.bold, pf.label)}       ${c(A.dim, pf.desc)}`);
+  lines.push(`  💵 Budget      Session $${cost.toFixed(2)} / $${profile.budgets.session_limit_usd}   Daily / $${profile.budgets.daily_limit_usd}`);
+  lines.push(`  🛡️  Gate        Reviews ${profile.gate.sensitivity_floor}+         Dual-brain ${profile.gate.dual_brain_minimum}+`);
+  lines.push('');
+
+  lines.push(`  🔌 ${c(A.bold, 'Providers')}`);
+  const cStatus = providers.claude.authed ? '✅ authenticated' : '⚠️  not authenticated';
+  const xStatus = providers.codex.authed ? '✅ authenticated' : providers.codex.installed ? '⚠️  login needed' : '❌ not found';
+  lines.push(`    🟠 Claude     ${cStatus}     ${c(A.dim, providers.claude.models)}`);
+  lines.push(`    🟢 Codex      ${xStatus}     ${c(A.dim, providers.codex.models)}`);
+  lines.push('');
+
+  lines.push(`  🌡️  ${c(A.bold, 'Pressure')} ${c(A.dim, '— rolling 5h')}`);
+  for (const [label, emoji, key] of [['Claude', '🟠', 'claude'], ['OpenAI', '🟢', 'openai']]) {
+    lines.push(`    ${emoji} ${label}`);
+    for (const tier of ['think', 'execute', 'search']) {
+      const p = pressure[key]?.[tier] || { pressure: 0 };
+      const tierLabel = (tier.charAt(0).toUpperCase() + tier.slice(1)).padEnd(8);
+      lines.push(`       ${c(A.dim, tierLabel)}  ${pressureBar(p.pressure)}`);
+    }
+    if (key === 'claude') lines.push('');
+  }
+  lines.push('');
+
+  if (flash) {
+    lines.push(`  ${flash}`);
+    lines.push('');
+  }
+
+  lines.push(c(A.dim, '  ─'.repeat(30)));
+  lines.push(`  ⌨️   ${c(A.bold, '1')} Balanced  ${c(A.bold, '2')} Cost-saver  ${c(A.bold, '3')} Quality-first  ${c(A.bold, 'b')} Budget  ${c(A.bold, 'e')} Explain  ${c(A.bold, 'q')} Quit`);
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+function renderExplain(decision, profile) {
+  const lines = [];
+  lines.push('');
+  lines.push(c(A.bold, '  🧭 Last Routing Decision'));
+  lines.push(c(A.dim, '  ' + '─'.repeat(40)));
+
+  if (!decision) {
+    lines.push('  💤 No routing decisions recorded today.');
+    lines.push('');
+    lines.push(c(A.dim, '  Press any key to go back'));
+    return lines.join('\n');
+  }
+
+  const time = decision.timestamp?.slice(11, 19) || '??:??:??';
+  const followed = decision.followed;
+  lines.push(`  🕐 Time         ${time}`);
+  lines.push(`  🔎 Detected     ${decision.detected_tier || 'unknown'} tier`);
+  lines.push(`  🧠 Recommended  ${decision.recommended_model || 'unknown'}`);
+  lines.push(`  🎯 Actual       ${decision.actual_model || 'unknown'}`);
+  lines.push(`  ${followed ? '✅' : '⚠️'}  Followed     ${followed ? 'yes' : 'no'}`);
+  lines.push(`  🎛️  Profile      ${profile.name}`);
+  lines.push('');
+
+  if (followed) {
+    lines.push('  ✅ Routing matched the recommendation.');
+  } else {
+    lines.push('  ⚠️  Recommendation was overridden.');
+  }
+
+  lines.push('');
+  lines.push(c(A.dim, '  Press any key to go back'));
+  return lines.join('\n');
+}
+
+function renderBudgetEditor(sessionVal, dailyVal, field, flash) {
+  const lines = [];
+  lines.push('');
+  lines.push(c(A.bold, '  💵 Edit Budget'));
+  lines.push(c(A.dim, '  ' + '─'.repeat(40)));
+  lines.push('');
+
+  const sCursor = field === 'session' ? '_' : '';
+  const dCursor = field === 'daily' ? '_' : '';
+  lines.push(`  Session limit:  $${sessionVal}${sCursor}${field === 'session' ? c(A.dim, ' ← editing') : ''}`);
+  lines.push(`  Daily limit:    $${dailyVal}${dCursor}${field === 'daily' ? c(A.dim, ' ← editing') : ''}`);
+  lines.push('');
+
+  if (flash) {
+    lines.push(`  ${flash}`);
+    lines.push('');
+  }
+
+  lines.push(c(A.dim, '  Type numbers · Tab next · Enter save · Esc cancel'));
+  return lines.join('\n');
+}
+
+// ─── Static (non-TTY) Output ───────────────────────────────────────────────
+
+function renderStatic() {
+  const profile = loadProfile();
+  const providers = detectProviders();
+  const pressure = loadPressure();
+  const cost = loadTodayCost();
+  const state = { profile, providers, pressure, cost, flash: null };
+  console.log(renderDashboard(state));
+}
+
+// ─── Interactive TUI ───────────────────────────────────────────────────────
+
+function startTUI() {
+  let view = 'dashboard';
+  let flash = null;
+  let flashTimeout = null;
+  let refreshTimer = null;
+
+  // Budget editor state
+  let budgetSession = '';
+  let budgetDaily = '';
+  let budgetField = 'session';
+
+  function setFlash(msg, ms = 3000) {
+    flash = msg;
+    clearTimeout(flashTimeout);
+    flashTimeout = setTimeout(() => { flash = null; render(); }, ms);
+  }
+
+  function loadState() {
+    return {
+      profile: loadProfile(),
+      providers: detectProviders(),
+      pressure: loadPressure(),
+      cost: loadTodayCost(),
+      flash,
+    };
+  }
+
+  function render() {
+    let screen;
+    if (view === 'dashboard') {
+      screen = renderDashboard(loadState());
+    } else if (view === 'explain') {
+      const decision = loadLastDecision();
+      const profile = loadProfile();
+      screen = renderExplain(decision, profile);
+    } else if (view === 'budget') {
+      screen = renderBudgetEditor(budgetSession, budgetDaily, budgetField, flash);
+    }
+    process.stdout.write(A.home + A.clear + screen);
+  }
+
+  function startRefresh() {
+    stopRefresh();
+    refreshTimer = setInterval(render, 2000);
+  }
+
+  function stopRefresh() {
+    if (refreshTimer) { clearInterval(refreshTimer); refreshTimer = null; }
+  }
+
+  function cleanup() {
+    stopRefresh();
+    clearTimeout(flashTimeout);
+    process.stdin.setRawMode(false);
+    process.stdout.write(A.reset + A.show + A.altOff);
+    process.exit(0);
+  }
+
+  function switchProfile(name) {
+    let customOverrides = null;
+    try {
+      const existing = JSON.parse(readFileSync(PROFILE_FILE, 'utf8'));
+      if (existing.custom_overrides?.budgets) customOverrides = { budgets: existing.custom_overrides.budgets };
+    } catch {}
+    saveProfile(name, customOverrides);
+    const pf = PROFILES[name];
+    setFlash(`✅ Profile switched: ${pf.emoji}  ${pf.label}`);
+    render();
+  }
+
+  // Setup
+  process.stdout.write(A.altOn + A.hide);
+  readline.emitKeypressEvents(process.stdin);
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+
+  process.on('SIGINT', cleanup);
+  process.on('SIGTERM', cleanup);
+  process.on('uncaughtException', (err) => {
+    cleanup();
+    console.error(err);
+  });
+
+  render();
+  startRefresh();
+
+  process.stdin.on('keypress', (str, key) => {
+    if (key?.ctrl && key?.name === 'c') return cleanup();
+
+    if (view === 'budget') {
+      if (key?.name === 'escape') {
+        view = 'dashboard';
+        startRefresh();
+        render();
+        return;
+      }
+      if (key?.name === 'tab') {
+        budgetField = budgetField === 'session' ? 'daily' : 'session';
+        render();
+        return;
+      }
+      if (key?.name === 'return') {
+        const s = parseFloat(budgetSession);
+        const d = parseFloat(budgetDaily);
+        if (isNaN(s) || s <= 0) { setFlash('❌ Invalid session limit'); render(); return; }
+        const daily = (isNaN(d) || d <= 0) ? s * 3 : d;
+        saveBudget(s, daily);
+        view = 'dashboard';
+        startRefresh();
+        setFlash(`✅ Budget updated: Session $${s} · Daily $${daily}`);
+        render();
+        return;
+      }
+      if (key?.name === 'backspace') {
+        if (budgetField === 'session') budgetSession = budgetSession.slice(0, -1);
+        else budgetDaily = budgetDaily.slice(0, -1);
+        render();
+        return;
+      }
+      if (str && /[0-9.]/.test(str)) {
+        if (budgetField === 'session') budgetSession += str;
+        else budgetDaily += str;
+        render();
+        return;
+      }
+      return;
+    }
+
+    if (view === 'explain') {
+      view = 'dashboard';
+      startRefresh();
+      render();
+      return;
+    }
+
+    // Dashboard keys
+    if (key?.name === 'q' || key?.name === 'escape') return cleanup();
+    if (str === '1') return switchProfile('balanced');
+    if (str === '2') return switchProfile('cost-saver');
+    if (str === '3') return switchProfile('quality-first');
+    if (str === 'r') { render(); return; }
+    if (str === 'e') {
+      view = 'explain';
+      stopRefresh();
+      render();
+      return;
+    }
+    if (str === 'b') {
+      view = 'budget';
+      stopRefresh();
+      const profile = loadProfile();
+      budgetSession = String(profile.budgets.session_limit_usd);
+      budgetDaily = String(profile.budgets.daily_limit_usd);
+      budgetField = 'session';
+      flash = null;
+      render();
+      return;
+    }
+  });
+}
+
+// ─── Entry ─────────────────────────────────────────────────────────────────
+
+const interactive = process.stdin.isTTY && process.stdout.isTTY && !process.env.CI;
+
+if (interactive) {
+  startTUI();
+} else {
+  renderStatic();
+}

package/hooks/dual-brain-review.mjs

@@ -19,7 +19,11 @@ import { fileURLToPath } from 'url';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
-const REVIEW_PROMPT = `Review the current uncommitted changes in this repo for:
+const REVIEW_PROMPT_R1 = `You are GPT-5.5 performing Round 1 of a dual-brain code review.
+Claude (Opus) will independently review the same changes, then send you their findings
+for a collaborative Round 2 discussion.
+
+Review the current uncommitted changes for:
 1. Correctness — logic errors, off-by-one, null/undefined risks
 2. Security — injection, auth bypass, data exposure
 3. Edge cases — what could break under unusual input
@@ -34,6 +38,24 @@ Required output:
 
 Be concise. Flag only real issues, not style preferences. If the code looks good, say "LGTM" and note any minor suggestions. Output your review as plain text, not JSON.`;
 
+const REVIEW_PROMPT_R2 = `You are GPT-5.5 in Round 2 of a collaborative code review with Claude (Opus).
+You already reviewed this diff in Round 1. Claude has now independently reviewed the same changes.
+This is a professional peer review dialogue — two senior engineers refining their assessment together.
+
+Claude's review findings:
+---CLAUDE_REVIEW---
+
+Now respond as a peer reviewer:
+1. CONFIRMED: Issues you both found — these are high-confidence findings
+2. MISSED: Issues Claude caught that you missed — acknowledge them
+3. DISAGREE: Claude's findings you think are false positives — explain why
+4. ESCALATED: Issues that are MORE severe than either of you initially rated
+5. VERDICT: Combined assessment — LGTM, minor issues, or blocks merge
+
+Be direct. If Claude found something real that you missed, say so.
+If Claude flagged something that isn't actually a problem, explain why with evidence.
+The goal is the most accurate review, not defending your initial take.`;
+
 function loadReviewRules() {
   const rulesFile = resolve(__dirname, '..', 'review-rules.md');
   try {
@@ -127,9 +149,9 @@ function exit(obj) {
 
 /**
  * Try GPT review via Codex CLI (uses ChatGPT subscription auth).
- * Returns review text or null if codex isn't available.
+ * Round 1: independent review. Round 2: respond to Claude's review.
  */
-function tryCodexReview(diff) {
+function tryCodexReview(diff, { round = 1, claudeReview = null } = {}) {
   if (!CODEX_BIN) return null;
   try {
     spawnSync(CODEX_BIN, ['login', 'status'], {
@@ -145,7 +167,14 @@ function tryCodexReview(diff) {
       ? diff.slice(0, MAX_DIFF_CHARS) + '\n[truncated]'
       : diff;
 
-    const fullPrompt = REVIEW_PROMPT + loadReviewRules();
+    let basePrompt;
+    if (round === 2 && claudeReview) {
+      basePrompt = REVIEW_PROMPT_R2.replace('---CLAUDE_REVIEW---', claudeReview);
+    } else {
+      basePrompt = REVIEW_PROMPT_R1;
+    }
+    const fullPrompt = basePrompt + loadReviewRules();
+
     const proc = spawnSync(CODEX_BIN, [
       'exec', '--json', '--ephemeral',
       '-c', `model="${model}"`,
@@ -159,7 +188,6 @@ function tryCodexReview(diff) {
     });
     const result = proc.stdout || '';
 
-    // Parse JSONL output, find agent_message items
     const messages = result
       .split('\n')
       .filter(l => l.trim())
@@ -173,16 +201,17 @@ function tryCodexReview(diff) {
     const usage = messages.find(m => m.type === 'turn.completed')?.usage;
 
     if (agentMessages.length > 0) {
+      const reviewText = agentMessages.join('\n\n');
       return {
-        review: agentMessages.join('\n\n'),
+        round,
+        review: reviewText,
         model,
         auth_type: 'codex_subscription',
-        issues_found: hasIssues(agentMessages.join(' ')),
+        issues_found: hasIssues(reviewText),
         tokens: usage || null,
       };
     }
 
-    // Check for errors
     const errors = messages.filter(m => m.type === 'error' || m.type === 'turn.failed');
     if (errors.length > 0) {
       return {
@@ -205,7 +234,7 @@ function tryCodexReview(diff) {
 /**
  * Try GPT review via direct API call (needs OPENAI_API_KEY).
  */
-async function tryApiReview(diff) {
+async function tryApiReview(diff, { round = 1, claudeReview = null } = {}) {
   const apiKey = process.env.OPENAI_API_KEY;
   if (!apiKey) return null;
 
@@ -214,7 +243,14 @@ async function tryApiReview(diff) {
     ? diff.slice(0, MAX_DIFF_CHARS) + '\n[truncated]'
     : diff;
 
-  const fullPrompt = REVIEW_PROMPT + loadReviewRules();
+  let basePrompt;
+  if (round === 2 && claudeReview) {
+    basePrompt = REVIEW_PROMPT_R2.replace('---CLAUDE_REVIEW---', claudeReview);
+  } else {
+    basePrompt = REVIEW_PROMPT_R1;
+  }
+  const fullPrompt = basePrompt + loadReviewRules();
+
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), 30_000);
 
@@ -245,6 +281,7 @@ async function tryApiReview(diff) {
     if (!text) return null;
 
     return {
+      round,
       review: text,
       model,
       auth_type: 'api_key',
@@ -256,7 +293,37 @@ async function tryApiReview(diff) {
   }
 }
 
+function parseArgs(argv) {
+  const args = {};
+  let i = 0;
+  while (i < argv.length) {
+    const arg = argv[i];
+    if (arg.startsWith('--')) {
+      const eqIdx = arg.indexOf('=');
+      if (eqIdx !== -1) {
+        args[arg.slice(2, eqIdx)] = arg.slice(eqIdx + 1);
+      } else {
+        const key = arg.slice(2);
+        const next = argv[i + 1];
+        if (next !== undefined && !next.startsWith('--')) {
+          args[key] = next;
+          i++;
+        } else {
+          args[key] = true;
+        }
+      }
+    }
+    i++;
+  }
+  return args;
+}
+
 async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const round = args.round ? parseInt(args.round, 10) : 1;
+  const claudeReview = args['claude-review'] || null;
+  const opts = { round, claudeReview };
+
   // 1. Get diff
   let diff = runGit('git diff --staged') || '';
   if (countLines(diff) < MIN_DIFF_LINES) {
@@ -264,12 +331,11 @@ async function main() {
     if (countLines(headDiff) > countLines(diff)) diff = headDiff;
   }
 
-  // Also gather content of untracked source files
   try {
     const untracked = runGit('git ls-files --others --exclude-standard') || '';
     const sourceExts = /\.(ts|tsx|js|jsx|py|rs|go|java|rb|swift|kt|mjs|cjs)$/;
     const untrackedSrc = untracked.split('\n').filter(f => f && sourceExts.test(f));
-    for (const f of untrackedSrc.slice(0, 10)) { // cap at 10 files
+    for (const f of untrackedSrc.slice(0, 10)) {
       const content = runGit(`git diff --no-index /dev/null "${f}"`);
       if (content) diff += '\n' + content;
     }
@@ -279,13 +345,36 @@ async function main() {
     exit({ review: 'No significant changes to review' });
   }
 
-  // 2. Try Codex CLI first (uses ChatGPT subscription)
-  const codexResult = tryCodexReview(diff);
-  if (codexResult) exit(codexResult);
+  // 2. Try Codex CLI first
+  const codexResult = tryCodexReview(diff, opts);
+  if (codexResult) {
+    if (round === 1) {
+      codexResult.instructions = `Round 1 complete. Now:
+1. Provide YOUR independent code review of the same changes
+2. Then call Round 2 to send your findings back to GPT:
+   node .claude/hooks/dual-brain-review.mjs --round 2 --claude-review "<your findings>"
+3. GPT will respond — confirming shared findings, acknowledging misses, and pushing back on false positives
+4. You then synthesize both rounds into the final review verdict`;
+    } else {
+      codexResult.instructions = `GPT has responded to your review. Synthesize into a FINAL REVIEW:
+- CONFIRMED findings (both found) → high confidence, must fix
+- GPT-only findings you agree with → add to your list
+- Your findings GPT disputed → re-evaluate honestly
+- Final verdict: LGTM, minor issues, or blocks merge`;
+    }
+    exit(codexResult);
+  }
 
   // 3. Try direct API
-  const apiResult = await tryApiReview(diff);
-  if (apiResult) exit(apiResult);
+  const apiResult = await tryApiReview(diff, opts);
+  if (apiResult) {
+    if (round === 1) {
+      apiResult.instructions = `Round 1 complete. Provide YOUR independent review, then call Round 2 with --round 2 --claude-review "<findings>"`;
+    } else {
+      apiResult.instructions = `Synthesize both rounds into a final review verdict.`;
+    }
+    exit(apiResult);
+  }
 
   // 4. No GPT available
   exit({

package/hooks/dual-brain-think.mjs

@@ -60,8 +60,33 @@ function findCodex() {
 // Prompt builder
 // ---------------------------------------------------------------------------
 
-function buildGptPrompt({ question, context, files }) {
+function buildGptPrompt({ question, context, files, round, claudePerspective }) {
+  if (round === 2 && claudePerspective) {
+    return `You are GPT-5.5 in a collaborative architectural discussion with Claude (Opus).
+You gave your initial analysis on a question. Claude has now provided its independent perspective.
+This is a professional dialogue — two experts refining a decision together.
+
+Original question: ${question}
+${context ? `\nContext: ${context}` : ''}
+
+Claude's perspective:
+${claudePerspective}
+
+Now respond as a colleague, not a critic. Structure your response:
+1. AGREEMENTS: Where Claude's analysis strengthens or confirms your thinking
+2. PUSHBACK: Where you disagree — be specific about WHY with evidence or reasoning
+3. NEW INSIGHTS: Anything Claude's perspective surfaced that you missed
+4. REFINED RECOMMENDATION: Your updated recommendation incorporating both perspectives
+5. REMAINING CONCERNS: Open questions neither of you fully resolved
+6. CONFIDENCE DELTA: Has your confidence changed? Why?
+
+Be direct and substantive. If Claude is right about something you got wrong, say so.
+If you still disagree after considering their points, explain what specific evidence would change your mind.`;
+  }
+
   return `You are GPT-5.5, providing an independent architectural perspective.
+This is Round 1 of a dual-brain analysis — Claude (Opus) will independently analyze the same question,
+then send you their perspective for a collaborative discussion in Round 2.
 
 Question: ${question}
 ${context ? `\nContext: ${context}` : ''}
@@ -165,7 +190,7 @@ function logUsage({ durationMs, usage, success }) {
 // Core exported function
 // ---------------------------------------------------------------------------
 
-export async function dualThink({ question, context, files } = {}) {
+export async function dualThink({ question, context, files, round, claudePerspective } = {}) {
   if (!question) {
     return {
       gpt: null,
@@ -174,6 +199,8 @@ export async function dualThink({ question, context, files } = {}) {
     };
   }
 
+  const effectiveRound = (round === 2 && claudePerspective) ? 2 : 1;
+
   const codexBin = findCodex();
   if (!codexBin) {
     return {
@@ -183,7 +210,6 @@ export async function dualThink({ question, context, files } = {}) {
     };
   }
 
-  // Check Codex auth before running
   try {
     execSync(`${codexBin} login status`, {
       encoding: 'utf8',
@@ -198,7 +224,7 @@ export async function dualThink({ question, context, files } = {}) {
     };
   }
 
-  const prompt = buildGptPrompt({ question, context, files });
+  const prompt = buildGptPrompt({ question, context, files, round: effectiveRound, claudePerspective });
   const raw = runGptAnalysis(codexBin, prompt);
 
   logUsage({ durationMs: raw.durationMs, usage: raw.usage, success: raw.success });
@@ -207,18 +233,44 @@ export async function dualThink({ question, context, files } = {}) {
     return {
       gpt: null,
       error: raw.error || 'GPT analysis failed',
-      fallback: 'Proceed with single-brain analysis on Claude Opus',
+      fallback: effectiveRound === 2
+        ? 'GPT rebuttal unavailable — synthesize from Round 1 analysis alone'
+        : 'Proceed with single-brain analysis on Claude Opus',
+    };
+  }
+
+  if (effectiveRound === 2) {
+    return {
+      round: 2,
+      gpt: {
+        rebuttal: raw.text,
+        model: MODEL,
+        durationMs: raw.durationMs,
+        tokens: raw.usage,
+      },
+      instructions: `GPT has responded to your analysis. Now synthesize both rounds into a FINAL DECISION:
+1. Where you both agree → high confidence, proceed
+2. Where GPT pushed back on your points → re-evaluate honestly
+3. Where you still disagree → state why and what evidence would resolve it
+4. Final recommendation with combined confidence level`,
+      question,
     };
   }
 
   return {
+    round: 1,
     gpt: {
       recommendation: raw.text,
       model: MODEL,
       durationMs: raw.durationMs,
       tokens: raw.usage,
     },
-    instructions: 'Now provide YOUR independent analysis of the same question. Then compare both perspectives and make a final decision. If you disagree with GPT, explain why with evidence.',
+    instructions: `Round 1 complete. Now:
+1. Provide YOUR independent analysis of the same question (same structure: recommendation, rationale, alternatives, risks, confidence, verification)
+2. Then call Round 2 to send your perspective back to GPT:
+   node .claude/hooks/dual-brain-think.mjs --question "<same question>" --round 2 --claude-says "<your analysis summary>"
+3. GPT will respond to your specific points — agreements, pushback, and refined recommendation
+4. You then synthesize both rounds into the final decision`,
     question,
     context: context || null,
   };
@@ -268,32 +320,41 @@ function printResult(result, question) {
   const TOP = '╔══════════════════════════════════════════════════╗';
   const BOT = '╚══════════════════════════════════════════════════╝';
 
+  const roundLabel = result.round === 2 ? 'Round 2 — Rebuttal' : 'Round 1 — Initial';
+
   console.log(TOP);
-  console.log('║              Dual-Brain Think                    ║');
+  console.log(`║  🧠 Dual-Brain Think · ${roundLabel}`.padEnd(51) + '║');
   console.log(BAR);
-  // Truncate question to fit the box
   const q = question.length > 44 ? question.slice(0, 41) + '...' : question;
   console.log(`║ Question: ${q.padEnd(38)} ║`);
   console.log(BAR);
 
   if (!result.gpt) {
-    // Failure path
-    console.log(`║ ERROR: ${(result.error || 'Unknown error').padEnd(41)} ║`);
+    console.log(`║ ❌ ${(result.error || 'Unknown error').padEnd(45)} ║`);
     console.log(BAR);
-    console.log(`║ Fallback: ${(result.fallback || '').padEnd(39)} ║`);
+    console.log(`║ ↩️  ${(result.fallback || '').padEnd(45)} ║`);
     console.log(BOT);
     return;
   }
 
-  const durSec = (result.gpt.durationMs / 1000).toFixed(1);
-  console.log(`║ GPT-5.5 Perspective (${MODEL}, ${durSec}s):`.padEnd(51) + '║');
+  const gptData = result.gpt;
+  const durSec = (gptData.durationMs / 1000).toFixed(1);
+  console.log(`║ 🤖 GPT-5.5 (${durSec}s):`.padEnd(51) + '║');
   console.log(BAR);
   console.log('');
-  console.log(result.gpt.recommendation);
+  console.log(gptData.recommendation || gptData.rebuttal);
   console.log('');
   console.log(BAR);
-  console.log('║ Now: Provide YOUR analysis and compare.          ║');
-  console.log('║ If you disagree, explain why with evidence.      ║');
+
+  if (result.round === 2) {
+    console.log('║ 🔄 Synthesize both rounds into final decision.  ║');
+    console.log('║ Where you agree → high confidence.               ║');
+    console.log('║ Where you disagree → state what would resolve it.║');
+  } else {
+    console.log('║ 📝 Your turn: analyze independently, then call   ║');
+    console.log('║    Round 2 with --round 2 --claude-says "..."    ║');
+    console.log('║    for GPT\'s rebuttal to your analysis.          ║');
+  }
   console.log(BOT);
 }
 
@@ -306,7 +367,8 @@ if (import.meta.url === `file://${process.argv[1]}`) {
 
   if (!args.question) {
     console.error(
-      'Usage: node dual-brain-think.mjs --question "<question>" [--context "<context>"] [--files file1,file2]'
+      'Usage: node dual-brain-think.mjs --question "<question>" [--context "<ctx>"] [--files f1,f2]\n' +
+      '       node dual-brain-think.mjs --question "<question>" --round 2 --claude-says "<analysis>"'
     );
     process.exit(1);
   }
@@ -315,6 +377,8 @@ if (import.meta.url === `file://${process.argv[1]}`) {
     question: args.question,
     context: args.context,
     files: args.files,
+    round: args.round ? parseInt(args.round, 10) : 1,
+    claudePerspective: args['claude-says'] || null,
   });
 
   printResult(result, args.question);

package/install.mjs

@@ -39,34 +39,34 @@ if (flag('--version') || flag('-v')) {
 
 if (flag('--help') || flag('-h')) {
   console.log(`
-  dual-brain v${VERSION} — Dual-provider orchestrator for Claude Code
+  🧠 dual-brain v${VERSION} — Dual-provider orchestrator for Claude Code
 
   Usage:  npx -y dual-brain [command] [options]
 
-  Commands:
-    (none)       Auto-detect and install/update orchestrator
-    status       Live view of mode, spend, pressure, profile
-    mode         Show or switch profile (balanced, cost-saver, quality-first)
-    budget       Set session/daily spend limits
-    explain      Show why the last routing decision was made
-    init         Alias for default install (backward compat)
+  ⌨️  Commands:
+    (none)       🧠 Auto-detect and install/update orchestrator
+    status       🟢 Open live control panel
+    mode         🎛️  Show or switch profile
+    budget       💵 Set session/daily spend limits
+    explain      🧭 Explain last routing decision
+    init         Alias for default install
 
   Options:
-    --force      Overwrite all existing config (keeps review-rules.md)
-    --dry-run    Detect environment only, don't install
-    --json       Output detection as JSON (implies --dry-run)
+    --force      Overwrite all existing config
+    --dry-run    Detect environment only
+    --json       Output detection as JSON
     --help       Show this help
 
-  Profiles:
-    balanced       Standard routing — best model for each tier
-    cost-saver     Minimize spend — prefer cheaper models
-    quality-first  Maximum quality — dual-brain for medium+ risk
+  🎛️  Profiles:
+    ⚖️  balanced       Standard routing — best model per tier
+    💸 cost-saver     Minimize spend — prefer cheaper models
+    💎 quality-first  Maximum quality — dual-brain for medium+
 
-  Examples:
+  🚀 Examples:
     ${cmd('npx dual-brain')}                  # install or update
-    ${cmd('npx dual-brain status')}           # live dashboard
+    ${cmd('npx dual-brain status')}           # open control panel
     ${cmd('npx dual-brain mode cost-saver')}  # switch profile
-    ${cmd('npx dual-brain budget 8 25')}      # $8 session / $25 daily
+    ${cmd('npx dual-brain budget 8 25')}      # \$8 session / \$25 daily
     ${cmd('npx dual-brain explain')}          # last routing decision
   `);
   process.exit(0);
@@ -381,43 +381,50 @@ function install(workspace, env, mode) {
 
 // ─── Status Report ──────────────────────────────────────────────────────────
 
-function statusIcon(val) { return val ? '✓' : '✗'; }
+function statusIcon(val) { return val ? '✅' : '❌'; }
+
+const MODE_EMOJIS = {
+  'dual':        '🧠',
+  'claude-only': '🟠',
+  'openai-only': '🟢',
+  'detect-only': '🔎',
+};
 
 function printReport(env, mode, actions) {
   const lines = [];
 
   lines.push(br('╔', '╗'));
-  lines.push(ln(`Dual-Brain Orchestrator v${VERSION}`));
+  lines.push(ln(`🧠 Dual-Brain Orchestrator v${VERSION}`));
   lines.push(sep());
 
-  lines.push(ln('Environment'));
+  lines.push(ln('🌎 Environment'));
   if (env.isReplit) {
-    lines.push(ln(`  Platform:    Replit${env.hasReplitTools ? ' (replit-tools detected)' : ''}`));
+    lines.push(ln(`  🌀 Platform:  Replit${env.hasReplitTools ? ' + replit-tools' : ''}`));
   } else {
     lines.push(ln('  Platform:    standalone'));
   }
 
   const cVer = env.claude.version ? ` ${env.claude.version}` : '';
-  const cAuth = env.claude.authed ? 'authenticated' : env.claude.installed ? 'not authenticated' : 'not found';
-  lines.push(ln(`  Claude CLI:  ${statusIcon(env.claude.authed)} ${cAuth}${cVer}`));
+  const cAuth = env.claude.authed ? '✅ authenticated' : env.claude.installed ? '⚠️  login needed' : '❌ not found';
+  lines.push(ln(`  🟠 Claude:   ${cAuth}${cVer}`));
 
   const xVer = env.codex.version ? ` ${env.codex.version}` : '';
-  const xAuth = env.codex.authed ? 'authenticated' : env.codex.installed ? 'not authenticated' : 'not found';
-  lines.push(ln(`  Codex CLI:   ${statusIcon(env.codex.authed)} ${xAuth}${xVer}`));
+  const xAuth = env.codex.authed ? '✅ authenticated' : env.codex.installed ? '⚠️  login needed' : '❌ not found';
+  lines.push(ln(`  🟢 Codex:    ${xAuth}${xVer}`));
 
   lines.push(sep());
-  lines.push(ln(`Mode: ${MODE_LABELS[mode.mode]}`));
+  lines.push(ln(`${MODE_EMOJIS[mode.mode] || '🧠'} Mode: ${MODE_LABELS[mode.mode]}`));
 
   if (actions) {
     lines.push(sep());
-    lines.push(ln('Installed'));
+    lines.push(ln('📝 Installed'));
     for (const a of actions) lines.push(ln(`  ${a}`));
   }
 
   const needsAction = !env.claude.authed || !env.codex.authed;
   if (needsAction && mode.mode !== 'dual') {
     lines.push(sep());
-    lines.push(ln('To unlock full features:'));
+    lines.push(ln('🔓 Unlock full power:'));
     if (!env.claude.installed) {
       lines.push(ln('  curl -fsSL https://claude.ai/install.sh | sh'));
     }
@@ -436,8 +443,8 @@ function printReport(env, mode, actions) {
   lines.push(sep());
   if (actions) {
     lines.push(ln(mode.mode === 'dual'
-      ? 'Ready — both providers active, no restart needed'
-      : 'Ready — hooks active, run commands above for full power'));
+      ? '✅ Ready: both providers active, no restart needed'
+      : '✅ Ready: hooks active, run commands above for full power'));
   } else {
     lines.push(ln('Dry run — no files written'));
   }
@@ -448,35 +455,26 @@ function printReport(env, mode, actions) {
   console.log('');
 
   if (actions) {
-    console.log('  What just happened:');
-    console.log('  Every Claude Code session in this project now auto-routes');
-    console.log('  agent work by complexity — cheap models for search, mid-tier');
-    console.log('  for execution, best models for thinking. Cost is tracked.');
+    console.log('  🧭 What changed:');
+    console.log('  Every Claude Code session now auto-routes agent work by');
+    console.log('  complexity — cheap models for search, mid-tier for execution,');
+    console.log('  best models for thinking. Cost is tracked automatically.');
     if (mode.mode === 'dual') {
-      console.log('  Both Claude and GPT are available as work providers.');
+      console.log('  🧠 Both Claude and GPT are available as work providers.');
     }
     console.log('');
-    if (IS_REPLIT) {
-      console.log('  Try these in your Replit shell (paste with ! prefix):');
-      console.log(`    ${cmd('npx dual-brain status')}              # live dashboard`);
-      console.log(`    ${cmd('npx dual-brain mode cost-saver')}     # switch profile`);
-      console.log(`    ${cmd('npx dual-brain budget 8 25')}         # set limits`);
-    } else {
-      console.log('  Try these in your next Claude Code session:');
-      console.log('    npx dual-brain status              # live dashboard');
-      console.log('    npx dual-brain mode cost-saver     # switch profile');
-      console.log('    npx dual-brain budget 8 25         # set limits');
-    }
+    console.log('  ⌨️  Open the control panel:');
+    console.log(`    ${cmd('npx dual-brain status')}`);
     console.log('');
-    console.log('  In-session tools (ask Claude to run these):');
+    console.log('  🩺 In-session tools (ask Claude to run):');
     console.log('    node .claude/hooks/health-check.mjs     # verify setup');
     console.log('    node .claude/hooks/cost-report.mjs      # see activity');
-    console.log('    node .claude/hooks/budget-balancer.mjs   # provider balance');
+    console.log('    node .claude/hooks/decision-ledger.mjs  # routing insights');
     if (mode.openaiEnabled) {
       console.log('    node .claude/hooks/dual-brain-review.mjs # GPT code review');
     }
     console.log('');
-    console.log('  Customize:');
+    console.log('  ⚙️  Customize:');
     console.log('    .claude/review-rules.md     # your project\'s review rules');
     console.log('    .claude/orchestrator.json   # routing, budgets, tiers');
     console.log('');
@@ -616,12 +614,13 @@ function cmdMode() {
 
   if (!modeArg || modeArg === 'list') {
     const current = loadProfile(workspace);
+    const PEMOJIS = { balanced: '⚖️ ', 'cost-saver': '💸', 'quality-first': '💎' };
     console.log('');
-    console.log('  Available profiles:');
+    console.log('  🎛️  Profiles:');
     console.log('');
     for (const [name, p] of Object.entries(PROFILES)) {
-      const active = name === current.name ? ' ← active' : '';
-      console.log(`    ${name.padEnd(15)} ${p.description}${active}`);
+      const active = name === current.name ? ' ✅ active' : '';
+      console.log(`    ${PEMOJIS[name] || '  '} ${name.padEnd(15)} ${p.description}${active}`);
     }
     console.log('');
     console.log(`  Switch: ${cmd('npx dual-brain mode <profile>')}`);
@@ -647,17 +646,18 @@ function cmdMode() {
 
   saveProfile(workspace, modeArg, customOverrides);
 
+  const PEMOJIS = { balanced: '⚖️ ', 'cost-saver': '💸', 'quality-first': '💎' };
   console.log('');
-  console.log(`  Profile switched to: ${modeArg}`);
+  console.log(`  ✅ Profile switched: ${PEMOJIS[modeArg] || ''} ${modeArg}`);
   console.log(`  ${profile.description}`);
   console.log('');
-  console.log('  What changed:');
-  console.log(`    Routing:      ${profile.routing.prefer_provider}`);
-  console.log(`    Budget:       $${profile.budgets.session_limit_usd}/session, $${profile.budgets.daily_limit_usd}/day`);
-  console.log(`    Reviews from: ${profile.quality_gate.sensitivity_floor} risk+`);
-  console.log(`    Dual-brain:   ${profile.quality_gate.dual_brain_minimum} risk+`);
+  console.log('  🧭 Routing changes:');
+  console.log(`    Provider:     ${profile.routing.prefer_provider}`);
+  console.log(`    💵 Budget:    $${profile.budgets.session_limit_usd}/session, $${profile.budgets.daily_limit_usd}/day`);
+  console.log(`    🛡️  Reviews:   ${profile.quality_gate.sensitivity_floor} risk+`);
+  console.log(`    🧠 Dual-brain: ${profile.quality_gate.dual_brain_minimum} risk+`);
   console.log('');
-  console.log('  Active immediately — no restart needed.');
+  console.log('  🟢 Active immediately, no restart needed.');
   console.log('');
 }
 
@@ -671,9 +671,9 @@ function cmdBudget() {
   if (sessionArg == null) {
     const profile = loadProfile(workspace);
     console.log('');
-    console.log('  Current budget limits:');
-    console.log(`    Session: warn $${profile.budgets.session_warn_usd} / limit $${profile.budgets.session_limit_usd}`);
-    console.log(`    Daily:   warn $${profile.budgets.daily_warn_usd} / limit $${profile.budgets.daily_limit_usd}`);
+    console.log('  💵 Current budget:');
+    console.log(`    Session: ⚠️  $${profile.budgets.session_warn_usd} warn · 🛑 $${profile.budgets.session_limit_usd} limit`);
+    console.log(`    Daily:   ⚠️  $${profile.budgets.daily_warn_usd} warn · 🛑 $${profile.budgets.daily_limit_usd} limit`);
     console.log('');
     console.log(`  Set limits: ${cmd('npx dual-brain budget <session$> [daily$]')}`);
     console.log(`  Example:    ${cmd('npx dual-brain budget 8 25')}`);
@@ -710,11 +710,11 @@ function cmdBudget() {
   renameSync(budgetTmp, budgetTarget);
 
   console.log('');
-  console.log('  Budget limits updated:');
-  console.log(`    Session: warn $${customOverrides.budgets.session_warn_usd} / limit $${sessionArg}`);
-  console.log(`    Daily:   warn $${customOverrides.budgets.daily_warn_usd} / limit $${daily}`);
+  console.log('  ✅ Budget updated:');
+  console.log(`    Session: ⚠️  $${customOverrides.budgets.session_warn_usd} warn · 🛑 $${sessionArg} limit`);
+  console.log(`    Daily:   ⚠️  $${customOverrides.budgets.daily_warn_usd} warn · 🛑 $${daily} limit`);
   console.log('');
-  console.log('  Active immediately — no restart needed.');
+  console.log('  🟢 Active immediately, no restart needed.');
   console.log('');
 }
 
@@ -728,7 +728,7 @@ function cmdExplain() {
 
   if (!existsSync(logFile)) {
     console.log('');
-    console.log('  No routing decisions recorded today.');
+    console.log('  💤 No routing decisions recorded today.');
     console.log('  Start a Claude Code session and the tier enforcer will log decisions.');
     console.log('');
     return;
@@ -752,7 +752,7 @@ function cmdExplain() {
 
   if (!lastRec) {
     console.log('');
-    console.log('  No routing decisions found in today\'s log.');
+    console.log('  💤 No routing decisions found in today\'s log.');
     console.log('  The tier enforcer logs decisions when Agent tool is used.');
     console.log('');
     return;
@@ -761,23 +761,23 @@ function cmdExplain() {
   const profile = loadProfile(workspace);
 
   console.log('');
-  console.log('  Last Routing Decision');
+  console.log('  🧭 Last Routing Decision');
   console.log('  ' + '─'.repeat(40));
-  console.log(`  Time:        ${lastRec.timestamp?.slice(11, 19) || 'unknown'}`);
-  console.log(`  Detected:    ${lastRec.detected_tier || 'unknown'} tier`);
-  console.log(`  Recommended: ${lastRec.recommended_model || 'unknown'}`);
-  console.log(`  Actual:      ${lastRec.actual_model || 'unknown'}`);
-  console.log(`  Followed:    ${lastRec.followed ? 'yes' : 'no'}`);
-  console.log(`  Profile:     ${profile.name}`);
+  console.log(`  🕐 Time:         ${lastRec.timestamp?.slice(11, 19) || 'unknown'}`);
+  console.log(`  🔎 Detected:     ${lastRec.detected_tier || 'unknown'} tier`);
+  console.log(`  🧠 Recommended:  ${lastRec.recommended_model || 'unknown'}`);
+  console.log(`  🎯 Actual:       ${lastRec.actual_model || 'unknown'}`);
+  console.log(`  ${lastRec.followed ? '✅' : '⚠️'}  Followed:     ${lastRec.followed ? 'yes' : 'no'}`);
+  console.log(`  🎛️  Profile:      ${profile.name}`);
   console.log('');
 
   if (!lastRec.followed) {
-    console.log('  The recommendation was not followed. This may mean:');
+    console.log('  ⚠️  Recommendation was overridden. This may mean:');
     console.log('  - The task needed a different model (valid override)');
     console.log('  - The subagent_type forced a specific tier');
     console.log(`  - Profile "${profile.name}" adjusted the threshold`);
   } else {
-    console.log('  The recommendation was followed — routing worked as expected.');
+    console.log('  ✅ Routing matched the recommendation.');
   }
 
   let total = 0, followed = 0;
@@ -796,7 +796,18 @@ function cmdExplain() {
 // ─── Main ───────────────────────────────────────────────────────────────────
 
 function main() {
-  if (subcommand === 'status')  { cmdStatus();  return; }
+  if (subcommand === 'status') {
+    // Launch interactive TUI if available and TTY
+    const panelPath = join(resolve(process.cwd()), '.claude', 'hooks', 'control-panel.mjs');
+    const pkgPanel = join(__dirname, 'hooks', 'control-panel.mjs');
+    const panel = existsSync(panelPath) ? panelPath : existsSync(pkgPanel) ? pkgPanel : null;
+    if (panel && process.stdin.isTTY && process.stdout.isTTY && !process.env.CI) {
+      const { status } = spawnSync(process.execPath, [panel], { stdio: 'inherit' });
+      process.exit(status || 0);
+    }
+    cmdStatus();
+    return;
+  }
   if (subcommand === 'mode')    { cmdMode();    return; }
   if (subcommand === 'budget')  { cmdBudget();  return; }
   if (subcommand === 'explain') { cmdExplain(); return; }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dual-brain",
-  "version": "3.2.0",
+  "version": "3.3.0",
   "description": "Dual-provider orchestration for Claude Code — tiered routing, budget balancing, and GPT dual-brain review across Claude + OpenAI subscriptions",
   "type": "module",
   "bin": {