dual-brain 0.1.5 → 0.1.7

package/bin/dual-brain.mjs

@@ -29,7 +29,7 @@ import {
 import { dispatch, detectRuntime, dispatchDualBrain } from '../src/dispatch.mjs';
 
 import { loadRepoCache } from '../src/repo.mjs';
-import { loadSession, saveSession, formatSessionCard, importReplitSessions, renameSession, pinSession, unpinSession, categorizeSession, enrichSessions } from '../src/session.mjs';
+import { loadSession, saveSession, formatSessionCard, importReplitSessions, getSessionMeta, saveSessionMeta, renameSession, pinSession, unpinSession, categorizeSession, enrichSessions, archiveSession, getArchivedSessions } from '../src/session.mjs';
 
 import { box, bar, badge, menu, separator } from '../src/tui.mjs';
 
@@ -368,22 +368,24 @@ async function cmdGo(args) {
     vtrace(`Dual-brain: ${decision.dualBrain ? 'yes' : 'no'} (${isSoloBrain(profile) ? 'solo provider' : 'dual provider'}, ${detection.risk} risk)`);
   }
 
-  // Print routing table
-  console.log(`  provider   : ${decision.provider}`);
-  console.log(`  model      : ${decision.model}${decision.effort ? ' (' + decision.effort + ')' : ''}`);
-  console.log(`  tier       : ${decision.tier}`);
-  console.log(`  dual-brain : ${decision.dualBrain ? 'yes' : 'no'}`);
-  console.log(`  reason     : ${decision.explanation}`);
+  // Print routing table (only in dry-run or verbose; silent in normal mode)
+  if (dryRun || verbose) {
+    console.log(`  provider   : ${decision.provider}`);
+    console.log(`  model      : ${decision.model}${decision.effort ? ' (' + decision.effort + ')' : ''}`);
+    console.log(`  tier       : ${decision.tier}`);
+    console.log(`  dual-brain : ${decision.dualBrain ? 'yes' : 'no'}`);
+    console.log(`  reason     : ${decision.explanation}`);
+  }
 
   if (dryRun) {
     console.log('\n(dry-run — not executing)');
     return;
   }
 
-  console.log('\nDispatching...');
+  if (verbose) console.log('\nDispatching...');
   let result;
   if (decision.dualBrain) {
-    result = await dispatchDualBrain({ decision, prompt, files, cwd });
+    result = await dispatchDualBrain({ decision, prompt, files, cwd, verbose });
     console.log(`\nConsensus: ${result.consensus}`);
     if (result.claude?.summary) console.log(`Claude : ${result.claude.summary}`);
     if (result.openai?.summary) console.log(`OpenAI : ${result.openai.summary}`);
@@ -398,7 +400,7 @@ async function cmdGo(args) {
       nextAction:   null,
     }, cwd);
   } else {
-    result = await dispatch({ decision, prompt, files, cwd });
+    result = await dispatch({ decision, prompt, files, cwd, verbose });
     const statusLine = result.status === 'completed' ? 'Done' : `Failed (exit ${result.exitCode})`;
     console.log(`\n${statusLine} in ${(result.durationMs / 1000).toFixed(1)}s`);
     if (result.summary) console.log(result.summary);
@@ -1000,6 +1002,176 @@ function loadTerminalState(cwd, terminalId) {
 
 // ─── Dashboard box helpers ────────────────────────────────────────────────────
 
+/**
+ * Detect repo state for action cards. All checks run with tight timeouts —
+ * best-effort only, never blocks startup.
+ *
+ * Returns: { dirtyCount, lastCommitAgeDays, lastFailure, isGitRepo }
+ */
+function detectRepoState(cwd) {
+  const result = { dirtyCount: 0, lastCommitAgeDays: 0, lastFailure: null, isGitRepo: false };
+  try {
+    execSync('git rev-parse --git-dir', { cwd, encoding: 'utf8', timeout: 2000, stdio: 'pipe' });
+    result.isGitRepo = true;
+  } catch { return result; }
+
+  try {
+    const status = execSync('git status --porcelain', { cwd, encoding: 'utf8', timeout: 2000, stdio: 'pipe' });
+    result.dirtyCount = status.trim().split('\n').filter(Boolean).length;
+  } catch {}
+
+  try {
+    const logOut = execSync('git log --format="%ct" -1', { cwd, encoding: 'utf8', timeout: 2000, stdio: 'pipe' }).trim();
+    if (logOut) {
+      const commitTs = parseInt(logOut, 10) * 1000;
+      result.lastCommitAgeDays = Math.floor((Date.now() - commitTs) / 86400000);
+    }
+  } catch {}
+
+  try {
+    const sessionPath = join(cwd, '.dualbrain', 'session.json');
+    if (existsSync(sessionPath)) {
+      const sess = JSON.parse(readFileSync(sessionPath, 'utf8'));
+      const lastResult = sess?.lastResult;
+      if (lastResult?.status === 'failure') {
+        const summary = lastResult.task
+          ? String(lastResult.task).slice(0, 40)
+          : 'last task';
+        result.lastFailure = summary;
+      }
+    }
+  } catch {}
+
+  return result;
+}
+
+/**
+ * Build action card rows for the dashboard based on repo state.
+ * Returns an array of box row strings (may be empty).
+ */
+function buildActionRows(repoState, rowFn) {
+  if (!repoState.isGitRepo) return [];
+
+  const YELLOW = '\x1b[33m';
+  const RED    = '\x1b[31m';
+  const GREEN  = '\x1b[32m';
+  const DIM    = '\x1b[2m';
+  const RESET  = '\x1b[0m';
+
+  const cards = [];
+
+  if (repoState.dirtyCount > 0) {
+    cards.push(`${YELLOW}⚡${RESET} ${repoState.dirtyCount} uncommitted file${repoState.dirtyCount === 1 ? '' : 's'}`);
+  }
+
+  if (repoState.lastFailure !== null) {
+    cards.push(`${RED}⚡${RESET} Last task failed: ${repoState.lastFailure}`);
+  }
+
+  if (repoState.lastCommitAgeDays >= 3) {
+    cards.push(`${YELLOW}⚡${RESET} ${repoState.lastCommitAgeDays} day${repoState.lastCommitAgeDays === 1 ? '' : 's'} since last commit`);
+  }
+
+  if (cards.length === 0) {
+    return [rowFn(`${DIM}${GREEN}✓${RESET}${DIM} Repo clean${RESET}`)];
+  }
+
+  return cards.map(c => rowFn(c));
+}
+
+/**
+ * Detect interrupted work from the most recent session.
+ * Returns a continuation hint if confidence is high enough, or null to skip.
+ *
+ * Signals that indicate interrupted work:
+ *  - Session < 4 hours old with no clean exit
+ *  - Last result was a failure
+ *  - Uncommitted git changes exist
+ *  - Session has high message count (user was deep in work)
+ *
+ * Minimum thresholds: messageCount > 5 OR filesChanged > 0
+ *
+ * @param {Array} sessions   — from importReplitSessions / enrichSessions
+ * @param {string} cwd
+ * @returns {{ shouldContinue: boolean, reason: string, sessionId: string, sessionName: string, lastState: string|null, ageLabel: string }|null}
+ */
+function detectInterruptedWork(sessions, cwd) {
+  if (!sessions || sessions.length === 0) return null;
+
+  const most = sessions[0]; // already sorted most-recent first
+  if (!most || !most.lastActive) return null;
+
+  const ageMs = Date.now() - new Date(most.lastActive).getTime();
+  const fourH = 4 * 60 * 60 * 1000;
+
+  // Must be within 4 hours
+  if (ageMs >= fourH) return null;
+
+  // Load session.json for deeper signal
+  const session = loadSession(cwd);
+
+  // Minimum thresholds: must have real work depth
+  const msgCount     = most.messageCount ?? most.promptCount ?? 0;
+  const filesChanged = session?.filesChanged?.length ?? 0;
+  if (msgCount <= 5 && filesChanged === 0) return null;
+
+  const lastResultStatus = session?.lastResult?.status ?? null;
+
+  // Build confidence signals
+  const signals = [];
+  if (lastResultStatus === 'failure') signals.push('last run failed');
+  if (filesChanged > 0) signals.push(`${filesChanged} file${filesChanged !== 1 ? 's' : ''} changed`);
+  if (msgCount > 10) signals.push('deep session');
+
+  // Check for uncommitted git changes
+  try {
+    const gitResult = _spawnSyncTop('git', ['status', '--porcelain'], {
+      cwd,
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 3000,
+    });
+    if (gitResult.status === 0 && gitResult.stdout.trim().length > 0) {
+      signals.push('uncommitted changes');
+    }
+  } catch { /* non-fatal */ }
+
+  // Need at least one signal beyond base thresholds to avoid annoying low-signal cards
+  if (signals.length === 0 && msgCount <= 10) return null;
+
+  // Build a human-readable "last state" from available data
+  let lastState = null;
+  if (session?.lastResult?.summary) {
+    lastState = session.lastResult.summary;
+  } else if (session?.objective) {
+    lastState = session.objective;
+  } else if (most.name && !/^Session [0-9a-f]{8}/i.test(most.name)) {
+    lastState = most.name;
+  }
+
+  // Trim lastState to fit on one line
+  if (lastState && lastState.length > 45) lastState = lastState.slice(0, 42) + '...';
+
+  // Build reason label
+  const reason = signals.length > 0 ? signals.join(', ') : `${msgCount} messages`;
+
+  // Age label
+  const mins = Math.floor(ageMs / 60000);
+  let ageLabel;
+  if (mins < 1)       ageLabel = 'just now';
+  else if (mins < 60) ageLabel = `${mins}m ago`;
+  else                ageLabel = `${Math.floor(mins / 60)}h ago`;
+
+  return {
+    shouldContinue: true,
+    reason,
+    sessionId:   most.id,
+    sessionName: most.name || most.id.slice(0, 8),
+    lastState,
+    ageLabel,
+  };
+}
+
 /**
  * Build a provider status string for the dashboard status line.
  * Returns a string like: "🟢 Claude $100×2 $20×1  🟢 OpenAI $100"
@@ -1094,12 +1266,20 @@ async function mainScreen(rl, ask) {
   } catch {}
 
   // Gather recent sessions
-  const recentSessions = enrichSessions(importReplitSessions(cwd), cwd).slice(0, 3);
+  const allSessions    = enrichSessions(importReplitSessions(cwd), cwd);
+  const recentSessions = allSessions.slice(0, 3);
+  const staleCount     = allSessions.filter(s => {
+    const ageMs = s.lastActive ? Date.now() - new Date(s.lastActive).getTime() : 0;
+    return ageMs >= 7 * 86400000;
+  }).length;
 
   // Detect data-tools version
   const rtMain    = detectReplitTools(cwd);
   const dtVersion = (rtMain.installed && rtMain.version) ? rtMain.version : null;
 
+  // ── Interrupted work detection ────────────────────────────────────────────
+  const interrupted = detectInterruptedWork(allSessions, cwd);
+
   // ── Box layout ────────────────────────────────────────────────────────────
   const termW = process.stdout.columns || 60;
   const boxW  = Math.min(termW - 2, 60); // outer width (including │ │)
@@ -1130,6 +1310,84 @@ async function mainScreen(rl, ask) {
     }
   }
 
+  // ── Continuation card (interrupted work) ─────────────────────────────────
+  if (interrupted) {
+    const ctop = `┌${'─'.repeat(boxW - 2)}┐`;
+    const csep = `├${'─'.repeat(boxW - 2)}┤`;
+    const cbot = `└${'─'.repeat(boxW - 2)}┘`;
+    const crow = (content) => makeBoxRow(content, W);
+
+    const titleLine = `\x1b[33m💡\x1b[0m Continue: ${interrupted.sessionName}`;
+    const lastLine  = interrupted.lastState
+      ? `   Last: ${interrupted.lastState} · ${interrupted.ageLabel}`
+      : `   ${interrupted.reason} · ${interrupted.ageLabel}`;
+    const actLine   = '   [Enter] Resume  [n] New session  [s] Skip';
+
+    process.stdout.write([ctop, crow(titleLine), csep, crow(lastLine), crow(actLine), cbot].join('\n') + '\n\n');
+
+    // Wait for a keypress to decide what to do with the card
+    const readline2 = await import('node:readline');
+    readline2.emitKeypressEvents(process.stdin, rl);
+
+    const cardChoice = await new Promise((resolve) => {
+      const wasRaw2 = process.stdin.isRaw;
+      const canRaw2 = process.stdin.isTTY && typeof process.stdin.setRawMode === 'function';
+      if (canRaw2) process.stdin.setRawMode(true);
+
+      const cleanup2 = () => {
+        process.stdin.removeListener('keypress', onCardKey);
+        if (canRaw2) {
+          try { process.stdin.setRawMode(wasRaw2 || false); } catch {}
+        }
+      };
+
+      const onCardKey = (str, key) => {
+        if (!key) return;
+        const name = key.name || '';
+        const seq  = key.sequence || str || '';
+
+        if (key.ctrl && (name === 'c' || name === 'd')) {
+          cleanup2();
+          process.stdout.write('\n');
+          resolve('q');
+          return;
+        }
+
+        if (name === 'return' || name === 'enter' || seq === '\r' || seq === '\n') {
+          cleanup2();
+          process.stdout.write('\n');
+          resolve('resume');
+          return;
+        }
+
+        if (!str || str.length === 0) return;
+        const lower = str.toLowerCase();
+        if (lower === 'n' || lower === 's' || lower === 'q') {
+          cleanup2();
+          process.stdout.write('\n');
+          resolve(lower);
+          return;
+        }
+      };
+
+      process.stdin.on('keypress', onCardKey);
+    });
+
+    if (cardChoice === 'q') return { next: 'exit' };
+
+    if (cardChoice === 'resume') {
+      const { spawnSync } = await import('node:child_process');
+      process.stdout.write(`  Launching: claude --resume ${interrupted.sessionId}\n\n`);
+      spawnSync('claude', ['--resume', interrupted.sessionId], { stdio: 'inherit' });
+      saveTerminalState(cwd, getTerminalId(), interrupted.sessionId, 'claude');
+      return { next: 'main' };
+    }
+
+    if (cardChoice === 'n') return { next: 'new-session' };
+
+    // 's' → fall through to normal dashboard
+  }
+
   // ── Status section ────────────────────────────────────────────────────────
   const providerLine = buildProviderStatusLine(profile, auth);
 
@@ -1138,6 +1396,10 @@ async function mainScreen(rl, ask) {
     statusRows.push(row(`\x1b[2m📦 data-tools v${dtVersion}\x1b[0m`));
   }
 
+  // ── Action cards (git state) ──────────────────────────────────────────────
+  const repoState  = detectRepoState(cwd);
+  const actionRows = buildActionRows(repoState, row);
+
   // ── Sessions section ──────────────────────────────────────────────────────
   const sessionRows = [];
   if (recentSessions.length === 0) {
@@ -1152,33 +1414,64 @@ async function mainScreen(rl, ask) {
           ? sess.project.replace(/^-/, '/').replace(/-/g, '/')
           : sess.id.slice(0, 8);
       }
-      // Layout: "{num}  {name...}  {age}"
+
+      // Build badges (ANSI color; track visible width separately)
+      const badges = [];
+      const badgeVisible = [];
+      if (sess.isActive) {
+        badges.push('\x1b[32m[active]\x1b[0m');
+        badgeVisible.push('[active]'.length);
+      }
+      if (sess.source === 'replit-tools' || sess.source === 'data-tools') {
+        badges.push('\x1b[36m[dt]\x1b[0m');
+        badgeVisible.push('[dt]'.length);
+      }
+      const ageMs = sess.lastActive ? Date.now() - new Date(sess.lastActive).getTime() : 0;
+      if (ageMs > 7 * 24 * 3600 * 1000) {
+        badges.push('\x1b[2m[stale]\x1b[0m');
+        badgeVisible.push('[stale]'.length);
+      }
+      const msgCount    = sess.messageCount ?? sess.promptCount ?? 0;
+      const msgBadge    = `\x1b[2m(${msgCount})\x1b[0m`;
+      const msgBadgeW   = `(${msgCount})`.length;
+
+      const badgeStr = badges.join('');
+      const badgesW  = badgeVisible.reduce((s, n) => s + n, 0);
+
+      // Layout: "{num}  {name...}{badges}  {age}  {msg}"
       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) + '...'
+      // Available for name: W minus fixed chrome, badge widths, and msg badge
+      const nameMax = W - numStr.length - 2 - badgesW - 2 - ageStr.length - 2 - msgBadgeW;
+      const truncName = rawName.length > nameMax
+        ? rawName.slice(0, Math.max(0, nameMax - 3)) + '...'
         : rawName.padEnd(nameMax);
-      const content = `${numStr}  ${name}  ${ageStr}`;
+      const content = `${numStr}  ${truncName}${badgeStr}  ${ageStr}  ${msgBadge}`;
       sessionRows.push(row(content));
     });
   }
 
   // ── Actions bar ───────────────────────────────────────────────────────────
-  const actionsContent = '↵ Resume  n New  / Search  s Settings  q Quit';
+  const actionsContent = '↵ Resume  n New  / Search  i Import  s Settings  q Quit';
   const actionsRow     = row(actionsContent);
 
   // ── Print the full box ────────────────────────────────────────────────────
+  // Include action cards between status and sessions (with separators only when non-empty)
   const lines = [
     top,
     ...statusRows,
+    ...(actionRows.length > 0 ? [sep, ...actionRows] : []),
     sep,
     ...sessionRows,
     sep,
     actionsRow,
     bot,
   ];
+  // ── Stale session hint ──────────────────────────────────────────────────
+  if (staleCount >= 3) {
+    process.stdout.write(`\x1b[2m${staleCount} stale sessions (>7d) — press s → archive to clean up\x1b[0m\n`);
+  }
+
   process.stdout.write(lines.join('\n') + '\n');
   process.stdout.write(`\x1b[2mPowered by data-tools · Steve Moraco\x1b[0m\n\n`);
 
@@ -1267,7 +1560,7 @@ async function mainScreen(rl, ask) {
       // 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 === '/') {
+        if (lower === 'n' || lower === 's' || lower === 'q' || lower === '/' || lower === 'i') {
           cleanup();
           process.stdout.write('\n');
           resolve(lower);
@@ -1372,6 +1665,7 @@ async function mainScreen(rl, ask) {
   }
 
   if (choice === 's') { return { next: 'settings' }; }
+  if (choice === 'i') { return { next: 'import-picker' }; }
   if (choice === 'q' || choice === 'exit') { return { next: 'exit' }; }
 
   return { next: 'main' };
@@ -1408,6 +1702,236 @@ async function newSessionScreen(rl, ask) {
   return { next: 'main' };
 }
 
+// ─── Screen: importPickerScreen ──────────────────────────────────────────────
+
+async function importPickerScreen() {
+  const cwd = process.cwd();
+
+  // Load all available sessions from data-tools
+  const allSessions = importReplitSessions(cwd);
+
+  // Load existing session meta to filter already-imported ones
+  const meta = getSessionMeta(cwd);
+  const alreadyImported = new Set(
+    Object.entries(meta)
+      .filter(([, v]) => v.source === 'data-tools')
+      .map(([id]) => id)
+  );
+
+  // Filter out already-imported sessions
+  const candidates = allSessions.filter(s => !alreadyImported.has(s.id));
+
+  // ── Box layout ────────────────────────────────────────────────────────────
+  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);
+
+  // Helper: wait for any keypress (used in edge-case screens)
+  const waitKey = async () => {
+    const rl2 = await import('node:readline');
+    rl2.emitKeypressEvents(process.stdin);
+    await new Promise(resolve => {
+      const wasRaw2 = process.stdin.isRaw;
+      const canRaw2 = process.stdin.isTTY && typeof process.stdin.setRawMode === 'function';
+      if (canRaw2) process.stdin.setRawMode(true);
+      const onKey2 = () => {
+        process.stdin.removeListener('keypress', onKey2);
+        if (canRaw2) { try { process.stdin.setRawMode(wasRaw2 || false); } catch {} }
+        resolve();
+      };
+      process.stdin.once('keypress', onKey2);
+    });
+  };
+
+  // Handle edge cases
+  if (allSessions.length === 0) {
+    process.stdout.write('\n');
+    process.stdout.write(top + '\n');
+    process.stdout.write(row('Import from data-tools') + '\n');
+    process.stdout.write(sep + '\n');
+    process.stdout.write(row('No data-tools sessions found.') + '\n');
+    process.stdout.write(row('Install replit-tools: npm i -g replit-tools') + '\n');
+    process.stdout.write(sep + '\n');
+    process.stdout.write(row('Press any key to go back...') + '\n');
+    process.stdout.write(bot + '\n\n');
+    await waitKey();
+    return { next: 'main' };
+  }
+
+  if (candidates.length === 0) {
+    process.stdout.write('\n');
+    process.stdout.write(top + '\n');
+    process.stdout.write(row('Import from data-tools') + '\n');
+    process.stdout.write(sep + '\n');
+    process.stdout.write(row(`All ${allSessions.length} sessions already imported.`) + '\n');
+    process.stdout.write(sep + '\n');
+    process.stdout.write(row('Press any key to go back...') + '\n');
+    process.stdout.write(bot + '\n\n');
+    await waitKey();
+    return { next: 'main' };
+  }
+
+  // Pre-select sessions < 3 days old
+  const threeDaysMs = 3 * 24 * 60 * 60 * 1000;
+  const selected = new Set(
+    candidates
+      .filter(s => s.lastActive && (Date.now() - new Date(s.lastActive).getTime()) < threeDaysMs)
+      .map(s => s.id)
+  );
+
+  let cursor = 0;
+
+  const renderPicker = () => {
+    process.stdout.write('\x1b[2J\x1b[H'); // clear screen
+
+    const headerTitle = 'Import from data-tools';
+    const footerLine  = '↑↓ Navigate  Space Toggle  Enter Import  q Back';
+
+    process.stdout.write('\n');
+    process.stdout.write(top + '\n');
+    process.stdout.write(row(headerTitle) + '\n');
+    process.stdout.write(sep + '\n');
+
+    candidates.forEach((sess, i) => {
+      const isCursor   = i === cursor;
+      const isSelected = selected.has(sess.id);
+      const check      = isSelected ? '☑' : '☐';
+      const cursor_ch  = isCursor   ? '▸ ' : '  ';
+
+      // Format age compactly
+      const ageStr = sess.age || '';
+      // Message count
+      const msgCount = sess.promptCount ?? sess.messageCount ?? 0;
+      const msgStr   = `${msgCount} msgs`;
+
+      // Name: truncate to fit
+      // Layout: "cursor_ch(2) check(1) space(1) name  age  msgs"
+      // chrome = 2 + 1 + 1 + 2 + ageStr.length + 2 + msgStr.length = 8 + ageStr.length + msgStr.length
+      const chrome  = 2 + 1 + 1 + 2 + ageStr.length + 2 + msgStr.length;
+      const nameMax = Math.max(0, W - chrome);
+      let name = sess.name || sess.id.slice(0, 8);
+      if (name.length > nameMax) name = name.slice(0, nameMax - 3) + '...';
+      else name = name.padEnd(nameMax);
+
+      const line = `${cursor_ch}${check} ${name}  ${ageStr}  ${msgStr}`;
+      // Highlight cursor row with dim inverse
+      const renderedLine = isCursor
+        ? `\x1b[7m${cursor_ch}${check} ${name}  ${ageStr}  ${msgStr}\x1b[0m`
+        : line;
+      process.stdout.write(row(renderedLine) + '\n');
+    });
+
+    process.stdout.write(sep + '\n');
+    process.stdout.write(row(footerLine) + '\n');
+    process.stdout.write(bot + '\n\n');
+  };
+
+  // Run the interactive picker
+  const readline = await import('node:readline');
+  readline.emitKeypressEvents(process.stdin);
+
+  const result = await new Promise((resolve) => {
+    const wasRaw = process.stdin.isRaw;
+    const canRaw = process.stdin.isTTY && typeof process.stdin.setRawMode === 'function';
+    if (canRaw) process.stdin.setRawMode(true);
+
+    const cleanup = () => {
+      process.stdin.removeListener('keypress', onKey);
+      if (canRaw) {
+        try { process.stdin.setRawMode(wasRaw || false); } catch {}
+      }
+    };
+
+    renderPicker();
+
+    const onKey = (str, key) => {
+      if (!key) return;
+      const name = key.name || '';
+      const seq  = key.sequence || str || '';
+
+      // Ctrl-C / Ctrl-D → exit to main
+      if (key.ctrl && (name === 'c' || name === 'd')) {
+        cleanup();
+        process.stdout.write('\n');
+        resolve({ action: 'back' });
+        return;
+      }
+
+      // q or Escape → back
+      if (name === 'escape' || (str && str.toLowerCase() === 'q')) {
+        cleanup();
+        process.stdout.write('\n');
+        resolve({ action: 'back' });
+        return;
+      }
+
+      // Arrow up
+      if (name === 'up') {
+        cursor = Math.max(0, cursor - 1);
+        renderPicker();
+        return;
+      }
+
+      // Arrow down
+      if (name === 'down') {
+        cursor = Math.min(candidates.length - 1, cursor + 1);
+        renderPicker();
+        return;
+      }
+
+      // Space → toggle selection
+      if (seq === ' ') {
+        const id = candidates[cursor].id;
+        if (selected.has(id)) selected.delete(id);
+        else selected.add(id);
+        renderPicker();
+        return;
+      }
+
+      // Enter → import
+      if (name === 'return' || name === 'enter' || seq === '\r' || seq === '\n') {
+        cleanup();
+        process.stdout.write('\n');
+        resolve({ action: 'import', ids: [...selected] });
+        return;
+      }
+    };
+
+    process.stdin.on('keypress', onKey);
+  });
+
+  if (result.action === 'back' || result.ids.length === 0) {
+    return { next: 'main' };
+  }
+
+  // Persist imported sessions to sessions.json
+  const updatedMeta = getSessionMeta(cwd);
+  const now = new Date().toISOString();
+  let importCount = 0;
+  for (const id of result.ids) {
+    const sess = candidates.find(s => s.id === id);
+    if (!sess) continue;
+    updatedMeta[id] = {
+      ...updatedMeta[id],
+      source:     'data-tools',
+      importedAt: now,
+      createdAt:  updatedMeta[id]?.createdAt ?? now,
+    };
+    importCount++;
+  }
+  saveSessionMeta(updatedMeta, cwd);
+
+  process.stdout.write(`✓ Imported ${importCount} session${importCount !== 1 ? 's' : ''} from data-tools\n\n`);
+
+  return { next: 'main' };
+}
+
 // ─── Screen: settingsScreen ───────────────────────────────────────────────────
 
 async function settingsScreen(rl, ask) {
@@ -1447,15 +1971,7 @@ async function settingsScreen(rl, ask) {
   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' };
+    return { next: 'import-picker' };
   }
 
   if (choice === 'd') {
@@ -2439,45 +2955,216 @@ async function sessionDetailScreen(rl, ask, ctx = {}) {
 // ─── Screen: sessionsScreen ───────────────────────────────────────────────────
 
 const CATEGORIES = ['security', 'ui', 'refactor', 'bugfix', 'testing', 'devops', 'planning'];
+const STALE_DAYS = 7;
 
+/**
+ * Return a compact status badge string for a session row (plain text, no ANSI).
+ */
+function sessionBadge(sess) {
+  if (sess.isActive) return '[active]';
+  const ageMs = sess.lastActive ? Date.now() - new Date(sess.lastActive).getTime() : 0;
+  if (ageMs >= STALE_DAYS * 86400000) return '[stale]';
+  if (sess.tool === 'codex') return '[dt]';
+  return '';
+}
+
+/**
+ * Interactive full session list with arrow-key navigation.
+ * Enter = resume, x = archive, r = rename, q/Esc = back to dashboard.
+ */
 async function sessionsScreen(rl, ask) {
   const cwd = process.cwd();
-  const sessions = enrichSessions(importReplitSessions(cwd), cwd).slice(0, 9);
 
-  console.log('');
-  console.log(separator('Session Manager'));
-  console.log('');
+  // Load all active sessions (no slice limit)
+  let sessions = enrichSessions(importReplitSessions(cwd), cwd);
+
+  // ── Box geometry ────────────────────────────────────────────────────────────
+  const termW = process.stdout.columns || 60;
+  const boxW  = Math.min(termW - 2, 52);
+  const W     = boxW - 4;
+
+  const top = `┌${'─'.repeat(boxW - 2)}┐`;
+  const sep = `├${'─'.repeat(boxW - 2)}┤`;
+  const bot = `└${'─'.repeat(boxW - 2)}┘`;
 
   if (sessions.length === 0) {
-    console.log('  No sessions found.\n');
-    console.log('  [b] Back\n');
-    const choice = (await ask('  Choice: ')).trim().toLowerCase();
-    if (choice === 'b' || choice === 'back') return { next: 'main' };
-    return { next: 'sessions' };
+    process.stdout.write('\n' + top + '\n');
+    process.stdout.write(makeBoxRow('Sessions', W) + '\n');
+    process.stdout.write(sep + '\n');
+    process.stdout.write(makeBoxRow('No sessions found.', W) + '\n');
+    process.stdout.write(sep + '\n');
+    process.stdout.write(makeBoxRow('q Back', W) + '\n');
+    process.stdout.write(bot + '\n\n');
+    await ask('  Press Enter to continue...');
+    return { next: 'main' };
   }
 
-  sessions.forEach((sess, i) => {
-    const pin    = sess.pinned ? '📌 ' : '   ';
-    const active = sess.isActive ? ' ●' : '';
-    const cat    = sess.category ? `  [${sess.category}]` : '';
-    console.log(`  [${i + 1}] ${pin}${sess.age.padEnd(6)}  ${sess.name}${active}${cat}`);
-  });
+  /**
+   * Format one session row.
+   * Right side: badge(9) + age(4) + space + count(4) = 18 chars total.
+   */
+  function formatRow(sess, selected) {
+    const arrow    = selected ? '▸ ' : '  ';
+    const badge    = sessionBadge(sess);
+    const badgeStr = badge ? badge.padEnd(9) : '         ';
+    const age      = (sess.age || '').replace(/ ago$/, '').padStart(4);
+    const count    = `(${sess.promptCount ?? 0})`.padStart(4);
+    const right    = `${badgeStr}${age} ${count}`;
+    const nameMax  = W - 2 - right.length;
+    let name       = sess.name || sess.id.slice(0, 8);
+    if (name.length > nameMax) name = name.slice(0, nameMax - 3) + '...';
+    else name = name.padEnd(nameMax);
+    return makeBoxRow(`${arrow}${name}${right}`, W);
+  }
+
+  let cursor = 0;
+
+  function render() {
+    process.stdout.write('\x1b[2J\x1b[H');
+    process.stdout.write(top + '\n');
+    process.stdout.write(makeBoxRow('Sessions', W) + '\n');
+    process.stdout.write(sep + '\n');
+    for (let i = 0; i < sessions.length; i++) {
+      process.stdout.write(formatRow(sessions[i], i === cursor) + '\n');
+    }
+    process.stdout.write(sep + '\n');
+    process.stdout.write(makeBoxRow('↑↓ Navigate  Enter Resume  x Archive  r Rename', W) + '\n');
+    process.stdout.write(makeBoxRow('q Back', W) + '\n');
+    process.stdout.write(bot + '\n');
+  }
 
-  console.log('');
-  console.log('  [1-9] Select a session to manage');
-  console.log('  [b] Back');
-  console.log('');
+  render();
 
-  const choice = (await ask('  Choice: ')).trim().toLowerCase();
+  const readline = await import('node:readline');
+  readline.emitKeypressEvents(process.stdin, rl);
 
-  if (choice === 'b' || choice === 'back') return { next: 'main' };
+  const result = await new Promise((resolve) => {
+    const wasRaw = process.stdin.isRaw;
+    const canRaw = process.stdin.isTTY && typeof process.stdin.setRawMode === 'function';
+    if (canRaw) process.stdin.setRawMode(true);
 
-  const numChoice = parseInt(choice, 10);
-  if (!isNaN(numChoice) && numChoice >= 1 && numChoice <= sessions.length) {
-    return { next: 'session-manage', session: sessions[numChoice - 1] };
-  }
+    const cleanup = () => {
+      process.stdin.removeListener('keypress', onKey);
+      if (canRaw) {
+        try { process.stdin.setRawMode(wasRaw || false); } catch {}
+      }
+    };
+
+    const onKey = async (str, key) => {
+      if (!key) return;
+      const kname = key.name || '';
+
+      // Ctrl-C / Ctrl-D → exit
+      if (key.ctrl && (kname === 'c' || kname === 'd')) {
+        cleanup();
+        process.stdout.write('\n');
+        resolve({ next: 'main' });
+        return;
+      }
 
-  return { next: 'sessions' };
+      // q / Escape → back
+      if (kname === 'q' || kname === 'escape' || str === 'q') {
+        cleanup();
+        process.stdout.write('\n');
+        resolve({ next: 'main' });
+        return;
+      }
+
+      // Arrow up
+      if (kname === 'up') {
+        cursor = Math.max(0, cursor - 1);
+        render();
+        return;
+      }
+
+      // Arrow down
+      if (kname === 'down') {
+        cursor = Math.min(sessions.length - 1, cursor + 1);
+        render();
+        return;
+      }
+
+      // Enter → resume highlighted session
+      if (kname === 'return' || kname === 'enter') {
+        const sess = sessions[cursor];
+        cleanup();
+        process.stdout.write('\n');
+        process.stdout.write(`\n  Launching: claude --resume ${sess.id}\n\n`);
+        const { spawnSync } = await import('node:child_process');
+        spawnSync('claude', ['--resume', sess.id], { stdio: 'inherit' });
+        saveTerminalState(cwd, getTerminalId(), sess.id, sess.tool || 'claude');
+        resolve({ next: 'main' });
+        return;
+      }
+
+      // x → archive highlighted session (non-destructive)
+      if (str === 'x' || str === 'X') {
+        const sess = sessions[cursor];
+        archiveSession(sess.id, cwd);
+        sessions = sessions.filter(s => s.id !== sess.id);
+        if (sessions.length === 0) {
+          cleanup();
+          process.stdout.write('\n');
+          resolve({ next: 'main' });
+          return;
+        }
+        cursor = Math.min(cursor, sessions.length - 1);
+        render();
+        return;
+      }
+
+      // r → rename highlighted session
+      if (str === 'r' || str === 'R') {
+        const sess = sessions[cursor];
+        cleanup();
+
+        // Briefly collect a line of text
+        process.stdout.write('\n  New name: ');
+        const newName = await new Promise(res2 => {
+          let buf = '';
+          const onData = (chunk) => {
+            const s = chunk.toString();
+            for (const ch of s) {
+              if (ch === '\n' || ch === '\r') {
+                process.stdin.removeListener('data', onData);
+                process.stdout.write('\n');
+                res2(buf.trim());
+                return;
+              }
+              if (ch === '\x7f' || ch === '\b') {
+                if (buf.length > 0) {
+                  buf = buf.slice(0, -1);
+                  process.stdout.write('\b \b');
+                }
+              } else {
+                buf += ch;
+                process.stdout.write(ch);
+              }
+            }
+          };
+          process.stdin.on('data', onData);
+        });
+
+        if (newName) {
+          renameSession(sess.id, newName, cwd);
+          sessions[cursor] = { ...sess, name: newName };
+        }
+
+        // Re-enable raw mode and re-attach listener
+        if (canRaw) {
+          try { process.stdin.setRawMode(true); } catch {}
+        }
+        readline.emitKeypressEvents(process.stdin, rl);
+        process.stdin.on('keypress', onKey);
+        render();
+        return;
+      }
+    };
+
+    process.stdin.on('keypress', onKey);
+  });
+
+  return result;
 }
 
 async function sessionManageScreen(rl, ask, ctx = {}) {
@@ -2568,6 +3255,7 @@ const SCREENS = {
   main:             mainScreen,
   'new-session':    newSessionScreen,
   settings:         settingsScreen,
+  'import-picker':  importPickerScreen,
   subscriptions:    subscriptionsScreen,
   dashboard:        dashboardScreen,
   auth:             authScreen,
@@ -2724,22 +3412,25 @@ async function cmdSpecialistGo(specialist, args) {
     vtrace(`Dual-brain: ${decision.dualBrain ? 'yes' : 'no'}`);
   }
 
-  console.log(`  specialist : ${specialist}`);
-  console.log(`  provider   : ${decision.provider}`);
-  console.log(`  model      : ${decision.model}${decision.effort ? ' (' + decision.effort + ')' : ''}`);
-  console.log(`  tier       : ${decision.tier}`);
-  console.log(`  dual-brain : ${decision.dualBrain ? 'yes' : 'no'}`);
-  console.log(`  reason     : ${decision.explanation}`);
+  // Print routing table (only in dry-run or verbose; silent in normal mode)
+  if (dryRun || verbose) {
+    console.log(`  specialist : ${specialist}`);
+    console.log(`  provider   : ${decision.provider}`);
+    console.log(`  model      : ${decision.model}${decision.effort ? ' (' + decision.effort + ')' : ''}`);
+    console.log(`  tier       : ${decision.tier}`);
+    console.log(`  dual-brain : ${decision.dualBrain ? 'yes' : 'no'}`);
+    console.log(`  reason     : ${decision.explanation}`);
+  }
 
   if (dryRun) {
     console.log('\n(dry-run — not executing)');
     return;
   }
 
-  console.log('\nDispatching...');
+  if (verbose) console.log('\nDispatching...');
   let result;
   if (decision.dualBrain) {
-    result = await dispatchDualBrain({ decision, prompt, files, cwd });
+    result = await dispatchDualBrain({ decision, prompt, files, cwd, verbose });
     console.log(`\nConsensus: ${result.consensus}`);
     if (result.claude?.summary) console.log(`Claude : ${result.claude.summary}`);
     if (result.openai?.summary) console.log(`OpenAI : ${result.openai.summary}`);
@@ -2753,7 +3444,7 @@ async function cmdSpecialistGo(specialist, args) {
       nextAction:   null,
     }, cwd);
   } else {
-    result = await dispatch({ decision, prompt, files, cwd });
+    result = await dispatch({ decision, prompt, files, cwd, verbose });
     const statusLine = result.status === 'completed' ? 'Done' : `Failed (exit ${result.exitCode})`;
     console.log(`\n${statusLine} in ${(result.durationMs / 1000).toFixed(1)}s`);
     if (result.summary) console.log(result.summary);
@@ -2813,13 +3504,26 @@ async function main() {
         await runScreens('main');
       }
     } else {
-      // Non-TTY: print status card and exit
-      const cwd = process.cwd();
-      const repo    = loadRepoCache(cwd);
-      const session = loadSession(cwd);
-      const health  = getHealth(cwd);
-      const card    = formatSessionCard(session, repo, health);
-      console.log(card);
+      // Non-TTY with no args: read stdin as a task and run one-shot
+      const stdinTask = await new Promise((resolve) => {
+        let data = '';
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', chunk => { data += chunk; });
+        process.stdin.on('end', () => resolve(data.trim()));
+        // If stdin has no data within 200ms (not truly piped), fall back to status card
+        setTimeout(() => resolve(null), 200);
+      });
+      if (stdinTask) {
+        process.stderr.write('🧠 routing...\n');
+        await cmdGo([stdinTask]);
+      } else {
+        const cwd = process.cwd();
+        const repo    = loadRepoCache(cwd);
+        const session = loadSession(cwd);
+        const health  = getHealth(cwd);
+        const card    = formatSessionCard(session, repo, health);
+        console.log(card);
+      }
     }
     return;
   }
@@ -2912,6 +3616,43 @@ fi
     return;
   }
 
+  // ─── One-shot mode ────────────────────────────────────────────────────────────
+  // If cmd is not a recognized subcommand, treat the entire arg list as a task.
+  // e.g. `dual-brain fix failing tests` → same as `dual-brain go "fix failing tests"`
+  const KNOWN_COMMANDS = new Set([
+    'init', 'install', 'auth', 'go', 'status', 'hot', 'cool',
+    'remember', 'forget', 'break-glass', 'specialists', 'search', 'shell-hook',
+    '--help', '-h', '--version', '-v',
+    ...Object.keys(loadSpecialistRegistry()),
+  ]);
+
+  if (!KNOWN_COMMANDS.has(cmd)) {
+    // All of args are part of the task description (plus any flags like --dry-run/--files).
+    // Join non-flag words into a single prompt string so cmdGo's args.find() picks it up.
+    // We strip out flag values (e.g. the value after --files) before collecting prompt words.
+    process.stderr.write('🧠 routing...\n');
+    const flagValuesToSkip = new Set();
+    const pairedFlags = ['--files'];
+    for (const f of pairedFlags) {
+      const idx = args.indexOf(f);
+      if (idx !== -1 && args[idx + 1] && !args[idx + 1].startsWith('--')) {
+        flagValuesToSkip.add(args[idx + 1]);
+      }
+    }
+    const passedFlags = [];
+    for (let i = 0; i < args.length; i++) {
+      if (args[i].startsWith('--') || args[i].startsWith('-')) {
+        passedFlags.push(args[i]);
+        if (pairedFlags.includes(args[i]) && args[i + 1] && !args[i + 1].startsWith('--')) {
+          passedFlags.push(args[++i]);
+        }
+      }
+    }
+    const promptWords = args.filter(a => !a.startsWith('--') && !a.startsWith('-') && !flagValuesToSkip.has(a));
+    await cmdGo([promptWords.join(' '), ...passedFlags]);
+    return;
+  }
+
   process.stderr.write(`Unknown command: ${cmd}\nRun "dual-brain --help" for usage.\n`);
   process.exit(1);
 }