@swarmify/agents-cli 1.10.4 → 1.11.1

package/dist/lib/session/discover.js

@@ -4,11 +4,16 @@ import * as os from 'os';
 import * as crypto from 'crypto';
 import * as readline from 'readline';
 import { execSync } from 'child_process';
+import { getCliVersion } from '../agents.js';
+import { getConfigSymlinkVersion } from '../shims.js';
 import { SESSION_AGENTS } from './types.js';
+import { extractSessionTopic } from './prompt.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');
+const cachedAgentVersions = new Map();
 /**
  * Discover sessions across all installed agents, versions, and backups.
  * Merges with a persistent index so sessions survive version removal.
@@ -43,12 +48,27 @@ export async function discoverSessions(options) {
         toSave.set(s.id, s);
     }
     saveIndex([...toSave.values()]);
+    // Build content index for all discovered sessions
+    const contentIndex = await buildContentIndex(sessions);
+    saveContentIndex(contentIndex);
+    const projectQuery = options?.project?.trim();
     // Filter by project (case-insensitive substring match)
-    if (options?.project) {
-        const query = options.project.toLowerCase();
+    if (projectQuery) {
+        const query = projectQuery.toLowerCase();
         sessions = sessions.filter(s => s.project?.toLowerCase().includes(query));
     }
-    if (!options?.all) {
+    // 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;
+        });
+    }
+    // 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);
     }
@@ -113,18 +133,7 @@ function saveIndex(sessions) {
             if (seen.has(s.id))
                 continue;
             seen.add(s.id);
-            lines.push(JSON.stringify({
-                id: s.id,
-                shortId: s.shortId,
-                agent: s.agent,
-                timestamp: s.timestamp,
-                project: s.project,
-                cwd: s.cwd,
-                filePath: s.filePath,
-                gitBranch: s.gitBranch,
-                version: s.version,
-                account: s.account,
-            }));
+            lines.push(JSON.stringify(s));
         }
         fs.writeFileSync(INDEX_PATH, lines.join('\n') + '\n', 'utf-8');
     }
@@ -133,6 +142,81 @@ function saveIndex(sessions) {
     }
 }
 // ---------------------------------------------------------------------------
+// Content index (inverted term -> session terms)
+// ---------------------------------------------------------------------------
+async function buildContentIndex(sessions) {
+    const index = new Map();
+    for (const session of sessions) {
+        const terms = extractSessionTerms(session);
+        for (const term of terms) {
+            if (!index.has(term))
+                index.set(term, new Set());
+            index.get(term).add(session.id);
+        }
+    }
+    return index;
+}
+function extractSessionTerms(session) {
+    const textParts = [];
+    if (session.topic)
+        textParts.push(session.topic);
+    if (session.project)
+        textParts.push(session.project);
+    if (session.cwd)
+        textParts.push(session.cwd);
+    if (session.gitBranch)
+        textParts.push(session.gitBranch);
+    if (session.account)
+        textParts.push(session.account);
+    if (session._userTerms)
+        textParts.push(session._userTerms.join('\n'));
+    return tokenizeText(textParts.join('\n'));
+}
+function tokenizeText(text) {
+    const seen = new Set();
+    const terms = [];
+    const tokens = text.toLowerCase().split(/[^a-z0-9]+/);
+    for (const token of tokens) {
+        if (token.length < 2 || seen.has(token))
+            continue;
+        seen.add(token);
+        terms.push(token);
+    }
+    return terms;
+}
+function saveContentIndex(index) {
+    try {
+        fs.mkdirSync(SESSIONS_DIR, { recursive: true });
+        const lines = [];
+        for (const [term, sessionIds] of index) {
+            lines.push(JSON.stringify({ term, sessions: [...sessionIds] }));
+        }
+        fs.writeFileSync(CONTENT_INDEX_PATH, lines.join('\n') + '\n', 'utf-8');
+    }
+    catch { /* index save failure is non-fatal */ }
+}
+function loadContentIndex() {
+    const index = new Map();
+    if (!fs.existsSync(CONTENT_INDEX_PATH))
+        return index;
+    try {
+        const content = fs.readFileSync(CONTENT_INDEX_PATH, 'utf-8');
+        for (const line of content.split('\n')) {
+            if (!line.trim())
+                continue;
+            try {
+                const entry = JSON.parse(line);
+                if (entry.term && entry.sessions) {
+                    index.set(entry.term, new Set(entry.sessions));
+                }
+            }
+            catch { /* malformed index entry, skip */ }
+        }
+    }
+    catch { /* index load failure is non-fatal */ }
+    return index;
+}
+// ---------------------------------------------------------------------------
 // Multi-version directory scanning
 // ---------------------------------------------------------------------------
 /**
@@ -269,41 +353,25 @@ async function discoverClaudeSessions() {
     return sessions;
 }
 async function readClaudeMeta(filePath, sessionId, account) {
-    const lines = await readFirstLines(filePath, 10);
-    let topic;
-    for (const line of lines) {
-        let parsed;
-        try {
-            parsed = JSON.parse(line);
-        }
-        catch {
-            continue;
-        }
-        // Extract topic from first user message
-        if (!topic && parsed.type === 'user' && parsed.message?.content) {
-            const text = Array.isArray(parsed.message.content)
-                ? parsed.message.content.find((b) => b.type === 'text')?.text
-                : typeof parsed.message.content === 'string' ? parsed.message.content : undefined;
-            if (text)
-                topic = extractTopic(text);
-        }
-        // Look for first user or assistant line with timestamp/cwd
-        if ((parsed.type === 'user' || parsed.type === 'assistant') && parsed.timestamp) {
-            const cwd = parsed.cwd || '';
-            return {
-                id: sessionId,
-                shortId: sessionId.slice(0, 8),
-                agent: 'claude',
-                timestamp: parsed.timestamp,
-                project: cwd ? path.basename(cwd) : undefined,
-                cwd,
-                filePath,
-                gitBranch: parsed.gitBranch || undefined,
-                version: parsed.version || undefined,
-                account,
-                topic,
-            };
-        }
+    const scan = await scanClaudeSession(filePath);
+    if (scan.timestamp) {
+        const cwd = scan.cwd || '';
+        return {
+            id: sessionId,
+            shortId: sessionId.slice(0, 8),
+            agent: 'claude',
+            timestamp: scan.timestamp,
+            project: cwd ? path.basename(cwd) : undefined,
+            cwd,
+            filePath,
+            gitBranch: scan.gitBranch,
+            version: scan.version,
+            account,
+            topic: scan.topic,
+            messageCount: scan.messageCount,
+            tokenCount: scan.tokenCount,
+            _userTerms: scan.userTerms?.flatMap(splitLines),
+        };
     }
     // Fallback: use file mtime
     const stat = safeStatSync(filePath);
@@ -314,6 +382,10 @@ async function readClaudeMeta(filePath, sessionId, account) {
         timestamp: stat ? stat.mtime.toISOString() : new Date().toISOString(),
         filePath,
         account,
+        messageCount: scan.messageCount,
+        tokenCount: scan.tokenCount,
+        topic: scan.topic,
+        _userTerms: scan.userTerms?.flatMap(splitLines),
     };
 }
 // ---------------------------------------------------------------------------
@@ -366,12 +438,13 @@ async function discoverCodexSessions() {
     const sessions = [];
     const seen = new Set();
     const account = getCodexAccount();
+    const currentVersion = await getCurrentAgentVersion('codex');
     let skipped = 0;
     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);
+                const meta = await readCodexMeta(filePath, account, currentVersion);
                 if (meta && !seen.has(meta.id)) {
                     seen.add(meta.id);
                     sessions.push(meta);
@@ -387,52 +460,27 @@ async function discoverCodexSessions() {
     }
     return sessions;
 }
-async function readCodexMeta(filePath, account) {
-    const lines = await readFirstLines(filePath, 5);
-    if (lines.length === 0)
-        return null;
-    let parsed;
-    try {
-        parsed = JSON.parse(lines[0]);
-    }
-    catch {
-        return null;
-    }
-    if (parsed.type !== 'session_meta')
-        return null;
-    const payload = parsed.payload || {};
-    const sessionId = payload.id || '';
+async function readCodexMeta(filePath, account, currentVersion) {
+    const scan = await scanCodexSession(filePath);
+    const sessionId = scan.sessionId || '';
     if (!sessionId)
         return null;
-    // Extract topic from first user message in subsequent lines
-    let topic;
-    for (let i = 1; i < lines.length; i++) {
-        try {
-            const ev = JSON.parse(lines[i]);
-            if (ev.type === 'message' && ev.role === 'user' && ev.content) {
-                const text = typeof ev.content === 'string' ? ev.content
-                    : Array.isArray(ev.content) ? ev.content.find((b) => b.type === 'input_text')?.text : undefined;
-                if (text) {
-                    topic = extractTopic(text);
-                    break;
-                }
-            }
-        }
-        catch { /* malformed event line */ }
-    }
-    const cwd = payload.cwd || '';
+    const cwd = scan.cwd || '';
     return {
         id: sessionId,
         shortId: sessionId.slice(0, 8),
         agent: 'codex',
-        timestamp: payload.timestamp || parsed.timestamp || new Date().toISOString(),
+        timestamp: scan.timestamp || new Date().toISOString(),
         project: cwd ? path.basename(cwd) : undefined,
         cwd,
         filePath,
-        gitBranch: payload.git?.branch || undefined,
-        version: payload.version || undefined,
-        topic,
+        gitBranch: scan.gitBranch,
+        version: resolveSessionVersion('codex', filePath, scan.version, currentVersion),
+        topic: scan.topic,
+        messageCount: scan.messageCount,
+        tokenCount: scan.tokenCount,
         account,
+        _userTerms: scan.userTerms?.flatMap(splitLines),
     };
 }
 // ---------------------------------------------------------------------------
@@ -442,6 +490,7 @@ async function discoverGeminiSessions() {
     const projectMap = buildGeminiProjectMap();
     const sessions = [];
     const seen = new Set();
+    const currentVersion = await getCurrentAgentVersion('gemini');
     let skipped = 0;
     for (const tmpDir of getAgentSessionDirs('gemini', 'tmp')) {
         let hashDirs;
@@ -465,7 +514,7 @@ async function discoverGeminiSessions() {
             for (const file of chatFiles) {
                 const filePath = path.join(chatsDir, file);
                 try {
-                    const meta = readGeminiMeta(filePath, hashDir, projectMap);
+                    const meta = readGeminiMeta(filePath, hashDir, projectMap, currentVersion);
                     if (meta && !seen.has(meta.id)) {
                         seen.add(meta.id);
                         sessions.push(meta);
@@ -482,17 +531,22 @@ async function discoverGeminiSessions() {
     }
     return sessions;
 }
-function readGeminiMeta(filePath, hashDir, projectMap) {
-    // Read the first ~2KB to get top-level fields without parsing entire messages array
-    const fd = fs.openSync(filePath, 'r');
-    const buf = Buffer.alloc(2048);
-    const bytesRead = fs.readSync(fd, buf, 0, 2048, 0);
-    fs.closeSync(fd);
-    const header = buf.toString('utf-8', 0, bytesRead);
-    // Extract fields via regex (avoids parsing potentially huge messages array)
-    const sessionId = extractJsonField(header, 'sessionId');
-    const startTime = extractJsonField(header, 'startTime');
-    const projectHash = extractJsonField(header, 'projectHash');
+function readGeminiMeta(filePath, hashDir, projectMap, currentVersion) {
+    let session;
+    try {
+        session = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+    const sessionId = typeof session.sessionId === 'string' ? session.sessionId : '';
+    const startTime = typeof session.startTime === 'string' ? session.startTime : '';
+    const projectHash = typeof session.projectHash === 'string' ? session.projectHash : '';
+    const embeddedVersion = typeof session.version === 'string'
+        ? session.version
+        : typeof session.cliVersion === 'string'
+            ? session.cliVersion
+            : undefined;
     if (!sessionId)
         return null;
     // Resolve project name from hash
@@ -500,11 +554,33 @@ function readGeminiMeta(filePath, hashDir, projectMap) {
     const project = projectInfo?.name || hashDir.slice(0, 12);
     const cwd = projectInfo?.path;
     const stat = safeStatSync(filePath);
-    // Try to extract first user message from the header bytes
+    const messages = Array.isArray(session.messages) ? session.messages : [];
     let topic;
-    const userMsgMatch = header.match(/"role"\s*:\s*"user"[\s\S]*?"text"\s*:\s*"([^"]{1,200})"/);
-    if (userMsgMatch)
-        topic = extractTopic(userMsgMatch[1]);
+    let messageCount = 0;
+    let tokenCount = 0;
+    let sawTokenCount = false;
+    const userTerms = [];
+    for (const message of messages) {
+        if (message.type === 'user') {
+            const text = extractGeminiMessageText(message.content);
+            if (text) {
+                messageCount++;
+                userTerms.push(text);
+                if (!topic)
+                    topic = extractSessionTopic(text);
+            }
+        }
+        else if (message.type === 'gemini') {
+            if (extractGeminiMessageText(message.content)) {
+                messageCount++;
+            }
+        }
+        const total = getGeminiTokenCount(message.tokens);
+        if (total !== null) {
+            tokenCount += total;
+            sawTokenCount = true;
+        }
+    }
     return {
         id: sessionId,
         shortId: sessionId.slice(0, 8),
@@ -513,7 +589,11 @@ function readGeminiMeta(filePath, hashDir, projectMap) {
         project,
         cwd,
         filePath,
+        version: resolveSessionVersion('gemini', filePath, embeddedVersion, currentVersion),
         topic,
+        messageCount,
+        tokenCount: sawTokenCount ? tokenCount : undefined,
+        _userTerms: userTerms.length > 0 ? userTerms : undefined,
     };
 }
 function buildGeminiProjectMap() {
@@ -594,13 +674,37 @@ async function discoverOpenCodeSessions() {
     if (!fs.existsSync(OPENCODE_DB))
         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 id, title, directory, version, time_created
-      FROM session
-      WHERE parent_id IS NULL
+      SELECT
+        s.id,
+        s.title,
+        s.directory,
+        s.version,
+        s.time_created,
+        COALESCE(stats.message_count, 0),
+        stats.token_count,
+        COALESCE(stats.has_token_data, 0)
+      FROM session s
+      LEFT JOIN (
+        SELECT
+          session_id,
+          COUNT(*) AS message_count,
+          SUM(
+            COALESCE(json_extract(data, '$.tokens.input'), 0) +
+            COALESCE(json_extract(data, '$.tokens.output'), 0) +
+            COALESCE(json_extract(data, '$.tokens.reasoning'), 0) +
+            COALESCE(json_extract(data, '$.tokens.cache.read'), 0) +
+            COALESCE(json_extract(data, '$.tokens.cache.write'), 0)
+          ) AS token_count,
+          MAX(CASE WHEN json_type(data, '$.tokens') IS NOT NULL THEN 1 ELSE 0 END) AS has_token_data
+        FROM message
+        GROUP BY session_id
+      ) stats ON stats.session_id = s.id
+      WHERE s.parent_id IS NULL
       ORDER BY time_created DESC
       LIMIT 200;
     `.replace(/\n/g, ' ');
@@ -609,10 +713,13 @@ async function discoverOpenCodeSessions() {
         for (const line of out.split('\n')) {
             if (!line.trim())
                 continue;
-            const [id, title, directory, version, timeCreatedStr] = line.split('|||');
+            const [id, title, directory, version, timeCreatedStr, messageCountStr, tokenCountStr, hasTokenDataStr] = line.split('|||');
             if (!id)
                 continue;
             const timeCreated = parseInt(timeCreatedStr, 10);
+            const messageCount = parseInt(messageCountStr, 10);
+            const tokenCount = parseInt(tokenCountStr, 10);
+            const hasTokenData = hasTokenDataStr === '1';
             const timestamp = isNaN(timeCreated) ? new Date().toISOString() : new Date(timeCreated).toISOString();
             const topic = title || undefined;
             sessions.push({
@@ -623,9 +730,11 @@ async function discoverOpenCodeSessions() {
                 project: directory ? path.basename(directory) : undefined,
                 cwd: directory || undefined,
                 filePath: `${OPENCODE_DB}#${id}`,
-                version: version || undefined,
+                version: resolveSessionVersion('opencode', OPENCODE_DB, version || undefined, currentVersion),
                 account,
                 topic,
+                messageCount: Number.isNaN(messageCount) ? undefined : messageCount,
+                tokenCount: hasTokenData && !Number.isNaN(tokenCount) ? tokenCount : undefined,
             });
         }
         return sessions;
@@ -649,6 +758,7 @@ async function discoverOpenClawSessions() {
     catch {
         return sessions;
     }
+    const currentVersion = await getCurrentAgentVersion('openclaw');
     // Discover active channels
     // Format: "- Telegram default (Jeff): enabled, configured, running, out:2h ago, mode:polling, token:config"
     try {
@@ -671,6 +781,7 @@ async function discoverOpenClawSessions() {
                 agent: 'openclaw',
                 timestamp: new Date().toISOString(),
                 project: name,
+                version: currentVersion,
                 filePath: '',
             });
         }
@@ -713,6 +824,7 @@ async function discoverOpenClawSessions() {
                 timestamp: new Date().toISOString(),
                 project: `${jobName} (${agentId || 'unknown'})`,
                 cwd: status,
+                version: currentVersion,
                 filePath: '',
             });
         }
@@ -722,6 +834,150 @@ async function discoverOpenClawSessions() {
     }
     return sessions;
 }
+async function scanClaudeSession(filePath) {
+    const stream = fs.createReadStream(filePath, { encoding: 'utf-8' });
+    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    let timestamp;
+    let cwd;
+    let gitBranch;
+    let version;
+    let topic;
+    let messageCount = 0;
+    let tokenCount = 0;
+    let sawTokenCount = false;
+    const seenAssistantIds = new Set();
+    const userTexts = [];
+    try {
+        for await (const line of rl) {
+            if (!line.trim())
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (!timestamp && (parsed.type === 'user' || parsed.type === 'assistant') && parsed.timestamp) {
+                timestamp = parsed.timestamp;
+                cwd = parsed.cwd || '';
+                gitBranch = parsed.gitBranch || undefined;
+                version = parsed.version || undefined;
+            }
+            if (parsed.type === 'user') {
+                const text = extractClaudeUserText(parsed);
+                if (text) {
+                    messageCount++;
+                    userTexts.push(text);
+                    if (!topic)
+                        topic = extractSessionTopic(text);
+                }
+                continue;
+            }
+            if (parsed.type !== 'assistant')
+                continue;
+            const assistantId = typeof parsed.message?.id === 'string'
+                ? parsed.message.id
+                : typeof parsed.uuid === 'string'
+                    ? parsed.uuid
+                    : undefined;
+            const logicalId = assistantId || `${parsed.timestamp || ''}:${seenAssistantIds.size}`;
+            if (seenAssistantIds.has(logicalId))
+                continue;
+            seenAssistantIds.add(logicalId);
+            messageCount++;
+            const usage = getClaudeUsageTotal(parsed.message?.usage || parsed.usage);
+            if (usage !== null) {
+                tokenCount += usage;
+                sawTokenCount = true;
+            }
+        }
+    }
+    finally {
+        rl.close();
+        stream.destroy();
+    }
+    return {
+        timestamp,
+        cwd,
+        gitBranch,
+        version,
+        topic,
+        messageCount,
+        tokenCount: sawTokenCount ? tokenCount : undefined,
+        userTerms: userTexts.length > 0 ? userTexts : undefined,
+    };
+}
+async function scanCodexSession(filePath) {
+    const stream = fs.createReadStream(filePath, { encoding: 'utf-8' });
+    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    let sessionId;
+    let timestamp;
+    let cwd;
+    let gitBranch;
+    let version;
+    let topic;
+    let messageCount = 0;
+    let tokenCount;
+    const userTexts = [];
+    try {
+        for await (const line of rl) {
+            if (!line.trim())
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (parsed.type === 'session_meta') {
+                const payload = parsed.payload || {};
+                sessionId = payload.id || sessionId;
+                timestamp = payload.timestamp || parsed.timestamp || timestamp;
+                cwd = payload.cwd || cwd;
+                gitBranch = payload.git?.branch || gitBranch;
+                version = payload.cli_version || payload.version || version;
+                continue;
+            }
+            if (parsed.type === 'response_item' && parsed.payload?.type === 'message') {
+                const role = parsed.payload.role === 'user' || parsed.payload.role === 'developer'
+                    ? 'user'
+                    : 'assistant';
+                const text = extractCodexMessageText(parsed.payload.content, role);
+                if (!text)
+                    continue;
+                messageCount++;
+                if (role === 'user') {
+                    userTexts.push(text);
+                    if (!topic)
+                        topic = extractSessionTopic(text);
+                }
+                continue;
+            }
+            if (parsed.type === 'event_msg' && parsed.payload?.type === 'token_count') {
+                const total = getCodexTokenCount(parsed.payload.info?.total_token_usage);
+                if (total !== null)
+                    tokenCount = total;
+            }
+        }
+    }
+    finally {
+        rl.close();
+        stream.destroy();
+    }
+    return {
+        sessionId,
+        timestamp,
+        cwd,
+        gitBranch,
+        version,
+        topic,
+        messageCount,
+        tokenCount,
+        userTerms: userTexts.length > 0 ? userTexts : undefined,
+    };
+}
 // ---------------------------------------------------------------------------
 // Utilities
 // ---------------------------------------------------------------------------
@@ -777,11 +1033,6 @@ export function walkForFiles(dir, ext, limit) {
     results.sort((a, b) => b.mtime - a.mtime);
     return results.slice(0, limit).map(r => r.path);
 }
-function extractJsonField(text, field) {
-    const re = new RegExp(`"${field}"\\s*:\\s*"([^"]*)"`, 'i');
-    const match = text.match(re);
-    return match ? match[1] : '';
-}
 function sha256(input) {
     return crypto.createHash('sha256').update(input).digest('hex');
 }
@@ -801,11 +1052,204 @@ function safeRealpathSync(p) {
         return null;
     }
 }
-function extractTopic(text) {
-    // Strip leading whitespace, slash commands, and system tags
-    let clean = text.replace(/^[\s\n]+/, '').replace(/<[^>]+>/g, '').trim();
-    // Take first line only
-    const firstLine = clean.split('\n')[0].trim();
-    return firstLine;
+function extractClaudeUserText(parsed) {
+    if (parsed.isMeta === true)
+        return undefined;
+    const content = parsed.message?.content;
+    if (typeof content === 'string') {
+        const text = content.trim();
+        return isLocalCommandMessage(text) ? undefined : text || undefined;
+    }
+    if (!Array.isArray(content))
+        return undefined;
+    const text = content
+        .filter((block) => block.type === 'text')
+        .map((block) => String(block.text || '').trim())
+        .find((value) => value && !value.startsWith('[Request interrupted'));
+    if (!text || isLocalCommandMessage(text))
+        return undefined;
+    return text;
+}
+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);
+}
+function getClaudeUsageTotal(usage) {
+    if (!usage || typeof usage !== 'object')
+        return null;
+    return sumKnownNumbers([
+        usage.input_tokens,
+        usage.output_tokens,
+        usage.cache_creation_input_tokens,
+        usage.cache_read_input_tokens,
+    ]);
+}
+function extractCodexMessageText(contentBlocks, role) {
+    if (!Array.isArray(contentBlocks))
+        return undefined;
+    const matches = role === 'user'
+        ? contentBlocks.filter((block) => block.type === 'input_text')
+        : contentBlocks.filter((block) => block.type === 'output_text');
+    const text = matches
+        .map((block) => String(block.text || '').trim())
+        .find((value) => {
+        if (!value)
+            return false;
+        if (role === 'user' && (value.length >= 2000 || value.includes('<permissions instructions>') || value.startsWith('# AGENTS.md instructions'))) {
+            return false;
+        }
+        return true;
+    });
+    return text || undefined;
+}
+function normalizeVersion(version) {
+    const trimmed = version?.trim();
+    return trimmed ? trimmed : undefined;
+}
+function extractVersionFromManagedPath(agent, sourcePath) {
+    if (!sourcePath)
+        return undefined;
+    const candidates = [sourcePath, safeRealpathSync(sourcePath) || ''];
+    const marker = `/.agents/versions/${agent}/`;
+    for (const candidate of candidates) {
+        if (!candidate)
+            continue;
+        const normalized = candidate.split(path.sep).join('/');
+        const start = normalized.indexOf(marker);
+        if (start === -1)
+            continue;
+        const version = normalized.slice(start + marker.length).split('/')[0];
+        if (version)
+            return version;
+    }
+    return undefined;
+}
+async function getCurrentAgentVersion(agent) {
+    const cached = cachedAgentVersions.get(agent);
+    if (cached)
+        return cached;
+    const promise = (async () => {
+        const symlinkVersion = normalizeVersion(getConfigSymlinkVersion(agent));
+        if (symlinkVersion)
+            return symlinkVersion;
+        return normalizeVersion(await getCliVersion(agent));
+    })();
+    cachedAgentVersions.set(agent, promise);
+    return promise;
+}
+function resolveSessionVersion(agent, sourcePath, embeddedVersion, currentVersion) {
+    return normalizeVersion(embeddedVersion)
+        || extractVersionFromManagedPath(agent, sourcePath)
+        || normalizeVersion(currentVersion);
+}
+function getCodexTokenCount(totalTokenUsage) {
+    if (!totalTokenUsage || typeof totalTokenUsage !== 'object')
+        return null;
+    return sumKnownNumbers([
+        totalTokenUsage.input_tokens,
+        totalTokenUsage.cached_input_tokens,
+        totalTokenUsage.output_tokens,
+        totalTokenUsage.reasoning_output_tokens,
+    ]);
+}
+function extractGeminiMessageText(content) {
+    if (typeof content === 'string')
+        return content.trim();
+    if (Array.isArray(content)) {
+        return content
+            .map((part) => {
+            if (typeof part === 'string')
+                return part;
+            if (typeof part?.text === 'string')
+                return part.text;
+            return '';
+        })
+            .join('\n')
+            .trim();
+    }
+    return '';
+}
+function getGeminiTokenCount(tokens) {
+    if (!tokens || typeof tokens !== 'object')
+        return null;
+    if (typeof tokens.total === 'number')
+        return tokens.total;
+    return sumKnownNumbers([
+        tokens.input,
+        tokens.output,
+        tokens.cached,
+        tokens.thoughts,
+        tokens.tool,
+    ]);
+}
+function sumKnownNumbers(values) {
+    let total = 0;
+    let found = false;
+    for (const value of values) {
+        if (typeof value !== 'number' || Number.isNaN(value))
+            continue;
+        total += value;
+        found = true;
+    }
+    return found ? total : null;
+}
+// ---------------------------------------------------------------------------
+// Time range parsing
+// ---------------------------------------------------------------------------
+export function parseTimeFilter(input) {
+    const relativeMatch = input.match(/^(\d+)([dw])$/i);
+    if (relativeMatch) {
+        const value = parseInt(relativeMatch[1], 10);
+        const unit = relativeMatch[2].toLowerCase();
+        if (unit === 'd')
+            return Date.now() - value * 86_400_000;
+        if (unit === 'w')
+            return Date.now() - value * 7 * 86_400_000;
+    }
+    const ts = new Date(input).getTime();
+    return Number.isNaN(ts) ? 0 : ts;
+}
+// ---------------------------------------------------------------------------
+// Content index search
+// ---------------------------------------------------------------------------
+/**
+ * Score sessions by matching against terms from the content index.
+ * Returns sessions with matched terms attached for highlighting.
+ */
+export function searchContentIndex(sessions, query) {
+    const index = loadContentIndex();
+    if (index.size === 0)
+        return new Map();
+    const terms = tokenizeText(query);
+    if (terms.length === 0)
+        return new Map();
+    const scored = new Map();
+    for (const term of terms) {
+        const matchingSessions = index.get(term);
+        if (!matchingSessions)
+            continue;
+        for (const sessionId of matchingSessions) {
+            const entry = scored.get(sessionId);
+            if (!entry) {
+                scored.set(sessionId, { score: 1, matchedTerms: [term] });
+            }
+            else {
+                entry.score += 1;
+                if (!entry.matchedTerms.includes(term)) {
+                    entry.matchedTerms.push(term);
+                }
+            }
+        }
+    }
+    const result = new Map();
+    for (const [sessionId, info] of scored) {
+        const session = sessions.find(s => s.id === sessionId);
+        if (session) {
+            result.set(sessionId, { ...session, _matchedTerms: info.matchedTerms });
+        }
+    }
+    return result;
 }
 //# sourceMappingURL=discover.js.map