sessionmem 1.4.0 → 1.6.0

package/dist/cli/commands/search.js

@@ -19,6 +19,7 @@ export async function searchCommand(query, options = {}, ctx) {
         limit,
         mode: "auto",
         depth: "default",
+        includeHistory: options.includeHistory,
     });
     if (!result.ok) {
         console.error(result.error.message);

package/dist/cli/commands/team.js

@@ -3,6 +3,7 @@ import { join } from "path";
 import { randomUUID } from "crypto";
 import { configFilePath, readPolicyConfig, writePolicyConfig, } from "../../core/config/policyConfig.js";
 import { createCliContext } from "../context.js";
+import { reconcileProjectSupersessions } from "../../core/storage/supersessionRepo.js";
 function resolvePath(options) {
     return options?.configPath ?? configFilePath();
 }
@@ -89,8 +90,11 @@ export function teamDisableCommand(options, ctx) {
         return;
     }
     const context = ctx ?? createCliContext();
-    const result = context.db
-        .prepare("DELETE FROM memories WHERE project_id = ? AND author != ? AND author != ''")
-        .run(context.projectId, context.username);
+    const result = context.db.transaction(() => {
+        const removed = context.db.prepare("DELETE FROM memories WHERE project_id = ? AND author != ? AND author != ''").run(context.projectId, context.username);
+        if (removed.changes)
+            reconcileProjectSupersessions(context.db, context.projectId);
+        return removed;
+    })();
     console.log(`Team mode disabled. Removed ${result.changes} teammate-authored ${result.changes === 1 ? "memory" : "memories"}.`);
 }

package/dist/cli/commands/ui.js

@@ -0,0 +1,67 @@
+import BetterSqlite3 from "better-sqlite3";
+import { spawn } from "node:child_process";
+import { once } from "node:events";
+import { createMemoryCoreService } from "../../core/api/memoryCoreService.js";
+import { deriveProjectId } from "../projectId.js";
+import { resolveDbPath } from "../context.js";
+import { inspectMigrations } from "../../core/schema/runMigrations.js";
+import { parseUiPort, startUiServer } from "../../ui/server.js";
+/** Open the OS browser without a shell or an additional runtime dependency. */
+export function openBrowser(url) {
+    const command = process.platform === "win32" ? "rundll32.exe" : process.platform === "darwin" ? "open" : "xdg-open";
+    const args = process.platform === "win32" ? ["url.dll,FileProtocolHandler", url] : [url];
+    const child = spawn(command, args, { stdio: "ignore", detached: true, windowsHide: true });
+    const failed = () => console.error("Could not open a browser. Open the printed URL manually.");
+    child.once("error", failed);
+    child.once("exit", code => { if (code)
+        failed(); });
+    child.unref();
+}
+export async function uiCommand(options = {}) {
+    const port = parseUiPort(options.port);
+    // Unlike the normal CLI context, a viewer must not create, migrate or write the store.
+    let db;
+    try {
+        db = new BetterSqlite3(resolveDbPath(), { readonly: true, fileMustExist: true });
+    }
+    catch {
+        throw new Error("Cannot open the memory store. Run sessionmem ping first, or check SESSIONMEM_DB_PATH.");
+    }
+    try {
+        db.pragma("query_only = ON");
+        db.pragma("busy_timeout = 5000");
+        const migrations = inspectMigrations(db);
+        if (migrations.unknown.length) {
+            throw new Error("The memory store uses an unrecognized schema. Use the sessionmem version that created it.");
+        }
+        if (migrations.pending.length) {
+            throw new Error("The memory store needs an upgrade. Run sessionmem ping first to apply pending migrations.");
+        }
+        const viewer = await startUiServer({ db, service: createMemoryCoreService({ db }), projectId: deriveProjectId() }, port);
+        let stopping = false;
+        const stop = () => {
+            if (stopping)
+                return;
+            stopping = true;
+            void viewer.close().catch(error => {
+                console.error(error instanceof Error ? error.message : String(error));
+                process.exitCode = 1;
+            });
+        };
+        process.once("SIGINT", stop);
+        process.once("SIGTERM", stop);
+        try {
+            const closed = once(viewer.server, "close");
+            console.log(`sessionmem viewer: ${viewer.url}\nRead-only. Press Ctrl-C to stop.`);
+            openBrowser(viewer.url);
+            await closed;
+        }
+        finally {
+            process.removeListener("SIGINT", stop);
+            process.removeListener("SIGTERM", stop);
+        }
+    }
+    finally {
+        db.close();
+    }
+}

package/dist/cli/commands/watch.js

@@ -0,0 +1,48 @@
+import { setTimeout } from "node:timers/promises";
+import { createCliContext } from "../context.js";
+import { printSweepSummary, sweepTranscripts } from "../transcriptSweep.js";
+export async function watchCommand(options = {}, ctx) {
+    const interval = Number(options.interval ?? 5);
+    if (!Number.isFinite(interval) || interval <= 0 || interval > 86400) {
+        throw new Error("--interval must be a number greater than 0 and at most 86400 seconds");
+    }
+    const context = ctx ?? createCliContext();
+    const controller = new AbortController();
+    const stop = () => controller.abort();
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+    let firstSweep = true;
+    try {
+        do {
+            try {
+                const summary = await sweepTranscripts(context, options);
+                if (firstSweep || options.once || summary.sessionsImported || summary.errors) {
+                    printSweepSummary("watch", summary);
+                }
+                firstSweep = false;
+                if (options.once && summary.errors)
+                    process.exitCode = 1;
+            }
+            catch (error) {
+                if (options.once)
+                    throw error;
+                console.error(`[sessionmem] watch: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            if (options.once || controller.signal.aborted)
+                break;
+            try {
+                await setTimeout(interval * 1000, undefined, { signal: controller.signal });
+            }
+            catch (error) {
+                if (!controller.signal.aborted)
+                    throw error;
+            }
+        } while (!controller.signal.aborted);
+    }
+    finally {
+        process.removeListener("SIGINT", stop);
+        process.removeListener("SIGTERM", stop);
+        if (!ctx)
+            context.db.close();
+    }
+}

package/dist/cli/index.js

@@ -5,6 +5,7 @@ import { runMcpServer } from "./commands/run.js";
 import { sessionStartCommand } from "./commands/sessionStart.js";
 import { sessionEndCommand } from "./commands/sessionEnd.js";
 import { installCommand } from "./commands/install.js";
+import { doctorCommand } from "./commands/doctor.js";
 import { uninstallCommand } from "./commands/uninstall.js";
 import { pingCommand } from "./commands/ping.js";
 import { searchCommand } from "./commands/search.js";
@@ -24,6 +25,11 @@ import { reEmbedCommand } from "./commands/reEmbed.js";
 import { ingestHookCommand } from "./commands/ingestHook.js";
 import { dedupeCommand } from "./commands/dedupe.js";
 import { browseCommand } from "./commands/browse.js";
+import { scanCommand } from "./commands/scan.js";
+import { watchCommand } from "./commands/watch.js";
+import { entitiesCommand } from "./commands/entities.js";
+import { historyCommand } from "./commands/history.js";
+import { uiCommand } from "./commands/ui.js";
 // Source the version from package.json (single source of truth) so `--version`
 // never drifts from the published manifest. createRequire + resolveJsonModule
 // reads the manifest relative to this module; from dist/cli/index.js the
@@ -35,6 +41,11 @@ program
     .command("run")
     .description("Start the sessionmem MCP server")
     .action(runMcpServer);
+program
+    .command("ui")
+    .description("Open a local read-only web viewer for the memory store")
+    .option("--port <N>", "Local port (default: 3777; 0 selects a free port)")
+    .action((options) => uiCommand(options));
 program
     .command("session-start")
     .description("Print prior memory context for the current project as Claude Code SessionStart hook output (invoked automatically by the hook installed during `sessionmem install`)")
@@ -47,11 +58,30 @@ program
     .command("ingest-hook")
     .description("Process a Claude Code PostToolUse hook payload from stdin and store it as a session event (invoked automatically by the hook installed during `sessionmem install`)")
     .action(() => ingestHookCommand());
+program
+    .command("scan")
+    .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, 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));
 program
     .command("install")
-    .description("Install sessionmem into the current MCP host")
+    .description("Install sessionmem into every detected agent host")
     .option("--adapter <name>", "Force a host adapter instead of auto-detecting (claude-code, cursor, windsurf, cline, codex, antigravity, qcoder, generic)")
     .action((options) => installCommand(options));
+program
+    .command("doctor")
+    .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
     .command("uninstall")
     .description("Remove sessionmem from the current MCP host")
@@ -75,11 +105,24 @@ program
     .command("search <query>")
     .description("Search memories by semantic query")
     .option("--limit <n>", "Maximum number of results (1-100)", "10")
+    .option("--include-history", "Include superseded facts")
     .action((query, options) => searchCommand(query, options));
 program
     .command("list")
     .description("List up to 200 recent memories for the current project")
     .action(() => listCommand());
+program
+    .command("entities")
+    .description("List extracted entities, typed relations, and source memory IDs for a project")
+    .option("--project <id>", "Project ID (default: current project)")
+    .option("--json", "Output entities and relations as JSON")
+    .action((options) => entitiesCommand(options));
+program
+    .command("history")
+    .description("List supersession chains, source memory IDs, and timestamps")
+    .option("--project <id>", "Project ID (default: current project)")
+    .option("--json", "Output supersession links as JSON")
+    .action((options) => historyCommand(options));
 program
     .command("show <id>")
     .description("Show memory details by ID (content capped at 2000 characters)")

package/dist/cli/projectId.js

@@ -92,7 +92,7 @@ export function projectIdFromCwd(cwd) {
  * bucket. The id is unchanged for anyone already running at the repo root,
  * since the root IS the cwd in that case.
  */
-export function deriveProjectId() {
+export function deriveProjectId(cwd = process.cwd()) {
     const envProjectId = process.env.SESSIONMEM_PROJECT_ID;
     if (envProjectId && envProjectId.trim() !== "") {
         // Sanitize the operator-supplied id to prevent path traversal: the id is
@@ -110,6 +110,5 @@ export function deriveProjectId() {
             return sanitized;
         }
     }
-    const cwd = process.cwd();
     return projectIdFromCwd(findProjectRoot(cwd) ?? cwd);
 }

package/dist/cli/transcriptSweep.js

@@ -0,0 +1,142 @@
+import { stat } from "node:fs/promises";
+import { handleSessionEndConfigSchema, MAX_INGEST_EVENTS } from "../core/api/contracts.js";
+import { deriveProjectId } from "./projectId.js";
+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 });
+    // 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 sources = transcriptSources(options);
+    const summary = { filesFound: 0, sessionsImported: 0, memoriesCreated: 0, skipped: 0, errors: 0 };
+    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 (?, ?)");
+    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 {
+            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;
+            }
+            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);
+                }
+            }
+        }
+        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,
+                    // 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)
+                    throw new Error(result.error.message);
+            }
+            const existing = context.db.prepare("SELECT id FROM memories WHERE project_id = ? AND session_id = ? AND kind = 'summary' LIMIT 1")
+                .get(projectId, sessionId);
+            const memoryId = existing?.id ?? stableId(projectId, sessionId, "summary");
+            const result = await context.service.call("handleSessionEnd", {
+                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`);
+            summary.sessionsImported++;
+            if (!existing)
+                summary.memoriesCreated++;
+            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) {
+            for (const file of group.files)
+                report(file.path, error);
+        }
+    }
+    return summary;
+}
+export function printSweepSummary(command, summary) {
+    console.log(`sessionmem ${command}: files found: ${summary.filesFound}; sessions imported: ${summary.sessionsImported}; memories created: ${summary.memoriesCreated}; skipped: ${summary.skipped}; errors: ${summary.errors}`);
+}

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;
+}