akm-cli 0.10.261013-beta → 0.10.261014-beta

package/dist/integrations/harnesses/opencode/runtime/tar.js

@@ -0,0 +1,107 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * One member of a gzip-compressed tar archive, streamed to a file. This is all
+ * akm needs of tar: the OpenCode binary is a single regular file of about 240 MB
+ * inside its package tarball, so it is never held in memory and no tar library
+ * is a dependency.
+ */
+import fs from "node:fs";
+import { pipeline } from "node:stream";
+import zlib from "node:zlib";
+const BLOCK_BYTES = 512;
+/** Exact reads from a stream of chunks. */
+class ByteReader {
+    #chunks;
+    #pending = Buffer.alloc(0);
+    constructor(source) {
+        this.#chunks = source[Symbol.asyncIterator]();
+    }
+    /** Up to `max` bytes, at least one unless the stream has ended (`undefined`). */
+    async read(max) {
+        if (this.#pending.length === 0) {
+            const next = await this.#chunks.next();
+            if (next.done)
+                return undefined;
+            this.#pending = next.value;
+        }
+        const taken = this.#pending.subarray(0, max);
+        this.#pending = this.#pending.subarray(taken.length);
+        return taken;
+    }
+    async exact(count) {
+        const parts = [];
+        for (let left = count; left > 0;) {
+            const part = await this.read(left);
+            if (!part)
+                throw new Error("the archive ends inside an entry");
+            parts.push(part);
+            left -= part.length;
+        }
+        return Buffer.concat(parts);
+    }
+    async skip(count) {
+        for (let left = count; left > 0;) {
+            const part = await this.read(left);
+            if (!part)
+                throw new Error("the archive ends inside an entry");
+            left -= part.length;
+        }
+    }
+}
+/** A header field of NUL-terminated text. */
+const field = (header, start, end) => {
+    const bytes = header.subarray(start, end);
+    const stop = bytes.indexOf(0);
+    return bytes.subarray(0, stop < 0 ? bytes.length : stop).toString("utf8");
+};
+/**
+ * Write the regular file `member` of the `.tgz` at `archive` to `destination` (mode 0755) and return its size. Entries
+ * are matched by the header's name field alone, which holds up to 100 bytes; a longer name, which tar keeps in the
+ * ustar prefix field or a PAX `path` record, is not read, so such a member is never found. The one member akm reads,
+ * `package/bin/opencode`, is short. Extended headers are skipped like any other entry that is not the member.
+ */
+export async function extractTarGzMember(archive, member, destination) {
+    const gunzip = zlib.createGunzip();
+    pipeline(fs.createReadStream(archive), gunzip, () => { });
+    const reader = new ByteReader(gunzip);
+    try {
+        return await extractFrom(reader, archive, member, destination);
+    }
+    finally {
+        // The rest of the archive is not read: close it now rather than when the stream is collected.
+        gunzip.destroy();
+    }
+}
+async function extractFrom(reader, archive, member, destination) {
+    for (;;) {
+        const header = await reader.exact(BLOCK_BYTES);
+        if (header.every((byte) => byte === 0))
+            throw new Error(`${archive} has no ${member}`);
+        const name = field(header, 0, 100).replace(/^\.\//, "");
+        const typeflag = String.fromCharCode(header[156] ?? 0);
+        const size = Number.parseInt(field(header, 124, 136).trim() || "0", 8);
+        if (!Number.isSafeInteger(size))
+            throw new Error(`${archive} is not a tar archive this reader understands`);
+        const padding = (BLOCK_BYTES - (size % BLOCK_BYTES)) % BLOCK_BYTES;
+        if (name !== member || (typeflag !== "0" && typeflag !== "\0")) {
+            await reader.skip(size + padding);
+            continue;
+        }
+        const out = await fs.promises.open(destination, "w", 0o755);
+        try {
+            for (let left = size; left > 0;) {
+                const part = await reader.read(left);
+                if (!part)
+                    throw new Error(`${archive} ends inside ${member}`);
+                await out.writeFile(part);
+                left -= part.length;
+            }
+        }
+        finally {
+            await out.close();
+        }
+        return size;
+    }
+}

package/dist/integrations/harnesses/opencode/session-log-v1.js

@@ -2,7 +2,16 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import { extractInlineRefMentions } from "../../session-logs/inline-refs.js";
-import { toMeta } from "./session-log-types.js";
+/** The metadata of a row, with a column that is absent or empty left out. */
+export function toMeta(r, sessionId) {
+    return {
+        sessionId,
+        startedAt: typeof r.time_created === "number" ? r.time_created : undefined,
+        endedAt: typeof r.time_updated === "number" ? r.time_updated : undefined,
+        projectHint: typeof r.directory === "string" && r.directory.length > 0 ? r.directory : undefined,
+        title: typeof r.title === "string" && r.title.length > 0 ? r.title : undefined,
+    };
+}
 /** Listing needs only `session`; reading a session needs `message` and `part`, and fails loudly without them. */
 export const V1_TABLES = ["session"];
 /** Every V1 session updated at or after `sinceMs`, newest first. Throws on an incompatible schema. */
@@ -12,18 +21,17 @@ export function listV1Sessions(db, sinceMs) {
         .all(sinceMs);
     return rows.map((r) => toMeta(r, r.id));
 }
-/** Whether a V1 `session` row exists for `sessionId`. */
-export function hasV1Session(db, sessionId) {
-    return db.prepare("SELECT id FROM session WHERE id = ?").get(sessionId) !== undefined;
-}
 /**
  * One event per message, text-parts concatenated in time order. Throws on an
- * incompatible schema; individual unparsable rows are skipped.
+ * incompatible schema or a session that is not in the file; individual unparsable
+ * rows are skipped.
  */
 export function readV1Session(db, harness, sessionId, filePath) {
     const meta = db
         .prepare("SELECT title, directory, time_created, time_updated FROM session WHERE id = ?")
         .get(sessionId);
+    if (!meta)
+        throw new Error(`session ${sessionId} is not in the file`);
     const messages = db
         .prepare("SELECT id, data, time_created FROM message WHERE session_id = ? ORDER BY time_created ASC, id ASC")
         .all(sessionId);
@@ -68,5 +76,5 @@ export function readV1Session(db, harness, sessionId, filePath) {
         inlineRefs.push(...extractInlineRefMentions(text, ts));
     }
     events.sort((a, b) => (a.ts ?? 0) - (b.ts ?? 0));
-    return { meta: meta ? toMeta(meta, sessionId) : { sessionId }, events, inlineRefs };
+    return { meta: toMeta(meta, sessionId), events, inlineRefs };
 }

package/dist/integrations/harnesses/opencode/session-log-v2.js

@@ -2,37 +2,25 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 /**
- * OpenCode 2 session-store adapter. V2 keeps one `session_v2` row per session
- * and the ordered conversation as `session_message` rows (`type` + JSON `data`
- * minus `id`/`type`, shapes from `@opencode/client` `SessionMessageInfo`).
- * Read-only: the database is never migrated; V1 rows a native upgrade copied
- * here arrive as the same shapes under the same session id.
+ * OpenCode 2 session store: the `session_v2` and `session_message` tables, read
+ * with SQLite only. Nothing here starts OpenCode (which would migrate the file
+ * and resume its suspended sessions); it reads the rows as they are.
  *
- * Mapping into the session-log contract follows the Codex reader: user and
- * assistant text become events of that role, a tool call becomes
- * `[tool:<name>] <input>` and its outcome a `tool` event
- * `[tool_result] <output>`, so the inline-ref scanner sees shell commands.
- * Reasoning, compaction, synthetic/system and bookkeeping messages are skipped.
+ * A message row is `(id, type, data)`; OpenCode decodes it as `{ ...data, id, type }`,
+ * which is rebuilt here. Only top-level sessions are read, and akm's own
+ * model-work sessions are left out: OpenCode 2 stores the agent a session ran as,
+ * and akm runs model work as one agent (`./agent-builder.ts`).
+ *
+ * Mapping to events follows the Codex reader: user and assistant text become events of
+ * that role, a tool call becomes `[tool:<name>] <input>` and its outcome a
+ * `tool` event `[tool_result] <output>`, so the inline-ref scanner sees shell
+ * commands. Reasoning, compaction, synthetic/system and bookkeeping messages
+ * are skipped.
  */
 import { asRecord, tryParseJson } from "../../../core/common.js";
-import { warnOnce } from "../../../core/warn.js";
 import { extractInlineRefMentions } from "../../session-logs/inline-refs.js";
-import { toMeta } from "./session-log-types.js";
-export const V2_TABLES = ["session_v2", "session_message"];
-/** Every V2 session updated at or after `sinceMs`, newest first. Throws on an incompatible schema. */
-export function listV2Sessions(db, sinceMs) {
-    const rows = db
-        .prepare("SELECT id, title, directory, time_created, time_updated FROM session_v2 WHERE time_updated >= ? ORDER BY time_updated DESC")
-        .all(sinceMs);
-    return rows.map((r) => toMeta(r, r.id));
-}
-/** Whether `sessionId` has a `session_v2` row, and how many `session_message` rows it owns. */
-export function v2SessionState(db, sessionId) {
-    const row = db
-        .prepare("SELECT (SELECT COUNT(*) FROM session_message WHERE session_id = s.id) AS n FROM session_v2 s WHERE s.id = ?")
-        .get(sessionId);
-    return row ? { exists: true, messages: row.n } : { exists: false, messages: 0 };
-}
+import { MODEL_WORK_AGENT } from "./agent-builder.js";
+import { toMeta } from "./session-log-v1.js";
 const asObject = asRecord;
 function asNumber(v) {
     return typeof v === "number" ? v : undefined;
@@ -69,17 +57,8 @@ function structuredErrorText(err) {
         return e.message;
     return typeof e?.type === "string" ? e.type : "error";
 }
-/**
- * Rebuild one session's events in `seq` order. Throws on an incompatible
- * schema; a message whose JSON cannot be read is skipped with one warning.
- */
-export function readV2Session(db, harness, sessionId, filePath) {
-    const meta = db
-        .prepare("SELECT title, directory, time_created, time_updated FROM session_v2 WHERE id = ?")
-        .get(sessionId);
-    const rows = db
-        .prepare("SELECT id, type, data, time_created FROM session_message WHERE session_id = ? ORDER BY seq ASC, time_created ASC, id ASC")
-        .all(sessionId);
+/** One session's events and inline refs, from its messages oldest first. A message that is not an object is skipped. */
+export function opencodeMessageEvents(messages, harness, sessionId, filePath) {
     const events = [];
     const inlineRefs = [];
     const push = (role, text, ts) => {
@@ -89,18 +68,16 @@ export function readV2Session(db, harness, sessionId, filePath) {
         events.push({ harness, text: trimmed, ts, sessionId, role, filePath });
         inlineRefs.push(...extractInlineRefMentions(trimmed, ts));
     };
-    for (const row of rows) {
-        const data = asObject(tryParseJson(row.data));
-        if (!data) {
-            warnOnce(`opencode-v2-message:${filePath}:${row.id}`, `OpenCode 2 history: skipped unreadable message ${row.id} in session ${sessionId} (${filePath}).`);
+    for (const message of messages) {
+        const data = asObject(message);
+        if (!data)
             continue;
-        }
-        const ts = asNumber(asObject(data.time)?.created) ?? asNumber(row.time_created);
-        if (row.type === "user") {
+        const ts = asNumber(asObject(data.time)?.created);
+        if (data.type === "user") {
             if (typeof data.text === "string")
                 push("user", data.text, ts);
         }
-        else if (row.type === "assistant") {
+        else if (data.type === "assistant") {
             const content = Array.isArray(data.content) ? data.content : [];
             const text = content
                 .map((c) => asObject(c))
@@ -128,7 +105,7 @@ export function readV2Session(db, harness, sessionId, filePath) {
                 }
             }
         }
-        else if (row.type === "shell") {
+        else if (data.type === "shell") {
             if (typeof data.command === "string")
                 push("assistant", `[tool:shell] ${data.command}`, ts);
             const out = asObject(data.output)?.output;
@@ -136,5 +113,52 @@ export function readV2Session(db, harness, sessionId, filePath) {
                 push("tool", `[tool_result] ${out}`, ts);
         }
     }
-    return { meta: meta ? toMeta(meta, sessionId) : { sessionId }, events, inlineRefs };
+    return { events, inlineRefs };
+}
+/** The columns of each table akm reads; a file lacking one is a schema akm does not support. */
+const V2_COLUMNS = {
+    session_v2: ["id", "parent_id", "title", "directory", "agent", "time_created", "time_updated"],
+    session_message: ["id", "session_id", "type", "seq", "data"],
+};
+/** Whether `db` has the OpenCode 2 session tables with the columns akm reads. */
+export function hasV2Tables(db) {
+    return Object.entries(V2_COLUMNS).every(([table, columns]) => {
+        const present = new Set(db
+            .prepare(`PRAGMA table_info(${table})`)
+            .all()
+            .map((c) => c.name));
+        return columns.every((column) => present.has(column));
+    });
+}
+/** Top-level sessions that are not akm's model work. */
+const AKM_USER_SESSIONS = `parent_id IS NULL AND (agent IS NULL OR agent != '${MODEL_WORK_AGENT}')`;
+/** Every top-level OpenCode 2 session updated at or after `sinceMs`, newest first. Throws on an incompatible schema. */
+export function listV2Sessions(db, sinceMs) {
+    return db
+        .prepare(`SELECT id, title, directory, time_created, time_updated FROM session_v2 WHERE ${AKM_USER_SESSIONS} AND time_updated >= ? ORDER BY time_updated DESC`)
+        .all(sinceMs)
+        .map((row) => toMeta(row, row.id));
+}
+/**
+ * The tokens one session's turns used: OpenCode records them on each assistant message and keeps their sums on the
+ * session row (equal, measured on 2.1.4). Undefined when the session is not in the file.
+ */
+export function v2SessionTokens(db, sessionId) {
+    const row = db
+        .prepare("SELECT tokens_input, tokens_output, tokens_reasoning FROM session_v2 WHERE id = ?")
+        .get(sessionId);
+    return row ? { input: row.tokens_input, output: row.tokens_output, reasoning: row.tokens_reasoning } : undefined;
+}
+/** One session's events, from its messages in order. Throws when the session is not in the file. */
+export function readV2Session(db, harness, sessionId, filePath) {
+    const row = db
+        .prepare("SELECT title, directory, time_created, time_updated FROM session_v2 WHERE id = ?")
+        .get(sessionId);
+    if (!row)
+        throw new Error(`session ${sessionId} is not in the file`);
+    const messages = db
+        .prepare("SELECT id, type, data FROM session_message WHERE session_id = ? ORDER BY seq ASC")
+        .all(sessionId)
+        .map((message) => ({ ...asRecord(tryParseJson(message.data)), id: message.id, type: message.type }));
+    return { meta: toMeta(row, sessionId), ...opencodeMessageEvents(messages, harness, sessionId, filePath) };
 }

package/dist/integrations/harnesses/opencode/session-log.js

@@ -2,167 +2,88 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
 import { toErrorMessage } from "../../../core/common.js";
 import { warnOnce } from "../../../core/warn.js";
 import { openDatabase } from "../../../storage/database.js";
 import { openSqliteReadSnapshot } from "../../../storage/sqlite-read-snapshot.js";
 import { AbstractSessionLogProvider } from "../../session-logs/provider-base.js";
-import { hasV1Session, listV1Sessions, readV1Session, V1_TABLES } from "./session-log-v1.js";
-import { listV2Sessions, readV2Session, V2_TABLES, v2SessionState } from "./session-log-v2.js";
-function getOpenCodeBaseDir() {
-    if (process.platform === "darwin") {
-        return path.join(os.homedir(), "Library", "Application Support", "opencode");
-    }
-    return path.join(os.homedir(), ".local", "share", "opencode");
-}
-/**
- * OpenCode session storage: one SQLite file, `<base>/opencode.db`, whose
- * layout decides the reader, never the installed binary or its version:
- *
- *   - V1: `session` table, with `message` / `part` for content (`session-log-v1.ts`).
- *   - V2: `session_v2` / `session_message` tables (`session-log-v2.ts`).
- *   - Both: a natively upgraded V1 file keeps its V1 tables and gains the V2
- *     ones. Sessions are merged by id, V2 winning, V1-only ones kept.
- *   - Neither: an unsupported layout, reported, never presented as empty.
- *
- * The file is opened read-only and never migrated or written.
- */
-/** Filename of opencode's SQLite session store, relative to its base dir. */
-const OPENCODE_DB_FILENAME = "opencode.db";
-function tableNames(db) {
+import { akmOpencodeDatabasePath, databaseIn, opencodeDatabasePath } from "./roots.js";
+import { listV1Sessions, readV1Session, V1_TABLES } from "./session-log-v1.js";
+import { hasV2Tables, listV2Sessions, readV2Session } from "./session-log-v2.js";
+function layoutOf(db) {
     const rows = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table'").all();
-    return new Set(rows.map((r) => r.name));
-}
-function classify(tables) {
-    const v1 = V1_TABLES.every((t) => tables.has(t));
-    const v2 = V2_TABLES.every((t) => tables.has(t));
-    return v1 || v2 ? { kind: "ok", v1, v2 } : { kind: "unsupported", tables: [...tables].sort() };
+    const tables = new Set(rows.map((r) => r.name));
+    if (tables.has("session_v2") && hasV2Tables(db))
+        return "v2";
+    return V1_TABLES.every((t) => tables.has(t)) && !tables.has("session_v2") ? "v1" : "unsupported";
 }
 export class OpenCodeProvider extends AbstractSessionLogProvider {
     name = "opencode";
-    #baseDir = getOpenCodeBaseDir();
+    #userDatabase = opencodeDatabasePath();
     availabilityRoot() {
-        return this.#dbPath(this.#baseDir);
+        return this.#userDatabase;
     }
-    /** Absolute path to opencode's SQLite store under `base`. */
-    #dbPath(base) {
-        return path.join(base, OPENCODE_DB_FILENAME);
+    /** The user's OpenCode history, or akm's own. */
+    isAvailable() {
+        return super.isAvailable() || fs.existsSync(akmOpencodeDatabasePath());
     }
-    /** Classify the store under `location` (default: opencode's data dir) without listing anything. */
-    inspectStore(location) {
-        const dbPath = this.#dbPath(location ?? this.#baseDir);
-        if (!fs.existsSync(dbPath))
-            return { kind: "missing" };
-        let db;
-        try {
-            db = openDatabase(dbPath, { readonly: true, create: false });
-        }
-        catch (error) {
-            return { kind: "unreadable", reason: toErrorMessage(error) };
-        }
-        try {
-            return classify(tableNames(db));
-        }
-        catch (error) {
-            return { kind: "unreadable", reason: toErrorMessage(error) };
-        }
-        finally {
-            db.close();
-        }
+    /** The stores to read: the one under `location`, else the user's and akm's. */
+    #stores(location) {
+        if (location)
+            return [databaseIn(location)];
+        return [this.#userDatabase, akmOpencodeDatabasePath()];
     }
-    listSessions(input = {}) {
-        const dbPath = this.#dbPath(input.location ?? this.#baseDir);
-        if (!fs.existsSync(dbPath))
-            return [];
-        let db;
-        try {
-            db = input.isolatedSnapshot
-                ? openSqliteReadSnapshot(dbPath)
-                : openDatabase(dbPath, { readonly: true, create: false });
-        }
-        catch (error) {
-            this.#warnUnavailable(dbPath, `cannot open it (${toErrorMessage(error)})`);
-            return [];
-        }
-        if (!db)
-            return [];
-        try {
-            const status = classify(tableNames(db));
-            if (status.kind !== "ok") {
-                this.#warnUnavailable(dbPath, `it has neither the OpenCode 1 (${V1_TABLES.join("/")}) nor the OpenCode 2 (${V2_TABLES.join("/")}) tables`);
-                return [];
+    async listSessions(input = {}) {
+        const sinceMs = input.sinceMs ?? 0;
+        const listed = [];
+        for (const dbPath of this.#stores(input.location)) {
+            if (!fs.existsSync(dbPath))
+                continue;
+            try {
+                listed.push(...this.#listStore(dbPath, sinceMs, input.isolatedSnapshot === true));
+            }
+            catch (error) {
+                this.#warnUnavailable(dbPath, `cannot list it (${toErrorMessage(error)})`);
             }
-            return this.#listFromDb(db, dbPath, input.sinceMs ?? 0, status.v1, status.v2);
-        }
-        catch (error) {
-            this.#warnUnavailable(dbPath, `cannot query it (${toErrorMessage(error)})`);
-            return [];
-        }
-        finally {
-            db.close();
         }
+        return listed.sort((a, b) => (b.endedAt ?? 0) - (a.endedAt ?? 0));
     }
-    readSession(ref) {
-        const emptyRef = this.sessionRef({ sessionId: ref.sessionId, filePath: ref.filePath });
-        const empty = { ref: emptyRef, events: [], inlineRefs: [] };
-        let db;
-        try {
-            db = openDatabase(ref.filePath, { readonly: true, create: false });
+    /** One session's events. A file or session that cannot be read throws, so the caller records the failure. */
+    async readSession(ref) {
+        const layout = this.#withDb(ref.filePath, false, layoutOf);
+        if (layout === "unsupported") {
+            throw new Error(`${ref.filePath} has no supported OpenCode 1 or OpenCode 2 session tables`);
         }
-        catch (error) {
-            this.#warnUnavailable(ref.filePath, `cannot open it (${toErrorMessage(error)})`);
-            return empty;
+        const read = this.#withDb(ref.filePath, false, (db) => layout === "v2"
+            ? readV2Session(db, this.name, ref.sessionId, ref.filePath)
+            : readV1Session(db, this.name, ref.sessionId, ref.filePath));
+        return {
+            ref: this.sessionRef({ ...read.meta, filePath: ref.filePath }),
+            events: read.events,
+            inlineRefs: read.inlineRefs,
+        };
+    }
+    #listStore(dbPath, sinceMs, isolated) {
+        const layout = this.#withDb(dbPath, isolated, layoutOf);
+        if (layout === "unsupported") {
+            this.#warnUnavailable(dbPath, `it has neither the OpenCode 1 (${V1_TABLES.join("/")}) nor the OpenCode 2 tables`);
+            return [];
         }
+        const metas = this.#withDb(dbPath, isolated, (db) => layout === "v2" ? listV2Sessions(db, sinceMs) : listV1Sessions(db, sinceMs));
+        return metas.map((meta) => this.sessionRef({ ...meta, filePath: dbPath }));
+    }
+    /** Run `use` on the SQLite file at `dbPath`, read-only (a private copy when `isolated`). */
+    #withDb(dbPath, isolated, use) {
+        const db = isolated ? openSqliteReadSnapshot(dbPath) : openDatabase(dbPath, { readonly: true, create: false });
+        if (!db)
+            throw new Error("the file disappeared");
         try {
-            const status = classify(tableNames(db));
-            if (status.kind !== "ok") {
-                this.#warnUnavailable(ref.filePath, "it has no supported OpenCode 1 or OpenCode 2 session tables");
-                return empty;
-            }
-            // V2 owns a session that has messages there; otherwise a retained V1 copy (a
-            // session the upgrade has not copied, or copied without messages) is the history.
-            const v2 = status.v2 ? v2SessionState(db, ref.sessionId) : { exists: false, messages: 0 };
-            const useV2 = v2.exists && (v2.messages > 0 || !status.v1 || !hasV1Session(db, ref.sessionId));
-            const read = useV2
-                ? readV2Session(db, this.name, ref.sessionId, ref.filePath)
-                : readV1Session(db, this.name, ref.sessionId, ref.filePath);
-            return {
-                ref: this.sessionRef({ ...read.meta, filePath: ref.filePath }),
-                events: read.events,
-                inlineRefs: read.inlineRefs,
-            };
-        }
-        catch (error) {
-            this.#warnUnavailable(ref.filePath, `cannot read session ${ref.sessionId} (${toErrorMessage(error)})`);
-            return empty;
+            return use(db);
         }
         finally {
             db.close();
         }
     }
-    /** List each present layout; one failing layout is reported and the other still listed. */
-    #listFromDb(db, dbPath, sinceMs, v1, v2) {
-        const merged = new Map();
-        const attempt = (label, list) => {
-            try {
-                for (const meta of list())
-                    if (!merged.has(meta.sessionId))
-                        merged.set(meta.sessionId, meta);
-            }
-            catch (error) {
-                this.#warnUnavailable(dbPath, `its ${label} session tables cannot be queried (${toErrorMessage(error)})`);
-            }
-        };
-        if (v2)
-            attempt("OpenCode 2", () => listV2Sessions(db, sinceMs));
-        if (v1)
-            attempt("OpenCode 1", () => listV1Sessions(db, sinceMs));
-        return [...merged.values()]
-            .sort((a, b) => (b.endedAt ?? 0) - (a.endedAt ?? 0))
-            .map((meta) => this.sessionRef({ ...meta, filePath: dbPath }));
-    }
     #warnUnavailable(dbPath, why) {
         warnOnce(`opencode-history:${dbPath}:${why}`, `OpenCode session history at ${dbPath} was not read: ${why}. This is an unsupported or damaged store, not an empty history.`);
     }