@statforge/claudestat 1.6.0 → 1.7.0

package/dist/routes/intents.js

@@ -0,0 +1,155 @@
+"use strict";
+// ─── /api/intent/* — Multi-tool file coordination ─────────────────────────────
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.intentsRouter = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = __importDefault(require("fs"));
+const express_1 = require("express");
+const db_1 = require("../db");
+const stream_1 = require("./stream");
+function computeHash(filePath) {
+    try {
+        if (!fs_1.default.existsSync(filePath))
+            return null;
+        const content = fs_1.default.readFileSync(filePath);
+        return crypto_1.default.createHash('sha256').update(content).digest('hex');
+    }
+    catch {
+        return null;
+    }
+}
+// Middleware para validar required `id` en body
+const validateId = (req, res, next) => {
+    const { id } = req.body;
+    if (!id) {
+        res.status(400).json({ error: 'id is required' });
+        return;
+    }
+    next();
+};
+exports.intentsRouter = (0, express_1.Router)();
+// POST /api/intent/declare
+// Body: { tool, session_id, task_desc?, files: [{ file_path, operation?, line_start?, line_end? }] }
+// Returns: { id, status: 'acquired'|'blocked', blocked_by?, files? }
+exports.intentsRouter.post('/api/intent/declare', (req, res) => {
+    const { tool, session_id, task_desc, files } = req.body;
+    if (!tool || !session_id || !Array.isArray(files) || files.length === 0) {
+        res.status(400).json({ error: 'tool, session_id and files[] are required' });
+        return;
+    }
+    const writeFiles = files.filter(f => !f.operation || f.operation === 'write');
+    const writePaths = writeFiles
+        .map(f => f.file_path)
+        .filter((p) => typeof p === 'string' && p.startsWith('/'));
+    if (writePaths.length < writeFiles.length) {
+        res.status(400).json({ error: 'file_path must be an absolute path (starting with /)' });
+        return;
+    }
+    // Check conflicts from other tools
+    const conflicts = writePaths.length > 0 ? db_1.dbOps.getWriteConflicts(writePaths, tool) : [];
+    if (conflicts.length > 0) {
+        const blockedBy = conflicts[0].tool;
+        (0, stream_1.broadcast)({ type: 'intent_conflict', payload: {
+                files: conflicts.map(c => c.file_path),
+                locked_by: blockedBy,
+                session_id: conflicts[0].session_id,
+                task: conflicts[0].task_desc,
+            } });
+        res.json({
+            id: null, status: 'blocked',
+            blocked_by: blockedBy,
+            files: conflicts.map(c => c.file_path),
+        });
+        return;
+    }
+    // Acquire
+    const id = db_1.dbOps.insertIntent(tool, session_id, task_desc);
+    const filePaths = [];
+    for (const f of files) {
+        if (f.file_path) {
+            db_1.dbOps.insertIntentFile(id, f.file_path, f.operation ?? 'write', f.line_start, f.line_end);
+            filePaths.push(f.file_path);
+        }
+    }
+    (0, stream_1.broadcast)({ type: 'intent_declared', payload: { tool, files: filePaths, task: task_desc } });
+    res.json({ id, status: 'acquired' });
+});
+// POST /api/intent/done
+// Body: { id }
+exports.intentsRouter.post('/api/intent/done', validateId, (req, res) => {
+    const { id } = req.body;
+    const intent = db_1.dbOps.getIntent(id);
+    const files = db_1.dbOps.getIntentFiles(id);
+    db_1.dbOps.releaseIntent(id);
+    for (const f of files) {
+        (0, stream_1.broadcast)({ type: 'intent_released', payload: { file: f.file_path, operation: f.operation, tool: intent?.tool } });
+    }
+    res.json({ ok: true });
+});
+// POST /api/intent/heartbeat
+// Body: { id }
+exports.intentsRouter.post('/api/intent/heartbeat', validateId, (req, res) => {
+    const { id } = req.body;
+    db_1.dbOps.heartbeatIntent(id);
+    res.json({ ok: true });
+});
+// GET /api/intent/status?files=path1,path2
+exports.intentsRouter.get('/api/intent/status', (req, res) => {
+    const raw = req.query.files;
+    const tool = req.query.exclude_tool;
+    const paths = raw ? raw.split(',').map(p => p.trim()).filter(Boolean) : [];
+    if (paths.length === 0) {
+        res.json({ conflicts: [] });
+        return;
+    }
+    const conflicts = db_1.dbOps.getWriteConflicts(paths, tool ?? '');
+    res.json({
+        conflicts: conflicts.map(c => ({
+            file: c.file_path,
+            locked_by: c.tool,
+            task: c.task_desc,
+            since: c.acquired_at,
+        })),
+    });
+});
+// POST /api/intent/check-hash — verify files haven't changed since last known hash
+// Body: { files: [{ file_path: string, hash: string }] }
+// Returns: { safe: boolean, changed: Array<{ file_path, current_hash }> }
+exports.intentsRouter.post('/api/intent/check-hash', (req, res) => {
+    const { files } = req.body;
+    if (!Array.isArray(files) || files.length === 0) {
+        res.status(400).json({ error: 'files[] is required' });
+        return;
+    }
+    const changed = [];
+    for (const f of files) {
+        const current = computeHash(f.file_path);
+        if (current && f.hash && current !== f.hash) {
+            changed.push({ file_path: f.file_path, current_hash: current });
+        }
+    }
+    res.json({ safe: changed.length === 0, changed });
+});
+// GET /api/intent/hashes?files=/abs/path1,/abs/path2
+// Returns current SHA256 hashes for the given file paths
+exports.intentsRouter.get('/api/intent/hashes', (req, res) => {
+    const raw = req.query.files;
+    const paths = raw ? raw.split(',').map(p => p.trim()).filter((p) => !!p && p.startsWith('/')) : [];
+    if (paths.length === 0) {
+        res.status(400).json({ error: 'files query param required (comma-separated absolute paths)' });
+        return;
+    }
+    const hashes = {};
+    for (const p of paths) {
+        hashes[p] = computeHash(p);
+    }
+    res.json({ hashes });
+});
+// GET /api/intent/active — list all currently active intents
+exports.intentsRouter.get('/api/intent/active', (_req, res) => {
+    const intents = db_1.dbOps.getActiveIntents();
+    res.json({ intents });
+});

package/dist/routes/misc.js

@@ -22,6 +22,7 @@ const projects_1 = require("./projects");
 const session_state_1 = require("../session-state");
 const stream_1 = require("./stream");
 const paths_1 = require("../paths");
+const opencode_1 = require("../watchers/opencode");
 const cost_projector_1 = require("../cost-projector");
 exports.miscRouter = (0, express_1.Router)();
 // ─── GET /git?path=... — git info para un proyecto ────────────────────────────
@@ -134,14 +135,14 @@ exports.miscRouter.get('/claude-stats', (_req, res) => {
 });
 // ─── GET /api/active-sessions — fuentes activas en los últimos 5 min ──────────
 exports.miscRouter.get('/api/active-sessions', (_req, res) => {
-    const cutoff = Date.now() - 5 * 60 * 1000;
+    const cutoff = Date.now() - 24 * 60 * 60 * 1000;
     const sessions = db_1.dbOps.getAllSessions();
     const bySource = new Map();
     for (const s of sessions) {
         const lastSeen = s.last_event_at ?? s.started_at;
         if (lastSeen < cutoff)
             continue;
-        const src = s.source ?? 'claude-code';
+        const src = s.source ?? 'unknown';
         const existing = bySource.get(src);
         if (!existing || lastSeen > existing.last_seen_ms) {
             bySource.set(src, {
@@ -153,10 +154,16 @@ exports.miscRouter.get('/api/active-sessions', (_req, res) => {
                 output_tokens: s.total_output_tokens ?? 0,
                 cache_read: s.total_cache_read ?? 0,
                 cache_creation: s.total_cache_creation ?? 0,
+                project: s.project_path ?? s.cwd ?? null,
             });
         }
     }
-    const result = Array.from(bySource.entries()).map(([source, v]) => ({ source, ...v }));
+    const KNOWN_SOURCES = new Set(['claude-code', 'opencode', 'codex', 'amp', 'droid', 'codebuff']);
+    let result = Array.from(bySource.entries())
+        .filter(([source]) => KNOWN_SOURCES.has(source))
+        .map(([source, v]) => ({ source, ...v }));
+    // OpenCode: filter out archived sessions (user closed the tool)
+    result = result.filter(s => s.source !== 'opencode' || !(0, opencode_1.isSessionArchived)(s.sessionId));
     res.json(result);
 });
 // ─── GET /system-config — mapa completo del setup de Claude ──────────────────
@@ -262,7 +269,74 @@ exports.miscRouter.get('/system-config', (_req, res) => {
         const modeDistribution = db_1.dbOps.getModeDistribution(7);
         // 6. Config de claudestat
         const claudestatConfig = (0, config_1.readConfig)();
-        _systemConfigCache = { hooks, agents, workflows, skills, contextFiles, memoryFiles, modeDistribution, claudestatConfig };
+        // ─── 7. OpenCode data ────────────────────────────────────────────────────────
+        const opencodeDir = (0, paths_1.getOpencodeDir)();
+        let opencodeConfig = null;
+        try {
+            opencodeConfig = JSON.parse(fs_1.default.readFileSync(path_1.default.join(opencodeDir, 'opencode.json'), 'utf-8'));
+        }
+        catch { }
+        let opencodeAgentsMd = null;
+        try {
+            const p = path_1.default.join(opencodeDir, 'AGENTS.md');
+            const content = fs_1.default.readFileSync(p, 'utf-8');
+            opencodeAgentsMd = { lines: content.split('\n').length, sizeKb: Math.round(Buffer.byteLength(content, 'utf-8') / 1024 * 10) / 10 };
+        }
+        catch { }
+        let opencodeSkills = [];
+        try {
+            const skillsDir = path_1.default.join(opencodeDir, 'skills');
+            for (const entry of fs_1.default.readdirSync(skillsDir, { withFileTypes: true })) {
+                if (entry.isDirectory()) {
+                    const skillMd = path_1.default.join(skillsDir, entry.name, 'SKILL.md');
+                    try {
+                        const content = fs_1.default.readFileSync(skillMd, 'utf-8');
+                        const lines = content.split('\n').length;
+                        const description = content.match(/^description:\s*(.+)$/m)?.[1]?.trim() ?? '';
+                        opencodeSkills.push({ name: entry.name, description, lines });
+                    }
+                    catch { }
+                }
+            }
+        }
+        catch { }
+        let opencodeAgents = [];
+        try {
+            const agentsDir = path_1.default.join(opencodeDir, 'agents');
+            opencodeAgents = fs_1.default.readdirSync(agentsDir).filter(f => f.endsWith('.md'));
+        }
+        catch { }
+        let opencodeProjects = 0;
+        try {
+            const raw = JSON.parse(fs_1.default.readFileSync(path_1.default.join(opencodeDir, 'projects.json'), 'utf-8'));
+            opencodeProjects = Object.keys(raw.projects ?? {}).length;
+        }
+        catch { }
+        let opencodeCommands = [];
+        try {
+            const cmdsDir = path_1.default.join(opencodeDir, 'commands');
+            opencodeCommands = fs_1.default.readdirSync(cmdsDir).filter(f => f.endsWith('.md'));
+        }
+        catch { }
+        const opencodePlugins = [];
+        try {
+            const pluginsDir = path_1.default.join(opencodeDir, 'plugins');
+            opencodePlugins.push(...fs_1.default.readdirSync(pluginsDir).filter(f => f.endsWith('.ts') || f.endsWith('.js')));
+        }
+        catch { }
+        _systemConfigCache = {
+            hooks, agents, workflows, skills, contextFiles, memoryFiles,
+            modeDistribution, claudestatConfig,
+            opencode: {
+                config: opencodeConfig,
+                agentsMd: opencodeAgentsMd,
+                skills: opencodeSkills,
+                agents: opencodeAgents,
+                projects: opencodeProjects,
+                commands: opencodeCommands,
+                plugins: opencodePlugins,
+            },
+        };
         _systemConfigCacheTs = Date.now();
         res.json(_systemConfigCache);
     }
@@ -294,3 +368,57 @@ exports.miscRouter.put('/config', (req, res) => {
 exports.miscRouter.get('/cost-projection', (_req, res) => {
     res.json((0, cost_projector_1.computeProjection)(90));
 });
+// ─── GET /coordination/status — detección automática de herramienta activa ───
+exports.miscRouter.get('/coordination/status', (req, res) => {
+    const project = req.query.project;
+    const tool = req.query.tool ?? 'unknown';
+    if (!project) {
+        res.status(400).json({ error: 'project is required' });
+        return;
+    }
+    const active = db_1.dbOps.getActiveToolsInProject(project, tool);
+    res.json({
+        other_tool_active: active.length > 0,
+        tools: active.map(r => r.source),
+        since: active.length > 0 ? Math.min(...active.map(r => r.last_event_at)) : null,
+    });
+});
+// ─── GET /tool-status — estado de cada tool (claude-code, opencode) ──────────
+const AI_COLLAB_STATUS = path_1.default.join(process.env.HOME ?? '/tmp', '.ai-collab', 'STATUS.json');
+exports.miscRouter.get('/tool-status', (_req, res) => {
+    try {
+        const raw = fs_1.default.readFileSync(AI_COLLAB_STATUS, 'utf-8');
+        res.json(JSON.parse(raw));
+    }
+    catch {
+        res.json({
+            'claude-code': { status: 'unknown', last_task: null, finished_at: null, session_id: null, waiting_for: null },
+            'opencode': { status: 'unknown', last_task: null, finished_at: null, session_id: null, waiting_for: null },
+        });
+    }
+});
+// ─── POST /tool-status — actualizar estado de un tool ────────────────────────
+exports.miscRouter.post('/tool-status', (req, res) => {
+    const { tool, status, last_task, session_id, waiting_for } = req.body;
+    if (!tool || !status) {
+        res.status(400).json({ error: 'tool and status are required' });
+        return;
+    }
+    let current = {};
+    try {
+        current = JSON.parse(fs_1.default.readFileSync(AI_COLLAB_STATUS, 'utf-8'));
+    }
+    catch { }
+    const finished_at = status === 'idle' ? Date.now() : null;
+    current[tool] = { status, last_task: last_task ?? null, finished_at, session_id: session_id ?? null, waiting_for: waiting_for ?? null };
+    try {
+        fs_1.default.mkdirSync(path_1.default.dirname(AI_COLLAB_STATUS), { recursive: true });
+        fs_1.default.writeFileSync(AI_COLLAB_STATUS, JSON.stringify(current, null, 2), 'utf-8');
+    }
+    catch (e) {
+        res.status(500).json({ error: String(e) });
+        return;
+    }
+    (0, stream_1.broadcast)({ type: 'tool_status_changed', payload: { tool, status, last_task: last_task ?? null, finished_at, session_id: session_id ?? null, waiting_for: waiting_for ?? null } });
+    res.json({ ok: true });
+});

package/dist/routes/opencode-reader.js

@@ -10,12 +10,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.opencodeReaderRouter = void 0;
-const os_1 = __importDefault(require("os"));
-const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const express_1 = require("express");
+const paths_1 = require("../paths");
 exports.opencodeReaderRouter = (0, express_1.Router)();
-const OPENCODE_DB = path_1.default.join(os_1.default.homedir(), '.local', 'share', 'opencode', 'opencode.db');
 // OpenCode tool names → claudestat canonical names
 const TOOL_NAME_MAP = {
     glob: 'Glob', read: 'Read', write: 'Write', edit: 'Edit', bash: 'Bash',
@@ -27,23 +25,59 @@ function mapToolName(raw) {
 }
 function openDb() {
     const { DatabaseSync } = require('node:sqlite');
-    return new DatabaseSync(OPENCODE_DB, { open: true });
+    return new DatabaseSync((0, paths_1.getOpencodeDb)(), { open: true });
 }
 exports.opencodeReaderRouter.get('/api/opencode/session/:id', (req, res) => {
-    if (!fs_1.default.existsSync(OPENCODE_DB)) {
+    if (!fs_1.default.existsSync((0, paths_1.getOpencodeDb)())) {
         res.status(404).json({ error: 'OpenCode DB not found' });
         return;
     }
     try {
         const { id: sessionId } = req.params;
         const db = openDb();
-        // Get all messages for this session ordered by time
+        // ── Find all related session IDs (OpenCode creates one session per prompt) ──
+        // Look up directory for this session
+        const sessionRow = db.prepare(`
+      SELECT directory, time_created FROM session WHERE id = ?
+    `).get(sessionId);
+        let sessionIds = [sessionId];
+        if (sessionRow?.directory) {
+            // Find sessions with same directory, ordered by creation time
+            const sameDir = db.prepare(`
+        SELECT id, time_created FROM session
+        WHERE directory = ? AND time_archived IS NULL
+        ORDER BY time_created ASC
+      `).all(sessionRow.directory);
+            if (sameDir.length > 1) {
+                // Locate our session in the sorted list
+                let idx = sameDir.findIndex(s => s.id === sessionId);
+                if (idx !== -1) {
+                    // Expand forward: consecutive sessions with gap < 60s
+                    let end = idx;
+                    for (let i = idx + 1; i < sameDir.length; i++) {
+                        if (sameDir[i].time_created - sameDir[i - 1].time_created > 300000)
+                            break;
+                        end = i;
+                    }
+                    // Expand backward
+                    let begin = idx;
+                    for (let i = idx - 1; i >= 0; i--) {
+                        if (sameDir[begin].time_created - sameDir[i].time_created > 300000)
+                            break;
+                        begin = i;
+                    }
+                    sessionIds = sameDir.slice(begin, end + 1).map(s => s.id);
+                }
+            }
+        }
+        // ── Query messages from ALL sessions in the group ──
+        const placeholders = sessionIds.map(() => '?').join(',');
         const messages = db.prepare(`
       SELECT id, time_created, time_updated, data
       FROM message
-      WHERE session_id = ?
+      WHERE session_id IN (${placeholders})
       ORDER BY time_created ASC
-    `).all(sessionId);
+    `).all(...sessionIds);
         const events = [];
         const prompts = [];
         let totalParts = 0;

package/dist/routes/projects.js

@@ -125,6 +125,14 @@ exports.projectsRouter.get('/projects', (_req, res) => {
             jsonl_source: useJSONL,
         });
     }
+    // CLI hours per project (source breakdown from DB)
+    const cliHoursRows = db_1.dbOps.getProjectCliHours();
+    const cliHoursMap = new Map();
+    for (const row of cliHoursRows) {
+        if (!cliHoursMap.has(row.project_path))
+            cliHoursMap.set(row.project_path, {});
+        cliHoursMap.get(row.project_path)[row.source] = row.total_ms / 3600000;
+    }
     // Attach pattern insights per project (only if DB has enough data)
     const projects = [...projectMap.values()].map(p => {
         const toolCounts = db_1.dbOps.getProjectToolCounts(p.path);
@@ -132,7 +140,8 @@ exports.projectsRouter.get('/projects', (_req, res) => {
         const insights = (sessionStats && sessionStats.session_count >= 2)
             ? (0, pattern_analyzer_1.analyzePatterns)(toolCounts, sessionStats)
             : [];
-        return { ...p, insights };
+        const cli_hours = cliHoursMap.get(p.path);
+        return { ...p, insights, ...(cli_hours ? { cli_hours } : {}) };
     })
         .sort((a, b) => (b.last_active ?? 0) - (a.last_active ?? 0));
     res.json({ projects, active_project: activeProject });

package/dist/routes/replay.d.ts

@@ -0,0 +1 @@
+export declare const replayRouter: import("express-serve-static-core").Router;

package/dist/routes/replay.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replayRouter = void 0;
+const express_1 = require("express");
+const db_1 = require("../db");
+exports.replayRouter = (0, express_1.Router)();
+const CONTEXT_WINDOW = 200000;
+exports.replayRouter.get('/session/:id/replay', (req, res) => {
+    const { id } = req.params;
+    const turns = db_1.dbOps.getAssistantTurns(id);
+    res.json({ turns, context_window: CONTEXT_WINDOW });
+});
+function buildTree(sessionId, depth = 0) {
+    if (depth > 5)
+        return { id: sessionId, started_at: 0, children: [] };
+    const session = db_1.dbOps.getSession(sessionId);
+    const children = db_1.dbOps.getChildSessions(sessionId);
+    return {
+        id: sessionId,
+        dominant_model: session?.dominant_model ?? undefined,
+        total_cost_usd: session?.total_cost_usd ?? undefined,
+        started_at: session?.started_at ?? 0,
+        children: children.map(c => buildTree(c.id, depth + 1)),
+    };
+}
+exports.replayRouter.get('/session/:id/agent-tree', (req, res) => {
+    const { id } = req.params;
+    res.json(buildTree(id));
+});

package/dist/routes/reports.js

@@ -61,6 +61,13 @@ exports.reportsRouter.get('/api/analytics', (req, res) => {
         },
     });
 });
+// ─── GET /api/analytics/coach — eventos combinados para el coach multi-source ─
+exports.reportsRouter.get('/api/analytics/coach', (req, res) => {
+    const raw = req.query.session_ids;
+    const sessionIds = raw ? raw.split(',').map(s => s.trim()).filter(Boolean) : [];
+    const events = db_1.dbOps.getCoachEvents(sessionIds);
+    res.json({ events });
+});
 // ─── POST /api/weekly-reports/generate-now — generar informe inmediatamente ───
 exports.reportsRouter.post('/api/weekly-reports/generate-now', (_req, res) => {
     const cfg = (0, config_1.readConfig)();

package/dist/routes/stream.js

@@ -46,7 +46,7 @@ exports.streamRouter.get('/stream', (req, res) => {
     res.flushHeaders();
     const clientId = Math.random().toString(36).slice(2);
     sseClients.set(clientId, res);
-    const latestSession = db_1.dbOps.getLatestClaudeSession();
+    const latestSession = db_1.dbOps.getLatestSession();
     if (latestSession) {
         const allEvents = db_1.dbOps.getSessionEvents(latestSession.id);
         const events = allEvents.length > SSE_INIT_EVENT_LIMIT

package/dist/routes/top.js

@@ -8,18 +8,25 @@ exports.topRouter.get('/api/top', (req, res) => {
     const by = req.query.by ?? 'cost';
     const limit = Math.min(parseInt(req.query.limit, 10) || 10, 50);
     const days = Math.min(parseInt(req.query.days, 10) || 30, 365);
+    const source = req.query.source ?? 'all';
     if (!['cost', 'count', 'duration'].includes(by)) {
         res.status(400).json({ error: 'Invalid "by" parameter. Use: cost, count, duration' });
         return;
     }
-    const tools = db_1.dbOps.getTopTools(days, by, limit);
+    if (!['all', 'claude-code', 'opencode'].includes(source)) {
+        res.status(400).json({ error: 'Invalid "source" parameter. Use: all, claude-code, opencode' });
+        return;
+    }
+    const tools = db_1.dbOps.getTopTools(days, by, limit, source);
     const totalCost = tools.reduce((s, t) => s + t.total_cost_usd, 0);
     const totalCount = tools.filter(t => t.tool_name !== 'Other').reduce((s, t) => s + t.count, 0);
     res.json({
         by,
         days,
+        source,
         tools: tools.map(t => ({
             tool: t.tool_name,
+            source: t.source,
             count: t.count,
             totalDurationMs: t.total_duration_ms,
             estimatedCostUsd: t.total_cost_usd,

package/dist/watchers/adapter.d.ts

@@ -33,6 +33,7 @@ export interface WatcherAdapter {
 export interface PollSession {
     sessionId: string;
     cost: CostUpdate;
+    cwd?: string;
 }
 /** Adapters que no usan archivos JSONL sino una DB o API propia */
 export interface PollableAdapter extends WatcherAdapter {

package/dist/watchers/claude-code.d.ts

@@ -6,8 +6,23 @@
  */
 import { type WatcherAdapter } from './adapter';
 import type { BlockCostEntry } from '../db';
-export declare function getContextWindow(model: string): number;
 export declare const claudeCodeAdapter: WatcherAdapter;
+export interface AssistantTurn {
+    turn_index: number;
+    ts?: number;
+    text_preview: string;
+    tool_calls: string[];
+    error_count: number;
+    output_chars: number;
+    context_used: number;
+}
+export interface SemanticData {
+    turns: AssistantTurn[];
+    avg_output_chars: number;
+    error_block_count: number;
+}
+export declare function findJSONLForSession(sessionId: string): Promise<string | null>;
+export declare function extractSemanticData(filePath: string): Promise<SemanticData | null>;
 export declare function getAllBlockCostsForSession(sessionId: string): Promise<BlockCostEntry[]>;
 export interface SessionPrompt {
     index: number;