@statforge/claudestat 1.2.0 → 1.2.2

package/dist/mcp-server.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env -S node --disable-warning=ExperimentalWarning
 "use strict";
 /**
  * mcp-server.ts — MCP (Model Context Protocol) server for claudestat
@@ -50,9 +50,10 @@ const readline = __importStar(require("readline"));
 const db_1 = require("./db");
 const quota_tracker_1 = require("./quota-tracker");
 const insights_1 = require("./insights");
+const config_1 = require("./config");
 const SERVER_NAME = 'claudestat';
-const SERVER_VERSION = '1.2.0';
-const PROTOCOL_VERSION = '2025-06-18';
+const SERVER_VERSION = '1.2.2';
+const PROTOCOL_VERSION = '2025-03-26';
 const TOOLS = [
     {
         name: 'get_quota_status',
@@ -104,6 +105,34 @@ const TOOLS = [
             required: []
         }
     },
+    {
+        name: 'get_usage_insights',
+        description: 'Get unique usage insights not available in /usage: cost per project, cache savings, output/input ratio, efficiency trend, and peak hours',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                days: {
+                    type: 'number',
+                    description: 'Days to look back (default 7)'
+                }
+            },
+            required: []
+        }
+    },
+    {
+        name: 'get_model_breakdown',
+        description: 'Get cost and session count broken down by Claude model (Sonnet, Haiku, Opus) for the last N days',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                days: {
+                    type: 'number',
+                    description: 'Days to look back (default 7)'
+                }
+            },
+            required: []
+        }
+    },
     {
         name: 'get_weekly_insight',
         description: 'Get the weekly usage summary with an actionable tip (same as claudestat weekly command)',
@@ -141,10 +170,13 @@ function toolGetQuotaStatus() {
         : `${resetMin}m`;
     const weeklyTotalHours = q.weeklyHoursSonnet + q.weeklyHoursOpus;
     const weeklyLimitTotal = q.weeklyLimitSonnet + q.weeklyLimitOpus;
+    const planLabel = q.planSource === 'inferred'
+        ? `${q.detectedPlan.toUpperCase()} plan (unverified — checking API...)`
+        : `${q.detectedPlan.toUpperCase()} plan`;
     const parts = [
-        `Quota status — ${q.detectedPlan.toUpperCase()} plan`,
+        `Quota status — ${planLabel}`,
         ``,
-        `5h cycle:    ${q.cyclePrompts}/${q.cycleLimit} prompts (${q.cyclePct}%)  ·  resets in ${resetLabel}`,
+        `5h cycle:    ${q.cyclePct}%  ·  ${q.cyclePrompts > q.cycleLimit ? `${q.cyclePrompts}/${q.cycleLimit} prompts (OVER LIMIT)` : `${q.cyclePrompts}/${q.cycleLimit} prompts`}  ·  resets in ${resetLabel}`,
         `Weekly:      ${weeklyTotalHours}h / ${weeklyLimitTotal}h (${q.weeklyPctAll}%)`,
     ];
     if (q.weeklyLimitOpus > 0) {
@@ -154,6 +186,33 @@ function toolGetQuotaStatus() {
     if (q.burnRateTokensPerMin > 0) {
         parts.push(`Burn rate:   ${q.burnRateTokensPerMin.toLocaleString()} tokens/min`);
     }
+    // Active alerts — only shown when thresholds are crossed
+    const cfg = (0, config_1.readConfig)();
+    if (cfg.alertsEnabled) {
+        const alerts = [];
+        const cycleLevel = (0, config_1.getWarnLevel)(q.cyclePct, cfg.warnThresholds);
+        const weeklyLevel = (0, config_1.getWarnLevel)(q.weeklyPctAll, cfg.weeklyWarnThresholds);
+        if (cycleLevel === 'red')
+            alerts.push(`🔴 5h cycle at ${q.cyclePct}% — critical, limit imminent`);
+        else if (cycleLevel)
+            alerts.push(`⚠️  5h cycle at ${q.cyclePct}% — approaching limit`);
+        if (weeklyLevel === 'red')
+            alerts.push(`🔴 Weekly at ${q.weeklyPctAll}% — critical`);
+        else if (weeklyLevel)
+            alerts.push(`⚠️  Weekly at ${q.weeklyPctAll}% — approaching weekly limit`);
+        if (q.cyclePrompts > q.cycleLimit) {
+            alerts.push(`⚠️  Prompt count (${q.cyclePrompts}) exceeds plan limit (${q.cycleLimit}) — plan may be mis-detected`);
+        }
+        const reminderMins = cfg.resetReminderMins ?? 10;
+        if (reminderMins > 0 && resetMin <= reminderMins && resetMin > 0) {
+            alerts.push(`⏰  Cycle resets in ${resetMin}m — good time to wrap up or start fresh`);
+        }
+        if (alerts.length > 0) {
+            parts.push(``);
+            parts.push(`─── ACTIVE ALERTS ───────────────────────`);
+            parts.push(...alerts);
+        }
+    }
     return parts.join('\n');
 }
 function toolGetCurrentSession() {
@@ -221,6 +280,71 @@ function toolGetTopTools(days, sortBy) {
     }
     return lines.join('\n');
 }
+function toolGetUsageInsights(days) {
+    const d = Math.max(1, Math.min(90, Math.floor(days || 7)));
+    const i = (0, insights_1.getUsageInsights)(d);
+    if (i.total_sessions === 0)
+        return `No data for the last ${d} days.`;
+    const bar = (pct, width = 20) => '█'.repeat(Math.round(pct / 100 * width)) + '░'.repeat(width - Math.round(pct / 100 * width));
+    const lines = [];
+    lines.push(`💡 Usage insights — last ${d} days`);
+    lines.push('━'.repeat(44));
+    lines.push(``);
+    lines.push(`  💰  ${fmtDollar(i.avg_cost_per_session)}/session  ·  ${i.total_sessions} sessions  ·  ${fmtDollar(i.total_cost)} total`);
+    if (i.project_costs.length > 0) {
+        lines.push(``);
+        lines.push(`  🗂  Top projects`);
+        const topTotal = i.project_costs.reduce((s, p) => s + p.total_cost, 0);
+        for (const p of i.project_costs.slice(0, 4)) {
+            const pct = topTotal > 0 ? Math.round(p.total_cost / topTotal * 100) : 0;
+            const name = (p.project.split('/').pop() ?? p.project).slice(0, 14).padEnd(14);
+            lines.push(`     ${name}  ${bar(pct)}  ${fmtDollar(p.total_cost)}  ${pct}%`);
+        }
+    }
+    lines.push(``);
+    lines.push(`  ⚡  Cache ~${fmtDollar(i.cache_savings_usd)} saved  ·  ${i.cache_hit_pct}% hit rate`);
+    lines.push(``);
+    lines.push(`  📊  ${i.output_input_ratio}× output/input  ·  ${i.ratio_label}`);
+    lines.push(``);
+    const effTrend = i.efficiency_delta !== -999
+        ? `  ${i.efficiency_delta > 0 ? `↑ +${i.efficiency_delta}` : i.efficiency_delta < 0 ? `↓ ${i.efficiency_delta}` : '→ same'} vs prev period`
+        : '';
+    lines.push(`  📈  Efficiency  ${i.avg_efficiency}/100${effTrend}  ·  ${i.total_loops} loops`);
+    if (i.hour_ranges.length > 0) {
+        lines.push(``);
+        lines.push(`  ⏰  Activity by time of day`);
+        const maxCount = Math.max(...i.hour_ranges.map(r => r.count));
+        for (let j = 0; j < i.hour_ranges.length; j++) {
+            const r = i.hour_ranges[j];
+            const pct = maxCount > 0 ? Math.round(r.count / maxCount * 100) : 0;
+            lines.push(`     ${r.emoji}  ${r.from}–${r.to}  ${bar(pct)}  ${r.count} sessions`);
+            if (j < i.hour_ranges.length - 1)
+                lines.push('');
+        }
+    }
+    lines.push(``);
+    lines.push('━'.repeat(44));
+    return lines.join('\n');
+}
+function toolGetModelBreakdown(days) {
+    const d = Math.max(1, Math.min(90, Math.floor(days || 7)));
+    const models = db_1.dbOps.getModelBreakdown(d);
+    if (models.length === 0)
+        return `No model data in the last ${d} days.`;
+    const totalCost = models.reduce((s, m) => s + m.total_cost, 0);
+    const lines = [
+        `Model breakdown — last ${d} days`,
+        '',
+    ];
+    for (const m of models) {
+        const pct = totalCost > 0 ? Math.round(m.total_cost / totalCost * 100) : 0;
+        const rawName = (m.model ?? 'unknown').replace(/^<|>$/g, '');
+        const name = rawName.padEnd(30);
+        const cost = fmtDollar(m.total_cost).padEnd(10);
+        lines.push(`  ${name}${cost}${pct}%   ${m.session_count} sessions`);
+    }
+    return lines.join('\n');
+}
 function toolGetWeeklyInsight(days) {
     const d = Math.max(1, Math.min(90, Math.floor(days || 7)));
     const data = (0, insights_1.getWeeklyInsightData)(d);
@@ -239,25 +363,25 @@ function toolGetWeeklyInsight(days) {
         `Tip: ${(0, insights_1.generateTip)(data)}`,
     ].join('\n');
 }
-function handleToolCall(name, args) {
-    const days = typeof args.days === 'number' ? args.days : 7;
+async function handleToolCall(name, args) {
     const sortBy = typeof args.sort_by === 'string' ? args.sort_by : 'cost';
     switch (name) {
-        case 'get_quota_status': return toolGetQuotaStatus();
+        case 'get_quota_status':
+            await (0, quota_tracker_1.refreshFromApi)();
+            return toolGetQuotaStatus();
         case 'get_current_session': return toolGetCurrentSession();
-        case 'get_session_stats': return toolGetSessionStats(days);
-        case 'get_top_tools': return toolGetTopTools(days, sortBy);
-        case 'get_weekly_insight': return toolGetWeeklyInsight(days);
+        case 'get_session_stats': return toolGetSessionStats(typeof args.days === 'number' ? args.days : 7);
+        case 'get_top_tools': return toolGetTopTools(typeof args.days === 'number' ? args.days : 30, sortBy);
+        case 'get_usage_insights': return toolGetUsageInsights(typeof args.days === 'number' ? args.days : 7);
+        case 'get_model_breakdown': return toolGetModelBreakdown(typeof args.days === 'number' ? args.days : 7);
+        case 'get_weekly_insight': return toolGetWeeklyInsight(typeof args.days === 'number' ? args.days : 7);
         default: return `Unknown tool: ${name}`;
     }
 }
-function handleRequest(msg) {
+async function handleRequest(msg) {
     const { id, method, params } = msg;
-    if (id === undefined) {
-        if (method === 'notifications/initialized')
-            return null;
+    if (id === undefined)
         return null;
-    }
     try {
         switch (method) {
             case 'initialize':
@@ -274,7 +398,7 @@ function handleRequest(msg) {
             case 'tools/call': {
                 const toolName = params?.name;
                 const toolArgs = (params?.arguments ?? {});
-                const text = handleToolCall(toolName, toolArgs);
+                const text = await handleToolCall(toolName, toolArgs);
                 return {
                     jsonrpc: '2.0', id,
                     result: { content: [{ type: 'text', text }], isError: false }
@@ -301,10 +425,12 @@ rl.on('line', (line) => {
         return;
     try {
         const msg = JSON.parse(trimmed);
-        const response = handleRequest(msg);
-        if (response) {
-            process.stdout.write(JSON.stringify(response) + '\n');
-        }
+        handleRequest(msg).then(response => {
+            if (response)
+                process.stdout.write(JSON.stringify(response) + '\n');
+        }).catch((e) => {
+            process.stderr.write(`[claudestat-mcp] Handler error: ${e.message}\n`);
+        });
     }
     catch (e) {
         process.stderr.write(`[claudestat-mcp] Parse error: ${e.message}\n`);
@@ -312,4 +438,5 @@ rl.on('line', (line) => {
 });
 process.on('SIGTERM', () => process.exit(0));
 process.on('SIGINT', () => process.exit(0));
+// API quota is refreshed on-demand per get_quota_status call (disk cache throttles to 1 call/5min)
 process.stderr.write(`[claudestat-mcp] Server ready (stdio, protocol ${PROTOCOL_VERSION})\n`);

package/dist/notifier.js

@@ -8,15 +8,33 @@ const child_process_1 = require("child_process");
 const os_1 = __importDefault(require("os"));
 function sendDesktopNotification(title, body) {
     try {
-        if (os_1.default.platform() === 'darwin') {
-            const escaped = body.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
-            (0, child_process_1.execSync)(`osascript -e 'display notification "${escaped}" with title "${title}"'`, { stdio: 'ignore' });
+        const platform = os_1.default.platform();
+        if (platform === 'darwin') {
+            const t = title.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+            const b = body.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+            (0, child_process_1.execSync)(`osascript -e 'display notification "${b}" with title "${t}"'`, { stdio: 'ignore', timeout: 5000 });
         }
-        else if (os_1.default.platform() === 'linux') {
-            (0, child_process_1.execSync)(`notify-send "${title}" "${body}"`, { stdio: 'ignore' });
+        else if (platform === 'linux') {
+            (0, child_process_1.execSync)(`notify-send "${title}" "${body}"`, { stdio: 'ignore', timeout: 5000 });
+        }
+        else if (platform === 'win32') {
+            // UTF-16LE base64-encoded PowerShell to handle any special characters safely
+            const script = [
+                `Add-Type -AssemblyName System.Windows.Forms`,
+                `$n = New-Object System.Windows.Forms.NotifyIcon`,
+                `$n.Icon = [System.Drawing.SystemIcons]::Information`,
+                `$n.BalloonTipIcon = [System.Windows.Forms.ToolTipIcon]::Info`,
+                `$n.BalloonTipTitle = '${title.replace(/'/g, "''")}'`,
+                `$n.BalloonTipText  = '${body.replace(/'/g, "''")}'`,
+                `$n.Visible = $true`,
+                `$n.ShowBalloonTip(5000)`,
+                `Start-Sleep -Milliseconds 200`,
+            ].join('; ');
+            const encoded = Buffer.from(script, 'utf16le').toString('base64');
+            (0, child_process_1.execSync)(`powershell -NoProfile -NonInteractive -EncodedCommand ${encoded}`, { stdio: 'ignore', timeout: 8000 });
         }
     }
     catch {
-        // notification not available — already logged to console
+        // notification unavailable — silent fallback
     }
 }

package/dist/pattern-analyzer.d.ts

@@ -12,6 +12,7 @@
  *   - High cache ratio → positive: great cost efficiency
  *   - High avg cost    → consider Haiku for simpler tasks
  *   - Low efficiency   → linked to loops
+ *   - Write vs Edit    → suggest Edit for incremental changes
  */
 export type InsightLevel = 'tip' | 'warning' | 'positive';
 export interface PatternInsight {

package/dist/pattern-analyzer.js

@@ -13,6 +13,7 @@
  *   - High cache ratio → positive: great cost efficiency
  *   - High avg cost    → consider Haiku for simpler tasks
  *   - Low efficiency   → linked to loops
+ *   - Write vs Edit    → suggest Edit for incremental changes
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.analyzePatterns = analyzePatterns;
@@ -52,6 +53,18 @@ function analyzePatterns(toolCounts, stats) {
             metric: `${bashPct}% Bash (${bashCount}) vs ${readGrep} Read+Grep+Glob`,
         });
     }
+    // ── Heavy Write vs Edit ────────────────────────────────────────────────────
+    const writeCount = get('Write');
+    const editCount = get('Edit');
+    const writePct = Math.round(writeCount / totalTools * 100);
+    if (writeCount > editCount * 3 && writeCount >= 10) {
+        insights.push({
+            level: 'tip',
+            title: 'Heavy Write vs Edit usage',
+            description: 'More than 3× Write calls vs Edit calls. Editing existing files is cheaper in tokens than writing from scratch. Consider using Edit for incremental changes instead of rewriting entire files.',
+            metric: `${writePct}% Write (${writeCount} writes vs ${editCount} edits)`,
+        });
+    }
     // ── High loop rate ────────────────────────────────────────────────────────
     if (stats.avg_loops >= 1.5) {
         insights.push({

package/dist/quota-tracker.d.ts

@@ -38,6 +38,12 @@ export interface QuotaData {
     planSource: 'config' | 'keychain' | 'inferred';
     computedAt: number;
 }
+/**
+ * Llama a la API de Anthropic para obtener los % de quota exactos que muestra claude.ai.
+ * Actualiza apiCache si la llamada tiene éxito; de lo contrario, no hace nada (silent fallback).
+ * Debe llamarse periódicamente desde el daemon y al inicio del MCP server.
+ */
+export declare function refreshFromApi(): Promise<void>;
 /**
  * Calcula y retorna QuotaData.
  * Usa caché de 30s para no re-leer todos los JSONL en cada request del dashboard.

package/dist/quota-tracker.js

@@ -19,6 +19,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.refreshFromApi = refreshFromApi;
 exports.computeQuota = computeQuota;
 exports.invalidateQuotaCache = invalidateQuotaCache;
 const fs_1 = __importDefault(require("fs"));
@@ -35,33 +36,6 @@ const PLAN_LIMITS = {
 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);
@@ -210,6 +184,63 @@ function readAllEntries(sinceTs) {
     catch { /* PROJECTS_DIR inaccesible */ }
     return all;
 }
+// ─── API de uso de Anthropic (datos exactos = claude.ai/settings/usage) ──────
+const USAGE_API_URL = 'https://api.anthropic.com/api/oauth/usage';
+const USAGE_API_BETA = 'oauth-2025-04-20';
+const API_CACHE_TTL = 5 * 60000; // 5 minutes
+const API_DISK_CACHE = path_1.default.join((0, paths_1.getClaudestatDir)(), 'api-cache.json');
+let apiCache = null;
+/**
+ * Llama a la API de Anthropic para obtener los % de quota exactos que muestra claude.ai.
+ * Actualiza apiCache si la llamada tiene éxito; de lo contrario, no hace nada (silent fallback).
+ * Debe llamarse periódicamente desde el daemon y al inicio del MCP server.
+ */
+async function refreshFromApi() {
+    // Shared disk cache: all processes (daemon + MCP) read/write the same file.
+    // This ensures at most 1 API call per API_CACHE_TTL across all processes.
+    try {
+        const raw = fs_1.default.readFileSync(API_DISK_CACHE, 'utf8');
+        const disk = JSON.parse(raw);
+        if (disk && Date.now() - disk.ts < API_CACHE_TTL) {
+            apiCache = disk;
+            invalidateQuotaCache();
+            return;
+        }
+    }
+    catch { /* no disk cache yet — proceed to API */ }
+    const token = (0, claude_auth_1.getOAuthAccessToken)();
+    if (!token)
+        return;
+    try {
+        const ctrl = new AbortController();
+        const timer = setTimeout(() => ctrl.abort(), 3000);
+        const res = await fetch(USAGE_API_URL, {
+            headers: { Authorization: `Bearer ${token}`, 'anthropic-beta': USAGE_API_BETA },
+            signal: ctrl.signal,
+        });
+        clearTimeout(timer);
+        if (!res.ok) {
+            process.stderr.write(`[claudestat] API quota fetch failed: HTTP ${res.status}\n`);
+            return;
+        }
+        const data = await res.json();
+        const fh = data.five_hour;
+        if (fh == null)
+            return;
+        apiCache = {
+            cyclePct: Math.round(fh.utilization),
+            weeklyPctAll: data.seven_day != null ? Math.round(data.seven_day.utilization) : 0,
+            cycleResetAt: fh.resets_at ? new Date(fh.resets_at).getTime() : 0,
+            ts: Date.now(),
+        };
+        try {
+            fs_1.default.writeFileSync(API_DISK_CACHE, JSON.stringify(apiCache), 'utf8');
+        }
+        catch { }
+        invalidateQuotaCache();
+    }
+    catch { /* no network or keychain — silent fallback to JSONL */ }
+}
 // ─── Caché de 30 segundos ─────────────────────────────────────────────────────
 let cache = null;
 const CACHE_TTL = 30000; // 30 segundos
@@ -225,6 +256,16 @@ function computeQuota(forcePlan) {
     if (!forcePlan && cache && now - cache.ts < CACHE_TTL) {
         return cache.data;
     }
+    // Load API data from disk cache if in-memory is stale (shared across processes)
+    if (!apiCache || now - apiCache.ts >= API_CACHE_TTL) {
+        try {
+            const raw = fs_1.default.readFileSync(API_DISK_CACHE, 'utf8');
+            const disk = JSON.parse(raw);
+            if (disk && now - disk.ts < API_CACHE_TTL)
+                apiCache = disk;
+        }
+        catch { }
+    }
     const weekStart = getWeekStart(now);
     const thirtyMinAgo = now - 30 * 60 * 1000;
     // Leer entradas relevantes (última semana + un poco más para detección de plan)
@@ -251,7 +292,7 @@ function computeQuota(forcePlan) {
     const limits = PLAN_LIMITS[plan];
     // ─ Ciclo 5h: ventana deslizante [now-5h, now] ─
     const fiveHAgo = now - CYCLE_MS;
-    const cycleResetAt = computeResetAt(entries, now);
+    const cycleResetAt = (Math.floor(now / CYCLE_MS) + 1) * CYCLE_MS; // epoch-aligned, matches claude.ai
     const cycleStart = fiveHAgo; // inicio real de la ventana de conteo
     // Basado en tokens (como claude.ai/settings/usage)
     const cycleEntries = entries.filter(e => e.ts >= fiveHAgo);
@@ -297,14 +338,20 @@ function computeQuota(forcePlan) {
     const weeklyPctAll = limits.weeklyHoursSonnet + limits.weeklyHoursOpus > 0
         ? Math.min(100, Math.round((weeklyHoursSonnet + weeklyHoursOpus) / (limits.weeklyHoursSonnet + limits.weeklyHoursOpus) * 100))
         : 0;
+    // Override with API data if fresh — matches claude.ai exactly
+    const apiFresh = apiCache != null && Date.now() - apiCache.ts < API_CACHE_TTL;
+    const resolvedCyclePct = apiFresh ? apiCache.cyclePct : cyclePct;
+    const resolvedWeeklyPctAll = apiFresh ? apiCache.weeklyPctAll : weeklyPctAll;
+    const resolvedCycleResetAt = (apiFresh && apiCache.cycleResetAt > 0) ? apiCache.cycleResetAt : cycleResetAt;
+    const resolvedCycleResetMs = Math.max(0, resolvedCycleResetAt - now);
     const data = {
         cyclePrompts: cycleEntries.filter(e => e.type === 'human').length,
         cycleLimit: limits.prompts5h,
-        cyclePct,
+        cyclePct: resolvedCyclePct,
         cycleTokens,
         cycleLimitTokens: limits.tokens5h,
-        cycleResetMs,
-        cycleResetAt,
+        cycleResetMs: resolvedCycleResetMs,
+        cycleResetAt: resolvedCycleResetAt,
         cycleStartTs: cycleStart,
         weeklyHoursSonnet,
         weeklyHoursOpus,
@@ -314,7 +361,7 @@ function computeQuota(forcePlan) {
         weeklyTokensHaiku,
         weeklyLimitSonnet: limits.weeklyHoursSonnet,
         weeklyLimitOpus: limits.weeklyHoursOpus,
-        weeklyPctAll,
+        weeklyPctAll: resolvedWeeklyPctAll,
         burnRateTokensPerMin,
         detectedPlan: plan,
         planSource,