@swarmify/agents-cli 1.11.3 → 1.13.0

package/dist/lib/session/discover.js

@@ -1,3 +1,11 @@
+/**
+ * Session discovery across Claude, Codex, Gemini, OpenCode, and OpenClaw.
+ *
+ * Performs incremental scans: each agent's session files are stat'd and compared
+ * to a scan-stamp ledger in SQLite. Only files whose mtime or size changed since
+ * the last run are re-parsed. All metadata is upserted into the sessions DB so
+ * subsequent queries are served entirely from the cache.
+ */
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
@@ -8,79 +16,72 @@ import { AGENTS, getCliVersion } from '../agents.js';
 import { getConfigSymlinkVersion } from '../shims.js';
 import { SESSION_AGENTS } from './types.js';
 import { extractSessionTopic } from './prompt.js';
+import { getDB, getScanStampByPath, getScanStampsForPaths, recordScans, syncLabels, upsertSessionsBatch, querySessions, countSessions, ftsSearch, } from './db.js';
 const HOME = os.homedir();
 const AGENTS_DIR = path.join(HOME, '.agents');
-const SESSIONS_DIR = path.join(AGENTS_DIR, 'sessions');
-const INDEX_PATH = path.join(SESSIONS_DIR, 'index.jsonl');
-const CONTENT_INDEX_PATH = path.join(SESSIONS_DIR, 'content_index.jsonl');
+/** How long OpenClaw channel/cron snapshots stay valid before we re-shell-out. */
+const OPENCLAW_TTL_MS = 60_000;
 let cachedOpenClawWorkspaces = null;
 const cachedAgentVersions = new Map();
 /**
- * Discover sessions across all installed agents, versions, and backups.
- * Merges with a persistent index so sessions survive version removal.
- * Returns SessionMeta[] sorted by timestamp descending (most recent first).
+ * Discover sessions. Scans only files whose (mtime, size) have changed since
+ * the last run; everything else is served from the SQLite cache.
  */
 export async function discoverSessions(options) {
+    // Touch the DB so the schema is ready and connection is cached for this run.
+    getDB();
     const agents = options?.agent ? [options.agent] : SESSION_AGENTS;
-    const limit = options?.limit ?? 50;
-    const results = await Promise.all(agents.map(agent => {
+    const onProgress = options?.onProgress;
+    // Incrementally re-scan changed files across all selected agents in parallel.
+    await Promise.all(agents.map(agent => {
         switch (agent) {
-            case 'claude': return discoverClaudeSessions();
-            case 'codex': return discoverCodexSessions();
-            case 'gemini': return discoverGeminiSessions();
-            case 'opencode': return discoverOpenCodeSessions();
-            case 'openclaw': return discoverOpenClawSessions();
+            case 'claude': return scanClaudeIncremental(onProgress);
+            case 'codex': return scanCodexIncremental(onProgress);
+            case 'gemini': return scanGeminiIncremental(onProgress);
+            case 'opencode': return scanOpenCodeIncremental();
+            case 'openclaw': return scanOpenClawIncremental();
         }
     }));
-    let sessions = results.flat();
-    // Merge with persistent index (preserves sessions whose files were removed)
-    const index = loadIndex();
-    const liveIds = new Set(sessions.map(s => s.id));
-    const agentFilter = new Set(agents);
-    // Add matching index entries to display results
-    index.forEach((entry, id) => {
-        if (!liveIds.has(id) && agentFilter.has(entry.agent)) {
-            sessions.push(entry);
-        }
-    });
-    // Persist: merge live sessions into full index (don't drop unqueried agents)
-    const toSave = new Map(index);
-    for (const s of sessions) {
-        toSave.set(s.id, s);
-    }
-    saveIndex([...toSave.values()]);
-    // Build BM25 content index for all discovered sessions
-    const bm25 = buildBM25Index(sessions);
-    saveBM25Index(bm25);
+    const sessions = querySessions(buildQueryOptions(options, agents, { includeLimit: true }));
+    return sessions;
+}
+/**
+ * Count sessions in scope without running an incremental scan. Assumes the DB
+ * is already fresh (typically true because `discoverSessions` ran first this
+ * turn). Uses the exact same filter shape as the discover query.
+ */
+export function countSessionsInScope(options) {
+    const agents = options.agent ? [options.agent] : SESSION_AGENTS;
+    return countSessions(buildQueryOptions(options, agents, { includeLimit: false }));
+}
+/** Translate DiscoverOptions into the QueryOptions shape expected by the DB layer. */
+function buildQueryOptions(options, agents, opts) {
     const projectQuery = options?.project?.trim();
-    // Filter by project (case-insensitive substring match)
-    if (projectQuery) {
-        const query = projectQuery.toLowerCase();
-        sessions = sessions.filter(s => s.project?.toLowerCase().includes(query));
-    }
-    // Apply time range filters
-    if (options?.since || options?.until) {
-        const sinceMs = options.since ? parseTimeFilter(options.since) : 0;
-        const untilMs = options.until ? new Date(options.until).getTime() : Infinity;
-        sessions = sessions.filter(s => {
-            const ts = new Date(s.timestamp).getTime();
-            return ts >= sinceMs && ts <= untilMs;
-        });
+    const sinceMs = options?.since ? parseTimeFilter(options.since) : undefined;
+    const untilMs = options?.until ? new Date(options.until).getTime() : undefined;
+    let cwdFilter;
+    let cwdPrefixFilter;
+    if (options?.cwdPrefix) {
+        cwdPrefixFilter = normalizeCwd(options.cwdPrefix);
     }
-    // An explicit project search should scan across directories instead of
-    // intersecting with the default cwd-only scope.
-    if (!options?.all && !projectQuery) {
-        const currentDir = normalizeCwd(options?.cwd || process.cwd());
-        sessions = sessions.filter(s => normalizeCwd(s.cwd) === currentDir);
+    else if (!options?.all && !projectQuery) {
+        cwdFilter = normalizeCwd(options?.cwd || process.cwd());
     }
-    // Sort by timestamp descending
-    sessions.sort((a, b) => {
-        const ta = new Date(a.timestamp).getTime() || 0;
-        const tb = new Date(b.timestamp).getTime() || 0;
-        return tb - ta;
-    });
-    return sessions.slice(0, limit);
+    return {
+        agent: options?.agent,
+        agents: options?.agent ? undefined : agents,
+        version: options?.version,
+        cwd: cwdFilter,
+        cwdPrefix: cwdPrefixFilter,
+        project: projectQuery,
+        sinceMs,
+        untilMs: Number.isFinite(untilMs) ? untilMs : undefined,
+        limit: opts.includeLimit ? (options?.limit ?? 50) : undefined,
+        excludeTeamOrigin: options?.excludeTeamOrigin,
+        onlyTeamOrigin: options?.onlyTeamOrigin,
+    };
 }
+/** Resolve and canonicalize a working directory path (follows symlinks). */
 function normalizeCwd(cwd) {
     if (!cwd)
         return '';
@@ -88,195 +89,76 @@ function normalizeCwd(cwd) {
     return safeRealpathSync(resolved) || resolved;
 }
 /**
- * Resolve a session by full or short ID from the full index.
+ * Resolve a session by full or short ID. Accepts a pre-loaded session list
+ * (fast path from discoverSessions) and falls back to a DB lookup for the
+ * "I only know the id" case.
  */
 export function resolveSessionById(sessions, idQuery) {
     const query = idQuery.toLowerCase();
-    // Exact match first (full id or shortId)
     const exact = sessions.filter(s => s.id.toLowerCase() === query || s.shortId.toLowerCase() === query);
     if (exact.length > 0)
         return exact;
-    // Prefix match (against both id and shortId)
     return sessions.filter(s => s.id.toLowerCase().startsWith(query) || s.shortId.toLowerCase().startsWith(query));
 }
 // ---------------------------------------------------------------------------
-// Persistent session index
+// Content-index search (FTS5-backed)
 // ---------------------------------------------------------------------------
-function loadIndex() {
-    const map = new Map();
-    if (!fs.existsSync(INDEX_PATH))
-        return map;
-    try {
-        const content = fs.readFileSync(INDEX_PATH, 'utf-8');
-        for (const line of content.split('\n')) {
-            if (!line.trim())
-                continue;
-            try {
-                const entry = JSON.parse(line);
-                if (entry.id)
-                    map.set(entry.id, entry);
-            }
-            catch { /* malformed index entry, skip */ }
-        }
-    }
-    catch (err) {
-        console.error(`Warning: Could not load session cache (${err.message}). Rebuilding...`);
-    }
-    return map;
-}
-function saveIndex(sessions) {
-    try {
-        fs.mkdirSync(SESSIONS_DIR, { recursive: true });
-        // Deduplicate by id, keeping the first occurrence (live sessions take priority)
-        const seen = new Set();
-        const lines = [];
-        for (const s of sessions) {
-            if (seen.has(s.id))
-                continue;
-            seen.add(s.id);
-            lines.push(JSON.stringify(s));
-        }
-        fs.writeFileSync(INDEX_PATH, lines.join('\n') + '\n', 'utf-8');
-    }
-    catch (err) {
-        console.error(`Warning: Could not save session cache: ${err.message}`);
+/**
+ * Run an FTS5 search over the DB and intersect with the given session list,
+ * preserving the existing SessionMeta[] contract so sessions.ts is unchanged.
+ */
+export function searchContentIndex(sessions, query) {
+    if (!query.trim())
+        return new Map();
+    const hits = ftsSearch(query);
+    if (hits.length === 0)
+        return new Map();
+    const byId = new Map(sessions.map(s => [s.id, s]));
+    const result = new Map();
+    for (const hit of hits) {
+        const session = byId.get(hit.sessionId);
+        if (!session)
+            continue;
+        result.set(hit.sessionId, {
+            ...session,
+            _matchedTerms: hit.matchedTerms,
+            _bm25Score: hit.score,
+        });
     }
+    return result;
 }
 // ---------------------------------------------------------------------------
-// BM25 content index
+// Incremental scan orchestration
 // ---------------------------------------------------------------------------
-const BM25_K1 = 1.2;
-const BM25_B = 0.75;
-const BM25_INDEX_VERSION = 2;
-function tokenizeCounted(text) {
-    const counts = new Map();
-    let length = 0;
-    const raw = text.toLowerCase().split(/[^a-z0-9]+/);
-    for (const token of raw) {
-        if (token.length < 2)
+/**
+ * For a list of files, stat each, compare to the DB ledger, and return only
+ * the ones that need rescanning. One bulk DB query for the whole list.
+ */
+function filterChangedFiles(filePaths) {
+    const ledger = getScanStampsForPaths(filePaths);
+    const out = [];
+    for (const filePath of filePaths) {
+        const stat = safeStatSync(filePath);
+        if (!stat)
             continue;
-        length++;
-        counts.set(token, (counts.get(token) ?? 0) + 1);
-    }
-    return { length, counts };
-}
-function collectSessionText(s) {
-    const parts = [];
-    if (s.topic)
-        parts.push(s.topic);
-    if (s.project)
-        parts.push(s.project);
-    if (s.cwd)
-        parts.push(s.cwd);
-    if (s.gitBranch)
-        parts.push(s.gitBranch);
-    if (s.account)
-        parts.push(s.account);
-    if (s._userTerms)
-        parts.push(s._userTerms.join('\n'));
-    return parts.join('\n');
-}
-export function buildBM25Index(sessions) {
-    const docLengths = new Map();
-    const postings = new Map();
-    let totalLength = 0;
-    for (const session of sessions) {
-        const { length, counts } = tokenizeCounted(collectSessionText(session));
-        docLengths.set(session.id, length);
-        totalLength += length;
-        for (const [term, tf] of counts) {
-            let termPostings = postings.get(term);
-            if (!termPostings) {
-                termPostings = new Map();
-                postings.set(term, termPostings);
-            }
-            termPostings.set(session.id, tf);
-        }
-    }
-    const N = sessions.length;
-    const avgdl = N > 0 ? totalLength / N : 0;
-    return { N, avgdl, docLengths, postings };
-}
-function saveBM25Index(index) {
-    try {
-        fs.mkdirSync(SESSIONS_DIR, { recursive: true });
-        const lines = [];
-        lines.push(JSON.stringify({ v: BM25_INDEX_VERSION, N: index.N, avgdl: index.avgdl }));
-        for (const [sid, len] of index.docLengths) {
-            lines.push(JSON.stringify({ d: sid, l: len }));
-        }
-        for (const [term, termPostings] of index.postings) {
-            const p = [];
-            for (const [sid, tf] of termPostings)
-                p.push([sid, tf]);
-            lines.push(JSON.stringify({ t: term, p }));
-        }
-        fs.writeFileSync(CONTENT_INDEX_PATH, lines.join('\n') + '\n', 'utf-8');
-    }
-    catch { /* non-fatal */ }
-}
-function loadBM25Index() {
-    if (!fs.existsSync(CONTENT_INDEX_PATH))
-        return null;
-    let content;
-    try {
-        content = fs.readFileSync(CONTENT_INDEX_PATH, 'utf-8');
-    }
-    catch {
-        return null;
-    }
-    const lines = content.split('\n').filter(l => l.trim());
-    if (lines.length === 0)
-        return null;
-    let header;
-    try {
-        header = JSON.parse(lines[0]);
-    }
-    catch {
-        return null;
-    }
-    if (header?.v !== BM25_INDEX_VERSION)
-        return null;
-    const index = {
-        N: Number(header.N) || 0,
-        avgdl: Number(header.avgdl) || 0,
-        docLengths: new Map(),
-        postings: new Map(),
-    };
-    for (let i = 1; i < lines.length; i++) {
-        let entry;
-        try {
-            entry = JSON.parse(lines[i]);
-        }
-        catch {
+        const scan = {
+            fileMtimeMs: Math.floor(stat.mtimeMs),
+            fileSize: stat.size,
+        };
+        const prev = ledger.get(filePath);
+        if (prev && prev.fileMtimeMs === scan.fileMtimeMs && prev.fileSize === scan.fileSize) {
             continue;
         }
-        if (typeof entry.d === 'string' && typeof entry.l === 'number') {
-            index.docLengths.set(entry.d, entry.l);
-        }
-        else if (typeof entry.t === 'string' && Array.isArray(entry.p)) {
-            const termPostings = new Map();
-            for (const pair of entry.p) {
-                if (Array.isArray(pair) && pair.length >= 2) {
-                    termPostings.set(String(pair[0]), Number(pair[1]));
-                }
-            }
-            index.postings.set(entry.t, termPostings);
-        }
+        out.push({ filePath, scan });
     }
-    return index;
+    return out;
 }
 // ---------------------------------------------------------------------------
 // Multi-version directory scanning
 // ---------------------------------------------------------------------------
 /**
- * Collect all directories to scan for an agent's sessions.
- * Scans: active config dir, all installed version homes, and backups.
- * Deduplicates by realpath to avoid double-counting the active symlink.
- *
- * @param agent - Agent name (claude, codex, gemini)
- * @param subdir - Subdirectory within the agent's config dir where sessions live
- *                 (e.g., 'projects' for Claude, 'sessions' for Codex, 'tmp' for Gemini)
+ * Collect all directories to scan for an agent's sessions. Deduplicates by
+ * realpath to avoid double-counting symlinked version homes.
  */
 export function getAgentSessionDirs(agent, subdir) {
     const resolved = new Set();
@@ -291,9 +173,7 @@ export function getAgentSessionDirs(agent, subdir) {
         resolved.add(key);
         dirs.push(dir);
     }
-    // 1. Active config (may be a symlink to the current version's home)
     addDir(path.join(HOME, `.${agent}`, subdir));
-    // 2. All installed version homes
     const versionsBase = path.join(AGENTS_DIR, 'versions', agent);
     if (fs.existsSync(versionsBase)) {
         try {
@@ -301,9 +181,8 @@ export function getAgentSessionDirs(agent, subdir) {
                 addDir(path.join(versionsBase, version, 'home', `.${agent}`, subdir));
             }
         }
-        catch { /* dir unreadable or missing */ }
+        catch { /* dir unreadable */ }
     }
-    // 3. Backups (from before version management was enabled)
     const backupsBase = path.join(AGENTS_DIR, 'backups', agent);
     if (fs.existsSync(backupsBase)) {
         try {
@@ -311,7 +190,7 @@ export function getAgentSessionDirs(agent, subdir) {
                 addDir(path.join(backupsBase, ts, subdir));
             }
         }
-        catch { /* dir unreadable or missing */ }
+        catch { /* dir unreadable */ }
     }
     return dirs;
 }
@@ -319,18 +198,22 @@ export function getAgentSessionDirs(agent, subdir) {
 // Claude account info
 // ---------------------------------------------------------------------------
 let cachedClaudeAccount;
+/** Read the Claude OAuth account email from .claude.json across all version homes. */
 function getClaudeAccount() {
     if (cachedClaudeAccount !== undefined)
         return cachedClaudeAccount || undefined;
-    // Check all possible locations for .claude.json
+    // Claude's active config lives at $CLAUDE_CONFIG_DIR/.claude.json; for our shim
+    // that's <version>/home/.claude/.claude.json. The home-level .claude.json is a
+    // legacy path used when Claude runs without CLAUDE_CONFIG_DIR set.
     const candidates = [
+        path.join(HOME, '.claude', '.claude.json'),
         path.join(HOME, '.claude.json'),
     ];
-    // Also check version homes (auth files are symlinked there)
     const versionsBase = path.join(AGENTS_DIR, 'versions', 'claude');
     if (fs.existsSync(versionsBase)) {
         try {
             for (const version of fs.readdirSync(versionsBase)) {
+                candidates.push(path.join(versionsBase, version, 'home', '.claude', '.claude.json'));
                 candidates.push(path.join(versionsBase, version, 'home', '.claude.json'));
             }
         }
@@ -355,11 +238,50 @@ function getClaudeAccount() {
 // ---------------------------------------------------------------------------
 // Claude
 // ---------------------------------------------------------------------------
-async function discoverClaudeSessions() {
-    const sessions = [];
-    const seen = new Set();
+/**
+ * Build a map of Claude sessionId -> user-given label from ~/.claude/sessions/*.json.
+ * Each JSON has shape { pid, sessionId, cwd, startedAt, name?, ... }. The
+ * `name` field only exists if the user ran /rename in that session.
+ * For sessionId collisions (re-resume of the same session), prefer the most
+ * recent startedAt.
+ */
+function buildClaudeLabelMap() {
+    const map = new Map();
+    const dir = path.join(HOME, '.claude', 'sessions');
+    if (!fs.existsSync(dir))
+        return new Map();
+    let files;
+    try {
+        files = fs.readdirSync(dir).filter(f => f.endsWith('.json'));
+    }
+    catch {
+        return new Map();
+    }
+    for (const f of files) {
+        try {
+            const data = JSON.parse(fs.readFileSync(path.join(dir, f), 'utf-8'));
+            if (typeof data.sessionId !== 'string')
+                continue;
+            const name = typeof data.name === 'string' && data.name.trim() ? data.name.trim() : null;
+            const startedAt = typeof data.startedAt === 'number' ? data.startedAt : 0;
+            const existing = map.get(data.sessionId);
+            if (!existing || startedAt > existing.startedAt) {
+                map.set(data.sessionId, { label: name, startedAt });
+            }
+        }
+        catch { /* unreadable session metadata file */ }
+    }
+    const out = new Map();
+    for (const [sid, { label }] of map)
+        out.set(sid, label);
+    return out;
+}
+/** Incrementally re-scan changed Claude session files and upsert into the DB. */
+async function scanClaudeIncremental(onProgress) {
     const account = getClaudeAccount();
-    let skipped = 0;
+    const labelMap = buildClaudeLabelMap();
+    const filePaths = [];
+    const seen = new Set();
     for (const projectsDir of getAgentSessionDirs('claude', 'projects')) {
         let projectDirs;
         try {
@@ -385,28 +307,50 @@ async function discoverClaudeSessions() {
                 if (seen.has(sessionId))
                     continue;
                 seen.add(sessionId);
-                const filePath = path.join(dirPath, file);
-                try {
-                    const meta = await readClaudeMeta(filePath, sessionId, account);
-                    if (meta)
-                        sessions.push(meta);
+                filePaths.push(path.join(dirPath, file));
+            }
+        }
+    }
+    const changed = filterChangedFiles(filePaths);
+    if (changed.length > 0) {
+        onProgress?.({ agent: 'claude', parsed: 0, total: changed.length });
+        const entries = [];
+        const touched = [];
+        let parsed = 0;
+        for (const { filePath, scan } of changed) {
+            try {
+                const sessionId = path.basename(filePath).replace('.jsonl', '');
+                const label = labelMap.get(sessionId) ?? undefined;
+                const result = await readClaudeMeta(filePath, sessionId, account, label);
+                if (result) {
+                    entries.push({ meta: result.meta, content: result.content, scan });
                 }
-                catch {
-                    skipped++;
+                else {
+                    touched.push({ filePath, scan });
                 }
             }
+            catch {
+                touched.push({ filePath, scan });
+            }
+            parsed++;
+            onProgress?.({ agent: 'claude', parsed, total: changed.length });
         }
+        upsertSessionsBatch(entries);
+        recordScans(touched);
     }
-    if (skipped > 0 && process.env.AGENTS_DEBUG) {
-        console.error(`[debug] Skipped ${skipped} unreadable Claude session(s)`);
-    }
-    return sessions;
+    // Pick up /rename changes on sessions whose JSONL didn't change.
+    // Only bother for sessions we actually have a Claude row for.
+    if (labelMap.size > 0)
+        syncLabels(labelMap);
 }
-async function readClaudeMeta(filePath, sessionId, account) {
+/** Stream-parse a single Claude JSONL file to extract session metadata. */
+async function readClaudeMeta(filePath, sessionId, account, label) {
     const scan = await scanClaudeSession(filePath);
+    const isTeamOrigin = scan.entrypoint === 'sdk-cli';
+    let meta;
     if (scan.timestamp) {
-        const cwd = scan.cwd || '';
-        return {
+        const cwd = normalizeCwd(scan.cwd || '');
+        meta = {
             id: sessionId,
             shortId: sessionId.slice(0, 8),
             agent: 'claude',
@@ -418,37 +362,39 @@ async function readClaudeMeta(filePath, sessionId, account) {
             version: scan.version,
             account,
             topic: scan.topic,
+            label,
             messageCount: scan.messageCount,
             tokenCount: scan.tokenCount,
-            _userTerms: scan.userTerms?.flatMap(splitLines),
+            isTeamOrigin,
         };
     }
-    // Fallback: use file mtime
-    const stat = safeStatSync(filePath);
-    return {
-        id: sessionId,
-        shortId: sessionId.slice(0, 8),
-        agent: 'claude',
-        timestamp: stat ? stat.mtime.toISOString() : new Date().toISOString(),
-        filePath,
-        account,
-        messageCount: scan.messageCount,
-        tokenCount: scan.tokenCount,
-        topic: scan.topic,
-        _userTerms: scan.userTerms?.flatMap(splitLines),
-    };
+    else {
+        const stat = safeStatSync(filePath);
+        meta = {
+            id: sessionId,
+            shortId: sessionId.slice(0, 8),
+            agent: 'claude',
+            timestamp: stat ? stat.mtime.toISOString() : new Date().toISOString(),
+            filePath,
+            account,
+            label,
+            messageCount: scan.messageCount,
+            tokenCount: scan.tokenCount,
+            topic: scan.topic,
+            isTeamOrigin,
+        };
+    }
+    return { meta, content: scan.contentText || '' };
 }
 // ---------------------------------------------------------------------------
 // Codex account info
 // ---------------------------------------------------------------------------
 let cachedCodexAccount;
+/** Extract the Codex account email from the JWT id_token in auth.json. */
 function getCodexAccount() {
     if (cachedCodexAccount !== undefined)
         return cachedCodexAccount || undefined;
-    const candidates = [
-        path.join(HOME, '.codex', 'auth.json'),
-    ];
-    // Also check version homes
+    const candidates = [path.join(HOME, '.codex', 'auth.json')];
     const versionsBase = path.join(AGENTS_DIR, 'versions', 'codex');
     if (fs.existsSync(versionsBase)) {
         try {
@@ -463,7 +409,6 @@ function getCodexAccount() {
             if (!fs.existsSync(candidate))
                 continue;
             const data = JSON.parse(fs.readFileSync(candidate, 'utf-8'));
-            // Extract email from JWT id_token payload
             const idToken = data.tokens?.id_token;
             if (idToken) {
                 const parts = idToken.split('.');
@@ -484,39 +429,53 @@ function getCodexAccount() {
 // ---------------------------------------------------------------------------
 // Codex
 // ---------------------------------------------------------------------------
-async function discoverCodexSessions() {
-    const sessions = [];
-    const seen = new Set();
+/** Incrementally re-scan changed Codex session files and upsert into the DB. */
+async function scanCodexIncremental(onProgress) {
     const account = getCodexAccount();
     const currentVersion = await getCurrentAgentVersion('codex');
-    let skipped = 0;
+    const filePaths = [];
     for (const sessionsDir of getAgentSessionDirs('codex', 'sessions')) {
-        const jsonlFiles = walkForFiles(sessionsDir, '.jsonl', 200);
-        for (const filePath of jsonlFiles) {
-            try {
-                const meta = await readCodexMeta(filePath, account, currentVersion);
-                if (meta && !seen.has(meta.id)) {
-                    seen.add(meta.id);
-                    sessions.push(meta);
-                }
+        // High limit: we only stat files here, parsing is gated by ledger match.
+        for (const fp of walkForFiles(sessionsDir, '.jsonl', 100_000)) {
+            filePaths.push(fp);
+        }
+    }
+    const changed = filterChangedFiles(filePaths);
+    if (changed.length === 0)
+        return;
+    onProgress?.({ agent: 'codex', parsed: 0, total: changed.length });
+    const entries = [];
+    const touched = [];
+    const seen = new Set();
+    let parsed = 0;
+    for (const { filePath, scan } of changed) {
+        try {
+            const result = await readCodexMeta(filePath, account, currentVersion);
+            if (result && !seen.has(result.meta.id)) {
+                seen.add(result.meta.id);
+                entries.push({ meta: result.meta, content: result.content, scan });
             }
-            catch {
-                skipped++;
+            else {
+                touched.push({ filePath, scan });
             }
         }
+        catch {
+            touched.push({ filePath, scan });
+        }
+        parsed++;
+        onProgress?.({ agent: 'codex', parsed, total: changed.length });
     }
-    if (skipped > 0 && process.env.AGENTS_DEBUG) {
-        console.error(`[debug] Skipped ${skipped} unreadable Codex session(s)`);
-    }
-    return sessions;
+    upsertSessionsBatch(entries);
+    recordScans(touched);
 }
+/** Stream-parse a single Codex JSONL file to extract session metadata. */
 async function readCodexMeta(filePath, account, currentVersion) {
     const scan = await scanCodexSession(filePath);
     const sessionId = scan.sessionId || '';
     if (!sessionId)
         return null;
-    const cwd = scan.cwd || '';
-    return {
+    const cwd = normalizeCwd(scan.cwd || '');
+    const meta = {
         id: sessionId,
         shortId: sessionId.slice(0, 8),
         agent: 'codex',
@@ -530,18 +489,17 @@ async function readCodexMeta(filePath, account, currentVersion) {
         messageCount: scan.messageCount,
         tokenCount: scan.tokenCount,
         account,
-        _userTerms: scan.userTerms?.flatMap(splitLines),
     };
+    return { meta, content: scan.contentText || '' };
 }
 // ---------------------------------------------------------------------------
 // Gemini
 // ---------------------------------------------------------------------------
-async function discoverGeminiSessions() {
-    const projectMap = buildGeminiProjectMap();
-    const sessions = [];
-    const seen = new Set();
+/** Incrementally re-scan changed Gemini session files and upsert into the DB. */
+async function scanGeminiIncremental(onProgress) {
     const currentVersion = await getCurrentAgentVersion('gemini');
-    let skipped = 0;
+    const projectMap = buildGeminiProjectMap();
+    const filePaths = [];
     for (const tmpDir of getAgentSessionDirs('gemini', 'tmp')) {
         let hashDirs;
         try {
@@ -562,25 +520,44 @@ async function discoverGeminiSessions() {
                 continue;
             }
             for (const file of chatFiles) {
-                const filePath = path.join(chatsDir, file);
-                try {
-                    const meta = readGeminiMeta(filePath, hashDir, projectMap, currentVersion);
-                    if (meta && !seen.has(meta.id)) {
-                        seen.add(meta.id);
-                        sessions.push(meta);
-                    }
-                }
-                catch {
-                    skipped++;
-                }
+                filePaths.push({ filePath: path.join(chatsDir, file), hashDir });
             }
         }
     }
-    if (skipped > 0 && process.env.AGENTS_DEBUG) {
-        console.error(`[debug] Skipped ${skipped} unreadable Gemini session(s)`);
+    const changedPaths = filterChangedFiles(filePaths.map(f => f.filePath));
+    const changedByPath = new Map(changedPaths.map(c => [c.filePath, c.scan]));
+    if (changedByPath.size === 0)
+        return;
+    onProgress?.({ agent: 'gemini', parsed: 0, total: changedByPath.size });
+    const entries = [];
+    const touched = [];
+    const seen = new Set();
+    let parsed = 0;
+    for (const { filePath, hashDir } of filePaths) {
+        const scan = changedByPath.get(filePath);
+        if (!scan)
+            continue;
+        try {
+            const result = readGeminiMeta(filePath, hashDir, projectMap, currentVersion);
+            if (result && !seen.has(result.meta.id)) {
+                seen.add(result.meta.id);
+                entries.push({ meta: result.meta, content: result.content, scan });
+            }
+            else {
+                // Gemini file without a sessionId — record scan so we don't re-parse it next run.
+                touched.push({ filePath, scan });
+            }
+        }
+        catch {
+            touched.push({ filePath, scan });
+        }
+        parsed++;
+        onProgress?.({ agent: 'gemini', parsed, total: changedByPath.size });
     }
-    return sessions;
+    upsertSessionsBatch(entries);
+    recordScans(touched);
 }
+/** Parse a single Gemini JSON session file to extract session metadata. */
 function readGeminiMeta(filePath, hashDir, projectMap, currentVersion) {
     let session;
     try {
@@ -599,23 +576,22 @@ function readGeminiMeta(filePath, hashDir, projectMap, currentVersion) {
             : undefined;
     if (!sessionId)
         return null;
-    // Resolve project name from hash
     const projectInfo = projectMap.get(projectHash || hashDir);
     const project = projectInfo?.name || hashDir.slice(0, 12);
-    const cwd = projectInfo?.path;
+    const cwd = projectInfo?.path ? normalizeCwd(projectInfo.path) : undefined;
     const stat = safeStatSync(filePath);
     const messages = Array.isArray(session.messages) ? session.messages : [];
     let topic;
     let messageCount = 0;
     let tokenCount = 0;
     let sawTokenCount = false;
-    const userTerms = [];
+    const userTexts = [];
     for (const message of messages) {
         if (message.type === 'user') {
             const text = extractGeminiMessageText(message.content);
             if (text) {
                 messageCount++;
-                userTerms.push(text);
+                userTexts.push(text);
                 if (!topic)
                     topic = extractSessionTopic(text);
             }
@@ -631,7 +607,7 @@ function readGeminiMeta(filePath, hashDir, projectMap, currentVersion) {
             sawTokenCount = true;
         }
     }
-    return {
+    const meta = {
         id: sessionId,
         shortId: sessionId.slice(0, 8),
         agent: 'gemini',
@@ -643,40 +619,37 @@ function readGeminiMeta(filePath, hashDir, projectMap, currentVersion) {
         topic,
         messageCount,
         tokenCount: sawTokenCount ? tokenCount : undefined,
-        _userTerms: userTerms.length > 0 ? userTerms : undefined,
     };
+    return { meta, content: userTexts.join('\n') };
 }
+/** Build a hash-to-project mapping from Gemini's projects.json and history directories. */
 function buildGeminiProjectMap() {
     const map = new Map();
     const projectsJsonPath = path.join(HOME, '.gemini', 'projects.json');
-    if (!fs.existsSync(projectsJsonPath))
-        return map;
-    try {
-        const data = JSON.parse(fs.readFileSync(projectsJsonPath, 'utf-8'));
-        const projects = data.projects;
-        if (typeof projects === 'object' && projects !== null) {
-            if (Array.isArray(projects)) {
-                // Array format: ["path1", "path2"]
-                for (const p of projects) {
-                    if (typeof p === 'string') {
-                        const hash = sha256(p);
-                        map.set(hash, { name: path.basename(p), path: p });
-                        // Also try the raw directory name
-                        map.set(p, { name: path.basename(p), path: p });
+    if (fs.existsSync(projectsJsonPath)) {
+        try {
+            const data = JSON.parse(fs.readFileSync(projectsJsonPath, 'utf-8'));
+            const projects = data.projects;
+            if (typeof projects === 'object' && projects !== null) {
+                if (Array.isArray(projects)) {
+                    for (const p of projects) {
+                        if (typeof p === 'string') {
+                            const hash = sha256(p);
+                            map.set(hash, { name: path.basename(p), path: p });
+                            map.set(p, { name: path.basename(p), path: p });
+                        }
                     }
                 }
-            }
-            else {
-                // Object format: {path: name}
-                for (const [p, name] of Object.entries(projects)) {
-                    const hash = sha256(p);
-                    map.set(hash, { name: String(name), path: p });
+                else {
+                    for (const [p, name] of Object.entries(projects)) {
+                        const hash = sha256(p);
+                        map.set(hash, { name: String(name), path: p });
+                    }
                 }
             }
         }
+        catch { /* projects.json missing or malformed */ }
     }
-    catch { /* projects.json missing or malformed */ }
-    // Also check ~/.gemini/history/*/.project_root for additional mappings
     const historyDir = path.join(HOME, '.gemini', 'history');
     if (fs.existsSync(historyDir)) {
         try {
@@ -703,10 +676,10 @@ function buildGeminiProjectMap() {
 // ---------------------------------------------------------------------------
 const OPENCODE_DB = path.join(HOME, '.local', 'share', 'opencode', 'opencode.db');
 let cachedOpenCodeAccount;
+/** Query the active OpenCode account email from its SQLite database. */
 function getOpenCodeAccount() {
     if (cachedOpenCodeAccount !== undefined)
         return cachedOpenCodeAccount || undefined;
-    // Try control_account table in the DB
     try {
         if (fs.existsSync(OPENCODE_DB)) {
             const out = execSync(`sqlite3 "${OPENCODE_DB}" "SELECT email FROM control_account WHERE active=1 LIMIT 1;"`, { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
@@ -720,14 +693,26 @@ function getOpenCodeAccount() {
     cachedOpenCodeAccount = '';
     return undefined;
 }
-async function discoverOpenCodeSessions() {
+/** Scan OpenCode sessions from its SQLite database when the DB file has changed. */
+async function scanOpenCodeIncremental() {
     if (!fs.existsSync(OPENCODE_DB))
-        return [];
+        return;
+    const stat = safeStatSync(OPENCODE_DB);
+    if (!stat)
+        return;
+    // OpenCode is one big DB; we use its mtime/size as the ledger for the
+    // entire fleet of OpenCode sessions.
+    const currentScan = {
+        fileMtimeMs: Math.floor(stat.mtimeMs),
+        fileSize: stat.size,
+    };
+    const prev = getScanStampByPath(OPENCODE_DB);
+    if (prev && prev.fileMtimeMs === currentScan.fileMtimeMs && prev.fileSize === currentScan.fileSize) {
+        return;
+    }
     const account = getOpenCodeAccount();
     const currentVersion = await getCurrentAgentVersion('opencode');
     try {
-        // Query sessions. time_created is millisecond epoch. Limit to 200 most recent.
-        // Use session.title as topic (OpenCode auto-generates good titles).
         const query = `
       SELECT
         s.id,
@@ -756,10 +741,10 @@ async function discoverOpenCodeSessions() {
       ) stats ON stats.session_id = s.id
       WHERE s.parent_id IS NULL
       ORDER BY time_created DESC
-      LIMIT 200;
+      LIMIT 1000;
     `.replace(/\n/g, ' ');
         const out = execSync(`sqlite3 -separator '|||' "${OPENCODE_DB}"`, { encoding: 'utf-8', input: query, stdio: ['pipe', 'pipe', 'ignore'], timeout: 5000 });
-        const sessions = [];
+        const entries = [];
         for (const line of out.split('\n')) {
             if (!line.trim())
                 continue;
@@ -772,118 +757,128 @@ async function discoverOpenCodeSessions() {
             const hasTokenData = hasTokenDataStr === '1';
             const timestamp = isNaN(timeCreated) ? new Date().toISOString() : new Date(timeCreated).toISOString();
             const topic = title || undefined;
-            sessions.push({
+            const meta = {
                 id,
                 shortId: id.replace(/^ses_/, '').slice(0, 8),
                 agent: 'opencode',
                 timestamp,
                 project: directory ? path.basename(directory) : undefined,
-                cwd: directory || undefined,
+                cwd: directory ? normalizeCwd(directory) : undefined,
                 filePath: `${OPENCODE_DB}#${id}`,
                 version: resolveSessionVersion('opencode', OPENCODE_DB, version || undefined, currentVersion),
                 account,
                 topic,
                 messageCount: Number.isNaN(messageCount) ? undefined : messageCount,
                 tokenCount: hasTokenData && !Number.isNaN(tokenCount) ? tokenCount : undefined,
-            });
+            };
+            entries.push({ meta, content: topic || '', scan: currentScan });
         }
-        return sessions;
+        upsertSessionsBatch(entries);
+        // Stamp the OpenCode DB itself so we can short-circuit on the next run.
+        recordScans([{ filePath: OPENCODE_DB, scan: currentScan }]);
     }
     catch (err) {
         if (process.stderr.isTTY) {
             console.error(`Warning: Could not query OpenCode sessions: ${err.message}`);
         }
-        return [];
     }
 }
 // ---------------------------------------------------------------------------
 // OpenClaw
 // ---------------------------------------------------------------------------
-async function discoverOpenClawSessions() {
-    const sessions = [];
-    // Check if openclaw is installed
+/** Scan active OpenClaw channels and cron jobs via the openclaw CLI. */
+async function scanOpenClawIncremental() {
+    // Check if openclaw is installed — silently skip if not.
     try {
         execSync('which openclaw', { stdio: 'ignore' });
     }
     catch {
-        return sessions;
+        return;
+    }
+    // TTL cache: skip subprocess calls if we scanned recently. Stored in the
+    // meta table so we skip even when no channels/cron exist to produce rows.
+    const db = getDB();
+    const row = db.prepare(`SELECT value FROM meta WHERE key = 'openclaw_last_scan_ms'`).get();
+    const lastScanMs = row ? parseInt(row.value, 10) : 0;
+    if (lastScanMs && Date.now() - lastScanMs < OPENCLAW_TTL_MS) {
+        return;
     }
     const currentVersion = await getCurrentAgentVersion('openclaw');
-    // Discover active channels
-    // Format: "- Telegram default (Jeff): enabled, configured, running, out:2h ago, mode:polling, token:config"
+    const now = Date.now();
+    const scan = { fileMtimeMs: now, fileSize: 0 };
+    const entries = [];
     try {
         const output = execSync('openclaw channels status', {
             encoding: 'utf-8',
             stdio: ['ignore', 'pipe', 'ignore'],
         });
         for (const line of output.split('\n')) {
-            // Match: "- Telegram <agentId> (<Name>): ..., running, ..."
             const match = line.match(/^-\s+\w+\s+(\S+)\s+\((\w+)\):\s*(.+)/);
             if (!match)
                 continue;
             const [, agentId, name, statusStr] = match;
-            const isRunning = statusStr.includes('running');
-            if (!isRunning)
+            if (!statusStr.includes('running'))
                 continue;
-            sessions.push({
-                id: `openclaw-${agentId}`,
-                shortId: agentId.slice(0, 8),
-                agent: 'openclaw',
-                timestamp: new Date().toISOString(),
-                project: name,
-                cwd: getOpenClawSessionCwd(agentId),
-                version: currentVersion,
-                filePath: '',
+            entries.push({
+                meta: {
+                    id: `openclaw-${agentId}`,
+                    shortId: agentId.slice(0, 8),
+                    agent: 'openclaw',
+                    timestamp: new Date().toISOString(),
+                    project: name,
+                    cwd: getOpenClawSessionCwd(agentId),
+                    version: currentVersion,
+                    filePath: '',
+                },
+                content: `${name} ${agentId}`,
+                scan,
             });
         }
     }
     catch {
-        // Command failed or not available
+        /* channels command failed */
     }
-    // Discover cron jobs
-    // Output format (fixed-width columns, 1 space between UUID and name):
-    //   6ec2cffe-39f8-480b-821f-0b20a2062550 paul-hourly  cron */30 ...  in 7h  48m ago  ok  isolated  paul  -
-    // UUID is always 36 chars. Extract it first, then parse the rest.
     try {
         const output = execSync('openclaw cron list', {
             encoding: 'utf-8',
             stdio: ['ignore', 'pipe', 'ignore'],
         });
         const lines = output.split('\n');
-        // Skip header row
         for (let i = 1; i < lines.length; i++) {
             const line = lines[i].trim();
             if (!line)
                 continue;
-            // Extract UUID (36 chars) and name from start of line
             const headMatch = line.match(/^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\s+(\S+)/);
             if (!headMatch)
                 continue;
             const jobId = headMatch[1];
             const jobName = headMatch[2];
-            // Parse remaining columns (2+ whitespace separated)
-            // Schedule+Next merge (cron expressions have internal spaces), so cols are:
-            //   [schedule+next, last, status, target, agentId, model]
             const rest = line.slice(headMatch[0].length).trim();
             const cols = rest.split(/\s{2,}/);
             const agentId = cols[4] || '';
-            sessions.push({
-                id: `openclaw-cron-${jobId}`,
-                shortId: jobId.slice(0, 8),
-                agent: 'openclaw',
-                timestamp: new Date().toISOString(),
-                project: `${jobName} (${agentId || 'unknown'})`,
-                cwd: getOpenClawSessionCwd(agentId),
-                version: currentVersion,
-                filePath: '',
+            entries.push({
+                meta: {
+                    id: `openclaw-cron-${jobId}`,
+                    shortId: jobId.slice(0, 8),
+                    agent: 'openclaw',
+                    timestamp: new Date().toISOString(),
+                    project: `${jobName} (${agentId || 'unknown'})`,
+                    cwd: getOpenClawSessionCwd(agentId),
+                    version: currentVersion,
+                    filePath: '',
+                },
+                content: `${jobName} ${agentId}`,
+                scan,
             });
         }
     }
     catch {
-        // Command failed or not available
+        /* cron command failed */
     }
-    return sessions;
+    upsertSessionsBatch(entries);
+    db.prepare(`INSERT OR REPLACE INTO meta (key, value) VALUES ('openclaw_last_scan_ms', ?)`).run(String(Date.now()));
 }
+/** Stream a Claude JSONL file and extract scan-level metadata (timestamp, cwd, topic, tokens). */
 async function scanClaudeSession(filePath) {
     const stream = fs.createReadStream(filePath, { encoding: 'utf-8' });
     const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
@@ -892,6 +887,7 @@ async function scanClaudeSession(filePath) {
     let gitBranch;
     let version;
     let topic;
+    let entrypoint;
     let messageCount = 0;
     let tokenCount = 0;
     let sawTokenCount = false;
@@ -908,6 +904,11 @@ async function scanClaudeSession(filePath) {
             catch {
                 continue;
             }
+            // entrypoint ships on the first envelope event (attachment/user/assistant)
+            // and is the clean structural signal for "was this a team spawn?"
+            if (!entrypoint && typeof parsed.entrypoint === 'string') {
+                entrypoint = parsed.entrypoint;
+            }
             if (!timestamp && (parsed.type === 'user' || parsed.type === 'assistant') && parsed.timestamp) {
                 timestamp = parsed.timestamp;
                 cwd = parsed.cwd || '';
@@ -953,11 +954,13 @@ async function scanClaudeSession(filePath) {
         gitBranch,
         version,
         topic,
+        entrypoint,
         messageCount,
         tokenCount: sawTokenCount ? tokenCount : undefined,
-        userTerms: userTexts.length > 0 ? userTexts : undefined,
+        contentText: userTexts.length > 0 ? userTexts.join('\n') : undefined,
     };
 }
+/** Stream a Codex JSONL file and extract scan-level metadata (session ID, cwd, topic, tokens). */
 async function scanCodexSession(filePath) {
     const stream = fs.createReadStream(filePath, { encoding: 'utf-8' });
     const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
@@ -1025,9 +1028,10 @@ async function scanCodexSession(filePath) {
         topic,
         messageCount,
         tokenCount,
-        userTerms: userTexts.length > 0 ? userTexts : undefined,
+        contentText: userTexts.length > 0 ? userTexts.join('\n') : undefined,
     };
 }
+/** Resolve the working directory for an OpenClaw agent from its workspace config. */
 function getOpenClawSessionCwd(agentId) {
     const workspace = agentId ? getOpenClawWorkspaceMap().get(agentId) : undefined;
     if (workspace)
@@ -1035,6 +1039,7 @@ function getOpenClawSessionCwd(agentId) {
     const configDir = AGENTS.openclaw.configDir;
     return safeRealpathSync(configDir) || configDir;
 }
+/** Build a cached map of OpenClaw agent ID to workspace path from openclaw.json. */
 function getOpenClawWorkspaceMap() {
     if (cachedOpenClawWorkspaces)
         return cachedOpenClawWorkspaces;
@@ -1061,6 +1066,7 @@ function getOpenClawWorkspaceMap() {
 // ---------------------------------------------------------------------------
 // Utilities
 // ---------------------------------------------------------------------------
+/** Read up to maxLines non-empty lines from the beginning of a file. */
 export function readFirstLines(filePath, maxLines) {
     return new Promise((resolve) => {
         const lines = [];
@@ -1081,13 +1087,12 @@ export function readFirstLines(filePath, maxLines) {
 }
 /**
  * Walk a directory recursively for files with a given extension.
- * Returns at most `limit` files, sorted by mtime descending.
  */
 export function walkForFiles(dir, ext, limit) {
     const results = [];
     function walk(d, depth) {
         if (depth > 5)
-            return; // Prevent deep recursion
+            return;
         let entries;
         try {
             entries = fs.readdirSync(d);
@@ -1109,13 +1114,14 @@ export function walkForFiles(dir, ext, limit) {
         }
     }
     walk(dir, 0);
-    // Sort by mtime descending and limit
     results.sort((a, b) => b.mtime - a.mtime);
     return results.slice(0, limit).map(r => r.path);
 }
+/** Compute the SHA-256 hex digest of a string. */
 function sha256(input) {
     return crypto.createHash('sha256').update(input).digest('hex');
 }
+/** Stat a path, returning null on any error. */
 function safeStatSync(p) {
     try {
         return fs.statSync(p);
@@ -1124,6 +1130,7 @@ function safeStatSync(p) {
         return null;
     }
 }
+/** Resolve a path to its real path, returning null on any error. */
 function safeRealpathSync(p) {
     try {
         return fs.realpathSync(p);
@@ -1132,6 +1139,7 @@ function safeRealpathSync(p) {
         return null;
     }
 }
+/** Extract meaningful user text from a Claude JSONL user event, skipping meta and local-command messages. */
 function extractClaudeUserText(parsed) {
     if (parsed.isMeta === true)
         return undefined;
@@ -1150,12 +1158,11 @@ function extractClaudeUserText(parsed) {
         return undefined;
     return text;
 }
+/** Check whether a message is a local-command wrapper rather than real user input. */
 function isLocalCommandMessage(text) {
     return /<local-command-caveat>|<bash-(input|stdout|stderr)>/i.test(text);
 }
-function splitLines(text) {
-    return text.split('\n').map(l => l.trim()).filter(Boolean);
-}
+/** Sum all token usage fields from a Claude assistant message's usage object. */
 function getClaudeUsageTotal(usage) {
     if (!usage || typeof usage !== 'object')
         return null;
@@ -1166,6 +1173,7 @@ function getClaudeUsageTotal(usage) {
         usage.cache_read_input_tokens,
     ]);
 }
+/** Extract text from Codex message content blocks, filtering out system instructions for user messages. */
 function extractCodexMessageText(contentBlocks, role) {
     if (!Array.isArray(contentBlocks))
         return undefined;
@@ -1184,10 +1192,12 @@ function extractCodexMessageText(contentBlocks, role) {
     });
     return text || undefined;
 }
+/** Trim and normalize a version string, returning undefined for empty values. */
 function normalizeVersion(version) {
     const trimmed = version?.trim();
     return trimmed ? trimmed : undefined;
 }
+/** Extract the version number from a managed ~/.agents/versions/<agent>/<version>/... path. */
 function extractVersionFromManagedPath(agent, sourcePath) {
     if (!sourcePath)
         return undefined;
@@ -1206,6 +1216,7 @@ function extractVersionFromManagedPath(agent, sourcePath) {
     }
     return undefined;
 }
+/** Resolve the current version of an agent CLI (symlink version or live CLI output, cached). */
 async function getCurrentAgentVersion(agent) {
     const cached = cachedAgentVersions.get(agent);
     if (cached)
@@ -1219,11 +1230,13 @@ async function getCurrentAgentVersion(agent) {
     cachedAgentVersions.set(agent, promise);
     return promise;
 }
+/** Resolve a session's version: embedded in file > extracted from managed path > current CLI version. */
 function resolveSessionVersion(agent, sourcePath, embeddedVersion, currentVersion) {
     return normalizeVersion(embeddedVersion)
         || extractVersionFromManagedPath(agent, sourcePath)
         || normalizeVersion(currentVersion);
 }
+/** Sum all token usage fields from a Codex total_token_usage object. */
 function getCodexTokenCount(totalTokenUsage) {
     if (!totalTokenUsage || typeof totalTokenUsage !== 'object')
         return null;
@@ -1234,6 +1247,7 @@ function getCodexTokenCount(totalTokenUsage) {
         totalTokenUsage.reasoning_output_tokens,
     ]);
 }
+/** Extract text from a Gemini message content field (string or array of parts). */
 function extractGeminiMessageText(content) {
     if (typeof content === 'string')
         return content.trim();
@@ -1251,6 +1265,7 @@ function extractGeminiMessageText(content) {
     }
     return '';
 }
+/** Extract the total token count from a Gemini message's tokens object. */
 function getGeminiTokenCount(tokens) {
     if (!tokens || typeof tokens !== 'object')
         return null;
@@ -1264,6 +1279,7 @@ function getGeminiTokenCount(tokens) {
         tokens.tool,
     ]);
 }
+/** Sum all numeric values in an array, returning null if none are valid numbers. */
 function sumKnownNumbers(values) {
     let total = 0;
     let found = false;
@@ -1278,11 +1294,16 @@ function sumKnownNumbers(values) {
 // ---------------------------------------------------------------------------
 // Time range parsing
 // ---------------------------------------------------------------------------
+/** Parse a time filter string (relative like '7d' or ISO timestamp) into epoch milliseconds. */
 export function parseTimeFilter(input) {
-    const relativeMatch = input.match(/^(\d+)([dw])$/i);
+    const relativeMatch = input.match(/^(\d+)([mhdw])$/i);
     if (relativeMatch) {
         const value = parseInt(relativeMatch[1], 10);
         const unit = relativeMatch[2].toLowerCase();
+        if (unit === 'm')
+            return Date.now() - value * 60_000;
+        if (unit === 'h')
+            return Date.now() - value * 3_600_000;
         if (unit === 'd')
             return Date.now() - value * 86_400_000;
         if (unit === 'w')
@@ -1291,71 +1312,4 @@ export function parseTimeFilter(input) {
     const ts = new Date(input).getTime();
     return Number.isNaN(ts) ? 0 : ts;
 }
-// ---------------------------------------------------------------------------
-// BM25 content index search
-// ---------------------------------------------------------------------------
-/**
- * Pure BM25 scorer over an in-memory index. Returns sessionId -> score+matched terms,
- * sorted by score descending (Map preserves insertion order).
- */
-export function scoreBM25(index, query) {
-    const result = new Map();
-    if (index.N === 0)
-        return result;
-    const { counts: queryTerms } = tokenizeCounted(query);
-    if (queryTerms.size === 0)
-        return result;
-    const avgdl = index.avgdl || 1;
-    const scored = new Map();
-    for (const [term] of queryTerms) {
-        const termPostings = index.postings.get(term);
-        if (!termPostings)
-            continue;
-        const df = termPostings.size;
-        const idf = Math.log(1 + (index.N - df + 0.5) / (df + 0.5));
-        for (const [sessionId, tf] of termPostings) {
-            const dl = index.docLengths.get(sessionId) ?? avgdl;
-            const norm = 1 - BM25_B + BM25_B * (dl / avgdl);
-            const termScore = idf * (tf * (BM25_K1 + 1)) / (tf + BM25_K1 * norm);
-            const entry = scored.get(sessionId);
-            if (!entry) {
-                scored.set(sessionId, { score: termScore, matchedTerms: [term] });
-            }
-            else {
-                entry.score += termScore;
-                if (!entry.matchedTerms.includes(term))
-                    entry.matchedTerms.push(term);
-            }
-        }
-    }
-    const sorted = [...scored.entries()].sort((a, b) => b[1].score - a[1].score);
-    for (const [sid, info] of sorted)
-        result.set(sid, info);
-    return result;
-}
-/**
- * Score sessions using Okapi BM25 against the persisted content index.
- * Returns a Map sorted by score descending, with matched terms attached.
- */
-export function searchContentIndex(sessions, query) {
-    const index = loadBM25Index();
-    if (!index)
-        return new Map();
-    const scored = scoreBM25(index, query);
-    if (scored.size === 0)
-        return new Map();
-    const sessionsById = new Map(sessions.map(s => [s.id, s]));
-    const result = new Map();
-    for (const [sessionId, info] of scored) {
-        const session = sessionsById.get(sessionId);
-        if (session) {
-            result.set(sessionId, {
-                ...session,
-                _matchedTerms: info.matchedTerms,
-                _bm25Score: info.score,
-            });
-        }
-    }
-    return result;
-}
 //# sourceMappingURL=discover.js.map