@statforge/claudestat 1.6.0 → 1.7.0

package/dist/intelligence.d.ts

@@ -16,6 +16,10 @@ 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
@@ -39,7 +43,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 {};

package/dist/intelligence.js

@@ -9,6 +9,12 @@
 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
@@ -78,14 +84,170 @@ function calcEfficiencyScore(events, loops, costUsd) {
         score -= 5;
     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.
+ * 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);
     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/paths.d.ts

@@ -72,6 +72,16 @@ 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.
+ */
+export declare function getOpencodeDb(): string;
 /**
  * Returns the appropriate command to find an executable in PATH.
  *   Unix:    which <name>

package/dist/paths.js

@@ -26,6 +26,8 @@ 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;
@@ -145,6 +147,21 @@ function homeSlugRegex() {
 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.
+ */
+function getOpencodeDb() {
+    return process.env.OPENCODE_DB ?? path_1.default.join(os_1.default.homedir(), '.local', 'share', 'opencode', 'opencode.db');
+}
 // ─── Platform utilities ────────────────────────────────────────────────────────
 /**
  * Returns the appropriate command to find an executable in PATH.

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;

package/dist/routes/events.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processLatestForSession = exports.onCompactDetected = exports.onCostUpdate = exports.taggedSessionParents = exports.lastAgentByCwd = exports.eventsRouter = void 0;
+const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const express_1 = require("express");
 const db_1 = require("../db");
@@ -19,11 +20,23 @@ const notifier_1 = require("../notifier");
 const helpers_1 = require("./helpers");
 const enricher_1 = require("../enricher");
 Object.defineProperty(exports, "processLatestForSession", { enumerable: true, get: function () { return enricher_1.processLatestForSession; } });
+const claude_code_1 = require("../watchers/claude-code");
+// ─── Semantic extraction debounce: 3s after last new assistant turn ───────────
+const semanticDebounce = new Map();
+// ─── Predictive saturation: context samples + alert cooldown per session ──────
+const contextSamples = new Map();
+const saturationCooldown = new Map();
+const SATURATION_WARN_MINUTES = 30;
+const SATURATION_COOLDOWN_MS = 15 * 60000;
+const CONTEXT_SAMPLES_MAX = 20;
 // ─── 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();
+// ─── Memory leak bounds ────────────────────────────────────────────────────────
+const AGENT_CWD_TTL_MS = 30 * 60000; // entries older than 30min can't be valid parents
+const TAGGED_PARENTS_MAX = 500; // prevent unbounded growth over long daemon runs
 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.
@@ -55,17 +68,52 @@ function shouldFireAlert(level, pct) {
     alertCooldown.set(level, Date.now());
     return true;
 }
+function extractTextPreview(transcriptPath) {
+    try {
+        const size = fs_1.default.statSync(transcriptPath).size;
+        const readSize = Math.min(size, 8192);
+        const buf = Buffer.alloc(readSize);
+        const fd = fs_1.default.openSync(transcriptPath, 'r');
+        fs_1.default.readSync(fd, buf, 0, readSize, Math.max(0, size - readSize));
+        fs_1.default.closeSync(fd);
+        const lines = buf.toString('utf8').split('\n').filter(l => l.trim());
+        for (let i = lines.length - 1; i >= 0; i--) {
+            try {
+                const obj = JSON.parse(lines[i]);
+                const data = obj.message ?? obj;
+                if (data.role !== 'assistant')
+                    continue;
+                let text = '';
+                if (typeof data.content === 'string') {
+                    text = data.content;
+                }
+                else if (Array.isArray(data.content)) {
+                    text = data.content.find((c) => c.type === 'text')?.text ?? '';
+                }
+                text = text.replace(/\s+/g, ' ').trim();
+                if (!text)
+                    continue;
+                return text.length > 120 ? text.slice(0, 120) + '…' : text;
+            }
+            catch { }
+        }
+    }
+    catch { }
+    return undefined;
+}
 exports.eventsRouter.post('/event', (req, res) => {
     const ip = req.ip ?? '127.0.0.1';
     if ((0, rate_limiter_1.isRateLimited)(ip)) {
         res.status(429).json({ error: 'Too many requests — wait 1 minute' });
         return;
     }
-    const { type, session_id, tool_name, tool_input, tool_response, ts, cwd, transcript_path, source } = req.body;
+    const { type, session_id, tool_name, tool_input, tool_response, ts, cwd, transcript_path, source: rawSource } = req.body;
     if (!session_id || !type) {
         res.status(400).json({ error: 'Missing session_id or type' });
         return;
     }
+    const KNOWN_SOURCES = new Set(['claude-code', 'opencode', 'codex', 'amp', 'droid', 'codebuff']);
+    const source = rawSource && KNOWN_SOURCES.has(rawSource) ? rawSource : 'claude-code';
     const resolvedCwd = cwd
         ?? (transcript_path ? path_1.default.dirname(transcript_path) || undefined : undefined);
     db_1.dbOps.upsertSession({ id: session_id, cwd: resolvedCwd, started_at: ts, last_event_at: ts, source });
@@ -94,13 +142,23 @@ exports.eventsRouter.post('/event', (req, res) => {
         }
     }
     else {
+        const stopPreview = type === 'Stop'
+            ? (() => {
+                const lam = req.body.last_assistant_message;
+                if (lam && typeof lam === 'string') {
+                    const t = lam.replace(/\s+/g, ' ').trim();
+                    return t.length > 120 ? t.slice(0, 120) + '…' : t;
+                }
+                return transcript_path ? extractTextPreview(transcript_path) : undefined;
+            })()
+            : undefined;
         db_1.dbOps.insertEvent({
             session_id, type,
             tool_name: tool_name ?? undefined,
-            tool_input: tool_input ? JSON.stringify(tool_input) : undefined,
+            tool_input: tool_input ? JSON.stringify(tool_input) : (stopPreview ?? undefined),
             ts, cwd: resolvedCwd, skill_parent: skillParent, source
         });
-        (0, stream_1.broadcast)({ type: 'event', payload: { ...req.body, skill_parent: skillParent } });
+        (0, stream_1.broadcast)({ type: 'event', payload: { ...req.body, skill_parent: skillParent, ...(stopPreview ? { text_preview: stopPreview } : {}) } });
         // Stop limpia el skill activo para esta sesión
         if (type === 'Stop') {
             activeSkillBySession.delete(session_id);
@@ -108,6 +166,11 @@ exports.eventsRouter.post('/event', (req, res) => {
         }
         // Registrar Agent PreToolUse para detección de sub-sesiones
         if (type === 'PreToolUse' && tool_name === 'Agent' && resolvedCwd) {
+            const cwdCutoff = Date.now() - AGENT_CWD_TTL_MS;
+            for (const [cwd, info] of exports.lastAgentByCwd) {
+                if (info.pre_ts < cwdCutoff)
+                    exports.lastAgentByCwd.delete(cwd);
+            }
             exports.lastAgentByCwd.set(resolvedCwd, { pre_ts: ts, session_id });
         }
     }
@@ -121,6 +184,17 @@ exports.eventsRouter.post('/event', (req, res) => {
                 const projectCwd = (0, helpers_1.findProjectCwdForFile)(filePath);
                 if (projectCwd)
                     db_1.dbOps.updateSessionProject(session_id, projectCwd);
+                // Auto-declare intent for write tools when no active intent exists yet
+                if (type === 'PreToolUse' && ['Write', 'Edit'].includes(tool_name || '')) {
+                    if (!db_1.dbOps.hasActiveIntent(source, filePath)) {
+                        const conflicts = db_1.dbOps.getWriteConflicts([filePath], source);
+                        if (conflicts.length === 0) {
+                            const aid = db_1.dbOps.insertIntent(source, session_id, 'auto: ' + tool_name);
+                            db_1.dbOps.insertIntentFile(aid, filePath, 'write');
+                            (0, stream_1.broadcast)({ type: 'intent_declared', payload: { tool: source, files: [filePath], task: 'auto: ' + tool_name } });
+                        }
+                    }
+                }
             }
         }
         catch { /* ignorar errores de parsing */ }
@@ -197,12 +271,17 @@ exports.eventsRouter.post('/event', (req, res) => {
 const onCostUpdate = (sessionId, cost, source) => {
     // Ensure session row exists — sub-agent JSONLs arrive from the enricher without a
     // prior hook event (Claude Code does not fire hooks for sub-agent sessions).
-    db_1.dbOps.upsertSession({ id: sessionId, cwd: undefined, started_at: cost.firstTs ?? Date.now(), last_event_at: Date.now(), source });
+    db_1.dbOps.upsertSession({ id: sessionId, cwd: undefined, started_at: cost.firstTs ?? Date.now(), last_event_at: cost.lastTs ?? cost.firstTs ?? Date.now(), source });
     let sessionRow = db_1.dbOps.getSession(sessionId);
     // Sub-agent detection: first time we see a session, check if its firstTs falls after
     // a recent Agent PreToolUse from another session in the same CWD → tag as child.
     if (!exports.taggedSessionParents.has(sessionId) && cost.firstTs) {
         exports.taggedSessionParents.add(sessionId);
+        if (exports.taggedSessionParents.size > TAGGED_PARENTS_MAX) {
+            const arr = Array.from(exports.taggedSessionParents);
+            for (const id of arr.slice(0, arr.length >> 1))
+                exports.taggedSessionParents.delete(id);
+        }
         const cwd = sessionRow?.cwd;
         if (cwd) {
             const agentInfo = exports.lastAgentByCwd.get(cwd);
@@ -213,16 +292,44 @@ const onCostUpdate = (sessionId, cost, source) => {
     }
     const events = db_1.dbOps.getSessionEvents(sessionId);
     const report = (0, intelligence_1.analyzeSession)(events, cost.cost_usd);
-    db_1.dbOps.updateSessionCost(sessionId, cost, report.efficiencyScore, report.loops.length);
+    db_1.dbOps.updateSessionCost(sessionId, cost, report.efficiencyScore, report.loops.length, report.exactRetries, report.errorRate, report.fileChurnScore, report.seqCycleCount);
+    // ─── Predictive saturation ────────────────────────────────────────────────────
+    if (cost.context_used > 0 && cost.context_window > 0) {
+        const samples = contextSamples.get(sessionId) ?? [];
+        samples.push({ ts: Date.now(), context_used: cost.context_used });
+        if (samples.length > CONTEXT_SAMPLES_MAX)
+            samples.shift();
+        contextSamples.set(sessionId, samples);
+        const prediction = (0, intelligence_1.predictSaturation)(samples, cost.context_window);
+        if (prediction && prediction.minutesLeft <= SATURATION_WARN_MINUTES) {
+            const lastFired = saturationCooldown.get(sessionId) ?? 0;
+            if (Date.now() - lastFired >= SATURATION_COOLDOWN_MS) {
+                saturationCooldown.set(sessionId, Date.now());
+                (0, stream_1.broadcast)({
+                    type: 'saturation_warning',
+                    payload: {
+                        session_id: sessionId,
+                        minutes_left: prediction.minutesLeft,
+                        pct_per_min: prediction.pctPerMin,
+                        context_used: cost.context_used,
+                        context_window: cost.context_window,
+                    }
+                });
+            }
+        }
+    }
     const startedAt = sessionRow?.started_at ?? Date.now();
     const sessionDurationMinutes = (Date.now() - startedAt) / 60000;
     const projectedHourlyUsd = sessionDurationMinutes > 0.5
         ? cost.cost_usd / sessionDurationMinutes * 60
         : 0;
+    const sessionSource = sessionRow?.source ?? 'claude-code';
     (0, stream_1.broadcast)({
         type: 'cost_update',
         payload: {
             session_id: sessionId,
+            source: sessionSource,
+            started_at: startedAt,
             cost_usd: cost.cost_usd,
             input_tokens: cost.input_tokens,
             output_tokens: cost.output_tokens,
@@ -268,6 +375,30 @@ const onCostUpdate = (sessionId, cost, source) => {
                 outputTokens: cost.lastEntry.outputTokens,
             }
         });
+        // Semantic extraction: debounced 3s so rapid updates don't cause duplicate parses
+        const existing = semanticDebounce.get(sessionId);
+        if (existing)
+            clearTimeout(existing);
+        semanticDebounce.set(sessionId, setTimeout(async () => {
+            semanticDebounce.delete(sessionId);
+            try {
+                const filePath = await (0, claude_code_1.findJSONLForSession)(sessionId);
+                if (!filePath)
+                    return;
+                const semantic = await (0, claude_code_1.extractSemanticData)(filePath);
+                if (!semantic)
+                    return;
+                db_1.dbOps.upsertAssistantTurns(sessionId, semantic.turns);
+                const semLoops = (0, intelligence_1.analyzeSemanticLoops)(semantic.turns);
+                db_1.dbOps.updateSessionSemantic(sessionId, semantic.avg_output_chars, semantic.error_block_count, semLoops.length);
+                if (semLoops.length > 0) {
+                    (0, stream_1.broadcast)({ type: 'semantic_loop', payload: { session_id: sessionId, loops: semLoops } });
+                }
+            }
+            catch (err) {
+                console.warn('[events] Semantic extraction error:', err);
+            }
+        }, 3000));
     }
 };
 exports.onCostUpdate = onCostUpdate;

package/dist/routes/history.js

@@ -22,8 +22,10 @@ exports.historyRouter.get('/history', (_req, res) => {
         // Detectar modo desde los contadores precalculados en la query
         const hasAgent = (s.agent_count ?? 0) > 0;
         const hasSkill = (s.skill_count ?? 0) > 0;
-        const mode = hasAgent && hasSkill ? 'agentes+skills'
-            : hasAgent ? 'agentes' : hasSkill ? 'skills' : 'directo';
+        const isSubAgent = s.parent_session_id != null;
+        const mode = isSubAgent ? 'sub-agente'
+            : hasAgent && hasSkill ? 'agentes+skills'
+                : hasAgent ? 'agentes' : hasSkill ? 'skills' : 'directo';
         // Git info cacheada para este proyecto
         const gitInfo = s.project_path ? (0, projects_cache_1.getCachedGitInfo)(s.project_path) : null;
         byDate.get(date).push({
@@ -45,7 +47,9 @@ exports.historyRouter.get('/history', (_req, res) => {
                 return [];
             } })() : [],
             mode,
+            source: s.source ?? 'claude-code',
             ai_summary: s.ai_summary ?? null,
+            is_sub_agent: isSubAgent,
             git_branch: gitInfo?.branch ?? null,
             git_dirty: gitInfo?.dirty ?? false,
             git_ahead: gitInfo?.ahead ?? 0,

package/dist/routes/intents.d.ts

@@ -0,0 +1 @@
+export declare const intentsRouter: import("express-serve-static-core").Router;