agent-tracer 0.2.0

package/lib/session-store.js

@@ -0,0 +1,631 @@
+'use strict';
+/**
+ * In-memory session state, hook event handler, and SSE broadcast.
+ *
+ * Call createStore(dbExports) once at startup.
+ * All HTTP routes that need to read/mutate sessions should call store methods.
+ */
+
+const fs   = require('fs');
+const path = require('path');
+
+const {
+  isValidSessionId, safeFilePath, summarize, findTranscript,
+  parseTranscriptMeta, parseTranscriptCompactions,
+  parseTranscriptStats, parseFullSessionStats,
+  findChildSessionIds, PROJECTS_DIR,
+} = require('./parser');
+
+function createStore({ db, stmts, persistSession, persistTool, persistCompaction }) {
+
+  // ── In-memory state ────────────────────────────────────────────────────────
+  const sessions    = new Map(); // sessionId → AgentNode
+  const toolCallMap = new Map(); // toolUseId → { sessionId, call }
+  const sessionList = [];        // ordered root session IDs
+  const clients     = [];        // SSE response objects
+  let   compactSeq  = 0;         // monotonic counter for fallback compaction IDs
+
+  // ── SSE broadcast ──────────────────────────────────────────────────────────
+  function broadcast() {
+    const data = `data: ${serializeTree()}\n\n`;
+    for (let i = clients.length - 1; i >= 0; i--) {
+      try { clients[i].write(data); }
+      catch { clients.splice(i, 1); }
+    }
+  }
+
+  // ── Load history from DB on startup ───────────────────────────────────────
+  function loadHistory() {
+    const roots = stmts.listRootSessions.all();
+    for (const row of roots) loadSessionTree(row.id);
+    for (const row of [...roots].reverse()) {
+      if (!sessionList.includes(row.id)) sessionList.push(row.id);
+    }
+  }
+
+  function loadSessionTree(sessionId) {
+    if (sessions.has(sessionId)) return sessions.get(sessionId);
+
+    const row = stmts.getSession.get(sessionId);
+    if (!row) return null;
+
+    const toolRows  = stmts.getToolCalls.all(sessionId);
+    const compRows  = stmts.getCompactions.all(sessionId);
+    const childRows = stmts.getChildren.all(sessionId);
+
+    const node = {
+      sessionId:      row.id,
+      parentSessionId: row.parent_id || null,
+      label:          row.label,
+      status:         row.status,
+      startedAt:      row.started_at,
+      endedAt:        row.ended_at || null,
+      tokens:         { input: row.tokens_in, output: row.tokens_out, cacheRead: row.cache_read },
+      costUsd:        row.cost_usd,
+      lastText:       row.last_text       || '',
+      cwd:            row.cwd             || null,
+      permissionMode: row.permission_mode || null,
+      entrypoint:     row.entrypoint      || null,
+      version:        row.version         || null,
+      gitBranch:      row.git_branch      || null,
+      packageJson:    row.package_json ? (() => { try { return JSON.parse(row.package_json); } catch { return null; } })() : null,
+      toolCalls: toolRows.map(t => ({
+        id: t.id, name: t.name, summary: t.summary,
+        input: t.input_json ? (() => { try { return JSON.parse(t.input_json); } catch { return {}; } })() : {},
+        done: !!t.done || row.status !== 'running',
+        startedAt: t.started_at, durationMs: t.duration_ms,
+      })),
+      compactions: compRows.map(c => ({
+        id: c.id, timestamp: c.timestamp,
+        tokensBefore: c.tokens_before, tokensAfter: c.tokens_after,
+        summary: c.summary || '',
+      })),
+      children: childRows.map(c => c.id),
+    };
+
+    sessions.set(sessionId, node);
+    for (const child of childRows) loadSessionTree(child.id);
+    return node;
+  }
+
+  // ── Startup backfill (costs, meta, compactions) ────────────────────────────
+  function backfillCosts() {
+    for (const node of sessions.values()) {
+      const needsCost     = node.costUsd === 0 && node.tokens.input === 0;
+      const needsMeta     = !node.permissionMode && !node.entrypoint;
+      const needsLabel    = node.label === `agent-${node.sessionId.slice(0, 8)}`;
+      const needsCompacts = node.compactions.length === 0;
+      if (!needsCost && !needsMeta && !needsLabel && !needsCompacts) continue;
+
+      const transcript = findTranscript(node.sessionId, node.cwd);
+      if (!transcript) continue;
+
+      let changed = false;
+      if (needsCost) {
+        const stats = parseFullSessionStats(transcript, node.sessionId);
+        if (stats.inputTokens > 0 || stats.outputTokens > 0) {
+          node.tokens.input     = stats.inputTokens;
+          node.tokens.output    = stats.outputTokens;
+          node.tokens.cacheRead = stats.cacheReadTokens;
+          node.costUsd          = stats.costUsd;
+          if (node.status === 'running') node.status = 'done';
+          console.log(`  Backfilled ${node.sessionId.slice(0, 8)}: $${stats.costUsd.toFixed(4)}`);
+          changed = true;
+        }
+      }
+      if (needsMeta || needsLabel) {
+        const tmeta = parseTranscriptMeta(transcript);
+        if (needsMeta) {
+          if (tmeta.permissionMode) { node.permissionMode = tmeta.permissionMode; changed = true; }
+          if (tmeta.entrypoint)     { node.entrypoint     = tmeta.entrypoint;     changed = true; }
+          if (tmeta.version)        { node.version        = tmeta.version;        changed = true; }
+          if (tmeta.gitBranch)      { node.gitBranch      = tmeta.gitBranch;      changed = true; }
+        }
+        if (needsLabel && tmeta.label) { node.label = tmeta.label; changed = true; }
+      }
+      if (needsCompacts) {
+        const compacts = parseTranscriptCompactions(transcript);
+        for (const c of compacts) {
+          node.compactions.push(c);
+          persistCompaction(c, node.sessionId);
+        }
+        if (compacts.length > 0) changed = true;
+      }
+      if (changed) persistSession(node);
+    }
+  }
+
+  /**
+   * Discover worktree / background agent sessions from all project directories
+   * and synthesise virtual sidechain nodes for inline agents with no own file.
+   */
+  function discoverChildSessions() {
+    const knownIds = new Set(sessions.keys());
+
+    // Gather unrecognised JSONL files across all project dirs
+    const candidates = [];
+    try {
+      for (const dirEntry of fs.readdirSync(PROJECTS_DIR)) {
+        const projectDir = path.join(PROJECTS_DIR, dirEntry);
+        try { if (!fs.statSync(projectDir).isDirectory()) continue; } catch { continue; }
+        let files;
+        try { files = fs.readdirSync(projectDir).filter(f => f.endsWith('.jsonl')); } catch { continue; }
+        for (const file of files) {
+          const childId = file.replace('.jsonl', '');
+          if (!isValidSessionId(childId) || knownIds.has(childId)) continue;
+          const childPath = path.join(projectDir, file);
+          if (!safeFilePath(childPath)) continue;
+          candidates.push({ childId, childPath });
+        }
+      }
+    } catch {}
+
+    function readChildMeta(childPath) {
+      let firstPrompt = null, startedAt = null, endedAt = null, cwd = null;
+      try {
+        const lines = fs.readFileSync(childPath, 'utf8').split('\n');
+        for (const line of lines.slice(0, 30)) {
+          if (!line.trim()) continue;
+          try {
+            const obj = JSON.parse(line);
+            if (!startedAt && obj.timestamp) startedAt = new Date(obj.timestamp).getTime();
+            if (!cwd && obj.cwd) cwd = obj.cwd;
+            if (!firstPrompt && obj.type === 'user' && obj.message?.content) {
+              const c = obj.message.content;
+              const text = typeof c === 'string' ? c
+                : (Array.isArray(c) ? c.filter(b => b.type === 'text').map(b => b.text).join('') : '');
+              if (text && !text.startsWith('<') && !text.startsWith('/') && text.length > 10)
+                firstPrompt = text.trim();
+            }
+            if (firstPrompt && startedAt && cwd) break;
+          } catch {}
+        }
+        for (let i = lines.length - 1; i >= 0; i--) {
+          const l = lines[i].trim();
+          if (!l) continue;
+          try { const obj = JSON.parse(l); if (obj.timestamp) { endedAt = new Date(obj.timestamp).getTime(); break; } } catch {}
+        }
+      } catch {}
+      return { firstPrompt, startedAt, endedAt, cwd };
+    }
+
+    for (const node of [...sessions.values()]) {
+      const transcript = findTranscript(node.sessionId, node.cwd);
+      if (!transcript) continue;
+
+      const agentCalls   = [];
+      const agentResults = new Map();
+
+      try {
+        for (const line of fs.readFileSync(transcript, 'utf8').split('\n')) {
+          if (!line.trim()) continue;
+          try {
+            const obj = JSON.parse(line);
+            for (const block of (obj.message?.content || [])) {
+              if ((block.name === 'Agent' || block.name === 'Task') && block.input?.prompt) {
+                agentCalls.push({
+                  toolUseId:    block.id,
+                  prompt:       block.input.prompt,
+                  description:  block.input.description || '',
+                  isBackground: !!block.input.run_in_background,
+                  isolation:    block.input.isolation || null,
+                });
+              }
+              if (block.type === 'tool_result') {
+                const txt = Array.isArray(block.content)
+                  ? block.content.filter(b => b.type === 'text').map(b => b.text).join('')
+                  : (typeof block.content === 'string' ? block.content : '');
+                if (txt) agentResults.set(block.tool_use_id, txt);
+              }
+            }
+          } catch {}
+        }
+      } catch {}
+
+      if (!agentCalls.length) continue;
+
+      const matchedToolUseIds = new Set();
+
+      for (const { childId, childPath } of candidates) {
+        if (sessions.has(childId)) continue;
+        const { firstPrompt, startedAt, endedAt, cwd: childCwd } = readChildMeta(childPath);
+        if (!firstPrompt) continue;
+
+        const needle = firstPrompt.slice(0, 80).toLowerCase();
+        let matchedCall = null;
+        for (const call of agentCalls) {
+          const hay = call.prompt.slice(0, 80).toLowerCase();
+          if (hay === needle || needle.startsWith(hay.slice(0, 50)) || hay.startsWith(needle.slice(0, 50))) {
+            matchedCall = call; break;
+          }
+        }
+        if (!matchedCall) continue;
+
+        matchedToolUseIds.add(matchedCall.toolUseId);
+        const childMeta    = parseTranscriptMeta(childPath);
+        const childStats   = parseTranscriptStats(childPath);
+        const childCompacts = parseTranscriptCompactions(childPath);
+        const label = (matchedCall.description || matchedCall.prompt).replace(/\s+/g, ' ').slice(0, 50);
+        const isWorktree = matchedCall.isolation === 'worktree';
+
+        const childNode = {
+          sessionId:       childId,
+          parentSessionId: node.sessionId,
+          label,
+          status:          'done',
+          startedAt:       startedAt  || node.startedAt,
+          endedAt:         endedAt    || Date.now(),
+          tokens:          { input: childStats.inputTokens, output: childStats.outputTokens, cacheRead: childStats.cacheReadTokens },
+          costUsd:         childStats.costUsd,
+          lastText:        '',
+          cwd:             childCwd   || node.cwd,
+          permissionMode:  childMeta?.permissionMode || null,
+          entrypoint:      childMeta?.entrypoint     || null,
+          version:         childMeta?.version        || null,
+          gitBranch:       childMeta?.gitBranch      || null,
+          packageJson:     null,
+          toolCalls:       [],
+          compactions:     childCompacts,
+          children:        [],
+          isWorktree,
+          isSidechain:     false,
+        };
+        sessions.set(childId, childNode);
+        knownIds.add(childId);
+        if (!node.children.includes(childId)) node.children.push(childId);
+        persistSession(childNode);
+        for (const c of childCompacts) persistCompaction(c, childId);
+        console.log(`  Discovered ${isWorktree ? 'worktree' : 'background'} session ${childId.slice(0, 8)} → parent ${node.sessionId.slice(0, 8)}`);
+      }
+
+      for (const call of agentCalls) {
+        if (matchedToolUseIds.has(call.toolUseId)) continue;
+        if (call.isBackground) continue;
+
+        const virtualId = `sc-${node.sessionId.slice(0, 8)}-${call.toolUseId.slice(-12)}`;
+        if (sessions.has(virtualId)) continue;
+
+        const resultText = agentResults.get(call.toolUseId) || '';
+        const isError    = /^Error:|permission/i.test(resultText);
+
+        const virtualNode = {
+          sessionId:       virtualId,
+          parentSessionId: node.sessionId,
+          label:           (call.description || call.prompt).replace(/\s+/g, ' ').slice(0, 60),
+          status:          isError ? 'error' : 'done',
+          startedAt:       node.startedAt,
+          endedAt:         node.endedAt || Date.now(),
+          tokens:          { input: 0, output: 0, cacheRead: 0 },
+          costUsd:         0,
+          lastText:        resultText.slice(0, 300),
+          cwd:             node.cwd,
+          permissionMode:  null,
+          entrypoint:      null,
+          version:         null,
+          gitBranch:       null,
+          packageJson:     null,
+          toolCalls:       [],
+          compactions:     [],
+          children:        [],
+          isWorktree:      false,
+          isSidechain:     true,
+        };
+        sessions.set(virtualId, virtualNode);
+        knownIds.add(virtualId);
+        if (!node.children.includes(virtualId)) node.children.push(virtualId);
+        console.log(`  Synthesised sidechain ${virtualId} → parent ${node.sessionId.slice(0, 8)}`);
+      }
+    }
+  }
+
+  // ── Live cost refresh (every 45s) ─────────────────────────────────────────
+  function refreshLiveCosts() {
+    let changed = false;
+    for (const node of sessions.values()) {
+      if (node.status !== 'running') continue;
+      const transcript = findTranscript(node.sessionId, node.cwd);
+      if (!transcript) continue;
+      try {
+        const stats = parseFullSessionStats(transcript, node.sessionId);
+        if (stats.costUsd !== node.costUsd || stats.inputTokens !== node.tokens.input) {
+          node.tokens.input     = stats.inputTokens;
+          node.tokens.output    = stats.outputTokens;
+          node.tokens.cacheRead = stats.cacheReadTokens;
+          node.costUsd          = stats.costUsd;
+          persistSession(node);
+          changed = true;
+        }
+      } catch {}
+    }
+    if (changed) broadcast();
+  }
+
+  // ── Serialization ──────────────────────────────────────────────────────────
+  function serializeSession(sessionId, _visited = new Set()) {
+    if (_visited.has(sessionId)) return null; // cycle guard
+    _visited.add(sessionId);
+    const n = sessions.get(sessionId);
+    if (!n) return null;
+    return {
+      sessionId:      n.sessionId,
+      label:          n.label,
+      status:         n.status,
+      startedAt:      n.startedAt,
+      endedAt:        n.endedAt,
+      tokens:         n.tokens,
+      costUsd:        n.costUsd,
+      lastText:       n.lastText.slice(-200),
+      permissionMode: n.permissionMode || null,
+      entrypoint:     n.entrypoint     || null,
+      version:        n.version        || null,
+      gitBranch:      n.gitBranch      || null,
+      cwd:            n.cwd            || null,
+      compactions:    n.compactions    || [],
+      isSidechain:    n.isSidechain    || false,
+      isWorktree:     n.isWorktree     || false,
+      toolCalls: n.toolCalls.map(tc => ({
+        id: tc.id, name: tc.name, done: tc.done,
+        summary: tc.summary, input: tc.input, durationMs: tc.durationMs,
+        startedAt: tc.startedAt || null,
+      })),
+      children: n.children.map(cid => serializeSession(cid, _visited)).filter(Boolean),
+    };
+  }
+
+  function serializeTree(rootId = null) {
+    const roots = rootId ? [rootId] : [...sessionList].reverse();
+    const serializedRoots = roots.map(id => serializeSession(id)).filter(Boolean);
+    const allNodes  = [...sessions.values()];
+    const rootNodes = allNodes.filter(n => !n.parentSessionId);
+    const totals = {
+      agents:    allNodes.length,
+      tools:     allNodes.reduce((s, n) => s + n.toolCalls.length, 0),
+      tokensIn:  rootNodes.reduce((s, n) => s + n.tokens.input, 0),
+      tokensOut: rootNodes.reduce((s, n) => s + n.tokens.output, 0),
+      cacheRead: rootNodes.reduce((s, n) => s + n.tokens.cacheRead, 0),
+      cost:      rootNodes.reduce((s, n) => s + n.costUsd, 0),
+    };
+    return JSON.stringify({ roots: serializedRoots, root: serializedRoots[0] || null, totals });
+  }
+
+  // ── In-memory factory ─────────────────────────────────────────────────────
+  function getOrCreate(sessionId, parentSessionId = null, label = null) {
+    if (!sessions.has(sessionId)) {
+      const node = {
+        sessionId,
+        parentSessionId,
+        label:    label || `agent-${sessionId.slice(0, 8)}`,
+        status:   'running',
+        startedAt: Date.now(),
+        endedAt:  null,
+        tokens:   { input: 0, output: 0, cacheRead: 0 },
+        costUsd:  0,
+        toolCalls:   [],
+        compactions: [],
+        lastText: '',
+        children: [],
+        cwd:            null,
+        permissionMode: null,
+        entrypoint:     null,
+        version:        null,
+        gitBranch:      null,
+      };
+      sessions.set(sessionId, node);
+      persistSession(node);
+      if (!parentSessionId) {
+        sessionList.push(sessionId);
+      } else {
+        const parent = sessions.get(parentSessionId);
+        if (parent && !parent.children.includes(sessionId)) parent.children.push(sessionId);
+      }
+    }
+    return sessions.get(sessionId);
+  }
+
+  // ── Hook event handler ────────────────────────────────────────────────────
+  function handleHook(ev) {
+    const {
+      hook_event_name: event,
+      session_id:      sid,
+      parent_session_id: parentSid,
+      tool_name,
+      tool_input,
+      tool_use_id,
+      agent_description,
+      duration_ms,
+      is_error,
+      compact_summary,
+      tokens_before,
+      tokens_after,
+    } = ev;
+
+    if (!sid) return;
+
+    // Capture permission mode
+    if (ev.permission_mode || ev.permissionMode) {
+      const node = sessions.get(sid) || getOrCreate(sid, parentSid || null);
+      if (!node.permissionMode) node.permissionMode = ev.permission_mode || ev.permissionMode;
+    }
+
+    // Capture cwd and snapshot project files
+    if (ev.cwd) {
+      const node = sessions.get(sid) || getOrCreate(sid, parentSid || null);
+      if (!node.cwd) {
+        node.cwd = ev.cwd;
+        try {
+          const load = (p) => { try { return JSON.parse(fs.readFileSync(p, 'utf8')); } catch { return {}; } };
+          const ps  = load(path.join(ev.cwd, '.claude', 'settings.json'));
+          const pls = load(path.join(ev.cwd, '.claude', 'settings.local.json'));
+          const allow = [...(ps.permissions?.allow || []), ...(pls.permissions?.allow || [])];
+          const deny  = [...(ps.permissions?.deny  || []), ...(pls.permissions?.deny  || [])];
+          if (allow.length || deny.length) {
+            node.projectAllow = [...new Set(allow)];
+            node.projectDeny  = [...new Set(deny)];
+          }
+          try {
+            const pkg = load(path.join(ev.cwd, 'package.json'));
+            if (pkg.name) node.packageJson = { name: pkg.name, version: pkg.version,
+              deps: pkg.dependencies || {}, devDeps: pkg.devDependencies || {} };
+          } catch {}
+          try {
+            const reqs = fs.readFileSync(path.join(ev.cwd, 'requirements.txt'), 'utf8');
+            node.requirementsTxt = reqs.split('\n').map(l => l.trim()).filter(l => l && !l.startsWith('#'));
+          } catch {}
+        } catch {}
+        persistSession(node);
+      }
+    }
+
+    switch (event) {
+
+      case 'PreToolUse': {
+        const node = getOrCreate(sid, parentSid || null);
+        if (!tool_use_id || !tool_name) break;
+        const tc = {
+          id:        tool_use_id,
+          name:      tool_name,
+          input:     tool_input || {},
+          summary:   summarize(tool_name, tool_input),
+          done:      false,
+          startedAt: Date.now(),
+          durationMs: null,
+          sessionId: sid,
+        };
+        node.toolCalls.push(tc);
+        toolCallMap.set(tool_use_id, { sessionId: sid, call: tc });
+        persistTool(tc);
+        if ((tool_name === 'Agent' || tool_name === 'Task') && agent_description) {
+          const childId = `child-${tool_use_id}`;
+          getOrCreate(childId, sid, agent_description);
+          tc.childSessionId = childId;
+        }
+        break;
+      }
+
+      case 'PostToolUse': {
+        const entry = toolCallMap.get(tool_use_id);
+        if (entry) {
+          entry.call.done      = true;
+          entry.call.durationMs = duration_ms || (Date.now() - entry.call.startedAt);
+          persistTool(entry.call);
+        }
+        const node = sessions.get(sid);
+        if (node) {
+          node._toolsSinceRefresh = (node._toolsSinceRefresh || 0) + 1;
+          if (node._toolsSinceRefresh >= 5) {
+            node._toolsSinceRefresh = 0;
+            const transcript = findTranscript(sid, node.cwd);
+            if (transcript) {
+              try {
+                const stats = parseFullSessionStats(transcript, sid);
+                node.tokens.input     = stats.inputTokens;
+                node.tokens.output    = stats.outputTokens;
+                node.tokens.cacheRead = stats.cacheReadTokens;
+                node.costUsd          = stats.costUsd;
+                persistSession(node);
+              } catch {}
+            }
+          }
+        }
+        break;
+      }
+
+      case 'Stop': {
+        const node = sessions.get(sid);
+        if (node) {
+          node.status  = is_error ? 'error' : 'done';
+          node.endedAt = Date.now();
+          node.lastText = '';
+          for (const tc of node.toolCalls) {
+            if (!tc.done) { tc.done = true; tc.durationMs = Date.now() - tc.startedAt; persistTool(tc); }
+          }
+          const transcript = findTranscript(sid, node.cwd);
+          if (transcript) {
+            try {
+              const tmeta = parseTranscriptMeta(transcript);
+              if (tmeta.permissionMode) node.permissionMode = tmeta.permissionMode;
+              if (tmeta.entrypoint)     node.entrypoint     = tmeta.entrypoint;
+              if (tmeta.version)        node.version        = tmeta.version;
+              if (tmeta.gitBranch)      node.gitBranch      = tmeta.gitBranch;
+              const stats = parseFullSessionStats(transcript, sid);
+              node.tokens.input     = stats.inputTokens;
+              node.tokens.output    = stats.outputTokens;
+              node.tokens.cacheRead = stats.cacheReadTokens;
+              node.costUsd          = stats.costUsd;
+            } catch {}
+          }
+          persistSession(node);
+        }
+        break;
+      }
+
+      case 'PreCompact': {
+        const node = getOrCreate(sid, parentSid || null);
+        const cid = `compact-${sid}-${tool_use_id || ++compactSeq}`;
+        if (!node.compactions.find(x => x.id === cid)) {
+          const c = {
+            id:           cid,
+            timestamp:    Date.now(),
+            summary:      '',
+            tokensBefore: tokens_before || ev.input_tokens_before || null,
+            tokensAfter:  null,
+            _toolUseId:   tool_use_id || null,
+          };
+          node.compactions.push(c);
+          persistCompaction(c, sid);
+        }
+        break;
+      }
+
+      case 'PostCompact': {
+        const node = sessions.get(sid);
+        if (!node) break;
+        const existing = node.compactions.find(x =>
+          (tool_use_id && x._toolUseId === tool_use_id) ||
+          (!tool_use_id && x.tokensAfter === null && x.summary === '')
+        );
+        if (existing) {
+          existing.summary      = compact_summary || ev.summary || '';
+          existing.tokensAfter  = tokens_after  || ev.input_tokens_after  || null;
+          existing.tokensBefore = existing.tokensBefore || tokens_before || null;
+          persistCompaction(existing, sid);
+        } else {
+          const c = {
+            id:           `compact-${sid}-${tool_use_id || ++compactSeq}`,
+            timestamp:    Date.now(),
+            summary:      compact_summary || ev.summary || '',
+            tokensBefore: tokens_before || null,
+            tokensAfter:  tokens_after  || null,
+          };
+          if (!node.compactions.find(x => x.id === c.id)) {
+            node.compactions.push(c);
+            persistCompaction(c, sid);
+          }
+        }
+        persistSession(node);
+        break;
+      }
+
+      default: {
+        if (event) console.warn(`[hook] unknown event: ${event}`);
+        break;
+      }
+    }
+
+    broadcast();
+  }
+
+  return {
+    // State (read-only externally — mutate via methods)
+    sessions, toolCallMap, sessionList, clients,
+    // Lifecycle
+    loadHistory, loadSessionTree,
+    backfillCosts, discoverChildSessions, refreshLiveCosts,
+    // Serialization & broadcast
+    serializeSession, serializeTree, broadcast,
+    // Event handler
+    getOrCreate, handleHook,
+  };
+}
+
+module.exports = { createStore };

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "agent-tracer",
+  "version": "0.2.0",
+  "description": "Live trace viewer for Claude Code agent execution — shows subagent tree, tool calls, tokens, and cost in real time",
+  "main": "bin/agent-trace-daemon.js",
+  "bin": {
+    "agent-trace-daemon": "bin/agent-trace-daemon.js"
+  },
+  "scripts": {
+    "start": "node bin/agent-trace-daemon.js",
+    "daemon": "node bin/agent-trace-daemon.js",
+    "install-hooks": "node bin/agent-trace-daemon.js --install",
+    "test": "vitest run --reporter=verbose"
+  },
+  "files": [
+    "bin/agent-trace-daemon.js",
+    "lib",
+    "public",
+    "README.md"
+  ],
+  "keywords": [
+    "claude",
+    "claude-code",
+    "agent",
+    "trace",
+    "subagent",
+    "observability",
+    "hooks"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "better-sqlite3": "^12.8.0"
+  },
+  "devDependencies": {
+    "vitest": "^4.1.2"
+  }
+}