@statforge/claudestat 1.6.1 → 1.8.0

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/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/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;

package/dist/routes/intents.js

@@ -0,0 +1,155 @@
+"use strict";
+// ─── /api/intent/* — Multi-tool file coordination ─────────────────────────────
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.intentsRouter = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = __importDefault(require("fs"));
+const express_1 = require("express");
+const db_1 = require("../db");
+const stream_1 = require("./stream");
+function computeHash(filePath) {
+    try {
+        if (!fs_1.default.existsSync(filePath))
+            return null;
+        const content = fs_1.default.readFileSync(filePath);
+        return crypto_1.default.createHash('sha256').update(content).digest('hex');
+    }
+    catch {
+        return null;
+    }
+}
+// Middleware para validar required `id` en body
+const validateId = (req, res, next) => {
+    const { id } = req.body;
+    if (!id) {
+        res.status(400).json({ error: 'id is required' });
+        return;
+    }
+    next();
+};
+exports.intentsRouter = (0, express_1.Router)();
+// POST /api/intent/declare
+// Body: { tool, session_id, task_desc?, files: [{ file_path, operation?, line_start?, line_end? }] }
+// Returns: { id, status: 'acquired'|'blocked', blocked_by?, files? }
+exports.intentsRouter.post('/api/intent/declare', (req, res) => {
+    const { tool, session_id, task_desc, files } = req.body;
+    if (!tool || !session_id || !Array.isArray(files) || files.length === 0) {
+        res.status(400).json({ error: 'tool, session_id and files[] are required' });
+        return;
+    }
+    const writeFiles = files.filter(f => !f.operation || f.operation === 'write');
+    const writePaths = writeFiles
+        .map(f => f.file_path)
+        .filter((p) => typeof p === 'string' && p.startsWith('/'));
+    if (writePaths.length < writeFiles.length) {
+        res.status(400).json({ error: 'file_path must be an absolute path (starting with /)' });
+        return;
+    }
+    // Check conflicts from other tools
+    const conflicts = writePaths.length > 0 ? db_1.dbOps.getWriteConflicts(writePaths, tool) : [];
+    if (conflicts.length > 0) {
+        const blockedBy = conflicts[0].tool;
+        (0, stream_1.broadcast)({ type: 'intent_conflict', payload: {
+                files: conflicts.map(c => c.file_path),
+                locked_by: blockedBy,
+                session_id: conflicts[0].session_id,
+                task: conflicts[0].task_desc,
+            } });
+        res.json({
+            id: null, status: 'blocked',
+            blocked_by: blockedBy,
+            files: conflicts.map(c => c.file_path),
+        });
+        return;
+    }
+    // Acquire
+    const id = db_1.dbOps.insertIntent(tool, session_id, task_desc);
+    const filePaths = [];
+    for (const f of files) {
+        if (f.file_path) {
+            db_1.dbOps.insertIntentFile(id, f.file_path, f.operation ?? 'write', f.line_start, f.line_end);
+            filePaths.push(f.file_path);
+        }
+    }
+    (0, stream_1.broadcast)({ type: 'intent_declared', payload: { tool, files: filePaths, task: task_desc } });
+    res.json({ id, status: 'acquired' });
+});
+// POST /api/intent/done
+// Body: { id }
+exports.intentsRouter.post('/api/intent/done', validateId, (req, res) => {
+    const { id } = req.body;
+    const intent = db_1.dbOps.getIntent(id);
+    const files = db_1.dbOps.getIntentFiles(id);
+    db_1.dbOps.releaseIntent(id);
+    for (const f of files) {
+        (0, stream_1.broadcast)({ type: 'intent_released', payload: { file: f.file_path, operation: f.operation, tool: intent?.tool } });
+    }
+    res.json({ ok: true });
+});
+// POST /api/intent/heartbeat
+// Body: { id }
+exports.intentsRouter.post('/api/intent/heartbeat', validateId, (req, res) => {
+    const { id } = req.body;
+    db_1.dbOps.heartbeatIntent(id);
+    res.json({ ok: true });
+});
+// GET /api/intent/status?files=path1,path2
+exports.intentsRouter.get('/api/intent/status', (req, res) => {
+    const raw = req.query.files;
+    const tool = req.query.exclude_tool;
+    const paths = raw ? raw.split(',').map(p => p.trim()).filter(Boolean) : [];
+    if (paths.length === 0) {
+        res.json({ conflicts: [] });
+        return;
+    }
+    const conflicts = db_1.dbOps.getWriteConflicts(paths, tool ?? '');
+    res.json({
+        conflicts: conflicts.map(c => ({
+            file: c.file_path,
+            locked_by: c.tool,
+            task: c.task_desc,
+            since: c.acquired_at,
+        })),
+    });
+});
+// POST /api/intent/check-hash — verify files haven't changed since last known hash
+// Body: { files: [{ file_path: string, hash: string }] }
+// Returns: { safe: boolean, changed: Array<{ file_path, current_hash }> }
+exports.intentsRouter.post('/api/intent/check-hash', (req, res) => {
+    const { files } = req.body;
+    if (!Array.isArray(files) || files.length === 0) {
+        res.status(400).json({ error: 'files[] is required' });
+        return;
+    }
+    const changed = [];
+    for (const f of files) {
+        const current = computeHash(f.file_path);
+        if (current && f.hash && current !== f.hash) {
+            changed.push({ file_path: f.file_path, current_hash: current });
+        }
+    }
+    res.json({ safe: changed.length === 0, changed });
+});
+// GET /api/intent/hashes?files=/abs/path1,/abs/path2
+// Returns current SHA256 hashes for the given file paths
+exports.intentsRouter.get('/api/intent/hashes', (req, res) => {
+    const raw = req.query.files;
+    const paths = raw ? raw.split(',').map(p => p.trim()).filter((p) => !!p && p.startsWith('/')) : [];
+    if (paths.length === 0) {
+        res.status(400).json({ error: 'files query param required (comma-separated absolute paths)' });
+        return;
+    }
+    const hashes = {};
+    for (const p of paths) {
+        hashes[p] = computeHash(p);
+    }
+    res.json({ hashes });
+});
+// GET /api/intent/active — list all currently active intents
+exports.intentsRouter.get('/api/intent/active', (_req, res) => {
+    const intents = db_1.dbOps.getActiveIntents();
+    res.json({ intents });
+});

package/dist/routes/misc.js

@@ -22,6 +22,7 @@ const projects_1 = require("./projects");
 const session_state_1 = require("../session-state");
 const stream_1 = require("./stream");
 const paths_1 = require("../paths");
+const opencode_1 = require("../watchers/opencode");
 const cost_projector_1 = require("../cost-projector");
 exports.miscRouter = (0, express_1.Router)();
 // ─── GET /git?path=... — git info para un proyecto ────────────────────────────
@@ -61,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 ──────────────────────────────────
@@ -134,7 +136,7 @@ exports.miscRouter.get('/claude-stats', (_req, res) => {
 });
 // ─── GET /api/active-sessions — fuentes activas en los últimos 5 min ──────────
 exports.miscRouter.get('/api/active-sessions', (_req, res) => {
-    const cutoff = Date.now() - 5 * 60 * 1000;
+    const cutoff = Date.now() - 24 * 60 * 60 * 1000;
     const sessions = db_1.dbOps.getAllSessions();
     const bySource = new Map();
     for (const s of sessions) {
@@ -153,10 +155,16 @@ exports.miscRouter.get('/api/active-sessions', (_req, res) => {
                 output_tokens: s.total_output_tokens ?? 0,
                 cache_read: s.total_cache_read ?? 0,
                 cache_creation: s.total_cache_creation ?? 0,
+                project: s.project_path ?? s.cwd ?? null,
             });
         }
     }
-    const result = Array.from(bySource.entries()).map(([source, v]) => ({ source, ...v }));
+    const KNOWN_SOURCES = new Set(['claude-code', 'opencode', 'codex', 'amp', 'droid', 'codebuff']);
+    let result = Array.from(bySource.entries())
+        .filter(([source]) => KNOWN_SOURCES.has(source))
+        .map(([source, v]) => ({ source, ...v }));
+    // OpenCode: filter out archived sessions (user closed the tool)
+    result = result.filter(s => s.source !== 'opencode' || !(0, opencode_1.isSessionArchived)(s.sessionId));
     res.json(result);
 });
 // ─── GET /system-config — mapa completo del setup de Claude ──────────────────
@@ -262,7 +270,74 @@ exports.miscRouter.get('/system-config', (_req, res) => {
         const modeDistribution = db_1.dbOps.getModeDistribution(7);
         // 6. Config de claudestat
         const claudestatConfig = (0, config_1.readConfig)();
-        _systemConfigCache = { hooks, agents, workflows, skills, contextFiles, memoryFiles, modeDistribution, claudestatConfig };
+        // ─── 7. OpenCode data ────────────────────────────────────────────────────────
+        const opencodeDir = (0, paths_1.getOpencodeDir)();
+        let opencodeConfig = null;
+        try {
+            opencodeConfig = JSON.parse(fs_1.default.readFileSync(path_1.default.join(opencodeDir, 'opencode.json'), 'utf-8'));
+        }
+        catch { }
+        let opencodeAgentsMd = null;
+        try {
+            const p = path_1.default.join(opencodeDir, 'AGENTS.md');
+            const content = fs_1.default.readFileSync(p, 'utf-8');
+            opencodeAgentsMd = { lines: content.split('\n').length, sizeKb: Math.round(Buffer.byteLength(content, 'utf-8') / 1024 * 10) / 10 };
+        }
+        catch { }
+        let opencodeSkills = [];
+        try {
+            const skillsDir = path_1.default.join(opencodeDir, 'skills');
+            for (const entry of fs_1.default.readdirSync(skillsDir, { withFileTypes: true })) {
+                if (entry.isDirectory()) {
+                    const skillMd = path_1.default.join(skillsDir, entry.name, 'SKILL.md');
+                    try {
+                        const content = fs_1.default.readFileSync(skillMd, 'utf-8');
+                        const lines = content.split('\n').length;
+                        const description = content.match(/^description:\s*(.+)$/m)?.[1]?.trim() ?? '';
+                        opencodeSkills.push({ name: entry.name, description, lines });
+                    }
+                    catch { }
+                }
+            }
+        }
+        catch { }
+        let opencodeAgents = [];
+        try {
+            const agentsDir = path_1.default.join(opencodeDir, 'agents');
+            opencodeAgents = fs_1.default.readdirSync(agentsDir).filter(f => f.endsWith('.md'));
+        }
+        catch { }
+        let opencodeProjects = 0;
+        try {
+            const raw = JSON.parse(fs_1.default.readFileSync(path_1.default.join(opencodeDir, 'projects.json'), 'utf-8'));
+            opencodeProjects = Object.keys(raw.projects ?? {}).length;
+        }
+        catch { }
+        let opencodeCommands = [];
+        try {
+            const cmdsDir = path_1.default.join(opencodeDir, 'commands');
+            opencodeCommands = fs_1.default.readdirSync(cmdsDir).filter(f => f.endsWith('.md'));
+        }
+        catch { }
+        const opencodePlugins = [];
+        try {
+            const pluginsDir = path_1.default.join(opencodeDir, 'plugins');
+            opencodePlugins.push(...fs_1.default.readdirSync(pluginsDir).filter(f => f.endsWith('.ts') || f.endsWith('.js')));
+        }
+        catch { }
+        _systemConfigCache = {
+            hooks, agents, workflows, skills, contextFiles, memoryFiles,
+            modeDistribution, claudestatConfig,
+            opencode: {
+                config: opencodeConfig,
+                agentsMd: opencodeAgentsMd,
+                skills: opencodeSkills,
+                agents: opencodeAgents,
+                projects: opencodeProjects,
+                commands: opencodeCommands,
+                plugins: opencodePlugins,
+            },
+        };
         _systemConfigCacheTs = Date.now();
         res.json(_systemConfigCache);
     }
@@ -294,3 +369,74 @@ exports.miscRouter.put('/config', (req, res) => {
 exports.miscRouter.get('/cost-projection', (_req, res) => {
     res.json((0, cost_projector_1.computeProjection)(90));
 });
+// ─── GET /coordination/status — detección automática de herramienta activa ───
+exports.miscRouter.get('/coordination/status', (req, res) => {
+    const project = req.query.project;
+    const tool = req.query.tool ?? 'unknown';
+    if (!project) {
+        res.status(400).json({ error: 'project is required' });
+        return;
+    }
+    const active = db_1.dbOps.getActiveToolsInProject(project, tool);
+    res.json({
+        other_tool_active: active.length > 0,
+        tools: active.map(r => r.source),
+        since: active.length > 0 ? Math.min(...active.map(r => r.last_event_at)) : null,
+    });
+});
+// ─── GET /tool-status — estado de cada tool (claude-code, opencode) ──────────
+const AI_COLLAB_STATUS = path_1.default.join(process.env.HOME ?? '/tmp', '.ai-collab', 'STATUS.json');
+exports.miscRouter.get('/tool-status', (_req, res) => {
+    try {
+        const raw = fs_1.default.readFileSync(AI_COLLAB_STATUS, 'utf-8');
+        res.json(JSON.parse(raw));
+    }
+    catch {
+        res.json({
+            'claude-code': { status: 'unknown', last_task: null, finished_at: null, session_id: null, waiting_for: null },
+            'opencode': { status: 'unknown', last_task: null, finished_at: null, session_id: null, waiting_for: null },
+        });
+    }
+});
+// ─── POST /tool-status — actualizar estado de un tool ────────────────────────
+exports.miscRouter.post('/tool-status', (req, res) => {
+    const { tool, status, last_task, session_id, waiting_for } = req.body;
+    if (!tool || !status) {
+        res.status(400).json({ error: 'tool and status are required' });
+        return;
+    }
+    let current = {};
+    try {
+        current = JSON.parse(fs_1.default.readFileSync(AI_COLLAB_STATUS, 'utf-8'));
+    }
+    catch { }
+    const finished_at = status === 'idle' ? Date.now() : null;
+    current[tool] = { status, last_task: last_task ?? null, finished_at, session_id: session_id ?? null, waiting_for: waiting_for ?? null };
+    try {
+        fs_1.default.mkdirSync(path_1.default.dirname(AI_COLLAB_STATUS), { recursive: true });
+        fs_1.default.writeFileSync(AI_COLLAB_STATUS, JSON.stringify(current, null, 2), 'utf-8');
+    }
+    catch (e) {
+        res.status(500).json({ error: String(e) });
+        return;
+    }
+    (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: [] });
+    }
+});