dual-brain 0.1.6 → 0.1.7

package/bin/dual-brain.mjs

@@ -368,22 +368,24 @@ async function cmdGo(args) {
     vtrace(`Dual-brain: ${decision.dualBrain ? 'yes' : 'no'} (${isSoloBrain(profile) ? 'solo provider' : 'dual provider'}, ${detection.risk} risk)`);
   }
 
-  // Print routing table
-  console.log(`  provider   : ${decision.provider}`);
-  console.log(`  model      : ${decision.model}${decision.effort ? ' (' + decision.effort + ')' : ''}`);
-  console.log(`  tier       : ${decision.tier}`);
-  console.log(`  dual-brain : ${decision.dualBrain ? 'yes' : 'no'}`);
-  console.log(`  reason     : ${decision.explanation}`);
+  // Print routing table (only in dry-run or verbose; silent in normal mode)
+  if (dryRun || verbose) {
+    console.log(`  provider   : ${decision.provider}`);
+    console.log(`  model      : ${decision.model}${decision.effort ? ' (' + decision.effort + ')' : ''}`);
+    console.log(`  tier       : ${decision.tier}`);
+    console.log(`  dual-brain : ${decision.dualBrain ? 'yes' : 'no'}`);
+    console.log(`  reason     : ${decision.explanation}`);
+  }
 
   if (dryRun) {
     console.log('\n(dry-run — not executing)');
     return;
   }
 
-  console.log('\nDispatching...');
+  if (verbose) console.log('\nDispatching...');
   let result;
   if (decision.dualBrain) {
-    result = await dispatchDualBrain({ decision, prompt, files, cwd });
+    result = await dispatchDualBrain({ decision, prompt, files, cwd, verbose });
     console.log(`\nConsensus: ${result.consensus}`);
     if (result.claude?.summary) console.log(`Claude : ${result.claude.summary}`);
     if (result.openai?.summary) console.log(`OpenAI : ${result.openai.summary}`);
@@ -398,7 +400,7 @@ async function cmdGo(args) {
       nextAction:   null,
     }, cwd);
   } else {
-    result = await dispatch({ decision, prompt, files, cwd });
+    result = await dispatch({ decision, prompt, files, cwd, verbose });
     const statusLine = result.status === 'completed' ? 'Done' : `Failed (exit ${result.exitCode})`;
     console.log(`\n${statusLine} in ${(result.durationMs / 1000).toFixed(1)}s`);
     if (result.summary) console.log(result.summary);
@@ -1000,6 +1002,176 @@ function loadTerminalState(cwd, terminalId) {
 
 // ─── Dashboard box helpers ────────────────────────────────────────────────────
 
+/**
+ * Detect repo state for action cards. All checks run with tight timeouts —
+ * best-effort only, never blocks startup.
+ *
+ * Returns: { dirtyCount, lastCommitAgeDays, lastFailure, isGitRepo }
+ */
+function detectRepoState(cwd) {
+  const result = { dirtyCount: 0, lastCommitAgeDays: 0, lastFailure: null, isGitRepo: false };
+  try {
+    execSync('git rev-parse --git-dir', { cwd, encoding: 'utf8', timeout: 2000, stdio: 'pipe' });
+    result.isGitRepo = true;
+  } catch { return result; }
+
+  try {
+    const status = execSync('git status --porcelain', { cwd, encoding: 'utf8', timeout: 2000, stdio: 'pipe' });
+    result.dirtyCount = status.trim().split('\n').filter(Boolean).length;
+  } catch {}
+
+  try {
+    const logOut = execSync('git log --format="%ct" -1', { cwd, encoding: 'utf8', timeout: 2000, stdio: 'pipe' }).trim();
+    if (logOut) {
+      const commitTs = parseInt(logOut, 10) * 1000;
+      result.lastCommitAgeDays = Math.floor((Date.now() - commitTs) / 86400000);
+    }
+  } catch {}
+
+  try {
+    const sessionPath = join(cwd, '.dualbrain', 'session.json');
+    if (existsSync(sessionPath)) {
+      const sess = JSON.parse(readFileSync(sessionPath, 'utf8'));
+      const lastResult = sess?.lastResult;
+      if (lastResult?.status === 'failure') {
+        const summary = lastResult.task
+          ? String(lastResult.task).slice(0, 40)
+          : 'last task';
+        result.lastFailure = summary;
+      }
+    }
+  } catch {}
+
+  return result;
+}
+
+/**
+ * Build action card rows for the dashboard based on repo state.
+ * Returns an array of box row strings (may be empty).
+ */
+function buildActionRows(repoState, rowFn) {
+  if (!repoState.isGitRepo) return [];
+
+  const YELLOW = '\x1b[33m';
+  const RED    = '\x1b[31m';
+  const GREEN  = '\x1b[32m';
+  const DIM    = '\x1b[2m';
+  const RESET  = '\x1b[0m';
+
+  const cards = [];
+
+  if (repoState.dirtyCount > 0) {
+    cards.push(`${YELLOW}⚡${RESET} ${repoState.dirtyCount} uncommitted file${repoState.dirtyCount === 1 ? '' : 's'}`);
+  }
+
+  if (repoState.lastFailure !== null) {
+    cards.push(`${RED}⚡${RESET} Last task failed: ${repoState.lastFailure}`);
+  }
+
+  if (repoState.lastCommitAgeDays >= 3) {
+    cards.push(`${YELLOW}⚡${RESET} ${repoState.lastCommitAgeDays} day${repoState.lastCommitAgeDays === 1 ? '' : 's'} since last commit`);
+  }
+
+  if (cards.length === 0) {
+    return [rowFn(`${DIM}${GREEN}✓${RESET}${DIM} Repo clean${RESET}`)];
+  }
+
+  return cards.map(c => rowFn(c));
+}
+
+/**
+ * Detect interrupted work from the most recent session.
+ * Returns a continuation hint if confidence is high enough, or null to skip.
+ *
+ * Signals that indicate interrupted work:
+ *  - Session < 4 hours old with no clean exit
+ *  - Last result was a failure
+ *  - Uncommitted git changes exist
+ *  - Session has high message count (user was deep in work)
+ *
+ * Minimum thresholds: messageCount > 5 OR filesChanged > 0
+ *
+ * @param {Array} sessions   — from importReplitSessions / enrichSessions
+ * @param {string} cwd
+ * @returns {{ shouldContinue: boolean, reason: string, sessionId: string, sessionName: string, lastState: string|null, ageLabel: string }|null}
+ */
+function detectInterruptedWork(sessions, cwd) {
+  if (!sessions || sessions.length === 0) return null;
+
+  const most = sessions[0]; // already sorted most-recent first
+  if (!most || !most.lastActive) return null;
+
+  const ageMs = Date.now() - new Date(most.lastActive).getTime();
+  const fourH = 4 * 60 * 60 * 1000;
+
+  // Must be within 4 hours
+  if (ageMs >= fourH) return null;
+
+  // Load session.json for deeper signal
+  const session = loadSession(cwd);
+
+  // Minimum thresholds: must have real work depth
+  const msgCount     = most.messageCount ?? most.promptCount ?? 0;
+  const filesChanged = session?.filesChanged?.length ?? 0;
+  if (msgCount <= 5 && filesChanged === 0) return null;
+
+  const lastResultStatus = session?.lastResult?.status ?? null;
+
+  // Build confidence signals
+  const signals = [];
+  if (lastResultStatus === 'failure') signals.push('last run failed');
+  if (filesChanged > 0) signals.push(`${filesChanged} file${filesChanged !== 1 ? 's' : ''} changed`);
+  if (msgCount > 10) signals.push('deep session');
+
+  // Check for uncommitted git changes
+  try {
+    const gitResult = _spawnSyncTop('git', ['status', '--porcelain'], {
+      cwd,
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 3000,
+    });
+    if (gitResult.status === 0 && gitResult.stdout.trim().length > 0) {
+      signals.push('uncommitted changes');
+    }
+  } catch { /* non-fatal */ }
+
+  // Need at least one signal beyond base thresholds to avoid annoying low-signal cards
+  if (signals.length === 0 && msgCount <= 10) return null;
+
+  // Build a human-readable "last state" from available data
+  let lastState = null;
+  if (session?.lastResult?.summary) {
+    lastState = session.lastResult.summary;
+  } else if (session?.objective) {
+    lastState = session.objective;
+  } else if (most.name && !/^Session [0-9a-f]{8}/i.test(most.name)) {
+    lastState = most.name;
+  }
+
+  // Trim lastState to fit on one line
+  if (lastState && lastState.length > 45) lastState = lastState.slice(0, 42) + '...';
+
+  // Build reason label
+  const reason = signals.length > 0 ? signals.join(', ') : `${msgCount} messages`;
+
+  // Age label
+  const mins = Math.floor(ageMs / 60000);
+  let ageLabel;
+  if (mins < 1)       ageLabel = 'just now';
+  else if (mins < 60) ageLabel = `${mins}m ago`;
+  else                ageLabel = `${Math.floor(mins / 60)}h ago`;
+
+  return {
+    shouldContinue: true,
+    reason,
+    sessionId:   most.id,
+    sessionName: most.name || most.id.slice(0, 8),
+    lastState,
+    ageLabel,
+  };
+}
+
 /**
  * Build a provider status string for the dashboard status line.
  * Returns a string like: "🟢 Claude $100×2 $20×1  🟢 OpenAI $100"
@@ -1105,6 +1277,9 @@ async function mainScreen(rl, ask) {
   const rtMain    = detectReplitTools(cwd);
   const dtVersion = (rtMain.installed && rtMain.version) ? rtMain.version : null;
 
+  // ── Interrupted work detection ────────────────────────────────────────────
+  const interrupted = detectInterruptedWork(allSessions, cwd);
+
   // ── Box layout ────────────────────────────────────────────────────────────
   const termW = process.stdout.columns || 60;
   const boxW  = Math.min(termW - 2, 60); // outer width (including │ │)
@@ -1135,6 +1310,84 @@ async function mainScreen(rl, ask) {
     }
   }
 
+  // ── Continuation card (interrupted work) ─────────────────────────────────
+  if (interrupted) {
+    const ctop = `┌${'─'.repeat(boxW - 2)}┐`;
+    const csep = `├${'─'.repeat(boxW - 2)}┤`;
+    const cbot = `└${'─'.repeat(boxW - 2)}┘`;
+    const crow = (content) => makeBoxRow(content, W);
+
+    const titleLine = `\x1b[33m💡\x1b[0m Continue: ${interrupted.sessionName}`;
+    const lastLine  = interrupted.lastState
+      ? `   Last: ${interrupted.lastState} · ${interrupted.ageLabel}`
+      : `   ${interrupted.reason} · ${interrupted.ageLabel}`;
+    const actLine   = '   [Enter] Resume  [n] New session  [s] Skip';
+
+    process.stdout.write([ctop, crow(titleLine), csep, crow(lastLine), crow(actLine), cbot].join('\n') + '\n\n');
+
+    // Wait for a keypress to decide what to do with the card
+    const readline2 = await import('node:readline');
+    readline2.emitKeypressEvents(process.stdin, rl);
+
+    const cardChoice = await new Promise((resolve) => {
+      const wasRaw2 = process.stdin.isRaw;
+      const canRaw2 = process.stdin.isTTY && typeof process.stdin.setRawMode === 'function';
+      if (canRaw2) process.stdin.setRawMode(true);
+
+      const cleanup2 = () => {
+        process.stdin.removeListener('keypress', onCardKey);
+        if (canRaw2) {
+          try { process.stdin.setRawMode(wasRaw2 || false); } catch {}
+        }
+      };
+
+      const onCardKey = (str, key) => {
+        if (!key) return;
+        const name = key.name || '';
+        const seq  = key.sequence || str || '';
+
+        if (key.ctrl && (name === 'c' || name === 'd')) {
+          cleanup2();
+          process.stdout.write('\n');
+          resolve('q');
+          return;
+        }
+
+        if (name === 'return' || name === 'enter' || seq === '\r' || seq === '\n') {
+          cleanup2();
+          process.stdout.write('\n');
+          resolve('resume');
+          return;
+        }
+
+        if (!str || str.length === 0) return;
+        const lower = str.toLowerCase();
+        if (lower === 'n' || lower === 's' || lower === 'q') {
+          cleanup2();
+          process.stdout.write('\n');
+          resolve(lower);
+          return;
+        }
+      };
+
+      process.stdin.on('keypress', onCardKey);
+    });
+
+    if (cardChoice === 'q') return { next: 'exit' };
+
+    if (cardChoice === 'resume') {
+      const { spawnSync } = await import('node:child_process');
+      process.stdout.write(`  Launching: claude --resume ${interrupted.sessionId}\n\n`);
+      spawnSync('claude', ['--resume', interrupted.sessionId], { stdio: 'inherit' });
+      saveTerminalState(cwd, getTerminalId(), interrupted.sessionId, 'claude');
+      return { next: 'main' };
+    }
+
+    if (cardChoice === 'n') return { next: 'new-session' };
+
+    // 's' → fall through to normal dashboard
+  }
+
   // ── Status section ────────────────────────────────────────────────────────
   const providerLine = buildProviderStatusLine(profile, auth);
 
@@ -1143,6 +1396,10 @@ async function mainScreen(rl, ask) {
     statusRows.push(row(`\x1b[2m📦 data-tools v${dtVersion}\x1b[0m`));
   }
 
+  // ── Action cards (git state) ──────────────────────────────────────────────
+  const repoState  = detectRepoState(cwd);
+  const actionRows = buildActionRows(repoState, row);
+
   // ── Sessions section ──────────────────────────────────────────────────────
   const sessionRows = [];
   if (recentSessions.length === 0) {
@@ -1199,9 +1456,11 @@ async function mainScreen(rl, ask) {
   const actionsRow     = row(actionsContent);
 
   // ── Print the full box ────────────────────────────────────────────────────
+  // Include action cards between status and sessions (with separators only when non-empty)
   const lines = [
     top,
     ...statusRows,
+    ...(actionRows.length > 0 ? [sep, ...actionRows] : []),
     sep,
     ...sessionRows,
     sep,
@@ -3153,22 +3412,25 @@ async function cmdSpecialistGo(specialist, args) {
     vtrace(`Dual-brain: ${decision.dualBrain ? 'yes' : 'no'}`);
   }
 
-  console.log(`  specialist : ${specialist}`);
-  console.log(`  provider   : ${decision.provider}`);
-  console.log(`  model      : ${decision.model}${decision.effort ? ' (' + decision.effort + ')' : ''}`);
-  console.log(`  tier       : ${decision.tier}`);
-  console.log(`  dual-brain : ${decision.dualBrain ? 'yes' : 'no'}`);
-  console.log(`  reason     : ${decision.explanation}`);
+  // Print routing table (only in dry-run or verbose; silent in normal mode)
+  if (dryRun || verbose) {
+    console.log(`  specialist : ${specialist}`);
+    console.log(`  provider   : ${decision.provider}`);
+    console.log(`  model      : ${decision.model}${decision.effort ? ' (' + decision.effort + ')' : ''}`);
+    console.log(`  tier       : ${decision.tier}`);
+    console.log(`  dual-brain : ${decision.dualBrain ? 'yes' : 'no'}`);
+    console.log(`  reason     : ${decision.explanation}`);
+  }
 
   if (dryRun) {
     console.log('\n(dry-run — not executing)');
     return;
   }
 
-  console.log('\nDispatching...');
+  if (verbose) console.log('\nDispatching...');
   let result;
   if (decision.dualBrain) {
-    result = await dispatchDualBrain({ decision, prompt, files, cwd });
+    result = await dispatchDualBrain({ decision, prompt, files, cwd, verbose });
     console.log(`\nConsensus: ${result.consensus}`);
     if (result.claude?.summary) console.log(`Claude : ${result.claude.summary}`);
     if (result.openai?.summary) console.log(`OpenAI : ${result.openai.summary}`);
@@ -3182,7 +3444,7 @@ async function cmdSpecialistGo(specialist, args) {
       nextAction:   null,
     }, cwd);
   } else {
-    result = await dispatch({ decision, prompt, files, cwd });
+    result = await dispatch({ decision, prompt, files, cwd, verbose });
     const statusLine = result.status === 'completed' ? 'Done' : `Failed (exit ${result.exitCode})`;
     console.log(`\n${statusLine} in ${(result.durationMs / 1000).toFixed(1)}s`);
     if (result.summary) console.log(result.summary);
@@ -3242,13 +3504,26 @@ async function main() {
         await runScreens('main');
       }
     } else {
-      // Non-TTY: print status card and exit
-      const cwd = process.cwd();
-      const repo    = loadRepoCache(cwd);
-      const session = loadSession(cwd);
-      const health  = getHealth(cwd);
-      const card    = formatSessionCard(session, repo, health);
-      console.log(card);
+      // Non-TTY with no args: read stdin as a task and run one-shot
+      const stdinTask = await new Promise((resolve) => {
+        let data = '';
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', chunk => { data += chunk; });
+        process.stdin.on('end', () => resolve(data.trim()));
+        // If stdin has no data within 200ms (not truly piped), fall back to status card
+        setTimeout(() => resolve(null), 200);
+      });
+      if (stdinTask) {
+        process.stderr.write('🧠 routing...\n');
+        await cmdGo([stdinTask]);
+      } else {
+        const cwd = process.cwd();
+        const repo    = loadRepoCache(cwd);
+        const session = loadSession(cwd);
+        const health  = getHealth(cwd);
+        const card    = formatSessionCard(session, repo, health);
+        console.log(card);
+      }
     }
     return;
   }
@@ -3341,6 +3616,43 @@ fi
     return;
   }
 
+  // ─── One-shot mode ────────────────────────────────────────────────────────────
+  // If cmd is not a recognized subcommand, treat the entire arg list as a task.
+  // e.g. `dual-brain fix failing tests` → same as `dual-brain go "fix failing tests"`
+  const KNOWN_COMMANDS = new Set([
+    'init', 'install', 'auth', 'go', 'status', 'hot', 'cool',
+    'remember', 'forget', 'break-glass', 'specialists', 'search', 'shell-hook',
+    '--help', '-h', '--version', '-v',
+    ...Object.keys(loadSpecialistRegistry()),
+  ]);
+
+  if (!KNOWN_COMMANDS.has(cmd)) {
+    // All of args are part of the task description (plus any flags like --dry-run/--files).
+    // Join non-flag words into a single prompt string so cmdGo's args.find() picks it up.
+    // We strip out flag values (e.g. the value after --files) before collecting prompt words.
+    process.stderr.write('🧠 routing...\n');
+    const flagValuesToSkip = new Set();
+    const pairedFlags = ['--files'];
+    for (const f of pairedFlags) {
+      const idx = args.indexOf(f);
+      if (idx !== -1 && args[idx + 1] && !args[idx + 1].startsWith('--')) {
+        flagValuesToSkip.add(args[idx + 1]);
+      }
+    }
+    const passedFlags = [];
+    for (let i = 0; i < args.length; i++) {
+      if (args[i].startsWith('--') || args[i].startsWith('-')) {
+        passedFlags.push(args[i]);
+        if (pairedFlags.includes(args[i]) && args[i + 1] && !args[i + 1].startsWith('--')) {
+          passedFlags.push(args[++i]);
+        }
+      }
+    }
+    const promptWords = args.filter(a => !a.startsWith('--') && !a.startsWith('-') && !flagValuesToSkip.has(a));
+    await cmdGo([promptWords.join(' '), ...passedFlags]);
+    return;
+  }
+
   process.stderr.write(`Unknown command: ${cmd}\nRun "dual-brain --help" for usage.\n`);
   process.exit(1);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dual-brain",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "AI orchestration across Claude + OpenAI subscriptions — smart routing, budget awareness, and dual-brain collaboration",
   "type": "module",
   "bin": {

package/src/decide.mjs

@@ -6,7 +6,7 @@
  * to use and explains why in one sentence.
  *
  * Exports: decideRoute, getModelCapabilities, getAvailableModels,
- *          estimateBudgetPressure, shouldDualBrain, explainDecision
+ *          estimateBudgetPressure, shouldDualBrain, explainDecision, getFailoverOrder
  *
  * CLI: node src/decide.mjs --profile /path/to/profile.json \
  *        --detection '{"intent":"edit","risk":"low","complexity":"simple","effort":"medium","tier":"execute"}'
@@ -602,6 +602,82 @@ export function decideRoute({ profile = {}, detection = {}, cwd } = {}) {
   return result;
 }
 
+// ─── Exported: getFailoverOrder ──────────────────────────────────────────────
+
+/**
+ * Given a failed routing decision and the active profile, return an ordered list
+ * of fallback options to try next.
+ *
+ * Priority order:
+ *   1. Other subscriptions of the same provider (e.g. Claude Max #2 before Claude Pro)
+ *   2. Other provider (OpenAI or Claude, whichever wasn't tried)
+ *
+ * Within each group, options are ordered by capability match for the tier
+ * (best fit first, cheapest last).
+ *
+ * @param {object} decision  The routing decision that just failed (provider, model, tier)
+ * @param {object} profile   Active profile with providers/subscriptions info
+ * @returns {Array<{ provider: string, model: string, plan: string, label: string }>}
+ */
+export function getFailoverOrder(decision, profile) {
+  const { provider: failedProvider, model: failedModel, tier = 'execute' } = decision;
+  const available = getAvailableModels(profile);
+
+  // Build a ranked model list for Claude (best capability for tier → cheapest)
+  const claudeRankByTier = {
+    think:   ['opus', 'sonnet', 'haiku'],
+    execute: ['sonnet', 'opus', 'haiku'],
+    search:  ['haiku', 'sonnet', 'opus'],
+  };
+  const openaiRankByTier = {
+    think:   ['o3', 'gpt-4o', 'gpt-4.1', 'gpt-4.1-mini', 'gpt-4o-mini'],
+    execute: ['gpt-4o', 'gpt-4.1', 'o3', 'gpt-4.1-mini', 'gpt-4o-mini'],
+    search:  ['gpt-4o-mini', 'gpt-4.1-mini', 'gpt-4.1', 'gpt-4o', 'o3'],
+  };
+
+  const claudeRank = claudeRankByTier[tier] ?? claudeRankByTier.execute;
+  const openaiRank = openaiRankByTier[tier] ?? openaiRankByTier.execute;
+
+  const claudeEnabled = !!(profile?.providers?.claude?.enabled && profile?.providers?.claude?.plan);
+  const openaiEnabled = !!(profile?.providers?.openai?.enabled && profile?.providers?.openai?.plan);
+  const claudePlan    = profile?.providers?.claude?.plan ?? '$20';
+  const openaiPlan    = profile?.providers?.openai?.plan ?? '$20';
+
+  const fallbacks = [];
+
+  if (failedProvider === 'claude') {
+    // Same-provider fallbacks: other Claude models (skip the one that just failed)
+    for (const m of claudeRank) {
+      if (m === failedModel) continue;
+      if (!available.claude.includes(m)) continue;
+      fallbacks.push({ provider: 'claude', model: m, plan: claudePlan, label: `Claude ${m} (${claudePlan})` });
+    }
+    // Cross-provider fallbacks: OpenAI models
+    if (openaiEnabled) {
+      for (const m of openaiRank) {
+        if (!available.openai.includes(m)) continue;
+        fallbacks.push({ provider: 'openai', model: m, plan: openaiPlan, label: `OpenAI ${m} (${openaiPlan})` });
+      }
+    }
+  } else {
+    // Same-provider fallbacks: other OpenAI models (skip the one that just failed)
+    for (const m of openaiRank) {
+      if (m === failedModel) continue;
+      if (!available.openai.includes(m)) continue;
+      fallbacks.push({ provider: 'openai', model: m, plan: openaiPlan, label: `OpenAI ${m} (${openaiPlan})` });
+    }
+    // Cross-provider fallbacks: Claude models
+    if (claudeEnabled) {
+      for (const m of claudeRank) {
+        if (!available.claude.includes(m)) continue;
+        fallbacks.push({ provider: 'claude', model: m, plan: claudePlan, label: `Claude ${m} (${claudePlan})` });
+      }
+    }
+  }
+
+  return fallbacks;
+}
+
 // ─── CLI ──────────────────────────────────────────────────────────────────────
 
 if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {

package/src/dispatch.mjs

@@ -14,6 +14,7 @@ import { fileURLToPath } from 'node:url';
 import { createHash } from 'node:crypto';
 import { markHot, markDegraded, markHealthy, recordDispatch } from './health.mjs';
 import { redact } from './redact.mjs';
+import { getFailoverOrder } from './decide.mjs';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const USAGE_DIR = join(__dirname, '..', '.dualbrain', 'usage');
@@ -93,6 +94,44 @@ function medianDuration(provider, model) {
 // Rate-limit error keywords
 const RATE_LIMIT_PATTERNS = /rate.?limit|quota|capacity|too many requests|overloaded|throttl/i;
 
+// ─── Auto-heal failover helpers ───────────────────────────────────────────────
+
+const FAILOVER_LOG_DIR = join(__dirname, '..', '.dualbrain', 'audit');
+
+/** Retryable exit-code-1 patterns: rate limits, quota, capacity, timeouts */
+const RETRYABLE_PATTERNS = /rate.?limit|429|quota.?exceeded|capacity|overloaded|timeout/i;
+
+/** Non-retryable patterns: auth failures, bad input, user cancellation */
+const NON_RETRYABLE_PATTERNS = /unauthorized|forbidden|invalid.?api.?key|authentication|bad.?request|cancelled|canceled/i;
+
+/**
+ * Decide if a subprocess result is a retryable failure.
+ * Must be exit code 1 (or non-zero) AND match retryable keywords AND NOT match
+ * non-retryable keywords.
+ * @param {{ exitCode: number, stderr: string, stdout: string }} result
+ * @returns {boolean}
+ */
+function isRetryableFailure({ exitCode, stderr, stdout }) {
+  if (exitCode === 0) return false;
+  const errText = `${stderr} ${stdout}`.slice(0, 1000);
+  if (NON_RETRYABLE_PATTERNS.test(errText)) return false;
+  return RETRYABLE_PATTERNS.test(errText);
+}
+
+/**
+ * Append a failover event to .dualbrain/audit/failover.jsonl.
+ * @param {{ from: string, to: string, reason: string, attempt: number }} info
+ */
+function logFailover({ from, to, reason, attempt }) {
+  try {
+    mkdirSync(FAILOVER_LOG_DIR, { recursive: true });
+    appendFileSync(
+      join(FAILOVER_LOG_DIR, 'failover.jsonl'),
+      JSON.stringify({ ts: new Date().toISOString(), from, to, reason, attempt }) + '\n',
+    );
+  } catch {}
+}
+
 // ─── Native Claude Code detection ────────────────────────────────────────────
 
 /**
@@ -607,7 +646,7 @@ function _prependDispatchMarker(prompt) {
 
 // ─── Main dispatch ────────────────────────────────────────────────────────────
 async function dispatch(input = {}) {
-  const { files = [], cwd = process.cwd(), dryRun = false } = input;
+  const { files = [], cwd = process.cwd(), dryRun = false, verbose = false } = input;
   let decision = input.decision ?? {};
   let { prompt } = input;
 
@@ -629,7 +668,7 @@ async function dispatch(input = {}) {
     const specialistPrompt = loadSpecialistPrompt(specialist);
     if (specialistPrompt) {
       prompt = `${specialistPrompt}\n\n---\n\n${prompt}`;
-      process.stderr.write(`[dual-brain] specialist: ${specialist}\n`);
+      if (verbose) process.stderr.write(`[dual-brain] specialist: ${specialist}\n`);
     }
 
     // Apply tier_bias from registry if decision didn't already pin a tier
@@ -638,7 +677,7 @@ async function dispatch(input = {}) {
       const tierBias = registry?.specialists?.[specialist]?.tier_bias;
       if (tierBias) {
         decision = { ...decision, tier: tierBias };
-        process.stderr.write(`[dual-brain] specialist tier_bias applied: ${tierBias}\n`);
+        if (verbose) process.stderr.write(`[dual-brain] specialist tier_bias applied: ${tierBias}\n`);
       }
     }
   }
@@ -736,7 +775,39 @@ async function dispatch(input = {}) {
     _recordDispatchBudget(prompt);
 
     const dispatchEnv = { DUAL_BRAIN_DISPATCH: '1' };
-    const { exitCode, stdout, stderr, durationMs } = await runProcess(command, cwd, timeoutMs, dispatchEnv);
+
+    // ── Auto-heal failover retry loop (native Claude path) ────────────────
+    const MAX_FAILOVER_ATTEMPTS = 2;
+    let currentProvider = effectiveProvider;
+    let currentModel    = effectiveModel;
+    let currentDecision = effectiveDecision;
+    let currentCommand  = command;
+    let lastRaw;
+
+    for (let attempt = 0; attempt <= MAX_FAILOVER_ATTEMPTS; attempt++) {
+      lastRaw = await runProcess(currentCommand, cwd, timeoutMs, dispatchEnv);
+      if (lastRaw.exitCode === 0 || !isRetryableFailure(lastRaw) || attempt === MAX_FAILOVER_ATTEMPTS) break;
+
+      const failoverList = getFailoverOrder(
+        { provider: currentProvider, model: currentModel, tier },
+        input.profile ?? {},
+      );
+      if (failoverList.length === 0) break;
+
+      const next   = failoverList[0];
+      const reason = `${lastRaw.stderr || lastRaw.stdout}`.slice(0, 120);
+      logFailover({ from: `${currentProvider}/${currentModel}`, to: `${next.provider}/${next.model}`, reason, attempt: attempt + 1 });
+      process.stderr.write(`\x1b[2m[dual-brain] Provider busy, failing over to ${next.label}...\x1b[0m\n`);
+
+      markHot(currentProvider, currentModel, cwd);
+      currentProvider = next.provider;
+      currentModel    = next.model;
+      currentDecision = { ...currentDecision, provider: currentProvider, model: currentModel };
+      currentCommand  = buildCommand(currentDecision, prompt, files, cwd);
+    }
+
+    const { exitCode, stdout, stderr, durationMs } = lastRaw;
+    // ── End failover loop ────────────────────────────────────────────────
 
     // Extract token usage from JSON output if available
     let usage = null;
@@ -753,25 +824,25 @@ async function dispatch(input = {}) {
 
     // ── Health tracking ────────────────────────────────────────────────────
     if (success) {
-      recordDuration(effectiveProvider, effectiveModel, durationMs);
-      const median = medianDuration(effectiveProvider, effectiveModel);
+      recordDuration(currentProvider, currentModel, durationMs);
+      const median = medianDuration(currentProvider, currentModel);
       if (median !== null && durationMs > median * 3) {
-        markDegraded(effectiveProvider, effectiveModel, cwd);
+        markDegraded(currentProvider, currentModel, cwd);
       } else {
-        markHealthy(effectiveProvider, effectiveModel, cwd);
+        markHealthy(currentProvider, currentModel, cwd);
       }
       const totalTokens = (usage?.inputTokens ?? 0) + (usage?.outputTokens ?? 0);
-      recordDispatch(effectiveProvider, effectiveModel, totalTokens, cwd);
+      recordDispatch(currentProvider, currentModel, totalTokens, cwd);
     } else {
       if (RATE_LIMIT_PATTERNS.test(errorText)) {
-        markHot(effectiveProvider, effectiveModel, cwd);
+        markHot(currentProvider, currentModel, cwd);
       }
     }
     // ── End health tracking ────────────────────────────────────────────────
 
     recordUsage({
-      provider: effectiveProvider,
-      model:    effectiveModel,
+      provider: currentProvider,
+      model:    currentModel,
       tier,
       durationMs,
       inputTokens:  usage?.inputTokens  ?? null,
@@ -782,10 +853,10 @@ async function dispatch(input = {}) {
     return {
       status:        success ? 'completed' : 'failed',
       type:          'native-agent',
-      provider:      effectiveProvider,
-      model:         effectiveModel,
+      provider:      currentProvider,
+      model:         currentModel,
       specialist:    specialist ?? 'generic',
-      command,
+      command:       currentCommand,
       nativeDispatch: nativeDescriptor,
       exitCode,
       summary,
@@ -804,7 +875,38 @@ async function dispatch(input = {}) {
   // Record this dispatch against the budget
   _recordDispatchBudget(prompt);
 
-  const { exitCode, stdout, stderr, durationMs } = await runProcess(command, cwd, timeoutMs);
+  // ── Auto-heal failover retry loop (subprocess path) ──────────────────────
+  const MAX_FAILOVER_ATTEMPTS_SUB = 2;
+  let subProvider = effectiveProvider;
+  let subModel    = effectiveModel;
+  let subDecision = effectiveDecision;
+  let subCommand  = command;
+  let subRaw;
+
+  for (let attempt = 0; attempt <= MAX_FAILOVER_ATTEMPTS_SUB; attempt++) {
+    subRaw = await runProcess(subCommand, cwd, timeoutMs);
+    if (subRaw.exitCode === 0 || !isRetryableFailure(subRaw) || attempt === MAX_FAILOVER_ATTEMPTS_SUB) break;
+
+    const failoverList = getFailoverOrder(
+      { provider: subProvider, model: subModel, tier },
+      input.profile ?? {},
+    );
+    if (failoverList.length === 0) break;
+
+    const next   = failoverList[0];
+    const reason = `${subRaw.stderr || subRaw.stdout}`.slice(0, 120);
+    logFailover({ from: `${subProvider}/${subModel}`, to: `${next.provider}/${next.model}`, reason, attempt: attempt + 1 });
+    process.stderr.write(`\x1b[2m[dual-brain] Provider busy, failing over to ${next.label}...\x1b[0m\n`);
+
+    markHot(subProvider, subModel, cwd);
+    subProvider = next.provider;
+    subModel    = next.model;
+    subDecision = { ...subDecision, provider: subProvider, model: subModel };
+    subCommand  = buildCommand(subDecision, prompt, files, cwd);
+  }
+
+  const { exitCode, stdout, stderr, durationMs } = subRaw;
+  // ── End failover loop ──────────────────────────────────────────────────────
 
   // Extract token usage from JSON output if available
   let usage = null;
@@ -821,25 +923,25 @@ async function dispatch(input = {}) {
 
   // ── Health tracking ──────────────────────────────────────────────────────
   if (success) {
-    recordDuration(effectiveProvider, effectiveModel, durationMs);
-    const median = medianDuration(effectiveProvider, effectiveModel);
+    recordDuration(subProvider, subModel, durationMs);
+    const median = medianDuration(subProvider, subModel);
     if (median !== null && durationMs > median * 3) {
-      markDegraded(effectiveProvider, effectiveModel, cwd);
+      markDegraded(subProvider, subModel, cwd);
     } else {
-      markHealthy(effectiveProvider, effectiveModel, cwd);
+      markHealthy(subProvider, subModel, cwd);
     }
     const totalTokens = (usage?.inputTokens ?? 0) + (usage?.outputTokens ?? 0);
-    recordDispatch(effectiveProvider, effectiveModel, totalTokens, cwd);
+    recordDispatch(subProvider, subModel, totalTokens, cwd);
   } else {
     if (RATE_LIMIT_PATTERNS.test(errorText)) {
-      markHot(effectiveProvider, effectiveModel, cwd);
+      markHot(subProvider, subModel, cwd);
     }
   }
   // ── End health tracking ──────────────────────────────────────────────────
 
   recordUsage({
-    provider: effectiveProvider,
-    model: effectiveModel,
+    provider: subProvider,
+    model:    subModel,
     tier,
     durationMs,
     inputTokens:  usage?.inputTokens  ?? null,
@@ -849,10 +951,10 @@ async function dispatch(input = {}) {
 
   return {
     status:     success ? 'completed' : 'failed',
-    provider:   effectiveProvider,
-    model:      effectiveModel,
+    provider:   subProvider,
+    model:      subModel,
     specialist: specialist ?? 'generic',
-    command,
+    command:    subCommand,
     exitCode,
     summary,
     durationMs,
@@ -863,7 +965,7 @@ async function dispatch(input = {}) {
 
 // ─── Dual-brain dispatch (parallel) ───────────────────────────────────────────
 async function dispatchDualBrain(input = {}) {
-  const { decision = {}, files = [], cwd = process.cwd(), dryRun = false } = input;
+  const { decision = {}, files = [], cwd = process.cwd(), dryRun = false, verbose = false } = input;
   let { prompt } = input;
   if (!prompt) throw new Error('prompt is required');
 
@@ -887,10 +989,10 @@ async function dispatchDualBrain(input = {}) {
   const [claudeResult, openaiResult] = await Promise.all([
     validatedClaude._error
       ? Promise.resolve({ status: 'error', provider: 'claude', model: claudeDecision.model, command: null, exitCode: null, summary: validatedClaude._error, durationMs: 0, usage: null, error: validatedClaude._error })
-      : dispatch({ decision: validatedClaude, prompt, files, cwd, dryRun }),
+      : dispatch({ decision: validatedClaude, prompt, files, cwd, dryRun, verbose }),
     validatedOpenai._error
       ? Promise.resolve({ status: 'error', provider: 'openai', model: openaiDecision.model, command: null, exitCode: null, summary: validatedOpenai._error, durationMs: 0, usage: null, error: validatedOpenai._error })
-      : dispatch({ decision: validatedOpenai, prompt, files, cwd, dryRun }),
+      : dispatch({ decision: validatedOpenai, prompt, files, cwd, dryRun, verbose }),
   ]);
 
   return {