ccsniff 1.0.11

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 AnEntrypoint
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,82 @@
+# ccsniff
+
+Watch Claude Code JSONL output files and emit structured events as a Node.js EventEmitter.
+
+## Install
+
+```bash
+npm install ccsniff
+```
+
+## Usage
+
+```js
+import { watch } from 'ccsniff';
+
+const watcher = watch()
+  .on('conversation_created', ({ conversation }) => {
+    console.log('New session:', conversation.title);
+  })
+  .on('streaming_progress', ({ block, role }) => {
+    if (block.type === 'text') process.stdout.write(block.text);
+  })
+  .on('streaming_complete', ({ conversationId }) => {
+    console.log('Done:', conversationId);
+  });
+
+process.on('SIGINT', () => watcher.stop());
+```
+
+CommonJS:
+
+```js
+const { watch, JsonlWatcher } = require('ccsniff');
+```
+
+## CLI
+
+```bash
+npx ccsniff --since 24h --grep "rs-exec" --limit 50
+npx ccsniff --since 7d --role user --json
+npx ccsniff -f                     # tail new events live
+npx ccsniff --rollup out.ndjson --since 7d
+```
+
+## API
+
+### `watch(projectsDir?)` → `JsonlWatcher`
+
+Creates and starts a watcher. `projectsDir` defaults to `~/.claude/projects`.
+
+### `new JsonlWatcher(projectsDir?)`
+
+Class constructor. Call `.start()` manually after attaching listeners.
+
+### `watcher.start()` → `this`
+
+Scans for existing `.jsonl` files and begins watching. Chainable.
+
+### `watcher.stop()`
+
+Closes file descriptors and directory watcher.
+
+## Events
+
+| Event | Payload |
+|---|---|
+| `conversation_created` | `{ conversation: { id, title, cwd }, timestamp }` |
+| `streaming_start` | `{ conversationId, conversation, timestamp }` |
+| `streaming_progress` | `{ conversationId, conversation, block, role, seq, timestamp }` |
+| `streaming_complete` | `{ conversationId, conversation, seq, timestamp }` |
+| `streaming_error` | `{ conversationId, error, recoverable, timestamp }` |
+| `error` | `Error` |
+
+`block.type` values: `text`, `tool_use`, `tool_result`, `system`, `result`, etc.
+
+## Requirements
+
+Node >= 18. Zero external dependencies.
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "ccsniff",
+  "version": "1.0.11",
+  "description": "Watch Claude Code JSONL output files and emit structured events as a Node.js EventEmitter",
+  "type": "module",
+  "main": "./src/index.js",
+  "exports": {
+    ".": {
+      "import": "./src/index.js",
+      "require": "./src/index.cjs"
+    }
+  },
+  "bin": {
+    "ccsniff": "./src/cli.js"
+  },
+  "files": [
+    "src/"
+  ],
+  "keywords": [
+    "claude",
+    "claude-code",
+    "ai",
+    "agent",
+    "watch",
+    "streaming",
+    "jsonl"
+  ],
+  "author": "lanmower",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AnEntrypoint/ccsniff.git"
+  },
+  "homepage": "https://anentrypoint.github.io/ccsniff",
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/cli.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+import { JsonlReplayer, rollup } from './index.js';
+import path from 'path';
+
+function parseArgs(argv) {
+  const opts = { since: null, grep: null, cwd: null, role: null, type: null, limit: 0, json: false, tail: false, rollup: null, format: 'ndjson' };
+  const rest = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    const next = () => argv[++i];
+    if (a === '--since') opts.since = next();
+    else if (a === '--grep') opts.grep = next();
+    else if (a === '--cwd') opts.cwd = next();
+    else if (a === '--role') opts.role = next();
+    else if (a === '--type') opts.type = next();
+    else if (a === '--limit') opts.limit = parseInt(next(), 10) || 0;
+    else if (a === '--json') opts.json = true;
+    else if (a === '--tail' || a === '-f') opts.tail = true;
+    else if (a === '--rollup') opts.rollup = next();
+    else if (a === '--format') opts.format = next();
+    else if (a === '-h' || a === '--help') { printHelp(); process.exit(0); }
+    else rest.push(a);
+  }
+  return { opts, rest };
+}
+
+function printHelp() {
+  process.stdout.write(`ccsniff — query and tail Claude Code session history
+
+Usage:
+  ccsniff [--since 12d] [--grep pattern] [--cwd path] [--role user|assistant|tool_result]
+          [--type text|tool_use|tool_result] [--limit N] [--json] [-f]
+  ccsniff --rollup out.ndjson [--since 7d]
+  ccsniff --rollup out.sqlite --format sqlite [--since 7d]      # requires better-sqlite3
+
+Examples:
+  ccsniff --since 24h --grep "rs-exec" --limit 50
+  ccsniff --since 7d --role user --json
+  ccsniff -f                  # tail new events live
+`);
+}
+
+function parseSince(s) {
+  if (!s) return 0;
+  const m = /^(\d+)([smhd])$/.exec(s);
+  if (!m) return Date.parse(s) || 0;
+  const n = parseInt(m[1], 10);
+  const mult = { s: 1e3, m: 6e4, h: 36e5, d: 864e5 }[m[2]];
+  return Date.now() - n * mult;
+}
+
+const { opts } = parseArgs(process.argv.slice(2));
+const since = parseSince(opts.since);
+const grepRe = opts.grep ? new RegExp(opts.grep, 'i') : null;
+const cwdRe = opts.cwd ? new RegExp(opts.cwd, 'i') : null;
+
+let count = 0;
+function out(ev) {
+  const conv = ev.conversation;
+  if (cwdRe && !cwdRe.test(conv.cwd || '')) return;
+  if (opts.role && ev.role !== opts.role) return;
+  if (opts.type && ev.block?.type !== opts.type) return;
+  const text = ev.block?.text || (ev.block?.content ? (typeof ev.block.content === 'string' ? ev.block.content : JSON.stringify(ev.block.content).slice(0, 400)) : '');
+  if (grepRe && !grepRe.test(text)) return;
+  count++;
+  if (opts.limit && count > opts.limit) return;
+  if (opts.json) {
+    process.stdout.write(JSON.stringify({ ts: ev.timestamp, sid: conv.id, cwd: conv.cwd, role: ev.role, type: ev.block?.type, text: text.slice(0, 2000) }) + '\n');
+  } else {
+    const t = new Date(ev.timestamp).toISOString().slice(0, 19).replace('T', ' ');
+    const repo = path.basename(conv.cwd || '');
+    process.stdout.write(`[${t}] [${repo}] ${ev.role}/${ev.block?.type || '?'}: ${text.replace(/\s+/g, ' ').slice(0, 200)}\n`);
+  }
+}
+
+if (opts.rollup) {
+  const stats = await rollup({ since, out: opts.rollup, format: opts.format });
+  process.stderr.write(`# rolled up ${stats.rows} events from ${stats.events} routed (${stats.files} files) → ${stats.format}: ${stats.out}\n`);
+  process.exit(0);
+}
+
+const r = new JsonlReplayer();
+r.on('streaming_progress', out);
+r.on('error', e => process.stderr.write(`error: ${e?.message || e}\n`));
+
+if (opts.tail) {
+  r.start();
+  process.stdout.write('tailing... (Ctrl-C to exit)\n');
+} else {
+  const stats = r.replay({ since });
+  process.stderr.write(`# ${stats.events} events across ${stats.files} files (matched: ${count})\n`);
+}

package/src/index.cjs

@@ -0,0 +1,302 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { EventEmitter } = require('events');
+
+const DEFAULT_DIR = path.join(os.homedir(), '.claude', 'projects');
+const DEBOUNCE_MS = 16;
+
+class JsonlWatcher extends EventEmitter {
+  constructor(projectsDir = DEFAULT_DIR) {
+    super();
+    this._dir = projectsDir;
+    this._tails = new Map();
+    this._convs = new Map();
+    this._emitted = new Map();
+    this._timers = new Map();
+    this._seqs = new Map();
+    this._streaming = new Set();
+    this._watcher = null;
+  }
+
+  start() {
+    if (!fs.existsSync(this._dir)) return this;
+    this._scan(this._dir, 0);
+    try {
+      this._watcher = fs.watch(this._dir, { recursive: true }, (_, f) => {
+        if (f && f.endsWith('.jsonl')) this._debounce(path.join(this._dir, f));
+      });
+      this._watcher.on('error', e => this.emit('error', e));
+    } catch (e) { this.emit('error', e); }
+    return this;
+  }
+
+  stop() {
+    if (this._watcher) try { this._watcher.close(); } catch (_) {}
+    for (const s of this._tails.values()) if (s.fd !== null) try { fs.closeSync(s.fd); } catch (_) {}
+    for (const t of this._timers.values()) clearTimeout(t);
+    this._tails.clear(); this._convs.clear(); this._emitted.clear();
+    this._timers.clear(); this._seqs.clear(); this._streaming.clear();
+  }
+
+  _scan(dir, depth) {
+    if (depth > 4) return;
+    try {
+      for (const d of fs.readdirSync(dir, { withFileTypes: true })) {
+        const fp = path.join(dir, d.name);
+        if (d.isFile() && d.name.endsWith('.jsonl')) this._debounce(fp);
+        else if (d.isDirectory()) this._scan(fp, depth + 1);
+      }
+    } catch (_) {}
+  }
+
+  _debounce(fp) {
+    const t = this._timers.get(fp);
+    if (t) clearTimeout(t);
+    this._timers.set(fp, setTimeout(() => { this._timers.delete(fp); this._read(fp); }, DEBOUNCE_MS));
+  }
+
+  _read(fp) {
+    let s = this._tails.get(fp);
+    if (!s) { s = { fd: null, offset: 0, partial: '' }; this._tails.set(fp, s); }
+    try {
+      if (s.fd === null) s.fd = fs.openSync(fp, 'r');
+      const stat = fs.fstatSync(s.fd);
+      if (stat.size <= s.offset) return;
+      const buf = Buffer.allocUnsafe(stat.size - s.offset);
+      const n = fs.readSync(s.fd, buf, 0, buf.length, s.offset);
+      s.offset += n;
+      const text = s.partial + buf.toString('utf8', 0, n);
+      const lines = []; let start = 0, idx;
+      while ((idx = text.indexOf('\n', start)) !== -1) { lines.push(text.slice(start, idx)); start = idx + 1; }
+      s.partial = text.slice(start);
+      const fallbackSid = path.basename(fp, '.jsonl');
+      for (const l of lines) this._line(l, fallbackSid, fp);
+    } catch (e) {
+      if (e.code !== 'ENOENT') this.emit('error', e);
+      if (s.fd !== null) { try { fs.closeSync(s.fd); } catch (_) {} s.fd = null; }
+    }
+  }
+
+  _line(line, fallbackSid, fp) {
+    line = line.trim();
+    if (!line) return;
+    let e;
+    try { e = JSON.parse(line); } catch (_) { return; }
+    if (!e) return;
+    const sid = e.sessionId || fallbackSid;
+    if (!sid) return;
+    const conv = this._conv(sid, e, fp);
+    if (!conv) return;
+    this._route(conv, sid, e);
+  }
+
+  _conv(sid, e, fp) {
+    if (this._convs.has(sid)) return this._convs.get(sid);
+    if (e.type === 'queue-operation' || e.type === 'last-prompt') return null;
+    if (e.type === 'user' && e.isMeta) return null;
+    const dir = fp ? path.dirname(fp) : '';
+    const isSubagent = /[\\/]subagents$/.test(dir);
+    const projectDir = fp ? path.basename(isSubagent ? path.dirname(path.dirname(dir)) : path.dirname(fp)) : '';
+    const parentSid = isSubagent ? path.basename(path.dirname(dir)) : null;
+    const cwd = e.cwd || projectDir || '';
+    const branch = e.gitBranch || '';
+    const base = path.basename(cwd);
+    const title = isSubagent ? `[agent] ${base}` : (branch ? `${branch} @ ${base}` : base);
+    const conv = { id: sid, title, cwd, file: fp || null, parentSid, isSubagent };
+    this._convs.set(sid, conv);
+    this.emit('conversation_created', { conversation: conv, timestamp: Date.now() });
+    return conv;
+  }
+
+  _seq(sid) { const n = (this._seqs.get(sid) || 0) + 1; this._seqs.set(sid, n); return n; }
+
+  _startStreaming(conv, sid) {
+    if (this._streaming.has(sid)) return;
+    this._streaming.add(sid);
+    this.emit('streaming_start', { conversationId: conv.id, conversation: conv, timestamp: Date.now() });
+  }
+
+  _endStreaming(conv, sid) {
+    if (!this._streaming.has(sid)) return;
+    this._streaming.delete(sid);
+    this.emit('streaming_complete', { conversationId: conv.id, conversation: conv, seq: this._seq(sid), timestamp: Date.now() });
+  }
+
+  _push(conv, sid, block, role) {
+    this.emit('streaming_progress', { conversationId: conv.id, conversation: conv, block, role, seq: this._seq(sid), timestamp: Date.now() });
+  }
+
+  _route(conv, sid, e) {
+    if (e.type === 'queue-operation' || e.type === 'last-prompt' || (e.type === 'user' && e.isMeta)) return;
+
+    if (e.isApiErrorMessage && e.error === 'rate_limit') {
+      this.emit('streaming_error', { conversationId: conv.id, error: 'Rate limit hit', recoverable: true, timestamp: Date.now() });
+      return;
+    }
+
+    if (e.type === 'system') {
+      if (e.subtype === 'init') { this._startStreaming(conv, sid); return; }
+      if (e.subtype === 'turn_duration' || e.subtype === 'stop_hook_summary') { this._endStreaming(conv, sid); return; }
+      this._startStreaming(conv, sid);
+      this._push(conv, sid, { type: 'system', subtype: e.subtype, model: e.model, cwd: e.cwd, tools: e.tools }, 'system');
+      return;
+    }
+
+    if (e.type === 'assistant' && e.message?.content) {
+      this._startStreaming(conv, sid);
+      const key = `${sid}:${e.message.id}`;
+      const prev = this._emitted.get(key) || 0;
+      const newBlocks = e.message.content.slice(prev);
+      if (newBlocks.length > 0) {
+        this._emitted.set(key, e.message.content.length);
+        for (const b of newBlocks) if (b?.type) this._push(conv, sid, b, 'assistant');
+      }
+      if (e.message.stop_reason) this._emitted.delete(key);
+      return;
+    }
+
+    if (e.type === 'user' && e.message?.content) {
+      this._startStreaming(conv, sid);
+      const content = e.message.content;
+      if (typeof content === 'string') {
+        if (content.trim()) this._push(conv, sid, { type: 'text', text: content }, 'user');
+      } else if (Array.isArray(content)) {
+        for (const b of content) {
+          if (!b || !b.type) continue;
+          if (b.type === 'tool_result') this._push(conv, sid, b, 'tool_result');
+          else this._push(conv, sid, b, 'user');
+        }
+      }
+      return;
+    }
+
+    if (e.type === 'result') {
+      this._push(conv, sid, { type: 'result', result: e.result, subtype: e.subtype, duration_ms: e.duration_ms, total_cost_usd: e.total_cost_usd, is_error: e.is_error || false }, 'result');
+      this._endStreaming(conv, sid);
+    }
+  }
+}
+
+function watch(projectsDir) {
+  return new JsonlWatcher(projectsDir).start();
+}
+
+class JsonlReplayer extends JsonlWatcher {
+  constructor(projectsDir = DEFAULT_DIR) { super(projectsDir); }
+
+  replay({ since = 0, files: fileFilter = null } = {}) {
+    const all = [];
+    const collect = (dir, depth) => {
+      if (depth > 5) return;
+      try {
+        for (const d of fs.readdirSync(dir, { withFileTypes: true })) {
+          const fp = path.join(dir, d.name);
+          if (d.isFile() && d.name.endsWith('.jsonl')) all.push(fp);
+          else if (d.isDirectory()) collect(fp, depth + 1);
+        }
+      } catch {}
+    };
+    if (fs.existsSync(this._dir)) collect(this._dir, 0);
+    const chosen = fileFilter ? all.filter(fileFilter) : all;
+    let emitted = 0;
+    for (const fp of chosen) {
+      const fallbackSid = path.basename(fp, '.jsonl');
+      let data;
+      try { data = fs.readFileSync(fp, 'utf8'); } catch { continue; }
+      for (const line of data.split('\n')) {
+        if (!line.trim()) continue;
+        let e; try { e = JSON.parse(line); } catch { continue; }
+        if (!e) continue;
+        const t = e.timestamp ? Date.parse(e.timestamp) : 0;
+        if (since && t && t < since) continue;
+        const sid = e.sessionId || fallbackSid;
+        if (!sid) continue;
+        const conv = this._conv(sid, e, fp);
+        if (!conv) continue;
+        this._route(conv, sid, e);
+        emitted++;
+      }
+    }
+    this.emit('replay_complete', { files: chosen.length, events: emitted, timestamp: Date.now() });
+    return { files: chosen.length, events: emitted };
+  }
+}
+
+function replay(projectsDir, opts) {
+  return new JsonlReplayer(projectsDir);
+}
+
+async function rollup({ projectsDir, since = 0, out, format = 'ndjson' } = {}) {
+  if (!out) throw new Error('rollup: out path required');
+  const r = new JsonlReplayer(projectsDir);
+  if (format === 'sqlite') return rollupSqlite(r, { since, out });
+  return rollupNdjson(r, { since, out });
+}
+
+function rollupNdjson(r, { since, out }) {
+  const stream = fs.createWriteStream(out);
+  let rows = 0;
+  r.on('streaming_progress', ev => {
+    const b = ev.block || {};
+    const text = b.text || (typeof b.content === 'string' ? b.content : '');
+    stream.write(JSON.stringify({
+      ts: ev.timestamp,
+      sid: ev.conversationId,
+      parent: ev.conversation?.parentSid || null,
+      cwd: ev.conversation?.cwd || '',
+      role: ev.role,
+      type: b.type || null,
+      text: text.slice(0, 4000),
+      tool: b.name || null,
+    }) + '\n');
+    rows++;
+  });
+  const stats = r.replay({ since });
+  stream.end();
+  return { ...stats, rows, format: 'ndjson', out };
+}
+
+async function rollupSqlite(r, { since, out }) {
+  let Database;
+  try { Database = require('better-sqlite3'); } catch {
+    throw new Error('rollup: format=sqlite requires better-sqlite3 (npm i better-sqlite3)');
+  }
+  const db = new Database(out);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS events (
+      ts INTEGER, sid TEXT, parent TEXT, cwd TEXT,
+      role TEXT, type TEXT, tool TEXT, text TEXT
+    );
+    CREATE INDEX IF NOT EXISTS events_sid ON events(sid);
+    CREATE INDEX IF NOT EXISTS events_ts ON events(ts);
+    CREATE INDEX IF NOT EXISTS events_parent ON events(parent);
+  `);
+  const insert = db.prepare('INSERT INTO events (ts, sid, parent, cwd, role, type, tool, text) VALUES (?,?,?,?,?,?,?,?)');
+  let rows = 0;
+  const tx = db.transaction(events => { for (const e of events) insert.run(e.ts, e.sid, e.parent, e.cwd, e.role, e.type, e.tool, e.text); });
+  let batch = [];
+  r.on('streaming_progress', ev => {
+    const b = ev.block || {};
+    const text = b.text || (typeof b.content === 'string' ? b.content : '');
+    batch.push({
+      ts: ev.timestamp || 0,
+      sid: ev.conversationId || '',
+      parent: ev.conversation?.parentSid || null,
+      cwd: ev.conversation?.cwd || '',
+      role: ev.role || '',
+      type: b.type || null,
+      tool: b.name || null,
+      text: (text || '').slice(0, 4000),
+    });
+    rows++;
+    if (batch.length >= 500) { tx(batch); batch = []; }
+  });
+  const stats = r.replay({ since });
+  if (batch.length) tx(batch);
+  db.close();
+  return { ...stats, rows, format: 'sqlite', out };
+}
+
+module.exports = { JsonlWatcher, JsonlReplayer, watch, replay, rollup };

package/src/index.js

@@ -0,0 +1,299 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { EventEmitter } from 'events';
+
+const DEFAULT_DIR = path.join(os.homedir(), '.claude', 'projects');
+const DEBOUNCE_MS = 16;
+
+export class JsonlWatcher extends EventEmitter {
+  constructor(projectsDir = DEFAULT_DIR) {
+    super();
+    this._dir = projectsDir;
+    this._tails = new Map();
+    this._convs = new Map();
+    this._emitted = new Map();
+    this._timers = new Map();
+    this._seqs = new Map();
+    this._streaming = new Set();
+    this._watcher = null;
+  }
+
+  start() {
+    if (!fs.existsSync(this._dir)) return this;
+    this._scan(this._dir, 0);
+    try {
+      this._watcher = fs.watch(this._dir, { recursive: true }, (_, f) => {
+        if (f && f.endsWith('.jsonl')) this._debounce(path.join(this._dir, f));
+      });
+      this._watcher.on('error', e => this.emit('error', e));
+    } catch (e) { this.emit('error', e); }
+    return this;
+  }
+
+  stop() {
+    if (this._watcher) try { this._watcher.close(); } catch (_) {}
+    for (const s of this._tails.values()) if (s.fd !== null) try { fs.closeSync(s.fd); } catch (_) {}
+    for (const t of this._timers.values()) clearTimeout(t);
+    this._tails.clear(); this._convs.clear(); this._emitted.clear();
+    this._timers.clear(); this._seqs.clear(); this._streaming.clear();
+  }
+
+  _scan(dir, depth) {
+    if (depth > 4) return;
+    try {
+      for (const d of fs.readdirSync(dir, { withFileTypes: true })) {
+        const fp = path.join(dir, d.name);
+        if (d.isFile() && d.name.endsWith('.jsonl')) this._debounce(fp);
+        else if (d.isDirectory()) this._scan(fp, depth + 1);
+      }
+    } catch (_) {}
+  }
+
+  _debounce(fp) {
+    const t = this._timers.get(fp);
+    if (t) clearTimeout(t);
+    this._timers.set(fp, setTimeout(() => { this._timers.delete(fp); this._read(fp); }, DEBOUNCE_MS));
+  }
+
+  _read(fp) {
+    let s = this._tails.get(fp);
+    if (!s) { s = { fd: null, offset: 0, partial: '' }; this._tails.set(fp, s); }
+    try {
+      if (s.fd === null) s.fd = fs.openSync(fp, 'r');
+      const stat = fs.fstatSync(s.fd);
+      if (stat.size <= s.offset) return;
+      const buf = Buffer.allocUnsafe(stat.size - s.offset);
+      const n = fs.readSync(s.fd, buf, 0, buf.length, s.offset);
+      s.offset += n;
+      const text = s.partial + buf.toString('utf8', 0, n);
+      const lines = []; let start = 0, idx;
+      while ((idx = text.indexOf('\n', start)) !== -1) { lines.push(text.slice(start, idx)); start = idx + 1; }
+      s.partial = text.slice(start);
+      const fallbackSid = path.basename(fp, '.jsonl');
+      for (const l of lines) this._line(l, fallbackSid, fp);
+    } catch (e) {
+      if (e.code !== 'ENOENT') this.emit('error', e);
+      if (s.fd !== null) { try { fs.closeSync(s.fd); } catch (_) {} s.fd = null; }
+    }
+  }
+
+  _line(line, fallbackSid, fp) {
+    line = line.trim();
+    if (!line) return;
+    let e;
+    try { e = JSON.parse(line); } catch (_) { return; }
+    if (!e) return;
+    const sid = e.sessionId || fallbackSid;
+    if (!sid) return;
+    const conv = this._conv(sid, e, fp);
+    if (!conv) return;
+    this._route(conv, sid, e);
+  }
+
+  _conv(sid, e, fp) {
+    if (this._convs.has(sid)) return this._convs.get(sid);
+    if (e.type === 'queue-operation' || e.type === 'last-prompt') return null;
+    if (e.type === 'user' && e.isMeta) return null;
+    const dir = fp ? path.dirname(fp) : '';
+    const isSubagent = /[\\/]subagents$/.test(dir);
+    const projectDir = fp ? path.basename(isSubagent ? path.dirname(path.dirname(dir)) : path.dirname(fp)) : '';
+    const parentSid = isSubagent ? path.basename(path.dirname(dir)) : null;
+    const cwd = e.cwd || projectDir || '';
+    const branch = e.gitBranch || '';
+    const base = path.basename(cwd);
+    const title = isSubagent ? `[agent] ${base}` : (branch ? `${branch} @ ${base}` : base);
+    const conv = { id: sid, title, cwd, file: fp || null, parentSid, isSubagent };
+    this._convs.set(sid, conv);
+    this.emit('conversation_created', { conversation: conv, timestamp: Date.now() });
+    return conv;
+  }
+
+  _seq(sid) { const n = (this._seqs.get(sid) || 0) + 1; this._seqs.set(sid, n); return n; }
+
+  _startStreaming(conv, sid) {
+    if (this._streaming.has(sid)) return;
+    this._streaming.add(sid);
+    this.emit('streaming_start', { conversationId: conv.id, conversation: conv, timestamp: Date.now() });
+  }
+
+  _endStreaming(conv, sid) {
+    if (!this._streaming.has(sid)) return;
+    this._streaming.delete(sid);
+    this.emit('streaming_complete', { conversationId: conv.id, conversation: conv, seq: this._seq(sid), timestamp: Date.now() });
+  }
+
+  _push(conv, sid, block, role) {
+    this.emit('streaming_progress', { conversationId: conv.id, conversation: conv, block, role, seq: this._seq(sid), timestamp: Date.now() });
+  }
+
+  _route(conv, sid, e) {
+    if (e.type === 'queue-operation' || e.type === 'last-prompt' || (e.type === 'user' && e.isMeta)) return;
+
+    if (e.isApiErrorMessage && e.error === 'rate_limit') {
+      this.emit('streaming_error', { conversationId: conv.id, error: 'Rate limit hit', recoverable: true, timestamp: Date.now() });
+      return;
+    }
+
+    if (e.type === 'system') {
+      if (e.subtype === 'init') { this._startStreaming(conv, sid); return; }
+      if (e.subtype === 'turn_duration' || e.subtype === 'stop_hook_summary') { this._endStreaming(conv, sid); return; }
+      this._startStreaming(conv, sid);
+      this._push(conv, sid, { type: 'system', subtype: e.subtype, model: e.model, cwd: e.cwd, tools: e.tools }, 'system');
+      return;
+    }
+
+    if (e.type === 'assistant' && e.message?.content) {
+      this._startStreaming(conv, sid);
+      const key = `${sid}:${e.message.id}`;
+      const prev = this._emitted.get(key) || 0;
+      const newBlocks = e.message.content.slice(prev);
+      if (newBlocks.length > 0) {
+        this._emitted.set(key, e.message.content.length);
+        for (const b of newBlocks) if (b?.type) this._push(conv, sid, b, 'assistant');
+      }
+      if (e.message.stop_reason) this._emitted.delete(key);
+      return;
+    }
+
+    if (e.type === 'user' && e.message?.content) {
+      this._startStreaming(conv, sid);
+      const content = e.message.content;
+      if (typeof content === 'string') {
+        if (content.trim()) this._push(conv, sid, { type: 'text', text: content }, 'user');
+      } else if (Array.isArray(content)) {
+        for (const b of content) {
+          if (!b || !b.type) continue;
+          if (b.type === 'tool_result') this._push(conv, sid, b, 'tool_result');
+          else this._push(conv, sid, b, 'user');
+        }
+      }
+      return;
+    }
+
+    if (e.type === 'result') {
+      this._push(conv, sid, { type: 'result', result: e.result, subtype: e.subtype, duration_ms: e.duration_ms, total_cost_usd: e.total_cost_usd, is_error: e.is_error || false }, 'result');
+      this._endStreaming(conv, sid);
+    }
+  }
+}
+
+export function watch(projectsDir) {
+  return new JsonlWatcher(projectsDir).start();
+}
+
+export class JsonlReplayer extends JsonlWatcher {
+  constructor(projectsDir = DEFAULT_DIR) { super(projectsDir); }
+
+  replay({ since = 0, files: fileFilter = null } = {}) {
+    const all = [];
+    const collect = (dir, depth) => {
+      if (depth > 5) return;
+      try {
+        for (const d of fs.readdirSync(dir, { withFileTypes: true })) {
+          const fp = path.join(dir, d.name);
+          if (d.isFile() && d.name.endsWith('.jsonl')) all.push(fp);
+          else if (d.isDirectory()) collect(fp, depth + 1);
+        }
+      } catch {}
+    };
+    if (fs.existsSync(this._dir)) collect(this._dir, 0);
+    const chosen = fileFilter ? all.filter(fileFilter) : all;
+    let emitted = 0;
+    for (const fp of chosen) {
+      const fallbackSid = path.basename(fp, '.jsonl');
+      let data;
+      try { data = fs.readFileSync(fp, 'utf8'); } catch { continue; }
+      for (const line of data.split('\n')) {
+        if (!line.trim()) continue;
+        let e; try { e = JSON.parse(line); } catch { continue; }
+        if (!e) continue;
+        const t = e.timestamp ? Date.parse(e.timestamp) : 0;
+        if (since && t && t < since) continue;
+        const sid = e.sessionId || fallbackSid;
+        if (!sid) continue;
+        const conv = this._conv(sid, e, fp);
+        if (!conv) continue;
+        this._route(conv, sid, e);
+        emitted++;
+      }
+    }
+    this.emit('replay_complete', { files: chosen.length, events: emitted, timestamp: Date.now() });
+    return { files: chosen.length, events: emitted };
+  }
+}
+
+export function replay(projectsDir, opts) {
+  return new JsonlReplayer(projectsDir);
+}
+
+export async function rollup({ projectsDir, since = 0, out, format = 'ndjson' } = {}) {
+  if (!out) throw new Error('rollup: out path required');
+  const r = new JsonlReplayer(projectsDir);
+  if (format === 'sqlite') return rollupSqlite(r, { since, out });
+  return rollupNdjson(r, { since, out });
+}
+
+function rollupNdjson(r, { since, out }) {
+  const stream = fs.createWriteStream(out);
+  let rows = 0;
+  r.on('streaming_progress', ev => {
+    const b = ev.block || {};
+    const text = b.text || (typeof b.content === 'string' ? b.content : '');
+    stream.write(JSON.stringify({
+      ts: ev.timestamp,
+      sid: ev.conversationId,
+      parent: ev.conversation?.parentSid || null,
+      cwd: ev.conversation?.cwd || '',
+      role: ev.role,
+      type: b.type || null,
+      text: text.slice(0, 4000),
+      tool: b.name || null,
+    }) + '\n');
+    rows++;
+  });
+  const stats = r.replay({ since });
+  stream.end();
+  return { ...stats, rows, format: 'ndjson', out };
+}
+
+async function rollupSqlite(r, { since, out }) {
+  let Database;
+  try { Database = (await import('better-sqlite3')).default; } catch {
+    throw new Error('rollup: format=sqlite requires better-sqlite3 (npm i better-sqlite3)');
+  }
+  const db = new Database(out);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS events (
+      ts INTEGER, sid TEXT, parent TEXT, cwd TEXT,
+      role TEXT, type TEXT, tool TEXT, text TEXT
+    );
+    CREATE INDEX IF NOT EXISTS events_sid ON events(sid);
+    CREATE INDEX IF NOT EXISTS events_ts ON events(ts);
+    CREATE INDEX IF NOT EXISTS events_parent ON events(parent);
+  `);
+  const insert = db.prepare('INSERT INTO events (ts, sid, parent, cwd, role, type, tool, text) VALUES (?,?,?,?,?,?,?,?)');
+  let rows = 0;
+  const tx = db.transaction(events => { for (const e of events) insert.run(e.ts, e.sid, e.parent, e.cwd, e.role, e.type, e.tool, e.text); });
+  let batch = [];
+  r.on('streaming_progress', ev => {
+    const b = ev.block || {};
+    const text = b.text || (typeof b.content === 'string' ? b.content : '');
+    batch.push({
+      ts: ev.timestamp || 0,
+      sid: ev.conversationId || '',
+      parent: ev.conversation?.parentSid || null,
+      cwd: ev.conversation?.cwd || '',
+      role: ev.role || '',
+      type: b.type || null,
+      tool: b.name || null,
+      text: (text || '').slice(0, 4000),
+    });
+    rows++;
+    if (batch.length >= 500) { tx(batch); batch = []; }
+  });
+  const stats = r.replay({ since });
+  if (batch.length) tx(batch);
+  db.close();
+  return { ...stats, rows, format: 'sqlite', out };
+}