@statforge/claudestat 1.0.1

package/dist/routes/events.js

@@ -0,0 +1,272 @@
+"use strict";
+// ─── POST /event — recibe eventos de los hooks de Claude Code ─────────────────
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processLatestForSession = exports.onCompactDetected = exports.onCostUpdate = exports.taggedSessionParents = exports.lastAgentByCwd = exports.eventsRouter = void 0;
+exports.findProjectCwdForFile = findProjectCwdForFile;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const express_1 = require("express");
+const db_1 = require("../db");
+const intelligence_1 = require("../intelligence");
+const summarizer_1 = require("../summarizer");
+const session_state_1 = require("../session-state");
+const quota_tracker_1 = require("../quota-tracker");
+const config_1 = require("../config");
+const rate_limiter_1 = require("../middleware/rate-limiter");
+const stream_1 = require("./stream");
+const enricher_1 = require("../enricher");
+Object.defineProperty(exports, "processLatestForSession", { enumerable: true, get: function () { return enricher_1.processLatestForSession; } });
+exports.eventsRouter = (0, express_1.Router)();
+// Skill activa por sesión — se setea tras Skill Done, se limpia en Stop.
+// Permite taggear los eventos siguientes con skill_parent para agruparlos en la UI.
+const activeSkillBySession = new Map();
+// Último Agent PreToolUse por CWD — se usa para detectar sub-sesiones de agentes.
+// Clave: cwd  Valor: { pre_ts, session_id }
+exports.lastAgentByCwd = new Map();
+// Sesiones ya evaluadas para taggeo de parent — evita re-evaluar en cada cost update.
+exports.taggedSessionParents = new Set();
+// ─── Quota alerter: moving average de 3 muestras + cooldown 1h por nivel ─────
+// Evita falsas alarmas por spikes puntuales. Solo emite si el promedio de las
+// últimas 3 lecturas supera el threshold Y no se emitió ese nivel en la última hora.
+const quotaSamples = []; // últimas 3 lecturas de cyclePct
+const alertCooldown = new Map(); // nivel → timestamp del último aviso
+const ALERT_COOLDOWN_MS = 60 * 60 * 1000; // 1 hora
+const SAMPLES_NEEDED = 3; // muestras para el moving average
+function shouldFireAlert(level, pct) {
+    // Añadir muestra al buffer circular (máx SAMPLES_NEEDED)
+    quotaSamples.push(pct);
+    if (quotaSamples.length > SAMPLES_NEEDED)
+        quotaSamples.shift();
+    // Necesitamos SAMPLES_NEEDED lecturas antes de disparar (evita alert en el primer spike)
+    if (quotaSamples.length < SAMPLES_NEEDED)
+        return false;
+    // Cooldown: no repetir el mismo nivel en la última hora
+    const lastFired = alertCooldown.get(level) ?? 0;
+    if (Date.now() - lastFired < ALERT_COOLDOWN_MS)
+        return false;
+    alertCooldown.set(level, Date.now());
+    return true;
+}
+/** 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;
+}
+exports.eventsRouter.post('/event', (req, res) => {
+    const ip = req.ip ?? '127.0.0.1';
+    if ((0, rate_limiter_1.isRateLimited)(ip)) {
+        res.status(429).json({ error: 'Too many requests — wait 1 minute' });
+        return;
+    }
+    const { type, session_id, tool_name, tool_input, tool_response, ts, cwd, transcript_path } = req.body;
+    if (!session_id || !type) {
+        res.status(400).json({ error: 'Missing session_id or type' });
+        return;
+    }
+    const resolvedCwd = cwd
+        ?? (transcript_path ? transcript_path.split('/').slice(0, -1).join('/') : undefined);
+    db_1.dbOps.upsertSession({ id: session_id, cwd: resolvedCwd, started_at: ts, last_event_at: ts });
+    // Skill grouping: get current parent BEFORE processing this event
+    // (the Skill Done event itself is NOT tagged — only its subsequent sub-calls are)
+    const skillParent = (tool_name !== 'Skill' && type !== 'Stop')
+        ? activeSkillBySession.get(session_id)
+        : undefined;
+    if (type === 'PostToolUse' && tool_name) {
+        const pairedId = db_1.dbOps.pairPostWithPre(session_id, tool_name, typeof tool_response === 'string' ? tool_response : JSON.stringify(tool_response ?? ''), ts);
+        // Truncar tool_response a 4000 chars para no saturar SSE con archivos grandes
+        const rawResp = typeof tool_response === 'string' ? tool_response : JSON.stringify(tool_response ?? '');
+        const tool_output = rawResp.length > 4000
+            ? rawResp.slice(0, 4000) + `\n…[truncated: ${rawResp.length} chars]`
+            : rawResp;
+        (0, stream_1.broadcast)({ type: 'event', payload: { type: 'Done', session_id, tool_name, tool_input: tool_input != null ? JSON.stringify(tool_input) : undefined, tool_output, ts, pairedId, skill_parent: skillParent } });
+        // Activar skill parent para los eventos siguientes si este fue un Skill Done
+        if (tool_name === 'Skill') {
+            try {
+                const inp = typeof tool_input === 'object' ? tool_input : JSON.parse(tool_input ?? '{}');
+                activeSkillBySession.set(session_id, inp?.skill || inp?.name || 'skill');
+            }
+            catch {
+                activeSkillBySession.set(session_id, 'skill');
+            }
+        }
+    }
+    else {
+        db_1.dbOps.insertEvent({
+            session_id, type,
+            tool_name: tool_name ?? undefined,
+            tool_input: tool_input ? JSON.stringify(tool_input) : undefined,
+            ts, cwd: resolvedCwd, skill_parent: skillParent
+        });
+        (0, stream_1.broadcast)({ type: 'event', payload: { ...req.body, skill_parent: skillParent } });
+        // Stop limpia el skill activo para esta sesión
+        if (type === 'Stop') {
+            activeSkillBySession.delete(session_id);
+            (0, enricher_1.cleanupSession)(session_id);
+        }
+        // Registrar Agent PreToolUse para detección de sub-sesiones
+        if (type === 'PreToolUse' && tool_name === 'Agent' && resolvedCwd) {
+            exports.lastAgentByCwd.set(resolvedCwd, { pre_ts: ts, session_id });
+        }
+    }
+    // Intentar etiquetar la sesión con su proyecto (solo en eventos de herramientas de archivo)
+    const FILE_TOOLS = new Set(['Read', 'Write', 'Edit', 'Glob', 'Grep']);
+    if (FILE_TOOLS.has(tool_name || '') && tool_input) {
+        try {
+            const inp = typeof tool_input === 'string' ? JSON.parse(tool_input) : tool_input;
+            const filePath = (inp.file_path || inp.path);
+            if (filePath?.startsWith('/')) {
+                const projectCwd = findProjectCwdForFile(filePath);
+                if (projectCwd)
+                    db_1.dbOps.updateSessionProject(session_id, projectCwd);
+            }
+        }
+        catch { /* ignorar errores de parsing */ }
+    }
+    // Actualizar estado de sesión en memoria + broadcast state_change via SSE
+    stream_1.sessionLastEvent.set(session_id, { type, ts });
+    const state = (0, session_state_1.deriveSessionState)(type, ts);
+    const stateMeta = session_state_1.STATE_META[state];
+    (0, stream_1.broadcast)({ type: 'state_change', payload: { session_id, state, ...stateMeta } });
+    // Al terminar un turno (Stop) → invalidar quota cache + emitir warnings
+    if (type === 'Stop') {
+        (0, quota_tracker_1.invalidateQuotaCache)();
+        // Emitir warning SSE si la cuota supera algún threshold (moving avg 3 muestras + cooldown 1h)
+        setImmediate(() => {
+            try {
+                const cfg = (0, config_1.readConfig)();
+                const data = (0, quota_tracker_1.computeQuota)(cfg.plan ?? undefined);
+                const level = (0, config_1.getWarnLevel)(data.cyclePct, cfg.warnThresholds);
+                // shouldFireAlert acumula siempre la muestra; devuelve true solo si avg estable + cooldown ok
+                if (level && shouldFireAlert(level, data.cyclePct)) {
+                    (0, stream_1.broadcast)({
+                        type: 'quota_warning',
+                        payload: {
+                            level,
+                            cyclePct: data.cyclePct,
+                            cycleLimit: data.cycleLimit,
+                            resetMs: data.cycleResetMs,
+                            blocked: cfg.killSwitchEnabled && data.cyclePct >= cfg.killSwitchThreshold,
+                        }
+                    });
+                }
+                else if (!level) {
+                    // Sin nivel activo → alimentar el buffer igualmente para que las próximas muestras sean correctas
+                    quotaSamples.push(data.cyclePct);
+                    if (quotaSamples.length > SAMPLES_NEEDED)
+                        quotaSamples.shift();
+                }
+            }
+            catch { /* ignorar errores al calcular quota */ }
+        });
+        // Generar resumen IA solo si el usuario lo activa explícitamente
+        // Activar: CLAUDESTAT_AI_SUMMARY=true claudestat start
+        if (process.env.CLAUDESTAT_AI_SUMMARY === 'true') {
+            setImmediate(() => {
+                (async () => {
+                    try {
+                        const session = db_1.dbOps.getSession(session_id);
+                        if (!session)
+                            return;
+                        const events = db_1.dbOps.getSessionEvents(session_id);
+                        const projectName = session.project_path ? path_1.default.basename(session.project_path) : undefined;
+                        const summary = await (0, summarizer_1.summarizeSession)(events, session.total_cost_usd ?? 0, projectName);
+                        if (summary) {
+                            db_1.dbOps.updateSessionSummary(session_id, summary);
+                            (0, stream_1.broadcast)({ type: 'summary_ready', payload: { session_id, summary } });
+                        }
+                    }
+                    catch (err) {
+                        console.error('[events] Summary error:', err);
+                    }
+                })();
+            });
+        }
+    }
+    res.json({ ok: true });
+});
+// ─── Callback del enricher ────────────────────────────────────────────────────
+/**
+ * Cuando el enricher detecta nuevos tokens en un JSONL:
+ * 1. Corre el análisis de inteligencia
+ * 2. Guarda el coste + score en DB
+ * 3. Hace broadcast vía SSE para que el watch muestre el coste actualizado
+ */
+const onCostUpdate = (sessionId, cost) => {
+    // Ensure session row exists — sub-agent JSONLs arrive from the enricher without a
+    // prior hook event (Claude Code does not fire hooks for sub-agent sessions).
+    let sessionRow = db_1.dbOps.getSession(sessionId);
+    if (!sessionRow) {
+        db_1.dbOps.upsertSession({ id: sessionId, cwd: undefined, started_at: cost.firstTs ?? Date.now(), last_event_at: cost.firstTs ?? Date.now() });
+        sessionRow = db_1.dbOps.getSession(sessionId);
+    }
+    // Sub-agent detection: first time we see a session, check if its firstTs falls after
+    // a recent Agent PreToolUse from another session in the same CWD → tag as child.
+    if (!exports.taggedSessionParents.has(sessionId) && cost.firstTs) {
+        exports.taggedSessionParents.add(sessionId);
+        const cwd = sessionRow?.cwd;
+        if (cwd) {
+            const agentInfo = exports.lastAgentByCwd.get(cwd);
+            if (agentInfo && agentInfo.session_id !== sessionId && agentInfo.pre_ts < cost.firstTs) {
+                db_1.dbOps.updateSessionParent(sessionId, agentInfo.session_id);
+            }
+        }
+    }
+    const events = db_1.dbOps.getSessionEvents(sessionId);
+    const report = (0, intelligence_1.analyzeSession)(events, cost.cost_usd);
+    db_1.dbOps.updateSessionCost(sessionId, cost, report.efficiencyScore, report.loops.length);
+    const startedAt = sessionRow?.started_at ?? Date.now();
+    const sessionDurationMinutes = (Date.now() - startedAt) / 60000;
+    const projectedHourlyUsd = sessionDurationMinutes > 0.5
+        ? cost.cost_usd / sessionDurationMinutes * 60
+        : 0;
+    (0, stream_1.broadcast)({
+        type: 'cost_update',
+        payload: {
+            session_id: sessionId,
+            cost_usd: cost.cost_usd,
+            input_tokens: cost.input_tokens,
+            output_tokens: cost.output_tokens,
+            cache_read: cost.cache_read,
+            cache_creation: cost.cache_creation,
+            context_used: cost.context_used,
+            context_window: cost.context_window,
+            efficiency_score: report.efficiencyScore,
+            loops: report.loops,
+            summary: report.summary,
+            model: cost.lastModel,
+            projected_hourly_usd: projectedHourlyUsd,
+        }
+    });
+    // Emitir desglose de costo del último bloque (input vs output) para el TracePanel
+    if (cost.lastEntry) {
+        (0, stream_1.broadcast)({
+            type: 'block_cost',
+            payload: {
+                session_id: sessionId,
+                inputUsd: cost.lastEntry.inputUsd,
+                outputUsd: cost.lastEntry.outputUsd,
+                totalUsd: cost.lastEntry.totalUsd,
+                inputTokens: cost.lastEntry.inputTokens,
+                outputTokens: cost.lastEntry.outputTokens,
+            }
+        });
+    }
+};
+exports.onCostUpdate = onCostUpdate;
+// ─── Callback de auto-compact ────────────────────────────────────────────────
+const onCompactDetected = (sessionId) => {
+    (0, stream_1.broadcast)({ type: 'compact_detected', payload: { session_id: sessionId, ts: Date.now() } });
+    console.log(`[daemon] Auto-compact detectado para sesión ${sessionId.slice(0, 8)}`);
+};
+exports.onCompactDetected = onCompactDetected;

package/dist/routes/history.d.ts

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

package/dist/routes/history.js

@@ -0,0 +1,65 @@
+"use strict";
+// ─── GET /history — sesiones agrupadas por día ────────────────────────────────
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.historyRouter = void 0;
+const path_1 = __importDefault(require("path"));
+const express_1 = require("express");
+const db_1 = require("../db");
+const projects_cache_1 = require("../cache/projects-cache");
+exports.historyRouter = (0, express_1.Router)();
+exports.historyRouter.get('/history', (_req, res) => {
+    const sessions = db_1.dbOps.getRecentSessions(30);
+    // Agrupar por fecha local (YYYY-MM-DD)
+    const byDate = new Map();
+    for (const s of sessions) {
+        // toLocaleDateString('en-CA') produce YYYY-MM-DD en la zona horaria local del usuario
+        const date = new Date(s.started_at).toLocaleDateString('en-CA');
+        if (!byDate.has(date))
+            byDate.set(date, []);
+        // Detectar modo desde los contadores precalculados en la query
+        const hasAgent = (s.agent_count ?? 0) > 0;
+        const hasSkill = (s.skill_count ?? 0) > 0;
+        const mode = hasAgent && hasSkill ? 'agentes+skills'
+            : hasAgent ? 'agentes' : hasSkill ? 'skills' : 'directo';
+        // Git info cacheada para este proyecto
+        const gitInfo = s.project_path ? (0, projects_cache_1.getCachedGitInfo)(s.project_path) : null;
+        byDate.get(date).push({
+            id: s.id,
+            project_path: s.project_path ?? null,
+            project_name: s.project_path ? path_1.default.basename(s.project_path) : null,
+            started_at: s.started_at,
+            last_event_at: s.last_event_at ?? s.started_at,
+            duration_ms: (s.last_event_at ?? s.started_at) - s.started_at,
+            total_cost_usd: s.total_cost_usd ?? 0,
+            total_tokens: (s.total_input_tokens ?? 0) + (s.total_output_tokens ?? 0) + (s.total_cache_read ?? 0),
+            efficiency_score: s.efficiency_score ?? 100,
+            loops_detected: s.loops_detected ?? 0,
+            done_count: s.done_count ?? 0,
+            top_tools: s.top_tools_csv ? (() => { try {
+                return JSON.parse(s.top_tools_csv);
+            }
+            catch {
+                return [];
+            } })() : [],
+            mode,
+            ai_summary: s.ai_summary ?? null,
+            git_branch: gitInfo?.branch ?? null,
+            git_dirty: gitInfo?.dirty ?? false,
+            git_ahead: gitInfo?.ahead ?? 0,
+            git_behind: gitInfo?.behind ?? 0,
+        });
+    }
+    const days = [...byDate.entries()]
+        .map(([date, sessions]) => ({
+        date,
+        sessions,
+        total_cost: sessions.reduce((s, x) => s + x.total_cost_usd, 0),
+        total_tokens: sessions.reduce((s, x) => s + x.total_tokens, 0),
+        total_duration_ms: sessions.reduce((s, x) => s + x.duration_ms, 0),
+    }))
+        .sort((a, b) => b.date.localeCompare(a.date));
+    res.json({ days });
+});

package/dist/routes/misc.d.ts

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

package/dist/routes/misc.js

@@ -0,0 +1,280 @@
+"use strict";
+// ─── Rutas misceláneas: /git, /pr, /meta-stats, /intelligence, /quota,
+//     /kill-switch, /sessions, /prompts, /hidden-cost, /claude-stats,
+//     /system-config, /config ─────────────────────────────────────────────────
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.miscRouter = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const express_1 = require("express");
+const db_1 = require("../db");
+const intelligence_1 = require("../intelligence");
+const meta_stats_1 = require("../meta-stats");
+const quota_tracker_1 = require("../quota-tracker");
+const config_1 = require("../config");
+const enricher_1 = require("../enricher");
+const claude_stats_1 = require("../claude-stats");
+const projects_cache_1 = require("../cache/projects-cache");
+const projects_1 = require("./projects");
+const session_state_1 = require("../session-state");
+const stream_1 = require("./stream");
+const paths_1 = require("../paths");
+exports.miscRouter = (0, express_1.Router)();
+// ─── GET /git?path=... — git info para un proyecto ────────────────────────────
+exports.miscRouter.get('/git', (req, res) => {
+    const projectPath = req.query.path;
+    if (!projectPath) {
+        res.status(400).json({ error: 'Missing path parameter' });
+        return;
+    }
+    res.json((0, projects_cache_1.getCachedGitInfo)(projectPath) ?? null);
+});
+// ─── GET /pr?path=... — estado del PR para un proyecto ────────────────────────
+exports.miscRouter.get('/pr', (req, res) => {
+    const projectPath = req.query.path;
+    if (!projectPath) {
+        res.status(400).json({ error: 'Missing path parameter' });
+        return;
+    }
+    res.json((0, projects_cache_1.getCachedPRStatus)(projectPath) ?? null);
+});
+// ─── GET /meta-stats — KPIs de contexto ──────────────────────────────────────
+exports.miscRouter.get('/meta-stats', (_req, res) => {
+    const latestSession = db_1.dbOps.getLatestSession();
+    const events = latestSession ? db_1.dbOps.getSessionEvents(latestSession.id) : [];
+    // Inferir el directorio del proyecto desde los eventos (más fiable que el cwd del daemon)
+    const projectCwd = (0, projects_1.inferProjectCwd)(events) ?? latestSession?.cwd ?? undefined;
+    const current = (0, meta_stats_1.computeMetaStats)(projectCwd);
+    const history = (0, meta_stats_1.getMetaHistory)();
+    res.json({ current, history });
+});
+// ─── GET /intelligence/:sessionId — reporte de inteligencia ──────────────────
+exports.miscRouter.get('/intelligence/:sessionId', (req, res) => {
+    const { sessionId } = req.params;
+    const session = db_1.dbOps.getSession(sessionId);
+    if (!session) {
+        res.status(404).json({ error: 'Session not found' });
+        return;
+    }
+    const events = db_1.dbOps.getSessionEvents(sessionId);
+    const report = (0, intelligence_1.analyzeSession)(events, session.total_cost_usd ?? 0);
+    res.json({ sessionId, ...report });
+});
+// ─── GET /quota — datos de cuota y burn rate ──────────────────────────────────
+exports.miscRouter.get('/quota', (_req, res) => {
+    try {
+        const cfg = (0, config_1.readConfig)();
+        const data = (0, quota_tracker_1.computeQuota)(cfg.plan ?? undefined);
+        res.json(data);
+    }
+    catch (err) {
+        res.status(500).json({ error: 'Error computing quota' });
+    }
+});
+/** Formatea ms a "Xh Ym" legible */
+function formatMs(ms) {
+    const totalMin = Math.ceil(ms / 60000);
+    const h = Math.floor(totalMin / 60);
+    const m = totalMin % 60;
+    return h > 0 ? `${h}h ${m}m` : `${m}m`;
+}
+// ─── GET /kill-switch — consultado por el hook PreToolUse ─────────────────────
+// Si está bloqueado, el hook hace exit(2) y Claude Code cancela la acción.
+exports.miscRouter.get('/kill-switch', (_req, res) => {
+    try {
+        const cfg = (0, config_1.readConfig)();
+        const data = (0, quota_tracker_1.computeQuota)(cfg.plan ?? undefined);
+        const blocked = cfg.killSwitchEnabled && data.cyclePct >= cfg.killSwitchThreshold;
+        const reason = blocked
+            ? `5h quota at ${data.cyclePct}% (limit: ${cfg.killSwitchThreshold}%). Resets in ${formatMs(data.cycleResetMs)}.`
+            : undefined;
+        res.json({ blocked, reason, cyclePct: data.cyclePct });
+    }
+    catch {
+        res.json({ blocked: false }); // si hay error, no bloquear
+    }
+});
+// ─── GET /sessions — listado para dashboard futuro ────────────────────────────
+exports.miscRouter.get('/sessions', (_req, res) => {
+    const sessions = db_1.dbOps.getAllSessions();
+    // Enriquecer cada sesión con el estado derivado en tiempo real
+    const enriched = sessions.map(s => {
+        const lastEvt = stream_1.sessionLastEvent.get(s.id);
+        const ts = lastEvt?.ts ?? s.last_event_at ?? s.started_at;
+        const state = (0, session_state_1.deriveSessionState)(lastEvt?.type, ts);
+        return { ...s, state };
+    });
+    res.json(enriched);
+});
+// ─── GET /prompts — mensajes del usuario para una sesión ─────────────────────
+exports.miscRouter.get('/prompts', async (req, res) => {
+    const sessionId = req.query.session_id;
+    if (!sessionId)
+        return res.status(400).json({ error: 'session_id required' });
+    res.json({ prompts: await (0, enricher_1.getSessionPrompts)(sessionId) });
+});
+// ─── GET /hidden-cost — coste oculto en loops (últimos 7 días) ───────────────
+exports.miscRouter.get('/hidden-cost', (_req, res) => {
+    res.json(db_1.dbOps.getHiddenCostStats(7));
+});
+// ─── GET /claude-stats — actividad de ~/.claude/stats-cache.json ─────────────
+exports.miscRouter.get('/claude-stats', (_req, res) => {
+    res.json((0, claude_stats_1.readClaudeStats)());
+});
+// ─── GET /system-config — mapa completo del setup de Claude ──────────────────
+let _systemConfigCache = null;
+let _systemConfigCacheTs = 0;
+const SYSTEM_CONFIG_TTL = 30000;
+exports.miscRouter.get('/system-config', (_req, res) => {
+    if (_systemConfigCache && Date.now() - _systemConfigCacheTs < SYSTEM_CONFIG_TTL) {
+        res.json(_systemConfigCache);
+        return;
+    }
+    try {
+        const home = os_1.default.homedir();
+        const claudeDir = (0, paths_1.getClaudeDir)();
+        let hooks = {};
+        try {
+            const raw = fs_1.default.readFileSync(path_1.default.join(claudeDir, 'settings.json'), 'utf-8');
+            const rawHooks = JSON.parse(raw).hooks ?? {};
+            for (const [event, entries] of Object.entries(rawHooks)) {
+                hooks[event] = entries.flatMap(e => (e.hooks ?? []).map(h => ({ matcher: e.matcher, command: h.command })));
+            }
+        }
+        catch { }
+        // Helper para extraer descripción del frontmatter
+        const getDescription = (content) => content.match(/^description:\s*(.+)$/m)?.[1]?.trim() ?? '';
+        // Helper compartido — escanea archivos .md directos o anidados en subdirectorios
+        const scanMarkdownDir = (dir, excludes = [], nested) => {
+            const items = [];
+            for (const entry of fs_1.default.readdirSync(dir, { withFileTypes: true })) {
+                let filePath;
+                let itemName;
+                if (nested) {
+                    if (!entry.isDirectory() && !entry.isSymbolicLink())
+                        continue;
+                    filePath = path_1.default.join(dir, entry.name, nested);
+                    itemName = entry.name;
+                }
+                else {
+                    if (!entry.isFile() || !entry.name.endsWith('.md') || excludes.includes(entry.name))
+                        continue;
+                    filePath = path_1.default.join(dir, entry.name);
+                    itemName = entry.name.replace('.md', '');
+                }
+                try {
+                    const content = fs_1.default.readFileSync(filePath, 'utf-8');
+                    const lines = content.split('\n').length;
+                    items.push({ name: itemName, description: getDescription(content), lines });
+                }
+                catch {
+                    // Ignorar archivos no encontrados o no legibles
+                }
+            }
+            return items;
+        };
+        // 2. Agentes desde Claude Code agents/
+        let agents = [];
+        try {
+            agents = scanMarkdownDir(path_1.default.join(claudeDir, 'agents'), ['CLAUDE.md', 'ORCHESTRATOR.md', 'AGENTS.md']);
+        }
+        catch { }
+        // 2b. Workflows desde Claude Code agents/workflows/
+        let workflows = [];
+        try {
+            workflows = scanMarkdownDir(path_1.default.join(claudeDir, 'agents', 'workflows'));
+        }
+        catch { }
+        // 3. Archivos de contexto relevantes
+        const engramSlugCtx = (0, paths_1.getHomeSlug)();
+        const contextPaths = [
+            { key: 'CLAUDE.md global', filePath: path_1.default.join(claudeDir, 'CLAUDE.md') },
+            { key: 'MEMORY.md', filePath: path_1.default.join(claudeDir, 'projects', engramSlugCtx, 'memory', 'MEMORY.md') },
+            { key: 'settings.json', filePath: path_1.default.join(claudeDir, 'settings.json') },
+            { key: 'config claudestat', filePath: path_1.default.join((0, paths_1.getClaudestatDir)(), 'config.json') },
+        ];
+        const contextFiles = contextPaths.map(({ key, filePath }) => {
+            try {
+                const content = fs_1.default.readFileSync(filePath, 'utf-8');
+                const lines = content.split('\n').length;
+                const sizeKb = Math.round(Buffer.byteLength(content, 'utf-8') / 1024 * 10) / 10;
+                return { key, exists: true, sizeKb, lines };
+            }
+            catch {
+                return { key, exists: false, sizeKb: 0, lines: 0 };
+            }
+        });
+        // 3b. Skills: commands/ (skills nativos de Claude Code) + skills/ (skills.sh)
+        let skills = [];
+        try {
+            skills = scanMarkdownDir(path_1.default.join(claudeDir, 'commands'));
+        }
+        catch { }
+        try {
+            skills = [...skills, ...scanMarkdownDir(path_1.default.join(claudeDir, 'skills'), [], 'SKILL.md')];
+        }
+        catch { }
+        // 4. Archivos de memoria Engram
+        let memoryFiles = [];
+        try {
+            const memDir = path_1.default.join(claudeDir, 'projects', engramSlugCtx, 'memory');
+            memoryFiles = fs_1.default.readdirSync(memDir).filter(f => f.endsWith('.md')).sort();
+        }
+        catch { }
+        // 5. Distribución de modos (últimos 7 días)
+        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 };
+        _systemConfigCacheTs = Date.now();
+        res.json(_systemConfigCache);
+    }
+    catch (err) {
+        res.status(500).json({ error: 'Error leyendo config del sistema' });
+    }
+});
+// ─── GET /config — leer configuración ────────────────────────────────────────
+exports.miscRouter.get('/config', (_req, res) => {
+    res.json((0, config_1.readConfig)());
+});
+// ─── PUT /config — guardar configuración ─────────────────────────────────────
+exports.miscRouter.put('/config', (req, res) => {
+    const validationError = (0, config_1.validateConfig)(req.body);
+    if (validationError) {
+        res.status(400).json({ error: validationError });
+        return;
+    }
+    try {
+        const current = (0, config_1.readConfig)();
+        (0, config_1.writeConfig)({ ...current, ...req.body });
+        res.json({ ok: true });
+    }
+    catch (e) {
+        res.status(500).json({ error: String(e) });
+    }
+});
+// ─── GET /cost-projection — weekly/monthly cost projection ──────────────────
+exports.miscRouter.get('/cost-projection', (_req, res) => {
+    const week = db_1.dbOps.getCostProjection(7);
+    const month = db_1.dbOps.getCostProjection(30);
+    const weekSpan = week.latest && week.earliest ? (week.latest - week.earliest) / 86400000 : 0;
+    const monthSpan = month.latest && month.earliest ? (month.latest - month.earliest) / 86400000 : 0;
+    const weeklyProjected = weekSpan > 0.5 ? (week.total_cost_usd ?? 0) / weekSpan * 7 : 0;
+    const monthlyProjected = monthSpan > 1 ? (month.total_cost_usd ?? 0) / monthSpan * 30 : 0;
+    res.json({
+        weekly: {
+            daysWithData: Math.round(weekSpan * 10) / 10,
+            costSoFar: week.total_cost_usd ?? 0,
+            projected: Math.round(weeklyProjected * 100) / 100,
+        },
+        monthly: {
+            daysWithData: Math.round(monthSpan * 10) / 10,
+            costSoFar: month.total_cost_usd ?? 0,
+            projected: Math.round(monthlyProjected * 100) / 100,
+        },
+    });
+});

package/dist/routes/projects.d.ts

@@ -0,0 +1,15 @@
+import { type EventRow } from '../db';
+export declare const projectsRouter: import("express-serve-static-core").Router;
+/** Sube el árbol desde un file_path hasta encontrar HANDOFF.md → directorio del proyecto */
+export declare function findProjectCwdForFile(filePath: string): string | undefined;
+/** Infiere el proyecto activo mirando los eventos de archivo de una sesión */
+export declare function inferProjectCwd(events: EventRow[]): string | 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.
+ */
+export declare function inferActiveProjectByMajority(events: EventRow[], windowMs: number): string | undefined;