litmus-cli 1.4.2 → 1.4.3

package/dist/lib/backfill-tools.js

@@ -0,0 +1,787 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+import crypto from "crypto";
+import { execFileSync } from "child_process";
+import { createRequire } from "module";
+import { MAX_PROMPT_LENGTH, MAX_RESPONSE_LENGTH, MAX_TRANSCRIPT_BYTES, fitSerialized, sessionMatchesAssessment, truncate, windowEvents, } from "./backfill.js";
+function emptyScan(source, tool) {
+    return { source, tool, notes: [], sessions: [], scannedFiles: 0, skippedOversized: [], unreadable: [] };
+}
+function promptEvent(source, tool, ts, text, sessionId, approx = false) {
+    const event = {
+        ts,
+        type: "ai_prompt",
+        tool,
+        prompt: truncate(text, MAX_PROMPT_LENGTH),
+        backfilled: true,
+        backfillSource: source,
+    };
+    if (sessionId)
+        event.sessionId = sessionId;
+    if (approx)
+        event.tsApproximate = true;
+    return fitSerialized(event);
+}
+function responseEvent(source, tool, ts, text, sessionId, approx = false) {
+    const event = {
+        ts,
+        type: "ai_response",
+        tool,
+        text: truncate(text, MAX_RESPONSE_LENGTH),
+        backfilled: true,
+        backfillSource: source,
+    };
+    if (sessionId)
+        event.sessionId = sessionId;
+    if (approx)
+        event.tsApproximate = true;
+    return fitSerialized(event);
+}
+function asRecord(v) {
+    return v && typeof v === "object" && !Array.isArray(v) ? v : null;
+}
+function str(v) {
+    return typeof v === "string" && v.length > 0 ? v : null;
+}
+function listDirs(dir) {
+    try {
+        return fs.readdirSync(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    }
+    catch {
+        return [];
+    }
+}
+function listFiles(dir) {
+    try {
+        return fs.readdirSync(dir, { withFileTypes: true }).filter((d) => d.isFile()).map((d) => d.name);
+    }
+    catch {
+        return [];
+    }
+}
+/** Read a file within the transcript size cap, recording the reason it was skipped. */
+function readCapped(file, scan) {
+    let stat;
+    try {
+        stat = fs.statSync(file);
+    }
+    catch {
+        scan.unreadable.push(file);
+        return null;
+    }
+    if (stat.size > MAX_TRANSCRIPT_BYTES) {
+        scan.skippedOversized.push(file);
+        return null;
+    }
+    try {
+        return fs.readFileSync(file, "utf8");
+    }
+    catch {
+        scan.unreadable.push(file);
+        return null;
+    }
+}
+function mtimeIso(file) {
+    try {
+        return fs.statSync(file).mtime.toISOString();
+    }
+    catch {
+        return new Date(0).toISOString();
+    }
+}
+function pushSession(scan, file, label, sessionId, events) {
+    if (events.length === 0)
+        return;
+    scan.sessions.push({
+        file,
+        label,
+        tool: scan.tool,
+        sessionId,
+        prompts: events.filter((e) => e.type === "ai_prompt").length,
+        responses: events.filter((e) => e.type === "ai_response").length,
+        events,
+    });
+}
+// ── Gemini CLI ────────────────────────────────────────────────────
+export function defaultGeminiDir() {
+    return path.join(os.homedir(), ".gemini");
+}
+/** Project ids the Gemini registry attributes to roots inside the assessment. */
+function geminiProjectIdsInScope(geminiDir, assessmentRoot) {
+    const ids = new Set();
+    try {
+        const parsed = JSON.parse(fs.readFileSync(path.join(geminiDir, "projects.json"), "utf8"));
+        const projects = asRecord(asRecord(parsed)?.projects);
+        for (const [root, entry] of Object.entries(projects ?? {})) {
+            const id = str(entry) ?? str(asRecord(entry)?.shortId) ?? str(asRecord(entry)?.id);
+            if (id && sessionMatchesAssessment([root], assessmentRoot))
+                ids.add(id);
+        }
+    }
+    catch { /* no registry — legacy hash dirs below still apply */ }
+    // Legacy layout: the temp dir was keyed by sha256 of the resolved root.
+    const candidates = [path.resolve(assessmentRoot)];
+    try {
+        candidates.push(fs.realpathSync(assessmentRoot));
+    }
+    catch { /* deleted/unmaterialized root — resolve-only is fine */ }
+    for (const p of candidates) {
+        ids.add(crypto.createHash("sha256").update(p).digest("hex"));
+    }
+    return ids;
+}
+/** One chats/ file: either a JSON object with `messages`, or JSONL (metadata record first). */
+export function parseGeminiChatFile(raw, isJsonl, fallbackTs) {
+    let sessionId = null;
+    const messages = [];
+    if (isJsonl) {
+        for (const line of raw.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            let rec;
+            try {
+                rec = asRecord(JSON.parse(trimmed));
+            }
+            catch {
+                continue;
+            }
+            if (!rec || "$set" in rec)
+                continue;
+            if (!sessionId && str(rec.sessionId) && !rec.type) {
+                sessionId = str(rec.sessionId); // leading metadata record
+                continue;
+            }
+            if (str(rec.type) && rec.content !== undefined)
+                messages.push(rec);
+        }
+    }
+    else {
+        try {
+            const obj = asRecord(JSON.parse(raw));
+            sessionId = str(obj?.sessionId);
+            for (const m of Array.isArray(obj?.messages) ? obj.messages : []) {
+                const rec = asRecord(m);
+                if (rec)
+                    messages.push(rec);
+            }
+        }
+        catch { /* corrupt file — nothing extractable */ }
+    }
+    const events = [];
+    for (const msg of messages) {
+        const ts = str(msg.timestamp) ?? fallbackTs;
+        const content = str(msg.content);
+        if (!content)
+            continue; // synthetic/binary records carry no text
+        if (msg.type === "user")
+            events.push(promptEvent("gemini_transcript", "gemini", ts, content, sessionId));
+        else if (msg.type === "gemini")
+            events.push(responseEvent("gemini_transcript", "gemini", ts, content, sessionId));
+    }
+    return { sessionId, events };
+}
+export function collectGeminiSessions(opts) {
+    const scan = emptyScan("gemini_transcript", "gemini");
+    const tmpDir = path.join(opts.geminiDir, "tmp");
+    const available = new Set(listDirs(tmpDir));
+    if (available.size === 0)
+        return scan;
+    const inScope = opts.allSessions ? available : geminiProjectIdsInScope(opts.geminiDir, opts.assessmentRoot);
+    for (const id of inScope) {
+        if (!available.has(id))
+            continue;
+        const projectDir = path.join(tmpDir, id);
+        const chatSessionIds = new Set();
+        const chatsDir = path.join(projectDir, "chats");
+        for (const name of listFiles(chatsDir)) {
+            const isJsonl = name.endsWith(".jsonl");
+            if (!isJsonl && !name.endsWith(".json"))
+                continue;
+            const file = path.join(chatsDir, name);
+            scan.scannedFiles++;
+            const raw = readCapped(file, scan);
+            if (raw === null)
+                continue;
+            const parsed = parseGeminiChatFile(raw, isJsonl, mtimeIso(file));
+            if (parsed.sessionId)
+                chatSessionIds.add(parsed.sessionId);
+            pushSession(scan, file, path.relative(opts.geminiDir, file), parsed.sessionId, windowEvents(parsed.events, opts.sinceMs));
+        }
+        // logs.json is prompts-only; it covers sessions that predate chat
+        // recording (or had it disabled). Sessions already read from chats/
+        // are skipped so one prompt cannot arrive twice from the same store.
+        const logsFile = path.join(projectDir, "logs.json");
+        if (fs.existsSync(logsFile)) {
+            scan.scannedFiles++;
+            const raw = readCapped(logsFile, scan);
+            if (raw !== null) {
+                const bySession = new Map();
+                try {
+                    for (const entry of JSON.parse(raw)) {
+                        const rec = asRecord(entry);
+                        if (!rec || rec.type !== "user")
+                            continue;
+                        const message = str(rec.message);
+                        const sessionId = str(rec.sessionId);
+                        if (!message || !sessionId || chatSessionIds.has(sessionId))
+                            continue;
+                        const ts = str(rec.timestamp) ?? mtimeIso(logsFile);
+                        const list = bySession.get(sessionId) ?? [];
+                        list.push(promptEvent("gemini_transcript", "gemini", ts, message, sessionId));
+                        bySession.set(sessionId, list);
+                    }
+                }
+                catch {
+                    scan.unreadable.push(logsFile);
+                }
+                for (const [sessionId, events] of bySession) {
+                    pushSession(scan, logsFile, `${path.relative(opts.geminiDir, logsFile)}#${sessionId.slice(0, 8)}`, sessionId, windowEvents(events, opts.sinceMs));
+                }
+            }
+        }
+    }
+    return scan;
+}
+// ── Copilot CLI ───────────────────────────────────────────────────
+export function defaultCopilotDir() {
+    return path.join(os.homedir(), ".copilot");
+}
+export function parseCopilotCliEvents(raw, fallbackTs) {
+    let sessionId = null;
+    const cwds = [];
+    const events = [];
+    for (const line of raw.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        let rec;
+        try {
+            rec = asRecord(JSON.parse(trimmed));
+        }
+        catch {
+            continue;
+        }
+        if (!rec)
+            continue;
+        const data = asRecord(rec.data);
+        const ts = str(rec.timestamp) ?? fallbackTs;
+        if (rec.type === "session.start" && data) {
+            sessionId = str(data.sessionId) ?? sessionId;
+            const context = asRecord(data.context);
+            for (const key of ["cwd", "gitRoot"]) {
+                const p = str(context?.[key]);
+                if (p && !cwds.includes(p))
+                    cwds.push(p);
+            }
+            continue;
+        }
+        // `data.content` is the text as typed/produced; `transformedContent` is
+        // the wrapper-injected variant and is deliberately ignored.
+        if (rec.type === "user.message" && data) {
+            const content = str(data.content);
+            if (content)
+                events.push(promptEvent("copilot_cli_session", "copilot", ts, content, sessionId));
+            continue;
+        }
+        if (rec.type === "assistant.message" && data) {
+            const content = str(data.content);
+            if (content)
+                events.push(responseEvent("copilot_cli_session", "copilot", ts, content, sessionId));
+        }
+    }
+    return { sessionId, cwds, events };
+}
+/** Fallback cwd source when a session's events.jsonl lacks session.start. */
+function copilotWorkspaceYamlCwds(sessionDir) {
+    const cwds = [];
+    try {
+        const raw = fs.readFileSync(path.join(sessionDir, "workspace.yaml"), "utf8");
+        for (const key of ["cwd", "git_root"]) {
+            const m = raw.match(new RegExp(`^${key}:\\s*['"]?([^'"\\n]+)['"]?\\s*$`, "m"));
+            if (m && m[1] && !cwds.includes(m[1]))
+                cwds.push(m[1]);
+        }
+    }
+    catch { /* no workspace.yaml — session stays unattributed */ }
+    return cwds;
+}
+export function collectCopilotCliSessions(opts) {
+    const scan = emptyScan("copilot_cli_session", "copilot");
+    const stateDir = path.join(opts.copilotDir, "session-state");
+    for (const name of listDirs(stateDir)) {
+        const sessionDir = path.join(stateDir, name);
+        const file = path.join(sessionDir, "events.jsonl");
+        if (!fs.existsSync(file))
+            continue;
+        scan.scannedFiles++;
+        const raw = readCapped(file, scan);
+        if (raw === null)
+            continue;
+        const parsed = parseCopilotCliEvents(raw, mtimeIso(file));
+        if (parsed.events.length === 0)
+            continue;
+        const cwds = parsed.cwds.length > 0 ? parsed.cwds : copilotWorkspaceYamlCwds(sessionDir);
+        if (!opts.allSessions && !sessionMatchesAssessment(cwds, opts.assessmentRoot))
+            continue;
+        pushSession(scan, file, path.relative(opts.copilotDir, file), parsed.sessionId ?? name, windowEvents(parsed.events, opts.sinceMs));
+    }
+    return scan;
+}
+// ── VS Code Copilot Chat ──────────────────────────────────────────
+/** workspaceStorage roots for VS Code stable + insiders on this platform. */
+export function defaultVsCodeStorageDirs() {
+    const home = os.homedir();
+    const bases = [];
+    if (process.platform === "darwin") {
+        bases.push(path.join(home, "Library", "Application Support"));
+    }
+    else if (process.platform === "win32") {
+        if (process.env.APPDATA)
+            bases.push(process.env.APPDATA);
+    }
+    else {
+        bases.push(path.join(home, ".config"));
+    }
+    return bases.flatMap((base) => [
+        path.join(base, "Code", "User", "workspaceStorage"),
+        path.join(base, "Code - Insiders", "User", "workspaceStorage"),
+    ]);
+}
+/** file:// workspace URI → local path; null for remote (ssh/devcontainer) URIs. */
+export function fileUriToPath(uri) {
+    if (!uri.startsWith("file://"))
+        return null;
+    let p;
+    try {
+        p = decodeURIComponent(uri.slice("file://".length));
+    }
+    catch {
+        return null;
+    }
+    // Windows drive URIs arrive as file:///c:/...
+    if (process.platform === "win32" && /^\/[a-zA-Z]:/.test(p))
+        p = p.slice(1);
+    return p || null;
+}
+/**
+ * Replay a chat session append-log into its final state. Entry kinds:
+ * 0 = full initial state, 1 = set value at path `k`, 2 = append to the array
+ * at path `k`. Unknown kinds are ignored (additive format churn must not
+ * break recovery of the parts we understand).
+ */
+export function replayChatSessionLog(raw) {
+    let state = null;
+    const setPath = (root, keys, value, append) => {
+        let node = root;
+        for (let i = 0; i < keys.length - (append ? 0 : 1); i++) {
+            const key = keys[i];
+            const parent = node;
+            const idx = typeof key === "number" ? key : String(key);
+            let next = Array.isArray(node) ? node[key] : parent[idx];
+            if (next === undefined || next === null || typeof next !== "object") {
+                const following = i + 1 < keys.length ? keys[i + 1] : null;
+                next = typeof following === "number" ? [] : {};
+                if (Array.isArray(node))
+                    node[key] = next;
+                else
+                    parent[idx] = next;
+            }
+            node = next;
+        }
+        if (append) {
+            if (!Array.isArray(node))
+                return; // path exists but is not an array — malformed entry
+            if (Array.isArray(value))
+                node.push(...value);
+            else
+                node.push(value);
+            return;
+        }
+        const last = keys[keys.length - 1];
+        if (Array.isArray(node))
+            node[last] = value;
+        else
+            node[String(last)] = value;
+    };
+    for (const line of raw.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        let entry;
+        try {
+            entry = asRecord(JSON.parse(trimmed));
+        }
+        catch {
+            continue;
+        }
+        if (!entry)
+            continue;
+        if (entry.kind === 0) {
+            state = asRecord(entry.v) ?? state;
+            continue;
+        }
+        if (!state || !Array.isArray(entry.k))
+            continue;
+        if (entry.kind === 1)
+            setPath(state, entry.k, entry.v, false);
+        else if (entry.kind === 2)
+            setPath(state, entry.k, entry.v, true);
+    }
+    return state;
+}
+function epochToIso(v, fallback) {
+    return typeof v === "number" && isFinite(v) && v > 0 ? new Date(v).toISOString() : fallback;
+}
+export function extractChatSessionEvents(state, fallbackTs) {
+    const sessionId = str(state.sessionId);
+    const events = [];
+    for (const item of Array.isArray(state.requests) ? state.requests : []) {
+        const req = asRecord(item);
+        if (!req)
+            continue;
+        const ts = epochToIso(req.timestamp, fallbackTs);
+        const text = str(asRecord(req.message)?.text);
+        if (text)
+            events.push(promptEvent("copilot_chat_session", "copilot", ts, text, sessionId));
+        const parts = [];
+        for (const respItem of Array.isArray(req.response) ? req.response : []) {
+            const rec = asRecord(respItem);
+            if (!rec)
+                continue;
+            if (rec.kind === "markdownContent") {
+                const value = str(asRecord(rec.content)?.value) ?? str(rec.value);
+                if (value)
+                    parts.push(value);
+                continue;
+            }
+            // Assistant markdown most commonly serializes as a bare IMarkdownString
+            // ({value, isTrusted, supportThemeIcons, ...}) with NO kind field —
+            // every kinded part (thinking, toolInvocationSerialized, references)
+            // is something other than the reply text and is skipped.
+            if (rec.kind === undefined) {
+                const value = str(rec.value);
+                const markdownMarkers = "isTrusted" in rec || "supportThemeIcons" in rec || "supportHtml" in rec;
+                if (value && (markdownMarkers || Object.keys(rec).length === 1))
+                    parts.push(value);
+            }
+        }
+        if (parts.length > 0) {
+            events.push(responseEvent("copilot_chat_session", "copilot", epochToIso(req.responseTimestamp, ts), parts.join("\n\n"), sessionId));
+        }
+    }
+    return { sessionId, events };
+}
+export function collectCopilotChatSessions(opts) {
+    const scan = emptyScan("copilot_chat_session", "copilot");
+    for (const storageDir of opts.storageDirs) {
+        for (const hash of listDirs(storageDir)) {
+            const wsDir = path.join(storageDir, hash);
+            let folder = null;
+            try {
+                const ws = asRecord(JSON.parse(fs.readFileSync(path.join(wsDir, "workspace.json"), "utf8")));
+                folder = fileUriToPath(str(ws?.folder) ?? "");
+            }
+            catch {
+                continue; // no workspace.json — not a workspace dir
+            }
+            if (!folder)
+                continue; // remote workspace: sessions live on the remote host
+            if (!opts.allSessions && !sessionMatchesAssessment([folder], opts.assessmentRoot))
+                continue;
+            const chatDir = path.join(wsDir, "chatSessions");
+            for (const name of listFiles(chatDir)) {
+                if (!name.endsWith(".jsonl") && !name.endsWith(".json"))
+                    continue;
+                const file = path.join(chatDir, name);
+                scan.scannedFiles++;
+                const raw = readCapped(file, scan);
+                if (raw === null)
+                    continue;
+                const state = name.endsWith(".jsonl")
+                    ? replayChatSessionLog(raw)
+                    : (() => { try {
+                        return asRecord(JSON.parse(raw));
+                    }
+                    catch {
+                        return null;
+                    } })();
+                if (!state) {
+                    scan.unreadable.push(file);
+                    continue;
+                }
+                const parsed = extractChatSessionEvents(state, mtimeIso(file));
+                pushSession(scan, file, path.relative(storageDir, file), parsed.sessionId, windowEvents(parsed.events, opts.sinceMs));
+            }
+        }
+    }
+    return scan;
+}
+// ── Cursor ────────────────────────────────────────────────────────
+export function defaultCursorUserDir() {
+    const home = os.homedir();
+    if (process.platform === "darwin")
+        return path.join(home, "Library", "Application Support", "Cursor", "User");
+    if (process.platform === "win32")
+        return process.env.APPDATA ? path.join(process.env.APPDATA, "Cursor", "User") : null;
+    return path.join(home, ".config", "Cursor", "User");
+}
+/**
+ * Read-only SQLite rows via the system `sqlite3` binary (`-readonly -json`),
+ * falling back to `node:sqlite` where the runtime ships it. Returns null when
+ * no reader exists or the database cannot be read — the caller reports it.
+ */
+export const systemSqliteReader = (dbPath, sql) => {
+    try {
+        const out = execFileSync("sqlite3", ["-readonly", "-json", dbPath, sql], {
+            encoding: "utf8",
+            maxBuffer: 512 * 1024 * 1024,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const trimmed = out.trim();
+        if (!trimmed)
+            return [];
+        const rows = JSON.parse(trimmed);
+        return Array.isArray(rows) ? rows : null;
+    }
+    catch (err) {
+        const noBinary = err?.code === "ENOENT";
+        if (!noBinary)
+            return null; // binary exists but the read failed
+    }
+    try {
+        const require = createRequire(import.meta.url);
+        const { DatabaseSync } = require("node:sqlite");
+        const db = new DatabaseSync(dbPath, { readOnly: true });
+        try {
+            return db.prepare(sql).all();
+        }
+        finally {
+            db.close();
+        }
+    }
+    catch {
+        return null;
+    }
+};
+function sqlQuote(v) {
+    return `'${v.replace(/'/g, "''")}'`;
+}
+function chunk(items, size) {
+    const out = [];
+    for (let i = 0; i < items.length; i += size)
+        out.push(items.slice(i, i + size));
+    return out;
+}
+/** Composer ids a workspace's own store names (its allComposers + selection history). */
+export function cursorComposerIdsFromWorkspaceValue(value) {
+    const ids = new Set();
+    try {
+        const data = asRecord(JSON.parse(value));
+        if (!data)
+            return [];
+        for (const entry of Array.isArray(data.allComposers) ? data.allComposers : []) {
+            const id = str(asRecord(entry)?.composerId);
+            if (id)
+                ids.add(id);
+        }
+        for (const key of ["selectedComposerIds", "lastFocusedComposerIds"]) {
+            for (const id of Array.isArray(data[key]) ? data[key] : []) {
+                if (str(id))
+                    ids.add(id);
+            }
+        }
+    }
+    catch { /* malformed workspace record — contributes nothing */ }
+    return [...ids];
+}
+export function collectCursorSessions(opts) {
+    const scan = emptyScan("cursor_composer", "cursor");
+    if (!opts.cursorUserDir)
+        return scan;
+    const globalDb = path.join(opts.cursorUserDir, "globalStorage", "state.vscdb");
+    if (!fs.existsSync(globalDb))
+        return scan;
+    const readSqlite = opts.readSqlite ?? systemSqliteReader;
+    // Workspace side: which composers belong to folders inside the assessment.
+    const composerIds = new Set();
+    let anyWorkspaceRead = false;
+    const wsRoot = path.join(opts.cursorUserDir, "workspaceStorage");
+    for (const hash of listDirs(wsRoot)) {
+        const wsDir = path.join(wsRoot, hash);
+        let folder = null;
+        try {
+            const ws = asRecord(JSON.parse(fs.readFileSync(path.join(wsDir, "workspace.json"), "utf8")));
+            folder = fileUriToPath(str(ws?.folder) ?? "");
+        }
+        catch {
+            continue;
+        }
+        if (!folder)
+            continue;
+        if (!opts.allSessions && !sessionMatchesAssessment([folder], opts.assessmentRoot))
+            continue;
+        const wsDb = path.join(wsDir, "state.vscdb");
+        if (!fs.existsSync(wsDb))
+            continue;
+        const rows = readSqlite(wsDb, "SELECT value FROM ItemTable WHERE key = 'composer.composerData'");
+        if (rows === null) {
+            scan.unreadable.push(wsDb);
+            continue;
+        }
+        anyWorkspaceRead = true;
+        for (const row of rows) {
+            const value = str(row.value);
+            if (value)
+                for (const id of cursorComposerIdsFromWorkspaceValue(value))
+                    composerIds.add(id);
+        }
+    }
+    if (composerIds.size === 0) {
+        if (!anyWorkspaceRead && scan.unreadable.length > 0) {
+            scan.notes.push("Cursor history exists but could not be read (no usable SQLite reader on this machine)");
+        }
+        return scan;
+    }
+    const fallbackTs = mtimeIso(globalDb);
+    for (const idBatch of chunk([...composerIds], 40)) {
+        const keys = idBatch.map((id) => sqlQuote(`composerData:${id}`)).join(", ");
+        const rows = readSqlite(globalDb, `SELECT key, value FROM cursorDiskKV WHERE key IN (${keys})`);
+        if (rows === null) {
+            scan.unreadable.push(globalDb);
+            scan.notes.push("Cursor history exists but could not be read (no usable SQLite reader on this machine)");
+            return scan;
+        }
+        for (const row of rows) {
+            scan.scannedFiles++;
+            const composerId = str(row.key)?.slice("composerData:".length) ?? "";
+            const composer = asRecord((() => { try {
+                return JSON.parse(str(row.value) ?? "");
+            }
+            catch {
+                return null;
+            } })());
+            if (!composerId || !composer)
+                continue;
+            const createdAtMs = typeof composer.createdAt === "number" ? composer.createdAt : Date.parse(fallbackTs);
+            // Bubbles carry no timestamps: the whole conversation is windowed by its
+            // session's creation time, and events are stamped createdAt + index ms.
+            if (opts.sinceMs !== null && createdAtMs < opts.sinceMs)
+                continue;
+            // Conversation order: fullConversationHeadersOnly (bubble store), or a
+            // legacy inline `conversation` array of the same bubble shapes.
+            const headers = (Array.isArray(composer.fullConversationHeadersOnly) ? composer.fullConversationHeadersOnly : []);
+            let bubbles;
+            if (headers.length > 0) {
+                const bubbleById = new Map();
+                const bubbleIds = headers.map((h) => str(asRecord(h)?.bubbleId)).filter((v) => v !== null);
+                let bubbleReadFailed = false;
+                for (const bidBatch of chunk(bubbleIds, 40)) {
+                    const bubbleKeys = bidBatch.map((bid) => sqlQuote(`bubbleId:${composerId}:${bid}`)).join(", ");
+                    const bubbleRows = readSqlite(globalDb, `SELECT key, value FROM cursorDiskKV WHERE key IN (${bubbleKeys})`);
+                    if (bubbleRows === null) {
+                        bubbleReadFailed = true;
+                        break;
+                    }
+                    for (const bubbleRow of bubbleRows) {
+                        const bid = str(bubbleRow.key)?.split(":")[2];
+                        const bubble = asRecord((() => { try {
+                            return JSON.parse(str(bubbleRow.value) ?? "");
+                        }
+                        catch {
+                            return null;
+                        } })());
+                        if (bid && bubble)
+                            bubbleById.set(bid, bubble);
+                    }
+                }
+                if (bubbleReadFailed) {
+                    // The composerData batch read fine, so a reader exists — this is a
+                    // failed read on the same store mid-run. A partially-read
+                    // conversation would misrepresent the session, so skip it WHOLE,
+                    // report it, and let the remaining composers still try.
+                    if (!scan.unreadable.includes(globalDb))
+                        scan.unreadable.push(globalDb);
+                    const note = "some Cursor conversations could not be read and were skipped";
+                    if (!scan.notes.includes(note))
+                        scan.notes.push(note);
+                    continue;
+                }
+                // A healthy store keeps headers and bubble rows consistent (measured:
+                // zero gaps across a large real store), so a hole here means pruned
+                // or corrupt rows. Recover the messages that DO exist — discarding a
+                // conversation's surviving prompts because sibling rows are gone
+                // would be under-capture — and disclose the gap, same as every other
+                // store's partially-readable case.
+                if (bubbleIds.some((bid) => !bubbleById.has(bid))) {
+                    const note = "some Cursor conversations are missing messages in the store; recovered what exists";
+                    if (!scan.notes.includes(note))
+                        scan.notes.push(note);
+                }
+                bubbles = bubbleIds.map((bid) => bubbleById.get(bid)).filter((b) => b !== undefined);
+            }
+            else {
+                bubbles = (Array.isArray(composer.conversation) ? composer.conversation : [])
+                    .map((b) => asRecord(b))
+                    .filter((b) => b !== null);
+            }
+            const events = [];
+            for (const bubble of bubbles) {
+                const text = str(bubble.text);
+                if (!text)
+                    continue; // context-only bubbles (attachments, tool results) carry no typed text
+                const ts = new Date(createdAtMs + events.length).toISOString();
+                if (bubble.type === 1)
+                    events.push(promptEvent("cursor_composer", "cursor", ts, text, composerId, true));
+                else if (bubble.type === 2)
+                    events.push(responseEvent("cursor_composer", "cursor", ts, text, composerId, true));
+            }
+            pushSession(scan, globalDb, `cursor composer ${composerId.slice(0, 8)}`, composerId, events);
+        }
+    }
+    return scan;
+}
+// ── Orchestrator ──────────────────────────────────────────────────
+export function collectToolBackfillSources(opts) {
+    const scans = [];
+    const run = (collect, source, tool) => {
+        try {
+            scans.push(collect());
+        }
+        catch {
+            // A store must never be able to abort the whole recovery; an
+            // unexpectedly-shaped one reports itself and the rest still run.
+            const scan = emptyScan(source, tool);
+            scan.notes.push("store scan failed unexpectedly — nothing recovered from it");
+            scans.push(scan);
+        }
+    };
+    run(() => collectGeminiSessions({
+        geminiDir: opts.geminiDir ?? defaultGeminiDir(),
+        assessmentRoot: opts.assessmentRoot,
+        allSessions: opts.allSessions,
+        sinceMs: opts.sinceMs,
+    }), "gemini_transcript", "gemini");
+    run(() => collectCopilotCliSessions({
+        copilotDir: opts.copilotDir ?? defaultCopilotDir(),
+        assessmentRoot: opts.assessmentRoot,
+        allSessions: opts.allSessions,
+        sinceMs: opts.sinceMs,
+    }), "copilot_cli_session", "copilot");
+    run(() => collectCopilotChatSessions({
+        storageDirs: opts.vscodeStorageDirs ?? defaultVsCodeStorageDirs(),
+        assessmentRoot: opts.assessmentRoot,
+        allSessions: opts.allSessions,
+        sinceMs: opts.sinceMs,
+    }), "copilot_chat_session", "copilot");
+    run(() => collectCursorSessions({
+        cursorUserDir: opts.cursorUserDir === undefined ? defaultCursorUserDir() : opts.cursorUserDir,
+        assessmentRoot: opts.assessmentRoot,
+        allSessions: opts.allSessions,
+        sinceMs: opts.sinceMs,
+        readSqlite: opts.readSqlite,
+    }), "cursor_composer", "cursor");
+    return scans;
+}
+//# sourceMappingURL=backfill-tools.js.map