dual-brain 7.1.12 → 7.1.14

package/bin/dual-brain.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 // dual-brain — CLI entry point. Commands: init, go, status, remember, forget
 
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readFileSync, mkdirSync, writeFileSync, statSync, readdirSync, unlinkSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { execSync, spawnSync as _spawnSyncTop } from 'node:child_process';
@@ -41,10 +41,94 @@ const PKG_PATH  = join(__dirname, '..', 'package.json');
 function readVersion() {
   try { return JSON.parse(readFileSync(PKG_PATH, 'utf8')).version; } catch { return '0.0.0'; }
 }
+async function checkForUpdates(currentVersion) {
+  try {
+    const { execSync } = await import('node:child_process');
+    const latest = execSync('npm view dual-brain version 2>/dev/null', {
+      encoding: 'utf8',
+      timeout: 3000
+    }).trim();
+    if (latest && latest !== currentVersion) {
+      return latest;
+    }
+  } catch {}
+  return null;
+}
 function flag(args, name) { const i = args.indexOf(name); return i !== -1 ? (args[i + 1] ?? true) : null; }
 function err(msg) { process.stderr.write(`Error: ${msg}\n`); process.exit(1); }
 function vtrace(msg) { process.stderr.write(`[verbose] ${msg}\n`); }
 
+// ─── Loop-prevention markers ──────────────────────────────────────────────────
+
+function checkLoopMarker(cwd) {
+  const markerPath = join(cwd, '.dualbrain', `.prompt-shown-${process.pid}`);
+  if (existsSync(markerPath)) {
+    try {
+      const age = Date.now() - statSync(markerPath).mtimeMs;
+      if (age < 3600000) return true; // Not stale, skip prompt
+    } catch {}
+  }
+  return false;
+}
+
+function setLoopMarker(cwd) {
+  const dir = join(cwd, '.dualbrain');
+  try {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, `.prompt-shown-${process.pid}`), String(Date.now()));
+  } catch {}
+}
+
+function cleanStaleMarkers(cwd) {
+  const dir = join(cwd, '.dualbrain');
+  try {
+    for (const f of readdirSync(dir)) {
+      if (!f.startsWith('.prompt-shown-')) continue;
+      const pid = f.replace('.prompt-shown-', '');
+      try {
+        process.kill(parseInt(pid, 10), 0);
+      } catch {
+        // Process dead, remove marker
+        try { unlinkSync(join(dir, f)); } catch {}
+      }
+    }
+  } catch {}
+}
+
+function buildSparkline(cwd) {
+  const indexPath = join(cwd, '.dualbrain', 'session-index.json');
+  let index = {};
+  try { index = JSON.parse(readFileSync(indexPath, 'utf8')); } catch { return null; }
+
+  const sessions = Object.values(index);
+  if (sessions.length < 2) return null;
+
+  const now = Date.now();
+  const days = 7;
+  const buckets = new Array(days).fill(0);
+
+  for (const sess of sessions) {
+    if (!sess.date) continue;
+    const age = (now - Date.parse(sess.date)) / 86400000;
+    const bucket = Math.floor(age);
+    if (bucket >= 0 && bucket < days) {
+      buckets[days - 1 - bucket]++;
+    }
+  }
+
+  const max = Math.max(...buckets, 1);
+  const blocks = ['▁', '▂', '▃', '▄', '▅', '▆', '▇', '█'];
+  const spark = buckets.map(v => {
+    if (v === 0) return ' ';
+    const idx = Math.min(Math.floor((v / max) * (blocks.length - 1)), blocks.length - 1);
+    return blocks[idx];
+  }).join('');
+
+  const total = buckets.reduce((a, b) => a + b, 0);
+  if (total === 0) return null;
+  return `${spark} ${total} sessions (7d)`;
+}
+
 function daysUntil(isoDate) {
   if (!isoDate) return null;
   const ms = Date.parse(isoDate) - Date.now();
@@ -84,6 +168,7 @@ Commands:
   cool <provider>           Manually clear hot state for a provider
   remember "preference"     Save a project-scoped preference
   forget "preference"       Remove a preference by fuzzy match
+  search "keyword"           Search across all sessions
   shell-hook                Output bash snippet to add dual-brain to your shell
                             Usage: dual-brain shell-hook >> ~/.bashrc
 
@@ -98,6 +183,30 @@ Options:
 `.trim());
 }
 
+// ─── replit-tools detection ───────────────────────────────────────────────────
+
+function detectReplitTools(cwd) {
+  const replitToolsDir = join(cwd, '.replit-tools');
+  const hasDir = existsSync(replitToolsDir);
+  const hasConfig = existsSync(join(replitToolsDir, 'config.json'));
+  const hasScripts = existsSync(join(replitToolsDir, 'scripts', 'setup-claude-code.sh'));
+  const hasArchive = existsSync(join(replitToolsDir, '.session-archive'));
+
+  let version = null;
+  try {
+    version = readFileSync(join(replitToolsDir, '.version'), 'utf8').trim();
+  } catch {}
+
+  return {
+    installed: hasDir,
+    version,
+    hasConfig,
+    hasScripts,
+    hasArchive,
+    dir: replitToolsDir,
+  };
+}
+
 // ─── Subscription status table ────────────────────────────────────────────────
 
 /**
@@ -627,9 +736,26 @@ async function welcomeScreen(rl, ask) {
     detectedLines.push(`  ${existingSessions.length} session${existingSessions.length !== 1 ? 's' : ''} found from data-tools`);
   }
 
+  // --- Detect replit-tools ---
+  const rt = detectReplitTools(cwd);
+  if (rt.installed) {
+    detectedLines.push(`  replit-tools v${rt.version || '?'} detected`);
+    if (rt.hasArchive) {
+      try {
+        const archiveDir = join(rt.dir, '.session-archive', 'claude', 'projects', '-home-runner-workspace');
+        if (existsSync(archiveDir)) {
+          const count = readdirSync(archiveDir).filter(f => f.endsWith('.jsonl') && !f.startsWith('agent-')).length;
+          if (count > 0) detectedLines.push(`  ${count} archived sessions available`);
+        }
+      } catch {}
+    }
+  } else {
+    detectedLines.push(`  replit-tools not found — install with: npx replit-tools`);
+  }
+
   // Show detection results in a box
   const detectedFormatted = detectedLines.map(line => {
-    const ok = !line.includes('not logged');
+    const ok = !line.includes('not logged') && !line.includes('not found');
     return `${ok ? '✅' : '⚠️ '} ${line.trim()}`;
   });
   console.log('');
@@ -649,6 +775,11 @@ async function welcomeScreen(rl, ask) {
   if (existingSessions.length > 0) {
     console.log(`  [i]     Import ${existingSessions.length} session${existingSessions.length !== 1 ? 's' : ''} from data-tools`);
   }
+  if (!rt.installed) {
+    console.log('');
+    console.log('  💡 Tip: Install replit-tools for session persistence:');
+    console.log('     npx replit-tools');
+  }
   console.log('');
 
   const choice = (await ask('  Choice: ')).trim().toLowerCase();
@@ -685,6 +816,13 @@ async function welcomeScreen(rl, ask) {
       existing.mode = enabledCount >= 2 ? 'dual' : claudeReady ? 'solo-claude' : 'solo-openai';
       saveProfile(existing, { cwd });
     }
+    try {
+      const { ensurePersistence } = await import('../src/session.mjs');
+      const persisted = ensurePersistence(cwd);
+      if (persisted.length > 0) {
+        persisted.forEach(msg => console.log(`  ✅ ${msg}`));
+      }
+    } catch {}
     await cmdInstall(cwd);
     return { next: 'main' };
   }
@@ -783,6 +921,42 @@ async function welcomeScreen(rl, ask) {
   return { next: 'main' };
 }
 
+// ─── Running-instance + terminal helpers ─────────────────────────────────────
+
+function countRunningInstances() {
+  try {
+    const claude = parseInt(execSync('pgrep -x claude 2>/dev/null | wc -l', { encoding: 'utf8' }).trim(), 10) || 0;
+    const codex  = parseInt(execSync('pgrep -x codex 2>/dev/null | wc -l',  { encoding: 'utf8' }).trim(), 10) || 0;
+    return { claude, codex };
+  } catch { return { claude: 0, codex: 0 }; }
+}
+
+function getTerminalId() {
+  try {
+    const tty = execSync('tty 2>/dev/null', { encoding: 'utf8' }).trim();
+    if (tty && tty !== 'not a tty') {
+      return tty.replace('/dev/', '').replace(/\//g, '-');
+    }
+  } catch {}
+  return `shell-${process.pid}`;
+}
+
+function saveTerminalState(cwd, terminalId, sessionId, tool) {
+  const dir = join(cwd, '.dualbrain');
+  try {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, `terminal-${terminalId}.json`), JSON.stringify({
+      sessionId, tool, terminalId, timestamp: Math.floor(Date.now() / 1000),
+    }));
+  } catch {}
+}
+
+function loadTerminalState(cwd, terminalId) {
+  try {
+    return JSON.parse(readFileSync(join(cwd, '.dualbrain', `terminal-${terminalId}.json`), 'utf8'));
+  } catch { return null; }
+}
+
 // ─── Screen: mainScreen ───────────────────────────────────────────────────────
 
 async function mainScreen(rl, ask) {
@@ -824,6 +998,11 @@ async function mainScreen(rl, ask) {
   ];
 
   console.log(`📦 DATA Tools - 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('');
 
   // Help shortcuts box (matching data-tools style)
@@ -850,6 +1029,35 @@ async function mainScreen(rl, ask) {
     console.log(`  ${line}`);
   }
 
+  // replit-tools indicator
+  const rtMain = detectReplitTools(cwd);
+  if (rtMain.installed && rtMain.version) {
+    console.log(`  🔗 replit-tools v${rtMain.version}`);
+  }
+
+  const sparkline = buildSparkline(cwd);
+  if (sparkline) {
+    console.log(`  Activity: ${sparkline}`);
+  }
+
+  // Silent OAuth token auto-refresh (like data-tools)
+  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)`);
+    }
+  } catch {}
+
+  // Append-only session archive sync (like data-tools)
+  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`);
+    }
+  } catch {}
+
   // Auto-refresh expired subscriptions
   if (claudeExpired || openaiExpired) {
     const { spawnSync } = await import('node:child_process');
@@ -876,6 +1084,12 @@ async function mainScreen(rl, ask) {
   }
   console.log('');
 
+  // Build session index in background (powers search + smart resume)
+  try {
+    const { buildSessionIndex } = await import('../src/session.mjs');
+    buildSessionIndex(cwd);
+  } catch {}
+
   const recentSessions = enrichSessions(importReplitSessions(cwd), cwd).slice(0, 7);
 
   if (recentSessions.length > 0) {
@@ -904,11 +1118,22 @@ async function mainScreen(rl, ask) {
   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('');
+  }
+
   console.log('  [c] Continue last session');
   console.log('  [n] New session');
   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('  [i] Import from replit-tools');
   console.log('  [m] Manage subscriptions');
@@ -922,24 +1147,124 @@ async function mainScreen(rl, ask) {
   if (choice === 'n') { return { next: 'new-session' }; }
 
   if (choice === 'c') {
-    const sessions = importReplitSessions(cwd);
-    if (sessions.length === 0) {
+    const termId    = getTerminalId();
+    const termState = loadTerminalState(cwd, termId);
+    const sessions  = importReplitSessions(cwd);
+
+    // Priority: terminal-specific last session, then global last session
+    const targetId = termState?.sessionId || (sessions.length > 0 ? sessions[0].id : null);
+
+    if (!targetId) {
       console.log('\n  No recent sessions found.\n');
       await ask('  Press Enter to continue...');
       return { next: 'main' };
     }
+
+    // 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(', ')}`);
+      }
+    } catch {}
+
     const { spawnSync } = await import('node:child_process');
-    console.log(`\n  Launching: claude --resume ${sessions[0].id}\n`);
-    spawnSync('claude', ['--resume', sessions[0].id], { stdio: 'inherit' });
+    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);
     return { next: 'main' };
   }
 
   const numChoice = parseInt(choice, 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(', ')}`);
+      }
+    } catch {}
+
     const { spawnSync } = await import('node:child_process');
     console.log(`\n  Launching: claude --resume ${sess.id}\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 === '/') {
+    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`);
+      await ask('  Press Enter to continue...');
+      return { next: 'main' };
+    }
+
+    console.log(`\n  Found ${results.length} session${results.length === 1 ? '' : 's'}:`);
+    results.slice(0, 9).forEach((sess, i) => {
+      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}`);
+    });
+    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 <= 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`);
+      spawnSync(tool, ['--resume', sess.id], { stdio: 'inherit' });
+    }
     return { next: 'main' };
   }
 
@@ -992,12 +1317,19 @@ async function newSessionScreen(rl, ask) {
   console.log(`  Reason: ${decision.explanation}\n`);
 
   const { spawnSync } = await import('node:child_process');
-  if (decision.provider === 'openai') {
+  const launchTool = decision.provider === 'openai' ? 'codex' : 'claude';
+  if (launchTool === 'codex') {
     spawnSync('codex', [input], { stdio: 'inherit' });
   } else {
     spawnSync('claude', ['-p', input], { stdio: 'inherit' });
   }
 
+  // After session ends, capture the most-recent session ID so [c] can resume it
+  const freshSessions = importReplitSessions(cwd);
+  if (freshSessions.length > 0) {
+    saveTerminalState(cwd, getTerminalId(), freshSessions[0].id, launchTool);
+  }
+
   return { next: 'main' };
 }
 
@@ -1927,6 +2259,11 @@ async function main() {
   if (!cmd) {
     if (isInteractive) {
       const cwd = process.cwd();
+      cleanStaleMarkers(cwd);
+      if (!process.argv.includes('--force') && checkLoopMarker(cwd)) {
+        process.exit(0);
+      }
+      setLoopMarker(cwd);
       if (profileExists(cwd)) {
         await runScreens('main');
       } else {
@@ -1969,6 +2306,37 @@ async function main() {
   if (cmd === 'remember') { cmdRemember(args[1]); return; }
   if (cmd === 'forget')   { cmdForget(args[1]); return; }
 
+  if (cmd === 'search') {
+    const query = args.slice(1).filter(a => !a.startsWith('--')).join(' ');
+    if (!query) {
+      console.log('Usage: dual-brain search "keyword"');
+      process.exit(1);
+    }
+
+    const { searchSessions, buildSessionIndex } = await import('../src/session.mjs');
+    const cwd = process.cwd();
+    try { buildSessionIndex(cwd); } catch {}
+
+    const results = searchSessions(query, cwd);
+    if (results.length === 0) {
+      console.log(`No sessions matching "${query}"`);
+      process.exit(0);
+    }
+
+    console.log(`Found ${results.length} session${results.length === 1 ? '' : 's'}:\n`);
+    results.slice(0, 10).forEach((sess, i) => {
+      const tool = sess.tool === 'codex' ? 'cdx' : 'cld';
+      const date = sess.date ? new Date(sess.date).toLocaleDateString() : '?';
+      console.log(`  ${i + 1}. [${tool}] ${date}  ${sess.prompts.first || sess.id.slice(0, 8)}`);
+      if (sess.topics.length > 0) console.log(`     topics: ${sess.topics.slice(0, 5).join(', ')}`);
+      if (sess.files.length > 0) console.log(`     files: ${sess.files.slice(0, 5).join(', ')}`);
+      console.log(`     id: ${sess.id}`);
+      console.log('');
+    });
+
+    process.exit(0);
+  }
+
   if (cmd === 'shell-hook') {
     // Output a bash snippet users can add to their .bashrc or source directly.
     const hook = `

package/package.json

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

package/src/index.mjs

@@ -6,14 +6,14 @@
  * orchestrate() convenience function for programmatic use.
  */
 
-export { loadProfile, saveProfile, ensureProfile, runOnboarding, rememberPreference, forgetPreference, getActivePreferences, getAvailableProviders, isSoloBrain, getHeadModel, detectAuth, detectEnvironment, saveSubscription, listSubscriptions } from './profile.mjs';
+export { loadProfile, saveProfile, ensureProfile, runOnboarding, rememberPreference, forgetPreference, getActivePreferences, getAvailableProviders, isSoloBrain, getHeadModel, detectAuth, detectEnvironment, saveSubscription, listSubscriptions, autoRefreshToken } from './profile.mjs';
 export { detectTask, classifyIntent, classifyRisk, estimateComplexity, inferTier, extractPaths } from './detect.mjs';
 export { decideRoute, getModelCapabilities, getAvailableModels, shouldDualBrain, explainDecision } from './decide.mjs';
 export { dispatch, buildCommand, detectRuntime, compressResult, dispatchDualBrain } from './dispatch.mjs';
 export { loadPlaybook, listPlaybooks, executePlaybook, createRunArtifact } from './playbook.mjs';
 export { getHealth, markHot, markDegraded, markHealthy, checkCooldown, getProviderScore, recordDispatch, getSessionStats, resetHealth, remainingCooldownMinutes } from './health.mjs';
 export { detectRepo, loadRepoCache, getTestCommand, getLintCommand } from './repo.mjs';
-export { loadSession, saveSession, updateSession, clearSession, formatSessionCard, importReplitSessions, renameSession, pinSession, unpinSession, categorizeSession, getSessionMeta, autoLabel, enrichSessions } from './session.mjs';
+export { loadSession, saveSession, updateSession, clearSession, formatSessionCard, importReplitSessions, renameSession, pinSession, unpinSession, categorizeSession, getSessionMeta, autoLabel, enrichSessions, ensurePersistence, syncSessionMirror, buildSessionIndex, searchSessions, getSessionContext } from './session.mjs';
 export { decompose, isSimpleTask, taskGraphToWaves } from './decompose.mjs';
 export { generateBrief, compressPriorResults, listRoles } from './brief.mjs';
 export { redact, redactFiles, isSecretFile } from './redact.mjs';

package/src/profile.mjs

@@ -666,6 +666,92 @@ async function autoSetup(cwd) {
   return result;
 }
 
+// ---------------------------------------------------------------------------
+// OAuth token auto-refresh
+// ---------------------------------------------------------------------------
+
+/**
+ * Silently refresh the Claude OAuth token before it expires.
+ * Mirrors the approach used by replit-tools/data-tools claude-auth-refresh.sh,
+ * but implemented in JavaScript.
+ *
+ * Returns one of:
+ *   { status: 'valid', hoursRemaining }
+ *   { status: 'refreshed', hoursRemaining }
+ *   { status: 'expiring_no_refresh' | 'expired', hoursRemaining }
+ *   { status: 'no_credentials' | 'parse_error' | 'no_expiry' }
+ *   { status: 'refresh_failed', error }
+ *
+ * @param {string} [cwd]
+ */
+async function autoRefreshToken(cwd) {
+  const home = process.env.HOME || '/root';
+  const credPaths = [
+    join(home, '.claude', '.credentials.json'),
+    join(cwd || '.', '.replit-tools', '.claude-persistent', '.credentials.json'),
+  ];
+
+  let credPath = null;
+  for (const p of credPaths) {
+    if (existsSync(p)) { credPath = p; break; }
+  }
+  if (!credPath) return { status: 'no_credentials' };
+
+  let creds;
+  try {
+    creds = JSON.parse(readFileSync(credPath, 'utf8'));
+  } catch { return { status: 'parse_error' }; }
+
+  const oauth = creds?.claudeAiOauth;
+  if (!oauth?.expiresAt) return { status: 'no_expiry' };
+
+  const now = Date.now();
+  const remainingMs = oauth.expiresAt - now;
+  const remainingHours = Math.floor(remainingMs / 1000 / 60 / 60);
+
+  // More than 2 hours left — no refresh needed
+  if (remainingHours >= 2) {
+    return { status: 'valid', hoursRemaining: remainingHours };
+  }
+
+  // Need refresh
+  if (!oauth.refreshToken) {
+    return { status: remainingMs > 0 ? 'expiring_no_refresh' : 'expired', hoursRemaining: remainingHours };
+  }
+
+  try {
+    const res = await fetch('https://console.anthropic.com/v1/oauth/token', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        grant_type: 'refresh_token',
+        refresh_token: oauth.refreshToken,
+        client_id: '9d1c250a-e61b-44d9-88ed-5944d1962f5e',
+      }),
+    });
+
+    if (!res.ok) return { status: 'refresh_failed', error: `HTTP ${res.status}` };
+
+    const data = await res.json();
+    if (!data.access_token) return { status: 'refresh_failed', error: 'no access_token' };
+
+    // Update credentials
+    const newExpiresAt = now + (data.expires_in * 1000);
+    creds.claudeAiOauth.accessToken = data.access_token;
+    if (data.refresh_token) creds.claudeAiOauth.refreshToken = data.refresh_token;
+    creds.claudeAiOauth.expiresAt = newExpiresAt;
+
+    // Backup then write
+    try { writeFileSync(credPath + '.backup', readFileSync(credPath)); } catch {}
+    writeFileSync(credPath, JSON.stringify(creds));
+
+    const newHours = Math.floor((data.expires_in) / 60 / 60);
+    return { status: 'refreshed', hoursRemaining: newHours };
+  } catch (e) {
+    return { status: 'refresh_failed', error: e.message };
+  }
+}
+
 export {
   loadProfile, saveProfile, ensureProfile, runOnboarding,
   rememberPreference, forgetPreference, getActivePreferences,
@@ -673,5 +759,5 @@ export {
   detectPlans, syncPreferencesToMemory,
   detectAuth, detectEnvironment,
   saveSubscription, listSubscriptions,
-  defaultProfile, autoSetup,
+  defaultProfile, autoSetup, autoRefreshToken,
 };

package/src/session.mjs

@@ -10,8 +10,8 @@
  *   formatSessionCard(session, repo, health) → compact status card string (≤5 lines)
  */
 
-import { existsSync, readFileSync, writeFileSync, mkdirSync, unlinkSync, renameSync, readdirSync, statSync } from 'node:fs';
-import { join } from 'node:path';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, unlinkSync, renameSync, readdirSync, statSync, copyFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
 
 // ─── Constants ────────────────────────────────────────────────────────────────
 
@@ -216,6 +216,23 @@ export function formatSessionCard(session, repo, health, profile) {
 
 // ─── Replit-tools session import ──────────────────────────────────────────────
 
+/**
+ * Returns true if the text looks like a real user prompt (not a status line,
+ * slash command, paste marker, or agent-generated noise).
+ * @param {string} text
+ * @returns {boolean}
+ */
+function isRealPrompt(text) {
+  if (!text || !text.trim()) return false;
+  const t = text.trim();
+  if (/^[✅❌📦🔗⚠️🚀🎉🔧📝]/.test(t)) return false;
+  if (/Claude (history|binary|versions) symlink/.test(t)) return false;
+  if (t.startsWith('# AGENTS.md')) return false;
+  if (t.startsWith('/')) return false;
+  if (t.startsWith('[Pasted')) return false;
+  return true;
+}
+
 /**
  * Human-readable time-ago string from a Unix timestamp (ms).
  * @param {number} timestamp
@@ -299,61 +316,61 @@ export function importReplitSessions(cwd = process.cwd()) {
       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')) {
+      // Find first meaningful user prompt
+      if (!sess.firstPrompt && isRealPrompt(entry.display)) {
         sess.firstPrompt = entry.display;
       }
     } catch { continue; }
   }
 
-  // Scan ~/.claude/projects/-home-runner-workspace/ for JSONL files not already in bySession
-  const projectsDir = join(process.env.HOME || '/root', '.claude', 'projects', '-home-runner-workspace');
-  if (existsSync(projectsDir)) {
-    try {
-      for (const f of readdirSync(projectsDir)) {
-        if (!f.endsWith('.jsonl') || f.startsWith('agent-')) continue;
-        const sessionId = f.replace('.jsonl', '');
-        if (bySession.has(sessionId)) continue;
+  // Also read from the session archive as a fallback (contains cleaned-up sessions)
+  const archivePath = join(cwd, '.replit-tools', '.session-archive', 'claude', 'history.jsonl');
+  let archiveLines = [];
+  try {
+    if (existsSync(archivePath)) {
+      archiveLines = readFileSync(archivePath, 'utf8').split('\n').filter(Boolean);
+    }
+  } catch { /* non-fatal */ }
 
-        try {
-          const content = readFileSync(join(projectsDir, f), 'utf8');
-          const lines = content.split('\n').filter(Boolean).slice(0, 50);
-          let firstPrompt = null;
-          let lastTimestamp = 0;
+  for (const line of archiveLines) {
+    try {
+      const entry = JSON.parse(line);
+      if (!entry.sessionId) continue;
+      if (bySession.has(entry.sessionId)) continue; // already indexed from main history
 
-          for (const line of lines) {
-            try {
-              const entry = JSON.parse(line);
-              if (entry.timestamp && entry.timestamp > lastTimestamp) lastTimestamp = entry.timestamp;
-              if (!firstPrompt && entry.type === 'user' && entry.message?.content) {
-                const text = typeof entry.message.content === 'string'
-                  ? entry.message.content
-                  : entry.message.content?.[0]?.text;
-                if (text && !text.startsWith('/') && text.length < 200) {
-                  firstPrompt = text;
-                }
-              }
-            } catch { continue; }
-          }
+      bySession.set(entry.sessionId, {
+        sessionId: entry.sessionId,
+        project: entry.project,
+        entries: [],
+        firstPrompt: null,
+        lastTimestamp: 0,
+      });
 
-          if (lastTimestamp === 0) {
-            const stat = statSync(join(projectsDir, f));
-            lastTimestamp = Math.floor(stat.mtimeMs / 1000);
-          }
+      const sess = bySession.get(entry.sessionId);
+      sess.entries.push(entry);
+      if (entry.timestamp > sess.lastTimestamp) sess.lastTimestamp = entry.timestamp;
+      if (!sess.firstPrompt && isRealPrompt(entry.display)) {
+        sess.firstPrompt = entry.display;
+      }
+    } catch { continue; }
+  }
 
-          bySession.set(sessionId, {
-            sessionId,
-            project: '-home-runner-workspace',
-            entries: [],
-            firstPrompt: firstPrompt || sessionId.slice(0, 8) + '...',
-            lastTimestamp,
-          });
-        } catch { continue; }
+  // For archive sessions with multiple entries, finish accumulating them
+  // (second pass for sessions newly added from archive)
+  for (const line of archiveLines) {
+    try {
+      const entry = JSON.parse(line);
+      if (!entry.sessionId) continue;
+      const sess = bySession.get(entry.sessionId);
+      if (!sess) continue;
+      // Already pushed in first pass for new sessions; skip double-push
+      if (sess.entries.includes(entry)) continue;
+      sess.entries.push(entry);
+      if (entry.timestamp > sess.lastTimestamp) sess.lastTimestamp = entry.timestamp;
+      if (!sess.firstPrompt && isRealPrompt(entry.display)) {
+        sess.firstPrompt = entry.display;
       }
-    } catch { /* non-fatal */ }
+    } catch { continue; }
   }
 
   // Scan ~/.codex/sessions/ for codex session JSONLs (YYYY/MM/DD tree)
@@ -431,8 +448,22 @@ export function importReplitSessions(cwd = process.cwd()) {
     } catch { /* non-fatal */ }
   }
 
+  // Determine recency window from config (default 48 hours)
+  const configPath = join(cwd, '.replit-tools', 'config.json');
+  let windowHours = 48;
+  try {
+    if (existsSync(configPath)) {
+      const cfg = JSON.parse(readFileSync(configPath, 'utf8'));
+      windowHours = cfg.recentWindowHours || 48;
+    }
+  } catch { /* non-fatal */ }
+  const windowMs = windowHours * 60 * 60 * 1000;
+  const cutoff = Date.now() - windowMs;
+
   // Build session list
   for (const [id, sess] of bySession) {
+    // Skip sessions outside the recency window (timestamps are in seconds)
+    if (sess.lastTimestamp * 1000 < cutoff) continue;
     // Derive display name
     let name = sess.firstPrompt;
     if (!name) {
@@ -546,6 +577,450 @@ export function enrichSessions(sessions, cwd = process.cwd()) {
   return enriched;
 }
 
+// ─── Persistence settings ─────────────────────────────────────────────────────
+
+/**
+ * Ensure Claude and Codex are configured to retain session history indefinitely.
+ * Mirrors what replit-tools does to prevent session cleanup/deletion.
+ *
+ * @param {string} [cwd]
+ * @returns {string[]} List of changes made (empty if already configured)
+ */
+export function ensurePersistence(cwd = process.cwd()) {
+  const home = process.env.HOME || '/root';
+  const results = [];
+
+  // 1. Claude: set cleanupPeriodDays
+  const claudeSettingsPaths = [
+    join(home, '.claude', 'settings.json'),
+    join(cwd, '.replit-tools', '.claude-persistent', 'settings.json'),
+  ];
+
+  for (const settingsPath of claudeSettingsPaths) {
+    if (!existsSync(settingsPath)) continue;
+    try {
+      let settings = {};
+      try { settings = JSON.parse(readFileSync(settingsPath, 'utf8')); } catch { settings = {}; }
+      if (settings.cleanupPeriodDays !== 365250) {
+        settings.cleanupPeriodDays = 365250;
+        writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+        results.push('Claude cleanupPeriodDays set to 365250');
+      }
+      break; // only update one
+    } catch { continue; }
+  }
+
+  // 2. Codex: set history.persistence and max_bytes
+  const codexConfigPaths = [
+    join(home, '.codex', 'config.toml'),
+    join(cwd, '.replit-tools', '.codex-persistent', 'config.toml'),
+  ];
+
+  for (const configPath of codexConfigPaths) {
+    if (!existsSync(configPath)) continue;
+    try {
+      let content = readFileSync(configPath, 'utf8');
+      let changed = false;
+
+      if (!/\[history\]/.test(content)) {
+        content = content.trimEnd() + '\n\n[history]\npersistence = "save-all"\nmax_bytes = 104857600\n';
+        changed = true;
+      } else {
+        if (!/persistence\s*=/.test(content)) {
+          content = content.replace(/\[history\](\s*)/, '[history]$1persistence = "save-all"\n');
+          changed = true;
+        }
+        if (!/max_bytes\s*=/.test(content)) {
+          content = content.replace(/(persistence\s*=\s*"[^"]*"\s*\n)/, '$1max_bytes = 104857600\n');
+          changed = true;
+        }
+      }
+
+      if (changed) {
+        writeFileSync(configPath, content);
+        results.push('Codex history persistence enabled');
+      }
+      break;
+    } catch { continue; }
+  }
+
+  return results;
+}
+
+// ─── Session archive mirror sync ─────────────────────────────────────────────
+
+/**
+ * Append-only mirror sync for Claude/Codex sessions (matches what replit-tools does).
+ * Files in the mirror only grow — if the source deletes a session, the mirror still has it.
+ *
+ * @param {string} [cwd]
+ * @returns {{ copied: number, grew: number, disabled?: boolean }}
+ */
+export function syncSessionMirror(cwd = process.cwd()) {
+  const home = process.env.HOME || '/root';
+  const mirrorBase = join(cwd, '.replit-tools', '.session-archive');
+
+  // Check if replit-tools exists
+  if (!existsSync(join(cwd, '.replit-tools'))) return { copied: 0, grew: 0 };
+
+  // Check config — mirror can be disabled
+  const configPath = join(cwd, '.replit-tools', 'config.json');
+  try {
+    if (existsSync(configPath)) {
+      const cfg = JSON.parse(readFileSync(configPath, 'utf8'));
+      if (cfg.mirror && cfg.mirror.enabled === false) return { copied: 0, grew: 0, disabled: true };
+    }
+  } catch {}
+
+  let totalCopied = 0, totalGrew = 0;
+
+  function syncTree(srcDir, destDir) {
+    if (!existsSync(srcDir)) return;
+
+    function walk(dir) {
+      let entries;
+      try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+
+      for (const entry of entries) {
+        const srcPath = join(dir, entry.name);
+        const relPath = srcPath.slice(srcDir.length);
+        const destPath = join(destDir, relPath);
+
+        if (entry.isDirectory()) {
+          try { mkdirSync(destPath, { recursive: true }); } catch {}
+          walk(srcPath);
+        } else if (entry.isFile()) {
+          let destSize = 0;
+          try { destSize = statSync(destPath).size; } catch {}
+
+          let srcSize = 0;
+          try { srcSize = statSync(srcPath).size; } catch { continue; }
+
+          // Append-only: only copy if source is larger than mirror
+          if (srcSize > destSize) {
+            try {
+              mkdirSync(dirname(destPath), { recursive: true });
+              copyFileSync(srcPath, destPath);
+              if (destSize === 0) totalCopied++;
+              else totalGrew++;
+            } catch {}
+          }
+        }
+      }
+    }
+
+    walk(srcDir);
+  }
+
+  try { mkdirSync(mirrorBase, { recursive: true }); } catch {}
+
+  // Sync Claude sessions
+  const claudeDir = join(home, '.claude');
+  syncTree(join(claudeDir, 'projects'), join(mirrorBase, 'claude', 'projects'));
+  // Sync history.jsonl as a single file
+  const histSrc = join(claudeDir, 'history.jsonl');
+  const histDest = join(mirrorBase, 'claude', 'history.jsonl');
+  if (existsSync(histSrc)) {
+    try {
+      const srcSize = statSync(histSrc).size;
+      let destSize = 0;
+      try { destSize = statSync(histDest).size; } catch {}
+      if (srcSize > destSize) {
+        mkdirSync(dirname(histDest), { recursive: true });
+        copyFileSync(histSrc, histDest);
+        if (destSize === 0) totalCopied++; else totalGrew++;
+      }
+    } catch {}
+  }
+
+  // Sync Codex sessions
+  const codexDir = join(home, '.codex');
+  syncTree(join(codexDir, 'sessions'), join(mirrorBase, 'codex', 'sessions'));
+
+  return { copied: totalCopied, grew: totalGrew };
+}
+
+// ─── Session index ────────────────────────────────────────────────────────────
+
+/**
+ * Build/update `.dualbrain/session-index.json` from Claude and Codex JSONL session files.
+ * Extracts topics, file references, prompt snippets, and metadata per session.
+ *
+ * @param {string} [cwd]
+ * @returns {object} index — keyed by session UUID
+ */
+export function buildSessionIndex(cwd = process.cwd()) {
+  const home = process.env.HOME || '/root';
+  const indexPath = join(cwd, '.dualbrain', 'session-index.json');
+
+  // Load existing index
+  let index = {};
+  try {
+    if (existsSync(indexPath)) {
+      index = JSON.parse(readFileSync(indexPath, 'utf8'));
+    }
+  } catch {}
+
+  // Find all session JSONLs
+  const sources = [
+    join(home, '.claude', 'projects', '-home-runner-workspace'),
+    join(cwd, '.replit-tools', '.session-archive', 'claude', 'projects', '-home-runner-workspace'),
+  ];
+
+  const STOP_WORDS = new Set(['the','and','this','that','with','from','have','been','will','would','could','should','just','also','into','about','some','what','when','where','which','their','there','then','than','them','these','those','other','more','only','very','each','most','like','make','want','need','does','dont','didnt','cant','wont','your','they','were','are','for','not','but','was','you','all','can','had','her','one','our','out','use','its','let','get','has','him','his','how','did','got','may','new','now','old','see','way','who','any','few','said']);
+
+  for (const dir of sources) {
+    if (!existsSync(dir)) continue;
+    let files;
+    try { files = readdirSync(dir); } catch { continue; }
+
+    for (const f of files) {
+      if (!f.endsWith('.jsonl') || f.startsWith('agent-')) continue;
+      const sessionId = f.replace('.jsonl', '');
+
+      // Skip if already indexed and file hasn't grown
+      const filePath = join(dir, f);
+      let fileSize = 0;
+      try { fileSize = statSync(filePath).size; } catch { continue; }
+      if (index[sessionId] && index[sessionId]._fileSize >= fileSize) continue;
+
+      // Parse session
+      try {
+        const content = readFileSync(filePath, 'utf8');
+        const lines = content.split('\n').filter(Boolean);
+
+        const wordCounts = {};
+        const fileSet = new Set();
+        let firstPrompt = null;
+        let lastPrompt = null;
+        let lastTimestamp = 0;
+        let messageCount = 0;
+
+        for (const line of lines) {
+          try {
+            const entry = JSON.parse(line);
+
+            // Track timestamps
+            if (entry.timestamp) {
+              const ts = typeof entry.timestamp === 'number' ? entry.timestamp : Date.parse(entry.timestamp) / 1000;
+              if (ts > lastTimestamp) lastTimestamp = ts;
+            }
+
+            // Extract user messages
+            let text = null;
+            if (entry.type === 'user' && entry.message?.content) {
+              text = typeof entry.message.content === 'string'
+                ? entry.message.content
+                : entry.message.content?.[0]?.text;
+            }
+            if (entry.display) text = text || entry.display;
+
+            if (!text) continue;
+            messageCount++;
+
+            if (!firstPrompt) firstPrompt = text.slice(0, 80);
+            lastPrompt = text.slice(0, 80);
+
+            // Extract file paths
+            const filePaths = text.match(/[\w./~-]+\.(?:mjs|js|ts|tsx|jsx|json|md|css|html|py|sh|sql|toml|yaml|yml)\b/g);
+            if (filePaths) filePaths.forEach(p => fileSet.add(p));
+
+            // Count words for topics
+            const words = text.toLowerCase().split(/\W+/).filter(w => w.length > 3 && !STOP_WORDS.has(w));
+            for (const w of words) {
+              wordCounts[w] = (wordCounts[w] || 0) + 1;
+            }
+          } catch { continue; }
+        }
+
+        // Top 10 topics by frequency
+        const topics = Object.entries(wordCounts)
+          .sort((a, b) => b[1] - a[1])
+          .slice(0, 10)
+          .map(([w]) => w);
+
+        index[sessionId] = {
+          id: sessionId,
+          topics,
+          files: [...fileSet].slice(0, 20),
+          prompts: { first: firstPrompt || '', last: lastPrompt || '' },
+          date: lastTimestamp ? new Date(lastTimestamp * 1000).toISOString() : null,
+          messageCount,
+          tool: 'claude',
+          _fileSize: fileSize,
+        };
+      } catch { continue; }
+    }
+  }
+
+  // Also index codex sessions (same pattern)
+  const codexDir = join(home, '.codex', 'sessions');
+  if (existsSync(codexDir)) {
+    const walk = (dir) => {
+      let results = [];
+      try {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+          const full = join(dir, entry.name);
+          if (entry.isDirectory()) results = results.concat(walk(full));
+          else if (entry.isFile() && entry.name.endsWith('.jsonl')) results.push(full);
+        }
+      } catch {}
+      return results;
+    };
+
+    for (const filePath of walk(codexDir)) {
+      try {
+        const content = readFileSync(filePath, 'utf8');
+        const lines = content.split('\n').filter(Boolean);
+        if (!lines.length) continue;
+        const meta = JSON.parse(lines[0]);
+        if (meta.type !== 'session_meta' || !meta.payload) continue;
+        const id = meta.payload.id;
+        if (!id || index[id]) continue;
+
+        let fileSize = 0;
+        try { fileSize = statSync(filePath).size; } catch { continue; }
+
+        let firstPrompt = null, lastPrompt = null, messageCount = 0;
+        let lastTimestamp = Date.parse(meta.payload.timestamp || meta.timestamp) / 1000 || 0;
+
+        for (const ln of lines) {
+          try {
+            const j = JSON.parse(ln);
+            if (j.timestamp) {
+              const ts = Date.parse(j.timestamp) / 1000;
+              if (ts > lastTimestamp) lastTimestamp = ts;
+            }
+            if (j.type === 'event_msg' && j.payload?.type === 'user_message') {
+              const text = (j.payload.message || '').trim();
+              if (text) {
+                messageCount++;
+                if (!firstPrompt) firstPrompt = text.slice(0, 80);
+                lastPrompt = text.slice(0, 80);
+              }
+            }
+          } catch { continue; }
+        }
+
+        index[id] = {
+          id, topics: [], files: [],
+          prompts: { first: firstPrompt || '', last: lastPrompt || '' },
+          date: lastTimestamp ? new Date(lastTimestamp * 1000).toISOString() : null,
+          messageCount, tool: 'codex', _fileSize: fileSize,
+        };
+      } catch { continue; }
+    }
+  }
+
+  // Save index
+  try {
+    mkdirSync(join(cwd, '.dualbrain'), { recursive: true });
+    writeFileSync(indexPath, JSON.stringify(index, null, 2));
+  } catch {}
+
+  return index;
+}
+
+/**
+ * Search the session index by keyword. Returns matching sessions sorted by relevance.
+ *
+ * @param {string} query
+ * @param {string} [cwd]
+ * @returns {Array<object>} sessions with `_score` field, sorted descending
+ */
+export function searchSessions(query, cwd = process.cwd()) {
+  const indexPath = join(cwd, '.dualbrain', 'session-index.json');
+  let index = {};
+  try { index = JSON.parse(readFileSync(indexPath, 'utf8')); } catch {}
+
+  if (Object.keys(index).length === 0) {
+    index = buildSessionIndex(cwd);
+  }
+
+  const terms = query.toLowerCase().split(/\W+/).filter(Boolean);
+  const results = [];
+
+  for (const session of Object.values(index)) {
+    let score = 0;
+    const searchText = [
+      ...session.topics,
+      ...session.files,
+      session.prompts.first,
+      session.prompts.last,
+    ].join(' ').toLowerCase();
+
+    for (const term of terms) {
+      if (searchText.includes(term)) score++;
+      if (session.topics.includes(term)) score += 2;
+      if (session.files.some(f => f.includes(term))) score += 2;
+    }
+
+    if (score > 0) {
+      results.push({ ...session, _score: score });
+    }
+  }
+
+  return results.sort((a, b) => b._score - a._score);
+}
+
+/**
+ * Get detailed context for a session (for smart resume preview).
+ * Reads the last 20 lines of the session JSONL to surface the most recent prompt
+ * and files touched.
+ *
+ * @param {string} sessionId
+ * @param {string} [cwd]
+ * @returns {{ lastPrompt: string|null, filesTouched: string[], totalLines: number }|null}
+ */
+export function getSessionContext(sessionId, cwd = process.cwd()) {
+  const home = process.env.HOME || '/root';
+  const paths = [
+    join(home, '.claude', 'projects', '-home-runner-workspace', sessionId + '.jsonl'),
+    join(cwd, '.replit-tools', '.session-archive', 'claude', 'projects', '-home-runner-workspace', sessionId + '.jsonl'),
+  ];
+
+  let filePath = null;
+  for (const p of paths) {
+    if (existsSync(p)) { filePath = p; break; }
+  }
+  if (!filePath) return null;
+
+  try {
+    const content = readFileSync(filePath, 'utf8');
+    const lines = content.split('\n').filter(Boolean);
+
+    // Read last 20 lines for recent context
+    const recentLines = lines.slice(-20);
+    let lastUserPrompt = null;
+    const filesSet = new Set();
+
+    for (const line of recentLines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.type === 'user' && entry.message?.content) {
+          const text = typeof entry.message.content === 'string'
+            ? entry.message.content
+            : entry.message.content?.[0]?.text;
+          if (text) lastUserPrompt = text.slice(0, 120);
+        }
+        if (entry.display) lastUserPrompt = entry.display.slice(0, 120);
+
+        // Look for file edits in tool use
+        if (entry.type === 'tool_use' || entry.type === 'tool_result') {
+          const fp = entry.tool_input?.file_path || entry.tool_input?.path;
+          if (fp) filesSet.add(fp.split('/').pop());
+        }
+      } catch { continue; }
+    }
+
+    return {
+      lastPrompt: lastUserPrompt,
+      filesTouched: [...filesSet].slice(0, 5),
+      totalLines: lines.length,
+    };
+  } catch { return null; }
+}
+
 // ─── CLI (direct invocation) ──────────────────────────────────────────────────
 
 const isMain = process.argv[1]?.endsWith('session.mjs');