@statforge/claudestat 1.7.0 → 1.8.0

package/dist/install.js

@@ -23,6 +23,7 @@ const readline_1 = __importDefault(require("readline"));
 const child_process_1 = require("child_process");
 const paths_1 = require("./paths");
 const config_1 = require("./config");
+const doctor_1 = require("./doctor");
 const CLAUDESTAT_DIR = (0, paths_1.getClaudestatDir)();
 const CLAUDE_SETTINGS = path_1.default.join((0, paths_1.getClaudeDir)(), 'settings.json');
 const HOOKS_DIR = path_1.default.join(CLAUDESTAT_DIR, 'hooks');
@@ -143,9 +144,29 @@ async function runWizard() {
             plan = planMap[input.trim()] ?? 'pro';
         }
         console.log(`✓ Plan: ${plan}`);
+        // Paso 3b: puerto
+        let port = 7337;
+        if (!nonInteractive) {
+            const portInput = await new Promise(resolve => rl.question(`Port for daemon [default: 7337]: `, resolve));
+            const parsed = parseInt(portInput.trim(), 10);
+            if (!isNaN(parsed) && parsed >= 1024 && parsed <= 65535) {
+                port = parsed;
+            }
+        }
+        console.log(`✓ Port: ${port}`);
+        // Paso 3c: kill-switch threshold
+        let threshold = 95;
+        if (!nonInteractive) {
+            const tInput = await new Promise(resolve => rl.question(`Quota threshold for kill-switch warning [default: 95%]: `, resolve));
+            const parsed = parseInt(tInput.trim(), 10);
+            if (!isNaN(parsed) && parsed >= 50 && parsed <= 100) {
+                threshold = parsed;
+            }
+        }
+        console.log(`✓ Kill-switch threshold: ${threshold}%`);
         // Paso 4: crear config inicial
         const cfg = (0, config_1.readConfig)();
-        (0, config_1.writeConfig)({ ...cfg, plan: plan });
+        (0, config_1.writeConfig)({ ...cfg, plan: plan, port, killSwitchThreshold: threshold });
         console.log(`✓ Config created → ${CONFIG_PATH}\n`);
     }
     finally {
@@ -155,6 +176,12 @@ async function runWizard() {
     installHooks();
     // Paso 6: registrar MCP server en Claude Code
     installMcp();
+    // Paso final: doctor
+    console.log('\n🩺 Running doctor to verify installation...\n');
+    try {
+        await (0, doctor_1.runDoctor)();
+    }
+    catch { }
 }
 function installMcp() {
     const nodeExec = process.execPath;

package/dist/intelligence.d.ts

@@ -11,6 +11,12 @@ export interface LoopAlert {
     count: number;
     windowMs: number;
     ts: number;
+    context: LoopContext;
+}
+export interface LoopContext {
+    repeatedFiles: string[];
+    repeatedCommands: string[];
+    estimatedCostUsd: number;
 }
 export interface IntelligenceReport {
     loops: LoopAlert[];
@@ -22,12 +28,13 @@ export interface IntelligenceReport {
     seqCycleCount: number;
 }
 /**
- * Detecta loops: cuando el mismo tool se llama ≥ LOOP_THRESHOLD veces
- * dentro de LOOP_WINDOW_MS. Evita alertas duplicadas con LOOP_COOLDOWN_MS.
+ * Detecta loops: cuando el mismo tool se llama ≥ threshold veces
+ * dentro de windowMs. Evita alertas duplicadas con COOLDOWN_MS = windowMs.
  *
  * Algoritmo: ventana deslizante sobre eventos ordenados por timestamp.
+ * Captura contexto (archivos repetidos, comandos Bash repetidos) para cada alerta.
  */
-export declare function detectLoops(events: EventRow[]): LoopAlert[];
+export declare function detectLoops(events: EventRow[], threshold?: number, windowMs?: number): LoopAlert[];
 /**
  * Calcula un score de 0-100 basado en:
  * - Loops detectados     → -10 por loop, cap -25
@@ -96,5 +103,5 @@ export declare function predictSaturation(samples: Array<{
 /**
  * Genera el reporte completo de inteligencia para una sesión.
  */
-export declare function analyzeSession(events: EventRow[], costUsd: number): IntelligenceReport;
+export declare function analyzeSession(events: EventRow[], costUsd: number, threshold?: number, windowMs?: number): IntelligenceReport;
 export {};

package/dist/intelligence.js

@@ -17,35 +17,62 @@ exports.analyzeSemanticLoops = analyzeSemanticLoops;
 exports.predictSaturation = predictSaturation;
 exports.analyzeSession = analyzeSession;
 // ─── Detección de loops ───────────────────────────────────────────────────────
-const LOOP_THRESHOLD = 8; // calls para considerar loop
-const LOOP_WINDOW_MS = 120000; // ventana de tiempo: 2 minutos (antes 60s → demasiados falsos positivos en coding)
-const LOOP_COOLDOWN_MS = 120000; // cooldown entre alertas del mismo tool: 2 min (antes 15s → re-alertaba constantemente)
+const FILE_TOOLS = new Set(['Read', 'Write', 'Edit', 'Glob', 'Grep']);
 /**
- * Detecta loops: cuando el mismo tool se llama ≥ LOOP_THRESHOLD veces
- * dentro de LOOP_WINDOW_MS. Evita alertas duplicadas con LOOP_COOLDOWN_MS.
+ * Detecta loops: cuando el mismo tool se llama ≥ threshold veces
+ * dentro de windowMs. Evita alertas duplicadas con COOLDOWN_MS = windowMs.
  *
  * Algoritmo: ventana deslizante sobre eventos ordenados por timestamp.
+ * Captura contexto (archivos repetidos, comandos Bash repetidos) para cada alerta.
  */
-function detectLoops(events) {
+function detectLoops(events, threshold = 8, windowMs = 120000) {
+    const COOLDOWN_MS = windowMs; // cooldown = mismo tamaño que la ventana
     const alerts = [];
-    const windowsByTool = new Map(); // toolName → timestamps en ventana
+    const windowsByTool = new Map();
     for (const ev of events) {
-        // Solo contamos tool calls (PreToolUse o Done — uno de los dos)
         if (ev.type !== 'Done' && ev.type !== 'PreToolUse')
             continue;
         if (!ev.tool_name)
             continue;
         const toolName = ev.tool_name;
         const ts = ev.ts;
-        // Mantener solo los timestamps dentro de la ventana deslizante
-        const window = (windowsByTool.get(toolName) || []).filter(t => t >= ts - LOOP_WINDOW_MS);
+        const window = (windowsByTool.get(toolName) || []).filter(t => t >= ts - windowMs);
         window.push(ts);
         windowsByTool.set(toolName, window);
-        if (window.length >= LOOP_THRESHOLD) {
-            // Verificar cooldown: no alertar si ya alertamos recientemente para este tool
+        if (window.length >= threshold) {
             const lastAlert = [...alerts].reverse().find(a => a.toolName === toolName);
-            if (!lastAlert || ts - lastAlert.ts >= LOOP_COOLDOWN_MS) {
-                alerts.push({ toolName, count: window.length, windowMs: LOOP_WINDOW_MS, ts });
+            if (!lastAlert || ts - lastAlert.ts >= COOLDOWN_MS) {
+                const windowStart = ts - windowMs;
+                const loopEvents = events.filter(e => e.ts >= windowStart && e.ts <= ts && e.type === 'Done');
+                const repeatedFiles = new Set();
+                const repeatedCommands = new Set();
+                for (const le of loopEvents) {
+                    if (!le.tool_input)
+                        continue;
+                    try {
+                        const inp = JSON.parse(le.tool_input);
+                        if (FILE_TOOLS.has(le.tool_name ?? '')) {
+                            const fp = inp.file_path ?? inp.path ?? inp.pattern;
+                            if (typeof fp === 'string')
+                                repeatedFiles.add(fp);
+                        }
+                        if (le.tool_name === 'Bash' && typeof inp.command === 'string') {
+                            repeatedCommands.add(inp.command.slice(0, 80));
+                        }
+                    }
+                    catch { }
+                }
+                alerts.push({
+                    toolName,
+                    count: window.length,
+                    windowMs,
+                    ts,
+                    context: {
+                        repeatedFiles: [...repeatedFiles].slice(0, 10),
+                        repeatedCommands: [...repeatedCommands].slice(0, 5),
+                        estimatedCostUsd: 0,
+                    },
+                });
             }
         }
     }
@@ -85,7 +112,6 @@ function calcEfficiencyScore(events, loops, costUsd) {
     return Math.max(0, Math.min(100, score));
 }
 // ─── Semantic metrics ─────────────────────────────────────────────────────────
-const FILE_TOOLS = new Set(['Read', 'Write', 'Edit', 'Glob', 'Grep']);
 const ERROR_PATTERN = /error:|ENOENT|EACCES|EPERM|permission denied|failed|No such file/i;
 /**
  * Counts exact duplicate tool calls: same tool_name + same tool_input.
@@ -239,8 +265,8 @@ function predictSaturation(samples, contextWindow) {
 /**
  * Genera el reporte completo de inteligencia para una sesión.
  */
-function analyzeSession(events, costUsd) {
-    const loops = detectLoops(events);
+function analyzeSession(events, costUsd, threshold, windowMs) {
+    const loops = detectLoops(events, threshold, windowMs);
     const efficiencyScore = calcEfficiencyScore(events, loops, costUsd);
     const exactRetries = detectExactRetries(events);
     const errorRate = computeErrorRate(events);

package/dist/logger.d.ts

@@ -0,0 +1,6 @@
+export declare const logger: {
+    debug: (msg: string) => void;
+    info: (msg: string) => void;
+    warn: (msg: string) => void;
+    error: (msg: string) => void;
+};

package/dist/logger.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const fs_1 = __importDefault(require("fs"));
+const paths_1 = require("./paths");
+const config_1 = require("./config");
+const LEVEL_RANK = { debug: 0, info: 1, warn: 2, error: 3 };
+const MAX_SIZE_BYTES = 10 * 1024 * 1024;
+const MAX_FILES = 3;
+function rotate(logFile) {
+    for (let i = MAX_FILES - 2; i >= 0; i--) {
+        const src = i === 0 ? logFile : `${logFile}.${i}`;
+        const dst = `${logFile}.${i + 1}`;
+        try {
+            if (fs_1.default.existsSync(src))
+                fs_1.default.renameSync(src, dst);
+        }
+        catch { }
+    }
+}
+function write(level, message) {
+    try {
+        const cfg = (0, config_1.readConfig)();
+        const minRank = LEVEL_RANK[cfg.logLevel] ?? 1;
+        if ((LEVEL_RANK[level] ?? 0) < minRank)
+            return;
+        const logFile = (0, paths_1.getDaemonLogFile)();
+        fs_1.default.mkdirSync((0, paths_1.getClaudestatDir)(), { recursive: true });
+        try {
+            const stat = fs_1.default.statSync(logFile);
+            if (stat.size >= MAX_SIZE_BYTES)
+                rotate(logFile);
+        }
+        catch { }
+        const ts = new Date().toISOString();
+        const line = `${ts} [${level.toUpperCase()}] ${message}\n`;
+        fs_1.default.appendFileSync(logFile, line);
+    }
+    catch { }
+}
+exports.logger = {
+    debug: (msg) => write('debug', msg),
+    info: (msg) => write('info', msg),
+    warn: (msg) => write('warn', msg),
+    error: (msg) => write('error', msg),
+};

package/dist/notifier.d.ts

@@ -1 +1,16 @@
 export declare function sendDesktopNotification(title: string, body: string): void;
+export interface AlertPayload {
+    title: string;
+    body: string;
+    level: 'yellow' | 'orange' | 'red';
+    cyclePct: number;
+    weeklyPct?: number;
+    burnRate?: number;
+    resetInMins: number;
+}
+/**
+ * Sends an alert to a webhook URL (Slack, Discord, n8n, etc.).
+ * Payload format is compatible with Slack incoming webhooks and Discord webhooks.
+ * Fire-and-forget: errors are silently ignored.
+ */
+export declare function sendWebhookAlert(url: string, payload: AlertPayload): void;

package/dist/notifier.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sendDesktopNotification = sendDesktopNotification;
+exports.sendWebhookAlert = sendWebhookAlert;
 const child_process_1 = require("child_process");
 const os_1 = __importDefault(require("os"));
 function sendDesktopNotification(title, body) {
@@ -38,3 +39,28 @@ function sendDesktopNotification(title, body) {
         // notification unavailable — silent fallback
     }
 }
+/**
+ * Sends an alert to a webhook URL (Slack, Discord, n8n, etc.).
+ * Payload format is compatible with Slack incoming webhooks and Discord webhooks.
+ * Fire-and-forget: errors are silently ignored.
+ */
+function sendWebhookAlert(url, payload) {
+    const emoji = payload.level === 'red' ? '🔴' : payload.level === 'orange' ? '🟠' : '🟡';
+    const body = JSON.stringify({
+        text: `${emoji} *${payload.title}*\n${payload.body}`,
+        attachments: [{
+                color: payload.level === 'red' ? '#ff0000' : payload.level === 'orange' ? '#ff8800' : '#ffcc00',
+                fields: [
+                    { title: '5h cycle', value: `${payload.cyclePct}%`, short: true },
+                    { title: 'Resets in', value: `${payload.resetInMins}m`, short: true },
+                    ...(payload.burnRate ? [{ title: 'Burn rate', value: `${payload.burnRate.toLocaleString()} tok/min`, short: true }] : []),
+                ],
+            }],
+    });
+    fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body,
+        signal: AbortSignal.timeout(5000),
+    }).catch(() => { });
+}

package/dist/paths.d.ts

@@ -100,6 +100,24 @@ export declare function whichAllCmd(name: string): string;
  *   Windows: netstat -ano | findstr :<port>
  */
 export declare function portCheckCmd(port: number): string;
+/**
+ * Returns the port file path. The daemon writes the active port here on startup
+ * so the hook script (vanilla JS, no imports) can read it without parsing config.
+ */
+export declare function getPortFile(): string;
+/**
+ * Writes the active port to disk. Called by the daemon after successful bind.
+ */
+export declare function writePortFile(port: number): void;
+/**
+ * Returns the path of the pause signal file.
+ * When this file exists, the hook shows a warning instead of blocking.
+ */
+export declare function getPauseSignalFile(): string;
+/**
+ * Returns the daemon log file path.
+ */
+export declare function getDaemonLogFile(): string;
 /**
  * Returns true if running on Windows.
  */

package/dist/paths.js

@@ -31,6 +31,10 @@ exports.getOpencodeDb = getOpencodeDb;
 exports.whichCmd = whichCmd;
 exports.whichAllCmd = whichAllCmd;
 exports.portCheckCmd = portCheckCmd;
+exports.getPortFile = getPortFile;
+exports.writePortFile = writePortFile;
+exports.getPauseSignalFile = getPauseSignalFile;
+exports.getDaemonLogFile = getDaemonLogFile;
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
@@ -189,6 +193,36 @@ function portCheckCmd(port) {
         ? `netstat -ano | findstr :${port}`
         : `lsof -i :${port}`;
 }
+/**
+ * Returns the port file path. The daemon writes the active port here on startup
+ * so the hook script (vanilla JS, no imports) can read it without parsing config.
+ */
+function getPortFile() {
+    return path_1.default.join(getClaudestatDir(), 'port');
+}
+/**
+ * Writes the active port to disk. Called by the daemon after successful bind.
+ */
+function writePortFile(port) {
+    try {
+        fs_1.default.mkdirSync(getClaudestatDir(), { recursive: true });
+        fs_1.default.writeFileSync(getPortFile(), String(port));
+    }
+    catch { }
+}
+/**
+ * Returns the path of the pause signal file.
+ * When this file exists, the hook shows a warning instead of blocking.
+ */
+function getPauseSignalFile() {
+    return path_1.default.join(getClaudestatDir(), 'pause.signal');
+}
+/**
+ * Returns the daemon log file path.
+ */
+function getDaemonLogFile() {
+    return path_1.default.join(getClaudestatDir(), 'daemon.log');
+}
 /**
  * Returns true if running on Windows.
  */

package/dist/routes/helpers.d.ts

@@ -1,2 +1,7 @@
 /** Sube el árbol desde un file_path hasta encontrar HANDOFF.md → directorio del proyecto */
 export declare function findProjectCwdForFile(filePath: string): string | undefined;
+/**
+ * Returns the git root directory for the given directory, or undefined.
+ * Uses 'git rev-parse --show-toplevel' — fast and reliable.
+ */
+export declare function findGitRoot(fromDir: string): string | undefined;

package/dist/routes/helpers.js

@@ -4,8 +4,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.findProjectCwdForFile = findProjectCwdForFile;
+exports.findGitRoot = findGitRoot;
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
+const child_process_1 = require("child_process");
 /** Sube el árbol desde un file_path hasta encontrar HANDOFF.md → directorio del proyecto */
 function findProjectCwdForFile(filePath) {
     let dir = path_1.default.dirname(filePath);
@@ -17,5 +19,23 @@ function findProjectCwdForFile(filePath) {
             break;
         dir = parent;
     }
-    return undefined;
+    // Fallback: git root
+    return findGitRoot(path_1.default.dirname(filePath));
+}
+/**
+ * Returns the git root directory for the given directory, or undefined.
+ * Uses 'git rev-parse --show-toplevel' — fast and reliable.
+ */
+function findGitRoot(fromDir) {
+    try {
+        const root = (0, child_process_1.execSync)('git rev-parse --show-toplevel', {
+            cwd: fromDir,
+            stdio: 'pipe',
+            timeout: 2000,
+        }).toString().trim();
+        return root || undefined;
+    }
+    catch {
+        return undefined;
+    }
 }

package/dist/routes/misc.js

@@ -62,7 +62,8 @@ exports.miscRouter.get('/intelligence/:sessionId', (req, res) => {
         return;
     }
     const events = db_1.dbOps.getSessionEvents(sessionId);
-    const report = (0, intelligence_1.analyzeSession)(events, session.total_cost_usd ?? 0);
+    const cfg = (0, config_1.readConfig)();
+    const report = (0, intelligence_1.analyzeSession)(events, session.total_cost_usd ?? 0, cfg.loopThreshold, cfg.loopWindowSecs * 1000);
     res.json({ sessionId, ...report });
 });
 // ─── GET /quota — datos de cuota y burn rate ──────────────────────────────────
@@ -422,3 +423,20 @@ exports.miscRouter.post('/tool-status', (req, res) => {
     (0, stream_1.broadcast)({ type: 'tool_status_changed', payload: { tool, status, last_task: last_task ?? null, finished_at, session_id: session_id ?? null, waiting_for: waiting_for ?? null } });
     res.json({ ok: true });
 });
+// ─── GET /api/logs — últimos N líneas del daemon log ──────────────────────────
+exports.miscRouter.get('/api/logs', (req, res) => {
+    const n = Math.min(parseInt(req.query.n, 10) || 50, 500);
+    const logFile = (0, paths_1.getDaemonLogFile)();
+    try {
+        if (!fs_1.default.existsSync(logFile)) {
+            res.json({ lines: [] });
+            return;
+        }
+        const content = fs_1.default.readFileSync(logFile, 'utf8');
+        const lines = content.split('\n').filter(Boolean);
+        res.json({ lines: lines.slice(-n) });
+    }
+    catch {
+        res.json({ lines: [] });
+    }
+});

package/dist/routes/projects.js

@@ -13,6 +13,7 @@ const db_1 = require("../db");
 const projects_cache_1 = require("../cache/projects-cache");
 const pattern_analyzer_1 = require("../pattern-analyzer");
 const helpers_1 = require("./helpers");
+const config_1 = require("../config");
 exports.projectsRouter = (0, express_1.Router)();
 /** Infiere el proyecto activo mirando los eventos de archivo de una sesión */
 function inferProjectCwd(events) {
@@ -134,6 +135,7 @@ exports.projectsRouter.get('/projects', (_req, res) => {
         cliHoursMap.get(row.project_path)[row.source] = row.total_ms / 3600000;
     }
     // Attach pattern insights per project (only if DB has enough data)
+    const cfg = (0, config_1.readConfig)();
     const projects = [...projectMap.values()].map(p => {
         const toolCounts = db_1.dbOps.getProjectToolCounts(p.path);
         const sessionStats = db_1.dbOps.getProjectSessionStats(p.path);
@@ -141,7 +143,14 @@ exports.projectsRouter.get('/projects', (_req, res) => {
             ? (0, pattern_analyzer_1.analyzePatterns)(toolCounts, sessionStats)
             : [];
         const cli_hours = cliHoursMap.get(p.path);
-        return { ...p, insights, ...(cli_hours ? { cli_hours } : {}) };
+        const aliasName = cfg.projectAliases[p.path];
+        return {
+            ...p,
+            name: aliasName ?? p.name,
+            alias: aliasName ?? null,
+            insights,
+            ...(cli_hours ? { cli_hours } : {}),
+        };
     })
         .sort((a, b) => (b.last_active ?? 0) - (a.last_active ?? 0));
     res.json({ projects, active_project: activeProject });

package/dist/service.js

@@ -8,6 +8,14 @@ exports.uninstallService = uninstallService;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const child_process_1 = require("child_process");
+function buildEnvPath() {
+    const current = process.env.PATH ?? '/usr/local/bin:/usr/bin:/bin';
+    const nvmDir = process.env.NVM_DIR;
+    if (!nvmDir)
+        return current;
+    const nvmBin = path_1.default.join(nvmDir, 'versions', 'node', `v${process.versions.node}`, 'bin');
+    return current.includes(nvmBin) ? current : `${nvmBin}:${current}`;
+}
 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');
@@ -37,6 +45,8 @@ function makePlist() {
   <dict>
     <key>CLAUDESTAT_DAEMON</key>
     <string>1</string>
+    <key>PATH</key>
+    <string>${buildEnvPath()}</string>
   </dict>
   <key>StandardOutPath</key>
   <string>/tmp/claudestat-daemon.log</string>
@@ -56,6 +66,7 @@ ExecStart=${serviceCommand()} start
 Restart=on-failure
 RestartSec=5
 Environment=CLAUDESTAT_DAEMON=1
+Environment=PATH=${buildEnvPath()}
 
 [Install]
 WantedBy=default.target`;

package/hooks/event.js

@@ -14,8 +14,19 @@
  */
 
 const eventType = process.argv[2] || 'Unknown'
-const DAEMON_URL     = 'http://localhost:7337/event'
-const KILL_SWITCH_URL = 'http://localhost:7337/kill-switch'
+const fs = require('fs')
+const os = require('os')
+
+// Read port from ~/.claudestat/port (written by daemon on startup). Fallback: 7337.
+let DAEMON_PORT = 7337
+try {
+  const portFile = require('path').join(os.homedir(), '.claudestat', 'port')
+  const raw = fs.readFileSync(portFile, 'utf8').trim()
+  const parsed = parseInt(raw, 10)
+  if (!isNaN(parsed) && parsed >= 1024 && parsed <= 65535) DAEMON_PORT = parsed
+} catch {}
+
+const DAEMON_URL     = `http://localhost:${DAEMON_PORT}/event`
 
 let rawData = ''
 process.stdin.on('data', chunk => { rawData += chunk })
@@ -29,36 +40,43 @@ process.stdin.on('end', () => {
     ...hookData
   }
 
-  // Para PreToolUse: enviamos el evento Y consultamos el kill-switch en paralelo.
-  // Si el daemon bloquea, salimos con exit(2) para cancelar la acción.
+  // Para PreToolUse: enviamos el evento Y leemos el archivo de pausa local.
+  // Si existe pause.signal, mostramos warning y salimos según killSwitchForce.
   if (eventType === 'PreToolUse') {
-    Promise.all([
-      // 1. Registrar el evento (fire-and-forget, no nos importa el resultado)
-      fetch(DAEMON_URL, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(payload),
-        signal: AbortSignal.timeout(1500),
-      }).catch(() => null),
+    fetch(DAEMON_URL, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(1500),
+    }).catch(() => null)
+
+    // Check pause signal file (written by daemon when quota threshold reached)
+    const signalFile = require('path').join(os.homedir(), '.claudestat', 'pause.signal')
+    let signalMsg = null
+    try { signalMsg = fs.readFileSync(signalFile, 'utf8').trim() } catch {}
+
+    if (signalMsg) {
+      process.stderr.write(`\n⚠️  claudestat — quota warning\n`)
+      process.stderr.write(`   ${signalMsg}\n`)
 
-      // 2. Consultar el kill-switch con timeout corto para no retrasar a Claude
-      fetch(KILL_SWITCH_URL, {
-        signal: AbortSignal.timeout(1500),
-      })
-        .then(r => r.json())
-        .catch(() => ({ blocked: false })),  // daemon no disponible → fail-open
-    ])
-    .then(([_, ks]) => {
-      if (ks && ks.blocked) {
-        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`)
+      // Read config to check killSwitchForce
+      let forceBlock = false
+      try {
+        const cfgPath = require('path').join(os.homedir(), '.claudestat', 'config.json')
+        const cfg = JSON.parse(fs.readFileSync(cfgPath, 'utf8'))
+        forceBlock = cfg.killSwitchForce === true
+      } catch {}
+
+      if (forceBlock) {
+        process.stderr.write(`   Blocked (killSwitchForce is enabled). Run: claudestat resume\n\n`)
         process.exit(2)
       } else {
+        process.stderr.write(`   Continuing. To pause manually: claudestat resume (removes signal)\n\n`)
         process.exit(0)
       }
-    })
-    .catch(() => process.exit(0))  // cualquier error → no bloquear
+    } else {
+      process.exit(0)
+    }
 
   } else {
     // Para todos los demás tipos (SessionStart, PostToolUse, Stop):

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statforge/claudestat",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "private": false,
   "publishConfig": {
     "access": "public"