om-memory-system 3.2.0-next.11 → 3.2.0-next.12

package/dist/importer/import-sources.js

@@ -0,0 +1,147 @@
+import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
+import { closeSync, existsSync, openSync, readdirSync, readSync, realpathSync, statSync, } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join } from "node:path";
+import { DEFAULT_PI_SESSION_ROOT, readPiSessionHeader } from "./discovery.js";
+import { DEFAULT_OPENCODE_DB } from "./opencode-reader.js";
+export class ImportSourceError extends Error {
+    status;
+    constructor(message, status = 400) {
+        super(message);
+        this.status = status;
+        this.name = "ImportSourceError";
+    }
+}
+// Tokens only need to outlive the server process that issued them.
+const TOKEN_KEY = randomBytes(32);
+function sign(payload) {
+    return createHmac("sha256", TOKEN_KEY).update(payload).digest("base64url");
+}
+export function signImportSource(identity) {
+    const payload = Buffer.from(JSON.stringify(identity)).toString("base64url");
+    return `${payload}.${sign(payload)}`;
+}
+export function readImportSourceToken(token, host) {
+    if (typeof token !== "string")
+        throw new ImportSourceError("Choose a history source");
+    const [payload = "", signature = ""] = token.split(".");
+    const expected = Buffer.from(sign(payload));
+    const actual = Buffer.from(signature);
+    if (expected.length !== actual.length || !timingSafeEqual(expected, actual)) {
+        throw new ImportSourceError("The history source is no longer valid. Choose it again.");
+    }
+    const identity = JSON.parse(Buffer.from(payload, "base64url").toString());
+    if (identity.host !== host)
+        throw new ImportSourceError("The source belongs to the other host");
+    return identity;
+}
+/** Stable key for sharing snapshots and computing revisions. */
+export function importSourceKey(identity) {
+    return `${identity.realPath}:${identity.dev}:${identity.ino}`;
+}
+/** Refuse a source whose path now names another file, such as a swapped-in symlink. */
+export function assertImportSourceUnchanged(identity) {
+    let current;
+    try {
+        current = statSync(identity.realPath);
+    }
+    catch {
+        throw new ImportSourceError("The history source no longer exists. Choose it again.", 409);
+    }
+    if (current.dev !== identity.dev || current.ino !== identity.ino) {
+        throw new ImportSourceError("The history source changed. Choose it again.", 409);
+    }
+}
+function checkedPath(path) {
+    if (typeof path !== "string" || !path.trim())
+        throw new ImportSourceError("Enter a path");
+    if (!isAbsolute(path))
+        throw new ImportSourceError("Enter an absolute path");
+    if (path.split(/[\\/]/).includes("..")) {
+        throw new ImportSourceError("The path must not contain '..' segments");
+    }
+    try {
+        // Symlinks at or above the chosen path are fine: macOS /tmp, a linked ~/.pi.
+        return realpathSync.native(path);
+    }
+    catch {
+        throw new ImportSourceError("Path not found");
+    }
+}
+function isSqliteFile(path) {
+    const fd = openSync(path, "r");
+    try {
+        const buffer = Buffer.alloc(16);
+        readSync(fd, buffer, 0, 16, 0);
+        return buffer.toString("latin1") === "SQLite format 3\0";
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+export function defaultImportSourcePath(host) {
+    return host === "pi" ? DEFAULT_PI_SESSION_ROOT : DEFAULT_OPENCODE_DB;
+}
+/** Check an absolute path's kind and format; never returns file contents. */
+export function validateImportSource(host, path) {
+    const realPath = checkedPath(path);
+    const info = statSync(realPath);
+    let kind;
+    if (host === "pi") {
+        if (info.isDirectory())
+            kind = "pi-folder";
+        else if (info.isFile() && realPath.endsWith(".jsonl")) {
+            if ("reason" in readPiSessionHeader(realPath, "")) {
+                throw new ImportSourceError("The file is not a Pi session file");
+            }
+            kind = "pi-file";
+        }
+        else
+            throw new ImportSourceError("Choose a Pi sessions folder or one .jsonl session file");
+    }
+    else {
+        if (!info.isFile() || !isSqliteFile(realPath)) {
+            throw new ImportSourceError("Choose an OpenCode database file");
+        }
+        kind = "opencode-db";
+    }
+    const identity = { host, kind, realPath, dev: info.dev, ino: info.ino };
+    return { kind, displayPath: realPath, sourceToken: signImportSource(identity) };
+}
+const BROWSE_LIMIT = 500;
+/**
+ * One folder at a time, with no recursion: subfolders and files the host can
+ * import. Symlinked entries are hidden. Only offered on loopback binds.
+ */
+export function browseImportSources(host, path) {
+    let start = path;
+    if (start === undefined || start === null || start === "") {
+        const preferred = host === "pi" ? DEFAULT_PI_SESSION_ROOT : dirname(DEFAULT_OPENCODE_DB);
+        start = existsSync(preferred) ? preferred : homedir();
+    }
+    const folder = checkedPath(start);
+    if (!statSync(folder).isDirectory())
+        throw new ImportSourceError("Choose a folder to browse");
+    const entries = [];
+    for (const entry of readdirSync(folder, { withFileTypes: true })) {
+        if (entry.isSymbolicLink())
+            continue;
+        const full = join(folder, entry.name);
+        if (entry.isDirectory())
+            entries.push({ name: entry.name, path: full, kind: "folder" });
+        else if (entry.isFile() && host === "pi" && entry.name.endsWith(".jsonl")) {
+            entries.push({ name: entry.name, path: full, kind: "pi-file" });
+        }
+        else if (entry.isFile() && host === "opencode" && entry.name.endsWith(".db")) {
+            entries.push({ name: entry.name, path: full, kind: "opencode-db" });
+        }
+    }
+    entries.sort((a, b) => Number(b.kind === "folder") - Number(a.kind === "folder") || a.name.localeCompare(b.name));
+    const parent = dirname(folder);
+    return {
+        path: folder,
+        parent: parent === folder ? null : parent,
+        entries: entries.slice(0, BROWSE_LIMIT),
+        truncated: entries.length > BROWSE_LIMIT,
+    };
+}

package/dist/importer/importer.d.ts

@@ -29,6 +29,13 @@ export interface ImportFilters {
     skipMemories?: boolean;
     pathMaps?: ImportPathMap[];
     root?: string;
+    /**
+     * Web selection: only these discovery keys (paths relative to `root`).
+     * Never combined with `session` or `maxSessions`.
+     */
+    selectionKeys?: string[];
+    /** Web selection: user turns after this epoch ms are held back for a later run. */
+    cutoff?: number;
 }
 export type ImportUnitStatus = "imported" | "would-import" | "skipped" | "failed" | "already-handled";
 export interface ImportUnitReport {
@@ -72,11 +79,16 @@ export interface ImportReport {
     projects: ImportProjectReport[];
     units: ImportUnitReport[];
     profile?: ProfileImportReport;
+    /** Turns newer than the web listing time, left for a later run. */
+    unitsHeldBack?: number;
+    /** Turns without a timestamp; date limits cannot exclude them. */
+    unitsUntimed?: number;
 }
 export interface ImporterDeps {
     loadSession: (file: string) => LoadedPiSession;
     provider: CaptureSummaryProvider;
     onProgress?: (processed: number, total: number, promptPreview: string) => void;
+    signal?: AbortSignal;
     ledger?: PiImportLedger;
     profile?: {
         model?: ModelPort;
@@ -106,6 +118,24 @@ export declare function findMemoryIdByImportId(projectHash: string, importId: st
  * /private/var) name one project, so compare through the real path.
  */
 export declare function projectFilterTag(directory: string): string;
+/**
+ * Keep the windows a run would import: inside the date range and not newer
+ * than the web listing cutoff. Held-back windows are only counted; they never
+ * reach the ledger, so a later run imports them under the same keys.
+ */
+export declare function selectImportWindows<T extends ImportWindow>(windows: T[], filters: Pick<ImportFilters, "since" | "until" | "cutoff">): {
+    kept: T[];
+    heldBack: number;
+    untimed: number;
+};
+/** Units of one session that `importHistorySource` would consider, for a counting pass. */
+export declare function countImportableUnits(session: ImportSourceSession, host: MemoryHost, filters: Pick<ImportFilters, "since" | "until">): number;
+/** Sessions produced on demand, so a large source never holds every turn at once. */
+export interface LazyImportSource {
+    /** Units that pass the date and key filters, counted in an earlier pass. */
+    total: number;
+    open: () => AsyncIterable<ImportSourceSession>;
+}
 /** Process host-labelled work units through the shared capture and ledger pipeline. */
-export declare function importHistorySource(source: AsyncIterable<ImportSourceSession> | Iterable<ImportSourceSession>, host: MemoryHost, deps: Pick<ImporterDeps, "provider" | "ledger" | "onProgress">, filters: Pick<ImportFilters, "dryRun" | "force" | "since" | "until">, report: ImportReport): Promise<void>;
+export declare function importHistorySource(source: AsyncIterable<ImportSourceSession> | Iterable<ImportSourceSession> | LazyImportSource, host: MemoryHost, deps: Pick<ImporterDeps, "provider" | "ledger" | "onProgress" | "signal">, filters: Pick<ImportFilters, "dryRun" | "force" | "since" | "until">, report: ImportReport): Promise<void>;
 export declare function importPiHistory(deps: ImporterDeps, filters: ImportFilters): Promise<ImportReport>;

package/dist/importer/importer.js

@@ -7,6 +7,7 @@ import { tursoConnectionManager } from "../services/turso/connection-manager.js"
 import { tursoShardManager } from "../services/turso/shard-manager.js";
 import { extractPiConversationWindows, } from "../adapters/pi/conversation.js";
 import { discoverPiSessions } from "./discovery.js";
+import { resolveImportProject } from "./import-project.js";
 import { PiImportLedger, importLedgerDbPath } from "./ledger.js";
 export function buildImportKey(sessionId, window, host = "pi") {
     const terminalEntryId = window.sourceEntryIds?.[window.sourceEntryIds.length - 1];
@@ -46,13 +47,6 @@ export function projectFilterTag(directory) {
     }
     return getTags(real).project.tag;
 }
-function resolveSessionDirectory(cwd, pathMaps) {
-    if (!cwd)
-        return null;
-    const mapped = pathMaps.find((map) => map.from === cwd)?.to;
-    const directory = mapped ?? cwd;
-    return existsSync(directory) ? directory : null;
-}
 function preview(text) {
     const trimmed = text.trim().replace(/\s+/g, " ");
     return trimmed.length > 60 ? `${trimmed.slice(0, 60)}...` : trimmed;
@@ -66,6 +60,38 @@ function windowWithinDateRange(window, filters) {
         return false;
     return true;
 }
+/**
+ * Keep the windows a run would import: inside the date range and not newer
+ * than the web listing cutoff. Held-back windows are only counted; they never
+ * reach the ledger, so a later run imports them under the same keys.
+ */
+export function selectImportWindows(windows, filters) {
+    const kept = [];
+    let heldBack = 0;
+    let untimed = 0;
+    for (const window of windows) {
+        if (!windowWithinDateRange(window, filters))
+            continue;
+        if (filters.cutoff !== undefined &&
+            window.userTimestamp !== undefined &&
+            window.userTimestamp > filters.cutoff) {
+            heldBack++;
+            continue;
+        }
+        if (window.userTimestamp === undefined)
+            untimed++;
+        kept.push(window);
+    }
+    return { kept, heldBack, untimed };
+}
+/** Units of one session that `importHistorySource` would consider, for a counting pass. */
+export function countImportableUnits(session, host, filters) {
+    return session.units.filter((window) => windowWithinDateRange(window, filters) &&
+        buildImportKey(session.sessionId, window, host) !== null).length;
+}
+function isLazySource(source) {
+    return typeof source.open === "function";
+}
 async function lookupExistingMemory(projectHash, key, options) {
     if (!options.storageAccessible)
         return null;
@@ -91,21 +117,34 @@ export async function importHistorySource(source, host, deps, filters, report) {
             throw new Error(`Memory system is not ready for import: ${embeddingInitError}. Start the extension and retry.`);
         }
     }
-    const candidates = [];
-    for await (const session of source) {
+    const sessionCandidates = (session) => {
         const { hash } = extractScopeFromContainerTag(getTags(session.directory).project.tag);
-        for (const window of session.units) {
-            if (!windowWithinDateRange(window, filters))
-                continue;
-            if (!buildImportKey(session.sessionId, window, host))
-                continue;
-            candidates.push({ ...session, hash, window });
-        }
+        return session.units
+            .filter((window) => windowWithinDateRange(window, filters) &&
+            buildImportKey(session.sessionId, window, host) !== null)
+            .map((window) => ({ ...session, hash, window }));
+    };
+    // A lazy source is read session by session; an eager one is buffered as before.
+    let candidates;
+    if (isLazySource(source)) {
+        report.unitsTotal = source.total;
+        candidates = (async function* () {
+            for await (const session of source.open())
+                yield* sessionCandidates(session);
+        })();
+    }
+    else {
+        const all = [];
+        for await (const session of source)
+            all.push(...sessionCandidates(session));
+        report.unitsTotal = all.length;
+        candidates = all;
     }
-    report.unitsTotal = candidates.length;
     const storageAccessible = ledgerFileExists;
     let processed = 0;
-    for (const candidate of candidates) {
+    for await (const candidate of candidates) {
+        if (deps.signal?.aborted)
+            break;
         const { sessionId, directory, sourceFile, hash, window } = candidate;
         const key = buildImportKey(sessionId, window, host);
         processed++;
@@ -223,10 +262,19 @@ export async function importPiHistory(deps, filters) {
         skipReasons: {},
         projects: [],
         units: [],
+        unitsHeldBack: 0,
+        unitsUntimed: 0,
     };
+    const selected = filters.selectionKeys ? new Set(filters.selectionKeys) : null;
     const projectAggregates = new Map();
     const candidates = [];
     for (const discovered of discovery.sessions) {
+        if (deps.signal?.aborted)
+            break;
+        if (selected && !selected.has(discovered.key)) {
+            report.sessionsFilteredOut++;
+            continue;
+        }
         if (filters.session) {
             const wanted = filters.session;
             if (discovered.sessionId !== wanted && discovered.file !== wanted) {
@@ -245,7 +293,16 @@ export async function importPiHistory(deps, filters) {
             });
             continue;
         }
-        const directory = resolveSessionDirectory(session.cwd, pathMaps);
+        // The header ID names the session in the page's list; a file that loads as
+        // another session would be imported under keys the user never saw.
+        if (discovered.sessionId && discovered.sessionId !== session.sessionId) {
+            report.loadErrors.push({
+                file: discovered.file,
+                error: "Loaded session ID does not match the file header",
+            });
+            continue;
+        }
+        const directory = resolveImportProject(session.cwd, pathMaps).directory;
         if (!directory) {
             report.unresolvableSessions.push({ file: session.sourceFile, cwd: session.cwd });
             continue;
@@ -269,10 +326,10 @@ export async function importPiHistory(deps, filters) {
             projectAggregates.set(tags.project.tag, aggregate);
         }
         aggregate.sessions.add(session.sessionId);
-        const windows = extractPiConversationWindows(session.branch);
-        for (const window of windows) {
-            if (!windowWithinDateRange(window, filters))
-                continue;
+        const windows = selectImportWindows(extractPiConversationWindows(session.branch), filters);
+        report.unitsHeldBack += windows.heldBack;
+        report.unitsUntimed += windows.untimed;
+        for (const window of windows.kept) {
             const key = buildImportKey(session.sessionId, window);
             if (!key)
                 continue;
@@ -311,10 +368,11 @@ export async function importPiHistory(deps, filters) {
         sessions: aggregate.sessions.size,
         units: aggregate.units,
     }));
-    if (deps.profile) {
+    if (deps.profile && !deps.signal?.aborted) {
         const { importProfileFromHistory } = await import("./profile-import.js");
         report.profile = await importProfileFromHistory(sourceSessions, {
             host: "pi",
+            signal: deps.signal,
             dryRun,
             model: deps.profile.model,
             batchSize: deps.profile.batchSize,

package/dist/importer/opencode-import.d.ts

@@ -1,14 +1,22 @@
 import type { CaptureSummaryProvider } from "../core/host.js";
 import type { ModelPort } from "../core/profile-analysis.js";
 import { type ImportPathMap, type ImportReport } from "./importer.js";
-import { type UnresolvedProject } from "./opencode-project.js";
+import type { UnresolvedProject } from "./opencode-project.js";
+import { DEFAULT_OPENCODE_DB, type OpencodeOpenOptions } from "./opencode-reader.js";
 import { type ProfileImportReport } from "./profile-import.js";
+export { DEFAULT_OPENCODE_DB };
 export interface OpencodeImportOptions {
     dbPath?: string;
     dryRun?: boolean;
     since?: number;
     until?: number;
     session?: string;
+    /** Web selection by session ID; never combined with `session` or `maxSessions`. */
+    selectionKeys?: string[];
+    /** Web selection: user turns after this epoch ms are held back for a later run. */
+    cutoff?: number;
+    /** Web jobs share the listing's snapshot of a live database. */
+    snapshot?: OpencodeOpenOptions["shared"];
     project?: string;
     maxSessions?: number;
     pathMaps?: ImportPathMap[];
@@ -18,6 +26,8 @@ export interface OpencodeImportOptions {
     profileBatch?: number;
     provider?: CaptureSummaryProvider;
     profileModel?: ModelPort;
+    onProgress?: (processed: number, total: number, promptPreview: string) => void;
+    signal?: AbortSignal;
 }
 export interface OpencodeImportReport extends ImportReport {
     childSessionsFolded: number;

package/dist/importer/opencode-import.js

@@ -1,11 +1,12 @@
-import { homedir } from "node:os";
-import { join } from "node:path";
 import { getTags } from "../services/tags.js";
 import { extractScopeFromContainerTag } from "../services/memory-scope.js";
-import { importHistorySource, projectFilterTag, } from "./importer.js";
-import { resolveOpencodeSessions } from "./opencode-project.js";
-import { readOpencodeHistory } from "./opencode-reader.js";
+import { countImportableUnits, importHistorySource, projectFilterTag, selectImportWindows, } from "./importer.js";
+import { resolveImportProject } from "./import-project.js";
+import { DEFAULT_OPENCODE_DB, openOpencodeHistory, } from "./opencode-reader.js";
 import { importProfileFromHistory } from "./profile-import.js";
+export { DEFAULT_OPENCODE_DB };
+/** Let the web server and live capture run between sessions of a long read. */
+const yieldToEventLoop = () => new Promise((resolve) => setImmediate(resolve));
 /** Import resolved OpenCode history through the shared memory and profile steps. */
 export async function importOpencodeHistory(options) {
     if (!options.dryRun && !options.skipMemories && !options.provider) {
@@ -14,74 +15,137 @@ export async function importOpencodeHistory(options) {
     if (!options.dryRun && !options.skipProfile && !options.profileModel) {
         throw new Error("OpenCode history import needs a profile model");
     }
-    const dbPath = options.dbPath ?? join(homedir(), ".local/share/opencode/opencode.db");
-    // Resolve the filter before opening the reader: the reader only closes once iterated.
+    const dbPath = options.dbPath ?? DEFAULT_OPENCODE_DB;
     const projectTag = options.project ? projectFilterTag(options.project) : null;
-    const reader = readOpencodeHistory(dbPath, options);
-    const unresolved = new Map();
-    const sessions = [];
-    const projects = new Map();
-    let filtered = 0;
-    for await (const session of resolveOpencodeSessions(reader.sessions, options.pathMaps ?? [], unresolved)) {
-        const info = getTags(session.directory).project;
-        if (projectTag && projectTag !== projectFilterTag(session.directory)) {
-            filtered++;
-            continue;
+    const history = await openOpencodeHistory(dbPath, {
+        ...(options.since !== undefined ? { since: options.since } : {}),
+        ...(options.until !== undefined ? { until: options.until } : {}),
+        ...(options.session ? { session: options.session } : {}),
+        ...(options.selectionKeys ? { sessionIds: options.selectionKeys } : {}),
+        ...(options.maxSessions ? { maxSessions: options.maxSessions } : {}),
+    }, {
+        ...(options.snapshot ? { shared: options.snapshot } : {}),
+        ...(options.signal ? { signal: options.signal } : {}),
+    });
+    try {
+        const unresolved = new Map();
+        const projects = new Map();
+        const selected = [];
+        let filtered = 0;
+        for (const session of history.sessions) {
+            const { directory } = resolveImportProject(session.recordedDirectory, options.pathMaps ?? [], session.projectWorktree);
+            if (!directory) {
+                const entry = unresolved.get(session.recordedDirectory) ?? {
+                    directory: session.recordedDirectory,
+                    sessions: 0,
+                    units: 0,
+                };
+                entry.sessions++;
+                entry.units += history.loadUnits(session.sessionId).length;
+                unresolved.set(entry.directory, entry);
+                continue;
+            }
+            if (projectTag && projectTag !== projectFilterTag(directory)) {
+                filtered++;
+                continue;
+            }
+            selected.push({ ...session, directory });
         }
-        const project = projects.get(info.tag) ?? {
-            tag: info.tag,
-            hash: extractScopeFromContainerTag(info.tag).hash,
-            directory: session.directory,
-            sessions: 0,
-            units: 0,
-            sessionIds: new Set(),
+        const build = (session) => {
+            const windows = selectImportWindows(history.loadUnits(session.sessionId), options);
+            const source = {
+                sessionId: session.sessionId,
+                directory: session.directory,
+                sourceFile: dbPath,
+                units: windows.kept,
+            };
+            return { source, windows };
         };
-        project.sessionIds.add(session.sessionId);
-        project.sessions = project.sessionIds.size;
-        project.units += session.units.length;
-        projects.set(info.tag, project);
-        sessions.push(session);
-    }
-    const report = {
-        dryRun: Boolean(options.dryRun),
-        root: dbPath,
-        sessionsDiscovered: reader.topLevelSessions,
-        sessionsLoaded: sessions.length,
-        sessionsFilteredOut: filtered,
-        sessionsUnrecognized: 0,
-        unresolvableSessions: [],
-        loadErrors: [],
-        unitsTotal: 0,
-        unitsImported: 0,
-        unitsWouldImport: 0,
-        unitsSkipped: 0,
-        unitsFailed: 0,
-        unitsAlreadyHandled: 0,
-        skipReasons: {},
-        units: [],
-        projects: [...projects.values()].map(({ sessionIds: _ids, ...project }) => project),
-        childSessionsFolded: reader.childSessions,
-        unresolvedProjects: [...unresolved.values()],
-    };
-    if (!options.skipMemories) {
-        await importHistorySource(sessions, "opencode", {
-            provider: options.provider ?? {
-                summarize: async () => {
-                    throw new Error("A dry-run cannot call the capture model");
+        // Counting pass: totals for progress and the report, one session in memory at a time.
+        let total = 0;
+        let kept = 0;
+        let heldBack = 0;
+        let untimed = 0;
+        for (const session of selected) {
+            if (options.signal?.aborted)
+                break;
+            const { source, windows } = build(session);
+            const info = getTags(session.directory).project;
+            const project = projects.get(info.tag) ?? {
+                tag: info.tag,
+                hash: extractScopeFromContainerTag(info.tag).hash,
+                directory: session.directory,
+                sessions: 0,
+                units: 0,
+                sessionIds: new Set(),
+            };
+            project.sessionIds.add(session.sessionId);
+            project.sessions = project.sessionIds.size;
+            project.units += windows.kept.length;
+            projects.set(info.tag, project);
+            total += countImportableUnits(source, "opencode", options);
+            kept += windows.kept.length;
+            heldBack += windows.heldBack;
+            untimed += windows.untimed;
+            await yieldToEventLoop();
+        }
+        const open = () => (async function* () {
+            for (const session of selected) {
+                if (options.signal?.aborted)
+                    return;
+                await yieldToEventLoop();
+                yield build(session).source;
+            }
+        })();
+        const report = {
+            dryRun: Boolean(options.dryRun),
+            root: dbPath,
+            sessionsDiscovered: history.topLevelSessions,
+            sessionsLoaded: selected.length,
+            sessionsFilteredOut: filtered,
+            sessionsUnrecognized: 0,
+            unresolvableSessions: [],
+            loadErrors: [],
+            unitsTotal: 0,
+            unitsImported: 0,
+            unitsWouldImport: 0,
+            unitsSkipped: 0,
+            unitsFailed: 0,
+            unitsAlreadyHandled: 0,
+            unitsHeldBack: heldBack,
+            unitsUntimed: untimed,
+            skipReasons: {},
+            units: [],
+            projects: [...projects.values()].map(({ sessionIds: _ids, ...project }) => project),
+            childSessionsFolded: history.childSessions,
+            unresolvedProjects: [...unresolved.values()],
+        };
+        if (!options.skipMemories) {
+            await importHistorySource({ total, open }, "opencode", {
+                provider: options.provider ?? {
+                    summarize: async () => {
+                        throw new Error("A dry-run cannot call the capture model");
+                    },
                 },
-            },
-        }, options, report);
-    }
-    else {
-        report.unitsTotal = sessions.reduce((total, session) => total + session.units.length, 0);
+                ...(options.signal ? { signal: options.signal } : {}),
+                ...(options.onProgress ? { onProgress: options.onProgress } : {}),
+            }, options, report);
+        }
+        else {
+            report.unitsTotal = kept;
+        }
+        if (!options.skipProfile && !options.signal?.aborted) {
+            report.profile = await importProfileFromHistory(open(), {
+                host: "opencode",
+                signal: options.signal,
+                dryRun: options.dryRun,
+                batchSize: options.profileBatch,
+                model: options.profileModel,
+            });
+        }
+        return report;
     }
-    if (!options.skipProfile) {
-        report.profile = await importProfileFromHistory(sessions, {
-            host: "opencode",
-            dryRun: options.dryRun,
-            batchSize: options.profileBatch,
-            model: options.profileModel,
-        });
+    finally {
+        await history.close();
     }
-    return report;
 }

package/dist/importer/opencode-project.d.ts

@@ -1,11 +1,8 @@
 import type { ImportPathMap } from "./importer.js";
-import type { OpencodeSourceSession } from "./opencode-reader.js";
-/** Prefer the recorded directory, then an explicit map, then the project root. */
+/** A directory map first, then the recorded directory, then the project root. */
 export declare function resolveOpencodeProject(recordedDirectory: string, projectWorktree: string | null, maps?: ImportPathMap[]): string | null;
 export interface UnresolvedProject {
     directory: string;
     sessions: number;
     units: number;
 }
-/** Resolve each session without buffering its conversation windows. */
-export declare function resolveOpencodeSessions(sessions: AsyncIterable<OpencodeSourceSession>, maps: ImportPathMap[], unresolved: Map<string, UnresolvedProject>): AsyncGenerator<OpencodeSourceSession>;