@statforge/claudestat 1.0.1

package/dist/routes/projects.js

@@ -0,0 +1,153 @@
+"use strict";
+// ─── GET /projects — listado de proyectos con stats ──────────────────────────
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectsRouter = void 0;
+exports.findProjectCwdForFile = findProjectCwdForFile;
+exports.inferProjectCwd = inferProjectCwd;
+exports.inferActiveProjectByMajority = inferActiveProjectByMajority;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const express_1 = require("express");
+const db_1 = require("../db");
+const projects_cache_1 = require("../cache/projects-cache");
+const pattern_analyzer_1 = require("../pattern-analyzer");
+exports.projectsRouter = (0, express_1.Router)();
+/** Sube el árbol desde un file_path hasta encontrar HANDOFF.md → directorio del proyecto */
+function findProjectCwdForFile(filePath) {
+    let dir = path_1.default.dirname(filePath);
+    for (let i = 0; i < 6; i++) {
+        if (fs_1.default.existsSync(path_1.default.join(dir, 'HANDOFF.md')))
+            return dir;
+        const parent = path_1.default.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return undefined;
+}
+/** Infiere el proyecto activo mirando los eventos de archivo de una sesión */
+function inferProjectCwd(events) {
+    const FILE_TOOLS = new Set(['Read', 'Write', 'Edit', 'Glob', 'Grep']);
+    for (const ev of [...events].reverse()) {
+        if (!FILE_TOOLS.has(ev.tool_name || ''))
+            continue;
+        if (!ev.tool_input)
+            continue;
+        try {
+            const inp = JSON.parse(ev.tool_input);
+            const filePath = (inp.file_path || inp.path);
+            if (!filePath?.startsWith('/'))
+                continue;
+            const cwd = findProjectCwdForFile(filePath);
+            if (cwd)
+                return cwd;
+        }
+        catch { /* ignorar */ }
+    }
+    return undefined;
+}
+/**
+ * Determina el proyecto activo por mayoría de operaciones de archivo
+ * en una ventana de tiempo reciente. Evita que un único archivo tocado
+ * de otro proyecto cambie el badge.
+ *
+ * - Mínimo 2 hits en la ventana para declarar un proyecto como activo.
+ * - Si hay empate, gana el que tuvo actividad más reciente.
+ */
+function inferActiveProjectByMajority(events, windowMs) {
+    const FILE_TOOLS = new Set(['Read', 'Write', 'Edit', 'Glob', 'Grep']);
+    const cutoff = Date.now() - windowMs;
+    const hits = new Map();
+    for (const ev of events) {
+        if ((ev.ts ?? 0) < cutoff)
+            continue;
+        if (!FILE_TOOLS.has(ev.tool_name || ''))
+            continue;
+        if (!ev.tool_input)
+            continue;
+        try {
+            const inp = JSON.parse(ev.tool_input);
+            const filePath = (inp.file_path || inp.path);
+            if (!filePath?.startsWith('/'))
+                continue;
+            const project = findProjectCwdForFile(filePath);
+            if (!project)
+                continue;
+            const entry = hits.get(project) ?? { count: 0, lastTs: 0 };
+            hits.set(project, { count: entry.count + 1, lastTs: Math.max(entry.lastTs, ev.ts ?? 0) });
+        }
+        catch { /* ignorar */ }
+    }
+    if (hits.size === 0)
+        return undefined;
+    // Ordenar por hits desc, luego por timestamp desc en caso de empate
+    const sorted = [...hits.entries()].sort(([, a], [, b]) => b.count !== a.count ? b.count - a.count : b.lastTs - a.lastTs);
+    const [topProject, topStats] = sorted[0];
+    return topStats.count >= 2 ? topProject : undefined;
+}
+exports.projectsRouter.get('/projects', (_req, res) => {
+    // Proyectos del DB (ya etiquetados)
+    const dbAggregates = db_1.dbOps.getProjectAggregates();
+    // Proyectos descubiertos del filesystem (cacheados — pre-computados al arrancar)
+    const scanned = (0, projects_cache_1.getProjectsCached)();
+    // Obtener proyecto activo — mayoría en ventana de 10 min, luego fallbacks
+    const latestSession = db_1.dbOps.getLatestSession();
+    const latestEvents = latestSession ? db_1.dbOps.getSessionEvents(latestSession.id) : [];
+    const activeProject = inferActiveProjectByMajority(latestEvents, 10 * 60000)
+        ?? latestSession?.project_path
+        ?? inferProjectCwd(latestEvents)
+        ?? null;
+    // Merge: DB stats + filesystem scan
+    const projectMap = new Map();
+    for (const agg of dbAggregates) {
+        projectMap.set(agg.project_path, {
+            path: agg.project_path,
+            name: path_1.default.basename(agg.project_path),
+            session_count: agg.session_count,
+            total_cost_usd: agg.total_cost_usd,
+            total_tokens: (agg.total_input_tokens ?? 0) + (agg.total_output_tokens ?? 0) + (agg.total_cache_read ?? 0),
+            last_active: agg.last_active,
+            avg_efficiency: agg.avg_efficiency ? Math.round(agg.avg_efficiency) : null,
+            progress: { done: 0, total: 0, pct: 0, nextTask: null },
+            has_handoff: false,
+        });
+    }
+    for (const scan of scanned) {
+        const dbEntry = projectMap.get(scan.path);
+        const useJSONL = !dbEntry || dbEntry.session_count === 0;
+        const jStats = scan.jsonlStats;
+        const base = dbEntry ?? {
+            path: scan.path, name: scan.name,
+            session_count: 0, total_cost_usd: 0, total_tokens: 0,
+            last_active: null, avg_efficiency: null,
+        };
+        projectMap.set(scan.path, {
+            ...base,
+            // session_count and last_active: max of DB (live) and JSONL (full history before claudestat install)
+            session_count: Math.max(jStats.session_count, base.session_count),
+            last_active: Math.max(jStats.last_active ?? 0, base.last_active ?? 0) || null,
+            // cost and tokens: always from JSONL — covers full history, not just since claudestat install
+            total_cost_usd: jStats.total_cost_usd,
+            total_tokens: jStats.total_tokens,
+            has_handoff: scan.hasHandoff,
+            auto_handoff: scan.autoHandoff,
+            progress: scan.progress,
+            model_usage: jStats.modelUsage,
+            jsonl_source: useJSONL,
+        });
+    }
+    // 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);
+        const sessionStats = db_1.dbOps.getProjectSessionStats(p.path);
+        const insights = (sessionStats && sessionStats.session_count >= 2)
+            ? (0, pattern_analyzer_1.analyzePatterns)(toolCounts, sessionStats)
+            : [];
+        return { ...p, insights };
+    })
+        .sort((a, b) => (b.last_active ?? 0) - (a.last_active ?? 0));
+    res.json({ projects, active_project: activeProject });
+});

package/dist/routes/reports.d.ts

@@ -0,0 +1,11 @@
+import { type ClaudestatConfig } from '../config';
+export declare const reportsRouter: import("express-serve-static-core").Router;
+/** Número de semana ISO para lógica quincenal (semanas pares = informe). */
+export declare function getISOWeek(date: Date): number;
+/**
+ * Devuelve el label YYYY-MM-DD si ahora es el momento de generar un informe,
+ * o null si no corresponde todavía.
+ */
+export declare function getReportDateLabel(now: Date, cfg: ClaudestatConfig): string | null;
+/** Genera el markdown del informe para el período dado. */
+export declare function generateReport(dateLabel: string, cfg: ClaudestatConfig): string;

package/dist/routes/reports.js

@@ -0,0 +1,205 @@
+"use strict";
+// ─── Rutas de reportes: /api/weekly-reports, /api/analytics, /api/quota-stats
+//     + helpers del scheduler (getReportDateLabel, generateReport, getISOWeek) ──
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reportsRouter = void 0;
+exports.getISOWeek = getISOWeek;
+exports.getReportDateLabel = getReportDateLabel;
+exports.generateReport = generateReport;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const express_1 = require("express");
+const db_1 = require("../db");
+const config_1 = require("../config");
+const paths_1 = require("../paths");
+exports.reportsRouter = (0, express_1.Router)();
+// ─── POST /api/weekly-reports — guardar reporte generado por weekly-review.sh ─
+exports.reportsRouter.post('/api/weekly-reports', (req, res) => {
+    const { date, content } = req.body;
+    if (!date || !content) {
+        res.status(400).json({ error: 'date y content son requeridos' });
+        return;
+    }
+    try {
+        db_1.dbOps.insertWeeklyReport(date, content);
+        res.json({ ok: true });
+    }
+    catch (e) {
+        res.status(500).json({ error: String(e) });
+    }
+});
+// ─── GET /api/analytics — datos diarios agrupados para la vista Analytics ────
+exports.reportsRouter.get('/api/analytics', (req, res) => {
+    const days = Math.min(parseInt(String(req.query.days ?? '30'), 10) || 30, 90);
+    const projectDays = Math.min(parseInt(String(req.query.project_days ?? String(days)), 10) || days, 90);
+    const since = Date.now() - days * 24 * 60 * 60 * 1000;
+    const projectSince = Date.now() - projectDays * 24 * 60 * 60 * 1000;
+    const daily = db_1.dbOps.getAnalyticsDaily(since);
+    const byModel = db_1.dbOps.getAnalyticsByModel(since);
+    const projectHours = db_1.dbOps.getProjectHours(projectSince);
+    // KPIs (siempre sobre últimos 7d y 30d, independiente del período pedido)
+    const now7 = Date.now() - 7 * 24 * 60 * 60 * 1000;
+    const now30 = Date.now() - 30 * 24 * 60 * 60 * 1000;
+    const week = daily.filter(d => new Date(d.date + 'T12:00:00').getTime() >= now7);
+    const month = daily.filter(d => new Date(d.date + 'T12:00:00').getTime() >= now30);
+    const sum = (arr, k) => arr.reduce((a, d) => a + d[k], 0);
+    const avg = (arr, k) => arr.length ? sum(arr, k) / arr.length : 0;
+    res.json({
+        daily,
+        by_model: byModel,
+        project_hours: projectHours,
+        kpis: {
+            week_cost: sum(week, 'cost'),
+            month_cost: sum(month, 'cost'),
+            week_sessions: sum(week, 'sessions'),
+            month_sessions: sum(month, 'sessions'),
+            week_loops: sum(week, 'loops'),
+            avg_efficiency: Math.round(avg(week, 'avg_efficiency')),
+        },
+    });
+});
+// ─── 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)();
+    const dateLabel = new Date().toISOString().slice(0, 10);
+    if (db_1.dbOps.getWeeklyReportByDate(dateLabel)) {
+        res.json({ skipped: true, date: dateLabel });
+        return;
+    }
+    const markdown = generateReport(dateLabel, cfg);
+    db_1.dbOps.insertWeeklyReport(dateLabel, markdown);
+    console.log(`[daemon] Informe generado manualmente: ${dateLabel}`);
+    res.json({ ok: true, date: dateLabel });
+});
+// ─── POST /api/weekly-reports/import-local — importar .md desde ~/.claude/reports ─
+exports.reportsRouter.post('/api/weekly-reports/import-local', (_req, res) => {
+    const reportsDir = path_1.default.join((0, paths_1.getClaudeDir)(), 'reports');
+    if (!fs_1.default.existsSync(reportsDir)) {
+        res.json({ imported: 0, skipped: 0 });
+        return;
+    }
+    const files = fs_1.default.readdirSync(reportsDir).filter(f => /^weekly-\d{4}-\d{2}-\d{2}\.md$/.test(f));
+    let imported = 0, skipped = 0;
+    for (const file of files) {
+        const date = file.replace('weekly-', '').replace('.md', ''); // YYYY-MM-DD
+        const existing = db_1.dbOps.getWeeklyReportByDate(date);
+        if (existing) {
+            skipped++;
+            continue;
+        }
+        const content = fs_1.default.readFileSync(path_1.default.join(reportsDir, file), 'utf8');
+        db_1.dbOps.insertWeeklyReport(date, content);
+        imported++;
+    }
+    res.json({ imported, skipped });
+});
+// ─── GET /api/weekly-reports — lista de reportes (id, date, preview) ──────────
+exports.reportsRouter.get('/api/weekly-reports', (_req, res) => {
+    res.json(db_1.dbOps.listWeeklyReports());
+});
+// ─── GET /api/weekly-reports/:date — reporte completo de una fecha ────────────
+exports.reportsRouter.get('/api/weekly-reports/:date', (req, res) => {
+    const report = db_1.dbOps.getWeeklyReportByDate(req.params.date);
+    if (!report) {
+        res.status(404).json({ error: 'not found' });
+        return;
+    }
+    res.json(report);
+});
+// ─── DELETE /api/weekly-reports/:date — eliminar un reporte ──────────────────
+exports.reportsRouter.delete('/api/weekly-reports/:date', (req, res) => {
+    const report = db_1.dbOps.getWeeklyReportByDate(req.params.date);
+    if (!report) {
+        res.status(404).json({ error: 'not found' });
+        return;
+    }
+    db_1.dbOps.deleteWeeklyReport(req.params.date);
+    res.json({ ok: true });
+});
+// ─── GET /api/quota-stats — P90 de tokens y coste (últimos 30 días) ──────────
+exports.reportsRouter.get('/api/quota-stats', (_req, res) => {
+    const since = Date.now() - 30 * 24 * 60 * 60 * 1000;
+    const rows = db_1.dbOps.getQuotaStats(since);
+    if (rows.length === 0) {
+        res.json({ p90Tokens: 0, p90Cost: 0, sessionCount: 0 });
+        return;
+    }
+    const idx = Math.floor(rows.length * 0.9);
+    const p90Row = rows[Math.min(idx, rows.length - 1)];
+    const sortedByCost = [...rows].sort((a, b) => a.total_cost_usd - b.total_cost_usd);
+    const p90CostRow = sortedByCost[Math.min(idx, sortedByCost.length - 1)];
+    res.json({ p90Tokens: p90Row.total_tokens, p90Cost: p90CostRow.total_cost_usd, sessionCount: rows.length });
+});
+// ─── Report scheduler helpers (exportados para daemon.ts) ────────────────────
+/** Número de semana ISO para lógica quincenal (semanas pares = informe). */
+function getISOWeek(date) {
+    const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+    const day = d.getUTCDay() || 7;
+    d.setUTCDate(d.getUTCDate() + 4 - day);
+    const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+    return Math.ceil((((d.getTime() - yearStart.getTime()) / 86400000) + 1) / 7);
+}
+/**
+ * Devuelve el label YYYY-MM-DD si ahora es el momento de generar un informe,
+ * o null si no corresponde todavía.
+ */
+function getReportDateLabel(now, cfg) {
+    const hhmm = `${String(now.getHours()).padStart(2, '0')}:${String(now.getMinutes()).padStart(2, '0')}`;
+    if (hhmm !== cfg.reportTime)
+        return null;
+    if (now.getDay() !== cfg.reportDay)
+        return null;
+    if (cfg.reportFrequency === 'biweekly' && getISOWeek(now) % 2 !== 0)
+        return null;
+    if (cfg.reportFrequency === 'monthly' && now.getDate() > 7)
+        return null;
+    return now.toISOString().slice(0, 10);
+}
+/** Genera el markdown del informe para el período dado. */
+function generateReport(dateLabel, cfg) {
+    const periodDays = cfg.reportFrequency === 'monthly' ? 30 : cfg.reportFrequency === 'biweekly' ? 14 : 7;
+    const endMs = Date.now();
+    const startMs = endMs - periodDays * 24 * 60 * 60 * 1000;
+    const fromDate = new Date(startMs).toISOString().slice(0, 10);
+    const sessions = db_1.dbOps.getAllSessions().filter(s => s.started_at >= startMs && s.started_at <= endMs);
+    const totalCost = sessions.reduce((a, s) => a + (s.total_cost_usd ?? 0), 0);
+    const totalInput = sessions.reduce((a, s) => a + (s.total_input_tokens ?? 0), 0);
+    const totalOutput = sessions.reduce((a, s) => a + (s.total_output_tokens ?? 0), 0);
+    const totalLoops = sessions.reduce((a, s) => a + (s.loops_detected ?? 0), 0);
+    const avgEff = sessions.length > 0
+        ? Math.round(sessions.reduce((a, s) => a + (s.efficiency_score ?? 100), 0) / sessions.length)
+        : 100;
+    const byProject = new Map();
+    for (const s of sessions) {
+        const key = s.project_path ? path_1.default.basename(s.project_path) : 'Sin proyecto';
+        const cur = byProject.get(key) ?? { sessions: 0, cost: 0 };
+        byProject.set(key, { sessions: cur.sessions + 1, cost: cur.cost + (s.total_cost_usd ?? 0) });
+    }
+    const topProjects = [...byProject.entries()]
+        .sort((a, b) => b[1].cost - a[1].cost)
+        .slice(0, 5);
+    const periodLabel = cfg.reportFrequency === 'monthly' ? 'mensual' : cfg.reportFrequency === 'biweekly' ? 'quincenal' : 'semanal';
+    let md = `# Informe ${periodLabel} — ${dateLabel}\n\n`;
+    md += `> Período: ${fromDate} → ${dateLabel}\n\n`;
+    md += `## Resumen\n\n`;
+    md += `- **Sesiones**: ${sessions.length}\n`;
+    md += `- **Costo total**: $${totalCost.toFixed(4)}\n`;
+    md += `- **Tokens entrada**: ${(totalInput / 1000000).toFixed(2)}M\n`;
+    md += `- **Tokens salida**: ${(totalOutput / 1000000).toFixed(2)}M\n`;
+    md += `- **Eficiencia promedio**: ${avgEff}%\n`;
+    md += `- **Loops detectados**: ${totalLoops}\n\n`;
+    if (topProjects.length > 0) {
+        md += `## Proyectos más activos\n\n`;
+        for (const [name, stats] of topProjects) {
+            md += `- **${name}**: ${stats.sessions} sesión${stats.sessions !== 1 ? 'es' : ''} · $${stats.cost.toFixed(4)}\n`;
+        }
+        md += '\n';
+    }
+    if (sessions.length === 0) {
+        md += `> Sin actividad en este período.\n`;
+    }
+    return md;
+}

package/dist/routes/stream.d.ts

@@ -0,0 +1,8 @@
+export declare const streamRouter: import("express-serve-static-core").Router;
+export declare const sessionLastEvent: Map<string, {
+    type: string;
+    ts: number;
+}>;
+export declare function broadcast(msg: object): void;
+export declare function getSseClientsSize(): number;
+export declare function setOnCostUpdateRef(cb: (sessionId: string, cost: any) => void): void;

package/dist/routes/stream.js

@@ -0,0 +1,70 @@
+"use strict";
+// ─── GET /stream — SSE para claudestat watch ─────────────────────────────────
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sessionLastEvent = exports.streamRouter = void 0;
+exports.broadcast = broadcast;
+exports.getSseClientsSize = getSseClientsSize;
+exports.setOnCostUpdateRef = setOnCostUpdateRef;
+const express_1 = require("express");
+const db_1 = require("../db");
+const enricher_1 = require("../enricher");
+const session_state_1 = require("../session-state");
+exports.streamRouter = (0, express_1.Router)();
+const SSE_INIT_EVENT_LIMIT = 200;
+const sseClients = new Map();
+exports.sessionLastEvent = new Map();
+function broadcast(msg) {
+    let data;
+    try {
+        data = `data: ${JSON.stringify(msg)}\n\n`;
+    }
+    catch {
+        return;
+    }
+    const dead = [];
+    sseClients.forEach((client, id) => {
+        try {
+            client.write(data);
+        }
+        catch {
+            dead.push(id);
+        }
+    });
+    dead.forEach(id => sseClients.delete(id));
+}
+function getSseClientsSize() {
+    return sseClients.size;
+}
+let _onCostUpdateRef = null;
+function setOnCostUpdateRef(cb) {
+    _onCostUpdateRef = cb;
+}
+exports.streamRouter.get('/stream', (req, res) => {
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Connection', 'keep-alive');
+    res.flushHeaders();
+    const clientId = Math.random().toString(36).slice(2);
+    sseClients.set(clientId, res);
+    const latestSession = db_1.dbOps.getLatestSession();
+    if (latestSession) {
+        const allEvents = db_1.dbOps.getSessionEvents(latestSession.id);
+        const events = allEvents.length > SSE_INIT_EVENT_LIMIT
+            ? allEvents.slice(-SSE_INIT_EVENT_LIMIT)
+            : allEvents;
+        const lastEvt = exports.sessionLastEvent.get(latestSession.id);
+        const state = (0, session_state_1.deriveSessionState)(lastEvt?.type, lastEvt?.ts ?? latestSession.last_event_at ?? latestSession.started_at);
+        (0, enricher_1.getAllBlockCostsForSession)(latestSession.id).then(blockCosts => {
+            const subAgentSessions = db_1.dbOps.getChildSessions(latestSession.id);
+            res.write(`data: ${JSON.stringify({ type: 'init', session: { ...latestSession, state }, events, blockCosts, subAgentSessions })}\n\n`);
+            if (_onCostUpdateRef) {
+                (0, enricher_1.processLatestForSession)(latestSession.id, _onCostUpdateRef).catch(err => console.error('[stream] Error processing latest session:', err));
+            }
+        }).catch(err => {
+            console.error('[stream] Error loading block costs:', err);
+            const subAgentSessions = db_1.dbOps.getChildSessions(latestSession.id);
+            res.write(`data: ${JSON.stringify({ type: 'init', session: { ...latestSession, state }, events, blockCosts: [], subAgentSessions })}\n\n`);
+        });
+    }
+    req.on('close', () => sseClients.delete(clientId));
+});

package/dist/routes/top.d.ts

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

package/dist/routes/top.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.topRouter = void 0;
+const express_1 = require("express");
+const db_1 = require("../db");
+exports.topRouter = (0, express_1.Router)();
+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);
+    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);
+    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,
+        tools: tools.map(t => ({
+            tool: t.tool_name,
+            count: t.count,
+            totalDurationMs: t.total_duration_ms,
+            estimatedCostUsd: t.total_cost_usd,
+            pctCost: totalCost > 0 ? Math.round(t.total_cost_usd / totalCost * 100) : 0,
+            pctCount: totalCount > 0 ? Math.round(t.count / totalCount * 100) : 0,
+        })),
+    });
+});

package/dist/session-state.d.ts

@@ -0,0 +1,35 @@
+/**
+ * session-state.ts — State machine para estado de sesión en tiempo real
+ *
+ * Estados posibles:
+ *   working           — Claude está ejecutando un tool (PreToolUse recibido)
+ *   waiting_for_input — Claude terminó su turno (Stop recibido) o sesión recién iniciada
+ *   idle              — Sin actividad por > IDLE_THRESHOLD_MS
+ *
+ * Diseño: módulo puro sin efectos secundarios ni acceso a DB.
+ * El estado se DERIVA a demanda desde el último evento y su timestamp.
+ * No se persiste en DB — se recalcula en cada broadcast y endpoint.
+ *
+ * Por qué no persistir:
+ * - El estado decae automáticamente a "idle" por tiempo, sin necesidad de evento
+ * - Simplifica migraciones y evita estados "atascados" en DB
+ */
+export type SessionState = 'working' | 'waiting_for_input' | 'idle';
+/**
+ * Deriva el estado de sesión a partir del último evento y su timestamp.
+ *
+ * Reglas (en orden de prioridad):
+ * 1. Si han pasado > IDLE_THRESHOLD_MS desde el último evento → idle
+ * 2. PreToolUse o PostToolUse → working (Claude está ejecutando o procesando resultado)
+ * 3. Stop o SessionStart → waiting_for_input
+ * 4. Cualquier otro tipo → waiting_for_input (estado conservador)
+ */
+export declare function deriveSessionState(lastEventType: string | undefined, lastEventTs: number, now?: number): SessionState;
+/**
+ * Metadatos visuales para cada estado — usados en dashboard y CLI.
+ */
+export declare const STATE_META: Record<SessionState, {
+    label: string;
+    color: string;
+    pulse: boolean;
+}>;

package/dist/session-state.js

@@ -0,0 +1,50 @@
+"use strict";
+/**
+ * session-state.ts — State machine para estado de sesión en tiempo real
+ *
+ * Estados posibles:
+ *   working           — Claude está ejecutando un tool (PreToolUse recibido)
+ *   waiting_for_input — Claude terminó su turno (Stop recibido) o sesión recién iniciada
+ *   idle              — Sin actividad por > IDLE_THRESHOLD_MS
+ *
+ * Diseño: módulo puro sin efectos secundarios ni acceso a DB.
+ * El estado se DERIVA a demanda desde el último evento y su timestamp.
+ * No se persiste en DB — se recalcula en cada broadcast y endpoint.
+ *
+ * Por qué no persistir:
+ * - El estado decae automáticamente a "idle" por tiempo, sin necesidad de evento
+ * - Simplifica migraciones y evita estados "atascados" en DB
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STATE_META = void 0;
+exports.deriveSessionState = deriveSessionState;
+// 5 minutos sin actividad → idle automático
+const IDLE_THRESHOLD_MS = 5 * 60 * 1000;
+/**
+ * Deriva el estado de sesión a partir del último evento y su timestamp.
+ *
+ * Reglas (en orden de prioridad):
+ * 1. Si han pasado > IDLE_THRESHOLD_MS desde el último evento → idle
+ * 2. PreToolUse o PostToolUse → working (Claude está ejecutando o procesando resultado)
+ * 3. Stop o SessionStart → waiting_for_input
+ * 4. Cualquier otro tipo → waiting_for_input (estado conservador)
+ */
+function deriveSessionState(lastEventType, lastEventTs, now = Date.now()) {
+    if (now - lastEventTs > IDLE_THRESHOLD_MS)
+        return 'idle';
+    switch (lastEventType) {
+        case 'PreToolUse': return 'working';
+        case 'PostToolUse': return 'working'; // tool terminó, Claude aún procesa la respuesta
+        case 'Stop': return 'waiting_for_input';
+        case 'SessionStart': return 'waiting_for_input';
+        default: return 'waiting_for_input';
+    }
+}
+/**
+ * Metadatos visuales para cada estado — usados en dashboard y CLI.
+ */
+exports.STATE_META = {
+    working: { label: 'working', color: '#3fb950', pulse: true },
+    waiting_for_input: { label: 'waiting', color: '#58a6ff', pulse: false },
+    idle: { label: 'idle', color: '#7d8590', pulse: false },
+};

package/dist/summarizer.d.ts

@@ -0,0 +1,18 @@
+/**
+ * summarizer.ts — Resumen de sesión con IA (opcional)
+ *
+ * Solo se activa si ANTHROPIC_API_KEY está disponible en el entorno.
+ * Si no hay key → retorna null silenciosamente, sin errores ni warnings.
+ *
+ * Usa claude-haiku-4-5 (el modelo más económico) para minimizar coste.
+ * Un resumen de sesión consume ~200 tokens → ~$0.0002 por resumen.
+ *
+ * El cliente de Anthropic se carga con dynamic import para que el daemon
+ * no falle si @anthropic-ai/sdk no está instalado o la key no existe.
+ */
+import type { EventRow } from './db';
+/**
+ * Genera un resumen de 10-15 palabras de lo que hizo Claude en la sesión.
+ * Retorna null si no hay API key o falla la llamada.
+ */
+export declare function summarizeSession(events: EventRow[], costUsd: number, projectName?: string): Promise<string | null>;