dual-brain 0.3.28 → 0.3.30

package/bin/dual-brain.mjs

@@ -331,6 +331,38 @@ async function checkForUpdates(currentVersion) {
   } catch {}
   return null;
 }
+
+async function maybeAutoUpdateAndRelaunch(args, { cmd, isInteractive } = {}) {
+  if (!isInteractive) return false;
+  if (process.env.DUAL_BRAIN_NO_AUTO_UPDATE === '1') return false;
+  if (process.env.DUAL_BRAIN_AUTO_UPDATED === '1') return false;
+  const skip = new Set(['update', 'upgrade', 'install', 'uninstall', 'shell-hook', '--version', '-v', '--help', '-h']);
+  if (skip.has(cmd)) return false;
+
+  const current = readVersion();
+  const latest = await checkForUpdates(current);
+  if (!latest) return false;
+
+  const { spawnSync } = await import('node:child_process');
+  process.stdout.write(`\n  Updating dual-brain ${current} -> ${latest}...\n`);
+  const install = spawnSync('npm', ['install', '-g', `dual-brain@${latest}`], {
+    stdio: 'inherit',
+    cwd: process.cwd(),
+  });
+  if (install.status !== 0) {
+    process.stdout.write(`  Update failed; continuing with ${current}.\n\n`);
+    return false;
+  }
+
+  process.stdout.write(`  Updated to ${latest}. Restarting dual-brain...\n\n`);
+  const relaunched = spawnSync('dual-brain', args, {
+    stdio: 'inherit',
+    cwd: process.cwd(),
+    env: { ...process.env, DUAL_BRAIN_AUTO_UPDATED: '1' },
+  });
+  process.exit(relaunched.status ?? 0);
+}
+
 function flag(args, name) { const i = args.indexOf(name); return i !== -1 ? (args[i + 1] ?? true) : null; }
 function err(msg) { process.stderr.write(`Error: ${msg}\n`); process.exit(1); }
 function vtrace(msg) { process.stderr.write(`[verbose] ${msg}\n`); }
@@ -1532,12 +1564,38 @@ async function cmdRuntimeSwitch(args = []) {
 }
 
 async function cmdAuto(args = []) {
-  const switchArgs = ['--automode', '--confirm'];
+  const switchArgs = ['--automode', '--confirm', '--apply'];
   const levelIdx = args.findIndex(a => a === '--level' || a === '--intelligence' || a === '--intelligence-level');
   if (levelIdx !== -1 && args[levelIdx + 1]) switchArgs.push('--level', args[levelIdx + 1]);
   await cmdRuntimeSwitch(switchArgs);
 }
 
+async function cmdSwitchover(args = []) {
+  const cwd = process.cwd();
+  let sessions = [];
+  try { sessions = enrichSessions(importReplitSessions(cwd), cwd); } catch {}
+  const active = readActiveConversation(cwd);
+  const sess = active
+    ? (sessions.find(s => s.id === active.sessionId) || {
+        id: active.sessionId,
+        tool: active.provider,
+        smartName: active.sessionName || active.conversationId || active.sessionId,
+      })
+    : sessions[0];
+  if (!sess) {
+    console.log('No resumable session found.');
+    return;
+  }
+
+  let target = null;
+  const joined = args.join(' ').toLowerCase();
+  if (/\b(gpt|codex|openai)\b/.test(joined)) target = 'codex';
+  if (/\bclaude\b/.test(joined)) target = 'claude';
+  target ||= _sessionTool(sess) === 'codex' ? 'claude' : 'codex';
+
+  await cmdRuntimeSwitch(['--to', target, '--automode', '--confirm', '--apply', '--reason', 'head-switchover']);
+}
+
 async function cmdUpdate() {
   const cwd = process.cwd();
   console.log('  Updating Dual Brain...');
@@ -2501,6 +2559,44 @@ function applyIntelligenceCommand(cmd, cwd) {
   return { scope: 'this session', level: cmd.level };
 }
 
+function parseProviderSwitchCommand(input) {
+  const text = input.trim().toLowerCase().replace(/\s+/g, ' ');
+  if (/\b(switch over|switchover|switch)\b.*\b(auto|automode|auto mode|smart auto)\b/.test(text)) {
+    return { provider: null, automode: true };
+  }
+  if (!/\b(switchover|switch over|switch provider|other provider|continue in (gpt|codex|claude|other provider)|switch (to|into) (gpt|codex|claude|openai))\b/.test(text)) {
+    return null;
+  }
+  let provider = null;
+  if (/\b(gpt|codex|openai)\b/.test(text)) provider = 'codex';
+  if (/\bclaude\b/.test(text)) provider = 'claude';
+  return { provider };
+}
+
+function getActionSession(cwd, recentSessions = []) {
+  const active = readActiveConversation(cwd);
+  if (active) {
+    return recentSessions.find(s => s.id === active.sessionId) || {
+      id: active.sessionId,
+      tool: active.provider,
+      smartName: active.sessionName || active.conversationId || active.sessionId,
+    };
+  }
+  return recentSessions[0] || null;
+}
+
+async function switchProviderNow(cwd, session, target = null) {
+  if (!session) return false;
+  const currentTool = _sessionTool(session);
+  const targetTool = target || (currentTool === 'codex' ? 'claude' : 'codex');
+  const brief = _sessionBrief(session, targetTool);
+  setSessionResumeProvider(cwd, session, targetTool, 'head-provider-switch');
+  writeHandoffConversationLease(cwd, session, currentTool, targetTool, brief);
+  markSessionSuperseded(cwd, session, targetTool, 'head-provider-switch');
+  await cmdSwitch([targetTool, brief]);
+  return true;
+}
+
 async function offerRuntimeReloadAfterModeChange(cwd, ask, recentSessions, label = 'runtime settings') {
   const cyan = '\x1b[36m';
   const reset = '\x1b[0m';
@@ -3330,6 +3426,11 @@ function classifyInput(input) {
     return { tier: 'free', command: 'intelligence', args: [], intelligenceCommand };
   }
 
+  const providerSwitchCommand = parseProviderSwitchCommand(trimmed);
+  if (providerSwitchCommand) {
+    return { tier: 'free', command: 'provider-switch', args: [], providerSwitchCommand };
+  }
+
   // Tier 0: SKILL — slash commands (checked first, deterministic)
   if (trimmed.startsWith('/')) {
     try {
@@ -4224,6 +4325,19 @@ async function mainScreen(rl, ask) {
         return await offerRuntimeReloadAfterModeChange(cwd, ask, recentSessions, `Intelligence ${result.level}`);
       }
 
+      if (cmd === 'provider-switch') {
+        if (classified.providerSwitchCommand.automode) {
+          await cmdAuto(['--level', String(_getIntelligenceLevel(loadProfile(cwd), loadSessionSettings(cwd)))]);
+          return { next: 'main' };
+        }
+        const sess = getActionSession(cwd, recentSessions);
+        if (!sess) return { next: 'new-session' };
+        const target = classified.providerSwitchCommand.provider;
+        process.stdout.write(`\n  Switching HEAD to ${target === 'claude' ? 'Claude' : target === 'codex' ? 'Codex/GPT' : 'the other provider'}...\n\n`);
+        await switchProviderNow(cwd, sess, target);
+        return { next: 'main' };
+      }
+
       if (cmd === 'resume' || cmd === 'r') {
         if (recentSessions.length === 0) return { next: 'new-session' };
         return { next: 'sessions' };
@@ -4548,10 +4662,7 @@ async function switchProviderScreen(rl, ask, ctx = {}) {
   }
   if (choice === 'b' || choice === 'q') return { next: 'main' };
 
-  setSessionResumeProvider(cwd, session, target, 'user-switch-now');
-  writeHandoffConversationLease(cwd, session, currentTool, target, brief);
-  markSessionSuperseded(cwd, session, target, 'manual-provider-switch');
-  await cmdSwitch([target, brief]);
+  await switchProviderNow(cwd, session, target);
   return { next: 'main' };
 }
 
@@ -7756,6 +7867,9 @@ async function main() {
 
   const args = process.argv.slice(2);
   const cmd  = args[0];
+  const isInteractive = process.stdin.isTTY;
+
+  await maybeAutoUpdateAndRelaunch(args, { cmd, isInteractive });
 
   // Session start marker — feeds routing advisor with cross-session timing signals
   try {
@@ -7766,9 +7880,6 @@ async function main() {
   if (cmd === '--help' || cmd === '-h') { printHelp(); return; }
   if (cmd === '--version' || cmd === '-v') { console.log(readVersion()); return; }
 
-  // Interactive-only commands: enter screen state machine (only when TTY)
-  const isInteractive = process.stdin.isTTY;
-
   if (cmd === 'menu') {
     if (!isInteractive) {
       process.stderr.write('dual-brain menu requires an interactive terminal.\n');
@@ -8023,9 +8134,11 @@ async function main() {
   if (cmd === 'pr')       { await cmdPR(args.slice(1)); return; }
   if (cmd === 'status')   { await cmdStatus(args.slice(1)); return; }
   if (cmd === 'handoff')  { await cmdHandoff(args.slice(1)); return; }
+  if (cmd === 'switch' && /\b(auto|automode|auto mode|smart auto)\b/i.test(args.join(' '))) { await cmdAuto(args.slice(1)); return; }
   if (cmd === 'switch')   { await cmdSwitch(args.slice(1)); return; }
   if (cmd === 'runtime-switch') { await cmdRuntimeSwitch(args.slice(1)); return; }
   if (cmd === 'auto' || cmd === 'automode' || cmd === 'smart-auto') { await cmdAuto(args.slice(1)); return; }
+  if (cmd === 'switchover' || cmd === 'switch-over') { await cmdSwitchover(args.slice(1)); return; }
   if (cmd === 'update' || cmd === 'upgrade') { await cmdUpdate(); return; }
   if (cmd === 'hot')      { cmdHot(args[1]); return; }
   if (cmd === 'cool')     { cmdCool(args[1]); return; }
@@ -8090,7 +8203,7 @@ fi
   // 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([
-    'menu', 'init', 'install', 'uninstall', 'auth', 'go', 'do', 'plan', 'ship', 'think', 'review', 'pr', 'status', 'handoff', 'switch', 'runtime-switch', 'auto', 'automode', 'smart-auto', 'hot', 'cool',
+    'menu', 'init', 'install', 'uninstall', 'auth', 'go', 'do', 'plan', 'ship', 'think', 'review', 'pr', 'status', 'handoff', 'switch', 'switchover', 'switch-over', 'runtime-switch', 'auto', 'automode', 'smart-auto', 'hot', 'cool',
     'remember', 'forget', 'break-glass', 'specialists', 'search', 'shell-hook', 'watch', 'update', 'upgrade',
     '--help', '-h', '--version', '-v',
     ...Object.keys(loadSpecialistRegistry()),

package/package.json

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