@statforge/claudestat 1.0.1

package/dist/quota-tracker.js

@@ -0,0 +1,320 @@
+"use strict";
+/**
+ * quota-tracker.ts — Seguimiento de cuota de uso de Claude Code
+ *
+ * Calcula en base a los JSONL de ~/.claude/projects/:
+ * - Prompts reales en el ciclo actual de 5 horas (ventana deslizante desde epoch UTC)
+ * - Tiempo hasta el reset del ciclo
+ * - Horas de sesión semanales por modelo (Sonnet vs Opus)
+ * - Burn rate: tokens/min promedio de los últimos 30 minutos
+ * - Plan detectado automáticamente desde el máximo histórico
+ *
+ * Por qué 5h desde epoch UTC (no desde una hora fija):
+ *   Claude Code usa ventanas deslizantes de exactamente 5 horas desde el epoch Unix.
+ *   Ciclo actual = floor(now / 5h) * 5h. El reset ocurre cuando cruza ese límite.
+ *
+ * Caché de 30 segundos para no re-leer todos los JSONL en cada request del dashboard.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeQuota = computeQuota;
+exports.invalidateQuotaCache = invalidateQuotaCache;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const claude_auth_1 = require("./claude-auth");
+const paths_1 = require("./paths");
+const PLAN_LIMITS = {
+    free: { prompts5h: 10, weeklyHoursSonnet: 40, weeklyHoursOpus: 0 },
+    pro: { prompts5h: 45, weeklyHoursSonnet: 80, weeklyHoursOpus: 0 },
+    max5: { prompts5h: 225, weeklyHoursSonnet: 280, weeklyHoursOpus: 35 },
+    max20: { prompts5h: 900, weeklyHoursSonnet: 480, weeklyHoursOpus: 40 },
+};
+// ─── Helpers de ventanas temporales ──────────────────────────────────────────
+const CYCLE_MS = 5 * 60 * 60 * 1000; // 5 horas en ms
+const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
+const WINDOW_5MIN = 5 * 60 * 1000; // ventana de 5 min para agrupar actividad por modelo
+/**
+ * Calcula el timestamp de reset usando ventana rolling real.
+ *
+ * Claude Code NO usa floor(now/5h) desde epoch UTC — usa una ventana rolling
+ * que empieza desde el primer mensaje del ciclo actual.
+ *
+ * Enfoque: buscar el primer mensaje humano en los últimos 5h de actividad.
+ * resetAt = primerMensaje.ts + 5h
+ *
+ * Si no hay mensajes en las últimas 5h → el ciclo ya reseteó, el próximo
+ * reset es en 5h desde el primer mensaje futuro (mostramos ~5h).
+ */
+function computeResetAt(entries, now) {
+    const fiveHoursAgo = now - CYCLE_MS;
+    const recentHuman = entries
+        .filter(e => e.type === 'human' && e.ts >= fiveHoursAgo)
+        .sort((a, b) => a.ts - b.ts);
+    if (recentHuman.length > 0) {
+        // Usamos el PRIMER mensaje humano (más antiguo) + 5h
+        // = momento en que el primer prompt de la ventana actual expira → cuota empieza a liberarse
+        // Los mensajes tool_result de sub-agentes ya están filtrados en el caller
+        return recentHuman[0].ts + CYCLE_MS;
+    }
+    // Sin actividad en las últimas 5h → cuota ya libre, no hay reset pendiente
+    // Retornar `now` hace que cycleResetMs = 0, la UI puede mostrar "Disponible"
+    return now;
+}
+function getWeekStart(now) {
+    // Lunes 00:00 hora local
+    const d = new Date(now);
+    const day = d.getDay(); // 0=domingo … 6=sábado
+    const diff = day === 0 ? -6 : 1 - day; // días hasta el lunes anterior
+    d.setDate(d.getDate() + diff);
+    d.setHours(0, 0, 0, 0);
+    return d.getTime();
+}
+// ─── Parser de un archivo JSONL ───────────────────────────────────────────────
+function parseJSONLFile(filePath) {
+    const entries = [];
+    let content;
+    try {
+        content = fs_1.default.readFileSync(filePath, 'utf8');
+    }
+    catch {
+        return entries;
+    }
+    for (const raw of content.split('\n')) {
+        const line = raw.trim();
+        if (!line)
+            continue;
+        try {
+            const obj = JSON.parse(line);
+            // Timestamp: ISO string en la raíz del objeto
+            const ts = obj.timestamp ? new Date(obj.timestamp).getTime() : 0;
+            if (!ts || isNaN(ts))
+                continue;
+            // Mensajes de usuario: tipo 'human' (algunas versiones usan 'user')
+            if (obj.type === 'human' || obj.type === 'user') {
+                // Filtrar comandos locales — no son prompts reales del usuario
+                const content = obj.message?.content;
+                // Saltar mensajes internos de sub-agentes: su content comienza con tool_result
+                // (son respuestas de herramientas que el sub-agente recibe, no prompts del usuario)
+                if (Array.isArray(content) && content[0]?.type === 'tool_result')
+                    continue;
+                const text = typeof content === 'string' ? content
+                    : Array.isArray(content)
+                        ? content.find(c => c?.type === 'text')?.text ?? ''
+                        : '';
+                if (text.includes('<command-name>') ||
+                    text.includes('<local-command-stdout>') ||
+                    text.includes('<system-reminder>'))
+                    continue;
+                entries.push({ ts, type: 'human' });
+            }
+            // Respuestas del asistente: tienen datos de uso de tokens
+            if (obj.type === 'assistant') {
+                const usage = obj.message?.usage;
+                const model = obj.message?.model ?? 'claude-sonnet-4-6';
+                entries.push({
+                    ts, type: 'assistant',
+                    model,
+                    inputTokens: usage?.input_tokens ?? 0,
+                    outputTokens: usage?.output_tokens ?? 0,
+                });
+            }
+        }
+        catch {
+            // Línea malformada — ignorar y continuar
+        }
+    }
+    return entries;
+}
+// ─── Detección automática de plan ────────────────────────────────────────────
+/**
+ * Infiere el plan mirando el máximo de prompts humanos en cualquier ciclo de 5h.
+ * Si en algún ciclo hubo >200 prompts → Max20. Si >40 → Max5. Si ≤40 → Pro.
+ *
+ * Es conservador: si nunca se ha llegado al límite, asume Pro.
+ */
+function detectPlan(entries) {
+    const countsByCycle = new Map();
+    for (const e of entries) {
+        if (e.type !== 'human')
+            continue;
+        const cycle = Math.floor(e.ts / CYCLE_MS) * CYCLE_MS;
+        countsByCycle.set(cycle, (countsByCycle.get(cycle) ?? 0) + 1);
+    }
+    const maxSeen = countsByCycle.size > 0 ? Math.max(...countsByCycle.values()) : 0;
+    if (maxSeen > 200)
+        return 'max20';
+    if (maxSeen > 40)
+        return 'max5';
+    return 'pro';
+}
+// ─── Lector de todos los JSONL ────────────────────────────────────────────────
+const PROJECTS_DIR = path_1.default.join((0, paths_1.getClaudeDir)(), 'projects');
+function readAllEntries(sinceTs) {
+    const all = [];
+    try {
+        if (!fs_1.default.existsSync(PROJECTS_DIR))
+            return all;
+        for (const dir of fs_1.default.readdirSync(PROJECTS_DIR)) {
+            const dirPath = path_1.default.join(PROJECTS_DIR, dir);
+            try {
+                if (!fs_1.default.statSync(dirPath).isDirectory())
+                    continue;
+                // Recopilar todos los subdirectorios a leer: el propio dir + cualquier <uuid>/subagents/
+                const subdirs = [dirPath];
+                try {
+                    for (const entry of fs_1.default.readdirSync(dirPath)) {
+                        const entryPath = path_1.default.join(dirPath, entry);
+                        if (fs_1.default.statSync(entryPath).isDirectory()) {
+                            const subagentsPath = path_1.default.join(entryPath, 'subagents');
+                            if (fs_1.default.existsSync(subagentsPath))
+                                subdirs.push(subagentsPath);
+                        }
+                    }
+                }
+                catch { /* ignorar */ }
+                for (const subdir of subdirs) {
+                    try {
+                        if (!fs_1.default.existsSync(subdir))
+                            continue;
+                        // Recopilar archivos con su mtime para ordenar por recencia y limitar
+                        const candidates = [];
+                        for (const file of fs_1.default.readdirSync(subdir)) {
+                            if (!file.endsWith('.jsonl'))
+                                continue;
+                            if (!file.includes('-') || file.length < 15)
+                                continue;
+                            try {
+                                const mtime = fs_1.default.statSync(path_1.default.join(subdir, file)).mtimeMs;
+                                if (mtime < sinceTs - WEEK_MS)
+                                    continue;
+                                candidates.push({ path: path_1.default.join(subdir, file), mtime });
+                            }
+                            catch {
+                                continue;
+                            }
+                        }
+                        // Procesar solo los 300 más recientes — evita bloquear el event loop
+                        candidates
+                            .sort((a, b) => b.mtime - a.mtime)
+                            .slice(0, 300)
+                            .forEach(c => all.push(...parseJSONLFile(c.path)));
+                    }
+                    catch { /* subdir inaccesible */ }
+                }
+            }
+            catch { /* directorio inaccesible */ }
+        }
+    }
+    catch { /* PROJECTS_DIR inaccesible */ }
+    return all;
+}
+// ─── Caché de 30 segundos ─────────────────────────────────────────────────────
+let cache = null;
+const CACHE_TTL = 30000; // 30 segundos
+// ─── Función principal ────────────────────────────────────────────────────────
+/**
+ * Calcula y retorna QuotaData.
+ * Usa caché de 30s para no re-leer todos los JSONL en cada request del dashboard.
+ * Pasar `forcePlan` para fijar el plan manualmente (por config del usuario).
+ */
+function computeQuota(forcePlan) {
+    const now = Date.now();
+    // Devolver caché si está fresco y no se fuerza plan
+    if (!forcePlan && cache && now - cache.ts < CACHE_TTL) {
+        return cache.data;
+    }
+    const weekStart = getWeekStart(now);
+    const thirtyMinAgo = now - 30 * 60 * 1000;
+    // Leer entradas relevantes (última semana + un poco más para detección de plan)
+    const entries = readAllEntries(weekStart - CYCLE_MS);
+    // ─ Plan (prioridad: config manual → keychain → inferencia JSONL) ─
+    let plan;
+    let planSource;
+    if (forcePlan) {
+        plan = forcePlan;
+        planSource = 'config';
+    }
+    else {
+        // Intentar leer plan desde las credenciales del keychain (más fiable que inferir)
+        const auth = (0, claude_auth_1.readClaudeAuth)();
+        if (auth.source !== 'unknown' && auth.subscriptionType !== 'unknown') {
+            plan = (0, claude_auth_1.subscriptionTypeToPlan)(auth.subscriptionType, auth.rateLimitTier);
+            planSource = 'keychain';
+        }
+        else {
+            plan = detectPlan(entries);
+            planSource = 'inferred';
+        }
+    }
+    const limits = PLAN_LIMITS[plan];
+    // ─ Ciclo 5h: ventana deslizante [now-5h, now] ─
+    const fiveHAgo = now - CYCLE_MS;
+    const cycleResetAt = computeResetAt(entries, now);
+    const cycleStart = fiveHAgo; // inicio real de la ventana de conteo
+    const cyclePrompts = entries.filter(e => e.type === 'human' && e.ts >= fiveHAgo).length;
+    const cyclePct = Math.min(100, Math.round(cyclePrompts / limits.prompts5h * 100));
+    const cycleResetMs = Math.max(0, cycleResetAt - now);
+    // ─ Semanal por modelo: ventanas de 5 min con actividad ─
+    // Contamos ventanas de 5 min distintas con al menos 1 respuesta por modelo
+    const sonnetWindows = new Set();
+    const opusWindows = new Set();
+    const haikuWindows = new Set();
+    let weeklyTokensSonnet = 0;
+    let weeklyTokensOpus = 0;
+    let weeklyTokensHaiku = 0;
+    for (const e of entries) {
+        if (e.type !== 'assistant' || e.ts < weekStart)
+            continue;
+        const win = Math.floor(e.ts / WINDOW_5MIN) * WINDOW_5MIN;
+        const tokens = (e.inputTokens ?? 0) + (e.outputTokens ?? 0);
+        if (e.model?.includes('opus')) {
+            opusWindows.add(win);
+            weeklyTokensOpus += tokens;
+        }
+        else if (e.model?.includes('haiku')) {
+            haikuWindows.add(win);
+            weeklyTokensHaiku += tokens;
+        }
+        else {
+            sonnetWindows.add(win);
+            weeklyTokensSonnet += tokens;
+        }
+    }
+    const weeklyHoursSonnet = parseFloat((sonnetWindows.size * 5 / 60).toFixed(1));
+    const weeklyHoursOpus = parseFloat((opusWindows.size * 5 / 60).toFixed(1));
+    const weeklyHoursHaiku = parseFloat((haikuWindows.size * 5 / 60).toFixed(1));
+    // ─ Burn rate: tokens/min en los últimos 30 min ─
+    const recentAssistant = entries.filter(e => e.type === 'assistant' && e.ts >= thirtyMinAgo);
+    const totalRecentTok = recentAssistant.reduce((sum, e) => sum + (e.inputTokens ?? 0) + (e.outputTokens ?? 0), 0);
+    const burnRateTokensPerMin = recentAssistant.length > 0
+        ? Math.round(totalRecentTok / 30)
+        : 0;
+    const data = {
+        cyclePrompts,
+        cycleLimit: limits.prompts5h,
+        cyclePct,
+        cycleResetMs,
+        cycleResetAt,
+        cycleStartTs: cycleStart,
+        weeklyHoursSonnet,
+        weeklyHoursOpus,
+        weeklyHoursHaiku,
+        weeklyTokensSonnet,
+        weeklyTokensOpus,
+        weeklyTokensHaiku,
+        weeklyLimitSonnet: limits.weeklyHoursSonnet,
+        weeklyLimitOpus: limits.weeklyHoursOpus,
+        burnRateTokensPerMin,
+        detectedPlan: plan,
+        planSource,
+        computedAt: now,
+    };
+    cache = { data, ts: now };
+    return data;
+}
+/** Invalida la caché (llamar cuando llega un nuevo evento para que el siguiente /quota sea fresco) */
+function invalidateQuotaCache() {
+    cache = null;
+}

package/dist/render.d.ts

@@ -0,0 +1,55 @@
+/**
+ * render.ts — Renderizado del trace tree en terminal (Phase 2 visual upgrade)
+ *
+ * Mejoras sobre Phase 1:
+ * - Agrupa tool calls por bloque de respuesta (entre Stop events)
+ * - Detecta modo por bloque: Claude directo / Con agentes / Con skills
+ * - Barra visual de contexto (cuánto % del contexto está en uso)
+ * - Barra visual de eficiencia
+ * - Tokens en formato legible (K / M)
+ * - Badge de loop por línea de tool repetido
+ * - Coste y stats por bloque individual
+ */
+export interface TraceEvent {
+    type: string;
+    tool_name?: string;
+    tool_input?: string;
+    ts: number;
+    duration_ms?: number;
+    session_id?: string;
+    cwd?: string;
+}
+export interface LoopAlert {
+    toolName: string;
+    count: number;
+    ts: number;
+}
+export interface CostInfo {
+    cost_usd: number;
+    input_tokens: number;
+    output_tokens: number;
+    cache_read: number;
+    cache_creation: number;
+    efficiency_score: number;
+    loops: LoopAlert[];
+    summary?: string;
+    context_used?: number;
+    context_window?: number;
+}
+export interface WeeklyStats {
+    totalTokens: number;
+    byDay: {
+        date: string;
+        tokens: number;
+    }[];
+    lastUpdated: string | null;
+}
+export interface RenderState {
+    sessionId: string;
+    cwd: string;
+    startedAt: number;
+    events: TraceEvent[];
+    cost?: CostInfo;
+    weekly?: WeeklyStats;
+}
+export declare function renderTrace(state: RenderState): string;

package/dist/render.js

@@ -0,0 +1,229 @@
+"use strict";
+/**
+ * render.ts — Renderizado del trace tree en terminal (Phase 2 visual upgrade)
+ *
+ * Mejoras sobre Phase 1:
+ * - Agrupa tool calls por bloque de respuesta (entre Stop events)
+ * - Detecta modo por bloque: Claude directo / Con agentes / Con skills
+ * - Barra visual de contexto (cuánto % del contexto está en uso)
+ * - Barra visual de eficiencia
+ * - Tokens en formato legible (K / M)
+ * - Badge de loop por línea de tool repetido
+ * - Coste y stats por bloque individual
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderTrace = renderTrace;
+const TOOL_ICONS = {
+    Read: '📖', Write: '✏️', Edit: '✏️', Bash: '🖥️',
+    Glob: '🔍', Grep: '🔎', WebSearch: '🌐', WebFetch: '🌐',
+    Agent: '🤖', Skill: '⚡', TodoWrite: '📝', TodoRead: '📝',
+    Task: '📋', default: '🔧'
+};
+const C = {
+    reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
+    green: '\x1b[32m', yellow: '\x1b[33m', blue: '\x1b[34m',
+    cyan: '\x1b[36m', red: '\x1b[31m', gray: '\x1b[90m',
+    bgRed: '\x1b[41m',
+};
+// ─── Helpers de formato ───────────────────────────────────────────────────────
+function relTs(base, ts) {
+    const diff = ts - base;
+    const s = Math.floor(diff / 1000);
+    const ms = diff % 1000;
+    return `${String(s).padStart(2, '0')}:${String(ms).padStart(3, '0')}`;
+}
+function fmtMs(ms) {
+    if (!ms)
+        return '';
+    return ms < 1000 ? `${ms}ms` : `${(ms / 1000).toFixed(1)}s`;
+}
+// Formatea tokens en K o M para legibilidad
+function fmtTok(n) {
+    if (n >= 1000000)
+        return `${(n / 1000000).toFixed(1)}M`;
+    if (n >= 1000)
+        return `${(n / 1000).toFixed(1)}K`;
+    return String(n);
+}
+function trunc(s, n = 48) {
+    return s.length > n ? s.slice(0, n - 3) + '...' : s;
+}
+function detail(toolName, rawInput) {
+    if (!toolName || !rawInput)
+        return '';
+    try {
+        const inp = JSON.parse(rawInput);
+        if (['Read', 'Write', 'Edit'].includes(toolName))
+            return trunc(inp.file_path || inp.path || '');
+        if (toolName === 'Bash')
+            return trunc(inp.command || '');
+        if (['Glob', 'Grep'].includes(toolName))
+            return trunc(inp.pattern || inp.query || '');
+        if (['WebSearch', 'WebFetch'].includes(toolName))
+            return trunc(inp.query || inp.url || '');
+        if (toolName === 'Agent')
+            return trunc((inp.prompt || '').slice(0, 45));
+        if (toolName === 'Skill')
+            return trunc(inp.skill || inp.name || '');
+    }
+    catch { }
+    return '';
+}
+// Barra de progreso visual: ████████░░░░  63%
+function progressBar(pct, width = 18, color = C.cyan) {
+    const clamped = Math.max(0, Math.min(100, pct));
+    const filled = Math.round(clamped / 100 * width);
+    const empty = width - filled;
+    return `${color}${'█'.repeat(filled)}${C.dim}${'░'.repeat(empty)}${C.reset}`;
+}
+function detectMode(tools) {
+    const hasAgent = tools.some(e => e.tool_name === 'Agent');
+    const hasSkill = tools.some(e => e.tool_name === 'Skill');
+    if (hasAgent && hasSkill)
+        return 'agentes+skills';
+    if (hasAgent)
+        return 'agentes';
+    if (hasSkill)
+        return 'skills';
+    return 'directo';
+}
+function modeLabel(mode) {
+    const labels = {
+        'directo': `${C.dim}Claude directo${C.reset}`,
+        'agentes': `${C.yellow}🤖 Con agentes${C.reset}`,
+        'skills': `${C.cyan}⚡ Con skills${C.reset}`,
+        'agentes+skills': `${C.yellow}🤖⚡ Agentes + skills${C.reset}`,
+    };
+    return labels[mode];
+}
+function groupByResponse(events) {
+    const blocks = [];
+    let current = { index: 1, tools: [], mode: 'directo' };
+    for (const ev of events) {
+        if (ev.type === 'SessionStart')
+            continue;
+        if (ev.type === 'Stop') {
+            current.stop = ev;
+            current.mode = detectMode(current.tools);
+            blocks.push(current);
+            current = { index: blocks.length + 1, tools: [], mode: 'directo' };
+        }
+        else {
+            current.tools.push(ev);
+        }
+    }
+    // Bloque en curso (sin Stop todavía — Claude está respondiendo)
+    if (current.tools.length > 0) {
+        current.mode = detectMode(current.tools);
+        blocks.push(current);
+    }
+    return blocks;
+}
+// ─── Render principal ─────────────────────────────────────────────────────────
+function renderTrace(state) {
+    const { sessionId, cwd, startedAt, events, cost } = state;
+    const lines = [];
+    // ── Header de sesión ──────────────────────────────────────────────────────
+    lines.push('');
+    lines.push(`${C.bold}● claudestat${C.reset}  ` +
+        `${C.dim}session:${C.reset} ${C.cyan}${sessionId.slice(0, 8)}${C.reset}  ` +
+        `${C.dim}dir:${C.reset} ${C.blue}${cwd || '—'}${C.reset}`);
+    // ── Barra de contexto ─────────────────────────────────────────────────────
+    if (cost?.context_used && cost.context_window) {
+        const pct = Math.round(cost.context_used / cost.context_window * 100);
+        const barColor = pct > 80 ? C.red : pct > 60 ? C.yellow : C.green;
+        const bar = progressBar(pct, 24, barColor);
+        const remaining = 100 - pct;
+        lines.push(`  ${C.dim}auto-compact en:${C.reset} ${bar}  ` +
+            `${barColor}${remaining}% restante${C.reset}  ` +
+            `${C.dim}${fmtTok(cost.context_used)} / ${fmtTok(cost.context_window)} tokens usados${C.reset}`);
+    }
+    else {
+        lines.push(`  ${C.dim}contexto: calculando...${C.reset}`);
+    }
+    lines.push(C.dim + '─'.repeat(72) + C.reset);
+    // ── Bloques de respuesta ──────────────────────────────────────────────────
+    const blocks = groupByResponse(events);
+    for (const block of blocks) {
+        const isLast = block.index === blocks.length;
+        const inProgress = !block.stop && isLast;
+        // Contar repeticiones de cada tool en este bloque (para badge de loop)
+        const toolCount = new Map();
+        for (const t of block.tools) {
+            if (t.tool_name)
+                toolCount.set(t.tool_name, (toolCount.get(t.tool_name) || 0) + 1);
+        }
+        const isLooping = (name) => (toolCount.get(name) || 0) >= 3;
+        // Cabecera del bloque
+        const blockHeader = inProgress
+            ? `${C.yellow}⟳ Respuesta #${block.index}${C.reset}`
+            : `${C.dim}Respuesta #${block.index}${C.reset}`;
+        lines.push(`  ${blockHeader}  ${modeLabel(block.mode)}`);
+        // Tool calls del bloque
+        for (const ev of block.tools) {
+            const ts = `${C.gray}[${relTs(startedAt, ev.ts)}]${C.reset}`;
+            const det = detail(ev.tool_name, ev.tool_input);
+            const ico = TOOL_ICONS[ev.tool_name || ''] || TOOL_ICONS.default;
+            const loopBadge = ev.tool_name && isLooping(ev.tool_name)
+                ? `  ${C.red}⚠ loop${C.reset}` : '';
+            if (ev.type === 'PreToolUse') {
+                lines.push(`    ${ts} ${ico} ${C.yellow}${ev.tool_name}${C.reset}` +
+                    (det ? `  ${C.dim}${det}${C.reset}` : '') +
+                    `  ${C.dim}⟳${C.reset}${loopBadge}`);
+            }
+            else if (ev.type === 'Done') {
+                lines.push(`    ${ts} ${ico} ${C.green}${ev.tool_name}${C.reset}` +
+                    (det ? `  ${C.dim}${det}${C.reset}` : '') +
+                    (ev.duration_ms ? `  ${C.dim}(${fmtMs(ev.duration_ms)})${C.reset}` : '') +
+                    loopBadge);
+            }
+        }
+        // Pie del bloque (solo si terminó)
+        if (block.stop) {
+            const toolsDone = block.tools.filter(e => e.type === 'Done').length;
+            const elapsed = fmtMs(block.stop.ts - (block.tools[0]?.ts ?? block.stop.ts));
+            lines.push(`    ${C.dim}└─ ✅ ${toolsDone} tools · ${elapsed}${C.reset}`);
+        }
+        lines.push('');
+    }
+    // ── Footer global ─────────────────────────────────────────────────────────
+    lines.push(C.dim + '─'.repeat(72) + C.reset);
+    if (cost && cost.cost_usd > 0) {
+        // Alertas de loops
+        if (cost.loops?.length) {
+            for (const loop of cost.loops) {
+                lines.push(`  ${C.red}⚠  Loop: ${loop.toolName} x${loop.count} en 60s${C.reset}`);
+            }
+        }
+        // Barra de eficiencia — si score es 0 y cost es muy bajo, aún no calculó
+        const score = (cost.efficiency_score === 0 && cost.cost_usd < 0.001) ? 100 : cost.efficiency_score;
+        const scoreColor = score >= 90 ? C.green : score >= 70 ? C.yellow : C.red;
+        const scoreBar = progressBar(score, 14, scoreColor);
+        // Tokens
+        const tokenLine = `${C.dim}↑${C.reset}${fmtTok(cost.input_tokens)} ` +
+            `${C.dim}↓${C.reset}${fmtTok(cost.output_tokens)} ` +
+            `${C.dim}🗄${C.reset}${fmtTok(cost.cache_read)}`;
+        lines.push(`  ${C.bold}💰 $${cost.cost_usd.toFixed(4)}${C.reset}   ` +
+            `${tokenLine}   ` +
+            `eficiencia: ${scoreBar} ${scoreColor}${score}/100${C.reset}`);
+    }
+    else {
+        const totalDone = events.filter(e => e.type === 'Done').length;
+        const elapsed = fmtMs((events.at(-1)?.ts ?? startedAt) - startedAt);
+        lines.push(`  ${C.dim}⏱ ${elapsed}  ✅ ${totalDone} tools  💰 calculando...${C.reset}`);
+    }
+    // ── Barra semanal (stats-cache.json) ──────────────────────────────────────
+    if (state.weekly && state.weekly.totalTokens > 0) {
+        const { totalTokens, byDay, lastUpdated } = state.weekly;
+        // Mini sparkline: un char por día de la semana
+        const maxDay = Math.max(...byDay.map(d => d.tokens), 1);
+        const BARS = ['▁', '▂', '▃', '▄', '▅', '▆', '▇', '█'];
+        const spark = byDay.map(d => BARS[Math.min(7, Math.floor(d.tokens / maxDay * 7))]).join('');
+        const padded = spark.padStart(7, '▁'); // garantizar 7 chars (1 por día)
+        lines.push(`  ${C.dim}semanal:${C.reset}  ${C.cyan}${padded}${C.reset}  ` +
+            `${C.bold}${fmtTok(totalTokens)} tokens${C.reset}  ` +
+            `${C.dim}(últimos 7 días${lastUpdated ? ' · datos al ' + lastUpdated : ''})${C.reset}`);
+    }
+    lines.push('');
+    return lines.join('\n');
+}

package/dist/routes/events.d.ts

@@ -0,0 +1,18 @@
+import { processLatestForSession, type CostUpdateCallback, type CompactDetectedCallback } from '../enricher';
+export declare const eventsRouter: import("express-serve-static-core").Router;
+export declare const lastAgentByCwd: Map<string, {
+    pre_ts: number;
+    session_id: string;
+}>;
+export declare const taggedSessionParents: Set<string>;
+/** Sube el árbol desde un file_path hasta encontrar HANDOFF.md → directorio del proyecto */
+export declare function findProjectCwdForFile(filePath: string): string | undefined;
+/**
+ * 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
+ */
+export declare const onCostUpdate: CostUpdateCallback;
+export declare const onCompactDetected: CompactDetectedCallback;
+export { processLatestForSession };