dual-brain 0.1.1 → 0.1.3

package/bin/dual-brain.mjs

@@ -998,112 +998,94 @@ function loadTerminalState(cwd, terminalId) {
   } catch { return null; }
 }
 
-// ─── Screen: mainScreen ───────────────────────────────────────────────────────
-
-async function mainScreen(rl, ask) {
-  const cwd = process.cwd();
-  const version = readVersion();
-  const profile = loadProfile(cwd);
-  const auth = await detectAuth();
+// ─── Dashboard box helpers ────────────────────────────────────────────────────
 
-  const claudeSub = profile?.providers?.claude;
-  const openaiSub = profile?.providers?.openai;
-  const claudePlan = claudeSub?.plan ?? 'Pro';
-  const openaiPlan = openaiSub?.plan ?? 'Plus';
+/**
+ * Build a provider status string for the dashboard status line.
+ * Returns a string like: "🟢 Claude $100×2 $20×1  🟢 OpenAI $100"
+ * Uses ANSI color codes for the dots (no emoji width issues).
+ */
+function buildProviderStatusLine(profile, auth) {
+  const GREEN = '\x1b[32m●\x1b[0m';
+  const RED   = '\x1b[31m●\x1b[0m';
+  const now   = Date.now();
 
-  // Check subscription expiry
-  const now = Date.now();
-  const claudeExpired = claudeSub?.expiresAt && Date.parse(claudeSub.expiresAt) < now;
-  const openaiExpired = openaiSub?.expiresAt && Date.parse(openaiSub.expiresAt) < now;
+  function providerSegment(provKey, displayName) {
+    const sub    = profile?.providers?.[provKey];
+    const found  = provKey === 'claude' ? auth.claude.found : auth.openai.found;
+    if (!found) return `${RED} ${displayName}: not connected`;
 
-  const claudeDays = daysUntil(claudeSub?.expiresAt);
-  const openaiDays = daysUntil(openaiSub?.expiresAt);
+    const expired = sub?.expiresAt && Date.parse(sub.expiresAt) < now;
+    if (expired)  return `${RED} ${displayName}: expired`;
 
-  function subLine(name, plan, found, expired, days, sub) {
-    const label = sub?.label ? ` [${sub.label}]` : '';
-    if (!found) return `⚠️  ${name}: not logged in — run: ${name === 'Claude' ? 'claude auth login' : 'codex login'}`;
-    // Multi-sub: show aggregated counts when more than one sub exists
+    const dot = GREEN;
+    // Multi-sub: show aggregated plan amounts
     const subs = sub?.subs;
-    if (subs && subs.length > 1) {
-      const aggregate = aggregatePlans(subs);
-      return `✅ ${name}: ${aggregate}  [${subs.length} subs]`;
+    if (subs && subs.length > 0) {
+      const agg = aggregatePlans(subs);
+      return `${dot} ${displayName} ${agg}`;
     }
-    if (expired) return `🔴 ${name}: ${plan} expired${label} — will re-auth`;
-    const daysNote = (days !== null && days <= 7) ? ` (${days}d left)` : '';
-    return `✅ ${name}: ${plan}${label}${daysNote}`;
+    // Single plan
+    const planPrice = PLAN_PRICES[sub?.plan] || sub?.plan || 'connected';
+    return `${dot} ${displayName} ${planPrice}`;
   }
 
-  const headerLines = [
-    subLine('Claude', claudePlan, auth.claude.found, claudeExpired, claudeDays, claudeSub),
-    subLine('OpenAI', openaiPlan, auth.openai.found, openaiExpired, openaiDays, openaiSub),
-  ];
+  const parts = [];
+  parts.push(providerSegment('claude', 'Claude'));
+  parts.push(providerSegment('openai', 'OpenAI'));
+  return parts.join('  ');
+}
 
-  const rtMain = detectReplitTools(cwd);
-  const dtVersion = (rtMain.installed && rtMain.version) ? rtMain.version : null;
-  console.log(`🧠 Dual Brain v${version}`);
-  const latestVersion = await checkForUpdates(version);
-  if (latestVersion) {
-    console.log(`  ⬆️  Update available: v${version} → v${latestVersion}`);
-    console.log(`     Run: npx -y dual-brain@latest`);
-  }
-  console.log('');
+/**
+ * Render a box row padded to inner width W (stripping ANSI for length calculation).
+ * Returns a string like: "│ content padded to W │"
+ */
+function makeBoxRow(content, W) {
+  const plain = content.replace(/\x1b\[[0-9;]*m/g, '');
+  const padding = Math.max(0, W - plain.length);
+  return `│ ${content}${' '.repeat(padding)} │`;
+}
 
-  // Provider status (outside the box)
-  for (const line of headerLines) {
-    console.log(`  ${line}`);
-  }
-  if (dtVersion) {
-    console.log(`  📦 data-tools v${dtVersion} detected`);
-  }
+// ─── Screen: mainScreen ───────────────────────────────────────────────────────
 
-  const sparkline = buildSparkline(cwd);
-  if (sparkline) {
-    console.log(`  Activity: ${sparkline}`);
-  }
+async function mainScreen(rl, ask) {
+  const cwd     = process.cwd();
+  const version = readVersion();
+  const profile = loadProfile(cwd);
+  const auth    = await detectAuth();
+
+  const claudeSub = profile?.providers?.claude;
+  const openaiSub = profile?.providers?.openai;
 
-  // Silent OAuth token auto-refresh (like data-tools)
+  // Check subscription expiry for auto-refresh
+  const now          = Date.now();
+  const claudeExpired = claudeSub?.expiresAt && Date.parse(claudeSub.expiresAt) < now;
+  const openaiExpired = openaiSub?.expiresAt && Date.parse(openaiSub.expiresAt) < now;
+
+  // Silent OAuth token auto-refresh
   try {
     const { autoRefreshToken } = await import('../src/profile.mjs');
-    const refreshResult = await autoRefreshToken(cwd);
-    if (refreshResult.status === 'refreshed') {
-      console.log(`  🔄 Token auto-refreshed (${refreshResult.hoursRemaining}h remaining)`);
-    }
+    await autoRefreshToken(cwd);
   } catch {}
 
-  // Append-only session archive sync (like data-tools)
+  // Append-only session archive sync
   try {
     const { syncSessionMirror } = await import('../src/session.mjs');
-    const mirror = syncSessionMirror(cwd);
-    if (mirror.copied > 0 || mirror.grew > 0) {
-      console.log(`  ✅ Archive mirror: +${mirror.copied} new, ${mirror.grew} updated`);
-    }
+    syncSessionMirror(cwd);
   } catch {}
 
   // Auto-refresh expired subscriptions
   if (claudeExpired || openaiExpired) {
     const { spawnSync } = await import('node:child_process');
-    const expired = [];
-    if (claudeExpired) expired.push('Claude');
-    if (openaiExpired) expired.push('OpenAI');
-    console.log(`\n  ${expired.join(' & ')} subscription expired. Re-authenticating...`);
     if (claudeExpired) {
       const r = spawnSync('claude', ['auth', 'login'], { stdio: 'inherit', timeout: 30000 });
-      if (r.status === 0) {
-        claudeSub.expiresAt = null;
-        saveProfile(profile, { cwd });
-        console.log('  ✓ Claude re-authenticated');
-      }
+      if (r.status === 0) { claudeSub.expiresAt = null; saveProfile(profile, { cwd }); }
     }
     if (openaiExpired) {
       const r = spawnSync('codex', ['login'], { stdio: 'inherit', timeout: 30000 });
-      if (r.status === 0) {
-        openaiSub.expiresAt = null;
-        saveProfile(profile, { cwd });
-        console.log('  ✓ OpenAI re-authenticated');
-      }
+      if (r.status === 0) { openaiSub.expiresAt = null; saveProfile(profile, { cwd }); }
     }
   }
-  console.log('');
 
   // Build session index in background (powers search + smart resume)
   try {
@@ -1111,245 +1093,284 @@ async function mainScreen(rl, ask) {
     buildSessionIndex(cwd);
   } catch {}
 
-  const recentSessions = enrichSessions(importReplitSessions(cwd), cwd).slice(0, 7);
+  // Gather recent sessions
+  const recentSessions = enrichSessions(importReplitSessions(cwd), cwd).slice(0, 3);
+
+  // Detect data-tools version
+  const rtMain    = detectReplitTools(cwd);
+  const dtVersion = (rtMain.installed && rtMain.version) ? rtMain.version : null;
+
+  // ── Box layout ────────────────────────────────────────────────────────────
+  const termW = process.stdout.columns || 60;
+  const boxW  = Math.min(termW - 2, 60); // outer width (including │ │)
+  const W     = boxW - 4;                // inner content width (│ {content} │)
+
+  const top = `┌${'─'.repeat(boxW - 2)}┐`;
+  const sep = `├${'─'.repeat(boxW - 2)}┤`;
+  const bot = `└${'─'.repeat(boxW - 2)}┘`;
+
+  const row = (content) => makeBoxRow(content, W);
+
+  // ── Header: one line above the box ────────────────────────────────────────
+  process.stdout.write(`\n🧠 dual-brain v${version}\n`);
+  {
+    let gitName = '';
+    try {
+      const { execSync } = await import('node:child_process');
+      gitName = execSync('git config user.name', { encoding: 'utf8', stdio: ['pipe','pipe','pipe'] }).trim();
+    } catch { /* ignore */ }
+    if (gitName) {
+      const hour = new Date().getHours();
+      let greet;
+      if (hour >= 5 && hour <= 11)  greet = 'Good morning';
+      else if (hour >= 12 && hour <= 16) greet = 'Good afternoon';
+      else if (hour >= 17 && hour <= 21) greet = 'Good evening';
+      else                               greet = 'Late night';
+      process.stdout.write(`\x1b[2m${greet}, ${gitName}\x1b[0m\n`);
+    }
+  }
 
-  if (recentSessions.length > 0) {
-    console.log('  Recent Sessions:');
+  // ── Status section ────────────────────────────────────────────────────────
+  const providerLine = buildProviderStatusLine(profile, auth);
+
+  const statusRows = [row(providerLine)];
+  if (dtVersion) {
+    statusRows.push(row(`\x1b[2m📦 data-tools v${dtVersion}\x1b[0m`));
+  }
+
+  // ── Sessions section ──────────────────────────────────────────────────────
+  const sessionRows = [];
+  if (recentSessions.length === 0) {
+    const noSessMsg = 'No sessions yet. Press n to start.';
+    sessionRows.push(row(noSessMsg));
+  } else {
     recentSessions.forEach((sess, i) => {
-      const pin    = sess.pinned ? '📌 ' : '   ';
-      const active = sess.isActive ? ' ●' : '';
-      const cat    = sess.category ? `  [${sess.category}]` : '';
-      const tool = (sess.tool === 'codex') ? 'cdx' : 'cld';
-      // If the name is still the "Session XXXXXXXX" fallback, try the project path instead
+      // Normalize name: strip "Session XXXXXXXX" fallbacks
       let rawName = sess.name || '';
       if (/^Session [0-9a-f]{8,}$/i.test(rawName)) {
-        rawName = sess.project ? sess.project.replace(/^-/, '/').replace(/-/g, '/') : sess.id.slice(0, 8);
+        rawName = sess.project
+          ? sess.project.replace(/^-/, '/').replace(/-/g, '/')
+          : sess.id.slice(0, 8);
       }
-      const displayName = rawName.length > 40 ? rawName.slice(0, 37) + '...' : (rawName || sess.id.slice(0, 8));
-      console.log(`  [${i + 1}] ${pin}${tool}  ${sess.age.padEnd(8)} ${displayName}${active}${cat}`);
+      // Layout: "{num}  {name...}  {age}"
+      const numStr  = String(i + 1);
+      const ageStr  = sess.age || '';
+      // Available for name: W - numStr.length - 2 spaces - 2 spaces before age - ageStr.length
+      const nameMax = W - numStr.length - 2 - 2 - ageStr.length;
+      const name    = rawName.length > nameMax
+        ? rawName.slice(0, nameMax - 3) + '...'
+        : rawName.padEnd(nameMax);
+      const content = `${numStr}  ${name}  ${ageStr}`;
+      sessionRows.push(row(content));
     });
-    console.log('');
   }
 
-  const brandW = 37;
-  const brandTop    = `  ┌${'─'.repeat(brandW)}┐`;
-  const brandBottom = `  └${'─'.repeat(brandW)}┘`;
-  const brandPad = (s) => {
-    const leftPad = Math.floor((brandW - s.length) / 2);
-    const rightPad = brandW - s.length - leftPad;
-    return ' '.repeat(leftPad) + s + ' '.repeat(rightPad);
+  // ── Actions bar ───────────────────────────────────────────────────────────
+  const actionsContent = '↵ Resume  n New  / Search  s Settings  q Quit';
+  const actionsRow     = row(actionsContent);
+
+  // ── Print the full box ────────────────────────────────────────────────────
+  const lines = [
+    top,
+    ...statusRows,
+    sep,
+    ...sessionRows,
+    sep,
+    actionsRow,
+    bot,
+  ];
+  process.stdout.write(lines.join('\n') + '\n');
+  process.stdout.write(`\x1b[2mPowered by data-tools · Steve Moraco\x1b[0m\n\n`);
+
+  // ── Key handling ──────────────────────────────────────────────────────────
+  // Use raw keypress mode so we can show a live type-to-start buffer.
+  // Single-key commands (n, s, q, /, 1-9, Enter) only fire when buffer is empty.
+  let taskBuffer = '';
+
+  const readline = await import('node:readline');
+
+  // Render the type-ahead line below the box (overwrites the current cursor line)
+  const renderBuffer = (buf) => {
+    // Move to the prompt line (we're already at it after printing the box + footer)
+    // Use carriage return + clear-to-end-of-line to overwrite
+    if (buf.length === 0) {
+      process.stdout.write('\r\x1b[K');
+    } else {
+      const display = buf.length > W - 4 ? buf.slice(-(W - 4)) : buf;
+      process.stdout.write(`\r\x1b[K> ${display}\x1b[7m \x1b[0m`);
+    }
   };
-  console.log(brandTop);
-  console.log(`  │ ${brandPad('Dual Brain Session Manager')}│`);
-  console.log(`  │ ${brandPad('Built on data-tools by Steve Moraco')}│`);
-  console.log(brandBottom);
-  console.log('');
 
-  const running = countRunningInstances();
-  const runningParts = [];
-  if (running.claude > 0) runningParts.push(`${running.claude} claude`);
-  if (running.codex > 0)  runningParts.push(`${running.codex} codex`);
-  if (runningParts.length > 0) {
-    console.log(`  (${runningParts.join(', ')} running)`);
-    console.log('');
-  }
+  // Enable keypress events on stdin (safe to call multiple times)
+  readline.emitKeypressEvents(process.stdin, rl);
 
-  console.log('  [c] Continue last session');
-  console.log('  [n] New session');
-  console.log('');
-  if (recentSessions.length > 0) {
-    console.log('  [1-9] Resume numbered above');
-  }
-  console.log('  [r] Resume (full list)');
-  console.log('  [/] Search sessions');
-  console.log('  [e] Manage sessions');
-  console.log('  [m] Manage subscriptions');
-  console.log('  [s] Settings');
-  console.log('  [?] Help & shortcuts');
-  console.log('');
-  console.log('  \x1b[2mreplit-tools:\x1b[0m');
-  console.log('  [i] Import sessions');
-  console.log('  [d] Switch to data-tools');
-  console.log('');
-  console.log('  [q] Exit');
-  console.log('');
+  const raw = await new Promise((resolve) => {
+    // Switch to raw mode if possible (TTY only)
+    const wasRaw = process.stdin.isRaw;
+    const canRaw = process.stdin.isTTY && typeof process.stdin.setRawMode === 'function';
+    if (canRaw) process.stdin.setRawMode(true);
 
-  const choice = (await ask('  Choice: ')).trim().toLowerCase();
+    const cleanup = () => {
+      process.stdin.removeListener('keypress', onKey);
+      if (canRaw) {
+        try { process.stdin.setRawMode(wasRaw || false); } catch {}
+      }
+    };
 
-  if (choice === '?') {
-    const W = 37;
-    const helpTop    = `  ┌${'─'.repeat(W)}┐`;
-    const helpSep    = `  ├${'─'.repeat(W)}┤`;
-    const helpBottom = `  └${'─'.repeat(W)}┘`;
-    const helpPad = (s) => s + ' '.repeat(Math.max(0, W - s.length));
-    console.log('');
-    console.log(helpTop);
-    console.log(`  │ ${helpPad('At ~/workspace$ prompt:')}│`);
-    console.log(`  │ ${helpPad('db = show this menu')}│`);
-    console.log(`  │ ${helpPad('j  = login to claude')}│`);
-    console.log(`  │ ${helpPad('k  = login to codex')}│`);
-    console.log(helpSep);
-    console.log(`  │ ${helpPad('In Claude:')}│`);
-    console.log(`  │ ${helpPad('Ctrl+C x2 = back to menu')}│`);
-    console.log(`  │ ${helpPad('Ctrl+C x3 = exit to shell')}│`);
-    console.log(helpBottom);
-    console.log('');
-    await ask('  Press Enter to continue...');
-    return { next: 'main' };
-  }
+    const onKey = (str, key) => {
+      if (!key) return;
 
-  if (choice === 'n') { return { next: 'new-session' }; }
+      const name = key.name || '';
+      const seq  = key.sequence || str || '';
 
-  if (choice === 'c') {
-    const termId    = getTerminalId();
-    const termState = loadTerminalState(cwd, termId);
-    const sessions  = importReplitSessions(cwd);
+      // Ctrl-C / Ctrl-D → exit
+      if (key.ctrl && (name === 'c' || name === 'd')) {
+        cleanup();
+        process.stdout.write('\n');
+        resolve('q');
+        return;
+      }
 
-    // Priority: terminal-specific last session, then global last session
-    const targetId = termState?.sessionId || (sessions.length > 0 ? sessions[0].id : null);
+      // Enter key
+      if (name === 'return' || name === 'enter' || seq === '\r' || seq === '\n') {
+        cleanup();
+        if (taskBuffer.length > 0) {
+          process.stdout.write('\n');
+          resolve(`__task__:${taskBuffer}`);
+        } else {
+          resolve('');
+        }
+        return;
+      }
 
-    if (!targetId) {
-      console.log('\n  No recent sessions found.\n');
-      await ask('  Press Enter to continue...');
-      return { next: 'main' };
-    }
+      // Escape → clear buffer
+      if (name === 'escape') {
+        taskBuffer = '';
+        renderBuffer('');
+        return;
+      }
 
-    // Smart resume preview
-    try {
-      const { getSessionContext } = await import('../src/session.mjs');
-      const ctx = getSessionContext(targetId, cwd);
-      if (ctx) {
-        console.log('');
-        if (ctx.lastPrompt) console.log(`  Last working on: ${ctx.lastPrompt}`);
-        if (ctx.filesTouched.length > 0) console.log(`  Files touched: ${ctx.filesTouched.join(', ')}`);
+      // Backspace / delete
+      if (name === 'backspace' || name === 'delete') {
+        if (taskBuffer.length > 0) {
+          taskBuffer = taskBuffer.slice(0, -1);
+          renderBuffer(taskBuffer);
+        }
+        return;
       }
-    } catch {}
 
+      // Ignore non-printable / control keys
+      if (key.ctrl || key.meta || !str || str.length === 0) return;
+      const code = str.codePointAt(0);
+      if (code < 32 || code === 127) return;
+
+      // Single-key commands only fire when buffer is empty
+      if (taskBuffer.length === 0) {
+        const lower = str.toLowerCase();
+        if (lower === 'n' || lower === 's' || lower === 'q' || lower === '/') {
+          cleanup();
+          process.stdout.write('\n');
+          resolve(lower);
+          return;
+        }
+        const digit = parseInt(str, 10);
+        if (!isNaN(digit) && digit >= 1 && digit <= 9) {
+          cleanup();
+          process.stdout.write('\n');
+          resolve(str);
+          return;
+        }
+      }
+
+      // Accumulate into buffer
+      taskBuffer += str;
+      renderBuffer(taskBuffer);
+    };
+
+    process.stdin.on('keypress', onKey);
+  });
+
+  const choice = typeof raw === 'string' ? raw.toLowerCase() : '';
+
+  // Typed task → dispatch as "dual-brain go"
+  if (raw.startsWith('__task__:')) {
+    const prompt = raw.slice('__task__:'.length).trim();
+    if (prompt) {
+      return { next: 'go', prompt };
+    }
+    return { next: 'main' };
+  }
+
+  // Enter (empty) → resume most recent session
+  if (raw === '' || choice === '\r') {
+    if (recentSessions.length === 0) {
+      return { next: 'new-session' };
+    }
+    const sess = recentSessions[0];
     const { spawnSync } = await import('node:child_process');
-    const tool = termState?.tool || 'claude';
-    console.log(`\n  Resuming: ${tool} --resume ${targetId}\n`);
-    spawnSync(tool === 'codex' ? 'codex' : 'claude', ['--resume', targetId], { stdio: 'inherit' });
-    saveTerminalState(cwd, termId, targetId, tool);
+    process.stdout.write(`\n  Launching: claude --resume ${sess.id}\n\n`);
+    spawnSync('claude', ['--resume', sess.id], { stdio: 'inherit' });
+    saveTerminalState(cwd, getTerminalId(), sess.id, sess.tool || 'claude');
     return { next: 'main' };
   }
 
-  const numChoice = parseInt(choice, 10);
+  // Number 1-3 → resume that session
+  const numChoice = parseInt(raw, 10);
   if (!isNaN(numChoice) && numChoice >= 1 && numChoice <= recentSessions.length) {
     const sess = recentSessions[numChoice - 1];
-
-    // Smart resume preview
     try {
       const { getSessionContext } = await import('../src/session.mjs');
       const ctx = getSessionContext(sess.id, cwd);
       if (ctx) {
-        console.log('');
-        if (ctx.lastPrompt) console.log(`  Last working on: ${ctx.lastPrompt}`);
-        if (ctx.filesTouched.length > 0) console.log(`  Files touched: ${ctx.filesTouched.join(', ')}`);
+        if (ctx.lastPrompt) process.stdout.write(`\n  Last working on: ${ctx.lastPrompt}\n`);
+        if (ctx.filesTouched.length > 0) process.stdout.write(`  Files touched: ${ctx.filesTouched.join(', ')}\n`);
       }
     } catch {}
-
     const { spawnSync } = await import('node:child_process');
-    console.log(`\n  Launching: claude --resume ${sess.id}\n`);
+    process.stdout.write(`\n  Launching: claude --resume ${sess.id}\n\n`);
     spawnSync('claude', ['--resume', sess.id], { stdio: 'inherit' });
     saveTerminalState(cwd, getTerminalId(), sess.id, sess.tool || 'claude');
     return { next: 'main' };
   }
 
-  if (choice === 'r') {
-    const allSessions = enrichSessions(importReplitSessions(cwd), cwd);
-    if (allSessions.length === 0) {
-      console.log('\n  No sessions found.\n');
-      await ask('  Press Enter to continue...');
-      return { next: 'main' };
-    }
-
-    console.log('\n  All Sessions:');
-    allSessions.forEach((sess, i) => {
-      const pin    = sess.pinned ? '📌 ' : '   ';
-      const active = sess.isActive ? ' ●' : '';
-      const cat    = sess.category ? `  [${sess.category}]` : '';
-      const tool   = (sess.tool === 'codex') ? 'cdx' : 'cld';
-      console.log(`  [${String(i + 1).padStart(2)}] ${pin}${tool}  ${sess.age.padEnd(8)} ${sess.name}${active}${cat}`);
-    });
-    console.log('');
-
-    const pick = (await ask('  Enter number to resume (or Enter to cancel): ')).trim();
-    const num = parseInt(pick, 10);
-    if (!isNaN(num) && num >= 1 && num <= allSessions.length) {
-      const sess = allSessions[num - 1];
-      const { spawnSync } = await import('node:child_process');
-      const tool = sess.tool === 'codex' ? 'codex' : 'claude';
-      console.log(`\n  Launching: ${tool} --resume ${sess.id}\n`);
-      spawnSync(tool, ['--resume', sess.id], { stdio: 'inherit' });
-    }
-    return { next: 'main' };
-  }
+  if (choice === 'n') { return { next: 'new-session' }; }
 
   if (choice === '/') {
     const query = (await ask('  Search: ')).trim();
     if (!query) return { next: 'main' };
 
     const { searchSessions, buildSessionIndex } = await import('../src/session.mjs');
-    // Build index if needed (silent)
     try { buildSessionIndex(cwd); } catch {}
 
     const results = searchSessions(query, cwd);
     if (results.length === 0) {
-      console.log(`\n  No sessions matching "${query}"\n`);
+      process.stdout.write(`\n  No sessions matching "${query}"\n\n`);
       await ask('  Press Enter to continue...');
       return { next: 'main' };
     }
 
-    console.log(`\n  Found ${results.length} session${results.length === 1 ? '' : 's'}:`);
+    process.stdout.write(`\n  Found ${results.length} session${results.length === 1 ? '' : 's'}:\n`);
     results.slice(0, 9).forEach((sess, i) => {
-      const tool = sess.tool === 'codex' ? 'cdx' : 'cld';
-      const date = sess.date ? new Date(sess.date).toLocaleDateString() : '?';
+      const tool   = sess.tool === 'codex' ? 'cdx' : 'cld';
+      const date   = sess.date ? new Date(sess.date).toLocaleDateString() : '?';
       const topics = sess.topics.slice(0, 3).join(', ');
-      console.log(`  [${i + 1}] ${tool}  ${date}  ${sess.prompts.first || sess.id.slice(0, 8)}`);
-      if (topics) console.log(`       topics: ${topics}`);
+      process.stdout.write(`  [${i + 1}] ${tool}  ${date}  ${sess.prompts.first || sess.id.slice(0, 8)}\n`);
+      if (topics) process.stdout.write(`       topics: ${topics}\n`);
     });
-    console.log('');
+    process.stdout.write('\n');
 
     const pick = (await ask('  Enter number to resume (or Enter to cancel): ')).trim();
-    const num = parseInt(pick, 10);
+    const num  = parseInt(pick, 10);
     if (!isNaN(num) && num >= 1 && num <= Math.min(results.length, 9)) {
       const sess = results[num - 1];
       const { spawnSync } = await import('node:child_process');
       const tool = sess.tool === 'codex' ? 'codex' : 'claude';
-      console.log(`\n  Launching: ${tool} --resume ${sess.id}\n`);
+      process.stdout.write(`\n  Launching: ${tool} --resume ${sess.id}\n\n`);
       spawnSync(tool, ['--resume', sess.id], { stdio: 'inherit' });
     }
     return { next: 'main' };
   }
 
-  if (choice === 'e') { return { next: 'sessions' }; }
-
-  if (choice === 'i') {
-    const sessions = importReplitSessions(cwd);
-    if (sessions.length === 0) {
-      console.log('\n  No replit-tools sessions found to import.\n');
-    } else {
-      console.log(`\n  ✅ Found ${sessions.length} sessions from replit-tools.`);
-      console.log('  Sessions are automatically available in the list above.\n');
-    }
-    await ask('  Press Enter to continue...');
-    return { next: 'main' };
-  }
-
-  if (choice === 'd') {
-    const { spawnSync } = await import('node:child_process');
-    const which = spawnSync('which', ['claude-menu'], { encoding: 'utf8' });
-    if (which.status === 0) {
-      spawnSync('claude-menu', { stdio: 'inherit' });
-    } else {
-      console.log('\n  data-tools not found — install with: npm i -g replit-tools\n');
-      await ask('  Press Enter to continue...');
-    }
-    return { next: 'main' };
-  }
-
-  if (choice === 'm') { return { next: 'subscriptions' }; }
-
   if (choice === 's') { return { next: 'settings' }; }
   if (choice === 'q' || choice === 'exit') { return { next: 'exit' }; }
 
@@ -1391,84 +1412,90 @@ async function newSessionScreen(rl, ask) {
 
 async function settingsScreen(rl, ask) {
   const cwd = process.cwd();
-  const profile = loadProfile(cwd);
-  const auth = await detectAuth();
 
-  let guardCount = 0;
-  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));
-      guardCount = [hasEdit, hasWrite, hasBash, hasAgent].filter(Boolean).length;
-    }
-  } catch { /* ignore */ }
-
-  const modeLabel = (m) => m === profile.mode ? `${m} (active)` : m;
-
-  const claudeSub = profile?.providers?.claude;
-  const openaiSub = profile?.providers?.openai;
-  const claudePlanLabel = claudeSub?.enabled
-    ? (CLAUDE_PLAN_LABELS[claudeSub.plan] ?? claudeSub.plan ?? 'n/a')
-    : 'disabled';
-  const openaiPlanLabel = openaiSub?.enabled
-    ? (OPENAI_PLAN_LABELS[openaiSub.plan] ?? openaiSub.plan ?? 'n/a')
-    : 'disabled';
-
-  const settingsLines = [
-    `Mode:`,
-    `  [1] ${modeLabel('cost-saver')}`,
-    `  [2] ${modeLabel('balanced')}`,
-    `  [3] ${modeLabel('quality-first')}`,
-    '',
-    `Subscriptions:`,
-    `  Claude: ${auth.claude.found ? 'logged in' : 'not logged in'} — ${claudePlanLabel}${claudeSub?.label ? ` [${claudeSub.label}]` : ''}`,
-    `  OpenAI: ${auth.openai.found ? 'logged in' : 'not logged in'} — ${openaiPlanLabel}${openaiSub?.label ? ` [${openaiSub.label}]` : ''}`,
-    '',
-    `Enforcement: ${guardCount}/4 guards active`,
+  // Box layout matching dashboard
+  const termW = process.stdout.columns || 60;
+  const boxW  = Math.min(termW - 2, 60);
+  const W     = boxW - 4;
+
+  const top = `┌${'─'.repeat(boxW - 2)}┐`;
+  const sep = `├${'─'.repeat(boxW - 2)}┤`;
+  const bot = `└${'─'.repeat(boxW - 2)}┘`;
+  const row = (content) => makeBoxRow(content, W);
+
+  const lines = [
+    top,
+    row('Settings'),
+    sep,
+    row('[m] Manage subscriptions'),
+    row('[e] Manage sessions'),
+    row('[i] Import from replit-tools'),
+    row('[d] Switch to data-tools'),
+    row('[?] Help & shortcuts'),
+    row('[x] Diagnostics'),
+    row(''),
+    row('[Esc/b] Back to dashboard'),
+    bot,
   ];
+  process.stdout.write('\n' + lines.join('\n') + '\n\n');
 
-  console.log('');
-  console.log(box('Settings', settingsLines));
-  console.log('');
-  console.log(menu([
-    { key: '1', label: 'Switch to cost-saver',       section: 'Mode' },
-    { key: '2', label: 'Switch to balanced',          section: 'Mode' },
-    { key: '3', label: 'Switch to quality-first',     section: 'Mode' },
-    { key: 'a', label: 'Manage subscriptions',        section: 'Subscriptions' },
-    { key: 'i', label: 'Reinstall hooks',             section: 'Enforcement' },
-    { key: 'b', label: 'Back',                        section: '' },
-  ]));
-  console.log('');
+  const raw    = (await ask('  Choice: ')).trim();
+  const choice = raw.toLowerCase();
 
-  const choice = (await ask('  Choice: ')).trim().toLowerCase();
+  if (choice === 'm') { return { next: 'subscriptions' }; }
 
-  if (choice === '1' || choice === '2' || choice === '3') {
-    const modeMap = { '1': 'cost-saver', '2': 'balanced', '3': 'quality-first' };
-    profile.mode = modeMap[choice];
-    saveProfile(profile, { cwd });
-    console.log(`  Mode set to: ${profile.mode}`);
+  if (choice === 'e') { return { next: 'sessions' }; }
+
+  if (choice === 'i') {
+    const sessions = importReplitSessions(cwd);
+    if (sessions.length === 0) {
+      process.stdout.write('\n  No replit-tools sessions found to import.\n\n');
+    } else {
+      process.stdout.write(`\n  Found ${sessions.length} sessions from replit-tools.\n`);
+      process.stdout.write('  Sessions are automatically available in the Recent list.\n\n');
+    }
+    await ask('  Press Enter to continue...');
     return { next: 'settings' };
   }
 
-  if (choice === 'a') {
-    return { next: 'subscriptions' };
+  if (choice === 'd') {
+    const { spawnSync } = await import('node:child_process');
+    const which = spawnSync('which', ['claude-menu'], { encoding: 'utf8' });
+    if (which.status === 0) {
+      spawnSync('claude-menu', { stdio: 'inherit' });
+    } else {
+      process.stdout.write('\n  data-tools not found — install with: npm i -g replit-tools\n\n');
+      await ask('  Press Enter to continue...');
+    }
+    return { next: 'settings' };
   }
 
-  if (choice === 'i') {
-    await cmdInstall();
+  if (choice === '?') {
+    const W2 = 37;
+    const helpTop    = `  ┌${'─'.repeat(W2)}┐`;
+    const helpSep    = `  ├${'─'.repeat(W2)}┤`;
+    const helpBottom = `  └${'─'.repeat(W2)}┘`;
+    const helpPad    = (s) => s + ' '.repeat(Math.max(0, W2 - s.length));
+    process.stdout.write('\n');
+    process.stdout.write(helpTop + '\n');
+    process.stdout.write(`  │ ${helpPad('At ~/workspace$ prompt:')}│\n`);
+    process.stdout.write(`  │ ${helpPad('db = show this menu')}│\n`);
+    process.stdout.write(`  │ ${helpPad('j  = login to claude')}│\n`);
+    process.stdout.write(`  │ ${helpPad('k  = login to codex')}│\n`);
+    process.stdout.write(helpSep + '\n');
+    process.stdout.write(`  │ ${helpPad('In Claude:')}│\n`);
+    process.stdout.write(`  │ ${helpPad('Ctrl+C x2 = back to menu')}│\n`);
+    process.stdout.write(`  │ ${helpPad('Ctrl+C x3 = exit to shell')}│\n`);
+    process.stdout.write(helpBottom + '\n\n');
+    await ask('  Press Enter to continue...');
     return { next: 'settings' };
   }
 
-  if (choice === 'b' || choice === 'back') { return { next: 'main' }; }
+  if (choice === 'x') { return { next: 'diagnostics' }; }
 
-  return { next: 'settings' };
+  if (choice === 'b' || choice === 'back' || raw === '\x1b') { return { next: 'main' }; }
+
+  return { next: 'main' };
 }
 
 // ─── Helper: aggregatePlans ───────────────────────────────────────────────────
@@ -2559,13 +2586,40 @@ async function runScreens(startScreen = 'dashboard') {
   let current = startScreen;
   let ctx = {};
   while (current && current !== 'exit') {
+    // Handle type-to-start dispatch from mainScreen
+    if (current === 'go' && ctx.prompt) {
+      const prompt = ctx.prompt;
+      const cwd    = process.cwd();
+      const profile   = loadProfile(cwd);
+      const detection = detectTask({ prompt });
+      const decision  = decideRoute({ profile, detection, cwd });
+      process.stdout.write(`\n  Routing: ${decision.provider}/${decision.model} (${decision.tier})\n`);
+      process.stdout.write(`  Reason: ${decision.explanation}\n\n`);
+      const { spawnSync } = await import('node:child_process');
+      const launchTool = decision.provider === 'openai' ? 'codex' : 'claude';
+      if (launchTool === 'codex') {
+        spawnSync('codex', [prompt], { stdio: 'inherit' });
+      } else {
+        spawnSync('claude', ['-p', prompt], { stdio: 'inherit' });
+      }
+      const freshSessions = importReplitSessions(cwd);
+      if (freshSessions.length > 0) {
+        saveTerminalState(cwd, getTerminalId(), freshSessions[0].id, launchTool);
+      }
+      current = 'main';
+      ctx = {};
+      continue;
+    }
+
     const screen = SCREENS[current];
     if (!screen) break;
     try {
       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 } : {};
+      // Pass through context (e.g. selected session, typed prompt) to next screen
+      ctx = result?.session ? { session: result.session }
+          : result?.prompt  ? { prompt: result.prompt }
+          : {};
     } catch (e) {
       console.error(`Error: ${e.message}`);
       current = 'main';

package/package.json

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

package/src/session.mjs

@@ -461,23 +461,38 @@ export function importReplitSessions(cwd = process.cwd()) {
   const windowMs = windowHours * 60 * 60 * 1000;
   const cutoff = Date.now() - windowMs;
 
+  // Load existing session index for smartName lookup (best-effort, non-fatal)
+  let sessionIndex = {};
+  try {
+    const indexPath = join(cwd, '.dualbrain', 'session-index.json');
+    if (existsSync(indexPath)) {
+      sessionIndex = JSON.parse(readFileSync(indexPath, 'utf8'));
+    }
+  } catch { /* non-fatal */ }
+
   // Build session list
   for (const [id, sess] of bySession) {
     // Skip sessions outside the recency window (timestamps are in ms)
     if (sess.lastTimestamp < cutoff) continue;
-    // Derive display name
-    let name = sess.firstPrompt;
+
+    // Use smartName from index if available, otherwise fall back to first prompt
+    let name = sessionIndex[id]?.smartName || null;
+
     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)}`;
+      // Classic fallback: first meaningful prompt
+      name = sess.firstPrompt;
+      if (!name) {
+        const firstReal = sess.entries.find(e => e.display && e.display !== 'login');
+        name = firstReal?.display || `Session ${id.slice(0, 8)}`;
+      }
+      // Truncate long names that came from raw prompts
+      if (name.length > 60) name = name.slice(0, 57) + '...';
     }
-    // Truncate long names
-    if (name.length > 60) name = name.slice(0, 57) + '...';
 
     sessions.push({
       id: sess.sessionId,
       name,
+      smartName: sessionIndex[id]?.smartName || null,
       project: sess.project,
       promptCount: sess.entries.length,
       lastActive: new Date(sess.lastTimestamp).toISOString(),
@@ -741,6 +756,159 @@ export function syncSessionMirror(cwd = process.cwd()) {
   return { copied: totalCopied, grew: totalGrew };
 }
 
+// ─── Smart session naming ─────────────────────────────────────────────────────
+
+/**
+ * File pattern → human label mapping (checked in order, first match wins).
+ * Each entry: { pattern: RegExp, label: string, action?: string }
+ */
+const FILE_PATTERN_RULES = [
+  { pattern: /auth/i,      label: 'Auth',      action: 'Refactor' },
+  { pattern: /test|spec/i, label: 'Tests',     action: 'Fix' },
+  { pattern: /dispatch/i,  label: 'Dispatch',  action: 'Update' },
+  { pattern: /session/i,   label: 'Session',   action: 'Update' },
+  { pattern: /profile/i,   label: 'Profile',   action: 'Update' },
+  { pattern: /detect/i,    label: 'Detection', action: 'Update' },
+  { pattern: /decide/i,    label: 'Routing',   action: 'Update' },
+  { pattern: /budget/i,    label: 'Budget',    action: 'Update' },
+  { pattern: /hook/i,      label: 'Hooks',     action: 'Update' },
+  { pattern: /install/i,   label: 'Install',   action: 'Update' },
+  { pattern: /config/i,    label: 'Config',    action: 'Update' },
+  { pattern: /migrate/i,   label: 'Migration', action: 'Add' },
+];
+
+/**
+ * Topic words that suggest a dominant action verb.
+ */
+const TOPIC_ACTION_MAP = [
+  { words: ['fix', 'bug', 'error', 'crash', 'broken', 'fail'],  action: 'Fix' },
+  { words: ['refactor', 'cleanup', 'clean', 'reorganize'],       action: 'Refactor' },
+  { words: ['add', 'implement', 'create', 'build', 'write'],     action: 'Add' },
+  { words: ['update', 'upgrade', 'bump', 'patch'],               action: 'Update' },
+  { words: ['test', 'spec', 'coverage'],                         action: 'Fix' },
+  { words: ['deploy', 'release', 'publish'],                     action: 'Deploy' },
+  { words: ['audit', 'review', 'check'],                         action: 'Review' },
+];
+
+/**
+ * Convert a string to Title Case.
+ * @param {string} str
+ * @returns {string}
+ */
+function toTitleCase(str) {
+  return str.replace(/\b\w/g, c => c.toUpperCase());
+}
+
+/**
+ * Strip file extensions from a name candidate.
+ * @param {string} name
+ * @returns {string}
+ */
+function stripExtensions(name) {
+  return name.replace(/\.(mjs|js|ts|tsx|jsx|json|md|css|html|py|sh|sql|toml|yaml|yml)\b/gi, '');
+}
+
+/**
+ * Truncate a string to maxLen characters, preserving whole words where possible.
+ * @param {string} str
+ * @param {number} maxLen
+ * @returns {string}
+ */
+function truncate(str, maxLen = 40) {
+  if (str.length <= maxLen) return str;
+  const cut = str.slice(0, maxLen).replace(/\s+\S*$/, '');
+  return cut || str.slice(0, maxLen);
+}
+
+/**
+ * Generate a smart human-readable session name from session index data.
+ *
+ * Priority:
+ *   1. Dominant file pattern (e.g. auth*.mjs → "Refactor Auth Module")
+ *   2. Top topics (e.g. ['auth','token','refresh'] → "Auth Token Refresh")
+ *   3. Fallback: first prompt truncated to 40 chars
+ *
+ * Rules: ≤40 chars, Title Case, no file extensions, action-prefixed when detectable.
+ *
+ * @param {{ topics?: string[], files?: string[], prompts?: { first?: string } }} sessionData
+ * @returns {string}
+ */
+export function generateSmartName(sessionData) {
+  const topics = sessionData.topics || [];
+  const files  = sessionData.files  || [];
+  const firstPrompt = sessionData.prompts?.first || '';
+
+  // ── Step 1: Detect dominant action from topics ─────────────────────────────
+  let detectedAction = null;
+  for (const { words, action } of TOPIC_ACTION_MAP) {
+    if (topics.some(t => words.includes(t))) {
+      detectedAction = action;
+      break;
+    }
+  }
+
+  // ── Step 2: Try file pattern match ─────────────────────────────────────────
+  if (files.length > 0) {
+    // Flatten all filenames for pattern matching
+    const fileNames = files.map(f => f.split('/').pop()).join(' ');
+
+    for (const { pattern, label, action } of FILE_PATTERN_RULES) {
+      if (pattern.test(fileNames)) {
+        const actionWord = detectedAction || action || 'Update';
+        const candidate = `${actionWord} ${label}`;
+        return truncate(toTitleCase(candidate));
+      }
+    }
+
+    // No named pattern — derive a label from the most common directory or base name
+    const basenames = files.map(f => {
+      const base = f.split('/').pop() || f;
+      // Strip extension and convert camelCase/kebab to words
+      return stripExtensions(base)
+        .replace(/[-_]/g, ' ')
+        .replace(/([a-z])([A-Z])/g, '$1 $2')
+        .trim();
+    }).filter(Boolean);
+
+    if (basenames.length > 0) {
+      // Use the most common prefix or first significant basename
+      const label = basenames[0];
+      const actionWord = detectedAction || 'Update';
+      const candidate = `${actionWord} ${label}`;
+      return truncate(toTitleCase(stripExtensions(candidate)));
+    }
+  }
+
+  // ── Step 3: Try top topics ─────────────────────────────────────────────────
+  if (topics.length >= 2) {
+    // Take top 3 topics and compose a name
+    const topTopics = topics.slice(0, 3);
+    const actionWord = detectedAction || null;
+
+    let candidate;
+    if (actionWord) {
+      // Use action + remaining topics
+      candidate = [actionWord, ...topTopics.filter(t => t !== actionWord.toLowerCase())].slice(0, 3).join(' ');
+    } else {
+      candidate = topTopics.join(' ');
+    }
+
+    return truncate(toTitleCase(candidate));
+  }
+
+  if (topics.length === 1) {
+    const actionWord = detectedAction || 'Work on';
+    return truncate(toTitleCase(`${actionWord} ${topics[0]}`));
+  }
+
+  // ── Step 4: Fallback — first prompt truncated ──────────────────────────────
+  if (firstPrompt) {
+    return truncate(firstPrompt);
+  }
+
+  return 'Session';
+}
+
 // ─── Session index ────────────────────────────────────────────────────────────
 
 /**
@@ -841,7 +1009,7 @@ export function buildSessionIndex(cwd = process.cwd()) {
           .slice(0, 10)
           .map(([w]) => w);
 
-        index[sessionId] = {
+        const sessionEntry = {
           id: sessionId,
           topics,
           files: [...fileSet].slice(0, 20),
@@ -851,6 +1019,8 @@ export function buildSessionIndex(cwd = process.cwd()) {
           tool: 'claude',
           _fileSize: fileSize,
         };
+        sessionEntry.smartName = generateSmartName(sessionEntry);
+        index[sessionId] = sessionEntry;
       } catch { continue; }
     }
   }
@@ -904,12 +1074,14 @@ export function buildSessionIndex(cwd = process.cwd()) {
           } catch { continue; }
         }
 
-        index[id] = {
+        const codexEntry = {
           id, topics: [], files: [],
           prompts: { first: firstPrompt || '', last: lastPrompt || '' },
           date: lastTimestamp ? new Date(lastTimestamp * 1000).toISOString() : null,
           messageCount, tool: 'codex', _fileSize: fileSize,
         };
+        codexEntry.smartName = generateSmartName(codexEntry);
+        index[id] = codexEntry;
       } catch { continue; }
     }
   }