agentacta 2026.3.12 → 2026.3.27

package/README.md

@@ -32,12 +32,15 @@ AgentActa gives you one place to inspect the full trail.
 
 - 🔍 Full-text search across messages, tool calls, and results
 - 📋 Session browser with summaries, token breakdowns, and model info
+- 🧭 Project-scoped session filtering with per-event attribution
+- 🤖 Clear Codex run visibility for direct and Symphony-origin sessions
 - 📅 Timeline view with live updates for today
 - 📁 File activity across all indexed sessions
 - 🌗 Light and dark themes
 - 📊 Stats for sessions, messages, tools, and tokens
 - ⚡ Live indexing via file watching
-- 📱 Mobile-friendly UI
+- 📱 Mobile-optimized UI with floating navigation
+- 🏥 Session health scoring — reliability scores, issue detection, and per-signal breakdowns
 - 💡 Search suggestions based on real data
 - ⌨️ Command palette (⌘K / Ctrl+K) for quick navigation
 - 🎨 Theme settings (system, light, dark, OLED)
@@ -80,12 +83,22 @@ Suggestions come from your own dataset: top tools, common topics, frequently tou
 
 Browse indexed sessions with auto-generated summaries, token splits (input/output), and model details. Click into any session to see the full event history.
 
-Session types get tagged so noisy categories are easier to spot (cron, sub-agent, heartbeat).
+Session detail view supports project-scoped filtering, so mixed-project sessions can be narrowed down without losing the full underlying transcript. The Initial Prompt jump still resolves from full session context even when a project filter is active.
+
+Session types get tagged so noisy categories are easier to spot (cron, sub-agent, heartbeat). Codex-backed work is also distinguished more clearly, including direct Codex runs and Symphony-origin Codex sessions.
 
 ### Timeline
 
 Pick a date, see everything that happened, newest first. Today's view updates live as new events come in.
 
+### Insights
+
+The Insights tab surfaces session health across your entire history.
+
+It tracks five issue signals — repeated tool loops, sessions that produced no output, high error rates, vague instructions, and incomplete sessions. Each signal is severity-scaled so scores reflect how bad the problem actually was, not just whether it occurred.
+
+The reliability score (0–100) is the inverse of the confusion score: higher means the agent completed work cleanly. The issue rate shows what percentage of possible signal types were detected in a session.
+
 ### File Activity
 
 See what files were touched, how often, and by which sessions.
@@ -163,6 +176,7 @@ Default config (auto-generated on first run — session directories are detected
 | `GET /api/timeline/stream?after=<ts>` | SSE stream for live timeline updates |
 | `POST /api/maintenance` | VACUUM + WAL checkpoint (returns size before/after) |
 | `GET /api/health` | Server status, version, uptime, session count |
+| `GET /api/insights` | Session health summary — reliability scores, issue counts, top flagged sessions |
 | `GET /api/export/search?q=<query>&format=md` | Export search results |
 
 ### Context API

package/config.js

@@ -57,6 +57,8 @@ function loadConfig() {
     }
   }
 
+  // In demo mode, ignore file-based sessionsPath so live data doesn't bleed in
+  if (process.env.AGENTACTA_DEMO_MODE) delete fileConfig.sessionsPath;
   const config = { ...DEFAULTS, ...fileConfig };
 
   // Env var overrides (highest priority)

package/db.js

@@ -103,6 +103,18 @@ function init(dbPath) {
     );
 
     CREATE INDEX IF NOT EXISTS idx_archive_session ON archive(session_id);
+
+    CREATE TABLE IF NOT EXISTS session_insights (
+      session_id TEXT PRIMARY KEY,
+      signals TEXT,
+      confusion_score INTEGER DEFAULT 0,
+      flagged INTEGER DEFAULT 0,
+      computed_at TEXT,
+      FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_insights_flagged ON session_insights(flagged);
+    CREATE INDEX IF NOT EXISTS idx_insights_score ON session_insights(confusion_score DESC);
   `);
 
   // Add columns if missing (migration)

package/delta-attribution-context.js

@@ -0,0 +1,57 @@
+'use strict';
+
+function extractCallBaseId(id) {
+  if (!id) return '';
+  return String(id).replace(/:(call|result)$/, '');
+}
+
+function loadDeltaAttributionContext(db, sessionId, rows) {
+  if (!db || !Array.isArray(rows) || !rows.length) return [];
+
+  const ordered = [...rows].sort((a, b) => {
+    const ta = Date.parse(a?.timestamp || 0) || 0;
+    const tb = Date.parse(b?.timestamp || 0) || 0;
+    if (ta !== tb) return ta - tb;
+    return String(a?.id || '').localeCompare(String(b?.id || ''));
+  });
+
+  const first = ordered[0];
+  const firstTs = first?.timestamp || '1970-01-01T00:00:00.000Z';
+  const firstId = first?.id || '';
+  const neighborhoodRows = db.prepare(
+    `SELECT * FROM events
+     WHERE session_id = ?
+       AND (timestamp < ? OR (timestamp = ? AND id < ?))
+     ORDER BY timestamp DESC, id DESC
+     LIMIT 12`
+  ).all(sessionId, firstTs, firstTs, firstId).reverse();
+
+  const callIds = [...new Set(
+    rows
+      .filter(row => row && row.type === 'tool_result')
+      .map(row => extractCallBaseId(row.id))
+      .filter(Boolean)
+      .map(base => `${base}:call`)
+  )];
+
+  if (!callIds.length) return neighborhoodRows;
+
+  const placeholders = callIds.map(() => '?').join(',');
+  const linkedCallRows = db.prepare(
+    `SELECT * FROM events
+     WHERE session_id = ?
+       AND type = 'tool_call'
+       AND id IN (${placeholders})`
+  ).all(sessionId, ...callIds);
+
+  const merged = [];
+  const seen = new Set();
+  for (const row of [...neighborhoodRows, ...linkedCallRows]) {
+    if (!row || !row.id || seen.has(row.id)) continue;
+    seen.add(row.id);
+    merged.push(row);
+  }
+  return merged;
+}
+
+module.exports = { loadDeltaAttributionContext };

package/index.js

@@ -20,12 +20,16 @@ if (process.argv.includes('--demo')) {
   }
   process.env.AGENTACTA_SESSIONS_PATH = demoDir;
   process.env.AGENTACTA_DB_PATH = path.join(demoDir, 'demo.db');
+  process.env.AGENTACTA_DEMO_MODE = '1'; // signal to config.js to skip file-based sessionsPath
   console.log(`Demo mode: using sessions from ${demoDir}`);
 }
 
 const { loadConfig } = require('./config');
 const { open, init, createStmts } = require('./db');
-const { discoverSessionDirs, indexFile } = require('./indexer');
+const { discoverSessionDirs, listJsonlFiles, indexFile } = require('./indexer');
+const { attributeSessionEvents, attributeEventDelta } = require('./project-attribution');
+const { loadDeltaAttributionContext } = require('./delta-attribution-context');
+const { analyzeSession, analyzeAll, getInsightsSummary } = require('./insights');
 
 const config = loadConfig();
 const PORT = config.port;
@@ -154,26 +158,68 @@ const sessionDirs = discoverSessionDirs(config);
 
 // Initial indexing pass
 for (const dir of sessionDirs) {
-  const files = fs.readdirSync(dir.path).filter(f => f.endsWith('.jsonl'));
-  for (const file of files) {
+  const files = listJsonlFiles(dir.path, !!dir.recursive);
+  for (const filePath of files) {
     try {
-      const result = indexFile(db, path.join(dir.path, file), dir.agent, stmts, ARCHIVE_MODE);
-      if (!result.skipped) console.log(`Indexed: ${file} (${dir.agent})`);
+      const result = indexFile(db, filePath, dir.agent, stmts, ARCHIVE_MODE, config);
+      if (!result.skipped) console.log(`Indexed: ${path.basename(filePath)} (${dir.agent})`);
     } catch (err) {
-      console.error(`Error indexing ${file}:`, err.message);
+      console.error(`Error indexing ${path.basename(filePath)}:`, err.message);
     }
   }
 }
 
+// Compute insights for all indexed sessions
+try {
+  analyzeAll(db);
+  console.log('Insights computed for all sessions');
+} catch (err) {
+  console.error('Error computing insights:', err.message);
+}
+
 console.log(`Watching ${sessionDirs.length} session directories`);
 
 // Debounce map: filePath -> timeout handle
 const _reindexTimers = new Map();
 const REINDEX_DEBOUNCE_MS = 2000;
+const RECURSIVE_RESCAN_MS = 15000;
+
+function reindexRecursiveDir(dir) {
+  try {
+    const files = listJsonlFiles(dir.path, true);
+    let changed = 0;
+    const upsert = db.prepare('INSERT OR REPLACE INTO session_insights (session_id, signals, confusion_score, flagged, computed_at) VALUES (?, ?, ?, ?, ?)');
+    for (const filePath of files) {
+      const result = indexFile(db, filePath, dir.agent, stmts, ARCHIVE_MODE, config);
+      if (!result.skipped) {
+        changed++;
+        if (result.sessionId) {
+          try {
+            const insight = analyzeSession(db, result.sessionId);
+            if (insight) upsert.run(insight.session_id, JSON.stringify(insight.signals), insight.confusion_score, insight.flagged ? 1 : 0, insight.computed_at);
+          } catch {}
+          sseEmitter.emit('session-update', result.sessionId);
+        }
+      }
+    }
+    if (changed > 0) console.log(`Live re-indexed ${changed} files (${dir.agent})`);
+  } catch (err) {
+    console.error(`Error rescanning ${dir.path}:`, err.message);
+  }
+}
 
 for (const dir of sessionDirs) {
   try {
     fs.watch(dir.path, { persistent: false }, (eventType, filename) => {
+      if (dir.recursive) {
+        if (_reindexTimers.has(dir.path)) clearTimeout(_reindexTimers.get(dir.path));
+        _reindexTimers.set(dir.path, setTimeout(() => {
+          _reindexTimers.delete(dir.path);
+          reindexRecursiveDir(dir);
+        }, REINDEX_DEBOUNCE_MS));
+        return;
+      }
+
       if (!filename || !filename.endsWith('.jsonl')) return;
       const filePath = path.join(dir.path, filename);
       if (!fs.existsSync(filePath)) return;
@@ -183,10 +229,13 @@ for (const dir of sessionDirs) {
       _reindexTimers.set(filePath, setTimeout(() => {
         _reindexTimers.delete(filePath);
         try {
-          const result = indexFile(db, filePath, dir.agent, stmts, ARCHIVE_MODE);
+          const result = indexFile(db, filePath, dir.agent, stmts, ARCHIVE_MODE, config);
           if (!result.skipped) {
             console.log(`Live re-indexed: ${filename} (${dir.agent})`);
-            if (result.sessionId) sseEmitter.emit('session-update', result.sessionId);
+            if (result.sessionId) {
+              try { analyzeSession(db, result.sessionId); const upsert = db.prepare('INSERT OR REPLACE INTO session_insights (session_id, signals, confusion_score, flagged, computed_at) VALUES (?, ?, ?, ?, ?)'); const insight = analyzeSession(db, result.sessionId); if (insight) upsert.run(insight.session_id, JSON.stringify(insight.signals), insight.confusion_score, insight.flagged ? 1 : 0, insight.computed_at); } catch {}
+              sseEmitter.emit('session-update', result.sessionId);
+            }
           }
         } catch (err) {
           console.error(`Error re-indexing ${filename}:`, err.message);
@@ -194,6 +243,10 @@ for (const dir of sessionDirs) {
       }, REINDEX_DEBOUNCE_MS));
     });
     console.log(`  Watching: ${dir.path}`);
+    if (dir.recursive) {
+      const timer = setInterval(() => reindexRecursiveDir(dir), RECURSIVE_RESCAN_MS);
+      timer.unref?.();
+    }
   } catch (err) {
     console.error(`  Failed to watch ${dir.path}:`, err.message);
   }
@@ -206,6 +259,7 @@ const server = http.createServer((req, res) => {
     if (pathname === '/api/reindex') {
       const { indexAll } = require('./indexer');
       const result = indexAll(db, config);
+      try { analyzeAll(db); } catch (e) { console.error('Insights recompute error:', e.message); }
       return json(res, { ok: true, sessions: result.sessions, events: result.events });
     }
 
@@ -293,7 +347,7 @@ const server = http.createServer((req, res) => {
 
     else if (pathname.match(/^\/api\/sessions\/[^/]+\/events$/)) {
       const id = pathname.split('/')[3];
-      const session = db.prepare('SELECT id FROM sessions WHERE id = ?').get(id);
+      const session = db.prepare('SELECT * FROM sessions WHERE id = ?').get(id);
       if (!session) return json(res, { error: 'Not found' }, 404);
 
       const after = query.after || '1970-01-01T00:00:00.000Z';
@@ -306,12 +360,14 @@ const server = http.createServer((req, res) => {
          ORDER BY timestamp ASC, id ASC
          LIMIT ?`
       ).all(id, after, after, afterId, limit);
-      json(res, { events: rows, after, afterId, count: rows.length });
+      const contextRows = loadDeltaAttributionContext(db, id, rows);
+      const events = attributeEventDelta(session, rows, contextRows);
+      json(res, { events, after, afterId, count: events.length });
     }
 
     else if (pathname.match(/^\/api\/sessions\/[^/]+\/stream$/)) {
       const id = pathname.split('/')[3];
-      const session = db.prepare('SELECT id FROM sessions WHERE id = ?').get(id);
+      const session = db.prepare('SELECT * FROM sessions WHERE id = ?').get(id);
       if (!session) return json(res, { error: 'Not found' }, 404);
 
       res.writeHead(200, {
@@ -331,8 +387,10 @@ const server = http.createServer((req, res) => {
             'SELECT * FROM events WHERE session_id = ? AND timestamp > ? ORDER BY timestamp ASC'
           ).all(id, lastTs);
           if (rows.length) {
+            const contextRows = loadDeltaAttributionContext(db, id, rows);
+            const attributedRows = attributeEventDelta(session, rows, contextRows);
             lastTs = rows[rows.length - 1].timestamp;
-            res.write(`id: ${lastTs}\ndata: ${JSON.stringify(rows)}\n\n`);
+            res.write(`id: ${lastTs}\ndata: ${JSON.stringify(attributedRows)}\n\n`);
           }
         } catch (err) {
           console.error('SSE query error:', err.message);
@@ -356,8 +414,9 @@ const server = http.createServer((req, res) => {
       if (!session) { json(res, { error: 'Not found' }, 404); }
       else {
         const events = db.prepare('SELECT * FROM events WHERE session_id = ? ORDER BY timestamp DESC').all(id);
+        const attributed = attributeSessionEvents(session, events);
         const hasArchive = ARCHIVE_MODE && db.prepare('SELECT COUNT(*) as c FROM archive WHERE session_id = ?').get(id).c > 0;
-        json(res, { session, events, hasArchive });
+        json(res, { session, events: attributed.events, projectFilters: attributed.projectFilters, hasArchive });
       }
     }
     else if (pathname.match(/^\/api\/archive\/session\/[^/]+$/)) {
@@ -726,6 +785,27 @@ const server = http.createServer((req, res) => {
       `).all(fp);
       json(res, { file: fp, sessions: rows });
     }
+    else if (pathname === '/api/insights') {
+      const summary = getInsightsSummary(db);
+      return json(res, summary);
+    }
+    else if (pathname.match(/^\/api\/insights\/session\/[^/]+$/)) {
+      const id = pathname.split('/')[4];
+      const row = db.prepare('SELECT * FROM session_insights WHERE session_id = ?').get(id);
+      if (!row) {
+        // Compute on-the-fly if not yet analyzed
+        const result = analyzeSession(db, id);
+        if (!result) return json(res, { error: 'Session not found' }, 404);
+        return json(res, result);
+      }
+      return json(res, {
+        session_id: row.session_id,
+        signals: JSON.parse(row.signals || '[]'),
+        confusion_score: row.confusion_score,
+        flagged: !!row.flagged,
+        computed_at: row.computed_at
+      });
+    }
     else if (!serveStatic(req, res)) {
       const index = path.join(PUBLIC, 'index.html');
       if (fs.existsSync(index)) {

package/indexer.js

@@ -28,14 +28,26 @@ function listJsonlFiles(baseDir, recursive = false) {
 function discoverSessionDirs(config) {
   const dirs = [];
   const home = process.env.HOME;
+  const codexSessionsPath = path.join(home, '.codex/sessions');
+
+  function normalizedPath(p) {
+    return path.resolve(p).replace(/[\\\/]+$/, '');
+  }
+
+  function hasDir(targetPath) {
+    const wanted = normalizedPath(targetPath);
+    return dirs.some(d => normalizedPath(d.path) === wanted);
+  }
 
   // Expand a single path into session dirs, handling Claude Code's per-project structure
   function expandPath(p) {
     if (!fs.existsSync(p)) return;
     const stat = fs.statSync(p);
     if (!stat.isDirectory()) return;
+    const normalized = normalizedPath(p);
+    const normalizedCodex = normalizedPath(codexSessionsPath);
     // Claude Code: ~/.claude/projects contains per-project subdirs with JSONL files
-    if (p.replace(/\/$/, '').endsWith('/.claude/projects')) {
+    if (normalized.endsWith('/.claude/projects')) {
       for (const proj of fs.readdirSync(p)) {
         const projDir = path.join(p, proj);
         if (fs.statSync(projDir).isDirectory()) {
@@ -43,6 +55,9 @@ function discoverSessionDirs(config) {
           if (hasJsonl) dirs.push({ path: projDir, agent: 'claude-code' });
         }
       }
+    } else if (normalized === normalizedCodex) {
+      // Codex CLI stores nested YYYY/MM/DD directories and must be recursive.
+      dirs.push({ path: p, agent: 'codex-cli', recursive: true });
     } else {
       dirs.push({ path: p, agent: path.basename(path.dirname(p)) });
     }
@@ -55,6 +70,10 @@ function discoverSessionDirs(config) {
       ? sessionsOverride
       : sessionsOverride.split(':');
     overridePaths.forEach(expandPath);
+    // Keep direct Codex visibility even when custom overrides omit it.
+    if (fs.existsSync(codexSessionsPath) && fs.statSync(codexSessionsPath).isDirectory() && !hasDir(codexSessionsPath)) {
+      dirs.push({ path: codexSessionsPath, agent: 'codex-cli', recursive: true });
+    }
     if (dirs.length) return dirs;
   }
 
@@ -73,7 +92,7 @@ function discoverSessionDirs(config) {
   expandPath(path.join(home, '.claude/projects'));
 
   // Scan ~/.codex/sessions recursively (Codex CLI stores nested YYYY/MM/DD/*.jsonl)
-  const codexSessions = path.join(home, '.codex/sessions');
+  const codexSessions = codexSessionsPath;
   if (fs.existsSync(codexSessions) && fs.statSync(codexSessions).isDirectory()) {
     dirs.push({ path: codexSessions, agent: 'codex-cli', recursive: true });
   }
@@ -226,6 +245,8 @@ function extractProjectFromPath(filePath, config) {
 
   // Common repo location: ~/Developer/<repo>/...
   if (parts[0] === 'Developer' && parts[1]) return aliasProject(parts[1], config);
+  // Symphony worktrees: ~/symphony-workspaces/<issue>/...
+  if (parts[0] === 'symphony-workspaces' && parts[1]) return aliasProject(parts[1], config);
 
   // OpenClaw workspace and agent stores
   if (parts[0] === '.openclaw' && parts[1] === 'workspace') return aliasProject('workspace', config);
@@ -274,6 +295,7 @@ function indexFile(db, filePath, agentName, stmts, archiveMode, config) {
   let firstMessageTimestamp = null;
   let codexProvider = null;
   let codexSource = null;
+  let codexOriginator = null;
   let sawSnapshotRecord = false;
   let sawNonSnapshotRecord = false;
 
@@ -321,7 +343,7 @@ function indexFile(db, filePath, agentName, stmts, archiveMode, config) {
     const meta = firstLine.payload || {};
     sessionId = meta.id || path.basename(filePath, '.jsonl');
     sessionStart = meta.timestamp || firstLine.timestamp || new Date().toISOString();
-    sessionType = 'codex-cli';
+    sessionType = 'codex-direct';
     agent = 'codex-cli';
     if (meta.model) {
       model = meta.model;
@@ -329,6 +351,8 @@ function indexFile(db, filePath, agentName, stmts, archiveMode, config) {
     }
     codexProvider = meta.model_provider || null;
     codexSource = meta.source || null;
+    codexOriginator = meta.originator || null;
+    if (codexOriginator && codexOriginator.includes('symphony')) sessionType = 'codex-symphony';
   } else {
     return { skipped: true };
   }
@@ -363,6 +387,8 @@ function indexFile(db, filePath, agentName, stmts, archiveMode, config) {
         }
         if (meta.model_provider) codexProvider = meta.model_provider;
         if (meta.source) codexSource = meta.source;
+        if (meta.originator) codexOriginator = meta.originator;
+        if (codexOriginator && codexOriginator.includes('symphony')) sessionType = 'codex-symphony';
         if (meta.model_provider && !model) model = meta.model_provider;
         continue;
       }
@@ -567,6 +593,7 @@ function indexFile(db, filePath, agentName, stmts, archiveMode, config) {
       const parts = ['Codex CLI session'];
       if (codexProvider) parts.push(`provider=${codexProvider}`);
       if (codexSource) parts.push(`source=${codexSource}`);
+      if (codexOriginator) parts.push(`originator=${codexOriginator}`);
       summary = parts.join(' · ');
     } else {
       summary = 'Heartbeat session';
@@ -730,6 +757,6 @@ function indexAll(db, config) {
   return { sessions: stats.sessions, events: evStats.events, newSessions: totalSessions };
 }
 
-module.exports = { discoverSessionDirs, indexFile, indexAll };
+module.exports = { discoverSessionDirs, listJsonlFiles, indexFile, indexAll };
 
 if (require.main === module) run();