resumecontext 0.1.0

package/dist/localHistory/claudeCode.js

@@ -0,0 +1,82 @@
+/**
+ * Claude Code stores each session as a plain JSONL log at
+ * ~/.claude/projects/<projectDirSlug>/<sessionId>.jsonl -- one line per
+ * event, filtered here to user/assistant message events.
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { isPlainObject, listDirs, listFiles, newestMtimeMs, renderContent } from "./shared.js";
+export const DEFAULT_CLAUDE_DIR = path.join(os.homedir(), ".claude");
+export const DEFAULT_CLAUDE_PROJECTS_DIR = path.join(DEFAULT_CLAUDE_DIR, "projects");
+export function claudeProjectsDir(configuredDir) {
+    return path.join(path.resolve(configuredDir), "projects");
+}
+/** Yields normalized turns from one Claude Code session .jsonl file. */
+function parseClaudeCodeFile(filePath) {
+    const turns = [];
+    const source_mtime_ms = newestMtimeMs([filePath]);
+    const lines = fs.readFileSync(filePath, "utf-8").split("\n");
+    for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        let d;
+        try {
+            d = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (d.type !== "user" && d.type !== "assistant")
+            continue;
+        const message = d.message || {};
+        const role = message.role;
+        if (role !== "user" && role !== "assistant")
+            continue;
+        const content = message.content;
+        const text = renderContent(content);
+        const toolCalls = [];
+        if (Array.isArray(content)) {
+            for (const block of content) {
+                if (isPlainObject(block) && block.type === "tool_use") {
+                    toolCalls.push(block.name || "unknown_tool");
+                }
+            }
+        }
+        if (!text && toolCalls.length === 0)
+            continue;
+        const cwd = d.cwd;
+        if (!cwd)
+            continue;
+        turns.push({
+            project_cwd: cwd, // resolved to the real project root later
+            session_id: d.sessionId ?? null,
+            agent: "claude-code",
+            timestamp: d.timestamp ?? null,
+            role,
+            text,
+            tool_calls: toolCalls,
+            source_mtime_ms,
+        });
+    }
+    return turns;
+}
+export const CLAUDE_CODE_DIR_SHAPE = "~/.claude (projects/<name>/<session-id>.jsonl is resolved at sync time)";
+/** True when `dir` is the top-level Claude install dir (~/.claude). */
+export function looksLikeClaudeCodeDir(dir) {
+    const projectsDir = claudeProjectsDir(dir);
+    if (!fs.existsSync(projectsDir))
+        return false;
+    return listDirs(projectsDir).some((projectDir) => listFiles(projectDir, ".jsonl").length > 0);
+}
+export function collectClaudeCodeTurns(configuredDir) {
+    const turns = [];
+    for (const projectDir of listDirs(claudeProjectsDir(configuredDir))) {
+        for (const jsonlFile of listFiles(projectDir, ".jsonl")) {
+            for (const turn of parseClaudeCodeFile(jsonlFile))
+                turns.push(turn);
+        }
+    }
+    return turns;
+}

package/dist/localHistory/codex.js

@@ -0,0 +1,106 @@
+/**
+ * Codex CLI stores each session as a plain JSONL "rollout" file under
+ * ~/.codex/sessions/YYYY/MM/DD/*.jsonl -- a session_meta event carries the
+ * cwd/session id, followed by response_item events for everything else.
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { hasFileWithSuffix, newestMtimeMs, renderContent, walkJsonl } from "./shared.js";
+export const DEFAULT_CODEX_DIR = path.join(os.homedir(), ".codex");
+export const DEFAULT_CODEX_SESSIONS_DIR = path.join(DEFAULT_CODEX_DIR, "sessions");
+export function codexSessionsDir(configuredDir) {
+    return path.join(path.resolve(configuredDir), "sessions");
+}
+/**
+ * Yields normalized turns from one Codex CLI session .jsonl rollout file.
+ * Handles every response_item payload type actually observed in these files
+ * (message, function_call, function_call_output, custom_tool_call,
+ * custom_tool_call_output, reasoning) -- earlier versions silently dropped
+ * function_call_output (tool results) and custom_tool_call_output entirely,
+ * and only kept tool *names* for function_call, not their arguments.
+ */
+function parseCodexFile(filePath) {
+    const turns = [];
+    const source_mtime_ms = newestMtimeMs([filePath]);
+    let cwd = null;
+    let sessionId = null;
+    const lines = fs.readFileSync(filePath, "utf-8").split("\n");
+    for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        let d;
+        try {
+            d = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (d.type === "session_meta") {
+            const payload = d.payload || {};
+            cwd = payload.cwd ?? null;
+            sessionId = payload.id ?? null;
+            continue;
+        }
+        if (d.type !== "response_item")
+            continue;
+        if (!cwd)
+            continue;
+        const payload = d.payload || {};
+        const ptype = payload.type;
+        const timestamp = d.timestamp ?? null;
+        const base = { project_cwd: cwd, session_id: sessionId, agent: "codex", timestamp };
+        if (ptype === "message") {
+            const role = payload.role;
+            if (role !== "user" && role !== "assistant")
+                continue;
+            const text = renderContent(payload.content);
+            if (!text)
+                continue;
+            turns.push({ ...base, role, text, tool_calls: [], source_mtime_ms });
+        }
+        else if (ptype === "function_call") {
+            const name = payload.name || "unknown_tool";
+            const args = payload.arguments ?? "";
+            turns.push({ ...base, role: "assistant", text: `[tool_call: ${name}] ${args}`, tool_calls: [name], source_mtime_ms });
+        }
+        else if (ptype === "custom_tool_call") {
+            const name = payload.name || "unknown_tool";
+            const args = payload.input ?? "";
+            turns.push({ ...base, role: "assistant", text: `[tool_call: ${name}] ${args}`, tool_calls: [name], source_mtime_ms });
+        }
+        else if (ptype === "function_call_output" || ptype === "custom_tool_call_output") {
+            let output = payload.output ?? "";
+            if (typeof output !== "string")
+                output = JSON.stringify(output);
+            // Matches Claude Code's convention of tool results living in a
+            // user-role turn (that's the API shape both are modeled on).
+            turns.push({ ...base, role: "user", text: `[tool_result] ${output}`, tool_calls: [], source_mtime_ms });
+        }
+        else if (ptype === "reasoning") {
+            const summaryText = renderContent(payload.summary);
+            const contentText = renderContent(payload.content);
+            const text = [summaryText, contentText].filter((t) => t).join("\n");
+            if (text) {
+                turns.push({ ...base, role: "assistant", text: `[reasoning] ${text}`, tool_calls: [], source_mtime_ms });
+            }
+        }
+    }
+    return turns;
+}
+export const CODEX_DIR_SHAPE = "~/.codex (sessions/YYYY/MM/DD/*.jsonl is resolved at sync time)";
+/** True when `dir` is the top-level Codex install dir (~/.codex). */
+export function looksLikeCodexDir(dir) {
+    const sessionsDir = codexSessionsDir(dir);
+    return fs.existsSync(sessionsDir) && hasFileWithSuffix(sessionsDir, ".jsonl");
+}
+/** `configuredDir` is the user-configured top-level dir (~/.codex). */
+export function collectCodexTurns(configuredDir) {
+    const turns = [];
+    for (const jsonlFile of walkJsonl(codexSessionsDir(configuredDir))) {
+        for (const turn of parseCodexFile(jsonlFile))
+            turns.push(turn);
+    }
+    return turns;
+}

package/dist/localHistory/cursor.js

@@ -0,0 +1,492 @@
+/**
+ * Cursor agent history lives in two places Cursor keeps in sync for most
+ * sessions, but not always:
+ *
+ *   ~/.cursor/chats/<projectHash>/<sessionId>/{meta.json, store.db}
+ *     -- SQLite blob store; richest source when present.
+ *   ~/.cursor/projects/<workspaceSlug>/agent-transcripts/<sessionId>/<id>.jsonl
+ *     -- JSONL export; often the ONLY copy for a live session (store.db may
+ *     never appear). Lossier (no per-turn timestamps, truncated tool output)
+ *     but required for current chats.
+ *
+ * resumecontext scopes collection to Cursor workspaces that belong to the
+ * project: the slug derived from the resumecontext project root, plus any
+ * slug whose path is nested inside that root. Cursor gives every directory
+ * it is opened in its own ~/.cursor/projects/<slug>/ folder, so a session
+ * run from a subdirectory like cli/ lives under a different slug than the
+ * parent project and must be discovered via slug-prefix matching (the
+ * transform is lossy, so we match `w === p || w.startsWith(p + "-")` rather
+ * than decoding). Sessions with meta.json still pass through the generic
+ * resolveProjectRoots filter on their real cwd; transcript-only sessions
+ * rely on this slug containment. Unrelated workspaces on the machine are
+ * excluded. Within matching workspaces, only sessions whose start time is
+ * at or after the project's .resumecontext.json createdAt are included.
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { CURSOR_SQLITE_TIMEOUT_MS } from "../constants.js";
+import { isPlainObject, listDirs, msToIso, newestMtimeMs, renderContent } from "./shared.js";
+// Not a static `import { DatabaseSync } from "node:sqlite"`: this module is
+// imported unconditionally (registry.ts's AGENT_ADAPTERS covers every
+// agent regardless of what a given project has configured), and merely
+// importing node:sqlite -- even without ever constructing a DatabaseSync --
+// prints Node's ExperimentalWarning immediately. That warning would then
+// fire on every single CLI invocation, including every daemon tick (a
+// fresh process every DAEMON_INTERVAL_MS) whether or not that tick's
+// projects use Cursor at all, drowning out daemon.log with noise no one
+// asked for. createRequire's require() defers actually loading the module
+// (and so the warning) until parseCursorSession genuinely runs.
+const require = createRequire(import.meta.url);
+function loadDatabaseSync() {
+    return require("node:sqlite").DatabaseSync;
+}
+export const DEFAULT_CURSOR_DIR = path.join(os.homedir(), ".cursor");
+export const DEFAULT_CURSOR_CHATS_DIR = path.join(DEFAULT_CURSOR_DIR, "chats");
+export const DEFAULT_CURSOR_PROJECTS_DIR = path.join(DEFAULT_CURSOR_DIR, "projects");
+const TIMESTAMP_TAG_RE = /<timestamp>([^<]+)<\/timestamp>/;
+/** Maps a resumecontext project root to Cursor's ~/.cursor/projects/<slug>. */
+export function cursorWorkspaceSlug(projectRoot) {
+    return path.resolve(projectRoot).replace(/^\//, "").replace(/\//g, "-");
+}
+export function cursorAgentTranscriptsDir(projectRoot, projectsDir = DEFAULT_CURSOR_PROJECTS_DIR) {
+    return path.join(projectsDir, cursorWorkspaceSlug(projectRoot), "agent-transcripts");
+}
+/** Cursor workspace slugs under ~/.cursor/projects/ that belong to this
+ * project: the root's own slug plus any slug for a nested subdirectory.
+ * Prefix matching is lossy (slashes and literal dashes both become `-`) but
+ * is only used to discover which folders to scan; meta.json-backed sessions
+ * are still filtered by their real cwd downstream. */
+function matchingWorkspaceSlugs(projectRoot, projectsDir) {
+    const projectSlug = cursorWorkspaceSlug(projectRoot);
+    if (!fs.existsSync(projectsDir))
+        return [];
+    return listDirs(projectsDir)
+        .map((d) => path.basename(d))
+        .filter((slug) => slug === projectSlug || slug.startsWith(`${projectSlug}-`));
+}
+function cursorAgentTranscriptsDirs(projectRoot, projectsDir) {
+    return matchingWorkspaceSlugs(projectRoot, projectsDir).map((slug) => path.join(projectsDir, slug, "agent-transcripts"));
+}
+/** Project-scoped paths derived at sync/fingerprint time from the configured
+ * ~/.cursor base and the resumecontext project root. */
+export function cursorDerivedDirs(projectRoot, configuredCursorDir) {
+    const base = path.resolve(configuredCursorDir);
+    const projectsDir = path.join(base, "projects");
+    return {
+        chatsDir: path.join(base, "chats"),
+        projectsDir,
+        transcriptsDirs: cursorAgentTranscriptsDirs(projectRoot, projectsDir),
+    };
+}
+/** Yields normalized turns from one Cursor chat session directory
+ * (~/.cursor/chats/<projectHash>/<sessionId>/). */
+function parseCursorSession(sessionDir) {
+    const metaPath = path.join(sessionDir, "meta.json");
+    const dbPath = path.join(sessionDir, "store.db");
+    if (!fs.existsSync(metaPath) || !fs.existsSync(dbPath))
+        return [];
+    // Only meta.json and store.db -- NOT store.db-shm or store.db-wal. Opening
+    // a WAL-mode SQLite database read-only bumps the -shm mtime, which would
+    // keep every Cursor session permanently "hot" and never sync its trailing
+    // turn (see daemon.ts isFingerprintNoise for the same trap).
+    const source_mtime_ms = newestMtimeMs([metaPath, dbPath]);
+    let meta;
+    try {
+        meta = JSON.parse(fs.readFileSync(metaPath, "utf-8"));
+    }
+    catch {
+        return [];
+    }
+    const cwd = meta.cwd;
+    if (!cwd || meta.hasConversation === false)
+        return [];
+    const sessionId = path.basename(sessionDir);
+    const startMs = meta.createdAtMs ?? null;
+    let endMs = meta.updatedAtMs ?? startMs;
+    if (endMs !== null && startMs !== null && endMs < startMs)
+        endMs = startMs;
+    let rows;
+    try {
+        // Read-only connection: this file can be live-open in a running Cursor
+        // instance, and we must never write to or lock real app state.
+        const DatabaseSync = loadDatabaseSync();
+        const db = new DatabaseSync(dbPath, { readOnly: true, timeout: CURSOR_SQLITE_TIMEOUT_MS });
+        try {
+            rows = db.prepare("SELECT id, data FROM blobs ORDER BY rowid").all();
+        }
+        finally {
+            db.close();
+        }
+    }
+    catch {
+        return [];
+    }
+    // First collect the raw (role, text, tool_calls) turns in chat order,
+    // THEN assign interpolated timestamps once we know the final count --
+    // can't interpolate on the fly since we don't know N until we're done.
+    const rawTurns = [];
+    for (const { data } of rows) {
+        let d;
+        try {
+            // Binary protobuf envelope blobs decode to non-JSON text (or, on the
+            // rare invalid-UTF-8 byte, a lossy replacement-char string) and then
+            // fail JSON.parse -- functionally equivalent to Python's explicit
+            // UnicodeDecodeError/JSONDecodeError catch, just via one path.
+            d = JSON.parse(Buffer.from(data).toString("utf-8"));
+        }
+        catch {
+            continue;
+        }
+        if (!isPlainObject(d))
+            continue;
+        const role = d.role;
+        if (role !== "user" && role !== "assistant" && role !== "tool") {
+            continue; // covers "system" (skipped -- static boilerplate, same
+            // precedent as Claude Code/Codex never emitting a system turn) and
+            // the store's other non-message JSON blobs (e.g. our own tool's
+            // cached results, which have no "role" key at all).
+        }
+        const content = d.content;
+        const text = renderContent(content);
+        const toolCalls = [];
+        if (Array.isArray(content)) {
+            for (const block of content) {
+                if (isPlainObject(block) && block.type === "tool-call") {
+                    toolCalls.push(block.toolName || "unknown_tool");
+                }
+            }
+        }
+        if (!text && toolCalls.length === 0)
+            continue;
+        // Tool results are their own role='tool' message in this store, unlike
+        // Claude/Codex where they're folded into a user-role turn -- normalize
+        // to the same "tool results live in a user turn" convention so
+        // downstream code (which only ever expects user/assistant) is
+        // consistent across all four agents.
+        const normalizedRole = role === "tool" ? "user" : role;
+        rawTurns.push({ role: normalizedRole, text, toolCalls });
+    }
+    const n = rawTurns.length;
+    const turns = [];
+    rawTurns.forEach((rt, i) => {
+        let tsMs;
+        if (startMs === null) {
+            tsMs = null;
+        }
+        else if (endMs === null || endMs === startMs || n <= 1) {
+            tsMs = startMs;
+        }
+        else {
+            tsMs = startMs + Math.floor(((endMs - startMs) * i) / (n - 1));
+        }
+        turns.push({
+            project_cwd: cwd, // resolved to the real project root later
+            session_id: sessionId,
+            agent: "cursor",
+            timestamp: tsMs !== null ? msToIso(tsMs) : null,
+            role: rt.role,
+            text: rt.text,
+            tool_calls: rt.toolCalls,
+            source_mtime_ms,
+        });
+    });
+    return turns;
+}
+function readSessionMeta(sessionDir) {
+    try {
+        return JSON.parse(fs.readFileSync(path.join(sessionDir, "meta.json"), "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+/** Session start time for filtering: meta.createdAtMs when the SQLite copy
+ * exists, otherwise the first <timestamp> tag in the JSONL. */
+export function sessionStartMs(chatsSessionDir, transcriptPath) {
+    if (chatsSessionDir) {
+        const meta = readSessionMeta(chatsSessionDir);
+        if (meta?.createdAtMs != null)
+            return meta.createdAtMs;
+    }
+    if (transcriptPath && fs.existsSync(transcriptPath)) {
+        try {
+            const lines = fs.readFileSync(transcriptPath, "utf-8").split("\n");
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                const parsed = JSON.parse(line);
+                if (parsed.role !== "user")
+                    continue;
+                const text = renderContent(parsed.message?.content);
+                const match = TIMESTAMP_TAG_RE.exec(text);
+                if (match) {
+                    const ms = Date.parse(match[1].trim());
+                    if (!Number.isNaN(ms))
+                        return ms;
+                }
+            }
+        }
+        catch {
+            // fall through
+        }
+        try {
+            return fs.statSync(transcriptPath).birthtimeMs;
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+function findChatsSessionDir(chatsBaseDir, sessionId) {
+    for (const projectHashDir of listDirs(chatsBaseDir)) {
+        const sessionDir = path.join(projectHashDir, sessionId);
+        if (fs.existsSync(path.join(sessionDir, "store.db")))
+            return sessionDir;
+    }
+    return null;
+}
+function parseTimestampFromUserText(text) {
+    const match = TIMESTAMP_TAG_RE.exec(text);
+    if (!match)
+        return null;
+    const ms = Date.parse(match[1].trim());
+    return Number.isNaN(ms) ? null : ms;
+}
+/** Latest activity signal for a session -- used with projectInitAt to drop
+ * workspace history that ended before `init`, while keeping a live thread
+ * that started earlier but is still receiving messages. */
+export function sessionLastActivityMs(chatsSessionDir, transcriptPath) {
+    let latest = null;
+    const bump = (ms) => {
+        if (ms == null || Number.isNaN(ms))
+            return;
+        if (latest === null || ms > latest)
+            latest = ms;
+    };
+    if (chatsSessionDir) {
+        const meta = readSessionMeta(chatsSessionDir);
+        bump(meta?.updatedAtMs ?? meta?.createdAtMs);
+        try {
+            bump(fs.statSync(path.join(chatsSessionDir, "store.db")).mtimeMs);
+        }
+        catch {
+            // no store.db yet
+        }
+    }
+    if (transcriptPath && fs.existsSync(transcriptPath)) {
+        try {
+            const lines = fs.readFileSync(transcriptPath, "utf-8").split("\n");
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const parsed = JSON.parse(line);
+                    if (parsed.role !== "user")
+                        continue;
+                    bump(parseTimestampFromUserText(renderContent(parsed.message?.content)));
+                }
+                catch {
+                    // skip bad line
+                }
+            }
+        }
+        catch {
+            // unreadable transcript
+        }
+        try {
+            bump(fs.statSync(transcriptPath).mtimeMs);
+        }
+        catch {
+            // missing
+        }
+    }
+    return latest;
+}
+function sessionIncludedAfterInit(chatsSessionDir, transcriptPath, projectInitAtMs) {
+    if (chatsSessionDir) {
+        const meta = readSessionMeta(chatsSessionDir);
+        if (meta?.updatedAtMs != null && meta.updatedAtMs >= projectInitAtMs)
+            return true;
+        if (meta?.createdAtMs != null && meta.createdAtMs >= projectInitAtMs)
+            return true;
+    }
+    if (!transcriptPath || !fs.existsSync(transcriptPath))
+        return false;
+    let latestUserMs = null;
+    try {
+        for (const line of fs.readFileSync(transcriptPath, "utf-8").split("\n")) {
+            if (!line.trim())
+                continue;
+            try {
+                const parsed = JSON.parse(line);
+                if (parsed.role !== "user")
+                    continue;
+                const ms = parseTimestampFromUserText(renderContent(parsed.message?.content));
+                if (ms !== null && (latestUserMs === null || ms > latestUserMs))
+                    latestUserMs = ms;
+            }
+            catch {
+                // skip bad line
+            }
+        }
+    }
+    catch {
+        return false;
+    }
+    if (latestUserMs !== null)
+        return latestUserMs >= projectInitAtMs;
+    // Transcript-only session with no embedded timestamps -- fall back to file mtime.
+    try {
+        return fs.statSync(transcriptPath).mtimeMs >= projectInitAtMs;
+    }
+    catch {
+        return false;
+    }
+}
+function assignInterpolatedTimestamps(rawTurns, startMs, endMs) {
+    if (rawTurns.every((t) => t.timestampMs !== null))
+        return;
+    const known = rawTurns.map((t, i) => ({ i, ms: t.timestampMs })).filter((t) => t.ms !== null);
+    if (known.length === 0) {
+        if (startMs === null)
+            return;
+        rawTurns.forEach((t, i) => {
+            t.timestampMs = endMs === null || endMs === startMs || rawTurns.length <= 1
+                ? startMs
+                : startMs + Math.floor(((endMs - startMs) * i) / (rawTurns.length - 1));
+        });
+        return;
+    }
+    for (let i = 0; i < rawTurns.length; i++) {
+        if (rawTurns[i].timestampMs !== null)
+            continue;
+        const prev = [...known].reverse().find((k) => k.i < i);
+        const next = known.find((k) => k.i > i);
+        if (prev && next) {
+            rawTurns[i].timestampMs = prev.ms + Math.floor(((next.ms - prev.ms) * (i - prev.i)) / (next.i - prev.i));
+        }
+        else if (prev) {
+            rawTurns[i].timestampMs = prev.ms;
+        }
+        else if (next) {
+            rawTurns[i].timestampMs = next.ms;
+        }
+        else if (startMs !== null) {
+            rawTurns[i].timestampMs = startMs;
+        }
+    }
+}
+/** Parses ~/.cursor/projects/.../agent-transcripts/<id>/<id>.jsonl -- used
+ * when store.db hasn't been written yet for a live session. */
+export function parseCursorAgentTranscript(transcriptPath, sessionId, projectCwd) {
+    let lines;
+    try {
+        lines = fs.readFileSync(transcriptPath, "utf-8").split("\n");
+    }
+    catch {
+        return [];
+    }
+    const source_mtime_ms = newestMtimeMs([transcriptPath]);
+    const rawTurns = [];
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (parsed.type === "turn_ended")
+            continue;
+        const role = parsed.role;
+        if (role !== "user" && role !== "assistant" && role !== "tool")
+            continue;
+        const content = parsed.message?.content;
+        const text = renderContent(content);
+        const toolCalls = [];
+        if (Array.isArray(content)) {
+            for (const block of content) {
+                if (!isPlainObject(block))
+                    continue;
+                if (block.type === "tool-call" || block.type === "tool_use") {
+                    toolCalls.push(block.toolName || block.name || "unknown_tool");
+                }
+            }
+        }
+        if (!text && toolCalls.length === 0)
+            continue;
+        const normalizedRole = role === "tool" ? "user" : role;
+        const timestampMs = role === "user" ? parseTimestampFromUserText(text) : null;
+        rawTurns.push({ role: normalizedRole, text, toolCalls, timestampMs });
+    }
+    const startMs = sessionStartMs(null, transcriptPath);
+    const endMs = rawTurns.reduce((latest, t) => {
+        if (t.timestampMs === null)
+            return latest;
+        return latest === null || t.timestampMs > latest ? t.timestampMs : latest;
+    }, startMs);
+    assignInterpolatedTimestamps(rawTurns, startMs, endMs);
+    return rawTurns.map((rt) => ({
+        project_cwd: projectCwd,
+        session_id: sessionId,
+        agent: "cursor",
+        timestamp: rt.timestampMs !== null ? msToIso(rt.timestampMs) : null,
+        role: rt.role,
+        text: rt.text,
+        tool_calls: rt.toolCalls,
+        source_mtime_ms,
+    }));
+}
+/** Workspace-scoped collection: sessions under this project's Cursor
+ * workspace(s) agent-transcripts/ (root and nested subdirectories), started
+ * at or after projectInitAtMs. `configuredCursorDir` is the user-configured
+ * top-level dir (~/.cursor). */
+export function collectCursorTurnsForProject(projectRoot, projectInitAtMs, configuredCursorDir = DEFAULT_CURSOR_DIR) {
+    const { chatsDir: chatsBaseDir, transcriptsDirs } = cursorDerivedDirs(projectRoot, configuredCursorDir);
+    const projectCwd = path.resolve(projectRoot);
+    const turns = [];
+    for (const transcriptsDir of transcriptsDirs) {
+        if (!fs.existsSync(transcriptsDir))
+            continue;
+        for (const sessionDir of listDirs(transcriptsDir)) {
+            const sessionId = path.basename(sessionDir);
+            const transcriptPath = path.join(sessionDir, `${sessionId}.jsonl`);
+            const chatsSessionDir = findChatsSessionDir(chatsBaseDir, sessionId);
+            const transcriptExists = fs.existsSync(transcriptPath);
+            if (!sessionIncludedAfterInit(chatsSessionDir, transcriptExists ? transcriptPath : null, projectInitAtMs))
+                continue;
+            if (chatsSessionDir) {
+                turns.push(...parseCursorSession(chatsSessionDir));
+            }
+            else if (transcriptExists) {
+                turns.push(...parseCursorAgentTranscript(transcriptPath, sessionId, projectCwd));
+            }
+        }
+    }
+    return turns;
+}
+export const CURSOR_DIR_SHAPE = "~/.cursor (chats/ and projects/<slug>/agent-transcripts/ are resolved at sync time)";
+/** True when `dir` is the top-level Cursor install dir (~/.cursor). */
+export function looksLikeCursorDir(dir) {
+    const base = path.resolve(dir);
+    return fs.existsSync(path.join(base, "chats")) || fs.existsSync(path.join(base, "projects"));
+}
+/** Used only when validating a configured path outside project-scoped sync. */
+export function collectCursorTurns(configuredDir) {
+    const chatsDir = path.join(path.resolve(configuredDir), "chats");
+    if (!fs.existsSync(chatsDir))
+        return [];
+    const turns = [];
+    for (const projectHashDir of listDirs(chatsDir)) {
+        for (const sessionDir of listDirs(projectHashDir)) {
+            for (const turn of parseCursorSession(sessionDir))
+                turns.push(turn);
+        }
+    }
+    return turns;
+}