dual-brain 7.1.1 → 7.1.3

package/bin/dual-brain.mjs

@@ -12,6 +12,7 @@ import {
   rememberPreference, forgetPreference, getActivePreferences,
   getAvailableProviders, isSoloBrain, getHeadModel,
   detectAuth, detectEnvironment, setupAuth,
+  autoSetup,
 } from '../src/profile.mjs';
 
 import { detectTask } from '../src/detect.mjs';
@@ -27,7 +28,7 @@ import {
 import { dispatch, detectRuntime, dispatchDualBrain } from '../src/dispatch.mjs';
 
 import { loadRepoCache } from '../src/repo.mjs';
-import { loadSession, saveSession, formatSessionCard } from '../src/session.mjs';
+import { loadSession, saveSession, formatSessionCard, importReplitSessions } from '../src/session.mjs';
 
 import { box, bar, badge, menu, separator } from '../src/tui.mjs';
 
@@ -485,11 +486,10 @@ function cmdForget(text) {
 
 // ─── Screen helpers ───────────────────────────────────────────────────────────
 
-function profileExists() {
-  const { homedir } = { homedir: () => process.env.HOME || '/root' };
-  const cwd = process.cwd();
+function profileExists(cwd) {
+  const dir = cwd || process.cwd();
   const globalPath  = join(process.env.HOME || '/root', '.config', 'dual-brain', 'profile.json');
-  const projectPath = join(cwd, '.dualbrain', 'profile.json');
+  const projectPath = join(dir, '.dualbrain', 'profile.json');
   return existsSync(projectPath) || existsSync(globalPath);
 }
 
@@ -497,12 +497,66 @@ function profileExists() {
 
 async function welcomeScreen(rl, ask) {
   const version = readVersion();
-  console.log(box(`🧠 Dual-Brain v${version} — First-Time Setup`, [
-    'Let\'s configure your AI providers.',
+  const cwd = process.cwd();
+
+  // --- Try auto-setup first ---
+  console.log(box(`🧠 Dual-Brain v${version} — Setup`, [
+    'Detecting environment...',
   ]));
   console.log('');
 
-  // --- Claude provider selection ---
+  const setup = await autoSetup(cwd);
+
+  if (setup.confident) {
+    // Build summary lines for the auto-detected state
+    const detectedLines = [
+      'Detecting environment...',
+      ...setup.actions.map(a => `✓ ${a}`),
+      ...setup.warnings.map(w => `⚠ ${w}`),
+    ];
+
+    const modeLabel = setup.profile.mode === 'dual'      ? 'dual mode, balanced'
+      : setup.profile.mode === 'solo-claude' ? 'Claude-only mode, balanced'
+      : setup.profile.mode === 'solo-openai' ? 'OpenAI-only mode, balanced'
+      : `${setup.profile.mode}, balanced`;
+
+    const readyBox = box(`🧠 Dual-Brain v${version} — Setup`, [
+      ...detectedLines,
+      '',
+      `Ready to go! Auto-configured ${modeLabel}.`,
+    ]);
+    console.log(readyBox);
+    console.log('');
+    console.log('  [Enter] Start coding →');
+    console.log('  [c]     Customize setup');
+    console.log('  [a]     Auth management');
+    console.log('');
+
+    const choice = (await ask('  Choice: ')).trim().toLowerCase();
+
+    if (choice === 'c') {
+      // Fall through to manual wizard below
+    } else if (choice === 'a') {
+      return { next: 'auth' };
+    } else {
+      // Enter or anything else → save and go to dashboard
+      saveProfile(setup.profile, { cwd });
+      return { next: 'dashboard' };
+    }
+  } else {
+    // Not confident — show what's missing before falling through to wizard
+    if (setup.warnings.length > 0) {
+      console.log(box(`🧠 Dual-Brain v${version} — Setup`, [
+        'Auto-detection incomplete:',
+        ...setup.warnings.map(w => `  ✗ ${w}`),
+        '',
+        'Let\'s configure manually.',
+      ]));
+      console.log('');
+    }
+  }
+
+  // --- Manual wizard (fallback or [c] Customize) ---
   console.log(separator('Claude (Anthropic)'));
   console.log('  (1) $20/mo Pro');
   console.log('  (2) $100/mo Max 5x');
@@ -521,7 +575,6 @@ async function welcomeScreen(rl, ask) {
     // Ask for API key immediately
     const key = (await ask('Paste your Anthropic API key: ')).trim();
     if (key) {
-      const { saveAuthKey } = await import('../src/profile.mjs').then(m => m).catch(() => ({}));
       // Inline: set env var for this session, profile will persist
       process.env.ANTHROPIC_API_KEY = key;
       console.log('✓ Claude API key set for this session');
@@ -578,7 +631,6 @@ async function welcomeScreen(rl, ask) {
   else if (modeChoice === '3') { mode = 'quality-first'; }
 
   // --- Build and save profile ---
-  const cwd = process.cwd();
   const existingProfile = loadProfile(cwd);
   const profile = {
     ...existingProfile,
@@ -668,29 +720,34 @@ async function dashboardScreen(rl, ask) {
 
   console.log(box(`🧠 Dual-Brain v${version}`, dashLines));
   console.log('');
+
+  // ── Recent Sessions (replit-tools import) ──────────────────────────────────
+  const recentSessions = importReplitSessions(cwd).slice(0, 5);
+  if (recentSessions.length > 0) {
+    console.log(separator('Recent Sessions'));
+    recentSessions.forEach((sess, i) => {
+      const activeIndicator = sess.isActive ? '●' : ' ';
+      const promptsLabel = `(${sess.promptCount} prompt${sess.promptCount !== 1 ? 's' : ''})`;
+      console.log(`  [${i + 1}] ${sess.age.padEnd(6)}  ${activeIndicator} ${sess.name} ${promptsLabel}`);
+    });
+    console.log('');
+  }
+
   console.log(menu([
-    { key: 'g', label: 'Go — dispatch a task',        section: 'Actions' },
-    { key: 's', label: 'Status — detailed provider info', section: 'Actions' },
+    { key: 's', label: 'Status — detailed provider info', section: 'Info' },
     { key: 'p', label: 'Profile & preferences',        section: 'Settings' },
     { key: 'a', label: 'Auth management',              section: 'Settings' },
-    { key: 'd', label: 'Diagnostics',                  section: 'Settings' },
-    { key: 'c', label: 'Command mode (REPL)',           section: 'Session' },
-    { key: 'q', label: 'Exit',                         section: 'Session' },
+    { key: 'd', label: 'Diagnostics & repair',         section: 'Settings' },
+    { key: 'q', label: 'Exit to shell',                section: '' },
   ]));
   console.log('');
 
   const choice = (await ask('  Choice: ')).trim().toLowerCase();
 
-  if (choice === 'g') {
-    const taskDesc = (await ask('  Task description: ')).trim();
-    if (taskDesc) {
-      try {
-        await cmdGo([taskDesc]);
-      } catch (e) {
-        console.error(`Error: ${e.message}`);
-      }
-    }
-    return { next: 'dashboard' };
+  // Numeric choice → session detail
+  const numChoice = parseInt(choice, 10);
+  if (!isNaN(numChoice) && numChoice >= 1 && numChoice <= recentSessions.length) {
+    return { next: 'session-detail', session: recentSessions[numChoice - 1] };
   }
 
   if (choice === 's') {
@@ -702,7 +759,6 @@ async function dashboardScreen(rl, ask) {
   if (choice === 'p') { return { next: 'profile' }; }
   if (choice === 'a') { return { next: 'auth' }; }
   if (choice === 'd') { return { next: 'diagnostics' }; }
-  if (choice === 'c') { return { next: 'repl' }; }
   if (choice === 'q' || choice === 'exit') { return { next: 'exit' }; }
 
   // Unknown choice — stay on dashboard
@@ -827,77 +883,223 @@ async function profileScreen(rl, ask) {
 
 async function diagnosticsScreen(rl, ask) {
   const cwd = process.cwd();
+  const { spawnSync: _spawnSync } = await import('child_process');
+  const { readdirSync } = await import('node:fs');
+  const { detectPlans } = await import('../src/profile.mjs');
+
+  // ── Version info ──────────────────────────────────────────────────────────
   const version = readVersion();
-  const env = detectEnvironment();
-  const rt = await detectRuntime();
+  const nodeVersion = process.version;
+
+  // ── Provider health ───────────────────────────────────────────────────────
+  const auth  = await detectAuth();
+  const plans = detectPlans();
+  const { states: healthStates } = getHealth(cwd);
+
+  function _providerBadge(name) {
+    const entries = Object.entries(healthStates).filter(([k]) => k.startsWith(`${name}:`));
+    if (entries.length === 0) return '✅ healthy';
+    const statuses = entries.map(([, v]) => v.status);
+    if (statuses.includes('hot'))      return '🔴 hot';
+    if (statuses.includes('degraded')) return '⚠️  degraded';
+    if (statuses.includes('probing'))  return '⚠️  probing';
+    return '✅ healthy';
+  }
+
+  const claudeStatus  = auth.claude.found ? _providerBadge('claude') : '❌ no auth';
+  const openaiStatus  = auth.openai.found ? _providerBadge('openai') : '❌ no auth';
+  const claudePlanStr = plans.claude ? `Max ${plans.claude}` : (auth.claude.masked ?? 'unknown');
+  const openaiPlanStr = plans.openai ? `Pro ${plans.openai}` : (auth.openai.masked ?? 'unknown');
+  const claudeAuthStr = auth.claude.masked ?? 'not configured';
+  const openaiAuthStr = auth.openai.masked ?? 'not configured';
+
+  // ── Enforcement checks ────────────────────────────────────────────────────
+  const hooksDir           = join(cwd, '.claude', 'hooks');
+  const headGuardExists    = existsSync(join(hooksDir, 'head-guard.mjs'));
+  const enforceTierExists  = existsSync(join(hooksDir, 'enforce-tier.mjs'));
 
-  // Enforcement check
   let guardCount = 0;
-  let guardDetails = 'NOT INSTALLED';
   try {
     const settingsFile = join(cwd, '.claude', 'settings.json');
     if (existsSync(settingsFile)) {
       const settings = JSON.parse(readFileSync(settingsFile, 'utf8'));
       const preToolUse = settings?.hooks?.PreToolUse ?? [];
-      const guardCmd  = 'node .claude/hooks/head-guard.mjs';
-      const tierCmd   = 'node .claude/hooks/enforce-tier.mjs';
-      const hasEdit   = preToolUse.some(e => e.matcher === 'Edit'   && e.hooks?.some(h => h.command === guardCmd));
-      const hasWrite  = preToolUse.some(e => e.matcher === 'Write'  && e.hooks?.some(h => h.command === guardCmd));
-      const hasBash   = preToolUse.some(e => e.matcher === 'Bash'   && e.hooks?.some(h => h.command === guardCmd));
-      const hasAgent  = preToolUse.some(e => e.matcher === 'Agent'  && e.hooks?.some(h => h.command === tierCmd));
+      const guardCmd = 'node .claude/hooks/head-guard.mjs';
+      const tierCmd  = 'node .claude/hooks/enforce-tier.mjs';
+      const hasEdit  = preToolUse.some(e => e.matcher === 'Edit'  && e.hooks?.some(h => h.command === guardCmd));
+      const hasWrite = preToolUse.some(e => e.matcher === 'Write' && e.hooks?.some(h => h.command === guardCmd));
+      const hasBash  = preToolUse.some(e => e.matcher === 'Bash'  && e.hooks?.some(h => h.command === guardCmd));
+      const hasAgent = preToolUse.some(e => e.matcher === 'Agent' && e.hooks?.some(h => h.command === tierCmd));
       guardCount = [hasEdit, hasWrite, hasBash, hasAgent].filter(Boolean).length;
-      guardDetails = guardCount === 4
-        ? `${guardCount}/4 guards active (Edit, Write, Bash, Agent)`
-        : `${guardCount}/4 guards — run: dual-brain install`;
     }
-  } catch { guardDetails = 'unknown (could not read settings)'; }
+  } catch { /* ignore */ }
 
-  // Hook health: check if hook files exist
-  const hooksDir = join(cwd, '.claude', 'hooks');
-  const expectedHooks = [
-    'head-guard.mjs', 'enforce-tier.mjs', 'budget-balancer.mjs',
-    'session-report.mjs', 'quality-gate.mjs', 'health-check.mjs',
-  ];
-  const hookStatus = expectedHooks.map(h => {
-    const present = existsSync(join(hooksDir, h));
-    return `  ${present ? '✓' : '✗'} ${h}`;
-  });
-
-  const diagLines = [
-    `Version:       ${version}`,
-    `Enforcement:   ${guardDetails}`,
+  let hookifyCount = 0;
+  try {
+    const claudeDir = join(cwd, '.claude');
+    if (existsSync(claudeDir)) {
+      hookifyCount = readdirSync(claudeDir).filter(f => f.startsWith('hookify.') && f.endsWith('.md')).length;
+    }
+  } catch { /* ignore */ }
+
+  // ── Replit-tools integration ──────────────────────────────────────────────
+  const replitToolsDir         = join(cwd, '.replit-tools');
+  const hasReplitTools         = existsSync(replitToolsDir);
+  const persistentDir          = join(replitToolsDir, '.claude-persistent');
+  const sessionManagerExists   = existsSync(join(replitToolsDir, 'scripts', 'claude-session-manager.sh'));
+  const authRefreshScript      = join(replitToolsDir, 'scripts', 'claude-auth-refresh.sh');
+
+  let credsFresh = null;
+  let credsExpiry = null;
+  let historyCount = 0;
+
+  if (hasReplitTools) {
+    try {
+      const credsFile = join(persistentDir, '.credentials.json');
+      const creds = JSON.parse(readFileSync(credsFile, 'utf8'));
+      const expiresAt = creds?.claudeAiOauth?.expiresAt;
+      if (expiresAt) {
+        const expiresMs = typeof expiresAt === 'number' ? expiresAt : Date.parse(expiresAt);
+        credsFresh  = Date.now() < expiresMs;
+        credsExpiry = new Date(expiresMs).toISOString().slice(0, 10);
+      }
+    } catch { /* credentials missing or unreadable */ }
+
+    try {
+      const histFile = join(persistentDir, 'history.jsonl');
+      if (existsSync(histFile)) {
+        historyCount = readFileSync(histFile, 'utf8').split('\n').filter(Boolean).length;
+      }
+    } catch { /* ignore */ }
+  }
+
+  // ── Quality checks ────────────────────────────────────────────────────────
+  let testPass = null; let testTotal = null; let testError = null;
+  try {
+    const r = _spawnSync('node', ['--test', 'src/test.mjs'], { cwd, encoding: 'utf8', timeout: 30000 });
+    const out = (r.stdout ?? '') + (r.stderr ?? '');
+    const pm = out.match(/# pass (\d+)/);
+    const tm = out.match(/# tests (\d+)/);
+    if (pm && tm) { testPass = parseInt(pm[1], 10); testTotal = parseInt(tm[1], 10); }
+    else { testError = 'could not parse output'; }
+  } catch (e) { testError = e.message; }
+
+  let healthPass = null; let healthTotal = null; let healthError = null;
+  try {
+    const healthScript = join(hooksDir, 'health-check.mjs');
+    if (existsSync(healthScript)) {
+      const r = _spawnSync('node', [healthScript], { cwd, encoding: 'utf8', timeout: 15000 });
+      const out = (r.stdout ?? '') + (r.stderr ?? '');
+      // Try summary line first: "8 pass, 0 warn, 0 fail"
+      const sm = out.match(/(\d+) pass,\s*(\d+) warn,\s*(\d+) fail/);
+      if (sm) {
+        healthPass  = parseInt(sm[1], 10);
+        healthTotal = parseInt(sm[1], 10) + parseInt(sm[2], 10) + parseInt(sm[3], 10);
+      } else {
+        // Fall back to JSON block
+        const jm = out.match(/\{[\s\S]*?"healthy"[\s\S]*?\}/);
+        if (jm) {
+          try {
+            const p = JSON.parse(jm[0]);
+            healthPass  = p.pass ?? 0;
+            healthTotal = (p.pass ?? 0) + (p.warn ?? 0) + (p.fail ?? 0);
+          } catch { healthError = 'could not parse output'; }
+        } else { healthError = 'could not parse output'; }
+      }
+    } else { healthError = 'health-check.mjs not found'; }
+  } catch (e) { healthError = e.message; }
+
+  // ── Render ────────────────────────────────────────────────────────────────
+  const W = 56;
+  const hbar = '═'.repeat(W);
+  // Pad a string to exactly W visible columns (for box rows without leading ║  prefix)
+  const padRow = (s) => {
+    const plain = s.replace(/\x1B\[[0-9;]*[A-Za-z]/g, '');
+    let vlen = 0;
+    for (const ch of plain) {
+      const cp = ch.codePointAt(0);
+      if ((cp >= 0x1f300 && cp <= 0x1faff) || (cp >= 0x2600 && cp <= 0x27bf) || cp === 0xfe0f || cp === 0x20e3) vlen += 2;
+      else vlen += 1;
+    }
+    return s + ' '.repeat(Math.max(0, W - vlen));
+  };
+  const hrow = (s) => `║${padRow('  ' + s)}║`;
+
+  const output = [
+    `╔${hbar}╗`,
+    hrow('🔧 Diagnostics'),
+    `╠${hbar}╣`,
+    hrow(`dual-brain v${version}`),
+    hrow(`Node.js ${nodeVersion}`),
+    `╚${hbar}╝`,
     '',
-    'Environment:',
-    `  Replit:      ${env.isReplit ? 'yes' : 'no'}`,
-    `  replit-tools:${env.hasReplitTools ? 'yes' : 'no'}`,
-    `  CI:          ${env.isCI ? 'yes' : 'no'}`,
+    separator('Provider Health'),
+    `  ${claudeStatus.padEnd(14)} Claude    ${claudePlanStr.padEnd(16)} ${claudeAuthStr}`,
+    `  ${openaiStatus.padEnd(14)} OpenAI    ${openaiPlanStr.padEnd(16)} ${openaiAuthStr}`,
     '',
-    'Runtime:',
-    `  claude CLI:  ${rt.claudeAvailable ? 'available' : 'not found'}`,
-    `  codex CLI:   ${rt.codexAvailable  ? 'available' : 'not found'}`,
-    `  runtime:     ${rt.runtime}`,
+    separator('Enforcement'),
+    `  ${headGuardExists   ? '✅' : '❌'} head-guard.mjs     ${headGuardExists   ? 'installed' : 'missing — run: dual-brain install'}`,
+    `  ${enforceTierExists ? '✅' : '❌'} enforce-tier.mjs   ${enforceTierExists ? 'installed' : 'missing — run: dual-brain install'}`,
+    `  ${guardCount === 4  ? '✅' : '⚠️ '} settings.json      ${guardCount}/4 guards registered${guardCount < 4 ? ' — run: dual-brain install' : ''}`,
+    `  ${hookifyCount > 0  ? '✅' : '⚠️ '} hookify rules      ${hookifyCount} rules${hookifyCount > 0 ? ' (check: ls .claude/hookify.*.md)' : ' — none found'}`,
     '',
-    'Hook files:',
-    ...hookStatus,
+    separator('Replit Tools'),
+    `  ${hasReplitTools ? '✅' : '❌'} replit-tools        ${hasReplitTools ? 'detected' : 'not detected'}`,
   ];
 
-  console.log(box('Diagnostics', diagLines));
-  console.log('');
-  console.log(menu([
-    { key: 'h', label: 'Run health check',    section: '' },
-    { key: 'i', label: 'Install hooks',       section: '' },
-    { key: 'b', label: 'Back to dashboard',  section: '' },
-  ]));
+  if (hasReplitTools) {
+    if (credsFresh === null) {
+      output.push('  ⚠️  Claude auth         credentials file missing');
+    } else if (credsFresh) {
+      output.push(`  ✅ Claude auth         fresh (expires: ${credsExpiry})`);
+    } else {
+      output.push(`  ❌ Claude auth         expired (${credsExpiry}) — run [r] Refresh auth`);
+    }
+    output.push(`  ✅ Session archive     ${historyCount} entries`);
+    output.push(`  ${sessionManagerExists ? '✅' : '⚠️ '} Session manager     ${sessionManagerExists ? 'available' : 'not found'}`);
+  } else {
+    output.push('  ─── (not available)');
+  }
+
+  output.push('');
+  output.push(separator('Quality'));
+  if (testError) {
+    output.push(`  ❌ Tests               error: ${testError}`);
+  } else if (testPass !== null) {
+    output.push(`  ${testPass === testTotal ? '✅' : '❌'} Tests               ${testPass}/${testTotal} passing`);
+  }
+  if (healthError) {
+    output.push(`  ❌ Health check        error: ${healthError}`);
+  } else if (healthPass !== null) {
+    output.push(`  ${healthPass === healthTotal ? '✅' : '⚠️ '} Health check        ${healthPass}/${healthTotal} passing`);
+  }
+  output.push('');
+
+  console.log(output.join('\n'));
+
+  // Actions menu
+  const menuOpts = [
+    { key: 'h', label: 'Run health check',           section: 'Actions' },
+    { key: 't', label: 'Run test suite',             section: 'Actions' },
+  ];
+  if (hasReplitTools && existsSync(authRefreshScript)) {
+    menuOpts.push({ key: 'r', label: 'Refresh auth (replit-tools)', section: 'Actions' });
+  }
+  menuOpts.push({ key: 'i', label: 'Reinstall hooks',              section: 'Actions' });
+  menuOpts.push({ key: 'b', label: 'Back to dashboard',            section: 'Actions' });
+  console.log(menu(menuOpts));
   console.log('');
 
   const choice = (await ask('  Choice: ')).trim().toLowerCase();
 
   if (choice === 'h') {
-    const hookScript = join(cwd, '.claude', 'hooks', 'health-check.mjs');
+    const hookScript = join(hooksDir, 'health-check.mjs');
+    console.log('');
     if (existsSync(hookScript)) {
       try {
-        execSync(`node "${hookScript}"`, { stdio: 'inherit', cwd });
-      } catch { /* hook exits non-zero on issues — already printed output */ }
+        const r = _spawnSync('node', [hookScript], { stdio: 'inherit', cwd });
+        if (r.error) console.log(`  Error: ${r.error.message}`);
+      } catch (e) { console.log(`  Error: ${e.message}`); }
     } else {
       console.log('  health-check.mjs not found — run: dual-brain install');
     }
@@ -905,6 +1107,32 @@ async function diagnosticsScreen(rl, ask) {
     return { next: 'diagnostics' };
   }
 
+  if (choice === 't') {
+    console.log('\n  Running test suite...\n');
+    try {
+      const r = _spawnSync('node', ['--test', 'src/test.mjs'], { stdio: 'inherit', cwd, timeout: 60000 });
+      if (r.error) console.log(`  Error: ${r.error.message}`);
+    } catch (e) { console.log(`  Error: ${e.message}`); }
+    await ask('\n  Press Enter to continue...');
+    return { next: 'diagnostics' };
+  }
+
+  if (choice === 'r') {
+    if (existsSync(authRefreshScript)) {
+      console.log('\n  Refreshing Claude auth...\n');
+      try {
+        const r = _spawnSync('bash', [authRefreshScript], { stdio: 'inherit', cwd, timeout: 30000 });
+        if (r.error) console.log(`  Error: ${r.error.message}`);
+        else if (r.status === 0) console.log('\n  Auth refresh complete.');
+        else console.log(`\n  Auth refresh exited with code ${r.status}.`);
+      } catch (e) { console.log(`  Error: ${e.message}`); }
+    } else {
+      console.log('  claude-auth-refresh.sh not found.');
+    }
+    await ask('\n  Press Enter to continue...');
+    return { next: 'diagnostics' };
+  }
+
   if (choice === 'i') {
     await cmdInstall();
     return { next: 'diagnostics' };
@@ -963,15 +1191,75 @@ async function replScreen(rl, ask) {
   }
 }
 
+// ─── Screen: sessionDetailScreen ─────────────────────────────────────────────
+
+async function sessionDetailScreen(rl, ask, ctx = {}) {
+  const sess = ctx.session;
+  if (!sess) return { next: 'dashboard' };
+
+  const W = 56;
+  const hbar = '═'.repeat(W + 2);
+  const pad = (s) => {
+    const plain = s.replace(/\x1B\[[0-9;]*[A-Za-z]/g, '');
+    return s + ' '.repeat(Math.max(0, W - plain.length));
+  };
+
+  const statusLine = sess.isActive
+    ? `active`
+    : `inactive`;
+
+  const detailLines = [
+    `  Session: ${sess.name}`,
+    `╠${hbar}╣`,
+    `  ID: ${sess.id.slice(0, 8)}...`,
+    `  Status: ${statusLine}`,
+    `  Prompts: ${sess.promptCount}`,
+    `  Last active: ${sess.age}`,
+    `  Project: ${sess.project || process.cwd()}`,
+  ];
+
+  console.log(`╔${hbar}╗`);
+  for (const line of detailLines) {
+    console.log(`║  ${pad(line)}║`);
+  }
+  console.log(`╚${hbar}╝`);
+  console.log('');
+
+  if (sess.isActive) {
+    console.log('  [c] Continue this session (claude --continue)');
+  } else {
+    console.log('  [r] Resume this session (claude --resume)');
+  }
+  console.log('  [b] Back to dashboard');
+  console.log('');
+
+  const choice = (await ask('  Choice: ')).trim().toLowerCase();
+
+  if (choice === 'c' || choice === 'r') {
+    console.log(`\n  Launching: claude --resume ${sess.id}\n`);
+    try {
+      const { spawnSync } = await import('node:child_process');
+      spawnSync('claude', ['--resume', sess.id], { stdio: 'inherit' });
+    } catch {
+      console.log('  Could not launch claude CLI. Run manually:');
+      console.log(`    claude --resume ${sess.id}`);
+    }
+    return { next: 'dashboard' };
+  }
+
+  return { next: 'dashboard' };
+}
+
 // ─── Screen state machine ─────────────────────────────────────────────────────
 
 const SCREENS = {
-  welcome:     welcomeScreen,
-  dashboard:   dashboardScreen,
-  auth:        authScreen,
-  profile:     profileScreen,
-  diagnostics: diagnosticsScreen,
-  repl:        replScreen,
+  welcome:        welcomeScreen,
+  dashboard:      dashboardScreen,
+  auth:           authScreen,
+  profile:        profileScreen,
+  diagnostics:    diagnosticsScreen,
+  repl:           replScreen,
+  'session-detail': sessionDetailScreen,
 };
 
 async function runScreens(startScreen = 'dashboard') {
@@ -979,15 +1267,19 @@ async function runScreens(startScreen = 'dashboard') {
   const ask = (q) => new Promise(res => rl.question(q, res));
 
   let current = startScreen;
+  let ctx = {};
   while (current && current !== 'exit') {
     const screen = SCREENS[current];
     if (!screen) break;
     try {
-      const result = await screen(rl, ask);
+      const result = await screen(rl, ask, ctx);
       current = result?.next || 'exit';
+      // Pass through context (e.g. selected session) to next screen
+      ctx = result?.session ? { session: result.session } : {};
     } catch (e) {
       console.error(`Error: ${e.message}`);
       current = 'dashboard'; // recover to dashboard on error
+      ctx = {};
     }
   }
   rl.close();
@@ -1007,9 +1299,15 @@ async function main() {
 
   if (!cmd) {
     if (isInteractive) {
-      // Check if first-run (no profile) → welcome screen, else dashboard
-      const startScreen = profileExists() ? 'dashboard' : 'welcome';
-      await runScreens(startScreen);
+      const cwd = process.cwd();
+      if (profileExists(cwd)) {
+        // Profile already exists → go straight to dashboard
+        await runScreens('dashboard');
+      } else {
+        // First run: welcomeScreen handles auto-setup detection internally,
+        // then falls through to manual wizard if needed.
+        await runScreens('welcome');
+      }
     } else {
       // Non-TTY: print status card and exit
       const cwd = process.cwd();

package/package.json

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

package/src/profile.mjs

@@ -876,6 +876,94 @@ if (isMain) main().catch(e => { process.stderr.write(e.message + '\n'); process.
 // Exports
 // ---------------------------------------------------------------------------
 
+// ---------------------------------------------------------------------------
+// Auto-setup (1-click, no user input required)
+// ---------------------------------------------------------------------------
+
+/**
+ * Attempt to configure a profile entirely from detected state — no user input.
+ *
+ * Returns:
+ *   {
+ *     confident: boolean,   // true when at least one provider was found
+ *     profile: object|null, // fully-built profile ready to save, or null
+ *     warnings: string[],   // non-fatal issues (e.g. missing provider)
+ *     actions: string[],    // human-readable lines for the summary box
+ *   }
+ *
+ * IMPORTANT: this function NEVER stores credentials — it only reads what's
+ * already present on disk / in environment variables.
+ */
+async function autoSetup(cwd) {
+  const env  = detectEnvironment();
+  const auth = await detectAuth();
+  const plans = detectPlans();
+
+  const result = {
+    confident: false,
+    profile: null,
+    warnings: [],
+    actions: [],
+  };
+
+  // Need at least one provider authenticated
+  if (!auth.claude.found && !auth.openai.found) {
+    result.warnings.push('No provider credentials found');
+    return result;
+  }
+
+  // Build profile from detected state
+  const profile = defaultProfile();
+
+  // Claude
+  if (auth.claude.found) {
+    profile.providers.claude.enabled = true;
+    profile.providers.claude.plan    = plans.claude || '$20';
+    const planLabel = {
+      '$20':  'Claude Pro ($20)',
+      '$100': 'Claude Max x5 ($100)',
+      '$200': 'Claude Max x20 ($200)',
+    }[profile.providers.claude.plan] || profile.providers.claude.plan;
+    result.actions.push(`${planLabel} via ${auth.claude.source}`);
+  } else {
+    profile.providers.claude.enabled = false;
+    result.warnings.push('Claude not authenticated');
+  }
+
+  // OpenAI
+  if (auth.openai.found) {
+    profile.providers.openai.enabled = true;
+    profile.providers.openai.plan    = plans.openai || '$20';
+    const planLabel = {
+      '$20':  'ChatGPT Plus ($20)',
+      '$100': 'ChatGPT Pro ($100)',
+      '$200': 'ChatGPT Pro ($200)',
+    }[profile.providers.openai.plan] || profile.providers.openai.plan;
+    result.actions.push(`${planLabel} via ${auth.openai.source}`);
+  } else {
+    profile.providers.openai.enabled = false;
+    result.warnings.push('OpenAI not authenticated');
+  }
+
+  // Mode
+  const enabledCount = [auth.claude.found, auth.openai.found].filter(Boolean).length;
+  profile.mode = enabledCount >= 2 ? 'dual'
+    : auth.claude.found ? 'solo-claude'
+    : 'solo-openai';
+  profile.bias = 'balanced';
+
+  // Environment note
+  if (env.isReplit && env.hasReplitTools) {
+    result.actions.push('Replit + replit-tools detected');
+  } else if (env.isReplit) {
+    result.actions.push('Replit environment detected');
+  }
+
+  result.confident = true;
+  result.profile   = profile;
+  return result;
+}
+
 export {
   loadProfile, saveProfile, ensureProfile, runOnboarding,
   rememberPreference, forgetPreference, getActivePreferences,
@@ -884,4 +972,5 @@ export {
   detectAuth, detectEnvironment,
   setupAuth, saveAuthKey, loadAuthKeys,
   getActiveKey, removeAuthKey, disableKey, rotateToNextKey,
+  defaultProfile, autoSetup,
 };

package/src/session.mjs

@@ -10,7 +10,7 @@
  *   formatSessionCard(session, repo, health) → compact status card string (≤5 lines)
  */
 
-import { existsSync, readFileSync, writeFileSync, mkdirSync, unlinkSync, renameSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, unlinkSync, renameSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 
 // ─── Constants ────────────────────────────────────────────────────────────────
@@ -197,6 +197,147 @@ export function formatSessionCard(session, repo, health) {
   return lines.join('\n');
 }
 
+// ─── Replit-tools session import ──────────────────────────────────────────────
+
+/**
+ * Human-readable time-ago string from a Unix timestamp (ms).
+ * @param {number} timestamp
+ * @returns {string}
+ */
+function timeAgo(timestamp) {
+  const diff = Date.now() - timestamp;
+  const mins = Math.floor(diff / 60000);
+  if (mins < 1) return 'just now';
+  if (mins < 60) return `${mins}m ago`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+
+/**
+ * Import sessions from replit-tools history.jsonl.
+ * Returns an array of session summary objects, sorted most-recent first.
+ * Returns [] gracefully if replit-tools is not present.
+ *
+ * @param {string} cwd
+ * @returns {Array<{
+ *   id: string, name: string, project: string,
+ *   promptCount: number, lastActive: string,
+ *   isActive: boolean, source: string, age: string
+ * }>}
+ */
+export function importReplitSessions(cwd = process.cwd()) {
+  const sessions = [];
+
+  // Check multiple possible locations for replit-tools
+  const candidates = [
+    join(cwd, '.replit-tools', '.claude-persistent'),
+    join('/home/runner/workspace', '.replit-tools', '.claude-persistent'),
+  ];
+  // Deduplicate
+  const seen = new Set();
+  const replitBases = candidates.filter(p => {
+    const norm = p.replace(/\/+$/, '');
+    if (seen.has(norm)) return false;
+    seen.add(norm);
+    return true;
+  });
+
+  let replitBase = null;
+  for (const candidate of replitBases) {
+    if (existsSync(join(candidate, 'history.jsonl'))) {
+      replitBase = candidate;
+      break;
+    }
+  }
+  if (!replitBase) return sessions;
+
+  // Read history.jsonl
+  const historyPath = join(replitBase, 'history.jsonl');
+
+  let lines;
+  try {
+    lines = readFileSync(historyPath, 'utf8').split('\n').filter(Boolean);
+  } catch { return sessions; }
+
+  const bySession = new Map(); // sessionId → { entries, firstPrompt, lastTimestamp }
+
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      if (!entry.sessionId) continue;
+
+      if (!bySession.has(entry.sessionId)) {
+        bySession.set(entry.sessionId, {
+          sessionId: entry.sessionId,
+          project: entry.project,
+          entries: [],
+          firstPrompt: null,
+          lastTimestamp: 0,
+        });
+      }
+
+      const sess = bySession.get(entry.sessionId);
+      sess.entries.push(entry);
+      if (entry.timestamp > sess.lastTimestamp) sess.lastTimestamp = entry.timestamp;
+
+      // Find first meaningful user prompt (not slash commands, not login, not pastes)
+      if (!sess.firstPrompt && entry.display
+          && !entry.display.startsWith('/')
+          && !entry.display.startsWith('login')
+          && !entry.display.startsWith('[Pasted')) {
+        sess.firstPrompt = entry.display;
+      }
+    } catch { continue; }
+  }
+
+  // Read active terminal sessions
+  // Use the same root as replitBase (go up one level from .claude-persistent)
+  const replitRoot = join(replitBase, '..');
+  const sessionsDir = join(replitRoot, '..', '.claude-sessions');
+  const activeSessionIds = new Set();
+  if (existsSync(sessionsDir)) {
+    try {
+      for (const f of readdirSync(sessionsDir)) {
+        try {
+          const data = JSON.parse(readFileSync(join(sessionsDir, f), 'utf8'));
+          if (data.sessionId) activeSessionIds.add(data.sessionId);
+        } catch { continue; }
+      }
+    } catch { /* non-fatal */ }
+  }
+
+  // Build session list
+  for (const [id, sess] of bySession) {
+    // Derive display name
+    let name = sess.firstPrompt;
+    if (!name) {
+      // Fallback: use first non-login display
+      const firstReal = sess.entries.find(e => e.display && e.display !== 'login');
+      name = firstReal?.display || `Session ${id.slice(0, 8)}`;
+    }
+    // Truncate long names
+    if (name.length > 60) name = name.slice(0, 57) + '...';
+
+    sessions.push({
+      id: sess.sessionId,
+      name,
+      project: sess.project,
+      promptCount: sess.entries.length,
+      lastActive: new Date(sess.lastTimestamp).toISOString(),
+      isActive: activeSessionIds.has(id),
+      source: 'replit-tools',
+      age: timeAgo(sess.lastTimestamp),
+    });
+  }
+
+  // Sort by most recent first
+  sessions.sort((a, b) => new Date(b.lastActive) - new Date(a.lastActive));
+
+  return sessions;
+}
+
 // ─── CLI (direct invocation) ──────────────────────────────────────────────────
 
 const isMain = process.argv[1]?.endsWith('session.mjs');