dual-brain 4.5.0 → 4.6.0

package/install.mjs

@@ -9,6 +9,7 @@
  *   npx dual-brain --help
  */
 import { appendFileSync, cpSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync } from 'fs';
+import https from 'https';
 import { dirname, join, resolve } from 'path';
 import { fileURLToPath } from 'url';
 import { spawnSync } from 'child_process';
@@ -29,9 +30,14 @@ const flag = (f) => argv.includes(f);
 const force = flag('--force');
 const dryRun = flag('--dry-run');
 const jsonOut = flag('--json');
+const yesFlag = flag('--yes') || flag('-y');
+const noLaunch = flag('--no-launch');
 const positional = argv.filter(a => !a.startsWith('-'));
 const subcommand = positional[0] || null;
 
+const BRAND = `Data Tools — Dual Brain v${VERSION}`;
+const BRAND_SUBTITLE = 'Built on replit-tools by Steve Moraco';
+
 if (flag('--version') || flag('-v')) {
   console.log(`dual-brain v${VERSION}`);
   process.exit(0);
@@ -39,13 +45,18 @@ if (flag('--version') || flag('-v')) {
 
 if (flag('--help') || flag('-h')) {
   console.log(`
-  🧠 dual-brain v${VERSION} — Dual-provider orchestrator for Claude Code
+  ${BRAND}
+  ${BRAND_SUBTITLE}
 
   Usage:  npx -y dual-brain [command] [options]
 
   Setup:
-    (none)       Auto-detect and install/update orchestrator
+    (none)       Start persistent chat (setup if needed)
     init         Alias for default install
+    start        Start persistent chat
+    chat         Alias for start
+    auth         Check and repair provider authentication
+    setup        Configure providers, hooks, and preferences
     doctor       Check system health and report issues
     reset        Clear all state files (keeps config/hooks)
     repair       Fix corrupt files, stale locks, re-register hooks
@@ -99,6 +110,7 @@ if (flag('--help') || flag('-h')) {
     --force      Overwrite all existing config
     --dry-run    Detect environment only
     --json       Output detection as JSON
+    --no-launch  Install/setup only, do not open Claude
     --help       Show this help
 
   Routing modes:
@@ -108,7 +120,8 @@ if (flag('--help') || flag('-h')) {
     Aggressive     Maximizes both subscriptions, dual-brain for medium+
 
   Examples:
-    ${cmd('npx dual-brain')}                  # install or update
+    ${cmd('npx dual-brain')}                  # quick start
+    ${cmd('npx dual-brain setup')}            # configure providers and hooks
     ${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
@@ -124,10 +137,11 @@ if (flag('--help') || flag('-h')) {
 }
 
 const SUBCOMMANDS = [
-  'init', 'status', 'mode', 'budget', 'explain',
+  'init', 'setup', 'status', 'mode', 'budget', 'explain',
   'review', 'think', 'health', 'report', 'gate',
   'vibe', 'plan', 'cost', 'dispatch', 'memory',
   'test', 'ledger', 'doctor', 'reset', 'repair',
+  'auth', 'start', 'chat',
   'chain', 'chains',
   'agent', 'agents',
   'do', 'ship', 'test-run', 'diff', 'runs', 'resume',
@@ -166,6 +180,240 @@ function detectReplit() {
   return { isReplit, hasReplitTools };
 }
 
+// ─── Session Preferences + Auth Helpers ────────────────────────────────────
+
+const SESSION_PREFS_REL = '.claude/dual-brain.session.json';
+const DEFAULT_SESSION_PREFS = {
+  head_model: 'sonnet',
+  effort: 'medium',
+};
+
+function writeAtomicJson(targetPath, data) {
+  const tmpPath = `${targetPath}.tmp.${process.pid}`;
+  writeFileSync(tmpPath, JSON.stringify(data, null, 2) + '\n');
+  renameSync(tmpPath, targetPath);
+}
+
+function loadSessionPrefs(workspace) {
+  const prefsPath = join(workspace, SESSION_PREFS_REL);
+  try {
+    const raw = JSON.parse(readFileSync(prefsPath, 'utf8'));
+    return { ...DEFAULT_SESSION_PREFS, ...raw };
+  } catch {
+    return { ...DEFAULT_SESSION_PREFS };
+  }
+}
+
+function saveSessionPrefs(workspace, prefs) {
+  const claudeDir = join(workspace, '.claude');
+  mkdirSync(claudeDir, { recursive: true });
+  const prefsPath = join(workspace, SESSION_PREFS_REL);
+  writeAtomicJson(prefsPath, { ...DEFAULT_SESSION_PREFS, ...prefs });
+}
+
+function getClaudeCredentialPaths(workspace = process.cwd()) {
+  const configDir = process.env.CLAUDE_CONFIG_DIR;
+  const home = process.env.HOME || '';
+  return [
+    configDir ? join(configDir, '.credentials.json') : null,
+    join(home, '.claude', '.credentials.json'),
+    resolve(workspace, '.replit-tools', '.claude-persistent', '.credentials.json'),
+  ].filter(Boolean);
+}
+
+function safeParseJson(path) {
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function decodeJwtPayload(token) {
+  if (!token || typeof token !== 'string') return null;
+  const parts = token.split('.');
+  if (parts.length < 2) return null;
+  try {
+    return JSON.parse(Buffer.from(parts[1], 'base64url').toString());
+  } catch {
+    return null;
+  }
+}
+
+function computeExpiresInHours(expiresAtMs) {
+  if (!Number.isFinite(expiresAtMs)) return null;
+  return Math.round(((expiresAtMs - Date.now()) / 3_600_000) * 10) / 10;
+}
+
+function formatExpires(expiresInHours) {
+  if (expiresInHours == null) return 'unknown';
+  if (expiresInHours <= 0) return 'expired';
+  return `${Math.round(expiresInHours)}h remaining`;
+}
+
+function getClaudeAuthStatus() {
+  const defaults = {
+    valid: false,
+    expiresInHours: null,
+    hasRefreshToken: false,
+    email: null,
+    credPath: null,
+  };
+
+  for (const credPath of getClaudeCredentialPaths(process.cwd())) {
+    const cred = safeParseJson(credPath);
+    const oauth = cred?.claudeAiOauth;
+    if (!oauth) continue;
+
+    const expiresAtMs = typeof oauth.expiresAt === 'number'
+      ? oauth.expiresAt
+      : oauth.expiresAt
+        ? Date.parse(oauth.expiresAt)
+        : NaN;
+    const expiresInHours = computeExpiresInHours(expiresAtMs);
+    const valid = Number.isFinite(expiresAtMs) ? expiresAtMs > Date.now() : false;
+
+    let subscription = null;
+    try {
+      const authOut = run('claude', ['auth', 'status', '--json']);
+      if (authOut.status === 0) {
+        const info = JSON.parse(authOut.stdout.trim());
+        subscription = info.subscriptionType || null;
+      }
+    } catch {}
+    if (!subscription) subscription = oauth.subscriptionType || null;
+
+    return {
+      valid,
+      expiresInHours,
+      hasRefreshToken: !!oauth.refreshToken,
+      email: oauth.email || oauth.account?.email || cred.email || null,
+      subscription,
+      credPath,
+    };
+  }
+
+  return defaults;
+}
+
+function getCodexAuthStatus() {
+  const authPath = join(process.env.HOME || '', '.codex', 'auth.json');
+  const auth = safeParseJson(authPath);
+  const tokens = auth?.tokens || auth;
+  const accessToken = tokens?.access_token;
+  const refreshToken = tokens?.refresh_token;
+  const payload = decodeJwtPayload(accessToken);
+  const expiresAtMs = payload?.exp ? payload.exp * 1000 : NaN;
+  const expiresInHours = computeExpiresInHours(expiresAtMs);
+
+  return {
+    valid: Number.isFinite(expiresAtMs) ? expiresAtMs > Date.now() : false,
+    expiresInHours,
+    hasRefreshToken: !!refreshToken,
+    email: payload?.email || auth?.email || auth?.user?.email || null,
+  };
+}
+
+function postForm(url, body) {
+  return new Promise((resolve, reject) => {
+    const payload = Buffer.from(new URLSearchParams(body).toString(), 'utf8');
+    const req = https.request(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        'Content-Length': payload.length,
+      },
+      timeout: 8000,
+    }, (res) => {
+      const chunks = [];
+      res.on('data', (chunk) => chunks.push(chunk));
+      res.on('end', () => {
+        const raw = Buffer.concat(chunks).toString('utf8');
+        if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+          try {
+            resolve(JSON.parse(raw));
+          } catch (err) {
+            reject(err);
+          }
+        } else {
+          reject(new Error(`HTTP ${res.statusCode || 0}`));
+        }
+      });
+    });
+    req.on('timeout', () => req.destroy(new Error('Request timeout')));
+    req.on('error', reject);
+    req.write(payload);
+    req.end();
+  });
+}
+
+async function refreshClaudeToken(credPath) {
+  try {
+    const cred = safeParseJson(credPath);
+    const oauth = cred?.claudeAiOauth;
+    if (!oauth?.refreshToken) return { success: false, expiresInHours: null };
+
+    const refreshed = await postForm('https://console.anthropic.com/v1/oauth/token', {
+      grant_type: 'refresh_token',
+      refresh_token: oauth.refreshToken,
+      client_id: '9d1c250a-e61b-44d9-88ed-5944d1962f5e',
+    });
+
+    const nextOauth = {
+      ...oauth,
+      accessToken: refreshed.access_token || oauth.accessToken,
+      refreshToken: refreshed.refresh_token || oauth.refreshToken,
+      tokenType: refreshed.token_type || oauth.tokenType,
+      scopes: refreshed.scope || oauth.scopes,
+      expiresAt: Date.now() + ((refreshed.expires_in || 0) * 1000),
+    };
+    const updated = { ...cred, claudeAiOauth: nextOauth };
+    writeAtomicJson(credPath, updated);
+
+    return {
+      success: true,
+      expiresInHours: computeExpiresInHours(nextOauth.expiresAt),
+    };
+  } catch {
+    return { success: false, expiresInHours: null };
+  }
+}
+
+async function refreshCodexToken() {
+  try {
+    const authPath = join(process.env.HOME || '', '.codex', 'auth.json');
+    const auth = safeParseJson(authPath);
+    const tokens = auth?.tokens || auth;
+    const refreshToken = tokens?.refresh_token;
+    if (!refreshToken) return { success: false, expiresInHours: null };
+
+    const refreshed = await postForm('https://auth.openai.com/oauth/token', {
+      grant_type: 'refresh_token',
+      refresh_token: refreshToken,
+      client_id: 'app_EMoamEEZ73f0CkXaXp7hrann',
+    });
+
+    const updatedTokens = {
+      ...tokens,
+      access_token: refreshed.access_token || tokens.access_token,
+      refresh_token: refreshed.refresh_token || tokens.refresh_token,
+      id_token: refreshed.id_token || tokens.id_token,
+      token_type: refreshed.token_type || tokens.token_type,
+      scope: refreshed.scope || tokens.scope,
+    };
+    const updated = auth?.tokens ? { ...auth, tokens: updatedTokens } : updatedTokens;
+    writeAtomicJson(authPath, updated);
+
+    const payload = decodeJwtPayload(updatedTokens.access_token);
+    return {
+      success: true,
+      expiresInHours: payload?.exp ? computeExpiresInHours(payload.exp * 1000) : null,
+    };
+  } catch {
+    return { success: false, expiresInHours: null };
+  }
+}
+
 function detectClaude() {
   const result = { installed: false, version: null, authed: false };
 
@@ -261,6 +509,51 @@ function detectEnvironment() {
   };
 }
 
+function runtimeInstalled(workspace = process.cwd()) {
+  return existsSync(resolve(workspace, '.replit-tools'));
+}
+
+function providerReadiness(env) {
+  const issues = [];
+  if (!env.claude.installed) issues.push('Claude CLI not found.');
+  else if (!env.claude.authed) issues.push('Claude CLI not authenticated.');
+
+  if (!env.codex.installed) issues.push('Codex CLI not found.');
+  else if (!env.codex.authed) issues.push('Codex CLI not authenticated.');
+
+  return { ready: issues.length === 0, issues };
+}
+
+function readInputLine(prompt) {
+  process.stdout.write(prompt);
+  return new Promise((resolve) => {
+    process.stdin.setEncoding('utf8');
+    process.stdin.once('data', (chunk) => resolve(chunk.trim()));
+    process.stdin.resume();
+  }).finally(() => {
+    process.stdin.pause();
+  });
+}
+
+function isRunningFromNpxCache() {
+  const scriptPath = fileURLToPath(import.meta.url);
+  return scriptPath.includes('/.npm/_npx/') || scriptPath.includes('\\.npm\\_npx\\');
+}
+
+function warnIfUpdateAvailable() {
+  if (!isRunningFromNpxCache()) return;
+  const pkg = JSON.parse(readFileSync(join(__dirname, 'package.json'), 'utf8'));
+  const packageName = pkg.name || 'dual-brain';
+  const latest = run('npm', ['view', packageName, 'version']);
+  if (latest.status !== 0) return;
+  const newest = latest.stdout.trim().split('\n').pop();
+  if (newest && newest !== VERSION) {
+    console.log('');
+    console.log(`  Update available: ${cmd('npx -y dual-brain@latest')}`);
+    console.log('');
+  }
+}
+
 // ─── Mode Resolution ────────────────────────────────────────────────────────
 
 function resolveMode(env) {
@@ -444,131 +737,17 @@ function install(workspace, env, mode) {
   return actions;
 }
 
-// ─── Guided Auth ────────────────────────────────────────────────────────────
-
-function printGuidedAuth(env) {
-  const claudeOk = env.claude.installed && env.claude.authed;
-  const codexOk = env.codex.installed && env.codex.authed;
-
-  if (claudeOk && codexOk) return false; // nothing to guide
-
-  const claudeMissing = !env.claude.installed || !env.claude.authed;
-  const codexMissing = !env.codex.installed || !env.codex.authed;
-
-  console.log('');
-
-  if (claudeMissing && codexMissing) {
-    console.log('  ⚠️  No AI providers detected. You need at least one:');
-    console.log('');
-    console.log('  Claude (recommended):');
-    console.log('    npm install -g @anthropic-ai/claude-code && claude login');
-    console.log('');
-    console.log('  OpenAI (optional, enables dual-brain):');
-    console.log('    npm install -g @openai/codex && codex login');
-    console.log('');
-    console.log('  Then re-run: npx dual-brain');
-    console.log('');
-    return true;
-  }
-
-  if (claudeMissing) {
-    if (!env.claude.installed) {
-      console.log('  ⚠️  Claude CLI not detected. To enable Claude routing:');
-    } else {
-      console.log('  ⚠️  Claude CLI not authenticated. To enable Claude routing:');
-    }
-    console.log('');
-    console.log('  1. Install: npm install -g @anthropic-ai/claude-code');
-    console.log('  2. Login:   claude login');
-    console.log('');
-    console.log('  Run these commands, then re-run: npx dual-brain');
-    console.log('');
-  }
-
-  if (codexMissing) {
-    if (!env.codex.installed) {
-      console.log('  ℹ️  Codex CLI not detected. To enable GPT routing:');
-    } else {
-      console.log('  ℹ️  Codex CLI not authenticated. To enable GPT routing:');
-    }
-    console.log('');
-    console.log('  1. Install: npm install -g @openai/codex');
-    console.log('  2. Login:   codex login');
-    console.log('');
-    if (claudeMissing) {
-      console.log('  Run these commands, then re-run: npx dual-brain');
-    } else {
-      console.log('  Run these commands, then re-run: npx dual-brain');
-      console.log('  GPT features will be disabled until Codex is configured.');
-    }
-    console.log('');
-  }
-
-  return claudeMissing; // only block/poll if Claude (primary provider) is missing
-}
-
-async function waitForAuth(env) {
-  if (!process.stdin.isTTY || !process.stdout.isTTY) return;
-
-  const claudeMissing = !env.claude.installed || !env.claude.authed;
-  if (!claudeMissing) return; // only wait if primary provider needs setup
-
-  process.stdout.write('  Would you like me to wait while you authenticate? [Y/n] ');
-
-  const answer = await new Promise((resolve) => {
-    process.stdin.setEncoding('utf8');
-    process.stdin.once('data', (chunk) => resolve(chunk.trim().toLowerCase()));
-    process.stdin.resume();
-  });
-
-  if (answer === 'n' || answer === 'no') {
-    process.stdin.pause();
-    console.log('');
-    console.log('  Re-run `npx dual-brain` after authenticating.');
-    console.log('');
-    process.exit(0);
-  }
-
-  console.log('');
-  console.log('  Waiting for Claude CLI to become available (checking every 5s, max 5 min)...');
-  console.log('');
-
-  const maxAttempts = 60; // 60 × 5s = 5 minutes
-  for (let i = 0; i < maxAttempts; i++) {
-    await new Promise(r => setTimeout(r, 5000));
-    process.stdout.write('.');
-    const fresh = detectClaude();
-    if (fresh.installed) {
-      console.log('');
-      console.log('');
-      console.log('  Claude CLI detected! Continuing setup...');
-      console.log('');
-      process.stdin.pause();
-      // Update env in-place
-      env.claude = fresh;
-      return;
-    }
-  }
-
-  console.log('');
-  console.log('');
-  console.log('  Timed out after 5 minutes. Re-run `npx dual-brain` after authenticating.');
-  console.log('');
-  process.stdin.pause();
-  process.exit(1);
-}
-
 // ─── Quick Start Block ───────────────────────────────────────────────────────
 
 function printQuickStart() {
-  console.log('  ✓ dual-brain installed successfully');
   console.log('');
-  console.log('  Quick start:');
-  console.log(`    npx dual-brain do "fix a bug and write tests"   ← full pipeline`);
-  console.log('    npx dual-brain status                            ← check system');
-  console.log('    npx dual-brain doctor                            ← diagnose issues');
+  console.log(`  ${BRAND}`);
   console.log('');
-  console.log('  All commands: npx dual-brain --help');
+  console.log('  Quick start:');
+  console.log('    npx dual-brain do "fix the login bug"    ← one command to PR');
+  console.log('    npx dual-brain setup                     ← configure providers');
+  console.log('    npx dual-brain doctor                    ← check system health');
+  console.log('    npx dual-brain help                      ← full command list');
   console.log('');
 }
 
@@ -578,16 +757,10 @@ function printReport(env, mode, actions, isDryRun) {
   const lines = [];
 
   lines.push(br('╔', '╗'));
-  lines.push(ln(`🧠 Dual-Brain v${VERSION}`));
+  lines.push(ln(BRAND));
+  lines.push(ln(BRAND_SUBTITLE));
   lines.push(sep());
-
-  const cAuth = env.claude.authed ? '✅' : env.claude.installed ? '⚠️' : '❌';
-  const xAuth = env.codex.authed ? '✅' : env.codex.installed ? '⚠️' : '❌';
-  lines.push(ln(`  🟠 Claude ${cAuth}   🟢 Codex ${xAuth}`));
-
-  if (env.isReplit) {
-    lines.push(ln(`  🌀 Replit${env.hasReplitTools ? ' + replit-tools' : ''}`));
-  }
+  lines.push(ln(`Workspace: ${env.workspace}`));
 
   if (actions) {
     lines.push(sep());
@@ -1558,6 +1731,228 @@ async function checkReplitTools() {
   }
 }
 
+// ─── Auth Command ──────────────────────────────────────────────────────────
+
+async function cmdAuth() {
+  console.log('');
+  console.log(`  ${BRAND} — Auth Status`);
+  console.log('  ──────────────────────────────────────────────────');
+
+  const claude = getClaudeAuthStatus();
+  if (claude.valid) {
+    const email = claude.email ? ` — ${claude.email}` : '';
+    const sub = claude.subscription ? ` (${claude.subscription})` : '';
+    console.log(`  ✓ Claude: authenticated (${Math.round(claude.expiresInHours)}h remaining)${email}${sub}`);
+  } else if (claude.hasRefreshToken) {
+    console.log('  ⟳ Claude: expired — attempting refresh...');
+    const r = await refreshClaudeToken(claude.credPath);
+    console.log(r.success ? `  ✓ Claude: refreshed (${Math.round(r.expiresInHours)}h remaining)` : '  ✗ Claude: refresh failed — run: claude login');
+  } else {
+    console.log(`  ✗ Claude: ${claude.credPath ? 'expired' : 'not configured'} — run: claude login`);
+  }
+
+  const codex = getCodexAuthStatus();
+  if (codex.valid) {
+    const email = codex.email ? ` — ${codex.email}` : '';
+    console.log(`  ✓ Codex:  authenticated (${Math.round(codex.expiresInHours)}h remaining)${email}`);
+  } else if (codex.hasRefreshToken) {
+    console.log('  ⟳ Codex:  expired — attempting refresh...');
+    const r = await refreshCodexToken();
+    console.log(r.success ? `  ✓ Codex:  refreshed (${Math.round(r.expiresInHours)}h remaining)` : '  ✗ Codex:  refresh failed — run: codex login');
+  } else {
+    console.log('  ✗ Codex:  not configured — run: codex login');
+    console.log('           (GPT lane will be disabled)');
+  }
+
+  if (IS_REPLIT) {
+    console.log('');
+    console.log('  Replit tip: If login shows localhost errors, use browser-based auth');
+    console.log('  or run the login command from a local machine and copy credentials.');
+  }
+  console.log('');
+}
+
+// ─── Preflight Auth ────────────────────────────────────────────────────────
+
+async function preflightAuth() {
+  const claude = getClaudeAuthStatus();
+  const codex = getCodexAuthStatus();
+  let claudeOk = claude.valid;
+  let codexOk = codex.valid;
+
+  if (!claudeOk && claude.hasRefreshToken) {
+    const r = await refreshClaudeToken(claude.credPath);
+    claudeOk = r.success;
+    if (r.success) console.log(`  ⟳ Claude auth refreshed (${Math.round(r.expiresInHours)}h)`);
+  }
+  if (!codexOk && codex.hasRefreshToken) {
+    const r = await refreshCodexToken();
+    codexOk = r.success;
+    if (r.success) console.log(`  ⟳ Codex auth refreshed (${Math.round(r.expiresInHours)}h)`);
+  }
+
+  if (!claudeOk) {
+    console.log('');
+    console.log('  ✗ Claude auth required. Run: claude login');
+    if (IS_REPLIT) console.log('    (Use browser flow — localhost callbacks may not work)');
+    console.log('');
+    return false;
+  }
+  if (!codexOk) console.log('  ⚠ Codex not authenticated — GPT lane disabled (Claude-only mode)');
+  return true;
+}
+
+// ─── Session Wizard ────────────────────────────────────────────────────────
+
+function recommendModel() {
+  const claude = getClaudeAuthStatus();
+  const codex = getCodexAuthStatus();
+  if (claude.subscription === 'max' && codex.valid) return { model: 'sonnet', reason: 'Both $100 subs — sonnet for chat, opus auto-escalates for thinking' };
+  if (claude.subscription === 'max') return { model: 'sonnet', reason: '$100 Claude Max — sonnet balances speed + quality' };
+  if (claude.subscription === 'pro') return { model: 'haiku', reason: '$20 Claude Pro — haiku conserves limited credits' };
+  return { model: 'sonnet', reason: 'Default — good balance of speed and capability' };
+}
+
+async function askLine(prompt) {
+  if (!process.stdin.isTTY || yesFlag || process.env.CI) return '';
+  process.stdout.write(prompt);
+  const answer = await new Promise(resolve => {
+    process.stdin.setEncoding('utf8');
+    process.stdin.once('data', chunk => resolve(chunk.trim().toLowerCase()));
+    process.stdin.resume();
+  });
+  process.stdin.pause();
+  return answer;
+}
+
+async function runSessionWizard(workspace) {
+  const rec = recommendModel();
+  const claude = getClaudeAuthStatus();
+  const codex = getCodexAuthStatus();
+
+  console.log('');
+  console.log(`  ${BRAND}`);
+  console.log(`  ${BRAND_SUBTITLE}`);
+  console.log('');
+
+  const parts = [];
+  if (claude.subscription) parts.push(`Claude ${claude.subscription}`);
+  if (codex.valid) parts.push('Codex Pro');
+  if (parts.length) {
+    console.log(`  Detected: ${parts.join(' + ')}`);
+    console.log(`  Recommendation: ${rec.reason}`);
+    console.log('');
+  }
+
+  console.log('  Head session model:');
+  console.log('    [s] Sonnet — fast, cost-effective, great for most work');
+  console.log('    [o] Opus  — slower, smarter, best for complex architecture');
+  console.log('    [h] Haiku — fastest, cheapest, good for simple tasks');
+  const modelKey = await askLine(`  Choice [${rec.model === 'haiku' ? 'h' : 's'}]: `);
+  let model = rec.model === 'haiku' ? 'haiku' : 'sonnet';
+  if (modelKey === 'o' || modelKey === 'opus') model = 'opus';
+  else if (modelKey === 'h' || modelKey === 'haiku') model = 'haiku';
+  else if (modelKey === 's' || modelKey === 'sonnet') model = 'sonnet';
+
+  if (model === 'opus' && process.stdin.isTTY) {
+    console.log('  ⚠  Opus uses ~5x more credits than Sonnet.');
+    const confirm = await askLine('  Continue with Opus? [y/N] ');
+    if (confirm !== 'y' && confirm !== 'yes') { model = 'sonnet'; console.log('  Switched to Sonnet.'); }
+  }
+
+  console.log('');
+  console.log('  Effort level:');
+  console.log('    [l] Low    — faster responses, less thorough');
+  console.log('    [m] Medium — balanced (default)');
+  console.log('    [h] High   — thorough, slower, more expensive');
+  const effortKey = await askLine('  Choice [m]: ');
+  let effort = 'medium';
+  if (effortKey === 'l' || effortKey === 'low') effort = 'low';
+  else if (effortKey === 'h' || effortKey === 'high') effort = 'high';
+
+  const prefs = { head_model: model, effort, created_at: new Date().toISOString(), updated_at: new Date().toISOString() };
+  saveSessionPrefs(workspace, prefs);
+  console.log('');
+  console.log(`  Saved: ${model} / ${effort} effort`);
+  console.log('  Change anytime: npx dual-brain start --model opus --effort high');
+  return prefs;
+}
+
+// ─── Session Launcher ──────────────────────────────────────────────────────
+
+function launchClaudeSession(workspace, prefs) {
+  const model = prefs.head_model || 'sonnet';
+  const args = [];
+  const helpOut = run('claude', ['--help']);
+  const helpText = (helpOut.stdout || '') + (helpOut.stderr || '');
+  if (helpText.includes('--model')) args.push('--model', model);
+  if (helpText.includes('--resume') || helpText.includes('-c')) args.push('-c');
+
+  console.log('');
+  console.log(`  Launching ${model} session...`);
+  console.log('  (Work agents auto-route: haiku/sonnet/opus by task tier)');
+  console.log('');
+
+  const result = spawnSync('claude', args, {
+    stdio: 'inherit',
+    cwd: workspace,
+    env: { ...process.env, DUAL_BRAIN_HEAD_MODEL: model, DUAL_BRAIN_HEAD_EFFORT: prefs.effort || 'medium', DUAL_BRAIN_WORKSPACE: workspace },
+  });
+  process.exit(result.status ?? 0);
+}
+
+// ─── Ensure Setup + Launch ─────────────────────────────────────────────────
+
+async function ensureAndLaunch() {
+  const workspace = resolve(process.cwd());
+  if (!dryRun && !jsonOut) await checkReplitTools();
+
+  const alreadySetUp = existsSync(join(workspace, '.claude', 'hooks'))
+    || existsSync(join(workspace, '.claude', 'settings.json'));
+  if (!alreadySetUp || force) {
+    const env = detectEnvironment();
+    const mode = resolveMode(env);
+    install(env.workspace, env, mode);
+  }
+
+  const authOk = await preflightAuth();
+  if (!authOk) { console.log('  Fix auth first, then run: npx dual-brain'); process.exit(1); }
+
+  const cliModel = argv.find((a, i) => argv[i - 1] === '--model');
+  const cliEffort = argv.find((a, i) => argv[i - 1] === '--effort');
+  let prefs = loadSessionPrefs(workspace);
+
+  if (!prefs.created_at && !noLaunch) prefs = await runSessionWizard(workspace);
+  if (cliModel) prefs.head_model = cliModel;
+  if (cliEffort) prefs.effort = cliEffort;
+
+  if (noLaunch) { printQuickStart(); return; }
+  launchClaudeSession(workspace, prefs);
+}
+
+// ─── Doctor with Auth ──────────────────────────────────────────────────────
+
+async function cmdDoctorWithAuth() {
+  cmdDoctor();
+  console.log('  Auth Status:');
+  const claude = getClaudeAuthStatus();
+  if (claude.valid) {
+    const email = claude.email ? ` — ${claude.email}` : '';
+    const sub = claude.subscription ? ` (${claude.subscription})` : '';
+    console.log(`    ✓ Claude: ${Math.round(claude.expiresInHours)}h remaining${email}${sub}`);
+  } else {
+    console.log('    ✗ Claude: not authenticated — run: npx dual-brain auth');
+  }
+  const codex = getCodexAuthStatus();
+  if (codex.valid) {
+    const email = codex.email ? ` — ${codex.email}` : '';
+    console.log(`    ✓ Codex:  ${Math.round(codex.expiresInHours)}h remaining${email}`);
+  } else {
+    console.log('    ✗ Codex:  not authenticated — run: npx dual-brain auth');
+  }
+  console.log('');
+}
+
 // ─── Main ───────────────────────────────────────────────────────────────────
 
 async function main() {
@@ -1570,9 +1965,13 @@ async function main() {
   if (subcommand === 'mode')    { cmdMode();    return; }
   if (subcommand === 'budget')  { cmdBudget();  return; }
   if (subcommand === 'explain') { cmdExplain(); return; }
-  if (subcommand === 'doctor')  { cmdDoctor();  return; }
+  if (subcommand === 'doctor')  { await cmdDoctorWithAuth(); return; }
   if (subcommand === 'reset')   { cmdReset();   return; }
   if (subcommand === 'repair')  { cmdRepair();  return; }
+  if (subcommand === 'auth')    { await cmdAuth(); return; }
+  if (subcommand === 'start' || subcommand === 'chat') {
+    await ensureAndLaunch(); return;
+  }
 
   // agent <template> [flags] → agent-templates.mjs --run <template> [flags]
   if (subcommand === 'agent') {
@@ -1847,6 +2246,27 @@ async function main() {
     return;
   }
 
+  // ── Bare invocation (no subcommand): setup if needed, then launch ──
+  if (!subcommand) {
+    await ensureAndLaunch();
+    return;
+  }
+
+  if (subcommand === 'setup') {
+    if (!dryRun && !jsonOut) await checkReplitTools();
+    const env = detectEnvironment();
+    const mode = resolveMode(env);
+    const needsGuidance = printGuidedAuth(env);
+    if (needsGuidance && process.stdin.isTTY && process.stdout.isTTY && !process.env.CI) {
+      await waitForAuth(env);
+      Object.assign(mode, resolveMode(env));
+    }
+    const actions = install(env.workspace, env, mode);
+    printReport(env, mode, actions);
+    printQuickStart();
+    return;
+  }
+
   // ── replit-tools check — first thing before auth detection or install ──
   if (!dryRun && !jsonOut) {
     await checkReplitTools();
@@ -1869,30 +2289,12 @@ async function main() {
   const needsGuidance = printGuidedAuth(env);
   if (needsGuidance && process.stdin.isTTY && process.stdout.isTTY && !process.env.CI) {
     await waitForAuth(env);
-    // Re-resolve mode after potential auth
     Object.assign(mode, resolveMode(env));
   }
 
   const actions = install(env.workspace, env, mode);
   printReport(env, mode, actions);
-
-  // Always print quick-start block after successful install
   printQuickStart();
-
-  // Offer to launch control panel (opt-in, interactive TTY only)
-  if (process.stdin.isTTY && process.stdout.isTTY && !process.env.CI) {
-    process.stdout.write('  Launch control panel? [y/N] ');
-    const answer = await new Promise((resolve) => {
-      process.stdin.setEncoding('utf8');
-      process.stdin.once('data', (chunk) => resolve(chunk.trim().toLowerCase()));
-      process.stdin.resume();
-    });
-    process.stdin.pause();
-    console.log('');
-    if (answer === 'y' || answer === 'yes') {
-      launchPanel();
-    }
-  }
 }
 
 main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dual-brain",
-  "version": "4.5.0",
+  "version": "4.6.0",
   "description": "Data-Tools Dual-Brain — dual-provider orchestration extension for data-tools/replit-tools. Tiered routing, budget balancing, and GPT dual-brain review across Claude + OpenAI subscriptions",
   "type": "module",
   "bin": {