@statforge/claudestat 1.6.1 → 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,19 +11,30 @@ 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[];
     efficiencyScore: number;
     summary: string;
+    exactRetries: number;
+    errorRate: number;
+    fileChurnScore: number;
+    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
@@ -39,7 +50,58 @@ export declare function detectLoops(events: EventRow[]): LoopAlert[];
  *   20 tools, 0 loops, $0.30  → 100 - 0  - 0 - 0   = 100
  */
 export declare function calcEfficiencyScore(events: EventRow[], loops: LoopAlert[], costUsd: number): number;
+/**
+ * Counts exact duplicate tool calls: same tool_name + same tool_input.
+ * Only Done events with non-null tool_name are considered.
+ */
+export declare function detectExactRetries(events: EventRow[]): number;
+/**
+ * Fraction of Done calls whose tool_response matches an error pattern.
+ * Returns 0 if there are no Done calls with a response.
+ */
+export declare function computeErrorRate(events: EventRow[]): number;
+/**
+ * Diversity of file access: unique_files / total_file_calls.
+ * Returns 1.0 when there are no file tool calls (no penalty).
+ * Lower values indicate the agent is revisiting the same files repeatedly.
+ */
+export declare function computeFileChurn(events: EventRow[]): number;
+/**
+ * Counts A→B→A triplets in the Done event sequence within a 5-minute window.
+ * Indicates the agent oscillates between two tools without making progress.
+ */
+export declare function detectSeqCycles(events: EventRow[]): number;
+export interface SemanticLoop {
+    type: 'tool_sequence' | 'error_persistence';
+    turn_start: number;
+    count: number;
+    detail: string;
+}
+interface TurnLike {
+    turn_index: number;
+    tool_calls?: string[];
+    error_count: number;
+}
+/**
+ * Detects two kinds of semantic loops using assistant_turns data:
+ * - tool_sequence: same tool_calls signature repeated in ≥2 of the last 5 turns
+ * - error_persistence: ≥3 consecutive turns with error_count > 0
+ */
+export declare function analyzeSemanticLoops(turns: TurnLike[]): SemanticLoop[];
+export interface SaturationPrediction {
+    minutesLeft: number;
+    pctPerMin: number;
+}
+/**
+ * Linear regression over context_used samples → predicts minutes until 90% of context_window.
+ * Returns null if insufficient data or trend is flat/negative.
+ */
+export declare function predictSaturation(samples: Array<{
+    ts: number;
+    context_used: number;
+}>, contextWindow: number): SaturationPrediction | null;
 /**
  * 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

@@ -9,37 +9,70 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.detectLoops = detectLoops;
 exports.calcEfficiencyScore = calcEfficiencyScore;
+exports.detectExactRetries = detectExactRetries;
+exports.computeErrorRate = computeErrorRate;
+exports.computeFileChurn = computeFileChurn;
+exports.detectSeqCycles = detectSeqCycles;
+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,
+                    },
+                });
             }
         }
     }
@@ -78,14 +111,169 @@ function calcEfficiencyScore(events, loops, costUsd) {
         score -= 5;
     return Math.max(0, Math.min(100, score));
 }
+// ─── Semantic metrics ─────────────────────────────────────────────────────────
+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.
+ * Only Done events with non-null tool_name are considered.
+ */
+function detectExactRetries(events) {
+    const seen = new Map();
+    for (const e of events) {
+        if (e.type !== 'Done' || !e.tool_name)
+            continue;
+        const key = `${e.tool_name}:${e.tool_input ?? ''}`;
+        seen.set(key, (seen.get(key) ?? 0) + 1);
+    }
+    let retries = 0;
+    for (const count of seen.values()) {
+        if (count > 1)
+            retries += count - 1;
+    }
+    return retries;
+}
+/**
+ * Fraction of Done calls whose tool_response matches an error pattern.
+ * Returns 0 if there are no Done calls with a response.
+ */
+function computeErrorRate(events) {
+    const done = events.filter(e => e.type === 'Done' && e.tool_response != null);
+    if (done.length === 0)
+        return 0;
+    const errored = done.filter(e => ERROR_PATTERN.test(e.tool_response));
+    return errored.length / done.length;
+}
+/**
+ * Diversity of file access: unique_files / total_file_calls.
+ * Returns 1.0 when there are no file tool calls (no penalty).
+ * Lower values indicate the agent is revisiting the same files repeatedly.
+ */
+function computeFileChurn(events) {
+    const fileCalls = events.filter(e => e.type === 'Done' && FILE_TOOLS.has(e.tool_name ?? ''));
+    if (fileCalls.length === 0)
+        return 1.0;
+    const uniquePaths = new Set();
+    for (const e of fileCalls) {
+        if (!e.tool_input)
+            continue;
+        try {
+            const inp = JSON.parse(e.tool_input);
+            const fp = inp.file_path ?? inp.path ?? inp.pattern;
+            if (typeof fp === 'string')
+                uniquePaths.add(fp);
+        }
+        catch { /* malformed input */ }
+    }
+    return uniquePaths.size / fileCalls.length;
+}
+/**
+ * Counts A→B→A triplets in the Done event sequence within a 5-minute window.
+ * Indicates the agent oscillates between two tools without making progress.
+ */
+function detectSeqCycles(events) {
+    const SEQ_WINDOW_MS = 5 * 60000;
+    const done = events.filter(e => e.type === 'Done' && e.tool_name);
+    let cycles = 0;
+    for (let i = 2; i < done.length; i++) {
+        if (done[i].tool_name === done[i - 2].tool_name &&
+            done[i].ts - done[i - 2].ts <= SEQ_WINDOW_MS) {
+            cycles++;
+        }
+    }
+    return cycles;
+}
+/**
+ * Detects two kinds of semantic loops using assistant_turns data:
+ * - tool_sequence: same tool_calls signature repeated in ≥2 of the last 5 turns
+ * - error_persistence: ≥3 consecutive turns with error_count > 0
+ */
+function analyzeSemanticLoops(turns) {
+    const loops = [];
+    // ── error_persistence ────────────────────────────────────────────────────────
+    const ERROR_RUN_MIN = 3;
+    let runStart = -1;
+    let runLen = 0;
+    for (let i = 0; i < turns.length; i++) {
+        if (turns[i].error_count > 0) {
+            if (runLen === 0)
+                runStart = turns[i].turn_index;
+            runLen++;
+        }
+        else {
+            if (runLen >= ERROR_RUN_MIN) {
+                loops.push({ type: 'error_persistence', turn_start: runStart, count: runLen, detail: `${runLen} consecutive error turns` });
+            }
+            runLen = 0;
+        }
+    }
+    if (runLen >= ERROR_RUN_MIN) {
+        loops.push({ type: 'error_persistence', turn_start: runStart, count: runLen, detail: `${runLen} consecutive error turns` });
+    }
+    // ── tool_sequence: same tool_calls fingerprint in ≥2 of last 5 turns ────────
+    const WINDOW = 5;
+    const fingerprint = (t) => (t.tool_calls ?? []).join(',');
+    for (let i = 1; i < turns.length; i++) {
+        const fp = fingerprint(turns[i]);
+        if (!fp)
+            continue;
+        const window = turns.slice(Math.max(0, i - WINDOW + 1), i);
+        const matches = window.filter(t => fingerprint(t) === fp);
+        if (matches.length >= 1) {
+            const alreadyLogged = loops.some(l => l.type === 'tool_sequence' && l.turn_start === turns[i - matches.length].turn_index);
+            if (!alreadyLogged) {
+                const label = (turns[i].tool_calls ?? []).join('→') || 'empty';
+                loops.push({
+                    type: 'tool_sequence',
+                    turn_start: turns[i - matches.length].turn_index,
+                    count: matches.length + 1,
+                    detail: `${label} ×${matches.length + 1}`,
+                });
+            }
+        }
+    }
+    return loops;
+}
+/**
+ * Linear regression over context_used samples → predicts minutes until 90% of context_window.
+ * Returns null if insufficient data or trend is flat/negative.
+ */
+function predictSaturation(samples, contextWindow) {
+    if (samples.length < 3 || contextWindow <= 0)
+        return null;
+    const n = samples.length;
+    const t0 = samples[0].ts;
+    const xs = samples.map(s => (s.ts - t0) / 60000); // minutes from first sample
+    const ys = samples.map(s => s.context_used / contextWindow); // 0-1 fraction
+    const sumX = xs.reduce((a, b) => a + b, 0);
+    const sumY = ys.reduce((a, b) => a + b, 0);
+    const sumXY = xs.reduce((a, x, i) => a + x * ys[i], 0);
+    const sumX2 = xs.reduce((a, x) => a + x * x, 0);
+    const denom = n * sumX2 - sumX * sumX;
+    if (Math.abs(denom) < 1e-9)
+        return null;
+    const slope = (n * sumXY - sumX * sumY) / denom; // fraction per minute
+    const intercept = (sumY - slope * sumX) / n;
+    if (slope <= 0)
+        return null; // context shrinking or flat → no saturation risk
+    const target = 0.9;
+    const currentX = xs[n - 1];
+    const minutesLeft = (target - (intercept + slope * currentX)) / slope;
+    if (minutesLeft < 0)
+        return null; // already past target
+    return { minutesLeft: Math.round(minutesLeft), pctPerMin: Math.round(slope * 100 * 10) / 10 };
+}
 /**
  * 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);
+    const fileChurnScore = computeFileChurn(events);
+    const seqCycleCount = detectSeqCycles(events);
     const summary = buildSummary(loops, efficiencyScore, costUsd, events);
-    return { loops, efficiencyScore, summary };
+    return { loops, efficiencyScore, summary, exactRetries, errorRate, fileChurnScore, seqCycleCount };
 }
 function buildSummary(loops, score, costUsd, events) {
     const parts = [];

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

@@ -72,6 +72,11 @@ export declare function homeSlugRegex(): RegExp;
  *   Windows: C:\Users\db → C--Users-db
  */
 export declare function getHomeSlug(): string;
+/**
+ * Returns the OpenCode config directory.
+ * Can be overridden via OPENCODE_CONFIG_DIR env var.
+ */
+export declare function getOpencodeDir(): string;
 /**
  * Returns the OpenCode SQLite database path.
  * Can be overridden via OPENCODE_DB env var.
@@ -95,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

@@ -26,10 +26,15 @@ exports.encodeClaudePath = encodeClaudePath;
 exports.decodeClaudePath = decodeClaudePath;
 exports.homeSlugRegex = homeSlugRegex;
 exports.getHomeSlug = getHomeSlug;
+exports.getOpencodeDir = getOpencodeDir;
 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"));
@@ -147,6 +152,13 @@ function getHomeSlug() {
     return encodeClaudePath(os_1.default.homedir());
 }
 // ─── OpenCode data directory ───────────────────────────────────────────────────
+/**
+ * Returns the OpenCode config directory.
+ * Can be overridden via OPENCODE_CONFIG_DIR env var.
+ */
+function getOpencodeDir() {
+    return process.env.OPENCODE_CONFIG_DIR ?? path_1.default.join(os_1.default.homedir(), '.config', 'opencode');
+}
 /**
  * Returns the OpenCode SQLite database path.
  * Can be overridden via OPENCODE_DB env var.
@@ -181,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/pricing.d.ts

@@ -12,6 +12,8 @@ export interface ModelPricing {
 }
 export declare const PRICING: Record<string, ModelPricing>;
 export declare const DEFAULT_PRICING: ModelPricing;
+export declare const KNOWN_CONTEXT_WINDOWS: Record<string, number>;
+export declare function getContextWindow(model: string): number;
 export declare function calcCost(model: string, usage: {
     input_tokens: number;
     output_tokens: number;

package/dist/pricing.js

@@ -6,7 +6,8 @@
  * Prices are in USD per million tokens.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_PRICING = exports.PRICING = void 0;
+exports.KNOWN_CONTEXT_WINDOWS = exports.DEFAULT_PRICING = exports.PRICING = void 0;
+exports.getContextWindow = getContextWindow;
 exports.calcCost = calcCost;
 exports.PRICING = {
     'claude-opus-4-6': { input: 15, output: 75, cacheRead: 1.50, cacheCreate: 18.75 },
@@ -15,6 +16,16 @@ exports.PRICING = {
     'claude-haiku-4-5-20251001': { input: 0.80, output: 4, cacheRead: 0.08, cacheCreate: 1.00 },
 };
 exports.DEFAULT_PRICING = exports.PRICING['claude-sonnet-4-6'];
+exports.KNOWN_CONTEXT_WINDOWS = {
+    'claude-opus-4-6': 200000,
+    'claude-sonnet-4-6': 200000,
+    'claude-haiku-4-5': 200000,
+    'claude-haiku-4-5-20251001': 200000,
+    'deepseek-v4-flash-free': 1000000,
+};
+function getContextWindow(model) {
+    return exports.KNOWN_CONTEXT_WINDOWS[model] ?? 200000;
+}
 function calcCost(model, usage) {
     const price = exports.PRICING[model] ?? exports.DEFAULT_PRICING;
     const M = 1000000;