dual-brain 7.1.11 → 7.1.13

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,60 @@ 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 daysUntil(isoDate) {
   if (!isoDate) return null;
   const ms = Date.parse(isoDate) - Date.now();
@@ -685,6 +735,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 +840,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) {
@@ -823,8 +916,55 @@ async function mainScreen(rl, ask) {
     subLine('OpenAI', openaiPlan, auth.openai.found, openaiExpired, openaiDays, openaiSub),
   ];
 
+  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)
+  const W = 37;
+  const helpTop    = `  ┌${'─'.repeat(W)}┐`;
+  const helpSep    = `  ├${'─'.repeat(W)}┤`;
+  const helpBottom = `  └${'─'.repeat(W)}┘`;
+  const helpPad = (s) => s + ' '.repeat(Math.max(0, W - s.length));
+
+  console.log(helpTop);
+  console.log(`  │ ${helpPad('At ~/workspace$ prompt:')}│`);
+  console.log(`  │ ${helpPad('db = show this menu')}│`);
+  console.log(`  │ ${helpPad('j  = login to claude')}│`);
+  console.log(`  │ ${helpPad('k  = login to codex')}│`);
+  console.log(helpSep);
+  console.log(`  │ ${helpPad('In Claude:')}│`);
+  console.log(`  │ ${helpPad('Ctrl+C x2 = back to menu')}│`);
+  console.log(`  │ ${helpPad('Ctrl+C x3 = exit to shell')}│`);
+  console.log(helpBottom);
   console.log('');
-  console.log(renderHeader(version, headerLines));
+
+  // Provider status (outside the box)
+  for (const line of headerLines) {
+    console.log(`  ${line}`);
+  }
+
+  // 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) {
@@ -860,16 +1000,41 @@ async function mainScreen(rl, ask) {
       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}`);
+      const tool = (sess.tool === 'codex') ? 'cdx' : 'cld';
+      console.log(`  [${i + 1}] ${pin}${tool}  ${sess.age.padEnd(8)} ${sess.name}${active}${cat}`);
     });
     console.log('');
   }
 
+  const brandW = 37;
+  const brandTop    = `  ┌${'─'.repeat(brandW)}┐`;
+  const brandBottom = `  └${'─'.repeat(brandW)}┘`;
+  const brandPad = (s) => {
+    const leftPad = Math.floor((brandW - s.length) / 2);
+    const rightPad = brandW - s.length - leftPad;
+    return ' '.repeat(leftPad) + s + ' '.repeat(rightPad);
+  };
+  console.log(brandTop);
+  console.log(`  │ ${brandPad('Dual Brain Session Manager')}│`);
+  console.log(`  │ ${brandPad('by Steve Moraco + dual-brain')}│`);
+  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('  [e] Manage sessions');
   console.log('  [i] Import from replit-tools');
   console.log('  [m] Manage subscriptions');
@@ -883,15 +1048,24 @@ 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' };
     }
+
     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' };
   }
 
@@ -901,6 +1075,37 @@ async function mainScreen(rl, ask) {
     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' };
   }
 
@@ -953,12 +1158,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' };
 }
 
@@ -1888,6 +2100,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 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dual-brain",
-  "version": "7.1.11",
+  "version": "7.1.13",
   "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 } 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 } 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,16 +316,122 @@ 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; }
+  }
+
+  // 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 */ }
+
+  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
+
+      bySession.set(entry.sessionId, {
+        sessionId: entry.sessionId,
+        project: entry.project,
+        entries: [],
+        firstPrompt: null,
+        lastTimestamp: 0,
+      });
+
+      const sess = bySession.get(entry.sessionId);
+      sess.entries.push(entry);
+      if (entry.timestamp > sess.lastTimestamp) sess.lastTimestamp = entry.timestamp;
+      if (!sess.firstPrompt && isRealPrompt(entry.display)) {
+        sess.firstPrompt = entry.display;
+      }
+    } 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 { continue; }
   }
 
+  // Scan ~/.codex/sessions/ for codex session JSONLs (YYYY/MM/DD tree)
+  const codexSessionsDir = join(process.env.HOME || '/root', '.codex', 'sessions');
+  if (existsSync(codexSessionsDir)) {
+    try {
+      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 f of walk(codexSessionsDir)) {
+        try {
+          const content = readFileSync(f, '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;
+          if (meta.payload.cwd !== cwd && meta.payload.cwd !== '/home/runner/workspace') continue;
+
+          const id = meta.payload.id;
+          if (bySession.has(id)) continue;
+
+          let firstPrompt = null;
+          let lastTimestamp = Date.parse(meta.payload.timestamp || meta.timestamp) / 1000;
+
+          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 (!firstPrompt && j.type === 'event_msg' && j.payload?.type === 'user_message') {
+                const text = (j.payload.message || '').trim();
+                if (text) firstPrompt = text;
+              }
+            } catch { continue; }
+          }
+
+          bySession.set(id, {
+            sessionId: id,
+            project: '-home-runner-workspace',
+            entries: [],
+            firstPrompt: firstPrompt || id.slice(0, 8) + '...',
+            lastTimestamp,
+            tool: 'codex',
+          });
+        } catch { continue; }
+      }
+    } catch { /* non-fatal */ }
+  }
+
   // Read active terminal sessions
   // Use the same root as replitBase (go up one level from .claude-persistent)
   const replitRoot = join(replitBase, '..');
@@ -325,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) {
@@ -346,6 +483,7 @@ export function importReplitSessions(cwd = process.cwd()) {
       isActive: activeSessionIds.has(id),
       source: 'replit-tools',
       age: timeAgo(sess.lastTimestamp),
+      tool: sess.tool || 'claude',
     });
   }
 
@@ -439,6 +577,169 @@ 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 };
+}
+
 // ─── CLI (direct invocation) ──────────────────────────────────────────────────
 
 const isMain = process.argv[1]?.endsWith('session.mjs');