sessionmem 1.5.0 → 1.6.0

package/CHANGELOG.md

@@ -5,6 +5,25 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.6.0] - 2026-10-18
+
+### Added
+
+- Multi-host transcript imports: `sessionmem scan` and `sessionmem watch` now
+  sweep Claude Code, Codex CLI, and Cursor histories by default, with a
+  separate parser per host and an explicit unsupported-format error when a
+  claimed host's records cannot be parsed. `--host` selects one host.
+  ([#52], [#53])
+- Codex CLI support: dated rollout discovery, project and session identity from
+  session metadata, resume-file grouping with cross-file deduplication,
+  sub-agent session separation, native tool-call events, and filtering of
+  encrypted agent payloads and injected machine blocks. ([#52])
+- Cursor support: chat history read from Cursor's SQLite storage through
+  private snapshot copies opened read-only, covering both composer index
+  layouts, with per-composer checkpoints and live-update handling. ([#53])
+- `sessionmem doctor` now checks transcript discovery for each supported
+  host. ([#52], [#53])
+
 ## [1.5.0] - 2026-10-18
 
 ### Added
@@ -102,6 +121,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   errors and findings fail the job; added scanner dependency updates and
   Dependabot cooldowns. ([#32])
 
+[1.6.0]: https://github.com/catfish-1234/sessionmem/compare/v1.5.0...v1.6.0
 [1.5.0]: https://github.com/catfish-1234/sessionmem/compare/679b8954f0b49f197985c40da47f181c00060cd9...v1.5.0
 [#43]: https://github.com/catfish-1234/sessionmem/pull/43
 [#44]: https://github.com/catfish-1234/sessionmem/pull/44
@@ -112,6 +132,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 [#49]: https://github.com/catfish-1234/sessionmem/pull/49
 [#50]: https://github.com/catfish-1234/sessionmem/pull/50
 [#51]: https://github.com/catfish-1234/sessionmem/pull/51
+[#52]: https://github.com/catfish-1234/sessionmem/pull/52
+[#53]: https://github.com/catfish-1234/sessionmem/pull/53
 [1.4.0]: https://github.com/catfish-1234/sessionmem/compare/a73f503123b1d33c35407ce66403f281ba3451ac...679b8954f0b49f197985c40da47f181c00060cd9
 [#22]: https://github.com/catfish-1234/sessionmem/pull/22
 [#23]: https://github.com/catfish-1234/sessionmem/pull/23

package/README.md

@@ -210,7 +210,7 @@ See [`docs/architecture.md`](docs/architecture.md) for the technical overview.
 | Command | What it does |
 |---------|--------------|
 | `sessionmem install [--adapter <name>]` | Detect installed hosts, register sessionmem with each, and write default config; the flag selects one host. |
-| `sessionmem doctor [--adapter <name>]` | Check the store, schema, hooks, MCP wiring, and canary recall offline; print PASS/FAIL and repair hints. |
+| `sessionmem doctor [--adapter <name>]` | Check the store, schema, transcript discovery, hooks, MCP wiring, and canary recall offline; print PASS/FAIL and repair hints. |
 | `sessionmem uninstall [--adapter <name>] [--purge]` | Remove sessionmem from the host. `--purge` also deletes the local database. |
 | `sessionmem run` | Start the MCP server. |
 | `sessionmem ui [--port N]` | Open the local read-only web viewer (default port 3777). |
@@ -223,8 +223,8 @@ See [`docs/architecture.md`](docs/architecture.md) for the technical overview.
 | `sessionmem forget <id> [--force]` | Delete a memory by ID. |
 | `sessionmem export [path]` | Export all current-project memories to JSON (default `~/.sessionmem/export-YYYY-MM-DD.json`). |
 | `sessionmem import <path> [--merge]` | Import up to 1000 valid records from UTF-8 JSON into the current project. Existing IDs are preserved, including with `--merge`; invalid records are skipped with warnings. |
-| `sessionmem scan [--transcripts-dir <path>]` | Import existing Claude Code JSONL transcripts into local session memories. Reports files found, sessions imported, memories created, skipped files, and errors. |
-| `sessionmem watch [--once] [--interval <seconds>] [--transcripts-dir <path>]` | Capture new or updated Claude Code transcripts. Polls every 5 seconds by default; `--once` runs a single sweep. |
+| `sessionmem scan [--host <host>] [--transcripts-dir <path>]` | Import existing Claude Code, Codex CLI, and Cursor transcripts into local session memories. Reports files found, sessions imported, memories created, skips, and errors. |
+| `sessionmem watch [--once] [--interval <seconds>] [--host <host>] [--transcripts-dir <path>]` | Capture new or updated Claude Code, Codex CLI, and Cursor transcripts. Polls every 5 seconds by default; `--once` runs a single sweep. |
 | `sessionmem stats` | Show memory statistics for the current project. |
 | `sessionmem savings [--json]` | Show token savings from compression and injection, with percentage. |
 | `sessionmem redact-scan [--apply]` | Scan stored memories for secrets; `--apply` redacts in place. |
@@ -297,32 +297,78 @@ When a fact changes, sessionmem can link its replacement locally. For example,
 
 Detection uses deterministic entity/relation rules, shared purpose words, a small tool-category vocabulary, and explicit negation or replacement phrases. It needs no API or model. Unfamiliar wording can be missed, and ambiguous changes can be misclassified. A memory with independent claims remains searchable while any claim is current; history labels these partial supersessions. See [supersession details](docs/architecture.md#contradiction-and-supersession).
 
-Run a scan to capture Claude Code sessions from before sessionmem was installed:
+Run a scan to capture Claude Code, Codex CLI, and Cursor sessions from before sessionmem was installed:
 
 ```bash
 sessionmem scan
 sessionmem watch --once
 sessionmem watch --interval 10
+sessionmem scan --host cursor
 ```
 
-Both commands recursively read `~/.claude/projects/**/*.jsonl`. Use
-`--transcripts-dir "/path/to/projects"` to select another transcript tree. They
-work fully offline without API keys and always use the local summarizer, even
-if cloud summarization is enabled elsewhere.
-
-Transcript user/assistant text and supported tool uses (Bash, Edit, Write,
-MultiEdit) pass through the existing event-ingestion, redaction, and session-summary
-pipeline. Each session gets one summary memory, including short sessions with
-only one event. Updated sessions refresh that summary. Project buckets come from
-each transcript's `cwd`, using its repository root when available; the directory
-where you run scan/watch does not select the project. `SESSIONMEM_PROJECT_ID`
-can explicitly pin all imports to one bucket. Transcripts without a working
-directory or capturable events are skipped; nested subagent files get separate
-session summaries.
+Both commands sweep all detected transcript histories by default:
+
+- Claude Code: `~/.claude/projects/**/*.jsonl`.
+- Codex CLI: `~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl`.
+- Cursor: `User/globalStorage/state.vscdb` under
+  `~/Library/Application Support/Cursor` on macOS, `~/.config/Cursor` on Linux,
+  or `%APPDATA%/Cursor` on Windows.
+
+Missing history directories are allowed. Use `--transcripts-dir "/path/to/history"`
+to select another transcript tree; each JSONL file's host is detected from its records.
+For Cursor, the override accepts its `User` directory or a `state.vscdb` path.
+Use `--host cursor`, `--host codex`, or `--host claude-code` to select one host,
+including when using an override. A Cursor User directory or `.vscdb` file is
+also detected without `--host`. Files that do not match a supported format, or
+the selected host, produce an explicit `unsupported format` error.
+
+Both commands work offline without API keys and always use the local summarizer,
+even if cloud summarization is enabled elsewhere. `sessionmem doctor` checks
+transcript discovery for all three hosts, parses JSONL samples, and validates
+Cursor's composer indexes and message rows when history is present.
+
+Transcript user/assistant text, supported Claude tool uses (Bash, Edit, Write,
+MultiEdit), and Codex function calls pass through the existing event-ingestion,
+redaction, and session-summary pipeline. Codex tool events retain the native tool
+name and `call_id`. Encrypted `agent_message` payloads and obvious injected machine
+blocks, including plugin catalogues and environment context, are excluded. Each
+session gets one summary memory, including short sessions with only one event.
+Updated sessions refresh that summary. Project buckets come from
+each Claude transcript's `cwd`, Codex `session_meta.payload.cwd`, or Cursor's
+workspace path, using the repository root when available; the directory where you run scan/watch does not
+select the project. `SESSIONMEM_PROJECT_ID` can explicitly pin all imports to one
+bucket. Transcripts without capturable events are skipped. Claude transcripts
+without a working directory are also skipped; Codex session metadata must contain
+an ID and working directory. Nested subagent files get separate session summaries.
+Summary memories record `sourceAdapter` as `claude-code`, `codex`, or `cursor`
+according to the transcript host. Cursor session IDs come from `composerId`.
+
+Cursor stores messages in `cursorDiskKV` bubble rows in its global SQLite
+database. The importer supports workspace `composer.composerData` indexes
+(Cursor 2.6 and earlier) and the central `composer.composerHeaders` index
+(Cursor 3.0 and later). It captures up to 4,000 characters of user/assistant text
+per bubble and excludes tool-only bubbles and internal tool/code fields. Missing
+tables, index keys, or required conversation data produce an explicit
+`unsupported format for cursor` error.
+
+Cursor databases are never written. Each sweep copies the database and its WAL
+to a private temporary directory, checking for concurrent changes during the
+copy. SQLite opens the copy read-only, using immutable mode when URI support is
+available and there is no WAL to replay. Cursor's live database is never opened by SQLite. Busy
+copies are reported and retried. Each sweep reads a fresh snapshot; per-composer
+checkpoints skip unchanged messages, and streamed bubble updates refresh the
+existing event without duplicating it.
+
+Codex resumes create new rollout files. Files with the same session ID are grouped,
+and replayed events are deduplicated across files, sweeps, and restarts. A Codex
+sub-agent keeps its own `session_meta.payload.id`, even when `parent_thread_id`
+points to a parent session.
 
 Re-running either command does not duplicate memories or transcript events.
-File checkpoints live in the selected memory database, and unchanged files are
-skipped across restarts. Stable event IDs also make interrupted imports safe to
+File and composer checkpoints live in the selected memory database, and unchanged
+files or composers are skipped across restarts. For Cursor, `files found` counts
+global databases, and `skipped` counts unchanged or empty composers.
+Stable event IDs also make interrupted imports safe to
 retry. Partial or malformed JSONL lines are reported and retried on later sweeps;
 valid events in the same file can still be captured. A single sweep exits with
 status 1 if it encounters errors. The daemon keeps running and retries errors.
@@ -366,7 +412,7 @@ and adjust PATH for your Node install:
 
 ```ini
 [Unit]
-Description=Capture Claude Code transcripts with sessionmem
+Description=Capture Claude Code, Codex, and Cursor transcripts with sessionmem
 
 [Service]
 ExecStart=/usr/local/bin/sessionmem watch
@@ -511,8 +557,9 @@ sessionmem doctor
 sessionmem doctor --adapter claude-code  # explicit host override
 ```
 
-`doctor` reports a separate PASS or FAIL for the memory store, schema, hook
-definitions shipped with the current version, configured MCP command, and a
+`doctor` reports a separate PASS or FAIL for the memory store, schema, transcript
+discovery for Claude Code and Codex, hook definitions shipped with the current
+version, configured MCP command, and a
 canary write/recall. It exits nonzero if any check fails and prints fix hints,
 including exact commands for safe repairs. It does not create a missing store or
 apply migrations. Its temporary canary is isolated from your projects and rolled

package/dist/cli/commands/doctor.js

@@ -7,6 +7,7 @@ import { ADAPTER_NAMES, AdapterFactory } from "../../adapters/factory.js";
 import { createMemoryCoreService } from "../../core/api/memoryCoreService.js";
 import { inspectMigrations } from "../../core/schema/runMigrations.js";
 import { resolveDbPath } from "../context.js";
+import { inspectTranscriptDiscovery, TRANSCRIPT_HOSTS } from "../transcripts/index.js";
 const VERSION = createRequire(import.meta.url)("../../../package.json").version;
 /** Exercise real storage, embedding, ranking and injection without retaining data. */
 export async function probeRecall(db) {
@@ -53,6 +54,14 @@ export async function doctorCommand(options, overrides = {}) {
         report("Agent hosts", false, message(err), "Install a supported host or select one with sessionmem doctor --adapter <name>");
     }
     const dbPath = resolveDbPath(overrides.dbPath);
+    for (const host of TRANSCRIPT_HOSTS) {
+        try {
+            report(`${host} transcripts`, true, await inspectTranscriptDiscovery(host));
+        }
+        catch (err) {
+            report(`${host} transcripts`, false, message(err), `Check transcript directory permissions and format; run sessionmem scan --host ${host}`);
+        }
+    }
     let db;
     let schemaOk = false;
     try {

package/dist/cli/index.js

@@ -60,13 +60,15 @@ program
     .action(() => ingestHookCommand());
 program
     .command("scan")
-    .description("Import existing Claude Code transcripts using local capture and summarization")
-    .option("--transcripts-dir <path>", "Transcript directory (default: ~/.claude/projects)")
+    .description("Import Claude Code, Codex, and Cursor transcripts using local capture and summarization")
+    .option("--transcripts-dir <path>", "Override transcript roots (Cursor: User directory or state.vscdb)")
+    .option("--host <host>", "Select a transcript host: claude-code, codex, or cursor")
     .action(async (options) => { await scanCommand(options); });
 program
     .command("watch")
-    .description("Poll Claude Code transcripts and capture new or updated sessions offline")
-    .option("--transcripts-dir <path>", "Transcript directory (default: ~/.claude/projects)")
+    .description("Poll Claude Code, Codex, and Cursor transcripts and capture sessions offline")
+    .option("--transcripts-dir <path>", "Override transcript roots (Cursor: User directory or state.vscdb)")
+    .option("--host <host>", "Select a transcript host: claude-code, codex, or cursor")
     .option("--once", "Run one sweep and exit")
     .option("--interval <seconds>", "Seconds between sweeps", "5")
     .action((options) => watchCommand(options));
@@ -77,7 +79,7 @@ program
     .action((options) => installCommand(options));
 program
     .command("doctor")
-    .description("Check the local store, schema, hooks, adapter wiring, and recall offline")
+    .description("Check storage, transcript discovery, hooks, MCP wiring, and recall offline")
     .option("--adapter <name>", "Check a specific host instead of installed-host detection")
     .action(async (options) => { await doctorCommand(options); });
 program

package/dist/cli/transcriptSweep.js

@@ -1,145 +1,107 @@
-import { createHash } from "node:crypto";
-import { createReadStream } from "node:fs";
-import { readdir, stat } from "node:fs/promises";
-import { basename, join, resolve } from "node:path";
-import { createInterface } from "node:readline";
-import { homedir } from "node:os";
-import { buildToolEvent } from "../core/capture/toolEvent.js";
+import { stat } from "node:fs/promises";
 import { handleSessionEndConfigSchema, MAX_INGEST_EVENTS } from "../core/api/contracts.js";
-import { expandTilde } from "./context.js";
 import { deriveProjectId } from "./projectId.js";
-function object(value) {
-    return value && typeof value === "object" && !Array.isArray(value)
-        ? value : undefined;
-}
-function stableId(...parts) {
-    return `transcript-${createHash("sha256").update(JSON.stringify(parts)).digest("hex")}`;
-}
-/** Translate the transcript envelope; tool normalization stays shared with ingest-hook. */
-async function readTranscript(path) {
-    const result = {
-        cwd: undefined,
-        sessionId: basename(path, ".jsonl"),
-        events: [],
-        malformed: false,
-    };
-    const input = createReadStream(path);
-    const lines = createInterface({ input, crlfDelay: Infinity });
-    let lineIndex = 0;
-    try {
-        for await (const line of lines) {
-            const index = lineIndex++;
-            if (!line.trim())
-                continue;
-            let record;
-            try {
-                record = object(JSON.parse(line.replace(/^\uFEFF/, "")));
-            }
-            catch {
-                result.malformed = true;
-                continue;
-            }
-            if (!record)
-                continue;
-            if (!result.cwd && typeof record.cwd === "string" && record.cwd.trim()) {
-                result.cwd = record.cwd;
-            }
-            // Subagent files share their parent's sessionId; retain their own filename.
-            if (!basename(path).startsWith("agent-") && typeof record.sessionId === "string") {
-                result.sessionId = record.sessionId;
-            }
-            if (record.type !== "user" && record.type !== "assistant")
-                continue;
-            const message = object(record.message);
-            const content = message?.content;
-            const blocks = typeof content === "string" ? [{ type: "text", text: content }]
-                : Array.isArray(content) ? content : [];
-            for (const [blockIndex, rawBlock] of blocks.entries()) {
-                const block = object(rawBlock);
-                if (!block)
-                    continue;
-                const key = typeof record.uuid === "string" ? record.uuid : `line-${index}`;
-                const timestamp = typeof record.timestamp === "string" ? Date.parse(record.timestamp) : NaN;
-                const createdAt = Number.isFinite(timestamp) ? new Date(timestamp).toISOString() : undefined;
-                if (block.type === "tool_use" && typeof block.name === "string") {
-                    const event = buildToolEvent(block.name, object(block.input), result.cwd);
-                    if (event)
-                        result.events.push({
-                            id: typeof block.id === "string" ? `tool-${block.id}` : `${key}-${blockIndex}`,
-                            ...event,
-                            createdAt,
-                        });
-                }
-                else if (block.type === "text" && typeof block.text === "string" && block.text.trim()) {
-                    result.events.push({
-                        id: `${key}-${blockIndex}`,
-                        eventType: `message:${record.type}`,
-                        createdAt,
-                        payloadJson: JSON.stringify({ text: block.text.slice(0, 4000) }),
-                    });
-                }
-            }
-        }
-    }
-    finally {
-        lines.close();
-        input.destroy();
-    }
-    return result;
-}
-async function* transcriptFiles(directory) {
-    let entries;
-    try {
-        entries = await readdir(directory, { withFileTypes: true });
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return;
-        throw error;
-    }
-    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-        const path = join(directory, entry.name);
-        if (entry.isDirectory())
-            yield* transcriptFiles(path);
-        else if (entry.isFile() && entry.name.endsWith(".jsonl"))
-            yield path;
-    }
-}
-async function fingerprint(path) {
+import { isCursorSource, readTranscript, transcriptFiles, transcriptSources } from "./transcripts/index.js";
+import { cursorDatabasePath, readCursorTranscripts } from "./transcripts/cursor.js";
+import { stableId } from "./transcripts/types.js";
+async function fingerprint(path, host) {
     const info = await stat(path, { bigint: true });
-    return `${process.env.SESSIONMEM_PROJECT_ID ?? ""}:${info.dev}:${info.ino}:${info.size}:${info.mtimeNs}:${info.ctimeNs}`;
+    // Version the checkpoint so files scanned by the old Claude-only reader are
+    // retried, and a changed host claim cannot reuse a previous parser's result.
+    return `hosts-v1:${host ?? "auto"}:${process.env.SESSIONMEM_PROJECT_ID ?? ""}:${info.dev}:${info.ino}:${info.size}:${info.mtimeNs}:${info.ctimeNs}`;
 }
 export async function sweepTranscripts(context, options = {}) {
-    const directory = resolve(expandTilde(options.transcriptsDir ?? join(homedir(), ".claude", "projects")));
+    const sources = transcriptSources(options);
     const summary = { filesFound: 0, sessionsImported: 0, memoriesCreated: 0, skipped: 0, errors: 0 };
-    const importedSessions = new Set();
+    const groups = new Map();
     const checkpoint = context.db.prepare("SELECT fingerprint FROM transcript_checkpoints WHERE path = ?");
     const saveCheckpoint = context.db.prepare("INSERT OR REPLACE INTO transcript_checkpoints (path, fingerprint) VALUES (?, ?)");
-    for await (const path of transcriptFiles(directory)) {
-        summary.filesFound++;
+    const report = (path, error) => {
+        summary.errors++;
+        process.stderr.write(`[sessionmem] ${path}: ${error instanceof Error ? error.message : String(error)}\n`);
+    };
+    for (const source of sources) {
         try {
-            const before = await fingerprint(path);
-            if (checkpoint.get(path)?.fingerprint === before) {
-                summary.skipped++;
+            if (source.host === "cursor" || (!source.host && await isCursorSource(source.directory))) {
+                const path = await cursorDatabasePath(source.directory);
+                if (!path)
+                    continue;
+                summary.filesFound++;
+                for (const transcript of await readCursorTranscripts(path)) {
+                    const projectId = deriveProjectId(transcript.cwd);
+                    const checkpointPath = `cursor:${JSON.stringify([path, transcript.sessionId])}`;
+                    // A database/WAL fingerprint is insufficient: unrelated settings and
+                    // other composers change it. Hash only this composer's bounded events.
+                    const before = stableId("cursor-v1", projectId, JSON.stringify(transcript.events));
+                    if (checkpoint.get(checkpointPath)?.fingerprint === before) {
+                        summary.skipped++;
+                        continue;
+                    }
+                    if (!transcript.events.length) {
+                        summary.skipped++;
+                        saveCheckpoint.run(checkpointPath, before);
+                        continue;
+                    }
+                    groups.set(JSON.stringify(["cursor", projectId, transcript.sessionId]), {
+                        host: "cursor", projectId, sessionId: transcript.sessionId,
+                        events: new Map(transcript.events.map(event => [event.id, event])),
+                        files: [{ path: checkpointPath, before, host: "cursor", malformed: false, snapshot: true }],
+                    });
+                }
                 continue;
             }
-            const transcript = await readTranscript(path);
-            if (!transcript.cwd || transcript.events.length === 0) {
-                summary.skipped++;
-                if (!transcript.malformed)
-                    saveCheckpoint.run(path, before);
-                else
-                    throw new Error("malformed or incomplete JSONL; will retry");
-                continue;
+            for await (const path of transcriptFiles(source.directory)) {
+                summary.filesFound++;
+                try {
+                    const before = await fingerprint(path, source.host);
+                    if (checkpoint.get(path)?.fingerprint === before) {
+                        summary.skipped++;
+                        continue;
+                    }
+                    const transcript = await readTranscript(path, source.host);
+                    if (transcript.malformed)
+                        report(path, "malformed or incomplete JSONL; will retry");
+                    if (!transcript.cwd || transcript.events.length === 0) {
+                        summary.skipped++;
+                        if (!transcript.malformed && await fingerprint(path, source.host) === before)
+                            saveCheckpoint.run(path, before);
+                        continue;
+                    }
+                    const projectId = deriveProjectId(transcript.cwd);
+                    const key = JSON.stringify([transcript.host, projectId, transcript.sessionId]);
+                    let group = groups.get(key);
+                    if (!group) {
+                        group = { host: transcript.host, projectId, sessionId: transcript.sessionId, events: new Map(), files: [] };
+                        groups.set(key, group);
+                    }
+                    for (const event of transcript.events) {
+                        if (!group.events.has(event.id))
+                            group.events.set(event.id, event);
+                    }
+                    group.files.push({ path, before, host: source.host, malformed: transcript.malformed });
+                }
+                catch (error) {
+                    report(path, error);
+                }
             }
-            const projectId = deriveProjectId(transcript.cwd);
-            const sessionId = transcript.sessionId;
-            for (let offset = 0; offset < transcript.events.length; offset += MAX_INGEST_EVENTS) {
+        }
+        catch (error) {
+            report(source.directory, error);
+        }
+    }
+    for (const group of groups.values()) {
+        const { projectId, sessionId, host } = group;
+        try {
+            const events = [...group.events.values()];
+            for (let offset = 0; offset < events.length; offset += MAX_INGEST_EVENTS) {
                 const result = await context.service.call("ingestSessionEvents", {
-                    projectId,
-                    sessionId,
-                    events: transcript.events.slice(offset, offset + MAX_INGEST_EVENTS).map(event => ({
-                        ...event, id: stableId(projectId, sessionId, event.id),
+                    projectId, sessionId,
+                    // Cursor edits the same bubble while streaming a response.
+                    replaceExisting: host === "cursor",
+                    events: events.slice(offset, offset + MAX_INGEST_EVENTS).map(event => ({
+                        // Preserve existing Claude IDs for compatibility with earlier sweeps.
+                        ...event, id: host === "claude-code" ? stableId(projectId, sessionId, event.id)
+                            : stableId(host, projectId, sessionId, event.id),
                     })),
                 });
                 if (!result.ok)
@@ -147,32 +109,30 @@ export async function sweepTranscripts(context, options = {}) {
             }
             const existing = context.db.prepare("SELECT id FROM memories WHERE project_id = ? AND session_id = ? AND kind = 'summary' LIMIT 1")
                 .get(projectId, sessionId);
-            // The pipeline upserts by project/session; keep existing hook summary IDs.
             const memoryId = existing?.id ?? stableId(projectId, sessionId, "summary");
             const result = await context.service.call("handleSessionEnd", {
-                projectId,
-                sessionId,
-                memoryId,
-                sourceAdapter: "claude-code",
+                projectId, sessionId, memoryId, sourceAdapter: host,
                 config: handleSessionEndConfigSchema.parse({ minimumEventThreshold: 1, allowCloudSummarization: false }),
             });
             if (!result.ok)
                 throw new Error(result.error.message);
             if (result.status !== "stored")
                 throw new Error(`summary ${result.status}; will retry`);
-            importedSessions.add(JSON.stringify([projectId, sessionId]));
-            summary.sessionsImported = importedSessions.size;
+            summary.sessionsImported++;
             if (!existing)
                 summary.memoriesCreated++;
-            if (transcript.malformed)
-                throw new Error("malformed or incomplete JSONL; will retry");
-            // Never mark concurrent appends as processed. The next sweep replays safely.
-            if (await fingerprint(path) === before)
-                saveCheckpoint.run(path, before);
+            for (const file of group.files) {
+                // Never mark concurrent appends or incomplete files as processed.
+                // Cursor checkpoints describe the copied snapshot, so a newer live
+                // commit will be discovered by the next fresh read without a stat gate.
+                if (!file.malformed && (file.snapshot || await fingerprint(file.path, file.host) === file.before)) {
+                    saveCheckpoint.run(file.path, file.before);
+                }
+            }
         }
         catch (error) {
-            summary.errors++;
-            process.stderr.write(`[sessionmem] ${path}: ${error instanceof Error ? error.message : String(error)}\n`);
+            for (const file of group.files)
+                report(file.path, error);
         }
     }
     return summary;

package/dist/cli/transcripts/claudeCode.js

@@ -0,0 +1,62 @@
+import { basename } from "node:path";
+import { buildToolEvent } from "../../core/capture/toolEvent.js";
+import { createdAt, object, unsupported } from "./types.js";
+const METADATA_TYPES = new Set([
+    "file-history-snapshot", "queue-operation", "summary", "system", "progress",
+    "last-prompt", "pr-link", "custom-title", "agent-name", "agent-color",
+]);
+export function isClaudeRecord(record) {
+    return ((record.type === "user" || record.type === "assistant") && !!object(record.message))
+        || METADATA_TYPES.has(String(record.type));
+}
+export function parseClaudeTranscript(path, records) {
+    const result = { host: "claude-code", sessionId: basename(path, ".jsonl"), events: [], malformed: false };
+    for (const { value: record, line } of records) {
+        if (!isClaudeRecord(record))
+            unsupported(result.host, `unrecognized record on line ${line + 1}`);
+        if (!result.cwd && typeof record.cwd === "string" && record.cwd.trim())
+            result.cwd = record.cwd;
+        // Claude subagent files reuse the parent's session ID.
+        if (!basename(path).startsWith("agent-") && typeof record.sessionId === "string") {
+            result.sessionId = record.sessionId;
+        }
+        if (record.type !== "user" && record.type !== "assistant")
+            continue;
+        const content = object(record.message)?.content;
+        if (typeof content !== "string" && !Array.isArray(content)) {
+            unsupported(result.host, `invalid message content on line ${line + 1}`);
+        }
+        const blocks = typeof content === "string" ? [{ type: "text", text: content }] : content;
+        for (const [blockIndex, rawBlock] of blocks.entries()) {
+            const block = object(rawBlock);
+            if (!block)
+                unsupported(result.host, `invalid message block on line ${line + 1}`);
+            const key = typeof record.uuid === "string" ? record.uuid : `line-${line}`;
+            const timestamp = createdAt(record.timestamp);
+            if (block.type === "tool_use") {
+                if (typeof block.name !== "string")
+                    unsupported(result.host, `invalid tool use on line ${line + 1}`);
+                const event = buildToolEvent(block.name, object(block.input), result.cwd);
+                if (event)
+                    result.events.push({
+                        id: typeof block.id === "string" ? `tool-${block.id}` : `${key}-${blockIndex}`,
+                        ...event, createdAt: timestamp,
+                    });
+            }
+            else if (block.type === "text") {
+                if (typeof block.text !== "string")
+                    unsupported(result.host, `invalid text on line ${line + 1}`);
+                if (block.text.trim())
+                    result.events.push({
+                        id: `${key}-${blockIndex}`, eventType: `message:${record.type}`, createdAt: timestamp,
+                        payloadJson: JSON.stringify({ text: block.text.slice(0, 4000) }),
+                    });
+            }
+            else if (!["tool_result", "image", "document", "thinking", "redacted_thinking",
+                "server_tool_use", "web_search_tool_result", "web_fetch_tool_result"].includes(String(block.type))) {
+                unsupported(result.host, `unrecognized message block on line ${line + 1}`);
+            }
+        }
+    }
+    return result;
+}

package/dist/cli/transcripts/codex.js

@@ -0,0 +1,111 @@
+import { buildFunctionCallEvent } from "../../core/capture/toolEvent.js";
+import { createdAt, object, stableId, unsupported } from "./types.js";
+/** Remove known host context while preserving human text in the same chunk. */
+function humanText(text) {
+    if (/^gAAAAA[A-Za-z0-9_=-]+\s*$/.test(text.trim()))
+        return "";
+    if (/^\s*# AGENTS\.md instructions for\b/.test(text)
+        || /^\s*#{1,3} (?:Skills|Plugins|Plugin catalog(?:ue)?)\s*\n+\s*(?:A skill is|The following (?:skills|plugins)|(?:#{1,3} )?Available (?:skills|plugins))/i.test(text))
+        return "";
+    return text.replace(/<(environment_context|plugin_catalogue|plugin_catalog|available_plugins|available_skills|skills_instructions)>[\s\S]*?<\/\1>/gi, "").trim();
+}
+export function parseCodexTranscript(_path, records) {
+    const result = { host: "codex", sessionId: "", events: [], malformed: false };
+    const occurrences = new Map();
+    for (const { value: record, line } of records) {
+        // agent_message envelopes can hold opaque Fernet strings. Never interpret them.
+        if (record.type === "agent_message")
+            continue;
+        const payload = object(record.payload);
+        if (typeof record.timestamp !== "string" || typeof record.type !== "string" || !payload) {
+            unsupported(result.host, `invalid rollout envelope on line ${line + 1}`);
+        }
+        if (record.type === "session_meta") {
+            if (typeof payload.id !== "string" || !payload.id.trim()
+                || typeof payload.cwd !== "string" || !payload.cwd.trim()) {
+                unsupported(result.host, `session_meta needs id and cwd on line ${line + 1}`);
+            }
+            if (result.sessionId && (result.sessionId !== payload.id || result.cwd !== payload.cwd)) {
+                unsupported(result.host, "conflicting session_meta records");
+            }
+            result.sessionId = payload.id;
+            result.cwd = payload.cwd;
+        }
+        else if (record.type === "response_item") {
+            if (typeof payload.type !== "string")
+                unsupported(result.host, `invalid response_item on line ${line + 1}`);
+            if (payload.type === "message") {
+                if (typeof payload.role !== "string" || !Array.isArray(payload.content)) {
+                    unsupported(result.host, `invalid message on line ${line + 1}`);
+                }
+                if (payload.role !== "user" && payload.role !== "assistant") {
+                    if (payload.role !== "system" && payload.role !== "developer") {
+                        unsupported(result.host, `unrecognized message role on line ${line + 1}`);
+                    }
+                    continue;
+                }
+                const chunks = [];
+                for (const raw of payload.content) {
+                    const chunk = object(raw);
+                    if (!chunk || typeof chunk.type !== "string")
+                        unsupported(result.host, `invalid content on line ${line + 1}`);
+                    if (chunk.type !== "input_text" && chunk.type !== "output_text") {
+                        if (!["input_image", "output_image", "image", "input_audio", "audio"].includes(chunk.type)) {
+                            unsupported(result.host, `unrecognized content type ${chunk.type} on line ${line + 1}`);
+                        }
+                        continue;
+                    }
+                    if (typeof chunk.text !== "string")
+                        unsupported(result.host, `invalid text on line ${line + 1}`);
+                    const text = payload.role === "user" ? humanText(chunk.text)
+                        : /^gAAAAA[A-Za-z0-9_=-]+\s*$/.test(chunk.text.trim()) ? "" : chunk.text.trim();
+                    if (text)
+                        chunks.push(text);
+                }
+                // IDs are absent in some CLI releases. Content plus occurrence preserves
+                // repeated turns and survives added metadata and changed replay timestamps.
+                const identity = stableId(payload.role, JSON.stringify(chunks));
+                const occurrence = occurrences.get(identity) ?? 0;
+                if (!chunks.length)
+                    continue;
+                occurrences.set(identity, occurrence + 1);
+                const key = typeof payload.id === "string" ? payload.id
+                    : typeof record.id === "string" ? record.id : `${identity}-${occurrence}`;
+                for (const [index, text] of chunks.entries())
+                    result.events.push({
+                        id: `message-${key}-${index}`, eventType: `message:${payload.role}`,
+                        createdAt: createdAt(record.timestamp), payloadJson: JSON.stringify({ text: text.slice(0, 4000) }),
+                    });
+            }
+            else if (payload.type === "function_call") {
+                if (typeof payload.name !== "string" || !payload.name.trim()
+                    || typeof payload.call_id !== "string" || !payload.call_id.trim() || typeof payload.arguments !== "string") {
+                    unsupported(result.host, `invalid function_call on line ${line + 1}`);
+                }
+                let input;
+                try {
+                    input = object(JSON.parse(payload.arguments));
+                }
+                catch {
+                    unsupported(result.host, `invalid function_call arguments on line ${line + 1}`);
+                }
+                if (!input)
+                    unsupported(result.host, `function_call arguments must be an object on line ${line + 1}`);
+                result.events.push({
+                    id: `tool-${payload.call_id}`,
+                    ...buildFunctionCallEvent(payload.name, input, payload.call_id, result.cwd), createdAt: createdAt(record.timestamp),
+                });
+            }
+            else if (!["reasoning", "function_call_output", "custom_tool_call", "custom_tool_call_output",
+                "web_search_call", "local_shell_call", "compaction", "agent_message"].includes(payload.type)) {
+                unsupported(result.host, `unrecognized response_item type ${payload.type} on line ${line + 1}`);
+            }
+        }
+        else if (!["event_msg", "turn_context", "compacted"].includes(record.type)) {
+            unsupported(result.host, `unrecognized record type ${record.type} on line ${line + 1}`);
+        }
+    }
+    if (records.length && !result.sessionId)
+        unsupported(result.host, "missing session_meta record");
+    return result;
+}

package/dist/cli/transcripts/cursor.js

@@ -0,0 +1,295 @@
+import BetterSqlite3 from "better-sqlite3";
+import { copyFile, mkdtemp, readFile, readdir, rm, stat } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { createdAt, object, unsupported } from "./types.js";
+export function cursorUserDirectory(platform = process.platform) {
+    if (platform === "darwin")
+        return join(homedir(), "Library", "Application Support", "Cursor", "User");
+    if (platform === "win32")
+        return join(process.env.APPDATA || join(homedir(), "AppData", "Roaming"), "Cursor", "User");
+    return join(homedir(), ".config", "Cursor", "User");
+}
+async function fileStamp(path) {
+    try {
+        const info = await stat(path, { bigint: true });
+        return `${info.dev}:${info.ino}:${info.size}:${info.mtimeNs}:${info.ctimeNs}`;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+}
+/** Never give SQLite a connection to the source, including its WAL/SHM files. */
+async function snapshot(path, read) {
+    const temp = await mkdtemp(join(tmpdir(), "sessionmem-cursor-"));
+    try {
+        const target = join(temp, "state.vscdb");
+        // Copy the WAL too: immutable connections to a live database ignore it and
+        // would silently miss recently committed messages. Detect checkpoints and
+        // concurrent writes during the copy, then retry on a later sweep if busy.
+        const suffixes = ["", "-wal", "-journal"];
+        for (let attempt = 0; attempt < 3; attempt++) {
+            const before = await Promise.all(suffixes.map(suffix => fileStamp(path + suffix)));
+            if (!before[0])
+                throw new Error(`Cursor database disappeared: ${path}`);
+            try {
+                for (const [index, suffix] of suffixes.entries()) {
+                    await rm(target + suffix, { force: true });
+                    if (before[index])
+                        await copyFile(path + suffix, target + suffix);
+                }
+            }
+            catch (error) {
+                if (error.code === "ENOENT")
+                    continue;
+                throw error;
+            }
+            const after = await Promise.all(suffixes.map(suffix => fileStamp(path + suffix)));
+            if (JSON.stringify(before) !== JSON.stringify(after))
+                continue;
+            let db;
+            try {
+                // better-sqlite3 normally compiles with SQLITE_USE_URI=0. Try immutable
+                // only on a copy without sidecars; otherwise use a read-only temp copy
+                // where SQLite can reconstruct its private WAL index safely.
+                if (!before[1] && !before[2]) {
+                    try {
+                        db = new BetterSqlite3(`${pathToFileURL(target).href}?mode=ro&immutable=1`, { readonly: true, fileMustExist: true });
+                    }
+                    catch { /* URI opens are unavailable in the bundled SQLite build. */ }
+                }
+                db ??= new BetterSqlite3(target, { readonly: true, fileMustExist: true, timeout: 0 });
+                return read(db);
+            }
+            finally {
+                db?.close();
+            }
+        }
+        throw new Error("Cursor database changed while copying; will retry");
+    }
+    finally {
+        await rm(temp, { recursive: true, force: true });
+    }
+}
+function json(value, label) {
+    if (Buffer.isBuffer(value))
+        value = value.toString("utf8");
+    if (typeof value !== "string")
+        unsupported("cursor", `${label} is not JSON text`);
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        unsupported("cursor", `invalid JSON in ${label}`);
+    }
+}
+function requireTable(db, table) {
+    const columns = db.prepare(`PRAGMA table_info(${table})`).all();
+    if (!["key", "value"].every(name => columns.some(column => column.name === name))) {
+        unsupported("cursor", `missing ${table} table or key/value columns`);
+    }
+}
+function item(db, key) {
+    const row = db.prepare("SELECT value FROM ItemTable WHERE key = ?").get(key);
+    return row ? json(row.value, key) : undefined;
+}
+function workspacePath(value) {
+    const uri = object(value);
+    if (typeof uri?.fsPath === "string" && isAbsolute(uri.fsPath))
+        return uri.fsPath;
+    if (typeof value === "string" && isAbsolute(value))
+        return value;
+    if (typeof value === "string" && value.startsWith("file:")) {
+        try {
+            return fileURLToPath(value);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    // URI components are used in some workspaceIdentifier entries.
+    if (uri?.scheme === "file" && typeof uri.path === "string") {
+        try {
+            return fileURLToPath(`file://${typeof uri.authority === "string" ? uri.authority : ""}${uri.path}`);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return undefined;
+}
+function composers(value, key) {
+    const entries = Array.isArray(value) ? value : object(value)?.allComposers;
+    if (!Array.isArray(entries))
+        unsupported("cursor", `${key} needs an array of composers`);
+    return entries.map(entry => {
+        const composer = object(entry);
+        if (!composer || typeof composer.composerId !== "string" || !composer.composerId.trim() || composer.composerId.length > 200) {
+            unsupported("cursor", `invalid composerId in ${key}`);
+        }
+        return composer;
+    });
+}
+/** Resolve a User directory or a global/workspace state.vscdb override. */
+export async function cursorDatabasePath(directory) {
+    try {
+        if ((await stat(directory)).isFile()) {
+            if (basename(dirname(dirname(directory))) === "workspaceStorage") {
+                return join(dirname(dirname(dirname(directory))), "globalStorage", "state.vscdb");
+            }
+            return directory;
+        }
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+    const path = join(directory, "globalStorage", "state.vscdb");
+    return await fileStamp(path) ? path : undefined;
+}
+function parseBubble(value, id) {
+    const bubble = object(json(value, `bubble ${id}`));
+    if (!bubble)
+        unsupported("cursor", `invalid bubble ${id}`);
+    // Cursor uses 1=user and 2=assistant. Tool, system and internal bubbles are
+    // not conversation messages. Never stringify code, tool results or context.
+    const role = bubble.type === 1 || bubble.type === "user" ? "user"
+        : bubble.type === 2 || bubble.type === "assistant" ? "assistant" : undefined;
+    if (!role) {
+        if (bubble.type === undefined)
+            unsupported("cursor", `missing message type in bubble ${id}`);
+        return undefined;
+    }
+    if (bubble.text === undefined || bubble.text === null)
+        return undefined;
+    if (typeof bubble.text !== "string")
+        unsupported("cursor", `invalid text in bubble ${id}`);
+    if (!bubble.text.trim())
+        return undefined;
+    const timestamp = typeof bubble.createdAt === "number" && Number.isFinite(bubble.createdAt)
+        ? new Date(bubble.createdAt).toISOString() : createdAt(bubble.createdAt);
+    return { role, text: bubble.text.slice(0, 4000), timestamp };
+}
+export async function readCursorTranscripts(path) {
+    const global = await snapshot(path, db => {
+        requireTable(db, "cursorDiskKV");
+        // Older layouts only need ItemTable in the workspace databases.
+        const hasHeadersTable = !!db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'ItemTable'").get();
+        if (hasHeadersTable)
+            requireTable(db, "ItemTable");
+        const headers = hasHeadersTable ? item(db, "composer.composerHeaders") : undefined;
+        // Materialize only the relevant rows, one value at a time. Large tool and
+        // code fields are discarded immediately rather than retained in memory.
+        const metadata = new Map();
+        const bubbles = new Map();
+        for (const row of db.prepare("SELECT key, value FROM cursorDiskKV WHERE key GLOB 'composerData:*' OR key GLOB 'bubbleId:*' ORDER BY key").iterate()) {
+            if (row.key.startsWith("composerData:")) {
+                const data = object(json(row.value, row.key));
+                if (!data)
+                    unsupported("cursor", `invalid ${row.key}`);
+                metadata.set(row.key.slice("composerData:".length), data);
+            }
+            else {
+                const parts = row.key.split(":");
+                if (parts.length !== 3 || !parts[1] || !parts[2])
+                    unsupported("cursor", `invalid bubble key ${row.key}`);
+                const entries = bubbles.get(parts[1]) ?? [];
+                entries.push({ id: parts[2], message: parseBubble(row.value, parts[2]) });
+                bubbles.set(parts[1], entries);
+            }
+        }
+        return { headers, metadata, bubbles };
+    });
+    const index = new Map();
+    const add = (composer, cwd) => {
+        const id = composer.composerId;
+        if (!cwd)
+            unsupported("cursor", `missing workspace path for composer ${id}`);
+        if (index.has(id) && resolve(index.get(id)) !== resolve(cwd))
+            unsupported("cursor", `conflicting workspaces for composer ${id}`);
+        index.set(id, cwd);
+    };
+    let foundIndex = global.headers !== undefined;
+    if (foundIndex) {
+        for (const composer of composers(global.headers, "composer.composerHeaders")) {
+            add(composer, workspacePath(object(composer.workspaceIdentifier)?.uri));
+        }
+    }
+    const workspaces = join(dirname(dirname(path)), "workspaceStorage");
+    let directories;
+    try {
+        directories = await readdir(workspaces, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+        directories = [];
+    }
+    for (const entry of directories.sort((a, b) => a.name.localeCompare(b.name))) {
+        if (!entry.isDirectory())
+            continue;
+        const workspace = join(workspaces, entry.name);
+        const database = join(workspace, "state.vscdb");
+        if (!await fileStamp(database))
+            continue;
+        const legacy = await snapshot(database, db => {
+            requireTable(db, "ItemTable");
+            return item(db, "composer.composerData");
+        });
+        if (legacy === undefined)
+            continue;
+        foundIndex = true;
+        const entries = composers(legacy, "composer.composerData");
+        if (!entries.length)
+            continue;
+        let info;
+        try {
+            info = object(json(await readFile(join(workspace, "workspace.json"), "utf8"), "workspace.json"));
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                unsupported("cursor", "missing workspace.json for composer index");
+            throw error;
+        }
+        for (const composer of entries) {
+            // Current central headers take precedence over stale workspace indexes.
+            if (!index.has(composer.composerId))
+                add(composer, workspacePath(info?.folder ?? info?.workspace));
+        }
+    }
+    if (!foundIndex)
+        unsupported("cursor", "missing composer.composerHeaders and workspace composer.composerData indexes");
+    const transcripts = [];
+    for (const [sessionId, cwd] of index) {
+        const metadata = global.metadata.get(sessionId);
+        if (!metadata)
+            unsupported("cursor", `missing composerData:${sessionId}`);
+        const headers = metadata.fullConversationHeadersOnly ?? metadata.conversation;
+        if (headers !== undefined && !Array.isArray(headers))
+            unsupported("cursor", `invalid conversation headers for ${sessionId}`);
+        const order = new Map();
+        const entries = global.bubbles.get(sessionId) ?? [];
+        const bubbleIds = new Set(entries.map(bubble => bubble.id));
+        for (const [position, raw] of (Array.isArray(headers) ? headers : []).entries()) {
+            const header = object(raw);
+            if (typeof header?.bubbleId !== "string")
+                unsupported("cursor", `invalid conversation header for ${sessionId}`);
+            order.set(header.bubbleId, position);
+            if (!bubbleIds.has(header.bubbleId)) {
+                unsupported("cursor", `missing bubbleId:${sessionId}:${header.bubbleId}`);
+            }
+        }
+        entries.sort((a, b) => (order.get(a.id) ?? Infinity) - (order.get(b.id) ?? Infinity)
+            || (a.message?.timestamp ?? "").localeCompare(b.message?.timestamp ?? "") || a.id.localeCompare(b.id));
+        transcripts.push({ host: "cursor", cwd, sessionId, malformed: false,
+            events: entries.flatMap(({ id, message }) => message ? [{
+                    id: `bubble-${id}`, eventType: `message:${message.role}`, payloadJson: JSON.stringify({ text: message.text }), createdAt: message.timestamp,
+                }] : []),
+        });
+    }
+    return transcripts;
+}

package/dist/cli/transcripts/index.js

@@ -0,0 +1,118 @@
+import { createReadStream } from "node:fs";
+import { readdir, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { createInterface } from "node:readline";
+import { expandTilde } from "../context.js";
+import { isClaudeRecord, parseClaudeTranscript } from "./claudeCode.js";
+import { parseCodexTranscript } from "./codex.js";
+import { cursorDatabasePath, cursorUserDirectory, readCursorTranscripts } from "./cursor.js";
+import { object } from "./types.js";
+export const TRANSCRIPT_HOSTS = ["claude-code", "codex", "cursor"];
+const parsers = { "claude-code": parseClaudeTranscript, codex: parseCodexTranscript };
+export function transcriptDirectory(host) {
+    if (host === "cursor")
+        return cursorUserDirectory();
+    return join(homedir(), host === "codex" ? ".codex" : ".claude", host === "codex" ? "sessions" : "projects");
+}
+export function transcriptSources(options) {
+    const host = options.host;
+    if (host && !TRANSCRIPT_HOSTS.includes(host)) {
+        throw new Error(`Unsupported transcript host: ${host}. Choose ${TRANSCRIPT_HOSTS.join(" or ")}`);
+    }
+    const selected = host;
+    if (options.transcriptsDir)
+        return [{ directory: resolve(expandTilde(options.transcriptsDir)), host: selected }];
+    return (selected ? [selected] : TRANSCRIPT_HOSTS).map(host => ({ directory: transcriptDirectory(host), host }));
+}
+export async function* transcriptFiles(directory) {
+    let entries;
+    try {
+        entries = await readdir(directory, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return;
+        throw error;
+    }
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+        const path = join(directory, entry.name);
+        if (entry.isDirectory())
+            yield* transcriptFiles(path);
+        else if (entry.isFile() && entry.name.endsWith(".jsonl"))
+            yield path;
+    }
+}
+/** Recognize Cursor overrides without changing JSONL directory overrides. */
+export async function isCursorSource(directory) {
+    try {
+        if ((await stat(directory)).isFile())
+            return directory.endsWith(".vscdb");
+        return !!await cursorDatabasePath(directory);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+export async function readTranscript(path, claimedHost) {
+    if (claimedHost === "cursor")
+        throw new Error("unsupported format for cursor: expected a User directory or state.vscdb database");
+    const records = [];
+    let malformed = false;
+    const input = createReadStream(path);
+    const lines = createInterface({ input, crlfDelay: Infinity });
+    let lineIndex = 0;
+    try {
+        for await (const line of lines) {
+            const index = lineIndex++;
+            if (!line.trim())
+                continue;
+            let value;
+            try {
+                value = object(JSON.parse(line.replace(/^\uFEFF/, "")));
+            }
+            catch {
+                malformed = true;
+                continue;
+            }
+            if (!value)
+                throw new Error(`unsupported format${claimedHost ? ` for ${claimedHost}` : ""}: record on line ${index + 1} is not an object`);
+            records.push({ value, line: index });
+        }
+    }
+    finally {
+        lines.close();
+        input.destroy();
+    }
+    const host = claimedHost ?? (records.some(({ value }) => value.type === "session_meta") ? "codex"
+        : records.some(({ value }) => isClaudeRecord(value)) ? "claude-code" : undefined);
+    if (!host && records.length)
+        throw new Error("unsupported format: expected Claude Code transcripts or Codex CLI rollouts");
+    const result = parsers[host ?? "claude-code"](path, records);
+    return { ...result, malformed };
+}
+/** Read-only doctor probe: enumerate history and validate one sample per host. */
+export async function inspectTranscriptDiscovery(host) {
+    const directory = transcriptDirectory(host);
+    if (host === "cursor") {
+        const path = await cursorDatabasePath(directory);
+        if (!path)
+            return `No transcripts found (${directory})`;
+        const transcripts = await readCursorTranscripts(path);
+        return `${transcripts.length} composer(s) found (${path}); parsed as cursor`;
+    }
+    let count = 0;
+    let sample;
+    for await (const path of transcriptFiles(directory)) {
+        count++;
+        sample ??= path;
+    }
+    if (!sample)
+        return `No transcripts found (${directory})`;
+    const transcript = await readTranscript(sample, host);
+    if (transcript.malformed)
+        throw new Error(`malformed or incomplete JSONL (${sample})`);
+    return `${count} transcript file(s) found (${directory}); sample parsed as ${host}`;
+}

package/dist/cli/transcripts/types.js

@@ -0,0 +1,15 @@
+import { createHash } from "node:crypto";
+export function object(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value : undefined;
+}
+export function stableId(...parts) {
+    return `transcript-${createHash("sha256").update(JSON.stringify(parts)).digest("hex")}`;
+}
+export function createdAt(value) {
+    const timestamp = typeof value === "string" ? Date.parse(value) : NaN;
+    return Number.isFinite(timestamp) ? new Date(timestamp).toISOString() : undefined;
+}
+export function unsupported(host, detail) {
+    throw new Error(`unsupported format for ${host}: ${detail}`);
+}

package/dist/core/api/contracts.js

@@ -90,6 +90,9 @@ export const ingestSessionEventSchema = z.object({
 export const ingestSessionEventsRequestSchema = z.object({
     projectId: z.string().min(1),
     sessionId: z.string().min(1).max(200),
+    // Mutable transcript hosts can refresh an existing event without changing
+    // its identity, order or original timestamp. Other callers remain append-only.
+    replaceExisting: z.boolean().optional(),
     events: z.array(ingestSessionEventSchema).min(1).max(MAX_INGEST_EVENTS),
 });
 export const summarizeSessionToMemoryRequestSchema = z.object({

package/dist/core/api/memoryCoreService.js

@@ -208,7 +208,7 @@ export function createMemoryCoreService(deps) {
                         event_type: event.eventType,
                         payload_json: redactedPayload,
                         created_at: event.createdAt,
-                    });
+                    }, parsed.replaceExisting);
                 }
                 return written;
             });

package/dist/core/capture/toolEvent.js

@@ -61,16 +61,17 @@ function describeToolUse(toolName, input) {
  * structured input and keep only the human-readable summary rather than
  * emitting truncated — and therefore unparseable — JSON.
  */
-function buildPayloadJson(toolName, text, input, cwd) {
+function buildPayloadJson(toolName, text, input, cwd, callId) {
     const full = JSON.stringify({
         tool: toolName,
         text,
         input: shrinkValue(input),
         cwd,
+        ...(callId ? { call_id: callId } : {}),
     });
     if (full.length <= MAX_HOOK_PAYLOAD_CHARS)
         return full;
-    return JSON.stringify({ tool: toolName, text, cwd, truncated: true });
+    return JSON.stringify({ tool: toolName, text, cwd, ...(callId ? { call_id: callId } : {}), truncated: true });
 }
 export function buildToolEvent(toolName, input, cwd) {
     if (!CAPTURED_TOOL_TYPES.has(toolName))
@@ -80,3 +81,14 @@ export function buildToolEvent(toolName, input, cwd) {
         payloadJson: buildPayloadJson(toolName, describeToolUse(toolName, input), input, cwd),
     };
 }
+/** Codex function calls retain their native name and call ID. */
+export function buildFunctionCallEvent(name, input, callId, cwd) {
+    const command = input.command ?? input.cmd;
+    const text = ["exec_command", "shell_command", "shell"].includes(name)
+        ? describeToolUse("Bash", { command: Array.isArray(command) ? command.join(" ") : command })
+        : CAPTURED_TOOL_TYPES.has(name) ? describeToolUse(name, input) : truncate(`Called ${name}`, MAX_TEXT_CHARS);
+    return {
+        eventType: `tool_use:${name.toLowerCase()}`,
+        payloadJson: buildPayloadJson(name, text, input, cwd, callId),
+    };
+}

package/dist/core/storage/sessionEventsRepo.js

@@ -4,6 +4,11 @@ function getSessionEventsStatements(db) {
     if (stmts)
         return stmts;
     stmts = {
+        updateEvent: db.prepare(`
+      UPDATE session_events SET event_type = @event_type, payload_json = @payload_json
+      WHERE id = @id AND project_id = @project_id AND session_id = @session_id
+        AND (event_type != @event_type OR payload_json != @payload_json)
+    `),
         // INSERT OR IGNORE so re-ingesting an event with the same logical key
         // (project_id, session_id, event_index) — now a UNIQUE index, migration 009
         // — is a no-op rather than a duplicate row or a PK error.
@@ -34,10 +39,14 @@ function getSessionEventsStatements(db) {
 /**
  * Insert a session event. Returns the number of rows written (1, or 0 when the
  * (project_id, session_id, event_index) key already exists and the insert was
- * ignored).
+ * ignored). Mutable transcript imports can opt in to refreshing the content of
+ * an existing ID in the same project/session, preserving its index and date.
+ * Returns 1 for either an insertion or a content update; unchanged replays are 0.
  */
-export function insertSessionEvent(db, input) {
-    return getSessionEventsStatements(db).insertEvent.run(input).changes;
+export function insertSessionEvent(db, input, replaceExisting = false) {
+    const statements = getSessionEventsStatements(db);
+    const updated = replaceExisting ? statements.updateEvent.run(input).changes : 0;
+    return updated + statements.insertEvent.run(input).changes;
 }
 /**
  * Next free `event_index` for a session (max + 1, or 0 when the session has no

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sessionmem",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "private": false,
   "type": "module",
   "description": "Local-first MCP memory layer for coding agents across Claude Code, Codex, Cursor, Cline, Windsurf, and other MCP-compatible hosts.",