agentacta 2026.4.8 → 2026.4.10

package/dist/indexer.js

@@ -0,0 +1,879 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverSessionDirs = discoverSessionDirs;
+exports.listJsonlFiles = listJsonlFiles;
+exports.indexFile = indexFile;
+exports.indexCronRunFile = indexCronRunFile;
+exports.indexAll = indexAll;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const db_js_1 = require("./db.js");
+const config_js_1 = require("./config.js");
+const REINDEX = process.argv.includes('--reindex');
+const WATCH = process.argv.includes('--watch');
+function listJsonlFiles(baseDir, recursive = false) {
+    if (!node_fs_1.default.existsSync(baseDir))
+        return [];
+    const out = [];
+    function walk(dir) {
+        for (const entry of node_fs_1.default.readdirSync(dir, { withFileTypes: true })) {
+            const full = node_path_1.default.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (recursive)
+                    walk(full);
+                continue;
+            }
+            if (entry.isFile() && entry.name.endsWith('.jsonl'))
+                out.push(full);
+        }
+    }
+    walk(baseDir);
+    return out;
+}
+function discoverSessionDirs(config) {
+    const dirs = [];
+    const home = process.env.HOME;
+    const codexSessionsPath = node_path_1.default.join(home, '.codex/sessions');
+    const cronRunsPath = node_path_1.default.join(home, '.openclaw/cron/runs');
+    function normalizedPath(p) {
+        return node_path_1.default.resolve(p).replace(/[\\\/]+$/, '');
+    }
+    function hasDir(targetPath, sourceType = 'transcript') {
+        const wanted = normalizedPath(targetPath);
+        return dirs.some(d => normalizedPath(d.path) === wanted && (d.sourceType || 'transcript') === sourceType);
+    }
+    function addDir(dir) {
+        if (!dir || !dir.path)
+            return;
+        if (hasDir(dir.path, dir.sourceType || 'transcript'))
+            return;
+        dirs.push(dir);
+    }
+    // Expand a single path into session dirs, handling Claude Code's per-project structure
+    function expandPath(p) {
+        if (!node_fs_1.default.existsSync(p))
+            return;
+        const stat = node_fs_1.default.statSync(p);
+        if (!stat.isDirectory())
+            return;
+        const normalized = normalizedPath(p);
+        const normalizedCodex = normalizedPath(codexSessionsPath);
+        // Claude Code: ~/.claude/projects contains per-project subdirs with JSONL files
+        if (normalized.endsWith('/.claude/projects')) {
+            for (const proj of node_fs_1.default.readdirSync(p)) {
+                const projDir = node_path_1.default.join(p, proj);
+                if (node_fs_1.default.statSync(projDir).isDirectory()) {
+                    const hasJsonl = node_fs_1.default.readdirSync(projDir).some(f => f.endsWith('.jsonl'));
+                    if (hasJsonl)
+                        addDir({ path: projDir, agent: 'claude-code' });
+                }
+            }
+        }
+        else if (normalized === normalizedCodex) {
+            // Codex CLI stores nested YYYY/MM/DD directories and must be recursive.
+            addDir({ path: p, agent: 'codex-cli', recursive: true });
+        }
+        else {
+            addDir({ path: p, agent: node_path_1.default.basename(node_path_1.default.dirname(p)) });
+        }
+    }
+    // Config sessionsPath or env var override
+    const sessionsOverride = process.env.AGENTACTA_SESSIONS_PATH || (config && config.sessionsPath);
+    if (sessionsOverride) {
+        const overridePaths = Array.isArray(sessionsOverride)
+            ? sessionsOverride
+            : sessionsOverride.split(':');
+        overridePaths.forEach(expandPath);
+    }
+    // Auto-discover: ~/.openclaw/agents/*/sessions/
+    const oclawAgents = node_path_1.default.join(home, '.openclaw/agents');
+    if (node_fs_1.default.existsSync(oclawAgents)) {
+        for (const agent of node_fs_1.default.readdirSync(oclawAgents)) {
+            const sp = node_path_1.default.join(oclawAgents, agent, 'sessions');
+            if (node_fs_1.default.existsSync(sp) && node_fs_1.default.statSync(sp).isDirectory()) {
+                addDir({ path: sp, agent });
+            }
+        }
+    }
+    // Auto-discover: ~/.claude/projects/
+    expandPath(node_path_1.default.join(home, '.claude/projects'));
+    // Scan ~/.codex/sessions recursively (Codex CLI stores nested YYYY/MM/DD/*.jsonl)
+    const codexSessions = codexSessionsPath;
+    if (node_fs_1.default.existsSync(codexSessions) && node_fs_1.default.statSync(codexSessions).isDirectory()) {
+        addDir({ path: codexSessions, agent: 'codex-cli', recursive: true });
+    }
+    // Fallback synthetic source for cron-backed runs that have metadata but no transcript JSONL.
+    if (node_fs_1.default.existsSync(cronRunsPath) && node_fs_1.default.statSync(cronRunsPath).isDirectory()) {
+        addDir({ path: cronRunsPath, agent: 'cron', sourceType: 'cron-run' });
+    }
+    if (!dirs.length) {
+        // Fallback to hardcoded
+        const fallback = node_path_1.default.join(home, '.openclaw/agents/main/sessions');
+        if (node_fs_1.default.existsSync(fallback))
+            addDir({ path: fallback, agent: 'main' });
+    }
+    return dirs;
+}
+function isHeartbeat(text) {
+    if (!text)
+        return false;
+    const lower = text.toLowerCase();
+    return lower.includes('heartbeat') || lower.includes('heartbeat_ok');
+}
+function isBoilerplatePrompt(text) {
+    if (!text)
+        return false;
+    const lower = text.toLowerCase();
+    return lower.includes('<permissions instructions>')
+        || lower.includes('filesystem sandboxing defines which files can be read or written')
+        || lower.includes('# agents.md instructions for ');
+}
+function isSummaryCandidate(text) {
+    if (!text || text.trim().length <= 10)
+        return false;
+    if (isHeartbeat(text))
+        return false;
+    if (isBoilerplatePrompt(text))
+        return false;
+    return true;
+}
+function stripLeadingDatetimePrefix(text) {
+    if (!text)
+        return text;
+    return text
+        .replace(/^\[(Mon|Tue|Wed|Thu|Fri|Sat|Sun)\s+\d{4}-\d{2}-\d{2}[^\]]*\]\s*/i, '')
+        .trim();
+}
+function extractContent(msg) {
+    if (!msg || typeof msg !== 'object')
+        return '';
+    const m = msg;
+    if (!m.content)
+        return '';
+    if (typeof m.content === 'string')
+        return m.content;
+    if (Array.isArray(m.content)) {
+        return m.content.filter(b => b.type === 'text').map(b => b.text || '').join('\n');
+    }
+    return '';
+}
+function extractToolCalls(msg) {
+    if (!msg || typeof msg !== 'object')
+        return [];
+    const m = msg;
+    if (!Array.isArray(m.content))
+        return [];
+    return m.content
+        .filter(b => b.type === 'tool_use' || b.type === 'toolCall')
+        .map(b => ({
+        id: b.id || b.toolCallId || '',
+        name: b.name || '',
+        args: JSON.stringify(b.input || b.arguments || {})
+    }));
+}
+function extractToolResult(msg) {
+    if (!msg)
+        return null;
+    const m = msg;
+    if (m.role === 'toolResult' || m.role === 'tool') {
+        const content = Array.isArray(m.content)
+            ? m.content.map(b => b.text || '').join('\n')
+            : (typeof m.content === 'string' ? m.content : '');
+        return { toolCallId: m.toolCallId || '', toolName: m.toolName || '', content: content.slice(0, 10000) };
+    }
+    return null;
+}
+function extractCodexMessageText(content) {
+    if (!content)
+        return '';
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .map((part) => {
+        if (!part || typeof part !== 'object')
+            return '';
+        if (typeof part.text === 'string')
+            return part.text;
+        if (typeof part.output_text === 'string')
+            return part.output_text;
+        if (typeof part.input_text === 'string')
+            return part.input_text;
+        return '';
+    })
+        .filter(Boolean)
+        .join('\n');
+}
+function extractFilePaths(toolName, toolArgs) {
+    const paths = [];
+    if (!toolArgs)
+        return paths;
+    const maybePath = (value) => {
+        if (typeof value !== 'string')
+            return;
+        if (value.startsWith('/') || value.startsWith('~/') || value.startsWith('./') || value.startsWith('../')) {
+            paths.push(value);
+            return;
+        }
+        if (value.includes('/') || value.includes('\\'))
+            paths.push(value);
+    };
+    const visit = (obj) => {
+        if (!obj || typeof obj !== 'object')
+            return;
+        if (Array.isArray(obj)) {
+            for (const item of obj)
+                visit(item);
+            return;
+        }
+        for (const [key, value] of Object.entries(obj)) {
+            if (typeof value === 'string') {
+                if (['path', 'file_path', 'filePath', 'file', 'filename', 'cwd', 'workdir', 'directory', 'dir'].includes(key)) {
+                    maybePath(value);
+                }
+            }
+            else if (value && typeof value === 'object') {
+                visit(value);
+            }
+        }
+    };
+    try {
+        const args = typeof toolArgs === 'string' ? JSON.parse(toolArgs) : toolArgs;
+        visit(args);
+    }
+    catch {
+        // ignore parse errors
+    }
+    return [...new Set(paths)];
+}
+function aliasProject(project, config) {
+    if (!project)
+        return project;
+    const aliases = (config && config.projectAliases && typeof config.projectAliases === 'object') ? config.projectAliases : {};
+    return aliases[project] || project;
+}
+function extractProjectFromPath(filePath, config) {
+    if (!filePath || typeof filePath !== 'string')
+        return null;
+    const normalized = filePath.replace(/\\/g, '/');
+    // Relative paths are usually from workspace cwd -> treat as workspace activity
+    if (!normalized.startsWith('/') && !normalized.startsWith('~'))
+        return aliasProject('workspace', config);
+    const rel = normalized
+        .replace(/^\/home\/[^/]+\//, '')
+        .replace(/^\/Users\/[^/]+\//, '')
+        .replace(/^~\//, '');
+    const parts = rel.split('/').filter(Boolean);
+    if (!parts.length)
+        return null;
+    // Common repo location: ~/Developer/<repo>/...
+    if (parts[0] === 'Developer' && parts[1])
+        return aliasProject(parts[1], config);
+    // Symphony worktrees: ~/symphony-workspaces/<issue>/...
+    if (parts[0] === 'symphony-workspaces' && parts[1])
+        return aliasProject(parts[1], config);
+    // OpenClaw workspace and agent stores
+    if (parts[0] === '.openclaw' && parts[1] === 'workspace')
+        return aliasProject('workspace', config);
+    if (parts[0] === '.openclaw' && parts[1] === 'agents' && parts[2])
+        return aliasProject(`agent:${parts[2]}`, config);
+    // Claude Code projects
+    if (parts[0] === '.claude' && parts[1] === 'projects' && parts[2])
+        return aliasProject(`claude:${parts[2]}`, config);
+    // Shared files area
+    if (parts[0] === 'Shared')
+        return aliasProject('shared', config);
+    return null;
+}
+function indexCronRunFile(db, filePath, agentName, stmts) {
+    const stat = node_fs_1.default.statSync(filePath);
+    const mtime = stat.mtime.toISOString();
+    if (!REINDEX) {
+        const state = stmts.getState.get(filePath);
+        if (state && state.last_modified === mtime)
+            return { skipped: true };
+    }
+    const raw = node_fs_1.default.readFileSync(filePath, 'utf8').trim();
+    if (!raw)
+        return { skipped: true };
+    let meta;
+    try {
+        meta = JSON.parse(raw.split('\n').find(Boolean));
+    }
+    catch {
+        return { skipped: true };
+    }
+    const sessionId = meta.sessionId;
+    if (!sessionId)
+        return { skipped: true };
+    // Guard: don't overwrite a session that was already indexed from a real transcript.
+    // Check both event presence AND session_type — a transcript session with zero events
+    // (e.g. header-only file) should still win over synthetic cron metadata.
+    const existingSession = db.prepare('SELECT session_type FROM sessions WHERE id = ?').get(sessionId);
+    if (existingSession && existingSession.session_type !== 'cron') {
+        stmts.upsertState.run(filePath, 1, mtime);
+        return { skipped: true, preferredTranscript: true, sessionId };
+    }
+    const existingRealSession = db.prepare('SELECT EXISTS(SELECT 1 FROM events WHERE session_id = ?) AS has_events').get(sessionId);
+    if (existingRealSession && existingRealSession.has_events) {
+        stmts.upsertState.run(filePath, 1, mtime);
+        return { skipped: true, preferredTranscript: true, sessionId };
+    }
+    const ts = typeof meta.ts === 'number' ? new Date(meta.ts).toISOString() : new Date().toISOString();
+    const runAt = typeof meta.runAtMs === 'number' ? new Date(meta.runAtMs).toISOString() : ts;
+    const durationMs = typeof meta.durationMs === 'number' ? meta.durationMs : null;
+    const endTime = ts;
+    const startTime = durationMs ? new Date(new Date(endTime).getTime() - durationMs).toISOString() : runAt;
+    const summary = stripLeadingDatetimePrefix(meta.summary || 'Cron run');
+    const sessionKey = typeof meta.sessionKey === 'string' ? meta.sessionKey : '';
+    const sessionKeyParts = sessionKey.split(':');
+    const inferredAgent = sessionKeyParts[0] === 'agent' && sessionKeyParts[1] ? sessionKeyParts[1] : agentName;
+    const model = meta.model || meta.provider || null;
+    const totalInputTokens = meta.usage && typeof meta.usage.input_tokens === 'number' ? meta.usage.input_tokens : 0;
+    const totalOutputTokens = meta.usage && typeof meta.usage.output_tokens === 'number' ? meta.usage.output_tokens : 0;
+    const totalTokens = meta.usage && typeof meta.usage.total_tokens === 'number'
+        ? meta.usage.total_tokens
+        : totalInputTokens + totalOutputTokens;
+    const commitIndex = db.transaction(() => {
+        if (stmts.deleteArchive)
+            stmts.deleteArchive.run(sessionId);
+        stmts.deleteFileActivity.run(sessionId);
+        stmts.deleteEvents.run(sessionId);
+        stmts.deleteSession.run(sessionId);
+        stmts.upsertSession.run(sessionId, startTime, endTime, 0, 0, model, summary, inferredAgent, 'cron', 0, totalTokens, totalInputTokens, totalOutputTokens, 0, 0, null, null, null, model ? JSON.stringify([model]) : null, null);
+        stmts.upsertState.run(filePath, 1, mtime);
+    });
+    commitIndex();
+    return { sessionId, synthetic: true };
+}
+function indexFile(db, filePath, agentName, stmts, archiveMode, config) {
+    const stat = node_fs_1.default.statSync(filePath);
+    const mtime = stat.mtime.toISOString();
+    if (!REINDEX) {
+        const state = stmts.getState.get(filePath);
+        if (state && state.last_modified === mtime)
+            return { skipped: true };
+    }
+    const raw = node_fs_1.default.readFileSync(filePath, 'utf8');
+    const lines = raw.trim().split('\n').filter(Boolean);
+    if (lines.length === 0)
+        return { skipped: true };
+    let sessionId = null;
+    let sessionStart = null;
+    let sessionEnd = null;
+    let msgCount = 0;
+    let toolCount = 0;
+    let model = null;
+    const modelsSet = new Set();
+    let summary = '';
+    let sessionType = null;
+    let agent = agentName;
+    let totalCost = 0;
+    let totalTokens = 0;
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    let totalCacheReadTokens = 0;
+    let totalCacheWriteTokens = 0;
+    let initialPrompt = null;
+    let firstMessageId = null;
+    let firstMessageTimestamp = null;
+    let codexProvider = null;
+    let codexSource = null;
+    let codexOriginator = null;
+    let sawSnapshotRecord = false;
+    let sawNonSnapshotRecord = false;
+    let firstLine;
+    try {
+        firstLine = JSON.parse(lines[0]);
+    }
+    catch {
+        return { skipped: true };
+    }
+    let isClaudeCode = false;
+    let isCodexCli = false;
+    if (firstLine.type === 'session') {
+        // OpenClaw format
+        sessionId = firstLine.id || null;
+        sessionStart = firstLine.timestamp || null;
+        if (firstLine.agent)
+            agent = firstLine.agent;
+        if (firstLine.sessionType)
+            sessionType = firstLine.sessionType;
+        if (sessionId && sessionId.includes('subagent'))
+            sessionType = 'subagent';
+    }
+    else if (firstLine.type === 'user' || firstLine.type === 'assistant' || firstLine.type === 'file-history-snapshot' || firstLine.type === 'queue-operation') {
+        // Claude Code format — no session header, extract from first message or queue-operation line
+        isClaudeCode = true;
+        for (const line of lines) {
+            let obj;
+            try {
+                obj = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (obj.sessionId && obj.timestamp) {
+                sessionId = obj.sessionId;
+                sessionStart = obj.timestamp;
+                break;
+            }
+            if ((obj.type === 'user' || obj.type === 'assistant') && obj.sessionId) {
+                sessionId = obj.sessionId;
+                sessionStart = obj.timestamp || null;
+                break;
+            }
+        }
+        if (!sessionId) {
+            // Fallback: use filename as session ID
+            sessionId = node_path_1.default.basename(filePath, '.jsonl');
+            sessionStart = new Date(firstLine.timestamp || Date.now()).toISOString();
+        }
+    }
+    else if (firstLine.type === 'session_meta') {
+        // Codex CLI format
+        isCodexCli = true;
+        const meta = (firstLine.payload || {});
+        sessionId = meta.id || node_path_1.default.basename(filePath, '.jsonl');
+        sessionStart = meta.timestamp || firstLine.timestamp || new Date().toISOString();
+        sessionType = 'codex-direct';
+        agent = 'codex-cli';
+        if (meta.model) {
+            model = meta.model;
+            modelsSet.add(meta.model);
+        }
+        codexProvider = meta.model_provider || null;
+        codexSource = meta.source || null;
+        codexOriginator = meta.originator || null;
+        if (codexOriginator && codexOriginator.includes('symphony'))
+            sessionType = 'codex-symphony';
+    }
+    else {
+        return { skipped: true };
+    }
+    // --- Parse the entire file BEFORE any DB operations ---
+    const pendingEvents = [];
+    const fileActivities = [];
+    const projectCounts = new Map();
+    // Seed project from session cwd when available (helps chat-only sessions)
+    const sessionCwd = (firstLine && firstLine.cwd) || (firstLine && firstLine.payload && firstLine.payload.cwd);
+    if (sessionCwd) {
+        const p = extractProjectFromPath(sessionCwd, config);
+        if (p)
+            projectCounts.set(p, 1);
+    }
+    for (const line of lines) {
+        let obj;
+        try {
+            obj = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (obj.type === 'file-history-snapshot')
+            sawSnapshotRecord = true;
+        else
+            sawNonSnapshotRecord = true;
+        if (isCodexCli) {
+            if (obj.type === 'session_meta') {
+                const meta = (obj.payload || {});
+                if (meta.id)
+                    sessionId = meta.id;
+                if (meta.timestamp && !sessionStart)
+                    sessionStart = meta.timestamp;
+                if (meta.model) {
+                    if (!model)
+                        model = meta.model;
+                    modelsSet.add(meta.model);
+                }
+                if (meta.model_provider)
+                    codexProvider = meta.model_provider;
+                if (meta.source)
+                    codexSource = meta.source;
+                if (meta.originator)
+                    codexOriginator = meta.originator;
+                if (codexOriginator && codexOriginator.includes('symphony'))
+                    sessionType = 'codex-symphony';
+                if (meta.model_provider && !model)
+                    model = meta.model_provider;
+                continue;
+            }
+            if (obj.type === 'turn_context' && obj.payload) {
+                const tc = obj.payload;
+                if (tc.model && typeof tc.model === 'string') {
+                    if (!model || model === codexProvider)
+                        model = tc.model;
+                    modelsSet.add(tc.model);
+                }
+                continue;
+            }
+            if (obj.type === 'response_item' && obj.payload) {
+                const p = obj.payload;
+                const ts = obj.timestamp || sessionStart;
+                const eventId = `evt-${obj.type}-${Date.parse(ts) || Math.random()}`;
+                if (p.type === 'function_call') {
+                    const toolName = p.name || p.tool_name || '';
+                    const toolArgs = typeof p.arguments === 'string' ? p.arguments : JSON.stringify(p.arguments || {});
+                    const callBaseId = p.call_id || p.id || eventId;
+                    pendingEvents.push([`${callBaseId}:call`, sessionId, ts, 'tool_call', 'assistant', null, toolName, toolArgs, null]);
+                    toolCount++;
+                    const fps = extractFilePaths(toolName, toolArgs);
+                    for (const fp of fps) {
+                        fileActivities.push([sessionId, fp, 'read', ts]);
+                        const project = extractProjectFromPath(fp, config);
+                        if (project)
+                            projectCounts.set(project, (projectCounts.get(project) || 0) + 1);
+                    }
+                    sessionEnd = ts;
+                    continue;
+                }
+                if (p.type === 'function_call_output') {
+                    const output = (typeof p.output === 'string' ? p.output : JSON.stringify(p.output || '')).slice(0, 10000);
+                    const resultBaseId = p.call_id || p.id || eventId;
+                    pendingEvents.push([`${resultBaseId}:result`, sessionId, ts, 'tool_result', 'tool', output, p.name || p.tool_name || '', null, output]);
+                    sessionEnd = ts;
+                    continue;
+                }
+                if (p.type === 'message') {
+                    const rawRole = p.role || 'assistant';
+                    const role = rawRole === 'assistant' ? 'assistant' : 'user';
+                    const content = extractCodexMessageText(p.content);
+                    if (content) {
+                        pendingEvents.push([p.id || eventId, sessionId, ts, 'message', role, content, null, null, null]);
+                        msgCount++;
+                        if (!summary && role === 'user' && isSummaryCandidate(content))
+                            summary = content.slice(0, 200);
+                        if (!initialPrompt && role === 'user' && isSummaryCandidate(content)) {
+                            initialPrompt = content.slice(0, 500);
+                            firstMessageId = p.id || eventId;
+                            firstMessageTimestamp = ts;
+                        }
+                    }
+                    sessionEnd = ts;
+                    continue;
+                }
+            }
+            if (obj.type === 'event_msg' && obj.payload) {
+                const p = obj.payload;
+                const ts = obj.timestamp || sessionStart;
+                const eventId = `evt-${p.type || 'event'}-${Date.parse(ts) || Math.random()}`;
+                if (p.type === 'agent_message' && p.message) {
+                    pendingEvents.push([eventId, sessionId, ts, 'message', 'assistant', p.message, null, null, null]);
+                    msgCount++;
+                    sessionEnd = ts;
+                    continue;
+                }
+                if (p.type === 'user_message' && p.message) {
+                    pendingEvents.push([eventId, sessionId, ts, 'message', 'user', p.message, null, null, null]);
+                    msgCount++;
+                    if (!summary && isSummaryCandidate(p.message))
+                        summary = p.message.slice(0, 200);
+                    if (!initialPrompt && isSummaryCandidate(p.message)) {
+                        initialPrompt = p.message.slice(0, 500);
+                        firstMessageId = eventId;
+                        firstMessageTimestamp = ts;
+                    }
+                    sessionEnd = ts;
+                    continue;
+                }
+            }
+            continue;
+        }
+        if (obj.type === 'session' || obj.type === 'model_change' || obj.type === 'thinking_level_change' || obj.type === 'custom' || obj.type === 'file-history-snapshot') {
+            if (obj.type === 'model_change' && obj.modelId) {
+                if (!model)
+                    model = obj.modelId; // First model for backwards compat
+                modelsSet.add(obj.modelId); // Collect all unique models
+            }
+            continue;
+        }
+        // Normalize: Claude Code uses top-level type "user"/"assistant" with message object
+        // OpenClaw uses type "message" with message.role
+        let msg;
+        let ts;
+        if (obj.type === 'message' && obj.message) {
+            msg = obj.message;
+            ts = obj.timestamp;
+        }
+        else if ((obj.type === 'user' || obj.type === 'assistant') && obj.message) {
+            // Claude Code format: wrap into consistent shape
+            msg = obj.message;
+            if (!msg.role)
+                msg.role = obj.type === 'user' ? 'user' : 'assistant';
+            ts = obj.timestamp;
+        }
+        else {
+            continue;
+        }
+        if (msg) {
+            sessionEnd = ts || null;
+            // Extract model from assistant messages
+            if (msg.role === 'assistant' && msg.model && msg.model !== 'delivery-mirror' && !msg.model.startsWith('<')) {
+                if (!model)
+                    model = msg.model; // Keep first model for backwards compat
+                modelsSet.add(msg.model); // Collect all unique models
+            }
+            // Cost tracking
+            const usage = msg.usage;
+            if (usage) {
+                const cost = usage.cost;
+                if (cost && typeof cost.total === 'number') {
+                    totalCost += cost.total;
+                }
+                if (typeof usage.totalTokens === 'number') {
+                    totalTokens += usage.totalTokens;
+                }
+                // OpenClaw format
+                if (typeof usage.input === 'number')
+                    totalInputTokens += usage.input;
+                if (typeof usage.output === 'number')
+                    totalOutputTokens += usage.output;
+                if (typeof usage.cacheRead === 'number')
+                    totalCacheReadTokens += usage.cacheRead;
+                if (typeof usage.cacheWrite === 'number')
+                    totalCacheWriteTokens += usage.cacheWrite;
+                // Claude Code format
+                if (typeof usage.input_tokens === 'number')
+                    totalInputTokens += usage.input_tokens;
+                if (typeof usage.output_tokens === 'number')
+                    totalOutputTokens += usage.output_tokens;
+                if (typeof usage.cache_read_input_tokens === 'number')
+                    totalCacheReadTokens += usage.cache_read_input_tokens;
+                if (typeof usage.cache_creation_input_tokens === 'number')
+                    totalCacheWriteTokens += usage.cache_creation_input_tokens;
+            }
+            const eventId = obj.id || obj.uuid || `evt-${Date.parse(ts) || Math.random()}`;
+            const tr = extractToolResult(msg);
+            if (tr) {
+                pendingEvents.push([eventId, sessionId, ts, 'tool_result', 'tool', tr.content, tr.toolName, null, tr.content]);
+                continue;
+            }
+            const content = extractContent(msg);
+            const role = msg.role || 'unknown';
+            if (content) {
+                pendingEvents.push([eventId, sessionId, ts, 'message', role, content, null, null, null]);
+                msgCount++;
+                // Better summary: skip heartbeat/boilerplate messages
+                if (!summary && role === 'user' && isSummaryCandidate(content)) {
+                    summary = content.slice(0, 200);
+                }
+                // Capture initial prompt from first substantial user message
+                if (!initialPrompt && role === 'user' && isSummaryCandidate(content)) {
+                    initialPrompt = content.slice(0, 500); // Limit to 500 chars
+                    firstMessageId = eventId;
+                    firstMessageTimestamp = ts || null;
+                }
+            }
+            const tools = extractToolCalls(msg);
+            for (const tool of tools) {
+                pendingEvents.push([tool.id || `${eventId}-${tool.name}`, sessionId, ts, 'tool_call', role, null, tool.name, tool.args, null]);
+                toolCount++;
+                // File activity tracking
+                const fps = extractFilePaths(tool.name, tool.args);
+                for (const fp of fps) {
+                    const op = tool.name.includes('write') || tool.name === 'Write' ? 'write'
+                        : tool.name.includes('edit') || tool.name === 'Edit' ? 'edit'
+                            : 'read';
+                    fileActivities.push([sessionId, fp, op, ts]);
+                    const project = extractProjectFromPath(fp, config);
+                    if (project)
+                        projectCounts.set(project, (projectCounts.get(project) || 0) + 1);
+                }
+            }
+        }
+    }
+    // Classify snapshot-only Claude files explicitly (avoid heartbeat mislabel)
+    if (isClaudeCode && sawSnapshotRecord && !sawNonSnapshotRecord) {
+        sessionType = 'snapshot';
+        if (!summary)
+            summary = 'Claude file snapshot';
+    }
+    // Normalize summary text
+    if (summary)
+        summary = stripLeadingDatetimePrefix(summary);
+    // If no real summary found, set a sensible default
+    if (!summary) {
+        if (isCodexCli) {
+            const parts = ['Codex CLI session'];
+            if (codexProvider)
+                parts.push(`provider=${codexProvider}`);
+            if (codexSource)
+                parts.push(`source=${codexSource}`);
+            if (codexOriginator)
+                parts.push(`originator=${codexOriginator}`);
+            summary = parts.join(' · ');
+        }
+        else {
+            summary = 'Heartbeat session';
+        }
+    }
+    // Infer session type from first user message content
+    if (!sessionType && initialPrompt) {
+        const p = initialPrompt.toLowerCase();
+        if (p.includes('[cron:'))
+            sessionType = 'cron';
+        else if (p.includes('heartbeat') && p.includes('heartbeat_ok'))
+            sessionType = 'heartbeat';
+    }
+    if (!sessionType && !initialPrompt)
+        sessionType = 'heartbeat';
+    // Detect subagent: task-style prompts injected by sessions_spawn
+    if (!sessionType && initialPrompt) {
+        const p = initialPrompt.trim();
+        if (/^\[(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)\s+\d{4}-/.test(p) && !p.includes('[System Message]')) {
+            sessionType = 'subagent';
+        }
+    }
+    const modelsJson = modelsSet.size > 0 ? JSON.stringify([...modelsSet]) : null;
+    const projects = [...projectCounts.entries()]
+        .sort((a, b) => (b[1] - a[1]) || a[0].localeCompare(b[0]))
+        .map(([name]) => name);
+    const projectsJson = projects.length > 0 ? JSON.stringify(projects) : null;
+    // --- All DB operations in a single transaction for atomicity ---
+    const commitIndex = db.transaction(() => {
+        stmts.deleteEvents.run(sessionId);
+        stmts.deleteFileActivity.run(sessionId);
+        if (stmts.deleteArchive)
+            stmts.deleteArchive.run(sessionId);
+        stmts.deleteSession.run(sessionId);
+        stmts.upsertSession.run(sessionId, sessionStart, sessionEnd, msgCount, toolCount, model, summary, agent, sessionType, totalCost, totalTokens, totalInputTokens, totalOutputTokens, totalCacheReadTokens, totalCacheWriteTokens, initialPrompt, firstMessageId, firstMessageTimestamp, modelsJson, projectsJson);
+        for (const ev of pendingEvents)
+            stmts.insertEvent.run(...ev);
+        for (const fa of fileActivities)
+            stmts.insertFileActivity.run(...fa);
+        // Archive mode: store raw JSONL lines
+        if (archiveMode && stmts.insertArchive) {
+            for (let i = 0; i < lines.length; i++) {
+                stmts.insertArchive.run(sessionId, i + 1, lines[i]);
+            }
+        }
+        stmts.upsertState.run(filePath, lines.length, mtime);
+    });
+    commitIndex();
+    return { sessionId: sessionId, msgCount, toolCount };
+}
+function run() {
+    const config = (0, config_js_1.loadConfig)();
+    (0, db_js_1.init)();
+    const db = (0, db_js_1.open)();
+    const archiveMode = config.storage === 'archive';
+    console.log(`AgentActa indexer running in ${config.storage} mode`);
+    const stmts = (0, db_js_1.createStmts)(db);
+    const sessionDirs = discoverSessionDirs(config);
+    console.log(`Discovered ${sessionDirs.length} session directories:`);
+    sessionDirs.forEach(d => console.log(`  ${d.agent}: ${d.path}`));
+    let allFiles = [];
+    for (const dir of sessionDirs) {
+        const files = listJsonlFiles(dir.path, !!dir.recursive)
+            .map(filePath => ({ path: filePath, agent: dir.agent, sourceType: dir.sourceType || 'transcript' }));
+        allFiles.push(...files);
+    }
+    console.log(`Found ${allFiles.length} session files`);
+    const indexMany = db.transaction(() => {
+        let indexed = 0;
+        for (const f of allFiles) {
+            const result = f.sourceType === 'cron-run'
+                ? indexCronRunFile(db, f.path, f.agent, stmts)
+                : indexFile(db, f.path, f.agent, stmts, archiveMode, config);
+            if (!result.skipped) {
+                indexed++;
+                if (indexed % 10 === 0)
+                    process.stdout.write('.');
+            }
+        }
+        return indexed;
+    });
+    const count = indexMany();
+    console.log(`\nIndexed ${count} sessions`);
+    const stats = db.prepare('SELECT COUNT(*) as sessions FROM sessions').get();
+    const evStats = db.prepare('SELECT COUNT(*) as events FROM events').get();
+    console.log(`Total: ${stats.sessions} sessions, ${evStats.events} events`);
+    if (WATCH) {
+        console.log('\nWatching for changes...');
+        const rescanTimers = new Map();
+        for (const dir of sessionDirs) {
+            node_fs_1.default.watch(dir.path, { persistent: true }, (_eventType, filename) => {
+                // Recursive sources (e.g. ~/.codex/sessions/YYYY/MM/DD/*.jsonl):
+                // fs.watch on Linux does not watch nested dirs recursively, so on any root event
+                // run a debounced full rescan of known JSONL files under this source.
+                if (dir.recursive) {
+                    const key = dir.path;
+                    const existing = rescanTimers.get(key);
+                    if (existing)
+                        clearTimeout(existing);
+                    const t = setTimeout(() => {
+                        try {
+                            const files = listJsonlFiles(dir.path, true);
+                            let changed = 0;
+                            for (const filePath of files) {
+                                const result = dir.sourceType === 'cron-run'
+                                    ? indexCronRunFile(db, filePath, dir.agent, stmts)
+                                    : indexFile(db, filePath, dir.agent, stmts, archiveMode, config);
+                                if (!result.skipped)
+                                    changed++;
+                            }
+                            if (changed > 0)
+                                console.log(`Re-indexed ${changed} files (${dir.agent})`);
+                        }
+                        catch (err) {
+                            console.error(`Error rescanning ${dir.path}:`, err.message);
+                        }
+                    }, 500);
+                    rescanTimers.set(key, t);
+                    return;
+                }
+                if (!filename || !filename.endsWith('.jsonl'))
+                    return;
+                const filePath = node_path_1.default.join(dir.path, filename);
+                if (!node_fs_1.default.existsSync(filePath))
+                    return;
+                setTimeout(() => {
+                    try {
+                        const result = dir.sourceType === 'cron-run'
+                            ? indexCronRunFile(db, filePath, dir.agent, stmts)
+                            : indexFile(db, filePath, dir.agent, stmts, archiveMode, config);
+                        if (!result.skipped)
+                            console.log(`Re-indexed: ${filename} (${dir.agent})`);
+                    }
+                    catch (err) {
+                        console.error(`Error re-indexing ${filename}:`, err.message);
+                    }
+                }, 500);
+            });
+        }
+    }
+    else {
+        db.close();
+    }
+}
+function indexAll(db, config) {
+    const sessionDirs = discoverSessionDirs(config);
+    const archiveMode = config.storage === 'archive';
+    const stmts = (0, db_js_1.createStmts)(db);
+    let totalSessions = 0;
+    for (const dir of sessionDirs) {
+        const files = listJsonlFiles(dir.path, !!dir.recursive);
+        for (const filePath of files) {
+            try {
+                const result = dir.sourceType === 'cron-run'
+                    ? indexCronRunFile(db, filePath, dir.agent, stmts)
+                    : indexFile(db, filePath, dir.agent, stmts, archiveMode, config);
+                if (!result.skipped)
+                    totalSessions++;
+            }
+            catch (err) {
+                console.error(`Error indexing ${node_path_1.default.basename(filePath)}:`, err.message);
+            }
+        }
+    }
+    const stats = db.prepare('SELECT COUNT(*) as sessions FROM sessions').get();
+    const evStats = db.prepare('SELECT COUNT(*) as events FROM events').get();
+    return { sessions: stats.sessions, events: evStats.events, newSessions: totalSessions };
+}
+if (require.main === module)
+    run();
+//# sourceMappingURL=indexer.js.map