@openpond/evals 0.11.18 → 0.11.19

package/dist/native-conversations/history.js

@@ -0,0 +1,298 @@
+import { open, lstat, readdir, readFile, realpath, stat, } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { zstdDecompressSync } from "node:zlib";
+import { previewAgentImport } from "../connected-evidence/imports.js";
+import { connectedJsonLines, object } from "../connected-evidence/normalize.js";
+import { claudeGraph } from "../connected-evidence/sources/claude-branches.js";
+import { contentHash } from "@openpond/harness";
+import { listDatabaseSessions, readDatabaseSession } from "./database.js";
+import { NATIVE_READ_LIMIT, } from "./contracts.js";
+async function selectedPath(source, path, boundSize = true) {
+    const root = await realpath(source.root), target = await realpath(resolve(root, path));
+    const child = relative(root, target);
+    if (child.startsWith(`..${sep}`) || child === ".." || isAbsolute(child))
+        throw new Error("History path is outside the selected source.");
+    if (boundSize && (await stat(target)).size > NATIVE_READ_LIMIT)
+        throw new Error("Source file exceeds 32 MiB.");
+    return target;
+}
+async function readSelectedFile(source, path) {
+    const target = await selectedPath(source, path), bytes = await readFile(target);
+    if (bytes.byteLength > NATIVE_READ_LIMIT)
+        throw new Error("Source changed beyond the retained limit.");
+    const decoded = target.endsWith(".zst")
+        ? zstdDecompressSync(bytes, { maxOutputLength: 64 * 1024 * 1024 })
+        : bytes;
+    const text = new TextDecoder("utf-8", { fatal: true }).decode(decoded);
+    // A writer may be appending its last line. Only complete JSONL records enter snapshots.
+    if (target.endsWith(".jsonl") && text && !text.endsWith("\n")) {
+        const last = text.lastIndexOf("\n");
+        try {
+            JSON.parse(text.slice(last + 1));
+        }
+        catch {
+            return text.slice(0, last + 1);
+        }
+    }
+    return text;
+}
+async function pathsBelow(source) {
+    if ((await lstat(source.root)).isFile())
+        return [""];
+    const roots = source.source === "codex"
+        ? ["sessions", "archived_sessions"]
+        : source.source === "grok_build"
+            ? ["sessions"]
+            : source.source === "claude_code"
+                ? ["projects"]
+                : source.source === "pi" || source.source === "oh_my_pi"
+                    ? ["sessions"]
+                    : [""];
+    const paths = [];
+    async function walk(directory, depth) {
+        if (depth > 12)
+            throw new Error("Selected history exceeds directory depth limit.");
+        let entries;
+        try {
+            entries = await readdir(join(source.root, directory), {
+                withFileTypes: true,
+            });
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return;
+            throw error;
+        }
+        for (const entry of entries) {
+            const path = join(directory, entry.name);
+            if (entry.isSymbolicLink())
+                continue;
+            if (entry.isDirectory())
+                await walk(path, depth + 1);
+            else if (entry.isFile() &&
+                (source.source === "openclaw"
+                    ? entry.name === "manifest.json"
+                    : source.source === "grok_build"
+                        ? entry.name === "updates.jsonl"
+                        : /\.jsonl(?:\.zst)?$/u.test(entry.name)))
+                paths.push(path);
+            if (paths.length > 10000)
+                throw new Error("Select a narrower source directory (more than 10,000 history files).");
+        }
+    }
+    for (const root of roots)
+        await walk(root, 0);
+    // Explicit export directories need not mimic the application's home layout.
+    if (!paths.length && roots[0] !== "")
+        await walk("", 0);
+    return paths.sort();
+}
+function sessionFileJson(source, path) {
+    return (path || source.root).endsWith(".json");
+}
+export async function listSessions(source, input = {}) {
+    if (!source.available || !source.capabilities.history)
+        throw new Error(source.reason ?? "Native history is unavailable.");
+    const limit = input.limit ?? 50;
+    if (!Number.isInteger(limit) ||
+        limit < 1 ||
+        limit > 100 ||
+        (input.since && !Number.isFinite(Date.parse(input.since))))
+        throw new Error("Invalid history page or date range.");
+    if (source.acquisition === "sqlite")
+        return listDatabaseSessions(source, { ...input, limit });
+    const paths = await pathsBelow(source), candidates = [];
+    for (const path of paths) {
+        if (input.cursor && path <= input.cursor)
+            continue;
+        try {
+            const modified = await stat(join(source.root, path));
+            if (input.since && modified.mtimeMs < Date.parse(input.since))
+                continue;
+            let text;
+            if (source.acquisition !== "bundle" &&
+                !sessionFileJson(source, path) &&
+                source.source !== "hermes" &&
+                !(path || source.root).endsWith(".zst")) {
+                const handle = await open(await selectedPath(source, path, false), "r");
+                try {
+                    const buffer = Buffer.alloc(256 * 1024), read = await handle.read(buffer, 0, buffer.length, 0);
+                    const prefix = buffer.subarray(0, read.bytesRead).toString("utf8"), end = prefix.lastIndexOf("\n");
+                    text = prefix;
+                    if (!prefix.endsWith("\n")) {
+                        try {
+                            JSON.parse(prefix.slice(end + 1));
+                        }
+                        catch {
+                            text = prefix.slice(0, end + 1);
+                        }
+                    }
+                }
+                finally {
+                    await handle.close();
+                }
+            }
+            else
+                text = await readSelectedFile(source, path);
+            const rows = source.acquisition === "bundle" || sessionFileJson(source, path)
+                ? [object(JSON.parse(text))]
+                : text
+                    .split(/\r?\n/u)
+                    .filter(Boolean)
+                    .slice(0, source.source === "claude_code" ? undefined : 12)
+                    .map((line) => object(JSON.parse(line)));
+            const header = rows.find((row) => row.type === "session" || row.type === "session_meta") ??
+                rows[0] ??
+                {};
+            const payload = header.type === "session_meta"
+                ? object(header.payload)
+                : source.source === "grok_build"
+                    ? object(header.params)
+                    : source.source === "opencode"
+                        ? object(header.info)
+                        : header;
+            const id = typeof payload.id === "string"
+                ? payload.id
+                : typeof payload.sessionId === "string"
+                    ? payload.sessionId
+                    : basename(path).replace(/\.jsonl(?:\.zst)?$/u, "");
+            // Claude writes queue/history bookkeeping before its first message. The
+            // native session's message metadata owns cwd; encoded project-directory
+            // names are ambiguous and must never be decoded into a guessed path.
+            const claudeMessage = source.source === "claude_code"
+                ? rows.find((row) => row.sessionId === id && row.type === "user" && typeof row.cwd === "string" && isAbsolute(row.cwd))
+                : undefined;
+            let cwd = claudeMessage?.cwd ?? payload.cwd;
+            let title = id;
+            if (source.source === "grok_build" && path.endsWith("updates.jsonl")) {
+                try {
+                    const summary = object(JSON.parse(await readSelectedFile(source, join(dirname(path), "summary.json"))));
+                    const info = object(summary.info);
+                    if (info.id === id) {
+                        cwd = info.cwd;
+                        if (typeof summary.generated_title === "string")
+                            title = summary.generated_title.slice(0, 500);
+                    }
+                }
+                catch { /* Missing/unreadable metadata leaves history readable without native resume. */ }
+            }
+            candidates.push({
+                nativeSessionId: id,
+                sourceInstanceId: source.instanceId,
+                path,
+                title,
+                cwd: typeof cwd === "string" && isAbsolute(cwd) ? cwd : null,
+                updatedAt: modified.mtime.toISOString(),
+                storageRevision: [
+                    modified.dev,
+                    modified.ino,
+                    modified.size,
+                    modified.mtimeMs,
+                    modified.ctimeMs,
+                ].join(":"),
+            });
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                continue;
+            candidates.push({
+                nativeSessionId: basename(path || source.root),
+                sourceInstanceId: source.instanceId,
+                path,
+                title: basename(path || source.root),
+                cwd: null,
+                updatedAt: new Date(0).toISOString(),
+                issue: error instanceof Error
+                    ? error.message
+                    : "Unable to inspect native session",
+            });
+        }
+        if (candidates.length > limit)
+            break;
+    }
+    return {
+        items: candidates.slice(0, limit),
+        nextCursor: candidates.length > limit ? candidates[limit - 1].path : null,
+    };
+}
+export async function inspectSessionBranches(source, session) {
+    if (source.source !== "claude_code")
+        return { revision: "", branches: [] };
+    if (session.issue)
+        throw new Error(session.issue);
+    if (session.sourceInstanceId !== source.instanceId)
+        throw new Error("Native session belongs to another selected source.");
+    const text = await readSelectedFile(source, session.path);
+    const graph = claudeGraph(connectedJsonLines({ path: basename(session.path), text }));
+    if (graph.sessionId !== session.nativeSessionId)
+        throw new Error("Native session changed identity.");
+    return { revision: contentHash(text), branches: graph.branches() };
+}
+export async function readSession(source, session, input = {}) {
+    if (session.issue)
+        throw new Error(session.issue);
+    if (session.sourceInstanceId !== source.instanceId)
+        throw new Error("Native session belongs to another selected source.");
+    let files;
+    if (source.acquisition === "sqlite")
+        files = [readDatabaseSession(source, session.nativeSessionId)];
+    else if (source.acquisition === "bundle") {
+        const directory = session.path.slice(0, -"manifest.json".length);
+        files = await Promise.all(["manifest.json", "events.jsonl", "session-branch.json"].map(async (path) => ({
+            path,
+            text: await readSelectedFile(source, `${directory}${path}`),
+        })));
+    }
+    else
+        files = [
+            {
+                path: basename(session.path || source.root).replace(/\.zst$/u, ""),
+                text: await readSelectedFile(source, session.path),
+            },
+        ];
+    if (input.expectedBranchRevision && !input.branchLeafId)
+        throw new Error("Choose a branch before supplying its revision.");
+    if (source.source === "claude_code") {
+        const file = files[0];
+        const graph = claudeGraph(connectedJsonLines(file));
+        if (graph.sessionId !== session.nativeSessionId)
+            throw new Error("Native session changed identity.");
+        if (input.branchAnchor) {
+            if (input.branchLeafId || input.expectedBranchRevision)
+                throw new Error("Choose either a frozen branch snapshot or a followed branch anchor.");
+            const anchor = graph.select(input.branchAnchor.leafId);
+            if (anchor.chainHash !== input.branchAnchor.chainHash)
+                throw new Error("The selected branch history changed. Review and select it again before syncing.");
+            const descendants = graph.leaves.filter(leaf => graph.select(leaf.uuid).chain.some(row => row.uuid === input.branchAnchor.leafId));
+            if (descendants.length !== 1)
+                throw new Error("The selected branch diverged. Pause this connection and choose its branch again.");
+            input = { ...input, branchLeafId: descendants[0].uuid };
+        }
+        if (input.expectedBranchRevision && contentHash(file.text) !== input.expectedBranchRevision)
+            throw new Error("This conversation changed. Refresh its branches and choose again.");
+        if (input.branchLeafId) {
+            if (!graph.leaves.some(leaf => leaf.uuid === input.branchLeafId))
+                throw new Error("The selected Claude branch is no longer a leaf. Refresh and choose again.");
+            // Selected-branch consent never uploads sibling transcript rows. The
+            // retained native file is unchanged; admission receives only this chain.
+            files = [{ ...file, text: graph.select(input.branchLeafId).chain.map(row => JSON.stringify(row)).join("\n") + "\n" }];
+        }
+    }
+    else if (input.expectedBranchRevision || input.branchAnchor)
+        throw new Error("Branch revision selection is only supported for Claude Code.");
+    const preview = previewAgentImport({
+        source: source.source,
+        files,
+        acquisition: {
+            machineId: source.machineId,
+            sourceInstanceId: source.instanceId,
+        },
+        ...input,
+    });
+    if (preview.issues.length)
+        throw new Error(preview.issues.map((issue) => issue.message).join("; "));
+    if (source.acquisition === "sqlite" &&
+        preview.sessions.some((item) => item.sessionId !== session.nativeSessionId))
+        throw new Error("Native session changed identity.");
+    return { files, preview, branchLeafId: input.branchLeafId };
+}

package/dist/native-conversations/index.js

@@ -0,0 +1,11 @@
+/** Node-only retained native history and independently supervised sync service. */
+export * from "./contracts.js";
+export * from "./discovery.js";
+export * from "./history.js";
+export * from "./collector-contracts.js";
+export * from "./collector-store.js";
+export * from "./collector.js";
+export * from "./supervisor.js";
+export * from "./location.js";
+export * from "./collector-branches.js";
+export * from "./collector-destinations.js";

package/dist/native-conversations/location.js

@@ -0,0 +1,29 @@
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { randomUUID } from "node:crypto";
+import { mkdir, open, readFile } from "node:fs/promises";
+export function collectorDirectory(home = process.env.OPENPOND_HOME || join(homedir(), ".openpond")) {
+    return resolve(home, "conversation-importer");
+}
+export async function collectorMachineId(directory = collectorDirectory()) {
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    const file = join(directory, "machine-id");
+    try {
+        const handle = await open(file, "wx", 0o600);
+        try {
+            await handle.writeFile(randomUUID());
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch (error) {
+        if (error.code !== "EEXIST")
+            throw error;
+    }
+    const id = (await readFile(file, "utf8")).trim();
+    if (!/^[a-f0-9-]{36}$/u.test(id))
+        throw new Error("Collector machine identity is invalid; restore its retained state.");
+    return id;
+}

package/dist/native-conversations/openclaw-cold-archive.js

@@ -0,0 +1,91 @@
+import { createHash } from "node:crypto";
+import { readFileSync, realpathSync, statSync } from "node:fs";
+import { basename, dirname, join, relative, sep } from "node:path";
+import { zstdDecompressSync } from "node:zlib";
+import { NATIVE_READ_LIMIT } from "./contracts.js";
+/** Read the native cold-storage envelope without restoring or modifying its database. */
+export function readOpenClawColdArchive(database, source, sessionId) {
+    const metadata = database
+        .prepare("SELECT generation,archive_name,archive_sha256,event_count,raw_bytes,archive_bytes,last_seq,storage,length(archive_blob) AS blob_bytes FROM session_transcript_cold_archives WHERE session_id=?")
+        .get(sessionId);
+    if (!metadata)
+        return null;
+    if (Number(metadata.archive_bytes) > NATIVE_READ_LIMIT ||
+        Number(metadata.raw_bytes) > NATIVE_READ_LIMIT ||
+        Number(metadata.event_count) > 100000)
+        throw new Error("OpenClaw cold archive exceeds the retained size limit.");
+    let bytes;
+    if (metadata.storage === "sqlite") {
+        if (Number(metadata.blob_bytes) !== Number(metadata.archive_bytes))
+            throw new Error("OpenClaw cold archive size differs from its receipt.");
+        const row = database
+            .prepare("SELECT archive_blob FROM session_transcript_cold_archives WHERE session_id=?")
+            .get(sessionId);
+        if (!(row.archive_blob instanceof Uint8Array))
+            throw new Error("OpenClaw cold archive is unavailable.");
+        bytes = row.archive_blob;
+    }
+    else if (metadata.storage === "file") {
+        const name = String(metadata.archive_name);
+        if (!/^[a-f0-9]{64}\.jsonl\.zst$/.test(name))
+            throw new Error("Invalid OpenClaw cold archive name.");
+        const storeDirectory = dirname(source.root);
+        const artifactDirectory = basename(storeDirectory) === "agent"
+            ? join(dirname(storeDirectory), "sessions")
+            : storeDirectory;
+        const allowed = realpathSync(artifactDirectory);
+        const path = realpathSync(join(artifactDirectory, "cold", name));
+        const within = relative(allowed, path);
+        if (within === ".." ||
+            within.startsWith(`..${sep}`) ||
+            within.startsWith(sep))
+            throw new Error("OpenClaw cold archive leaves the selected agent directory.");
+        const stat = statSync(path);
+        if (!stat.isFile() || stat.size !== Number(metadata.archive_bytes))
+            throw new Error("OpenClaw cold archive size differs from its receipt.");
+        bytes = readFileSync(path);
+    }
+    else
+        throw new Error("Unsupported OpenClaw cold archive storage.");
+    if (bytes.length !== Number(metadata.archive_bytes) ||
+        createHash("sha256").update(bytes).digest("hex") !== metadata.archive_sha256)
+        throw new Error("OpenClaw cold archive checksum differs from its receipt.");
+    const decoded = zstdDecompressSync(bytes, {
+        maxOutputLength: NATIVE_READ_LIMIT,
+    });
+    const lines = new TextDecoder("utf8", { fatal: true })
+        .decode(decoded)
+        .trimEnd()
+        .split("\n");
+    const header = JSON.parse(lines.shift() ?? "null");
+    if (header?.kind !== "header" ||
+        header.version !== 1 ||
+        header.sessionId !== sessionId ||
+        header.generation !== metadata.generation)
+        throw new Error("OpenClaw cold archive identity differs from its receipt.");
+    const events = [];
+    let lastSequence = -1;
+    let rawBytes = 0;
+    for (const line of lines) {
+        const record = JSON.parse(line);
+        if (!["event", "identity", "active", "index", "fts"].includes(record?.kind))
+            throw new Error("Unsupported OpenClaw cold archive record.");
+        if (record.kind !== "event")
+            continue;
+        if (!Number.isSafeInteger(record.row?.seq) ||
+            record.row.seq <= lastSequence ||
+            typeof record.row.event_json !== "string")
+            throw new Error("Invalid OpenClaw cold archive event sequence.");
+        lastSequence = record.row.seq;
+        rawBytes += Buffer.byteLength(record.row.event_json);
+        events.push(record.row.event_json);
+    }
+    if (events.length !== Number(metadata.event_count) ||
+        lastSequence !== Number(metadata.last_seq) ||
+        rawBytes + events.length - 1 !== Number(metadata.raw_bytes))
+        throw new Error("OpenClaw cold archive contents differ from its receipt.");
+    const nativeHeader = JSON.parse(events[0] ?? "null");
+    if (nativeHeader?.type !== "session" || nativeHeader.id !== sessionId)
+        throw new Error("OpenClaw transcript identity differs from selected session.");
+    return { path: `${sessionId}.jsonl`, text: events.join("\n") + "\n" };
+}

package/dist/native-conversations/openclaw-database.js

@@ -0,0 +1,130 @@
+import { DatabaseSync } from "node:sqlite";
+import { zstdDecompressSync } from "node:zlib";
+import { createHash } from "node:crypto";
+import { readOpenClawColdArchive } from "./openclaw-cold-archive.js";
+import { NATIVE_READ_LIMIT, } from "./contracts.js";
+function open(source) {
+    const database = new DatabaseSync(source.root, {
+        readOnly: true,
+        allowExtension: false,
+        enableDoubleQuotedStringLiterals: false,
+    });
+    database.exec("PRAGMA query_only=ON; PRAGMA busy_timeout=1000; BEGIN");
+    return database;
+}
+function has(database, table) {
+    return !!database
+        .prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name=?")
+        .get(table);
+}
+export function listOpenClawSessions(source, input) {
+    const database = open(source);
+    try {
+        // Every hot transcript retains a native session header, including prior reset windows.
+        const archiveUnion = has(database, "session_transcript_archives")
+            ? "UNION ALL SELECT session_id AS id,created_at AS updated,archive_sha256 AS revision FROM session_transcript_archives"
+            : "";
+        const coldUnion = has(database, "session_transcript_cold_archives")
+            ? "UNION ALL SELECT session_id AS id,archived_at AS updated,archive_sha256 AS revision FROM session_transcript_cold_archives"
+            : "";
+        const rows = database
+            .prepare(`SELECT id,MAX(updated) AS updated,MAX(revision) AS revision FROM (
+      SELECT session_id AS id,MAX(created_at) AS updated,CAST(MAX(seq) AS TEXT) AS revision FROM transcript_events GROUP BY session_id
+      ${archiveUnion} ${coldUnion}) WHERE id > ? GROUP BY id ORDER BY id LIMIT ?`)
+            .all(input.cursor ?? "", input.limit + 1);
+        const items = rows.slice(0, input.limit).map((row) => ({
+            nativeSessionId: String(row.id),
+            sourceInstanceId: source.instanceId,
+            path: String(row.id),
+            title: String(row.id),
+            cwd: null,
+            updatedAt: new Date(Number(row.updated) || 0).toISOString(),
+        }));
+        return {
+            items,
+            nextCursor: rows.length > input.limit ? items.at(-1).nativeSessionId : null,
+        };
+    }
+    finally {
+        database.close();
+    }
+}
+export function readOpenClawSession(source, sessionId) {
+    const database = open(source);
+    try {
+        if (has(database, "session_transcript_cold_archives")) {
+            const cold = readOpenClawColdArchive(database, source, sessionId);
+            if (cold)
+                return cold;
+        }
+        const hasHot = database
+            .prepare("SELECT 1 FROM transcript_events WHERE session_id=? LIMIT 1")
+            .get(sessionId);
+        if (!hasHot) {
+            if (!has(database, "session_transcript_archives"))
+                throw new Error("OpenClaw archive is unavailable.");
+            const metadata = database
+                .prepare("SELECT archive_name,length(archive_blob) AS bytes FROM session_transcript_archives WHERE session_id=? ORDER BY created_at DESC LIMIT 1")
+                .get(sessionId);
+            if (!metadata || Number(metadata.bytes) > NATIVE_READ_LIMIT)
+                throw new Error("OpenClaw archive is missing or exceeds the retained byte limit.");
+            const archive = database
+                .prepare("SELECT archive_blob,archive_sha256,encoding FROM session_transcript_archives WHERE archive_name=? AND session_id=?")
+                .get(String(metadata.archive_name), sessionId);
+            if (!(archive.archive_blob instanceof Uint8Array) ||
+                createHash("sha256").update(archive.archive_blob).digest("hex") !==
+                    archive.archive_sha256)
+                throw new Error("OpenClaw archive checksum differs from its retained receipt.");
+            if (archive.encoding !== "zstd" && archive.encoding !== "identity")
+                throw new Error("Unsupported OpenClaw archive encoding.");
+            const bytes = archive.encoding === "zstd"
+                ? zstdDecompressSync(archive.archive_blob, {
+                    maxOutputLength: NATIVE_READ_LIMIT,
+                })
+                : archive.archive_blob;
+            const text = new TextDecoder("utf8", { fatal: true }).decode(bytes);
+            const header = JSON.parse(text.split("\n", 1)[0]);
+            if (header.type !== "session" || header.id !== sessionId)
+                throw new Error("OpenClaw archive identity differs from selected session.");
+            return { path: `${sessionId}.jsonl`, text };
+        }
+        const total = database
+            .prepare("SELECT COUNT(*) AS n,SUM(COALESCE(event_utf8_bytes,length(CAST(event_json AS BLOB)),0)) AS bytes FROM transcript_events WHERE session_id=?")
+            .get(sessionId);
+        if (Number(total.n) > 100000 || Number(total.bytes) > NATIVE_READ_LIMIT)
+            throw new Error("OpenClaw transcript exceeds the retained size limit.");
+        const rows = database
+            .prepare("SELECT seq,event_json,event_zstd,event_utf8_bytes FROM transcript_events WHERE session_id=? ORDER BY seq LIMIT 100001")
+            .all(sessionId);
+        let bytes = 0;
+        const lines = rows.map((row) => {
+            let text;
+            if (typeof row.event_json === "string")
+                text = row.event_json;
+            else {
+                if (!(row.event_zstd instanceof Uint8Array) ||
+                    Number(row.event_utf8_bytes) > NATIVE_READ_LIMIT)
+                    throw new Error("Unsupported OpenClaw compressed transcript record.");
+                const decoded = zstdDecompressSync(row.event_zstd, {
+                    maxOutputLength: NATIVE_READ_LIMIT,
+                });
+                if (decoded.length !== Number(row.event_utf8_bytes))
+                    throw new Error("OpenClaw compressed transcript size differs from its receipt.");
+                text = new TextDecoder("utf8", { fatal: true }).decode(decoded);
+            }
+            bytes += Buffer.byteLength(text);
+            if (bytes > NATIVE_READ_LIMIT)
+                throw new Error("OpenClaw transcript exceeds retained size limit.");
+            return text;
+        });
+        if (!lines.length)
+            throw new Error("OpenClaw transcript is unavailable.");
+        const header = JSON.parse(lines[0]);
+        if (header.type !== "session" || header.id !== sessionId)
+            throw new Error("OpenClaw transcript identity differs from selected session.");
+        return { path: `${sessionId}.jsonl`, text: lines.join("\n") + "\n" };
+    }
+    finally {
+        database.close();
+    }
+}