@statforge/claudestat 1.0.1

package/dist/claude-auth.js

@@ -0,0 +1,133 @@
+"use strict";
+/**
+ * claude-auth.ts — Lee las credenciales OAuth de Claude Code desde el sistema.
+ *
+ * macOS: las credenciales se guardan en el keychain del sistema con el servicio
+ *        "Claude Code-credentials". El campo "claudeAiOauth" contiene el token
+ *        OAuth, su expiración, scopes y el tipo de suscripción del plan.
+ *
+ * Linux/Windows: Claude Code puede guardar las credenciales en
+ *   ~/.config/Claude/credentials.json  (Electron userData path)
+ *   o en el keyring del sistema.
+ *
+ * Propósito: obtener el `subscriptionType` y `rateLimitTier` del plan real del
+ * usuario, sin inferirlo del máximo histórico de prompts en los JSONL.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readClaudeAuth = readClaudeAuth;
+exports.subscriptionTypeToPlan = subscriptionTypeToPlan;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const KEYCHAIN_SERVICE = 'Claude Code-credentials';
+/** Caché en memoria de 5 minutos */
+let cache = null;
+const CACHE_TTL = 5 * 60000;
+// ─── Leer desde macOS Keychain ────────────────────────────────────────────────
+function readFromKeychain() {
+    try {
+        const raw = (0, child_process_1.execSync)(`security find-generic-password -s "${KEYCHAIN_SERVICE}" -w`, { stdio: ['pipe', 'pipe', 'pipe'], timeout: parseInt(process.env.CLAUDESTAT_KEYCHAIN_TIMEOUT ?? '3000', 10) }).toString().trim();
+        if (!raw)
+            return null;
+        // El valor puede ser JSON directo o base64
+        let parsed;
+        try {
+            parsed = JSON.parse(Buffer.from(raw, 'base64').toString());
+        }
+        catch {
+            parsed = JSON.parse(raw);
+        }
+        const oa = parsed?.claudeAiOauth;
+        if (!oa)
+            return null;
+        return {
+            subscriptionType: (oa.subscriptionType ?? 'unknown').toLowerCase(),
+            rateLimitTier: oa.rateLimitTier ?? 'unknown',
+            expiresAt: oa.expiresAt ?? 0,
+            tokenValid: Date.now() < (oa.expiresAt ?? 0),
+            source: 'keychain',
+        };
+    }
+    catch {
+        return null;
+    }
+}
+// ─── Leer desde archivo (Linux / Electron userData) ──────────────────────────
+function readFromFile() {
+    const homeDir = os_1.default.homedir();
+    const candidates = [
+        // Windows Credential Manager / Electron userData
+        path_1.default.join(process.env.APPDATA ?? path_1.default.join(homeDir, 'AppData', 'Roaming'), 'Claude', 'credentials.json'),
+        path_1.default.join(process.env.LOCALAPPDATA ?? path_1.default.join(homeDir, 'AppData', 'Local'), 'Claude', 'credentials.json'),
+        // Linux Electron userData
+        path_1.default.join(homeDir, '.config', 'Claude', 'credentials.json'),
+        path_1.default.join(homeDir, '.config', 'Claude', '.credentials.json'),
+        // macOS Electron userData fallback
+        path_1.default.join(homeDir, 'Library', 'Application Support', 'Claude', 'credentials.json'),
+    ];
+    for (const p of candidates) {
+        try {
+            const raw = fs_1.default.readFileSync(p, 'utf8');
+            const parsed = JSON.parse(raw);
+            const oa = parsed?.claudeAiOauth ?? parsed;
+            if (!oa?.subscriptionType)
+                continue;
+            return {
+                subscriptionType: (oa.subscriptionType ?? 'unknown').toLowerCase(),
+                rateLimitTier: oa.rateLimitTier ?? 'unknown',
+                expiresAt: oa.expiresAt ?? 0,
+                tokenValid: Date.now() < (oa.expiresAt ?? 0),
+                source: 'file',
+            };
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+// ─── API pública ──────────────────────────────────────────────────────────────
+/**
+ * Lee las credenciales de autenticación de Claude Code.
+ * Intenta: keychain (macOS) → archivo → unknown.
+ * Resultado cacheado 5 minutos para no golpear el keychain en cada request.
+ */
+function readClaudeAuth() {
+    const now = Date.now();
+    if (cache && now - cache.ts < CACHE_TTL)
+        return cache.data;
+    const info = (os_1.default.platform() === 'darwin' ? readFromKeychain() : null)
+        ?? readFromFile()
+        ?? { subscriptionType: 'unknown', rateLimitTier: 'unknown', expiresAt: 0, tokenValid: false, source: 'unknown' };
+    cache = { data: info, ts: now };
+    return info;
+}
+/**
+ * Mapea el subscriptionType de las credenciales al ClaudePlan usado por quota-tracker.
+ *
+ * Valores conocidos de Claude Code:
+ *   "free"   → Free plan (10 prompts/5h)
+ *   "pro"    → Pro plan  (45 prompts/5h)
+ *   "max"    → Max plan — puede ser max5 o max20, diferenciado por rateLimitTier
+ *   "max_5"  → Max 5×   (225 prompts/5h)
+ *   "max_20" → Max 20×  (900 prompts/5h)
+ */
+function subscriptionTypeToPlan(subscriptionType, rateLimitTier) {
+    const sub = subscriptionType.toLowerCase();
+    const tier = rateLimitTier.toLowerCase();
+    if (sub.includes('max_20') || tier.includes('max_20'))
+        return 'max20';
+    if (sub.includes('max_5') || tier.includes('max_5'))
+        return 'max5';
+    if (sub === 'max' || tier.includes('max'))
+        return 'max5'; // conservador
+    if (sub === 'pro')
+        return 'pro';
+    if (sub === 'free')
+        return 'free';
+    return 'pro'; // fallback conservador
+}

package/dist/claude-stats.d.ts

@@ -0,0 +1,32 @@
+/**
+ * claude-stats.ts — Lee ~/.claude/stats-cache.json
+ *
+ * Claude Code mantiene este archivo con actividad agregada por día:
+ * - messageCount: total de mensajes (human + assistant) — ≈ 2× prompts reales
+ * - sessionCount: sesiones abiertas
+ * - toolCallCount: llamadas a herramientas
+ * - tokensByModel: tokens de OUTPUT por modelo (lo que genera Claude)
+ *
+ * NOTA: lastComputedDate indica hasta qué fecha están los datos. El día actual
+ * puede no aparecer todavía si Claude Code aún no actualizó el cache.
+ */
+export interface DayActivity {
+    date: string;
+    messages: number;
+    sessions: number;
+    tools: number;
+    outputTokens: number;
+}
+export interface ClaudeStatsData {
+    today: DayActivity | null;
+    yesterday: DayActivity | null;
+    last7: DayActivity;
+    allTime: {
+        sessions: number;
+        messages: number;
+    };
+    cacheDate: string | null;
+    todayLabel: string | null;
+    cacheIsStale: boolean;
+}
+export declare function readClaudeStats(): ClaudeStatsData;

package/dist/claude-stats.js

@@ -0,0 +1,98 @@
+"use strict";
+/**
+ * claude-stats.ts — Lee ~/.claude/stats-cache.json
+ *
+ * Claude Code mantiene este archivo con actividad agregada por día:
+ * - messageCount: total de mensajes (human + assistant) — ≈ 2× prompts reales
+ * - sessionCount: sesiones abiertas
+ * - toolCallCount: llamadas a herramientas
+ * - tokensByModel: tokens de OUTPUT por modelo (lo que genera Claude)
+ *
+ * NOTA: lastComputedDate indica hasta qué fecha están los datos. El día actual
+ * puede no aparecer todavía si Claude Code aún no actualizó el cache.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readClaudeStats = readClaudeStats;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const paths_1 = require("./paths");
+const STATS_PATH = path_1.default.join((0, paths_1.getClaudeDir)(), 'stats-cache.json');
+// ─── Lectura ──────────────────────────────────────────────────────────────────
+function readClaudeStats() {
+    const empty = {
+        today: null, yesterday: null,
+        last7: { date: 'last7', messages: 0, sessions: 0, tools: 0, outputTokens: 0 },
+        allTime: { sessions: 0, messages: 0 },
+        cacheDate: null, todayLabel: null, cacheIsStale: false,
+    };
+    try {
+        const raw = fs_1.default.readFileSync(STATS_PATH, 'utf8');
+        const data = JSON.parse(raw);
+        // Fechas de referencia
+        const now = new Date();
+        const todayStr = now.toISOString().slice(0, 10);
+        const yest = new Date(now.getTime() - 86400000);
+        const yestStr = yest.toISOString().slice(0, 10);
+        const cutoffStr = new Date(now.getTime() - 7 * 86400000).toISOString().slice(0, 10);
+        // Índice de tokens por fecha
+        const tokensByDate = {};
+        for (const entry of (data.dailyModelTokens ?? [])) {
+            tokensByDate[entry.date] = entry.tokensByModel ?? {};
+        }
+        // Suma de tokens por fecha
+        function tokensForDate(d) {
+            const byModel = tokensByDate[d] ?? {};
+            return Object.values(byModel).reduce((a, b) => a + b, 0);
+        }
+        // Construir DayActivity por fecha
+        const actByDate = {};
+        for (const a of (data.dailyActivity ?? [])) {
+            actByDate[a.date] = {
+                date: a.date, messages: a.messageCount ?? 0,
+                sessions: a.sessionCount ?? 0, tools: a.toolCallCount ?? 0,
+                outputTokens: tokensForDate(a.date),
+            };
+        }
+        // Last 7 days aggregate
+        const last7 = { date: 'last7', messages: 0, sessions: 0, tools: 0, outputTokens: 0 };
+        for (const [date, act] of Object.entries(actByDate)) {
+            if (date >= cutoffStr) {
+                last7.messages += act.messages;
+                last7.sessions += act.sessions;
+                last7.tools += act.tools;
+                last7.outputTokens += act.outputTokens;
+            }
+        }
+        // Si hoy/ayer no están en el cache, usar el día más reciente disponible
+        const todayData = actByDate[todayStr] ?? null;
+        const yesterdayData = actByDate[yestStr] ?? null;
+        let mostRecentDay = todayData ?? yesterdayData;
+        let mostRecentLabel = todayData ? 'Hoy' : yesterdayData ? 'Ayer' : null;
+        if (!mostRecentDay) {
+            // Cache antiguo — buscar el día más reciente disponible
+            const sortedDates = Object.keys(actByDate).sort().reverse();
+            if (sortedDates.length > 0) {
+                mostRecentDay = actByDate[sortedDates[0]];
+                mostRecentLabel = sortedDates[0]; // ej. "2026-04-16"
+            }
+        }
+        return {
+            today: mostRecentDay,
+            yesterday: yesterdayData,
+            last7,
+            allTime: {
+                sessions: data.totalSessions ?? 0,
+                messages: data.totalMessages ?? 0,
+            },
+            cacheDate: data.lastComputedDate ?? null,
+            todayLabel: mostRecentLabel,
+            cacheIsStale: !todayData && !yesterdayData,
+        };
+    }
+    catch {
+        return empty;
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,43 @@
+/**
+ * config.ts — Configuración de claudestat
+ *
+ * Lee/escribe ~/.claudestat/config.json con valores por defecto.
+ * Los thresholds de warning controlan cuándo se emite una alerta SSE
+ * y cuándo se activa el kill switch (hook bloqueante PreToolUse).
+ *
+ * Estructura del archivo:
+ * {
+ *   "killSwitchEnabled": true,     // activar/desactivar el hook bloqueante
+ *   "killSwitchThreshold": 95,     // % de cuota para bloquear (1-100)
+ *   "warnThresholds": [70, 85, 95],// niveles de aviso: amarillo, naranja, rojo
+ *   "plan": null,                  // forzar plan: "pro"|"max5"|"max20"|null (auto)
+ *   "reportsEnabled": false,       // activar/desactivar informes automáticos
+ *   "reportFrequency": "weekly",   // "weekly"|"biweekly"|"monthly"
+ *   "reportDay": 1,                // día de la semana: 0=Dom, 1=Lun … 6=Sáb
+ *   "reportTime": "09:00"          // hora HH:MM en que se genera el informe
+ * }
+ */
+import type { ClaudePlan } from './quota-tracker';
+export type ReportFrequency = 'weekly' | 'biweekly' | 'monthly';
+export interface ClaudestatConfig {
+    killSwitchEnabled: boolean;
+    killSwitchThreshold: number;
+    warnThresholds: number[];
+    plan: ClaudePlan | null;
+    reportsEnabled: boolean;
+    reportFrequency: ReportFrequency;
+    reportDay: number;
+    reportTime: string;
+    alertsEnabled: boolean;
+}
+/** Lee la config del disco. Valores ausentes se rellenan con defaults. */
+export declare function readConfig(): ClaudestatConfig;
+/** Escribe la config en disco. Crea el directorio si no existe. */
+export declare function writeConfig(cfg: ClaudestatConfig): void;
+/**
+ * Valida y sanitiza los campos de una config recibida por la API.
+ * Devuelve un string de error si algo es inválido, o null si está bien.
+ */
+export declare function validateConfig(raw: unknown): string | null;
+/** Devuelve el nivel de warning para un % dado, o null si no alcanza ningún threshold. */
+export declare function getWarnLevel(pct: number, thresholds: number[]): 'yellow' | 'orange' | 'red' | null;

package/dist/config.js

@@ -0,0 +1,110 @@
+"use strict";
+/**
+ * config.ts — Configuración de claudestat
+ *
+ * Lee/escribe ~/.claudestat/config.json con valores por defecto.
+ * Los thresholds de warning controlan cuándo se emite una alerta SSE
+ * y cuándo se activa el kill switch (hook bloqueante PreToolUse).
+ *
+ * Estructura del archivo:
+ * {
+ *   "killSwitchEnabled": true,     // activar/desactivar el hook bloqueante
+ *   "killSwitchThreshold": 95,     // % de cuota para bloquear (1-100)
+ *   "warnThresholds": [70, 85, 95],// niveles de aviso: amarillo, naranja, rojo
+ *   "plan": null,                  // forzar plan: "pro"|"max5"|"max20"|null (auto)
+ *   "reportsEnabled": false,       // activar/desactivar informes automáticos
+ *   "reportFrequency": "weekly",   // "weekly"|"biweekly"|"monthly"
+ *   "reportDay": 1,                // día de la semana: 0=Dom, 1=Lun … 6=Sáb
+ *   "reportTime": "09:00"          // hora HH:MM en que se genera el informe
+ * }
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readConfig = readConfig;
+exports.writeConfig = writeConfig;
+exports.validateConfig = validateConfig;
+exports.getWarnLevel = getWarnLevel;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const paths_1 = require("./paths");
+const CONFIG_PATH = path_1.default.join((0, paths_1.getClaudestatDir)(), 'config.json');
+const DEFAULTS = {
+    killSwitchEnabled: false,
+    killSwitchThreshold: 95,
+    warnThresholds: [70, 85, 95],
+    plan: null,
+    reportsEnabled: false,
+    reportFrequency: 'weekly',
+    reportDay: 1,
+    reportTime: '09:00',
+    alertsEnabled: true,
+};
+/** Lee la config del disco. Valores ausentes se rellenan con defaults. */
+function readConfig() {
+    try {
+        const raw = fs_1.default.readFileSync(CONFIG_PATH, 'utf8');
+        const parsed = JSON.parse(raw);
+        return { ...DEFAULTS, ...parsed };
+    }
+    catch {
+        return { ...DEFAULTS };
+    }
+}
+/** Escribe la config en disco. Crea el directorio si no existe. */
+function writeConfig(cfg) {
+    fs_1.default.mkdirSync(path_1.default.dirname(CONFIG_PATH), { recursive: true });
+    fs_1.default.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2) + '\n');
+}
+const VALID_PLANS = new Set(['free', 'pro', 'max5', 'max20', null]);
+/**
+ * Valida y sanitiza los campos de una config recibida por la API.
+ * Devuelve un string de error si algo es inválido, o null si está bien.
+ */
+function validateConfig(raw) {
+    if (typeof raw !== 'object' || raw === null)
+        return 'Body debe ser un objeto JSON';
+    const cfg = raw;
+    if ('killSwitchEnabled' in cfg && typeof cfg.killSwitchEnabled !== 'boolean')
+        return 'killSwitchEnabled debe ser boolean';
+    if ('killSwitchThreshold' in cfg) {
+        const v = cfg.killSwitchThreshold;
+        if (typeof v !== 'number' || isNaN(v) || v < 1 || v > 100)
+            return 'killSwitchThreshold debe ser un número entre 1 y 100';
+    }
+    if ('warnThresholds' in cfg) {
+        const v = cfg.warnThresholds;
+        if (!Array.isArray(v) || v.length !== 3 || v.some(n => typeof n !== 'number' || isNaN(n) || n < 1 || n > 100))
+            return 'warnThresholds debe ser un array de 3 números entre 1 y 100';
+    }
+    if ('plan' in cfg && !VALID_PLANS.has(cfg.plan))
+        return `plan debe ser uno de: free, pro, max5, max20 o null`;
+    if ('alertsEnabled' in cfg && typeof cfg.alertsEnabled !== 'boolean')
+        return 'alertsEnabled debe ser boolean';
+    if ('reportsEnabled' in cfg && typeof cfg.reportsEnabled !== 'boolean')
+        return 'reportsEnabled debe ser boolean';
+    if ('reportFrequency' in cfg && !['weekly', 'biweekly', 'monthly'].includes(cfg.reportFrequency))
+        return 'reportFrequency debe ser weekly, biweekly o monthly';
+    if ('reportDay' in cfg) {
+        const v = cfg.reportDay;
+        if (typeof v !== 'number' || !Number.isInteger(v) || v < 0 || v > 6)
+            return 'reportDay debe ser un entero entre 0 y 6';
+    }
+    if ('reportTime' in cfg) {
+        if (typeof cfg.reportTime !== 'string' || !/^\d{2}:\d{2}$/.test(cfg.reportTime))
+            return 'reportTime debe tener formato HH:MM';
+    }
+    return null;
+}
+/** Devuelve el nivel de warning para un % dado, o null si no alcanza ningún threshold. */
+function getWarnLevel(pct, thresholds) {
+    const sorted = [...thresholds].sort((a, b) => a - b); // [70, 85, 95]
+    if (sorted.length >= 3 && pct >= sorted[2])
+        return 'red';
+    if (sorted.length >= 2 && pct >= sorted[1])
+        return 'orange';
+    if (sorted.length >= 1 && pct >= sorted[0])
+        return 'yellow';
+    return null;
+}

package/dist/daemon.d.ts

@@ -0,0 +1,15 @@
+/**
+ * daemon.ts — Servidor HTTP + SSE con inteligencia integrada
+ *
+ * Phase 2 agrega:
+ * - Enriquecimiento de coste desde JSONL (enricher)
+ * - Análisis de inteligencia (loops + eficiencia) al recibir cada cost update
+ * - Endpoint GET /intelligence/:sessionId
+ * - Endpoint GET /sessions para el dashboard futuro
+ *
+ * Phase 3 agrega:
+ * - Sirve el dashboard React desde dashboard/dist
+ * - Endpoint GET /meta-stats: KPIs de HANDOFF, Engram, config y alertas
+ * - Procesa JSONL al conectar nuevo cliente SSE (contexto inmediato)
+ */
+export declare function startDaemon(): void;

package/dist/daemon.js

@@ -0,0 +1,247 @@
+"use strict";
+/**
+ * daemon.ts — Servidor HTTP + SSE con inteligencia integrada
+ *
+ * Phase 2 agrega:
+ * - Enriquecimiento de coste desde JSONL (enricher)
+ * - Análisis de inteligencia (loops + eficiencia) al recibir cada cost update
+ * - Endpoint GET /intelligence/:sessionId
+ * - Endpoint GET /sessions para el dashboard futuro
+ *
+ * Phase 3 agrega:
+ * - Sirve el dashboard React desde dashboard/dist
+ * - Endpoint GET /meta-stats: KPIs de HANDOFF, Engram, config y alertas
+ * - Procesa JSONL al conectar nuevo cliente SSE (contexto inmediato)
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startDaemon = startDaemon;
+const express_1 = __importDefault(require("express"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const db_1 = require("./db");
+const enricher_1 = require("./enricher");
+const config_1 = require("./config");
+const quota_tracker_1 = require("./quota-tracker");
+const notifier_1 = require("./notifier");
+const events_1 = require("./routes/events");
+const stream_1 = require("./routes/stream");
+const projects_1 = require("./routes/projects");
+const history_1 = require("./routes/history");
+const misc_1 = require("./routes/misc");
+const reports_1 = require("./routes/reports");
+const top_1 = require("./routes/top");
+const projects_cache_1 = require("./cache/projects-cache");
+const rate_limiter_1 = require("./middleware/rate-limiter");
+const summarizer_1 = require("./summarizer");
+const paths_1 = require("./paths");
+const PORT = 7337;
+const app = (0, express_1.default)();
+app.use(express_1.default.json());
+// ─── Shutdown graceful (cross-platform, no depende de SIGTERM) ────────────────
+let _server = null;
+app.post('/shutdown', (_req, res) => {
+    res.json({ ok: true });
+    if (_server)
+        shutdown(_server);
+    process.exit(0);
+});
+// ─── Montar rutas ─────────────────────────────────────────────────────────────
+app.use(events_1.eventsRouter);
+app.use(stream_1.streamRouter);
+app.use(projects_1.projectsRouter);
+app.use(history_1.historyRouter);
+app.use(misc_1.miscRouter);
+app.use(reports_1.reportsRouter);
+app.use(top_1.topRouter);
+// ─── GET /health — necesita acceso al tamaño del pool SSE ─────────────────────
+app.get('/health', (_req, res) => {
+    res.json({ status: 'ok', port: PORT, clients: (0, stream_1.getSseClientsSize)() });
+});
+// ─── Dashboard React (servir estáticos del build de Vite) ────────────────────
+const DASHBOARD_DIST = path_1.default.join(__dirname, '..', 'dashboard', 'dist');
+app.use(express_1.default.static(DASHBOARD_DIST, {
+    setHeaders(res, filePath) {
+        if (filePath.endsWith('.html')) {
+            res.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate');
+        }
+    },
+}));
+// SPA fallback: cualquier ruta no capturada sirve index.html
+app.get('*', (_req, res) => {
+    res.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate');
+    res.sendFile(path_1.default.join(DASHBOARD_DIST, 'index.html'));
+});
+// ─── Migración de arranque: etiquetar sesiones históricas ────────────────────
+function migrateSessionProjects() {
+    const sessions = db_1.dbOps.getAllSessions();
+    let tagged = 0;
+    for (const session of sessions) {
+        if (session.project_path)
+            continue;
+        const events = db_1.dbOps.getSessionEvents(session.id);
+        const projectCwd = (0, projects_1.inferProjectCwd)(events);
+        if (projectCwd) {
+            db_1.dbOps.updateSessionProject(session.id, projectCwd);
+            tagged++;
+        }
+    }
+    if (tagged > 0)
+        console.log(`[daemon] ${tagged} sessions tagged with project`);
+}
+/**
+ * Genera summaries IA para las últimas N sesiones que no tienen uno.
+ * Se ejecuta en background al arrancar el daemon — no bloquea el inicio.
+ */
+async function migrateSessionSummaries(limit = 5) {
+    const sessions = db_1.dbOps.getAllSessions()
+        .filter(s => !s.ai_summary)
+        .slice(0, limit);
+    for (const s of sessions) {
+        try {
+            const events = db_1.dbOps.getSessionEvents(s.id);
+            const projectName = s.project_path ? path_1.default.basename(s.project_path) : undefined;
+            const summary = await (0, summarizer_1.summarizeSession)(events, s.total_cost_usd ?? 0, projectName);
+            if (summary) {
+                db_1.dbOps.updateSessionSummary(s.id, summary);
+                console.log(`[daemon] Summary generado para sesión ${s.id.slice(0, 8)}: "${summary}"`);
+            }
+        }
+        catch (err) {
+            console.error('[daemon] Error generating summary:', err);
+        }
+    }
+}
+// ─── Interval refs for cleanup ────────────────────────────────────────────────
+let projectCacheInterval = null;
+let reportInterval = null;
+let alertInterval = null;
+function shutdown(server) {
+    (0, enricher_1.stopEnricher)();
+    (0, rate_limiter_1.stopRateLimiter)();
+    if (projectCacheInterval) {
+        clearInterval(projectCacheInterval);
+        projectCacheInterval = null;
+    }
+    if (reportInterval) {
+        clearInterval(reportInterval);
+        reportInterval = null;
+    }
+    if (alertInterval) {
+        clearInterval(alertInterval);
+        alertInterval = null;
+    }
+    cleanPid();
+    server.close();
+}
+const LEVEL_RANK = { yellow: 1, orange: 2, red: 3 };
+const LEVEL_COLOR = {
+    yellow: '\x1b[33m',
+    orange: '\x1b[33m',
+    red: '\x1b[31m',
+};
+let _lastAlertLevel = null;
+function startAlertPolling() {
+    alertInterval = setInterval(() => {
+        try {
+            const cfg = (0, config_1.readConfig)();
+            if (!cfg.alertsEnabled)
+                return;
+            const data = (0, quota_tracker_1.computeQuota)(cfg.plan ?? undefined);
+            const level = (0, config_1.getWarnLevel)(data.cyclePct, cfg.warnThresholds);
+            if (!level) {
+                _lastAlertLevel = null;
+                return;
+            }
+            const prevRank = _lastAlertLevel ? LEVEL_RANK[_lastAlertLevel] ?? 0 : 0;
+            const currRank = LEVEL_RANK[level] ?? 0;
+            if (currRank > prevRank) {
+                const color = LEVEL_COLOR[level];
+                process.stderr.write(`${color}[claudestat] ⚠️  Rate limit alert: ${data.cyclePct}% of quota used (${data.cyclePrompts}/${data.cycleLimit} prompts)\x1b[0m\n`);
+                if (data.cyclePct >= cfg.killSwitchThreshold) {
+                    (0, notifier_1.sendDesktopNotification)('claudestat — Rate limit warning', `${data.cyclePct}% of 5h quota used (${data.cyclePrompts}/${data.cycleLimit} prompts)`);
+                }
+                _lastAlertLevel = level;
+            }
+        }
+        catch {
+            // quota read failed — ignore
+        }
+    }, 60000);
+}
+// ─── Report scheduler ─────────────────────────────────────────────────────────
+const PROJECTS_CACHE_TTL = 2 * 60000; // 2 minutos
+const PID_FILE = (0, paths_1.getPidFile)();
+function writePid() {
+    try {
+        const dir = (0, paths_1.getClaudestatDir)();
+        fs_1.default.mkdirSync(dir, { recursive: true });
+        fs_1.default.writeFileSync(PID_FILE, String(process.pid));
+    }
+    catch { }
+}
+function cleanPid() {
+    try {
+        fs_1.default.unlinkSync(PID_FILE);
+    }
+    catch { }
+}
+function startDaemon() {
+    _server = app.listen(PORT, '127.0.0.1', () => {
+        writePid();
+        process.on('exit', cleanPid);
+        process.on('SIGTERM', () => { shutdown(_server); process.exit(0); });
+        process.on('SIGINT', () => { shutdown(_server); process.exit(0); });
+        console.log(`\n● claudestat daemon  →  http://localhost:${PORT}`);
+        console.log(`  Waiting for Claude Code events...\n`);
+        console.log(`  In another terminal: \x1b[36mclaudestat watch\x1b[0m\n`);
+        // Etiquetar sesiones históricas que no tienen proyecto asignado
+        migrateSessionProjects();
+        // Pre-scan de proyectos al arrancar — garantiza respuesta inmediata en el tab
+        // Se ejecuta en background para no retrasar el inicio del servidor
+        setImmediate(() => {
+            const projects = (0, projects_cache_1.getProjectsCached)();
+            console.log(`[daemon] ${projects?.length ?? 0} projects scanned`);
+        });
+        // Refresh automático del cache de proyectos cada 2 minutos
+        // Recoge cambios en HANDOFF.md aunque el daemon lleve horas corriendo
+        projectCacheInterval = setInterval(() => {
+            (0, projects_cache_1.invalidateProjectsCache)();
+            (0, projects_cache_1.getProjectsCached)();
+        }, PROJECTS_CACHE_TTL);
+        // Iniciar el watcher de JSONL para enriquecimiento de coste
+        (0, enricher_1.startEnricher)(events_1.onCostUpdate, events_1.onCompactDetected);
+        // Scheduler de informes automáticos — corre cada minuto
+        reportInterval = setInterval(() => {
+            const cfg = (0, config_1.readConfig)();
+            if (!cfg.reportsEnabled)
+                return;
+            const dateLabel = (0, reports_1.getReportDateLabel)(new Date(), cfg);
+            if (!dateLabel)
+                return;
+            if (db_1.dbOps.getWeeklyReportByDate(dateLabel))
+                return; // ya existe
+            const markdown = (0, reports_1.generateReport)(dateLabel, cfg);
+            db_1.dbOps.insertWeeklyReport(dateLabel, markdown);
+            console.log(`[daemon] Report auto-generated: ${dateLabel}`);
+        }, 60000);
+        // Summaries IA solo si opt-in explícito (CLAUDESTAT_AI_SUMMARY=true)
+        if (process.env.CLAUDESTAT_AI_SUMMARY === 'true') {
+            migrateSessionSummaries(5).catch(() => { });
+        }
+        // Polling de alertas de rate limit cada 60s
+        startAlertPolling();
+    });
+    // Manejo de error de puerto ocupado — fuera del callback para capturar EADDRINUSE
+    _server.on('error', (err) => {
+        if (err.code === 'EADDRINUSE') {
+            console.error(`\n❌ Error: Port ${PORT} is already in use.`);
+            console.error(`   Is claudestat already running? Check with: ${(0, paths_1.portCheckCmd)(PORT)}`);
+            console.error(`   If so, you don't need to start it again.\n`);
+            process.exit(1);
+        }
+        throw err;
+    });
+}