dual-brain 7.1.13 → 7.1.15

package/CLAUDE.md

@@ -135,3 +135,13 @@ For most tasks, prefer `dual-brain go "..."` — it runs the same detect→decid
 | `node .claude/hooks/health-check.mjs` | System health |
 | `node .claude/hooks/test-orchestrator.mjs` | Self-tests (40 tests) |
 | `node .claude/hooks/vibe-memory.mjs` | Persistent preferences across sessions |
+| `dual-brain search "..."` | Search across all previous sessions |
+
+## Cross-Session Context
+
+When the user references past work ("we did this before", "yesterday we worked on", "remember when we", "didn't we already fix"), use the session search to find relevant context:
+
+1. Run `dual-brain search "keyword"` to search the session index
+2. Or use the MCP tool `dual_brain_search` if available
+
+This surfaces previous conversations so HEAD can provide continuity across sessions without the user having to re-explain.

package/bin/dual-brain.mjs

@@ -95,6 +95,40 @@ function cleanStaleMarkers(cwd) {
   } 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();
@@ -134,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
 
@@ -148,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 ────────────────────────────────────────────────
 
 /**
@@ -677,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('');
@@ -699,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();
@@ -948,6 +1029,17 @@ 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');
@@ -992,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) {
@@ -1035,6 +1133,7 @@ async function mainScreen(rl, ask) {
     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');
@@ -1061,6 +1160,17 @@ async function mainScreen(rl, ask) {
       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');
     const tool = termState?.tool || 'claude';
     console.log(`\n  Resuming: ${tool} --resume ${targetId}\n`);
@@ -1072,6 +1182,18 @@ async function mainScreen(rl, ask) {
   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' });
@@ -1109,6 +1231,43 @@ async function mainScreen(rl, ask) {
     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' };
+  }
+
   if (choice === 'e') { return { next: 'sessions' }; }
 
   if (choice === 'i') {
@@ -2147,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/mcp-server/index.mjs

@@ -99,6 +99,34 @@ const TOOLS = [
       required: ['preference'],
     },
   },
+  {
+    name: 'dual_brain_search',
+    description: 'Search across all previous sessions for context. Use this when the user references past work ("we did this before", "yesterday we worked on", "remember when we", "didn\'t we already"). Returns matching sessions with prompts, topics, and files.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: {
+          type: 'string',
+          description: 'Search keywords to find in previous sessions. Can be topic, file name, or description of past work.',
+        },
+      },
+      required: ['query'],
+    },
+  },
+  {
+    name: 'dual_brain_session_context',
+    description: 'Get detailed context from a specific previous session. Use after dual_brain_search to retrieve details about what happened in a found session.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        sessionId: {
+          type: 'string',
+          description: 'The session UUID to get context for (from search results).',
+        },
+      },
+      required: ['sessionId'],
+    },
+  },
 ];
 
 // ─── Tool handlers ────────────────────────────────────────────────────────────
@@ -217,6 +245,34 @@ async function handleRemember({ preference }) {
   };
 }
 
+async function handleSearch({ query }) {
+  const { searchSessions, buildSessionIndex } = await import(`${SRC}/session.mjs`);
+  const cwd = process.cwd();
+  try { buildSessionIndex(cwd); } catch {}
+  const results = searchSessions(query, cwd);
+  return {
+    count: results.length,
+    sessions: results.slice(0, 5).map(s => ({
+      id: s.id,
+      tool: s.tool,
+      date: s.date,
+      firstPrompt: s.prompts.first,
+      lastPrompt: s.prompts.last,
+      topics: s.topics.slice(0, 5),
+      files: s.files.slice(0, 10),
+      messageCount: s.messageCount,
+    })),
+  };
+}
+
+async function handleSessionContext({ sessionId }) {
+  const { getSessionContext } = await import(`${SRC}/session.mjs`);
+  const cwd = process.cwd();
+  const ctx = getSessionContext(sessionId, cwd);
+  if (!ctx) return { error: 'Session not found' };
+  return ctx;
+}
+
 // ─── JSON-RPC dispatcher ──────────────────────────────────────────────────────
 
 async function dispatchTool(name, args) {
@@ -225,6 +281,8 @@ async function dispatchTool(name, args) {
     case 'dual_brain_decide':  return handleDecide(args);
     case 'dual_brain_status':  return handleStatus();
     case 'dual_brain_remember': return handleRemember(args);
+    case 'dual_brain_search':   return handleSearch(args);
+    case 'dual_brain_session_context': return handleSessionContext(args);
     default:
       throw Object.assign(new Error(`Unknown tool: ${name}`), { code: -32601 });
   }

package/package.json

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

package/src/index.mjs

@@ -13,7 +13,7 @@ export { dispatch, buildCommand, detectRuntime, compressResult, dispatchDualBrai
 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, ensurePersistence, syncSessionMirror } 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/session.mjs

@@ -740,6 +740,287 @@ export function syncSessionMirror(cwd = process.cwd()) {
   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');