sessionmem 1.5.0 → 1.7.0

package/dist/cli/commands/autostart.js

@@ -0,0 +1,24 @@
+import { createAutostart, invalidLaunchPaths } from "../autostart/index.js";
+export function autostartCommand(action, service) {
+    if (!["enable", "disable", "status"].includes(action))
+        throw new Error("Use sessionmem autostart enable, disable, or status");
+    const autostart = service ?? createAutostart();
+    if (action === "status") {
+        const status = autostart.status();
+        console.log(`Auto-start ${status.registered ? "enabled" : "disabled"}: ${status.detail}`);
+        if (status.launch) {
+            console.log(`Binary: ${status.launch.command}\nEntry point: ${status.launch.args[0]}`);
+            const invalid = invalidLaunchPaths(status.launch);
+            if (invalid.length) {
+                console.error(`Invalid binary path: ${invalid.join(", ")}. Run sessionmem autostart enable.`);
+                process.exitCode = 1;
+            }
+        }
+        return;
+    }
+    if (action === "enable")
+        autostart.enable();
+    else
+        autostart.disable();
+    console.log(`Auto-start ${action === "enable" ? "enabled and started" : "disabled and stopped"}`);
+}

package/dist/cli/commands/config.js

@@ -42,6 +42,7 @@ const CONFIG_KEYS = {
     retentionDays: { field: "retentionDays", coerce: coerceRetentionDays },
     redactionEnabled: { field: "redactionEnabled", coerce: coerceBool },
     injectionCap: { field: "injectionCap", coerce: coerceInjectionCap },
+    semanticSearch: { field: "semanticSearch", coerce: coerceBool },
 };
 function resolvePath(options) {
     return options?.configPath ?? configFilePath();

package/dist/cli/commands/doctor.js

@@ -1,3 +1,5 @@
+import { createAutostart, invalidLaunchPaths } from "../autostart/index.js";
+import { inspectWatchCheckpoint } from "../watchCheckpoint.js";
 import BetterSqlite3 from "better-sqlite3";
 import { randomUUID } from "node:crypto";
 import { createRequire } from "node:module";
@@ -7,6 +9,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 +56,31 @@ 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);
+    const captureFix = "Run sessionmem autostart enable; inspect logs/watch.log beside the database and OS service logs, then run sessionmem doctor";
+    try {
+        const registration = createAutostart({ dbPath }).status();
+        report("Auto-start registration", registration.registered, registration.detail, registration.registered ? undefined : captureFix);
+        const invalid = registration.launch ? invalidLaunchPaths(registration.launch) : ["No registered binary"];
+        report("Auto-start binary", invalid.length === 0, invalid.length ? invalid.join(", ") : "Registered Node binary and sessionmem entry point are readable", invalid.length ? "Reinstall sessionmem if needed, then run sessionmem autostart enable" : undefined);
+    }
+    catch (err) {
+        report("Auto-start registration", false, message(err), captureFix);
+        report("Auto-start binary", false, "Cannot inspect the registration", captureFix);
+    }
+    try {
+        report("Watcher capture", true, inspectWatchCheckpoint(dbPath));
+    }
+    catch (err) {
+        report("Watcher capture", false, message(err), captureFix);
+    }
+    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/commands/install.js

@@ -1,3 +1,4 @@
+import { createAutostart } from "../autostart/index.js";
 import { existsSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
@@ -87,6 +88,15 @@ export async function installCommand(options, contextOverrides) {
             console.log("✓ Claude Code: SessionStart, SessionEnd, PostToolUse hooks configured (~/.claude/settings.json)");
         }
     }
+    try {
+        createAutostart({ dbPath: dbPath }).enable();
+        console.log("Auto-start enabled and started; capture logs are in logs/watch.log beside the database");
+    }
+    catch (err) {
+        console.error(`Auto-start setup failed: ${err instanceof Error ? err.message : String(err)}`);
+        console.error("Fix the OS login service error, then run sessionmem autostart enable. Run sessionmem doctor to check capture.");
+        failed = true;
+    }
     if (failed)
         process.exit(1);
     console.log("✓ sessionmem ready — restart your editor/agent so it picks up the MCP server");

package/dist/cli/commands/uninstall.js

@@ -1,3 +1,4 @@
+import { createAutostart } from "../autostart/index.js";
 import { existsSync, rmSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
@@ -28,6 +29,9 @@ export async function uninstallCommand(options = {}) {
         console.error(err instanceof Error ? err.message : String(err));
         process.exit(1);
     }
+    // Stop capture before removing integrations or purging an open database.
+    createAutostart({ dbPath: options.dbPath }).disable();
+    console.log("Auto-start removed and watcher stopped");
     if (!adapter.uninstall) {
         console.error(`${adapter.name} does not support automated uninstall. Remove sessionmem from your MCP config manually.`);
         process.exit(1);

package/dist/cli/commands/watch.js

@@ -1,3 +1,5 @@
+import { openWatchLog } from "../watchLog.js";
+import { saveWatchCheckpoint } from "../watchCheckpoint.js";
 import { setTimeout } from "node:timers/promises";
 import { createCliContext } from "../context.js";
 import { printSweepSummary, sweepTranscripts } from "../transcriptSweep.js";
@@ -6,16 +8,20 @@ export async function watchCommand(options = {}, ctx) {
     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 closeLog = openWatchLog(options.logFile);
+    let context;
     const controller = new AbortController();
     const stop = () => controller.abort();
     process.once("SIGINT", stop);
     process.once("SIGTERM", stop);
     let firstSweep = true;
     try {
+        console.log(`sessionmem watch starting (pid ${process.pid}, interval ${interval}s)`);
+        context = ctx ?? createCliContext({ dbPath: options.dbPath });
         do {
             try {
                 const summary = await sweepTranscripts(context, options);
+                saveWatchCheckpoint(context, summary, interval);
                 if (firstSweep || options.once || summary.sessionsImported || summary.errors) {
                     printSweepSummary("watch", summary);
                 }
@@ -39,10 +45,16 @@ export async function watchCommand(options = {}, ctx) {
             }
         } while (!controller.signal.aborted);
     }
+    catch (error) {
+        console.error(`[sessionmem] watch failed: ${error instanceof Error ? error.stack ?? error.message : String(error)}`);
+        throw error;
+    }
     finally {
         process.removeListener("SIGINT", stop);
         process.removeListener("SIGTERM", stop);
         if (!ctx)
-            context.db.close();
+            context?.db.close();
+        console.log("sessionmem watch stopped");
+        closeLog();
     }
 }

package/dist/cli/index.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { autostartCommand } from "./commands/autostart.js";
 import { Command } from "commander";
 import { createRequire } from "node:module";
 import { runMcpServer } from "./commands/run.js";
@@ -60,29 +61,37 @@ 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("--db-path <path>", "Database file for headless capture")
+    .option("--log-file <path>", "Append timestamped stdout, stderr and startup failures to a file")
     .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 every detected agent host")
+    .description("Install integrations and enable login transcript capture")
     .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("autostart <action>")
+    .description("Control login capture: enable, disable, or status")
+    .action((action) => autostartCommand(action));
 program
     .command("doctor")
-    .description("Check the local store, schema, hooks, adapter wiring, and recall offline")
+    .description("Check login capture, storage, transcripts, 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")
+    .description("Stop login capture and remove sessionmem from the current MCP host")
     .option("--purge", "Also delete the local memories database")
     .option("--adapter <name>", "Force a host adapter instead of auto-detecting (claude-code, cursor, windsurf, cline, codex, antigravity, qcoder, generic)")
     .action((options) => uninstallCommand(options));

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