@statforge/claudestat 1.2.3 → 1.4.0

package/README.md

@@ -2,9 +2,11 @@
 
 # claudestat
 
-**Real-time execution trace and cost intelligence for Claude Code**
+**Live Claude Code monitor — real-time trace, quota guard, and MCP server**
+
+Most tools read your logs after a session ends. claudestat hooks into every event as it fires.
+See what Claude is spending right now, get alerted before you hit your quota, and ask Claude about its own usage — from inside the terminal.
 
-Hook into every tool call, token, and dollar — as it happens.
 Works with Claude Pro, Max 5, and Max 20. Zero cloud dependencies. Pure Node.js. Runs on macOS, Linux, and Windows.
 
 [![npm version](https://img.shields.io/npm/v/@statforge/claudestat?color=blue)](https://www.npmjs.com/package/@statforge/claudestat)
@@ -17,7 +19,7 @@ Works with Claude Pro, Max 5, and Max 20. Zero cloud dependencies. Pure Node.js.
 
 [Installation](#installation) • [Quick Start](#quick-start) • [Commands](#commands) • [Dashboard](#dashboard) • [Contributing](#contributing)
 
-![ClaudeStat dashboard](https://res.cloudinary.com/dgscloudinary/image/upload/v1778225605/My%20portfolio%7D/ClaudeStat_vnfmup.png)
+![ClaudeStat banner](https://raw.githubusercontent.com/DeibyGS/claudestat/main/assets/banner.png)
 
 ---
 
@@ -31,26 +33,57 @@ Works with Claude Pro, Max 5, and Max 20. Zero cloud dependencies. Pure Node.js.
 
 ---
 
-## Why?
+## Why claudestat?
+
+Tools like ccusage are great for reviewing history. claudestat is for while you're coding.
 
-You're burning tokens right now and you have no idea how many, on what, or whether Claude is stuck in a loop.
+It taps into Claude Code's hook system to capture every event the moment it fires, stores everything locally in SQLite, and gives you a live dashboard, quota alerts, and an MCP server — not just a report.
 
-Claude Code is powerful — but it's a black box while it runs. You can't see what it's spending, how deep the context is, whether it's looping, or if you're about to hit your quota limit.
+| | claudestat | ccusage |
+|---|:---:|:---:|
+| Real-time event stream | ✅ | ❌ |
+| Live terminal trace (`watch`) | ✅ | ❌ |
+| Web dashboard | ✅ | ❌ |
+| Quota alerts + kill switch | ✅ | ❌ |
+| Loop detector | ✅ | ❌ |
+| MCP server (ask Claude about itself) | ✅ | ❌ |
+| Historical usage analysis | ✅ | ✅ |
 
-**claudestat fixes that.** It taps into Claude Code's hook system to capture every event, stores it locally in SQLite, and shows you everything in a live dashboard or terminal trace.
+**What you get:**
 
-- Live tool trace with duration and token cost per call
-- Quota guard with configurable kill switch (block new sessions at X%)
-- Pattern analyzer: detects loops, Bash overuse, low cache reuse, and more
-- Per-session cost breakdown + cache savings + burn rate
-- Weekly usage insights with actionable tips
-- AI-generated weekly usage reports
-- MCP server: query quota, sessions, and tools from within Claude Code
+- Live tool trace — every call with duration and token cost as it runs
+- Quota guard — alerts at 70%, 85%, 95%; optional kill switch blocks new sessions at X%
+- Loop detector — flags context thrashing with estimated waste cost
+- Top tools — know which tools eat most of your budget
+- Web dashboard — session history, analytics, model breakdown, charts
+- MCP server — 7 tools so Claude can answer questions about its own usage
+- Weekly insights — pattern analysis with actionable tips
 
 > If claudestat is useful, give it a ⭐ — it helps other developers find it.
 
 ---
 
+## Ask Claude about itself
+
+claudestat ships an MCP server. Once registered, you can ask Claude Code questions about its own usage — without leaving the terminal.
+
+```bash
+claude mcp add claudestat -s user -- claudestat-mcp
+```
+
+Then just ask:
+
+```
+> What's my current quota status?
+> How much did I spend this week?
+> What are my top 5 tools by cost?
+> Break down my usage by model
+```
+
+Claude reads your local SQLite data through the MCP server and answers in real time. No cloud, no API key, no extra setup. [Full MCP reference →](#mcp-server)
+
+---
+
 ## How it works
 
 ```
@@ -85,40 +118,43 @@ Claude Code event
 ## Installation
 
 ```bash
-npm install -g @statforge/claudestat
+npm install -g @statforge/claudestat && claudestat setup
 ```
 
+`claudestat setup` installs the Claude Code hooks and registers the daemon as a system service (launchd on macOS, systemd on Linux) — no sudo required. The daemon starts automatically whenever you log in.
+
 > **Using NVM?** Make sure you're on your default Node version before installing to avoid stale binary conflicts:
 > ```bash
 > nvm use default && npm install -g @statforge/claudestat
+> claudestat setup
 > ```
 > Works with [nvm](https://github.com/nvm-sh/nvm) (macOS/Linux) and [nvm-windows](https://github.com/coreybutler/nvm-windows).
 
-Then wire up the hooks into Claude Code:
+> Restart Claude Code after setup so the hooks take effect.
 
-```bash
-claudestat install
-```
+### Manual setup (alternative)
 
-This modifies `~/.claude/settings.json` to add `SessionStart`, `PreToolUse`, `PostToolUse`, and `Stop` hooks. A backup is created before any change.
+If you prefer to manage the daemon yourself:
 
-> Restart Claude Code after installing so the hooks take effect.
+```bash
+npm install -g @statforge/claudestat
+claudestat install   # installs hooks into Claude Code
+claudestat start     # start the daemon manually
+```
 
 ---
 
 ## Quick Start
 
 ```bash
-# 1. Start the background daemon
-claudestat start
+# 1. Install and set up everything in one command
+npm install -g @statforge/claudestat && claudestat setup
 
 # 2. Open the dashboard in your browser
 #    macOS:
 open http://localhost:7337
-#    Windows:
-start http://localhost:7337
-#    Linux:
-xdg-open http://localhost:7337
+#    Windows / Linux:
+claudestat start   # start daemon manually, then open http://localhost:7337
 
 # 3. Or watch a live terminal trace
 claudestat watch
@@ -132,7 +168,9 @@ That's it. Start a Claude Code session and watch the events flow in.
 
 | Command | Description |
 |---|---|
-| `claudestat start` | Start the background daemon |
+| `claudestat setup` | One-command setup: install hooks + register daemon as system service |
+| `claudestat setup --uninstall` | Remove hooks and system service |
+| `claudestat start` | Start the background daemon manually |
 | `claudestat stop` | Stop the daemon |
 | `claudestat restart` | Restart the daemon |
 | `claudestat install` | Install hooks into Claude Code |
@@ -399,8 +437,9 @@ claudestat doctor
   ✓  Daemon running (localhost:7337)
   ✓  Global CLI symlink valid
   ✓  No duplicate claudestat binaries in PATH
-  ✓  Version match (installed: v1.2.2)
+  ✓  Version match (installed: v1.3.0)
   ✓  NVM prefix matches active binary
+  ✓  MCP server registered in Claude Code
 ──────────────────────────────────────────────
   All checks passed — claudestat is healthy!
 ```
@@ -416,11 +455,11 @@ Shows the current version and checks npm for updates.
 ```bash
 claudestat version
 
-1.2.2
+1.3.0
   latest ✓
 ```
 
-If a newer version is available, it shows: `latest: 1.3.0 — run npm update`.
+If a newer version is available, it shows: `latest: 1.4.0 — run npm update`.
 
 ### `claudestat export`
 
@@ -478,7 +517,9 @@ Once registered, ask Claude things like:
 - *"Give me usage insights for the last 14 days"*
 - *"Break down my usage by model"*
 
-Zero extra dependencies — stdio JSON-RPC, works without the daemon running. Uses on-demand API refresh with shared disk cache for accurate quota data.
+![claudestat MCP demo](https://raw.githubusercontent.com/DeibyGS/claudestat/main/assets/mcp-demo.gif)
+
+Zero extra dependencies — stdio JSON-RPC. Works without the daemon running (reads SQLite directly), but will warn you to start it if it's not active: `claudestat start`. Uses on-demand API refresh with shared disk cache for accurate quota data.
 
 ---
 
@@ -613,15 +654,19 @@ Have an idea? [Open an issue](https://github.com/DeibyGS/claudestat/issues) or s
 ## Uninstall
 
 ```bash
-claudestat uninstall        # removes hooks from Claude Code settings
+# Full uninstall (hooks + system service + daemon):
+claudestat setup --uninstall
 
+# Then remove the data directory:
 # macOS / Linux:
-rm -rf ~/.claudestat        # removes DB, config, and PID file
+rm -rf ~/.claudestat
 
 # Windows (PowerShell):
 Remove-Item -Recurse -Force "$env:USERPROFILE\.claudestat"
 ```
 
+> If you installed manually (without `setup`), use `claudestat uninstall` to remove only the hooks.
+
 ---
 
 ## Contributing
@@ -673,12 +718,11 @@ Want to appear here? Pick a [good-first-issue](https://github.com/DeibyGS/claude
 
 ## FAQ
 
-**What is claudestat?**
-claudestat is a real-time token monitoring and cost analytics tool for Claude Code.
-It captures every tool call, token usage, and API cost as it happens — locally, with zero cloud dependencies.
+**What is claudestat? How is it different from ccusage?**
+claudestat is a real-time monitor for Claude Code — not a log reader. It hooks into every tool call as it fires, tracks token usage and cost live, guards your quota with configurable alerts, and exposes an MCP server so Claude can answer questions about its own usage. ccusage reads JSONL history after sessions end; claudestat runs while you code.
 
 **How do I monitor Claude Code token usage?**
-Install with `npm install -g @statforge/claudestat`, run `claudestat start`, and open `http://localhost:7337` for the live dashboard.
+Install with `npm install -g @statforge/claudestat && claudestat setup`, then open `http://localhost:7337` for the live dashboard. The daemon starts automatically on login after setup.
 
 **How do I track Claude Code costs?**
 claudestat records every session's token usage and estimates API cost per tool call.

package/dist/config.d.ts

@@ -25,6 +25,7 @@ export interface ClaudestatConfig {
     warnThresholds: number[];
     weeklyWarnThresholds: number[];
     resetReminderMins: number;
+    sessionCostLimitUsd: number;
     plan: ClaudePlan | null;
     reportsEnabled: boolean;
     reportFrequency: ReportFrequency;

package/dist/config.js

@@ -36,6 +36,7 @@ const DEFAULTS = {
     warnThresholds: [70, 85, 95],
     weeklyWarnThresholds: [50, 75, 90],
     resetReminderMins: 10,
+    sessionCostLimitUsd: 0,
     plan: null,
     reportsEnabled: false,
     reportFrequency: 'weekly',
@@ -92,6 +93,11 @@ function validateConfig(raw) {
         if (typeof v !== 'number' || isNaN(v) || v < 0 || v > 60)
             return 'resetReminderMins must be a number between 0 and 60';
     }
+    if ('sessionCostLimitUsd' in cfg) {
+        const v = cfg.sessionCostLimitUsd;
+        if (typeof v !== 'number' || isNaN(v) || v < 0)
+            return 'sessionCostLimitUsd debe ser un número >= 0 (0 = desactivado)';
+    }
     if ('alertsEnabled' in cfg && typeof cfg.alertsEnabled !== 'boolean')
         return 'alertsEnabled debe ser boolean';
     if ('reportsEnabled' in cfg && typeof cfg.reportsEnabled !== 'boolean')

package/dist/index.js

@@ -24,6 +24,7 @@ const daemon_1 = require("./daemon");
 const watchdog_1 = require("./watchdog");
 const watch_1 = require("./watch");
 const install_1 = require("./install");
+const service_1 = require("./service");
 const export_1 = require("./export");
 const config_1 = require("./config");
 const doctor_1 = require("./doctor");
@@ -186,14 +187,43 @@ program
     console.error('\n❌ Error:', err.message);
     process.exit(1);
 }));
+program
+    .command('setup')
+    .description('One-command setup: install hooks + register daemon as system service (auto-starts on login)')
+    .option('--uninstall', 'Remove hooks and system service')
+    .action(async (opts) => {
+    if (opts.uninstall) {
+        console.log('Uninstalling claudestat...');
+        (0, service_1.uninstallService)();
+        (0, install_1.uninstallHooks)();
+        await stopDaemon().catch(() => { });
+        console.log('✅ claudestat fully removed');
+        process.exit(0);
+    }
+    // 1. Wizard: Node check + plan + config + hooks + MCP
+    await (0, install_1.runWizard)();
+    // 2. Start daemon now
+    const daemonRunning = await fetch('http://localhost:7337/health', {
+        signal: AbortSignal.timeout(2000),
+    }).then(r => r.ok).catch(() => false);
+    if (!daemonRunning) {
+        spawnDaemon();
+    }
+    else {
+        console.log('✅ Daemon already running');
+        console.log('   Dashboard → http://localhost:7337');
+    }
+    console.log('\n   Run \x1b[36mclaudestat watch\x1b[0m to see live activity');
+    process.exit(0);
+});
 program
     .command('install')
     .description('Install hooks into Claude Code settings')
-    .action(install_1.runInstall);
+    .action(async () => { await (0, install_1.runInstall)(); process.exit(0); });
 program
     .command('uninstall')
     .description('Remove hooks from Claude Code')
-    .action(install_1.uninstallHooks);
+    .action(() => { (0, install_1.uninstallHooks)(); process.exit(0); });
 program
     .command('export [format]')
     .description('Export session data (json | csv, default: json). Max 500 sessions.')
@@ -294,6 +324,7 @@ program
     .option('--threshold <number>', 'Quota percentage to trigger the kill switch (default: 95)')
     .option('--plan <plan>', 'Force plan detection: pro|max5|max20|auto')
     .option('--alerts <bool>', 'Enable/disable daemon rate limit alerts: true|false')
+    .option('--session-limit <usd>', 'Alert when a session exceeds this cost in USD (0 = disabled)')
     .action((opts) => {
     const cfg = (0, config_1.readConfig)();
     let changed = false;
@@ -323,6 +354,15 @@ program
         cfg.alertsEnabled = opts.alerts === 'true';
         changed = true;
     }
+    if (opts.sessionLimit !== undefined) {
+        const v = parseFloat(opts.sessionLimit);
+        if (!isNaN(v) && v >= 0) {
+            cfg.sessionCostLimitUsd = v;
+            changed = true;
+        }
+        else
+            console.warn('  ⚠️  session-limit must be a number >= 0 (e.g. 5 for $5)');
+    }
     if (changed) {
         (0, config_1.writeConfig)(cfg);
         console.log('✅ Config saved to ~/.claudestat/config.json');
@@ -352,6 +392,7 @@ program
     if (cfg.killSwitchEnabled) {
         lines.push(`                    ${bar(cfg.killSwitchThreshold)}`);
     }
+    lines.push(`  Session limit     ${cfg.sessionCostLimitUsd > 0 ? `${Y}$${cfg.sessionCostLimitUsd.toFixed(2)}${R}` : `${D}OFF${R}`}`);
     lines.push('');
     lines.push(`  Cycle thresholds  ${cfg.warnThresholds.join('%, ')}%`);
     lines.push(`                    ${D}yellow${R} ${bar(cfg.warnThresholds[0], 8)}  ${D}orange${R} ${bar(cfg.warnThresholds[1], 8)}  ${D}red${R} ${bar(cfg.warnThresholds[2], 8)}`);

package/dist/mcp-server.js

@@ -40,6 +40,9 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 process.on('warning', (w) => {
     if (w.name === 'ExperimentalWarning' && w.message.includes('SQLite'))
@@ -47,10 +50,27 @@ process.on('warning', (w) => {
     process.stderr.write(`${w.name}: ${w.message}\n`);
 });
 const readline = __importStar(require("readline"));
+const fs_1 = __importDefault(require("fs"));
 const db_1 = require("./db");
 const quota_tracker_1 = require("./quota-tracker");
 const insights_1 = require("./insights");
 const config_1 = require("./config");
+const paths_1 = require("./paths");
+function isDaemonRunning() {
+    try {
+        const pid = parseInt(fs_1.default.readFileSync((0, paths_1.getPidFile)(), 'utf8').trim(), 10);
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const DAEMON_WARNING = `⚠️ claudestat daemon is not running — real-time monitoring is disabled.
+Start it with: claudestat start
+
+Data shown below is from the last recorded session.
+---`;
 const SERVER_NAME = 'claudestat';
 const SERVER_VERSION = '1.2.2';
 const PROTOCOL_VERSION = '2025-03-26';
@@ -364,17 +384,18 @@ function toolGetWeeklyInsight(days) {
     ].join('\n');
 }
 async function handleToolCall(name, args) {
+    const warning = isDaemonRunning() ? '' : DAEMON_WARNING + '\n';
     const sortBy = typeof args.sort_by === 'string' ? args.sort_by : 'cost';
     switch (name) {
         case 'get_quota_status':
             await (0, quota_tracker_1.refreshFromApi)();
-            return toolGetQuotaStatus();
-        case 'get_current_session': return toolGetCurrentSession();
-        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);
+            return warning + toolGetQuotaStatus();
+        case 'get_current_session': return warning + toolGetCurrentSession();
+        case 'get_session_stats': return warning + toolGetSessionStats(typeof args.days === 'number' ? args.days : 7);
+        case 'get_top_tools': return warning + toolGetTopTools(typeof args.days === 'number' ? args.days : 30, sortBy);
+        case 'get_usage_insights': return warning + toolGetUsageInsights(typeof args.days === 'number' ? args.days : 7);
+        case 'get_model_breakdown': return warning + toolGetModelBreakdown(typeof args.days === 'number' ? args.days : 7);
+        case 'get_weekly_insight': return warning + toolGetWeeklyInsight(typeof args.days === 'number' ? args.days : 7);
         default: return `Unknown tool: ${name}`;
     }
 }

package/dist/routes/events.js

@@ -17,8 +17,14 @@ 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 notifier_1 = require("../notifier");
 const enricher_1 = require("../enricher");
 Object.defineProperty(exports, "processLatestForSession", { enumerable: true, get: function () { return enricher_1.processLatestForSession; } });
+// ─── Loop alert cooldown (toolName:sessionId → last alert ts) ─────────────────
+const loopAlertCooldown = new Map();
+const LOOP_ALERT_COOLDOWN_MS = 120000; // coincide con LOOP_COOLDOWN_MS en intelligence.ts
+// ─── Session cost alert: sesiones que ya recibieron notificación ───────────────
+const sessionCostAlertFired = new Set();
 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.
@@ -248,6 +254,24 @@ const onCostUpdate = (sessionId, cost) => {
             projected_hourly_usd: projectedHourlyUsd,
         }
     });
+    // ─── Session cost alert: notificar si la sesión supera el límite configurado ──
+    const cfg = (0, config_1.readConfig)();
+    if (cfg.alertsEnabled && cfg.sessionCostLimitUsd > 0 && cost.cost_usd >= cfg.sessionCostLimitUsd && !sessionCostAlertFired.has(sessionId)) {
+        sessionCostAlertFired.add(sessionId);
+        (0, notifier_1.sendDesktopNotification)('claudestat — Session cost limit reached', `Session cost: $${cost.cost_usd.toFixed(2)} — limit $${cfg.sessionCostLimitUsd.toFixed(2)} reached`);
+    }
+    // ─── Loop alert: notificación de escritorio si hay loops activos ─────────────
+    if (cfg.alertsEnabled && report.loops.length > 0) {
+        const now = Date.now();
+        for (const loop of report.loops) {
+            const key = `${loop.toolName}:${sessionId}`;
+            const lastSent = loopAlertCooldown.get(key) ?? 0;
+            if (now - lastSent >= LOOP_ALERT_COOLDOWN_MS) {
+                loopAlertCooldown.set(key, now);
+                (0, notifier_1.sendDesktopNotification)('claudestat — Loop detected', `${loop.toolName} called ${loop.count}× in 2min — session may be stuck`);
+            }
+        }
+    }
     // Emitir desglose de costo del último bloque (input vs output) para el TracePanel
     if (cost.lastEntry) {
         (0, stream_1.broadcast)({

package/dist/routes/misc.js

@@ -90,7 +90,7 @@ exports.miscRouter.get('/kill-switch', (_req, res) => {
         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)}.`
+            ? `Quota at ${data.cyclePct}% — kill switch threshold is ${cfg.killSwitchThreshold}%. Resets in ${formatMs(data.cycleResetMs)}.`
             : undefined;
         res.json({ blocked, reason, cyclePct: data.cyclePct });
     }

package/dist/service.d.ts

@@ -0,0 +1,2 @@
+export declare function installService(): void;
+export declare function uninstallService(): void;

package/dist/service.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installService = installService;
+exports.uninstallService = uninstallService;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const PLIST_LABEL = 'com.statforge.claudestat';
+const PLIST_PATH = path_1.default.join(process.env.HOME ?? '~', 'Library', 'LaunchAgents', `${PLIST_LABEL}.plist`);
+const SYSTEMD_DIR = path_1.default.join(process.env.HOME ?? '~', '.config', 'systemd', 'user');
+const SYSTEMD_PATH = path_1.default.join(SYSTEMD_DIR, 'claudestat.service');
+function makePlist() {
+    const node = process.execPath;
+    const script = process.argv[1];
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${PLIST_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${node}</string>
+    <string>${script}</string>
+    <string>start</string>
+  </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>CLAUDESTAT_DAEMON</key>
+    <string>1</string>
+  </dict>
+  <key>StandardOutPath</key>
+  <string>/tmp/claudestat-daemon.log</string>
+  <key>StandardErrorPath</key>
+  <string>/tmp/claudestat-daemon.err</string>
+</dict>
+</plist>`;
+}
+function makeUnit() {
+    const node = process.execPath;
+    const script = process.argv[1];
+    return `[Unit]
+Description=ClaudeStat daemon — real-time Claude Code monitor
+After=default.target
+
+[Service]
+Type=simple
+ExecStart=${node} ${script} start
+Restart=on-failure
+RestartSec=5
+Environment=CLAUDESTAT_DAEMON=1
+
+[Install]
+WantedBy=default.target`;
+}
+function installService() {
+    if (process.platform === 'darwin') {
+        fs_1.default.mkdirSync(path_1.default.dirname(PLIST_PATH), { recursive: true });
+        try {
+            (0, child_process_1.execSync)(`launchctl unload "${PLIST_PATH}" 2>/dev/null`, { stdio: 'ignore' });
+        }
+        catch { }
+        fs_1.default.writeFileSync(PLIST_PATH, makePlist());
+        (0, child_process_1.execSync)(`launchctl load "${PLIST_PATH}"`);
+        console.log(`   service  → ${PLIST_PATH}`);
+        console.log(`   node     → ${process.execPath}`);
+    }
+    else if (process.platform === 'linux') {
+        const hasSystemd = (() => {
+            try {
+                (0, child_process_1.execSync)('which systemctl', { stdio: 'pipe' });
+                return true;
+            }
+            catch {
+                return false;
+            }
+        })();
+        if (!hasSystemd) {
+            console.log('   systemd not found — run `claudestat start` manually to start the daemon');
+            return;
+        }
+        fs_1.default.mkdirSync(SYSTEMD_DIR, { recursive: true });
+        fs_1.default.writeFileSync(SYSTEMD_PATH, makeUnit());
+        (0, child_process_1.execSync)('systemctl --user daemon-reload');
+        (0, child_process_1.execSync)('systemctl --user enable --now claudestat');
+        console.log(`   service  → ${SYSTEMD_PATH}`);
+        console.log(`   node     → ${process.execPath}`);
+    }
+    else {
+        console.log('   Auto-start on Windows coming soon. Run `claudestat start` manually.');
+    }
+}
+function uninstallService() {
+    if (process.platform === 'darwin') {
+        try {
+            (0, child_process_1.execSync)(`launchctl unload "${PLIST_PATH}" 2>/dev/null`, { stdio: 'ignore' });
+        }
+        catch { }
+        try {
+            fs_1.default.unlinkSync(PLIST_PATH);
+            console.log(`   removed  → ${PLIST_PATH}`);
+        }
+        catch {
+            console.log('   service file not found (already removed)');
+        }
+    }
+    else if (process.platform === 'linux') {
+        try {
+            (0, child_process_1.execSync)('systemctl --user disable --now claudestat 2>/dev/null', { stdio: 'ignore' });
+        }
+        catch { }
+        try {
+            fs_1.default.unlinkSync(SYSTEMD_PATH);
+            (0, child_process_1.execSync)('systemctl --user daemon-reload');
+            console.log(`   removed  → ${SYSTEMD_PATH}`);
+        }
+        catch {
+            console.log('   service file not found (already removed)');
+        }
+    }
+}

package/hooks/event.js

@@ -46,18 +46,13 @@ process.stdin.on('end', () => {
         signal: AbortSignal.timeout(1500),
       })
         .then(r => r.json())
-        .catch(() => {
-          // Si el daemon no responde, loggeamos en stderr (visible en logs de Claude)
-          // pero NO bloqueamos — un fallo del daemon no debe interrumpir el trabajo
-          process.stderr.write(`[claudetrace] daemon no disponible — kill-switch desactivado\n`)
-          return { blocked: false }
-        }),
+        .catch(() => ({ blocked: false })),  // daemon no disponible → fail-open
     ])
     .then(([_, ks]) => {
       if (ks && ks.blocked) {
-        // Claude Code muestra este stderr al usuario antes de cancelar la acción
-        process.stderr.write(`\n🚫 claudetrace kill switch activado\n`)
-        process.stderr.write(`   ${ks.reason ?? 'Cuota de uso superada.'}\n\n`)
+        process.stderr.write(`\n🚫 claudestat — kill switch active\n`)
+        process.stderr.write(`   ${ks.reason ?? 'Usage quota exceeded.'}\n`)
+        process.stderr.write(`   To disable: claudestat config --kill-switch false\n\n`)
         process.exit(2)
       } else {
         process.exit(0)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statforge/claudestat",
-  "version": "1.2.3",
+  "version": "1.4.0",
   "description": "Observability layer for Claude Code — live token tracking, cost analytics, quota guard, loop detection, and usage dashboard. The htop for Claude Code.",
   "keywords": [
     "claude-code",