@statforge/claudestat 1.6.1 → 1.7.0

package/dist/db.js

@@ -13,7 +13,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.dbOps = exports.CLAUDESTAT_DIR = void 0;
+exports.dbOps = exports.TOOL_RESPONSE_MAX_BYTES = exports.CLAUDESTAT_DIR = void 0;
+exports.capToolResponse = capToolResponse;
 const node_sqlite_1 = require("node:sqlite");
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
@@ -22,35 +23,22 @@ exports.CLAUDESTAT_DIR = (0, paths_1.getClaudestatDir)();
 const DB_PATH = process.env.CLAUDESTAT_DB_PATH ?? path_1.default.join(exports.CLAUDESTAT_DIR, 'events.db');
 fs_1.default.mkdirSync(exports.CLAUDESTAT_DIR, { recursive: true });
 const db = new node_sqlite_1.DatabaseSync(DB_PATH);
-// Migraciones: añadir columnas nuevas sin romper instalaciones previas
-try {
-    db.exec(`ALTER TABLE sessions ADD COLUMN project_path TEXT`);
-}
-catch { /* ya existe */ }
-try {
-    db.exec(`ALTER TABLE sessions ADD COLUMN ai_summary   TEXT`);
+// ─── Tool response size cap ────────────────────────────────────────────────────
+exports.TOOL_RESPONSE_MAX_BYTES = 8192;
+function capToolResponse(raw) {
+    if (Buffer.byteLength(raw, 'utf8') <= exports.TOOL_RESPONSE_MAX_BYTES)
+        return raw;
+    const buf = Buffer.from(raw, 'utf8').subarray(0, exports.TOOL_RESPONSE_MAX_BYTES);
+    return buf.toString('utf8') + `…[truncated: ${raw.length} chars]`;
 }
-catch { /* ya existe */ }
-try {
-    db.exec(`
-  CREATE TABLE IF NOT EXISTS weekly_reports (
-    id              INTEGER PRIMARY KEY AUTOINCREMENT,
-    date            TEXT    NOT NULL UNIQUE,
-    report_markdown TEXT    NOT NULL,
-    created_at      TEXT    DEFAULT (datetime('now'))
-  )
-`);
-}
-catch { /* ya existe */ }
-try {
-    db.exec(`
+// ─── Base tables (idempotent — safe on every start) ───────────────────────────
+// meta must exist before runMigrations reads schema_version
+db.exec(`
   CREATE TABLE IF NOT EXISTS meta (
     key   TEXT PRIMARY KEY,
     value TEXT NOT NULL
   )
 `);
-}
-catch { /* ya existe */ }
 db.exec(`
   CREATE TABLE IF NOT EXISTS sessions (
     id                     TEXT    PRIMARY KEY,
@@ -82,7 +70,6 @@ db.exec(`
   );
 `);
 // Índices para acelerar las subqueries de getRecentSessions (N+3 pattern)
-// Wrapped en try-catch para no romper instalaciones que ya los tienen
 try {
     db.exec(`CREATE INDEX IF NOT EXISTS idx_events_session_type ON events(session_id, type)`);
 }
@@ -99,32 +86,96 @@ try {
     db.exec(`CREATE INDEX IF NOT EXISTS idx_sessions_project  ON sessions(project_path)`);
 }
 catch { }
-try {
-    db.exec(`ALTER TABLE sessions ADD COLUMN dominant_model TEXT`);
-}
-catch { }
-try {
-    db.exec(`ALTER TABLE events ADD COLUMN skill_parent TEXT`);
-}
-catch { }
-try {
-    db.exec(`ALTER TABLE sessions ADD COLUMN parent_session_id TEXT`);
-}
-catch { }
-try {
-    db.exec(`ALTER TABLE sessions ADD COLUMN source TEXT DEFAULT 'claude-code'`);
-}
-catch { }
-try {
-    db.exec(`ALTER TABLE events ADD COLUMN source TEXT DEFAULT 'claude-code'`);
+// ─── Schema migrations ─────────────────────────────────────────────────────────
+// Each migration runs exactly once, tracked by meta.schema_version.
+// try/catch per migration handles existing installs where columns already exist.
+const MIGRATIONS = [
+    { version: 1, sql: `ALTER TABLE sessions ADD COLUMN project_path TEXT` },
+    { version: 2, sql: `ALTER TABLE sessions ADD COLUMN ai_summary TEXT` },
+    { version: 3, sql: `CREATE TABLE IF NOT EXISTS weekly_reports (
+    id              INTEGER PRIMARY KEY AUTOINCREMENT,
+    date            TEXT    NOT NULL UNIQUE,
+    report_markdown TEXT    NOT NULL,
+    created_at      TEXT    DEFAULT (datetime('now'))
+  )` },
+    { version: 4, sql: `ALTER TABLE sessions ADD COLUMN dominant_model TEXT` },
+    { version: 5, sql: `ALTER TABLE events ADD COLUMN skill_parent TEXT` },
+    { version: 6, sql: `ALTER TABLE sessions ADD COLUMN parent_session_id TEXT` },
+    { version: 7, sql: `ALTER TABLE sessions ADD COLUMN source TEXT DEFAULT 'claude-code'` },
+    { version: 8, sql: `ALTER TABLE events ADD COLUMN source TEXT DEFAULT 'claude-code'` },
+    { version: 9, sql: `ALTER TABLE sessions ADD COLUMN exact_retries INTEGER DEFAULT 0` },
+    { version: 10, sql: `ALTER TABLE sessions ADD COLUMN error_rate REAL DEFAULT 0` },
+    { version: 11, sql: `ALTER TABLE sessions ADD COLUMN file_churn_score REAL DEFAULT 0` },
+    { version: 12, sql: `ALTER TABLE sessions ADD COLUMN seq_cycle_count INTEGER DEFAULT 0` },
+    { version: 13, sql: `ALTER TABLE sessions ADD COLUMN avg_output_chars INTEGER DEFAULT 0` },
+    { version: 14, sql: `ALTER TABLE sessions ADD COLUMN error_block_count INTEGER DEFAULT 0` },
+    { version: 15, sql: `CREATE TABLE IF NOT EXISTS assistant_turns (
+    id           INTEGER PRIMARY KEY AUTOINCREMENT,
+    session_id   TEXT    NOT NULL,
+    turn_index   INTEGER NOT NULL,
+    ts           INTEGER,
+    text_preview TEXT,
+    tool_calls   TEXT,
+    error_count  INTEGER DEFAULT 0,
+    output_chars INTEGER DEFAULT 0,
+    UNIQUE(session_id, turn_index) ON CONFLICT REPLACE
+  )` },
+    { version: 16, sql: `ALTER TABLE sessions ADD COLUMN semantic_loop_count INTEGER DEFAULT 0` },
+    { version: 17, sql: `ALTER TABLE assistant_turns ADD COLUMN context_used INTEGER DEFAULT 0` },
+    { version: 18, sql: `
+    CREATE TABLE IF NOT EXISTS file_intents (
+      id             INTEGER PRIMARY KEY AUTOINCREMENT,
+      tool           TEXT    NOT NULL,
+      session_id     TEXT    NOT NULL,
+      task_desc      TEXT,
+      status         TEXT    NOT NULL DEFAULT 'active',
+      acquired_at    INTEGER NOT NULL,
+      released_at    INTEGER,
+      last_heartbeat INTEGER
+    );
+    CREATE INDEX IF NOT EXISTS idx_intents_status ON file_intents(status);
+  ` },
+    { version: 19, sql: `
+    CREATE TABLE IF NOT EXISTS file_intent_files (
+      id           INTEGER PRIMARY KEY AUTOINCREMENT,
+      intent_id    INTEGER NOT NULL REFERENCES file_intents(id) ON DELETE CASCADE,
+      file_path    TEXT    NOT NULL,
+      operation    TEXT    NOT NULL DEFAULT 'write',
+      line_start   INTEGER,
+      line_end     INTEGER
+    );
+    CREATE INDEX IF NOT EXISTS idx_intent_files_path ON file_intent_files(file_path);
+  ` },
+    { version: 20, sql: `ALTER TABLE events ADD COLUMN external_id TEXT` },
+    { version: 21, sql: `CREATE UNIQUE INDEX IF NOT EXISTS idx_events_ext ON events(session_id, external_id) WHERE external_id IS NOT NULL` },
+];
+function runMigrations() {
+    const row = db.prepare(`SELECT value FROM meta WHERE key = 'schema_version'`).get();
+    const currentVersion = row ? parseInt(row.value, 10) : 0;
+    const upsertVersion = db.prepare(`INSERT INTO meta (key, value) VALUES ('schema_version', ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value`);
+    for (const m of MIGRATIONS) {
+        if (m.version <= currentVersion)
+            continue;
+        try {
+            db.exec(m.sql);
+        }
+        catch { /* column/table already exists on prior installs */ }
+        upsertVersion.run(String(m.version));
+    }
 }
-catch { }
+runMigrations(); // must run before stmts — some queries reference migrated columns
 // ─── Prepared statements (se compilan una vez al iniciar) ─────────────────────
 const stmts = {
     upsertSession: db.prepare(`
     INSERT INTO sessions (id, cwd, started_at, last_event_at, source)
     VALUES (?, ?, ?, ?, COALESCE(?, 'claude-code'))
-    ON CONFLICT(id) DO UPDATE SET last_event_at = excluded.last_event_at
+    ON CONFLICT(id) DO UPDATE SET
+      last_event_at = excluded.last_event_at,
+      source = COALESCE(excluded.source, source)
+  `),
+    insertSessionIfAbsent: db.prepare(`
+    INSERT OR IGNORE INTO sessions (id, cwd, started_at, last_event_at, source)
+    VALUES (?, ?, ?, ?, COALESCE(?, 'claude-code'))
   `),
     updateSessionCost: db.prepare(`
     UPDATE sessions SET
@@ -135,12 +186,20 @@ const stmts = {
       total_cache_creation = ?,
       efficiency_score     = ?,
       loops_detected       = ?,
-      dominant_model       = ?
+      dominant_model       = ?,
+      exact_retries        = ?,
+      error_rate           = ?,
+      file_churn_score     = ?,
+      seq_cycle_count      = ?
     WHERE id = ?
   `),
     insertEvent: db.prepare(`
     INSERT INTO events (session_id, type, tool_name, tool_input, ts, cwd, skill_parent, source)
     VALUES (?, ?, ?, ?, ?, ?, ?, COALESCE(?, 'claude-code'))
+  `),
+    insertOcEvent: db.prepare(`
+    INSERT OR IGNORE INTO events (session_id, type, tool_name, ts, duration_ms, external_id, source)
+    VALUES (?, 'Done', ?, ?, 0, ?, 'opencode')
   `),
     pairPost: db.prepare(`
     UPDATE events SET type = 'Done', tool_response = ?, duration_ms = ?
@@ -171,7 +230,7 @@ const stmts = {
     SELECT * FROM sessions WHERE id = ?
   `),
     updateSessionProject: db.prepare(`
-    UPDATE sessions SET project_path = ? WHERE id = ? AND project_path IS NULL
+    UPDATE sessions SET project_path = ? WHERE id = ?
   `),
     getRecentSessions: db.prepare(`
     SELECT s.*, s.ai_summary,
@@ -219,6 +278,13 @@ const stmts = {
     WHERE s.project_path = ? AND e.type = 'Done' AND e.tool_name IS NOT NULL
     GROUP BY e.tool_name
     ORDER BY count DESC
+  `),
+    getProjectCliHours: db.prepare(`
+    SELECT project_path, COALESCE(source, 'claude-code') as source,
+      SUM(last_event_at - started_at) as total_ms
+    FROM sessions
+    WHERE project_path IS NOT NULL AND last_event_at IS NOT NULL
+    GROUP BY project_path, COALESCE(source, 'claude-code')
   `),
     // Session-level aggregates for pattern analysis (cache, loops, cost, efficiency)
     getProjectSessionStats: db.prepare(`
@@ -284,6 +350,7 @@ const stmts = {
     analyticsDaily: db.prepare(`
     SELECT
       date(started_at / 1000, 'unixepoch', 'localtime')          AS date,
+      COALESCE(source, 'claude-code')                             AS source,
       COUNT(*)                                                     AS sessions,
       COALESCE(SUM(total_cost_usd),       0)                      AS cost,
       COALESCE(SUM(total_input_tokens),   0)                      AS input_tokens,
@@ -293,31 +360,34 @@ const stmts = {
       COALESCE(AVG(CASE WHEN efficiency_score > 0 THEN efficiency_score END), 100) AS avg_efficiency
     FROM sessions
     WHERE started_at >= ?
-    GROUP BY date
+    GROUP BY date, COALESCE(source, 'claude-code')
     ORDER BY date ASC
   `),
     analyticsByModel: db.prepare(`
     SELECT
       date(started_at / 1000, 'unixepoch', 'localtime')                                AS date,
       COALESCE(dominant_model, 'claude-sonnet-4-6')                                     AS model,
+      COALESCE(source, 'claude-code')                                                   AS source,
       COALESCE(SUM(total_input_tokens + total_output_tokens + total_cache_read), 0)     AS tokens,
       COALESCE(SUM(total_cost_usd), 0)                                                  AS cost
     FROM sessions
     WHERE started_at >= ?
-    GROUP BY date, model
+      AND (dominant_model IS NULL OR dominant_model NOT LIKE '<%')
+    GROUP BY date, model, COALESCE(source, 'claude-code')
     ORDER BY date ASC
   `),
     analyticsProjectHours: db.prepare(`
     SELECT
       COALESCE(project_path, 'No project')                      AS project,
+      COALESCE(source, 'claude-code')                           AS source,
       COUNT(*)                                                  AS sessions,
       COALESCE(SUM(last_event_at - started_at), 0) / 3600000.0 AS hours,
       COALESCE(SUM(total_cost_usd), 0)                         AS cost
     FROM sessions
     WHERE started_at >= ?
-    GROUP BY project
+    GROUP BY project, COALESCE(source, 'claude-code')
     ORDER BY hours DESC
-    LIMIT 8
+    LIMIT 16
   `),
     getTopToolsByCost: db.prepare(`
     WITH session_totals AS (
@@ -334,6 +404,7 @@ const stmts = {
     )
     SELECT
       tps.tool_name,
+      COALESCE(s.source, 'claude-code')              AS source,
       SUM(tps.cnt)                                   AS count,
       SUM(tps.tool_dur)                              AS total_duration_ms,
       SUM(CASE WHEN st.total_done > 0
@@ -342,8 +413,8 @@ const stmts = {
     FROM tool_per_session tps
     JOIN session_totals st ON tps.session_id = st.session_id
     JOIN sessions s ON tps.session_id = s.id
-    WHERE s.total_cost_usd > 0
-    GROUP BY tps.tool_name
+    WHERE (? = 'all' OR COALESCE(s.source, 'claude-code') = ?)
+    GROUP BY tps.tool_name, COALESCE(s.source, 'claude-code')
     ORDER BY total_cost_usd DESC
     LIMIT ?
   `),
@@ -362,6 +433,7 @@ const stmts = {
     )
     SELECT
       tps.tool_name,
+      COALESCE(s.source, 'claude-code')              AS source,
       SUM(tps.cnt)                                   AS count,
       SUM(tps.tool_dur)                              AS total_duration_ms,
       SUM(CASE WHEN st.total_done > 0
@@ -370,8 +442,8 @@ const stmts = {
     FROM tool_per_session tps
     JOIN session_totals st ON tps.session_id = st.session_id
     JOIN sessions s ON tps.session_id = s.id
-    WHERE s.total_cost_usd > 0
-    GROUP BY tps.tool_name
+    WHERE (? = 'all' OR COALESCE(s.source, 'claude-code') = ?)
+    GROUP BY tps.tool_name, COALESCE(s.source, 'claude-code')
     ORDER BY count DESC
     LIMIT ?
   `),
@@ -390,6 +462,7 @@ const stmts = {
     )
     SELECT
       tps.tool_name,
+      COALESCE(s.source, 'claude-code')              AS source,
       SUM(tps.cnt)                                   AS count,
       SUM(tps.tool_dur)                              AS total_duration_ms,
       SUM(CASE WHEN st.total_done > 0
@@ -398,8 +471,8 @@ const stmts = {
     FROM tool_per_session tps
     JOIN session_totals st ON tps.session_id = st.session_id
     JOIN sessions s ON tps.session_id = s.id
-    WHERE s.total_cost_usd > 0
-    GROUP BY tps.tool_name
+    WHERE (? = 'all' OR COALESCE(s.source, 'claude-code') = ?)
+    GROUP BY tps.tool_name, COALESCE(s.source, 'claude-code')
     ORDER BY total_duration_ms DESC
     LIMIT ?
   `),
@@ -440,6 +513,13 @@ const stmts = {
     GROUP BY project_path
     ORDER BY total_cost DESC
     LIMIT 5
+  `),
+    updateSessionSemantic: db.prepare(`
+    UPDATE sessions SET avg_output_chars = ?, error_block_count = ?, semantic_loop_count = ? WHERE id = ?
+  `),
+    getAssistantTurns: db.prepare(`
+    SELECT turn_index, ts, text_preview, tool_calls, error_count, output_chars, context_used
+    FROM assistant_turns WHERE session_id = ? ORDER BY turn_index ASC
   `),
     getHourlyDistribution: db.prepare(`
     SELECT
@@ -490,6 +570,12 @@ exports.dbOps = {
         const res = stmts.insertEvent.run(e.session_id, e.type, e.tool_name ?? null, e.tool_input ?? null, e.ts, e.cwd ?? null, e.skill_parent ?? null, e.source ?? null);
         return Number(res.lastInsertRowid);
     },
+    insertOcEvent(sessionId, toolName, ts, externalId) {
+        stmts.insertOcEvent.run(sessionId, toolName, ts, externalId);
+    },
+    insertSessionIfAbsent(s) {
+        stmts.insertSessionIfAbsent.run(s.id, s.cwd ?? null, s.started_at, s.last_event_at ?? s.started_at, s.source ?? null);
+    },
     /**
      * Al llegar PostToolUse, actualizamos el PreToolUse pendiente más reciente
      * del mismo tool para esta sesión. Esto convierte el par Pre+Post en
@@ -503,13 +589,13 @@ exports.dbOps = {
       ORDER BY ts DESC LIMIT 1
     `).get(sessionId, toolName);
         if (pending) {
-            stmts.pairPost.run(response, postTs - pending.ts, sessionId, toolName);
+            stmts.pairPost.run(capToolResponse(response), postTs - pending.ts, sessionId, toolName);
             return pending.id;
         }
         return null;
     },
-    updateSessionCost(sessionId, cost, efficiencyScore, loopsDetected) {
-        stmts.updateSessionCost.run(cost.cost_usd, cost.input_tokens, cost.output_tokens, cost.cache_read, cost.cache_creation, efficiencyScore, loopsDetected, cost.lastModel ?? null, sessionId);
+    updateSessionCost(sessionId, cost, efficiencyScore, loopsDetected, exactRetries = 0, errorRate = 0, fileChurnScore = 1, seqCycleCount = 0) {
+        stmts.updateSessionCost.run(cost.cost_usd, cost.input_tokens, cost.output_tokens, cost.cache_read, cost.cache_creation, efficiencyScore, loopsDetected, cost.lastModel ?? null, exactRetries, errorRate, fileChurnScore, seqCycleCount, sessionId);
     },
     getSessionEvents(sessionId) {
         return stmts.getSessionEvents.all(sessionId);
@@ -530,6 +616,13 @@ exports.dbOps = {
         return stmts.getSessionEventsRecent.all(sessionId, limit);
     },
     updateSessionProject(sessionId, projectPath) {
+        const existing = this.getSession(sessionId);
+        if (existing?.project_path) {
+            const cur = existing.project_path.endsWith('/')
+                ? existing.project_path : existing.project_path + '/';
+            if (!projectPath.startsWith(cur))
+                return;
+        }
         stmts.updateSessionProject.run(projectPath, sessionId);
     },
     getRecentSessions(days) {
@@ -545,6 +638,9 @@ exports.dbOps = {
     getProjectSessionStats(projectPath) {
         return stmts.getProjectSessionStats.get(projectPath);
     },
+    getProjectCliHours() {
+        return stmts.getProjectCliHours.all();
+    },
     updateSessionSummary(sessionId, summary) {
         stmts.updateSessionSummary.run(summary, sessionId);
     },
@@ -591,15 +687,31 @@ exports.dbOps = {
     getAnalyticsDaily(since) { return stmts.analyticsDaily.all(since); },
     getAnalyticsByModel(since) { return stmts.analyticsByModel.all(since); },
     getProjectHours(since) { return stmts.analyticsProjectHours.all(since); },
-    getTopTools(days = 30, by = 'cost', limit = 10) {
+    getCoachEvents(sessionIds) {
+        if (sessionIds.length === 0)
+            return [];
+        const placeholders = sessionIds.map(() => '?').join(',');
+        const cutoff = Date.now() - 2 * 60 * 60000;
+        return db.prepare(`
+      SELECT session_id, type, tool_name, tool_input, ts
+      FROM events
+      WHERE session_id IN (${placeholders})
+        AND type IN ('PreToolUse', 'Done', 'Stop')
+        AND ts > ?
+      ORDER BY ts ASC
+    `).all(...sessionIds, cutoff);
+    },
+    getTopTools(days = 30, by = 'cost', limit = 10, source = 'all') {
         const since = Date.now() - days * 86400000;
         const stmt = by === 'count' ? stmts.getTopToolsByCount
             : by === 'duration' ? stmts.getTopToolsByDuration
                 : stmts.getTopToolsByCost;
-        const tools = stmt.all(since, since, limit);
-        const other = stmts.getUnattributedCost.get(since, since, since);
-        if (other.other_cost_usd > 0) {
-            tools.push({ tool_name: 'Other', count: 0, total_duration_ms: 0, total_cost_usd: other.other_cost_usd });
+        const tools = stmt.all(since, since, source, source, limit);
+        if (source === 'all') {
+            const other = stmts.getUnattributedCost.get(since, since, since);
+            if (other.other_cost_usd > 0) {
+                tools.push({ tool_name: 'Other', source: 'claude-code', count: 0, total_duration_ms: 0, total_cost_usd: other.other_cost_usd });
+            }
         }
         return tools;
     },
@@ -626,6 +738,30 @@ exports.dbOps = {
         const since = Date.now() - days * 86400000;
         return stmts.getHourlyDistribution.all(since);
     },
+    updateSessionSemantic(sessionId, avgOutputChars, errorBlockCount, semanticLoopCount = 0) {
+        stmts.updateSessionSemantic.run(avgOutputChars, errorBlockCount, semanticLoopCount, sessionId);
+    },
+    upsertAssistantTurns(sessionId, turns) {
+        db.prepare(`DELETE FROM assistant_turns WHERE session_id = ?`).run(sessionId);
+        const insert = db.prepare(`
+      INSERT INTO assistant_turns (session_id, turn_index, ts, text_preview, tool_calls, error_count, output_chars, context_used)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        for (const t of turns) {
+            insert.run(sessionId, t.turn_index, t.ts ?? null, t.text_preview ?? null, JSON.stringify(t.tool_calls ?? []), t.error_count, t.output_chars, t.context_used);
+        }
+    },
+    getAssistantTurns(sessionId) {
+        return stmts.getAssistantTurns.all(sessionId).map(r => ({
+            turn_index: r.turn_index,
+            ts: r.ts ?? undefined,
+            text_preview: r.text_preview ?? undefined,
+            tool_calls: r.tool_calls ? JSON.parse(r.tool_calls) : [],
+            error_count: r.error_count,
+            output_chars: r.output_chars,
+            context_used: r.context_used ?? 0,
+        }));
+    },
     getCacheReadByModel(days) {
         const since = Date.now() - days * 86400000;
         return db.prepare(`
@@ -648,4 +784,98 @@ exports.dbOps = {
       ORDER BY total_cost DESC
     `).all(since);
     },
+    // ─── File intent coordination ──────────────────────────────────────────────
+    insertIntent(tool, sessionId, taskDesc) {
+        const res = db.prepare(`
+      INSERT INTO file_intents (tool, session_id, task_desc, status, acquired_at, last_heartbeat)
+      VALUES (?, ?, ?, 'active', ?, ?)
+    `).run(tool, sessionId, taskDesc ?? null, Date.now(), Date.now());
+        return Number(res.lastInsertRowid);
+    },
+    insertIntentFile(intentId, filePath, operation, lineStart, lineEnd) {
+        db.prepare(`
+      INSERT INTO file_intent_files (intent_id, file_path, operation, line_start, line_end)
+      VALUES (?, ?, ?, ?, ?)
+    `).run(intentId, filePath, operation, lineStart ?? null, lineEnd ?? null);
+    },
+    getWriteConflicts(filePaths, excludeTool) {
+        if (filePaths.length === 0)
+            return [];
+        const placeholders = filePaths.map(() => '?').join(',');
+        return db.prepare(`
+      SELECT f.file_path, i.tool, i.session_id, i.task_desc, i.acquired_at
+      FROM file_intent_files f
+      JOIN file_intents i ON i.id = f.intent_id
+      WHERE f.file_path IN (${placeholders})
+        AND f.operation = 'write'
+        AND i.status = 'active'
+        AND i.tool != ?
+    `).all(...filePaths, excludeTool);
+    },
+    getIntent(id) {
+        return db.prepare(`SELECT tool, session_id, task_desc FROM file_intents WHERE id = ?`).get(id);
+    },
+    releaseIntent(id) {
+        db.prepare(`
+      UPDATE file_intents SET status = 'done', released_at = ? WHERE id = ?
+    `).run(Date.now(), id);
+    },
+    heartbeatIntent(id) {
+        db.prepare(`
+      UPDATE file_intents SET last_heartbeat = ? WHERE id = ? AND status = 'active'
+    `).run(Date.now(), id);
+    },
+    getIntentFiles(id) {
+        return db.prepare(`
+      SELECT file_path, operation FROM file_intent_files WHERE intent_id = ?
+    `).all(id);
+    },
+    getActiveToolsInProject(projectPath, excludeTool) {
+        const since = Date.now() - 10 * 60000;
+        return db.prepare(`
+      SELECT COALESCE(source, 'claude-code') AS source, MAX(last_event_at) AS last_event_at
+      FROM sessions
+      WHERE project_path = ?
+        AND COALESCE(source, 'claude-code') != ?
+        AND last_event_at >= ?
+      GROUP BY COALESCE(source, 'claude-code')
+    `).all(projectPath, excludeTool, since);
+    },
+    releaseOrphanedIntents() {
+        db.prepare(`UPDATE file_intents SET status = 'stale' WHERE status = 'active'`).run();
+        db.prepare(`DELETE FROM file_intents WHERE status IN ('done','stale')`).run();
+    },
+    markStaleIntents() {
+        const cutoff = Date.now() - 10 * 60000;
+        const stale = db.prepare(`
+      SELECT id, tool, task_desc FROM file_intents
+      WHERE status = 'active' AND (last_heartbeat IS NULL OR last_heartbeat < ?)
+    `).all(cutoff);
+        if (stale.length > 0) {
+            const ids = stale.map(s => s.id);
+            db.prepare(`UPDATE file_intents SET status = 'stale' WHERE id IN (${ids.map(() => '?').join(',')})`).run(...ids);
+        }
+        return stale;
+    },
+    deleteOldStaleIntents() {
+        const cutoff = Date.now() - 60 * 60000;
+        db.prepare(`DELETE FROM file_intents WHERE status IN ('done','stale') AND COALESCE(released_at, acquired_at) < ?`).run(cutoff);
+    },
+    hasActiveIntent(tool, filePath) {
+        const row = db.prepare(`
+      SELECT 1 FROM file_intents i
+      JOIN file_intent_files f ON f.intent_id = i.id
+      WHERE i.tool = ? AND f.file_path = ? AND i.status = 'active'
+      LIMIT 1
+    `).get(tool, filePath);
+        return !!row;
+    },
+    getActiveIntents() {
+        return db.prepare(`
+      SELECT i.id, i.tool, f.file_path
+      FROM file_intents i
+      JOIN file_intent_files f ON f.intent_id = i.id
+      WHERE i.status = 'active'
+    `).all();
+    },
 };

package/dist/doctor.js

@@ -131,7 +131,7 @@ async function runDoctor() {
     if (activeBinary) {
         try {
             const runningVersion = (0, child_process_1.execSync)(`${activeBinary} --version`, { stdio: 'pipe' })
-                .toString().trim().replace(/^v?/, '');
+                .toString().split('\n')[0].trim().replace(/^v?/, '');
             versionOk = runningVersion === installedVersion;
             if (!versionOk) {
                 versionNote = `Active binary reports v${runningVersion}, installed package is v${installedVersion}`;

package/dist/enricher.d.ts

@@ -16,8 +16,9 @@ import './watchers/opencode';
 import './watchers/amp';
 import './watchers/droid';
 import './watchers/codebuff';
-import type { CostUpdate } from './db';
-export { getAllBlockCostsForSession, getContextWindow, getSessionPrompts } from './watchers/claude-code';
+import { type CostUpdate } from './db';
+export { getAllBlockCostsForSession, getSessionPrompts } from './watchers/claude-code';
+export { getContextWindow } from './pricing';
 export type CostUpdateCallback = (sessionId: string, cost: CostUpdate, source?: string) => void;
 export type CompactDetectedCallback = (sessionId: string) => void;
 export declare function startEnricher(onUpdate: CostUpdateCallback, onCompact?: CompactDetectedCallback): void;

package/dist/enricher.js

@@ -15,7 +15,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSessionPrompts = exports.getContextWindow = exports.getAllBlockCostsForSession = void 0;
+exports.getContextWindow = exports.getSessionPrompts = exports.getAllBlockCostsForSession = void 0;
 exports.startEnricher = startEnricher;
 exports.stopEnricher = stopEnricher;
 exports.cleanupSession = cleanupSession;
@@ -30,11 +30,13 @@ require("./watchers/opencode");
 require("./watchers/amp");
 require("./watchers/droid");
 require("./watchers/codebuff");
+const db_1 = require("./db");
 // Re-export Claude Code-specific utilities for routes/stream and routes/misc
 var claude_code_1 = require("./watchers/claude-code");
 Object.defineProperty(exports, "getAllBlockCostsForSession", { enumerable: true, get: function () { return claude_code_1.getAllBlockCostsForSession; } });
-Object.defineProperty(exports, "getContextWindow", { enumerable: true, get: function () { return claude_code_1.getContextWindow; } });
 Object.defineProperty(exports, "getSessionPrompts", { enumerable: true, get: function () { return claude_code_1.getSessionPrompts; } });
+var pricing_1 = require("./pricing");
+Object.defineProperty(exports, "getContextWindow", { enumerable: true, get: function () { return pricing_1.getContextWindow; } });
 const prevContextBySession = new Map();
 let watcher = null;
 const pendingFiles = new Map();
@@ -90,7 +92,7 @@ function startEnricher(onUpdate, onCompact) {
     console.log(`[enricher] Watching ${adapters.map(a => a.label).join(', ')}`);
     watcher = chokidar_1.default.watch(watchPaths, {
         persistent: true,
-        ignoreInitial: true,
+        ignoreInitial: false,
         awaitWriteFinish: {
             stabilityThreshold: 200,
             pollInterval: 100,
@@ -119,16 +121,19 @@ function startEnricher(onUpdate, onCompact) {
     watcher.on('add', handleFile);
     // ─── Poll-based adapters (e.g. OpenCode SQLite) ─────────────────────────────
     const POLL_INTERVAL_MS = 10000;
+    const POLL_LOOKBACK_MS = 7 * 24 * 60 * 60000; // backfill 7 days on first start
     for (const adapter of adapters) {
         if (!(0, adapter_1.isPollable)(adapter))
             continue;
-        let lastPoll = Date.now();
+        let lastPoll = Date.now() - POLL_LOOKBACK_MS;
         const interval = setInterval(async () => {
             const since = lastPoll;
             lastPoll = Date.now();
             const sessions = await adapter.pollSessions(since);
-            for (const { sessionId, cost } of sessions) {
+            for (const { sessionId, cost, cwd } of sessions) {
                 onUpdate(sessionId, cost, adapter.name);
+                if (cwd)
+                    db_1.dbOps.updateSessionProject(sessionId, cwd);
             }
         }, POLL_INTERVAL_MS);
         interval.unref();

package/dist/index.js

@@ -62,9 +62,20 @@ if (!SKIP_UPDATE_NOTICE.has(subcommand)) {
     catch {
         fetchLatestVersion();
     }
+    const semverGt = (a, b) => {
+        const [pa, pb] = [a.split('.').map(Number), b.split('.').map(Number)];
+        for (let i = 0; i < 3; i++) {
+            const aVal = pa[i] ?? 0, bVal = pb[i] ?? 0;
+            if (aVal > bVal)
+                return true;
+            if (aVal < bVal)
+                return false;
+        }
+        return false;
+    };
     const _exit = process.exit.bind(process);
     process.exit = ((code) => {
-        if ((code ?? 0) === 0 && cachedLatest && cachedLatest !== PKG_VERSION) {
+        if ((code ?? 0) === 0 && cachedLatest && semverGt(cachedLatest, PKG_VERSION)) {
             console.log(`\n  ✦ Update available: ${PKG_VERSION} → ${cachedLatest}`);
             console.log(`    Run: npm install -g @statforge/claudestat\n`);
         }