agentacta 2026.3.6 → 2026.3.12-r2

package/README.md

@@ -32,6 +32,8 @@ 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
@@ -80,7 +82,9 @@ 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
 
@@ -118,18 +122,20 @@ On first run, AgentActa creates:
 - `~/.config/agentacta/config.json`
 - or `agentacta.config.json` in current directory (if present)
 
-Default config:
+Default config (auto-generated on first run — session directories are detected automatically):
 
 ```json
 {
   "port": 4003,
   "storage": "reference",
-  "sessionsPath": null,
+  "sessionsPath": ["~/.claude/projects", "~/.openclaw/sessions"],
   "dbPath": "./agentacta.db",
   "projectAliases": {}
 }
 ```
 
+`sessionsPath` accepts a string, a colon-delimited string, or a JSON array.
+
 ### Storage modes
 
 - `reference` (default): index parsed events in SQLite, keep source JSONL on disk. Lightweight.
@@ -163,6 +169,76 @@ Default config:
 | `GET /api/health` | Server status, version, uptime, session count |
 | `GET /api/export/search?q=<query>&format=md` | Export search results |
 
+### Context API
+
+The Context API gives agents historical context before they start working. Instead of exploring a codebase from scratch, an agent can query what's happened before.
+
+| Endpoint | Description |
+|---|---|
+| `GET /api/context/file?path=<filepath>` | History for a specific file |
+| `GET /api/context/repo?path=<repo-path>` | Aggregates for a repo/project |
+| `GET /api/context/agent?name=<agent-name>` | Stats for a specific agent |
+
+**File context** — how many sessions touched this file, when it was last modified, recent change summaries, operation breakdown (reads vs edits), related files, and recent errors:
+
+```bash
+curl http://localhost:4003/api/context/file?path=/home/user/project/server.js
+```
+```json
+{
+  "file": "/home/user/project/server.js",
+  "sessionCount": 34,
+  "lastModified": "3h ago",
+  "recentChanges": ["Added OAuth state validation", "Fixed password masking"],
+  "operations": { "edit": 105, "read": 56 },
+  "relatedFiles": [{ "path": "public/app.js", "count": 28 }],
+  "recentErrors": []
+}
+```
+
+**Agent context** — total sessions, cost, average duration, most-used tools, recent work:
+
+```bash
+curl http://localhost:4003/api/context/agent?name=claude-code
+```
+```json
+{
+  "agent": "claude-code",
+  "sessionCount": 60,
+  "totalCost": 18.83,
+  "avgDuration": 288,
+  "topTools": [{ "tool": "edit", "count": 190 }, { "tool": "exec", "count": 560 }],
+  "recentSessions": [{ "id": "...", "summary": "Added context API...", "timestamp": "..." }],
+  "successRate": 100
+}
+```
+
+**Repo context** — aggregate cost, tokens, distinct agents, most-touched files, common tools:
+
+```bash
+curl http://localhost:4003/api/context/repo?path=agentacta
+```
+
+#### Using the Context API with agents
+
+Inject context into agent prompts so new sessions start informed:
+
+```bash
+# Fetch context before starting Claude Code
+CONTEXT=$(curl -s http://localhost:4003/api/context/file?path=$(pwd)/server.js)
+claude --print "Context from previous sessions: $CONTEXT
+
+Your task: refactor the auth module"
+```
+
+Or add it to a CLAUDE.md / AGENTS.md:
+
+```markdown
+## Project Context API
+Before modifying key files, query AgentActa for history:
+curl http://localhost:4003/api/context/file?path={filepath}
+```
+
 Agent integration example:
 
 ```javascript

package/config.js

@@ -14,6 +14,12 @@ function resolveConfigFile() {
 
 const CONFIG_FILE = resolveConfigFile();
 
+const KNOWN_SESSION_DIRS = [
+  path.join(os.homedir(), '.claude', 'projects'),    // Claude Code
+  path.join(os.homedir(), '.codex', 'sessions'),     // Codex CLI
+  path.join(os.homedir(), '.openclaw', 'sessions'),  // OpenClaw
+];
+
 const DEFAULTS = {
   port: 4003,
   storage: 'reference',
@@ -22,6 +28,11 @@ const DEFAULTS = {
   projectAliases: {}
 };
 
+function detectSessionDirs() {
+  const found = KNOWN_SESSION_DIRS.filter(d => fs.existsSync(d));
+  return found.length > 0 ? found : null;
+}
+
 function loadConfig() {
   let fileConfig = {};
 
@@ -32,11 +43,18 @@ function loadConfig() {
       console.error(`Warning: Could not parse ${CONFIG_FILE}:`, err.message);
     }
   } else {
-    // First-run: create default config in XDG location
+    // First-run: create default config with auto-detected session dirs
+    const detected = detectSessionDirs();
+    const firstRunDefaults = { ...DEFAULTS, sessionsPath: detected };
     const dir = path.dirname(CONFIG_FILE);
     if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(CONFIG_FILE, JSON.stringify(DEFAULTS, null, 2) + '\n');
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(firstRunDefaults, null, 2) + '\n');
+    // Apply to in-memory config so this run also benefits
+    fileConfig = firstRunDefaults;
     console.log(`Created default config: ${CONFIG_FILE}`);
+    if (detected) {
+      console.log(`Auto-detected session directories:\n${detected.map(d => `  - ${d}`).join('\n')}`);
+    }
   }
 
   const config = { ...DEFAULTS, ...fileConfig };

package/index.js

@@ -25,7 +25,9 @@ if (process.argv.includes('--demo')) {
 
 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 config = loadConfig();
 const PORT = config.port;
@@ -105,6 +107,15 @@ function getDbSize() {
   }
 }
 
+function relativeTime(ts) {
+  if (!ts) return null;
+  const diff = Math.floor((Date.now() - new Date(ts).getTime()) / 1000);
+  if (diff < 60) return 'just now';
+  if (diff < 3600) return `${Math.floor(diff / 60)}m ago`;
+  if (diff < 86400) return `${Math.floor(diff / 3600)}h ago`;
+  return `${Math.floor(diff / 86400)}d ago`;
+}
+
 function normalizeAgentLabel(agent) {
   if (!agent) return agent;
   if (agent === 'main') return 'openclaw-main';
@@ -145,13 +156,13 @@ 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);
     }
   }
 }
@@ -161,10 +172,37 @@ 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;
+    for (const filePath of files) {
+      const result = indexFile(db, filePath, dir.agent, stmts, ARCHIVE_MODE, config);
+      if (!result.skipped) {
+        changed++;
+        if (result.sessionId) 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;
@@ -174,7 +212,7 @@ 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);
@@ -185,6 +223,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);
   }
@@ -284,7 +326,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';
@@ -297,12 +339,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, {
@@ -322,8 +366,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);
@@ -347,8 +393,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\/[^/]+$/)) {
@@ -514,6 +561,182 @@ const server = http.createServer((req, res) => {
       const sizeAfter = getDbSize();
       json(res, { ok: true, sizeBefore, sizeAfter });
     }
+    // --- Context API ---
+    else if (pathname === '/api/context/file') {
+      const fp = query.path || '';
+      if (!fp) return json(res, { error: 'path parameter is required' }, 400);
+
+      const sessionCount = db.prepare(
+        'SELECT COUNT(DISTINCT session_id) as c FROM file_activity WHERE file_path = ?'
+      ).get(fp).c;
+
+      if (sessionCount === 0) {
+        return json(res, { file: fp, sessionCount: 0, lastModified: null, recentChanges: [], operations: {}, relatedFiles: [], recentErrors: [] });
+      }
+
+      const lastTouched = db.prepare(
+        'SELECT MAX(timestamp) as t FROM file_activity WHERE file_path = ?'
+      ).get(fp).t;
+
+      const recentChanges = db.prepare(
+        `SELECT DISTINCT s.summary FROM file_activity fa
+         JOIN sessions s ON s.id = fa.session_id
+         WHERE fa.file_path = ? AND s.summary IS NOT NULL
+         ORDER BY s.start_time DESC LIMIT 5`
+      ).all(fp).map(r => r.summary);
+
+      const opsRows = db.prepare(
+        'SELECT operation, COUNT(*) as c FROM file_activity WHERE file_path = ? GROUP BY operation'
+      ).all(fp);
+      const operations = {};
+      for (const r of opsRows) operations[r.operation] = r.c;
+
+      const relatedFiles = db.prepare(
+        `SELECT fa2.file_path, COUNT(DISTINCT fa1.session_id) as c
+         FROM file_activity fa1
+         JOIN file_activity fa2 ON fa1.session_id = fa2.session_id
+         WHERE fa1.file_path = ? AND fa2.file_path != ?
+         GROUP BY fa2.file_path
+         ORDER BY c DESC LIMIT 5`
+      ).all(fp, fp).map(r => ({ path: r.file_path, count: r.c }));
+
+      const sessionIds = db.prepare(
+        'SELECT DISTINCT session_id FROM file_activity WHERE file_path = ?'
+      ).all(fp).map(r => r.session_id);
+
+      let recentErrors = [];
+      if (sessionIds.length) {
+        const placeholders = sessionIds.map(() => '?').join(',');
+        recentErrors = db.prepare(
+          `SELECT tool_result FROM events
+           WHERE session_id IN (${placeholders})
+             AND tool_result IS NOT NULL
+             AND (tool_result LIKE '%error%' OR tool_result LIKE '%Error%' OR tool_result LIKE '%ERROR%')
+           ORDER BY timestamp DESC LIMIT 3`
+        ).all(...sessionIds).map(r => r.tool_result.slice(0, 200));
+      }
+
+      return json(res, {
+        file: fp, sessionCount,
+        lastModified: relativeTime(lastTouched),
+        recentChanges, operations, relatedFiles, recentErrors
+      });
+    }
+    else if (pathname === '/api/context/repo') {
+      const repoPath = query.path || '';
+      if (!repoPath) return json(res, { error: 'path parameter is required' }, 400);
+
+      // Find sessions matching the repo path via file_activity or initial_prompt
+      const sessionIds = db.prepare(
+        `SELECT DISTINCT session_id FROM file_activity WHERE file_path = ? OR file_path LIKE ?`
+      ).all(repoPath, repoPath + '/%').map(r => r.session_id);
+
+      const promptSessions = db.prepare(
+        `SELECT id FROM sessions WHERE initial_prompt LIKE ?`
+      ).all('%' + repoPath + '%').map(r => r.id);
+
+      const allIds = [...new Set([...sessionIds, ...promptSessions])];
+
+      if (allIds.length === 0) {
+        return json(res, { repo: repoPath, sessionCount: 0, totalCost: 0, totalTokens: 0, agents: [], topFiles: [], recentSessions: [], commonTools: [], commonErrors: [] });
+      }
+
+      const ph = allIds.map(() => '?').join(',');
+
+      const agg = db.prepare(
+        `SELECT COUNT(*) as c, SUM(total_cost) as cost, SUM(total_tokens) as tokens
+         FROM sessions WHERE id IN (${ph})`
+      ).get(...allIds);
+
+      const agents = [...new Set(
+        db.prepare(`SELECT DISTINCT agent FROM sessions WHERE id IN (${ph}) AND agent IS NOT NULL`).all(...allIds)
+          .map(r => normalizeAgentLabel(r.agent)).filter(Boolean)
+      )];
+
+      const topFiles = db.prepare(
+        `SELECT file_path, COUNT(*) as c FROM file_activity
+         WHERE session_id IN (${ph})
+         GROUP BY file_path ORDER BY c DESC LIMIT 10`
+      ).all(...allIds).map(r => ({ path: r.file_path, count: r.c }));
+
+      const recentSessions = db.prepare(
+        `SELECT id, summary, agent, start_time, end_time FROM sessions
+         WHERE id IN (${ph})
+         ORDER BY start_time DESC LIMIT 5`
+      ).all(...allIds).map(r => ({
+        id: r.id, summary: r.summary, agent: normalizeAgentLabel(r.agent),
+        timestamp: r.start_time, status: r.end_time ? 'completed' : 'in-progress'
+      }));
+
+      const commonTools = db.prepare(
+        `SELECT tool_name, COUNT(*) as c FROM events
+         WHERE session_id IN (${ph}) AND tool_name IS NOT NULL
+         GROUP BY tool_name ORDER BY c DESC LIMIT 10`
+      ).all(...allIds).map(r => ({ tool: r.tool_name, count: r.c }));
+
+      const commonErrors = db.prepare(
+        `SELECT DISTINCT SUBSTR(tool_result, 1, 200) as err FROM events
+         WHERE session_id IN (${ph})
+           AND tool_result IS NOT NULL
+           AND (tool_result LIKE '%error%' OR tool_result LIKE '%Error%' OR tool_result LIKE '%ERROR%')
+         ORDER BY timestamp DESC LIMIT 5`
+      ).all(...allIds).map(r => r.err);
+
+      return json(res, {
+        repo: repoPath, sessionCount: allIds.length,
+        totalCost: agg.cost || 0, totalTokens: agg.tokens || 0,
+        agents, topFiles, recentSessions, commonTools, commonErrors
+      });
+    }
+    else if (pathname === '/api/context/agent') {
+      const name = query.name || '';
+      if (!name) return json(res, { error: 'name parameter is required' }, 400);
+
+      // Try exact match first, then check all sessions with normalized label match
+      let sessions = db.prepare(
+        'SELECT * FROM sessions WHERE agent = ?'
+      ).all(name);
+      if (sessions.length === 0) {
+        sessions = db.prepare('SELECT * FROM sessions WHERE agent IS NOT NULL').all()
+          .filter(s => normalizeAgentLabel(s.agent) === name);
+      }
+
+      if (sessions.length === 0) {
+        return json(res, { agent: name, sessionCount: 0, totalCost: 0, avgDuration: 0, topTools: [], recentSessions: [], successRate: 0 });
+      }
+
+      const totalCost = sessions.reduce((s, r) => s + (r.total_cost || 0), 0);
+      let totalDuration = 0;
+      let durationCount = 0;
+      for (const s of sessions) {
+        if (s.start_time && s.end_time) {
+          totalDuration += (new Date(s.end_time) - new Date(s.start_time)) / 1000;
+          durationCount++;
+        }
+      }
+      const avgDuration = durationCount > 0 ? Math.round(totalDuration / durationCount) : 0;
+
+      const withSummary = sessions.filter(s => s.summary).length;
+      const successRate = Math.round((withSummary / sessions.length) * 100);
+
+      const ids = sessions.map(s => s.id);
+      const ph = ids.map(() => '?').join(',');
+      const topTools = db.prepare(
+        `SELECT tool_name, COUNT(*) as c FROM events
+         WHERE session_id IN (${ph}) AND tool_name IS NOT NULL
+         GROUP BY tool_name ORDER BY c DESC LIMIT 10`
+      ).all(...ids).map(r => ({ tool: r.tool_name, count: r.c }));
+
+      const recentSessions = sessions
+        .sort((a, b) => (b.start_time || '').localeCompare(a.start_time || ''))
+        .slice(0, 5)
+        .map(s => ({ id: s.id, summary: s.summary, timestamp: s.start_time }));
+
+      return json(res, {
+        agent: name, sessionCount: sessions.length,
+        totalCost, avgDuration, topTools, recentSessions, successRate
+      });
+    }
     else if (pathname === '/api/files') {
       const limit = parseInt(query.limit) || 100;
       const offset = parseInt(query.offset) || 0;

package/indexer.js

@@ -28,17 +28,56 @@ 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 (normalized.endsWith('/.claude/projects')) {
+      for (const proj of fs.readdirSync(p)) {
+        const projDir = path.join(p, proj);
+        if (fs.statSync(projDir).isDirectory()) {
+          const hasJsonl = fs.readdirSync(projDir).some(f => f.endsWith('.jsonl'));
+          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)) });
+    }
+  }
 
   // Config sessionsPath or env var override
   const sessionsOverride = process.env.AGENTACTA_SESSIONS_PATH || (config && config.sessionsPath);
   if (sessionsOverride) {
-    for (const p of sessionsOverride.split(':')) {
-      if (fs.existsSync(p)) dirs.push({ path: p, agent: path.basename(path.dirname(p)) });
+    const overridePaths = Array.isArray(sessionsOverride)
+      ? 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;
   }
 
-  // Scan ~/.openclaw/agents/*/sessions/
+  // Auto-discover: ~/.openclaw/agents/*/sessions/
   const oclawAgents = path.join(home, '.openclaw/agents');
   if (fs.existsSync(oclawAgents)) {
     for (const agent of fs.readdirSync(oclawAgents)) {
@@ -49,26 +88,11 @@ function discoverSessionDirs(config) {
     }
   }
 
-  // Scan ~/.claude/projects/*/ (Claude Code stores JSONL directly in project dirs)
-  const claudeProjects = path.join(home, '.claude/projects');
-  if (fs.existsSync(claudeProjects)) {
-    for (const proj of fs.readdirSync(claudeProjects)) {
-      const projDir = path.join(claudeProjects, proj);
-      // Claude Code: JSONL files directly in project dir
-      if (fs.existsSync(projDir) && fs.statSync(projDir).isDirectory()) {
-        const hasJsonl = fs.readdirSync(projDir).some(f => f.endsWith('.jsonl'));
-        if (hasJsonl) dirs.push({ path: projDir, agent: 'claude-code' });
-      }
-      // Also check sessions/ subdirectory (future-proofing)
-      const sp = path.join(projDir, 'sessions');
-      if (fs.existsSync(sp) && fs.statSync(sp).isDirectory()) {
-        dirs.push({ path: sp, agent: 'claude-code' });
-      }
-    }
-  }
+  // Auto-discover: ~/.claude/projects/
+  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 });
   }
@@ -221,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);
@@ -269,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;
 
@@ -289,11 +316,16 @@ function indexFile(db, filePath, agentName, stmts, archiveMode, config) {
     if (firstLine.agent) agent = firstLine.agent;
     if (firstLine.sessionType) sessionType = firstLine.sessionType;
     if (sessionId.includes('subagent')) sessionType = 'subagent';
-  } else if (firstLine.type === 'user' || firstLine.type === 'assistant' || firstLine.type === 'file-history-snapshot') {
-    // Claude Code format — no session header, extract from first message line
+  } else if (firstLine.type === 'user' || firstLine.type === 'assistant' || firstLine.type === 'file-history-snapshot' || firstLine.type === 'queue-operation') {
+    // Claude Code format — no session header, extract from first message or queue-operation line
     isClaudeCode = true;
     for (const line of lines) {
       let obj; try { obj = JSON.parse(line); } catch { continue; }
+      if (obj.sessionId && obj.timestamp) {
+        sessionId = obj.sessionId;
+        sessionStart = obj.timestamp;
+        break;
+      }
       if ((obj.type === 'user' || obj.type === 'assistant') && obj.sessionId) {
         sessionId = obj.sessionId;
         sessionStart = obj.timestamp;
@@ -311,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;
@@ -319,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 };
   }
@@ -353,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;
       }
@@ -557,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';
@@ -720,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();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentacta",
-  "version": "2026.3.6",
+  "version": "2026.3.12-r2",
   "description": "Audit trail and search engine for AI agent sessions",
   "main": "index.js",
   "bin": {

package/public/app.js

@@ -647,7 +647,9 @@ async function viewSession(id) {
   if (data._error || data.error) { content.innerHTML = `<div class="empty"><h2>${escHtml(data.error || 'Unable to load')}</h2></div>`; return; }
 
   const s = data.session;
-  const cost = fmtCost(s.total_cost);
+  const projectFilters = Array.isArray(data.projectFilters)
+    ? data.projectFilters.filter(p => p && p.project && Number.isFinite(Number(p.eventCount)))
+    : [];
   let html = `
     <div class="back-btn" id="backBtn">\u2190 Back</div>
     <div class="page-title">Session</div>
@@ -667,7 +669,6 @@ async function viewSession(id) {
       <div class="session-header" style="margin-bottom:12px">
         <span class="session-time">${fmtDate(s.start_time)} \u00b7 ${fmtTimeShort(s.start_time)} \u2013 ${fmtTimeShort(s.end_time)}</span>
         <span style="display:flex;gap:6px;align-items:center;flex-wrap:wrap">
-          ${renderProjectTags(s)}
           ${s.agent && s.agent !== 'main' ? `<span class="session-agent">${escHtml(normalizeAgentLabel(s.agent))}</span>` : ''}
           ${s.session_type && s.session_type !== normalizeAgentLabel(s.agent || '') ? `<span class="session-type">${escHtml(s.session_type)}</span>` : ''}
           ${renderModelTags(s)}
@@ -678,16 +679,62 @@ async function viewSession(id) {
         <span><span class="detail-icon"><svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M14.7 6.3a1 1 0 0 0 0 1.4l1.6 1.6a1 1 0 0 0 1.4 0l3.77-3.77a6 6 0 0 1-7.94 7.94l-6.91 6.91a2.12 2.12 0 0 1-3-3l6.91-6.91a6 6 0 0 1 7.94-7.94l-3.76 3.76z"/></svg></span> ${s.tool_count} tools</span>
         ${s.output_tokens ? `<span><span class="detail-icon"><svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="17 1 21 5 17 9"/><path d="M3 11V9a4 4 0 0 1 4-4h14"/></svg></span> ${fmtTokens(s.output_tokens)} output</span><span><span class="detail-icon"><svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="7 23 3 19 7 15"/><path d="M21 13v2a4 4 0 0 1-4 4H3"/></svg></span> ${fmtTokens(s.input_tokens + s.cache_read_tokens)} input</span>` : s.total_tokens ? `<span><span class="detail-icon"><svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M4 7V4h16v3"/><path d="M9 20h6"/><path d="M12 4v16"/></svg></span> ${fmtTokens(s.total_tokens)} tokens</span><span></span>` : '<span></span><span></span>'}
       </div>
+      ${projectFilters.length ? `
+        <div class="section-label" style="margin-top:14px">Project Filter</div>
+        <div class="filters" id="sessionProjectFilters" style="margin-bottom:4px">
+          <span class="filter-chip active" data-project-filter="all">All</span>
+          ${projectFilters.map(p => `<span class="filter-chip" data-project-filter="${escHtml(p.project)}">${escHtml(p.project)} · ${p.eventCount}</span>`).join('')}
+        </div>
+      ` : ''}
     </div>
-    <div class="section-label">Events</div>
+    <div class="section-label" id="sessionEventsLabel">Events</div>
+    <div id="eventsContainer"></div>
+    <div class="empty" id="sessionEventsEmpty" style="display:none"><h2>No events</h2><p>This session has no events to display.</p></div>
   `;
 
   const PAGE_SIZE = 50;
-  const allEvents = data.events;
+  const allEvents = Array.isArray(data.events) ? [...data.events] : [];
+  let activeProjectFilter = 'all';
   let rendered = 0;
+  let onScroll = null;
+  let pendingNewCount = 0;
+
+  const getFilteredEvents = () => {
+    if (activeProjectFilter === 'all') return allEvents;
+    return allEvents.filter(ev => ev.project === activeProjectFilter);
+  };
+
+  const updateEventsLabel = () => {
+    const el = $('#sessionEventsLabel');
+    if (!el) return;
+    const count = getFilteredEvents().length;
+    if (activeProjectFilter === 'all') {
+      el.textContent = `Events (${count})`;
+      return;
+    }
+    el.textContent = `Events (${count}) · ${activeProjectFilter}`;
+  };
+
+  const updateEventsEmptyState = () => {
+    const empty = $('#sessionEventsEmpty');
+    if (!empty) return;
+    empty.style.display = getFilteredEvents().length ? 'none' : 'block';
+  };
+
+  const setProjectFilter = (nextFilter) => {
+    if (nextFilter === activeProjectFilter) return;
+    activeProjectFilter = nextFilter;
+    const chips = $$('#sessionProjectFilters .filter-chip');
+    chips.forEach(node => node.classList.toggle('active', node.dataset.projectFilter === activeProjectFilter));
+    pendingNewCount = 0;
+    const indicator = document.getElementById('newEventsIndicator');
+    if (indicator) indicator.remove();
+    resetRenderedEvents();
+  };
 
   function renderBatch() {
-    const batch = allEvents.slice(rendered, rendered + PAGE_SIZE);
+    const filtered = getFilteredEvents();
+    const batch = filtered.slice(rendered, rendered + PAGE_SIZE);
     if (!batch.length) return;
     const frag = document.createElement('div');
     frag.innerHTML = batch.map(renderEvent).join('');
@@ -696,33 +743,61 @@ async function viewSession(id) {
       while (frag.firstChild) container.appendChild(frag.firstChild);
     }
     rendered += batch.length;
-
   }
 
-  html += '<div id="eventsContainer">' + allEvents.slice(0, PAGE_SIZE).map(renderEvent).join('') + '</div>';
-  rendered = Math.min(PAGE_SIZE, allEvents.length);
   content.innerHTML = html;
   transitionView();
 
-  let onScroll = null;
-  if (allEvents.length > PAGE_SIZE) {
+  const syncScrollHandler = () => {
+    const total = getFilteredEvents().length;
+    if (total <= rendered) {
+      if (onScroll) {
+        window.removeEventListener('scroll', onScroll);
+        onScroll = null;
+      }
+      return;
+    }
+
+    if (onScroll) return;
+
     let loading = false;
     onScroll = () => {
-      if (loading || rendered >= allEvents.length) return;
+      if (loading || rendered >= getFilteredEvents().length) return;
       const scrollBottom = window.innerHeight + window.scrollY;
       const threshold = document.body.offsetHeight - 300;
       if (scrollBottom >= threshold) {
         loading = true;
         renderBatch();
         loading = false;
-        if (rendered >= allEvents.length) {
+        if (rendered >= getFilteredEvents().length) {
           window.removeEventListener('scroll', onScroll);
           onScroll = null;
         }
       }
     };
     window.addEventListener('scroll', onScroll, { passive: true });
-  }
+  };
+
+  const resetRenderedEvents = () => {
+    const container = document.getElementById('eventsContainer');
+    if (!container) return;
+    container.innerHTML = '';
+    rendered = 0;
+    renderBatch();
+    syncScrollHandler();
+    updateEventsLabel();
+    updateEventsEmptyState();
+  };
+
+  resetRenderedEvents();
+
+  const filterChips = $$('#sessionProjectFilters .filter-chip');
+  filterChips.forEach(chip => {
+    chip.addEventListener('click', () => {
+      const nextFilter = chip.dataset.projectFilter || 'all';
+      setProjectFilter(nextFilter);
+    });
+  });
 
   $('#backBtn').addEventListener('click', () => {
     clearJumpUi();
@@ -778,22 +853,35 @@ async function viewSession(id) {
   if (jumpBtn) {
     jumpBtn.addEventListener('click', async () => {
       const fromY = window.scrollY || window.pageYOffset || 0;
+      const firstMessageId = s.first_message_id;
 
       jumpBtn.classList.add('jumping');
       jumpBtn.disabled = true;
 
+      if (!firstMessageId) {
+        jumpBtn.classList.remove('jumping');
+        jumpBtn.disabled = false;
+        return;
+      }
+
+      // Resolve from full session context, not just project-filtered events.
+      const inCurrentFilter = getFilteredEvents().some(ev => ev.id === firstMessageId);
+      if (!inCurrentFilter && activeProjectFilter !== 'all') {
+        setProjectFilter('all');
+      }
+
       // Let button state paint before heavy DOM work.
       await new Promise(requestAnimationFrame);
 
       // Load remaining events in chunks so UI stays responsive.
       let loops = 0;
-      while (rendered < allEvents.length) {
+      while (rendered < getFilteredEvents().length) {
         renderBatch();
         loops += 1;
         if (loops % 2 === 0) await new Promise(requestAnimationFrame);
       }
 
-      const firstMessage = document.querySelector(`[data-event-id="${s.first_message_id}"]`);
+      const firstMessage = document.querySelector(`[data-event-id="${firstMessageId}"]`);
       if (!firstMessage) {
         jumpBtn.classList.remove('jumping');
         jumpBtn.disabled = false;
@@ -838,9 +926,8 @@ async function viewSession(id) {
     });
   }
 
-    // --- Lightweight realtime updates (polling fallback first) ---
+  // --- Lightweight realtime updates (polling fallback first) ---
   const knownIds = new Set(allEvents.map(e => e.id));
-  let pendingNewCount = 0;
 
   const applyIncomingEvents = (incoming) => {
     const container = document.getElementById('eventsContainer');
@@ -850,8 +937,22 @@ async function viewSession(id) {
     if (!fresh.length) return;
     fresh.forEach(e => knownIds.add(e.id));
 
+    // Delta endpoint returns oldest -> newest, and view is newest-first.
+    for (const ev of fresh) allEvents.unshift(ev);
+
+    const visibleFresh = activeProjectFilter === 'all'
+      ? fresh
+      : fresh.filter(ev => ev.project === activeProjectFilter);
+
+    if (!visibleFresh.length) {
+      updateEventsLabel();
+      updateEventsEmptyState();
+      syncScrollHandler();
+      return;
+    }
+
     const isAtTop = window.scrollY < 100;
-    for (const ev of fresh) {
+    for (const ev of visibleFresh) {
       const div = document.createElement('div');
       div.innerHTML = renderEvent(ev);
       const el = div.firstElementChild;
@@ -859,9 +960,13 @@ async function viewSession(id) {
       container.insertBefore(el, container.firstChild);
       setTimeout(() => el.classList.remove('event-highlight'), 2000);
     }
+    rendered += visibleFresh.length;
+    updateEventsLabel();
+    updateEventsEmptyState();
+    syncScrollHandler();
 
     if (!isAtTop) {
-      pendingNewCount += fresh.length;
+      pendingNewCount += visibleFresh.length;
       let indicator = document.getElementById('newEventsIndicator');
       if (!indicator) {
         indicator = document.createElement('div');