@specship/specship-darwin-arm64 0.29.0 → 0.30.0

package/lib/dist/server/ingest/transcripts/gemini.js

@@ -0,0 +1,469 @@
+/**
+ * Gemini CLI transcript adapter (REQ-AGENTSWITCH-004, DOM-SPECSHIP-007).
+ *
+ * Verified against @google/gemini-cli-core 0.28.0
+ * (services/chatRecordingService.js, core/geminiChat.js, config/storage.js):
+ *
+ *   - a session is ONE pretty-printed JSON document at
+ *     `~/.gemini/tmp/<project_hash>/chats/session-<timestamp>-<id8>.json`,
+ *     rewritten whole on every update — never JSON lines;
+ *   - `<project_hash>` is sha256(project root) in hex, so a project is
+ *     recognised by hashing the roots the caller knows; otherwise the path is
+ *     kept as `gemini:<hash>` (never guessed);
+ *   - `messages[]` carry `type` ('user' | 'gemini' | 'info' | …), `content`
+ *     (string or parts), and on gemini messages `toolCalls[]`
+ *     (`{ id, name, args, result: responseParts | null, timestamp }`),
+ *     `thoughts[]` (`{ subject, description }`), `tokens`
+ *     (`{ input, output, cached, thoughts, … }`) and `model`;
+ *   - an MCP tool is recorded under its bare name (`specship_explore`); the
+ *     qualified `<server>__<tool>` form appears only on a name collision.
+ *
+ * Gemini CLI 0.33.0 changed both (REQ-AGENTSWITCH-018; verified against
+ * 0.67.0 services/chatRecordingService and config/storage):
+ *
+ *   - a session is JSON Lines (`session-*.jsonl`): a metadata record
+ *     (`sessionId`, `projectHash`, `startTime`, …, optionally `messages`),
+ *     then message records (keyed by `id`, the last one for an id wins),
+ *     `{ $set }` metadata updates (a `$set.messages` replaces the list),
+ *     `{ $patch }` records (`content` and tool-call `result`s for an id,
+ *     `updates[]`, `removeIds[]`, `orderIds[]`) and `{ $rewindTo }`;
+ *   - the folder is a short project name from Gemini's project registry, so
+ *     the project is resolved from the header's `projectHash` (still
+ *     sha256 of the root);
+ *   - MCP tools are named `mcp_<server>_<tool>`;
+ *   - tool responses and Gemini's `<session_context>` / `<hook_context>`
+ *     turns are also `user` messages (they open no prompt), and a prompt's
+ *     own text is in `displayContent` when Gemini added context to it.
+ *
+ * Tool names are mapped onto the shared set; a document that does not parse,
+ * or has no `messages` array, is unreadable — `parseFile` returns null and
+ * the ingestor counts it.
+ */
+import * as crypto from 'crypto';
+import * as fs from 'fs';
+import * as path from 'path';
+import { GEMINI_PROFILE } from '../../host-profiles.js';
+import { CANONICAL_TOOLS, specshipServerName, canonicalMcpToolName } from '../../canonical-tools.js';
+import { summarizeToolInput, toEpochMs } from './shared.js';
+import { normalizeToolName, } from './types.js';
+/** Gemini CLI 0.28.0 built-in tool names → shared names. */
+export const GEMINI_TOOL_NAMES = Object.freeze({
+    read_file: CANONICAL_TOOLS.read,
+    read_many_files: CANONICAL_TOOLS.read,
+    run_shell_command: CANONICAL_TOOLS.bash,
+    grep_search: CANONICAL_TOOLS.grep,
+    glob: CANONICAL_TOOLS.glob,
+    write_file: CANONICAL_TOOLS.write,
+    replace: CANONICAL_TOOLS.edit,
+});
+/** Bare SpecShip tools all start with this (tools/mcp-tool.js records the server's own tool name). */
+const bareSpecshipPrefix = `${specshipServerName}_`;
+/** The collision-qualified form Gemini used before 0.33.0: `<server>__<tool>`. */
+const QUALIFIED_RE = /^([A-Za-z0-9_-]+?)__(.+)$/;
+/** The form Gemini uses from 0.33.0: `mcp_<server>_<tool>` (server names carry no `_`). */
+const MCP_PREFIXED_RE = /^mcp_([^_]+)_(.+)$/;
+/** Map one Gemini tool name onto the shared set. */
+export function normalizeGeminiToolName(raw) {
+    const builtin = normalizeToolName(GEMINI_TOOL_NAMES, raw);
+    if (builtin !== raw)
+        return builtin;
+    const p = raw.match(MCP_PREFIXED_RE);
+    if (p)
+        return canonicalMcpToolName(p[1], p[2]);
+    const q = raw.match(QUALIFIED_RE);
+    if (q)
+        return canonicalMcpToolName(q[1], q[2]);
+    if (raw.startsWith(bareSpecshipPrefix))
+        return canonicalMcpToolName(specshipServerName, raw);
+    return raw;
+}
+/** Re-key Gemini args onto the shape the shared summariser reads. */
+function summarize(raw, name, args) {
+    if (!args || typeof args !== 'object')
+        return '';
+    if (raw === 'read_many_files') {
+        const inc = args['include'] ?? args['paths'];
+        if (Array.isArray(inc))
+            return inc.filter((x) => typeof x === 'string').join(', ').slice(0, 400);
+    }
+    const file = args['file_path'] ?? args['absolute_path'] ?? args['path'];
+    const keyed = typeof file === 'string' && args['file_path'] === undefined ? { ...args, file_path: file } : args;
+    return summarizeToolInput(name, keyed);
+}
+/** Text carried by a Gemini content / result value (string, part, or part list). */
+function textLength(v) {
+    if (v == null)
+        return 0;
+    if (typeof v === 'string')
+        return v.length;
+    if (Array.isArray(v))
+        return v.reduce((n, p) => n + textLength(p), 0);
+    if (typeof v === 'object') {
+        const o = v;
+        if (typeof o['text'] === 'string')
+            return o['text'].length;
+        const fr = o['functionResponse'];
+        if (fr && typeof fr === 'object') {
+            const out = fr.response?.['output'];
+            if (typeof out === 'string')
+                return out.length;
+            try {
+                return JSON.stringify(fr.response ?? null).length;
+            }
+            catch {
+                return 0;
+            }
+        }
+    }
+    return 0;
+}
+function contentText(v) {
+    if (typeof v === 'string')
+        return v;
+    if (Array.isArray(v)) {
+        return v.map((p) => (p && typeof p === 'object' && typeof p.text === 'string' ? p.text : ''))
+            .filter(Boolean).join('\n').trim();
+    }
+    if (v && typeof v === 'object' && typeof v.text === 'string')
+        return v.text;
+    return '';
+}
+const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : 0);
+const isRec = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+const strProp = (o, k) => (typeof o[k] === 'string' ? o[k] : undefined);
+/**
+ * Fold a JSON Lines session (Gemini CLI >= 0.33.0) into the single-document
+ * shape, applying records in order the way Gemini's own loader does.
+ * Malformed lines are skipped; null when no metadata record is found.
+ */
+export function foldGeminiJsonl(text) {
+    let meta = null;
+    const messages = new Map();
+    const setMessages = (list) => {
+        if (!Array.isArray(list))
+            return;
+        for (const m of list)
+            if (isRec(m) && strProp(m, 'id'))
+                messages.set(m['id'], m);
+    };
+    const patchOne = (patch) => {
+        const existing = messages.get(patch['id']);
+        if (!existing)
+            return;
+        if (patch['content'] !== undefined)
+            existing['content'] = patch['content'];
+        const calls = existing['toolCalls'];
+        if (Array.isArray(patch['toolCalls']) && Array.isArray(calls)) {
+            for (const tp of patch['toolCalls']) {
+                if (!isRec(tp) || !('result' in tp))
+                    continue;
+                const tc = calls.find((c) => isRec(c) && c['id'] === tp['id']);
+                if (isRec(tc))
+                    tc['result'] = tp['result'];
+            }
+        }
+    };
+    for (const line of text.split('\n')) {
+        if (!line.trim())
+            continue;
+        let r;
+        try {
+            r = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (!isRec(r))
+            continue;
+        const rewind = strProp(r, '$rewindTo');
+        if (rewind !== undefined) {
+            let found = false;
+            for (const id of [...messages.keys()]) {
+                if (id === rewind)
+                    found = true;
+                if (found)
+                    messages.delete(id);
+            }
+            if (!found)
+                messages.clear();
+        }
+        else if (isRec(r['$patch'])) {
+            const p = r['$patch'];
+            if (strProp(p, 'id'))
+                patchOne(p);
+            if (Array.isArray(p['updates']))
+                for (const u of p['updates'])
+                    if (isRec(u) && strProp(u, 'id'))
+                        patchOne(u);
+            if (Array.isArray(p['removeIds']))
+                for (const id of p['removeIds'])
+                    if (typeof id === 'string')
+                        messages.delete(id);
+            if (Array.isArray(p['orderIds'])) {
+                const ordered = p['orderIds'].filter((id) => typeof id === 'string' && messages.has(id));
+                const keep = new Set(ordered);
+                const entries = [...messages.entries()];
+                messages.clear();
+                for (const [id, m] of entries)
+                    if (!keep.has(id))
+                        messages.set(id, m);
+                for (const id of ordered)
+                    messages.set(id, entries.find(([k]) => k === id)[1]);
+            }
+        }
+        else if (strProp(r, 'id')) {
+            messages.set(r['id'], r);
+        }
+        else if (isRec(r['$set'])) {
+            const set = r['$set'];
+            if (Array.isArray(set['messages'])) {
+                messages.clear();
+                setMessages(set['messages']);
+            }
+            meta = { ...(meta ?? {}), ...set };
+        }
+        else if (strProp(r, 'sessionId') && strProp(r, 'projectHash')) {
+            meta = { ...(meta ?? {}), ...r };
+            setMessages(r['messages']);
+        }
+    }
+    if (!meta)
+        return null;
+    return { ...meta, messages: [...messages.values()] };
+}
+/** Parse one Gemini session (a JSON document, or JSON Lines). Null when it cannot be read. */
+export function parseGeminiSession(text) {
+    let doc;
+    try {
+        doc = JSON.parse(text);
+    }
+    catch {
+        doc = null;
+    }
+    // A JSON Lines session — or one holding only its header line, which parses whole.
+    if (!isRec(doc) || !Array.isArray(doc['messages']))
+        doc = foldGeminiJsonl(text);
+    if (!doc || typeof doc !== 'object')
+        return null;
+    const d = doc;
+    if (typeof d.sessionId !== 'string' || !d.sessionId || !Array.isArray(d.messages))
+        return null;
+    const sessionId = d.sessionId;
+    const startedAt = typeof d.startTime === 'string' ? toEpochMs(d.startTime) : 0;
+    const prompts = [];
+    let current = null;
+    let lastModel = null;
+    let lastTs = startedAt;
+    const openPrompt = (id, text, ts) => {
+        const p = {
+            id, text, ts, model: null,
+            inputTokens: 0, outputTokens: 0, cacheCreationTokens: 0, cacheReadTokens: 0,
+            assistantText: null, thinkingText: null, toolCalls: [],
+        };
+        prompts.push(p);
+        return p;
+    };
+    d.messages.forEach((m, i) => {
+        if (!m || typeof m !== 'object')
+            return;
+        const msg = m;
+        const ts = typeof msg['timestamp'] === 'string' ? toEpochMs(msg['timestamp']) : lastTs;
+        lastTs = Math.max(lastTs, ts);
+        const id = typeof msg['id'] === 'string' && msg['id'] ? msg['id'] : `${sessionId}:${i}`;
+        if (msg['type'] === 'user') {
+            // From 0.33.0 Gemini also records tool responses (no text parts) and
+            // its own `<session_context>` / `<hook_context>` turns as user
+            // messages; like Gemini's own resume logic, those start no prompt.
+            const said = contentText(msg['content']);
+            if (!said || /^<(session|hook)_context>/.test(said))
+                return;
+            current = openPrompt(id, contentText(msg['displayContent']) || said, ts);
+            return;
+        }
+        if (msg['type'] !== 'gemini')
+            return;
+        // A gemini turn before any user message still belongs to a prompt row.
+        const prompt = current ?? (current = openPrompt(`${sessionId}:prompt`, null, ts));
+        const model = typeof msg['model'] === 'string' && msg['model'] ? msg['model'] : null;
+        if (model) {
+            prompt.model = model;
+            lastModel = model;
+        }
+        const tokens = (msg['tokens'] ?? null);
+        if (tokens && typeof tokens === 'object') {
+            const cached = num(tokens['cached']);
+            prompt.inputTokens += Math.max(0, num(tokens['input']) - cached);
+            prompt.cacheReadTokens += cached;
+            prompt.outputTokens += num(tokens['output']) + num(tokens['thoughts']);
+        }
+        const said = contentText(msg['content']);
+        if (said)
+            prompt.assistantText = (prompt.assistantText ?? '') + said + '\n\n';
+        const thoughts = msg['thoughts'];
+        if (Array.isArray(thoughts)) {
+            const t = thoughts
+                .map((th) => (th && typeof th === 'object'
+                ? [th.subject, th.description]
+                    .filter((x) => typeof x === 'string' && x.length > 0).join(': ')
+                : ''))
+                .filter(Boolean).join('\n');
+            if (t)
+                prompt.thinkingText = (prompt.thinkingText ?? '') + t + '\n\n';
+        }
+        const calls = msg['toolCalls'];
+        if (!Array.isArray(calls))
+            return;
+        calls.forEach((c, j) => {
+            if (!c || typeof c !== 'object')
+                return;
+            const call = c;
+            const rawName = typeof call['name'] === 'string' ? call['name'] : '';
+            if (!rawName)
+                return;
+            const name = normalizeGeminiToolName(rawName);
+            const args = call['args'] && typeof call['args'] === 'object' ? call['args'] : undefined;
+            let inputJson = null;
+            try {
+                inputJson = JSON.stringify(call['args'] ?? null);
+            }
+            catch {
+                inputJson = null;
+            }
+            const tc = {
+                id: typeof call['id'] === 'string' && call['id'] ? call['id'] : `${id}:${j}`,
+                rawName,
+                name,
+                summary: summarize(rawName, name, args),
+                inputJson,
+                resultLength: textLength(call['result']),
+                ts: typeof call['timestamp'] === 'string' ? toEpochMs(call['timestamp']) : ts,
+            };
+            prompt.toolCalls.push(tc);
+        });
+    });
+    const endedAt = typeof d.lastUpdated === 'string' ? Math.max(toEpochMs(d.lastUpdated), lastTs) : lastTs;
+    return { sessionId, startedAt: startedAt || (prompts[0]?.ts ?? endedAt), endedAt, model: lastModel, prompts };
+}
+/** sha256(root) in hex — Gemini's project hash (config/storage.js getFilePathHash). */
+export function geminiProjectHash(projectRoot) {
+    return crypto.createHash('sha256').update(projectRoot).digest('hex');
+}
+const isSessionFile = (name) => /\.jsonl?$/i.test(name);
+/** The `projectHash` in a JSON Lines session's header, read from its first line. */
+function headerProjectHash(file) {
+    let fd;
+    try {
+        fd = fs.openSync(file, 'r');
+        const buf = Buffer.alloc(64 * 1024);
+        const n = fs.readSync(fd, buf, 0, buf.length, 0);
+        const first = buf.toString('utf-8', 0, n).split('\n', 1)[0] ?? '';
+        const rec = JSON.parse(first);
+        return isRec(rec) && typeof rec['projectHash'] === 'string' ? rec['projectHash'] : null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        if (fd !== undefined)
+            fs.closeSync(fd);
+    }
+}
+/**
+ * Every `<root>/<project>/chats/*.json[l]`. The project is resolved when a
+ * known root hashes to the folder name (before 0.33.0) or to the session
+ * header's `projectHash` (0.33.0 on); otherwise it is kept as `gemini:<id>`.
+ */
+export function listGeminiTranscriptFiles(root, ctx = {}) {
+    const byHash = new Map();
+    for (const p of ctx.projectPaths ?? [])
+        byHash.set(geminiProjectHash(p), p);
+    const out = [];
+    let hashes;
+    try {
+        hashes = fs.readdirSync(root, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const h of hashes) {
+        if (!h.isDirectory())
+            continue;
+        const chats = path.join(root, h.name, 'chats');
+        let files;
+        try {
+            files = fs.readdirSync(chats, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        const byDir = byHash.get(h.name);
+        for (const f of files) {
+            if (!f.isFile() || !isSessionFile(f.name))
+                continue;
+            const filePath = path.join(chats, f.name);
+            let projectPath = byDir;
+            if (!projectPath && f.name.toLowerCase().endsWith('.jsonl')) {
+                const hash = headerProjectHash(filePath);
+                if (hash)
+                    projectPath = byHash.get(hash);
+            }
+            out.push({ filePath, projectPath: projectPath ?? `${GEMINI_PROFILE.id}:${h.name}` });
+        }
+    }
+    return out;
+}
+/**
+ * Projects in Gemini CLI's registry (`~/.gemini/projects.json`, 0.33.0+:
+ * `{ projects: { <root>: <short id> } }`), with the session count and newest
+ * session under `tmp/<short id>/chats` (REQ-AGENTSWITCH-019.A1).
+ */
+export function listGeminiProjects(home) {
+    const dir = path.join(home, GEMINI_PROFILE.configDir);
+    let projects;
+    try {
+        const parsed = JSON.parse(fs.readFileSync(path.join(dir, 'projects.json'), 'utf-8'));
+        if (!isRec(parsed) || !isRec(parsed['projects']))
+            return [];
+        projects = parsed['projects'];
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const [root, id] of Object.entries(projects)) {
+        if (!path.isAbsolute(root))
+            continue;
+        let sessionCount = 0;
+        let lastModifiedMs = 0;
+        if (typeof id === 'string' && id && !/[\\/]/.test(id)) {
+            const chats = path.join(dir, 'tmp', id, 'chats');
+            try {
+                for (const f of fs.readdirSync(chats, { withFileTypes: true })) {
+                    if (!f.isFile() || !isSessionFile(f.name))
+                        continue;
+                    sessionCount++;
+                    try {
+                        lastModifiedMs = Math.max(lastModifiedMs, fs.statSync(path.join(chats, f.name)).mtimeMs);
+                    }
+                    catch { /* gone */ }
+                }
+            }
+            catch { /* no sessions yet */ }
+        }
+        out.push({ path: root, sessionCount, lastModifiedMs });
+    }
+    return out;
+}
+export const geminiTranscriptAdapter = {
+    id: GEMINI_PROFILE.id,
+    format: 'document',
+    defaultRoot: (home) => path.join(home, GEMINI_PROFILE.configDir, 'tmp'),
+    listFiles: listGeminiTranscriptFiles,
+    listProjects: listGeminiProjects,
+    watches: (fileName) => {
+        const parts = fileName.split(/[\\/]/);
+        return parts.length >= 2 && parts[parts.length - 2] === 'chats' && isSessionFile(fileName);
+    },
+    normalizeToolName: normalizeGeminiToolName,
+    parseFile: parseGeminiSession,
+};

package/lib/dist/server/ingest/transcripts/index.js

@@ -0,0 +1,14 @@
+/**
+ * Transcript adapter registry (REQ-AGENTSWITCH-004) — one adapter per agent,
+ * Claude Code first (the default host). Mirrors `src/workflows/agents/index.ts`.
+ */
+import { claudeTranscriptAdapter } from './claude.js';
+import { geminiTranscriptAdapter } from './gemini.js';
+const ADAPTERS = [claudeTranscriptAdapter, geminiTranscriptAdapter];
+/** Every transcript adapter. */
+export function transcriptAdapters() {
+    return ADAPTERS;
+}
+export { claudeTranscriptAdapter, decodeProjectSlug, listClaudeTranscriptFiles } from './claude.js';
+export { geminiTranscriptAdapter, normalizeGeminiToolName, parseGeminiSession, geminiProjectHash, GEMINI_TOOL_NAMES } from './gemini.js';
+export { normalizeToolName } from './types.js';

package/lib/dist/server/ingest/{parser.js → transcripts/shared.js}

@@ -1,24 +1,8 @@
 /**
- * JSONL line parser — converts one line of a Claude Code transcript into a
- * structured ClaudeRawEntry, or null for unparseable / unrecognised lines.
- *
- * Tolerant: a malformed line never throws; the worker logs and skips it.
+ * Agent-neutral transcript helpers shared by every transcript adapter
+ * (REQ-AGENTSWITCH-017): timestamp normalisation and the one-line tool-input
+ * summary the heatmap, tips and reflect read.
  */
-export function parseLine(line) {
-    const trimmed = line.trim();
-    if (!trimmed)
-        return null;
-    try {
-        const obj = JSON.parse(trimmed);
-        if (!obj || typeof obj !== 'object' || typeof obj.type !== 'string') {
-            return null;
-        }
-        return obj;
-    }
-    catch {
-        return null;
-    }
-}
 /** Convert a timestamp field (ISO string or epoch number) to epoch ms. */
 export function toEpochMs(ts) {
     if (ts == null)
@@ -30,24 +14,6 @@ export function toEpochMs(ts) {
     const parsed = Date.parse(ts);
     return Number.isFinite(parsed) ? parsed : Date.now();
 }
-/** Extract the user-visible prompt text from a user-entry message. */
-export function extractUserPrompt(entry) {
-    // Some user entries store text at the top level; most use message.content.
-    if (typeof entry.text === 'string' && entry.text.length > 0)
-        return entry.text;
-    const content = entry.message?.content;
-    if (typeof content === 'string')
-        return content;
-    if (Array.isArray(content)) {
-        return content
-            .filter((b) => b && typeof b === 'object')
-            .map((b) => (b.type === 'text' && typeof b.text === 'string' ? b.text : ''))
-            .filter((t) => t.length > 0)
-            .join('\n')
-            .trim();
-    }
-    return '';
-}
 /**
  * For a tool_use block, build a short, format-aware input summary:
  *   - Read/Edit/Write → file path
@@ -90,15 +56,3 @@ export function summarizeToolInput(name, input) {
         return '';
     }
 }
-/** Sum the character length of a tool_result content block. */
-export function toolResultLength(block) {
-    if (!block)
-        return 0;
-    const c = block.content;
-    if (typeof c === 'string')
-        return c.length;
-    if (Array.isArray(c)) {
-        return c.reduce((sum, item) => sum + (typeof item?.text === 'string' ? item.text.length : 0), 0);
-    }
-    return 0;
-}

package/lib/dist/server/ingest/transcripts/types.js

@@ -0,0 +1,4 @@
+/** Look `raw` up in an adapter's name map; an unmapped name passes through. */
+export function normalizeToolName(map, raw) {
+    return Object.prototype.hasOwnProperty.call(map, raw) ? map[raw] : raw;
+}

package/lib/dist/server/ingest/watcher.js

@@ -1,23 +1,23 @@
 /**
- * Filesystem watcher that re-runs the ingestor on JSONL changes.
+ * Filesystem watcher that re-runs the ingestor on transcript changes, one
+ * watched root per transcript adapter (REQ-AGENTSWITCH-004).
  *
  * Strategy:
  *   - One initial full pass on start (catches everything written while the
  *     watcher wasn't running — same offset state, no duplicates).
- *   - fs.watch on the ~/.claude/projects/ tree, debounced 300ms — Claude
- *     Code writes one line at a time during a session, so we don't want to
- *     re-ingest on every keystroke.
+ *   - fs.watch on each adapter's transcript root, debounced 300ms — agents
+ *     write a session incrementally, so we don't want to re-ingest on every
+ *     keystroke.
  *   - On change, re-run ingestAll. The state table makes this cheap: only
  *     new bytes are read + parsed.
  */
 import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import { ingestAll } from './ingestor.js';
+import { ingestAll, resolveIngestRoots } from './ingestor.js';
 export function startWatcher(db, options = {}) {
-    const claudeRoot = options.claudeRoot ?? path.join(os.homedir(), '.claude', 'projects');
     const debounceMs = options.debounceMs ?? 300;
     const verbose = options.verbose ?? false;
+    // One root per transcript adapter (REQ-AGENTSWITCH-004).
+    const targets = resolveIngestRoots(options);
     let pending = null;
     const triggerSoon = () => {
         if (pending)
@@ -25,7 +25,7 @@ export function startWatcher(db, options = {}) {
         pending = setTimeout(() => {
             pending = null;
             try {
-                ingestAll(db, { ...options, claudeRoot });
+                ingestAll(db, options);
             }
             catch (err) {
                 if (verbose) {
@@ -39,24 +39,25 @@ export function startWatcher(db, options = {}) {
     if (options.initialIngest !== false) {
         triggerSoon();
     }
-    // fs.watch on the root, recursive. On macOS + Linux this gives us per-file
-    // events; on Windows the recursive flag is supported as of recent Node.
-    let watcher = null;
-    try {
-        watcher = fs.watch(claudeRoot, { recursive: true, persistent: true }, (eventType, filename) => {
-            if (!filename)
-                return;
-            const f = filename.toString();
-            if (!f.toLowerCase().endsWith('.jsonl'))
-                return;
-            triggerSoon();
-        });
-    }
-    catch (err) {
-        // Directory doesn't exist (user hasn't run Claude Code) — just no-op.
-        if (verbose) {
-            // eslint-disable-next-line no-console
-            console.error('[ingest watcher] could not watch', claudeRoot, ':', err instanceof Error ? err.message : String(err));
+    // fs.watch each adapter's root, recursive. On macOS + Linux this gives us
+    // per-file events; on Windows the recursive flag is supported as of recent Node.
+    const watchers = [];
+    for (const { adapter, root } of targets) {
+        try {
+            watchers.push(fs.watch(root, { recursive: true, persistent: true }, (_eventType, filename) => {
+                if (!filename)
+                    return;
+                if (!adapter.watches(filename.toString()))
+                    return;
+                triggerSoon();
+            }));
+        }
+        catch (err) {
+            // Directory doesn't exist (the agent was never used here) — just no-op.
+            if (verbose) {
+                // eslint-disable-next-line no-console
+                console.error('[ingest watcher] could not watch', root, ':', err instanceof Error ? err.message : String(err));
+            }
         }
     }
     return {
@@ -65,13 +66,13 @@ export function startWatcher(db, options = {}) {
                 clearTimeout(pending);
                 pending = null;
             }
-            if (watcher) {
+            for (const w of watchers) {
                 try {
-                    watcher.close();
+                    w.close();
                 }
                 catch { /* ignore */ }
             }
         },
-        ingestNow: () => ingestAll(db, { ...options, claudeRoot }),
+        ingestNow: () => ingestAll(db, options),
     };
 }