om-memory-system 3.4.0-next.21 → 3.4.0-next.26

package/dist/importer/import-runs.js

@@ -0,0 +1,141 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { CONFIG } from "../config.js";
+import { safeHealthError } from "../services/safe-health-error.js";
+import { tursoConnectionManager } from "../services/turso/connection-manager.js";
+import { isProcessAlive } from "./backfill-lock.js";
+import { addProgressSample, estimateProgress, } from "./import-progress.js";
+const dbPath = (storagePath = CONFIG.storagePath) => join(storagePath, "import-ledger.db");
+async function table(storagePath) {
+    const db = await tursoConnectionManager.getConnection(dbPath(storagePath));
+    await db.run(`CREATE TABLE IF NOT EXISTS import_runs (
+    host TEXT PRIMARY KEY, surface TEXT, state TEXT, pid INTEGER, started_at INTEGER,
+    total INTEGER NOT NULL DEFAULT 0, done INTEGER NOT NULL DEFAULT 0,
+    imported INTEGER NOT NULL DEFAULT 0, skipped INTEGER NOT NULL DEFAULT 0,
+    failed INTEGER NOT NULL DEFAULT 0, error TEXT, updated_at INTEGER,
+    samples TEXT, paused INTEGER NOT NULL DEFAULT 0
+  )`);
+    // A row per host keeps every later statement a plain UPDATE.
+    await db.run("INSERT OR IGNORE INTO import_runs (host) VALUES ('pi'), ('opencode')");
+    return db;
+}
+const count = (value) => (Number.isSafeInteger(value) && value >= 0 ? value : 0);
+/** Read a host's run without creating the store; a running row whose process is gone reads as stopped. */
+export async function readImportRun(host) {
+    if (!existsSync(dbPath()))
+        return null;
+    const db = await tursoConnectionManager.getConnection(dbPath());
+    const exists = await db.get("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'import_runs'");
+    if (!exists)
+        return null;
+    const row = await db.get("SELECT * FROM import_runs WHERE host = ?", [
+        host,
+    ]);
+    if (!row)
+        return null;
+    const pid = row.pid === null ? null : Number(row.pid);
+    let state = (row.state ?? null);
+    if (state === "running" && (pid === null || !isProcessAlive(pid)))
+        state = "stopped";
+    const total = Number(row.total);
+    const done = Number(row.done);
+    const samples = row.samples ? JSON.parse(String(row.samples)) : [];
+    return {
+        host,
+        surface: (row.surface ?? null),
+        state,
+        pid,
+        startedAt: row.started_at === null ? null : Number(row.started_at),
+        updatedAt: row.updated_at === null ? null : Number(row.updated_at),
+        total,
+        done,
+        imported: Number(row.imported),
+        skipped: Number(row.skipped),
+        failed: Number(row.failed),
+        error: row.error === null ? null : String(row.error),
+        paused: Number(row.paused) === 1,
+        ...(state === "running"
+            ? estimateProgress(total, done, samples)
+            : {
+                percent: total > 0 ? Math.min(100, Math.floor((done / total) * 100)) : 0,
+                minutesLeft: null,
+                ratePerMinute: null,
+            }),
+    };
+}
+export async function isBackfillPaused(host) {
+    return (await readImportRun(host))?.paused ?? false;
+}
+export async function setBackfillPaused(host, paused) {
+    const db = await table();
+    await db.run("UPDATE import_runs SET paused = ?, updated_at = ? WHERE host = ?", [
+        paused ? 1 : 0,
+        Date.now(),
+        host,
+    ]);
+}
+/**
+ * Start a host's run record. Only numbers, the surface, and the PID are
+ * stored; `promptPreview` and all other conversation content never are.
+ */
+export async function startImportRun(host, surface, options = {}) {
+    const clock = options.now ?? Date.now;
+    const interval = options.intervalMs ?? 1_000;
+    const sampleInterval = options.sampleIntervalMs ?? 15_000;
+    const db = await table();
+    const startedAt = clock();
+    await db.run(`UPDATE import_runs SET surface = ?, state = 'running', pid = ?, started_at = ?, total = 0,
+       done = 0, imported = 0, skipped = 0, failed = 0, error = NULL, updated_at = ?, samples = '[]'
+     WHERE host = ?`, [surface, process.pid, startedAt, startedAt, host]);
+    let samples = [];
+    let lastWrite = Number.NEGATIVE_INFINITY;
+    let lastSample = Number.NEGATIVE_INFINITY;
+    let latest = { done: 0, total: 0 };
+    let pauseRequested = false;
+    let writing = Promise.resolve();
+    const write = () => {
+        const now = clock();
+        lastWrite = now;
+        // Sample less often than we write, so the window spans minutes, not seconds.
+        if (now - lastSample >= sampleInterval) {
+            lastSample = now;
+            samples = addProgressSample(samples, { at: now, done: latest.done });
+        }
+        const snapshot = { ...latest, samples: JSON.stringify(samples) };
+        writing = writing
+            .then(async () => {
+            await db.run("UPDATE import_runs SET total = ?, done = ?, samples = ?, updated_at = ? WHERE host = ?", [count(snapshot.total), count(snapshot.done), snapshot.samples, now, host]);
+            const row = await db.get("SELECT paused FROM import_runs WHERE host = ?", [host]);
+            if (Number(row?.paused) === 1 && !pauseRequested) {
+                pauseRequested = true;
+                options.onPause?.();
+            }
+        })
+            .catch(() => { });
+    };
+    return {
+        progress(done, total) {
+            latest = { done, total };
+            if (clock() - lastWrite >= interval)
+                write();
+        },
+        get pauseRequested() {
+            return pauseRequested;
+        },
+        async finish(state, counts, error) {
+            await writing;
+            await db.run(`UPDATE import_runs SET state = ?, total = ?, done = ?, imported = ?, skipped = ?,
+           failed = ?, error = ?, updated_at = ? WHERE host = ?`, [
+                state,
+                count(counts.total ?? latest.total),
+                count(counts.done ?? latest.done),
+                count(counts.imported ?? 0),
+                count(counts.skipped ?? 0),
+                count(counts.failed ?? 0),
+                error == null ? null : safeHealthError(error, [CONFIG.memoryApiKey]).slice(0, 500),
+                clock(),
+                host,
+            ]);
+        },
+    };
+}

package/dist/importer/import-sessions.js

@@ -65,14 +65,11 @@ export async function matchImportSessions(identity, options, snapshotMode) {
     const projectTag = options.scope === "current-project"
         ? projectFilterTag(resolve(options.cwd, options.project ?? "."))
         : null;
-    // Map targets resolve against the working directory, as `runHistoryImport` does.
-    const rows = await readRows(identity, {
-        ...options,
-        pathMaps: options.pathMaps.map((map) => ({
-            from: map.from,
-            to: resolve(options.cwd, map.to),
-        })),
-    }, snapshotMode);
+    // Saved maps plus the request's own, as `runHistoryImport` uses them.
+    // The revision hashes the same merged maps, so a saved-map change is seen as stale.
+    const { runPathMaps } = await import("./import-path-maps.js");
+    const merged = { ...options, pathMaps: await runPathMaps(options.pathMaps, options.cwd) };
+    const rows = await readRows(identity, merged, snapshotMode);
     const unresolved = rows.filter((row) => row.directory === null);
     const matching = rows
         .filter((row) => row.directory !== null)
@@ -82,7 +79,7 @@ export async function matchImportSessions(identity, options, snapshotMode) {
         identity,
         matching,
         unresolved,
-        revision: revisionOf(identity, options, projectTag, matching.map((row) => row.key)),
+        revision: revisionOf(identity, merged, projectTag, matching.map((row) => row.key)),
     };
 }
 /** Check a session-list request body from the page. */
@@ -136,6 +133,9 @@ export async function listImportSessions(request, options) {
     // A refresh takes a fresh copy of a live database; paging reuses the current one.
     const listedAt = Date.now();
     const matched = await matchImportSessions(identity, options, request.refresh ? "fresh" : "any");
+    // Feed the Directory maps list; a failure here must not break the listing.
+    const { recordUnresolvedDirectories, summarizeUnresolvedDirectories } = await import("../services/backfill-state.js");
+    await recordUnresolvedDirectories(options.host, summarizeUnresolvedDirectories(matched.unresolved.map((row) => ({ directory: row.recordedDirectory })))).catch(() => { });
     const rows = [
         ...matched.matching.map((row) => ({ ...row, selectable: true })),
         ...(options.scope === "all-projects"

package/dist/importer/importer.d.ts

@@ -87,7 +87,8 @@ export interface ImportReport {
 export interface ImporterDeps {
     loadSession: (file: string) => LoadedPiSession;
     provider: CaptureSummaryProvider;
-    onProgress?: (processed: number, total: number, promptPreview: string) => void;
+    /** `alreadyHandled`: units found already done so far, which need no model call. */
+    onProgress?: (processed: number, total: number, promptPreview: string, alreadyHandled?: number) => void;
     signal?: AbortSignal;
     ledger?: PiImportLedger;
     profile?: {

package/dist/importer/importer.js

@@ -6,7 +6,7 @@ import { extractScopeFromContainerTag } from "../services/memory-scope.js";
 import { getTags } from "../services/tags.js";
 import { tursoConnectionManager } from "../services/turso/connection-manager.js";
 import { tursoShardManager } from "../services/turso/shard-manager.js";
-import { extractPiConversationWindows, } from "../adapters/pi/conversation.js";
+import { extractPiConversationWindows, } from "./pi-conversation.js";
 import { discoverPiSessions } from "./discovery.js";
 import { resolveImportProject } from "./import-project.js";
 import { PiImportLedger, importLedgerDbPath } from "./ledger.js";
@@ -149,7 +149,7 @@ export async function importHistorySource(source, host, deps, filters, report) {
         const { sessionId, directory, sourceFile, hash, window } = candidate;
         const key = buildImportKey(sessionId, window, host);
         processed++;
-        deps.onProgress?.(processed, report.unitsTotal, preview(window.userPrompt));
+        deps.onProgress?.(processed, report.unitsTotal, preview(window.userPrompt), report.unitsAlreadyHandled);
         const unit = {
             key,
             sessionId: sessionId,

package/dist/importer/map-suggestions.d.ts

@@ -0,0 +1,39 @@
+import type { UnresolvedDirectory } from "../services/backfill-state.js";
+export interface MapSuggestionContext {
+    /** Existing project directories the user has history for; their parents are searched too. */
+    knownProjects?: readonly string[];
+    /** OpenCode's recorded project worktree for a session directory, read without writing. */
+    opencodeWorktree?: (directory: string) => string | null | undefined;
+    /** The user's home folder; the search never climbs above it. Defaults to `homedir()`. */
+    home?: string;
+    /** Folder listings already read in this request. */
+    cache?: Map<string, string[]>;
+}
+/**
+ * Suggest an existing target for a directory that no longer exists: first the
+ * main repository of a deleted worktree, by the longest leading part of the
+ * directory's name or one of its parents' names, then OpenCode's recorded
+ * project worktree. Returns null when there is no candidate.
+ */
+export declare function suggestMapTarget(missing: string, context?: MapSuggestionContext): string | null;
+export interface SuggestedDirectory extends UnresolvedDirectory {
+    suggestion: string | null;
+}
+export declare function suggestMapTargets(directories: readonly UnresolvedDirectory[], context?: MapSuggestionContext): SuggestedDirectory[];
+/**
+ * OpenCode's recorded project worktree for each session directory, through
+ * the importer's read-only reader. OpenCode's database is never written.
+ */
+export declare function readOpencodeWorktrees(dbPath: string): Promise<Map<string, string>>;
+/**
+ * The Directory maps list: saved maps and each host's unresolved directories
+ * from its latest run, with suggestions. Paths and counts only.
+ */
+export declare function directoryMapsView(options?: {
+    opencodeDbPath?: string;
+    knownProjects?: readonly string[];
+}): Promise<{
+    saved: import("./importer.js").ImportPathMap[];
+    pi: SuggestedDirectory[];
+    opencode: SuggestedDirectory[];
+}>;

package/dist/importer/map-suggestions.js

@@ -0,0 +1,133 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join, parse } from "node:path";
+const PROJECT_MARKERS = [".git", "package.json", "pyproject.toml", "Cargo.toml", "go.mod"];
+function isDirectory(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function isProject(path) {
+    return PROJECT_MARKERS.some((marker) => existsSync(join(path, marker)));
+}
+function childDirectories(parent, cache) {
+    const cached = cache?.get(parent);
+    if (cached)
+        return cached;
+    let children;
+    try {
+        children = readdirSync(parent, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => join(parent, entry.name));
+    }
+    catch {
+        children = [];
+    }
+    cache?.set(parent, children);
+    return children;
+}
+/** `app` is a leading part of `app`, `app-feat-x`, and `app-feat-x-2`, not of `apple`. */
+function isLeadingPart(candidate, name) {
+    return name === candidate || name.startsWith(`${candidate}-`);
+}
+/**
+ * Suggest an existing target for a directory that no longer exists: first the
+ * main repository of a deleted worktree, by the longest leading part of the
+ * directory's name or one of its parents' names, then OpenCode's recorded
+ * project worktree. Returns null when there is no candidate.
+ */
+export function suggestMapTarget(missing, context = {}) {
+    const searchRoots = new Set();
+    for (const project of context.knownProjects ?? []) {
+        if (!isDirectory(project))
+            continue;
+        searchRoots.add(dirname(project));
+    }
+    // Never list the filesystem root or the folder that holds every home folder,
+    // and stop at the home folder itself: broad scans suggest unrelated folders.
+    const home = context.home ?? homedir();
+    const blocked = new Set([parse(missing).root, dirname(home)]);
+    let ancestor = missing;
+    while (dirname(ancestor) !== ancestor && ancestor !== home) {
+        const name = basename(ancestor);
+        const parents = new Set([dirname(ancestor), ...searchRoots]);
+        let best = null;
+        for (const parent of parents) {
+            if (blocked.has(parent))
+                continue;
+            for (const candidate of childDirectories(parent, context.cache)) {
+                if (candidate === ancestor || !isLeadingPart(basename(candidate), name))
+                    continue;
+                if (!isProject(candidate))
+                    continue;
+                if (!best || basename(candidate).length > basename(best).length)
+                    best = candidate;
+            }
+        }
+        if (best)
+            return best;
+        ancestor = dirname(ancestor);
+    }
+    const worktree = context.opencodeWorktree?.(missing);
+    if (worktree && worktree !== "/" && isDirectory(worktree))
+        return worktree;
+    return null;
+}
+export function suggestMapTargets(directories, context = {}) {
+    const withCache = { ...context, cache: context.cache ?? new Map() };
+    return directories.map((item) => ({
+        ...item,
+        suggestion: suggestMapTarget(item.directory, withCache),
+    }));
+}
+/**
+ * OpenCode's recorded project worktree for each session directory, through
+ * the importer's read-only reader. OpenCode's database is never written.
+ */
+export async function readOpencodeWorktrees(dbPath) {
+    const { openOpencodeHistory } = await import("./opencode-reader.js");
+    const history = await openOpencodeHistory(dbPath);
+    try {
+        const worktrees = new Map();
+        for (const session of history.sessions) {
+            if (session.recordedDirectory && session.projectWorktree) {
+                worktrees.set(session.recordedDirectory, session.projectWorktree);
+            }
+        }
+        return worktrees;
+    }
+    finally {
+        await history.close();
+    }
+}
+/**
+ * The Directory maps list: saved maps and each host's unresolved directories
+ * from its latest run, with suggestions. Paths and counts only.
+ */
+export async function directoryMapsView(options = {}) {
+    const { CONFIG } = await import("../config.js");
+    const { readUnresolvedDirectories } = await import("../services/backfill-state.js");
+    const { DEFAULT_OPENCODE_DB } = await import("./opencode-reader.js");
+    const saved = new Set(CONFIG.importPathMaps.map((map) => map.from));
+    let worktrees = new Map();
+    const dbPath = options.opencodeDbPath ?? DEFAULT_OPENCODE_DB;
+    if (existsSync(dbPath)) {
+        worktrees = await readOpencodeWorktrees(dbPath).catch(() => new Map());
+    }
+    const knownProjects = [
+        ...(options.knownProjects ?? []),
+        ...CONFIG.importPathMaps.map((map) => map.to),
+        ...worktrees.values(),
+    ];
+    const host = async (name) => {
+        const pending = (await readUnresolvedDirectories(name)).filter((item) => !saved.has(item.directory));
+        return suggestMapTargets(pending, {
+            knownProjects,
+            ...(name === "opencode" ? { opencodeWorktree: (dir) => worktrees.get(dir) } : {}),
+        });
+    };
+    return { saved: CONFIG.importPathMaps, pi: await host("pi"), opencode: await host("opencode") };
+}

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

@@ -26,7 +26,8 @@ export interface OpencodeImportOptions {
     profileBatch?: number;
     provider?: CaptureSummaryProvider;
     profileModel?: ModelPort;
-    onProgress?: (processed: number, total: number, promptPreview: string) => void;
+    /** `alreadyHandled`: units found already done so far, which need no model call. */
+    onProgress?: (processed: number, total: number, promptPreview: string, alreadyHandled?: number) => void;
     signal?: AbortSignal;
 }
 export interface OpencodeImportReport extends ImportReport {

package/dist/{adapters/pi/conversation.d.ts → importer/pi-conversation.d.ts}

@@ -1,4 +1,4 @@
-import type { CaptureConversation } from "../../core/host.js";
+import type { CaptureConversation } from "../core/host.js";
 /**
  * Minimal structural view of Pi session entries (see Pi session-format docs).
  * Kept structural so the normaliser stays testable without importing Pi types.

package/dist/importer/profile-import.js

@@ -1,4 +1,4 @@
-import { isInternalPrompt } from "../adapters/opencode/user-prompt.js";
+import { isStructuredSummaryPromptMessage } from "../core/internal-prompt.js";
 import { analyzeProfile } from "../core/profile-analysis.js";
 import { isFullyPrivate, stripPrivateContent } from "../services/privacy.js";
 import { getTags } from "../services/tags.js";
@@ -37,7 +37,8 @@ export async function importProfileFromHistory(source, options) {
             const prompt = stripPrivateContent(unit.userPrompt).trim();
             if (!prompt ||
                 isFullyPrivate(unit.userPrompt) ||
-                isInternalPrompt(session.sessionId, prompt)) {
+                // OpenCode history already leaves out omms's own capture sessions by title.
+                isStructuredSummaryPromptMessage(prompt)) {
                 continue;
             }
             const key = buildImportKey(session.sessionId, unit, options.host);

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

@@ -1,8 +1,9 @@
 import type { CaptureSummaryProvider } from "../core/host.js";
 import type { ModelPort } from "../core/profile-analysis.js";
 import type { HistoryImportArgs, ImportHost } from "./import-args.js";
-import type { ImportReport } from "./importer.js";
+import type { ImportPathMap, ImportReport } from "./importer.js";
 import type { UnresolvedProject } from "./opencode-project.js";
+import type { ImportSurface } from "./import-runs.js";
 /** The two model roles an import uses; absent in a dry run or when the step is skipped. */
 export interface HistoryImportModels {
     capture?: CaptureSummaryProvider;
@@ -12,8 +13,17 @@ export interface HistoryImportRun {
     /** Directory that relative paths and the default project resolve against. */
     cwd: string;
     models: HistoryImportModels;
-    onProgress?: (processed: number, total: number, promptPreview: string) => void;
+    /** `alreadyHandled`: units found already done so far, which need no model call. */
+    onProgress?: (processed: number, total: number, promptPreview: string, alreadyHandled?: number) => void;
     signal?: AbortSignal;
+    /** Record progress and take the host's lock for a run that calls models. */
+    track?: {
+        surface: ImportSurface;
+        lockHeld?: boolean;
+        expectedTotal?: number;
+    };
+    /** Saved directory maps; defaults to the global `importPathMaps`. */
+    savedPathMaps?: readonly ImportPathMap[];
     /** Web selection, already re-resolved against the source; `args.source` is its real path. */
     selection?: {
         keys: string[];
@@ -26,7 +36,15 @@ export type HistoryImportReport = ImportReport & {
     childSessionsFolded?: number;
     unresolvedProjects?: UnresolvedProject[];
 };
-/** Run one host's history import with already-parsed, validated arguments. */
+/** Another process or surface holds this host's import lock. */
+export declare class ImportAlreadyRunningError extends Error {
+    constructor(host: ImportHost);
+}
+/**
+ * Run one host's history import with already-parsed, validated arguments.
+ * With `track`, a run that calls models takes the host's cross-process lock
+ * and records its progress; a dry run never does either.
+ */
 export declare function runHistoryImport(host: ImportHost, args: HistoryImportArgs, run: HistoryImportRun): Promise<HistoryImportReport>;
 /** The same plain-text report for every host and surface. */
 export declare function formatHistoryImportReport(host: ImportHost, report: HistoryImportReport, model?: string): string;

package/dist/importer/run-import.js

@@ -4,11 +4,91 @@ const dryRunCapture = {
         throw new Error("A dry-run cannot call the capture model");
     },
 };
-/** Run one host's history import with already-parsed, validated arguments. */
+/** Another process or surface holds this host's import lock. */
+export class ImportAlreadyRunningError extends Error {
+    constructor(host) {
+        super(`${host === "pi" ? "A Pi" : "An OpenCode"} import is already running`);
+        this.name = "ImportAlreadyRunningError";
+    }
+}
+/**
+ * Run one host's history import with already-parsed, validated arguments.
+ * With `track`, a run that calls models takes the host's cross-process lock
+ * and records its progress; a dry run never does either.
+ */
 export async function runHistoryImport(host, args, run) {
+    if (!run.track || args.dryRun)
+        return runUntracked(host, args, run);
+    let release = null;
+    if (!run.track.lockHeld) {
+        const { tryAcquireBackfillLock } = await import("./backfill-lock.js");
+        release = await tryAcquireBackfillLock(host);
+        if (!release)
+            throw new ImportAlreadyRunningError(host);
+    }
+    try {
+        const { startImportRun } = await import("./import-runs.js");
+        const { workProgress } = await import("./import-progress.js");
+        const controller = new AbortController();
+        const onAbort = () => controller.abort();
+        run.signal?.addEventListener("abort", onAbort, { once: true });
+        if (run.signal?.aborted)
+            controller.abort();
+        const recorder = await startImportRun(host, run.track.surface, {
+            onPause: () => controller.abort(),
+        });
+        try {
+            const report = await runUntracked(host, args, {
+                ...run,
+                signal: controller.signal,
+                onProgress: (processed, total, preview, alreadyHandled = 0) => {
+                    // Units already in the ledger need no model call: leave them out of
+                    // the progress so the bar and the time left describe real work.
+                    const work = workProgress(processed, total, alreadyHandled, run.track.expectedTotal);
+                    recorder.progress(work.done, work.total);
+                    run.onProgress?.(processed, total, preview, alreadyHandled);
+                },
+            });
+            const handled = report.unitsImported + report.unitsSkipped + report.unitsFailed;
+            await recorder.finish(recorder.pauseRequested ? "paused" : controller.signal.aborted ? "stopped" : "done", {
+                // The total stays the one progress last reported; a real run has no
+                // "would import" count of its own.
+                done: handled,
+                imported: report.unitsImported,
+                skipped: report.unitsSkipped,
+                failed: report.unitsFailed,
+            });
+            await recordUnresolved(host, report);
+            return report;
+        }
+        catch (error) {
+            await recorder
+                .finish(recorder.pauseRequested ? "paused" : controller.signal.aborted ? "stopped" : "failed", {}, error)
+                .catch(() => { });
+            throw error;
+        }
+        finally {
+            run.signal?.removeEventListener("abort", onAbort);
+        }
+    }
+    finally {
+        await release?.();
+    }
+}
+async function recordUnresolved(host, report) {
+    try {
+        const { recordUnresolvedDirectories, unresolvedDirectoriesOf } = await import("../services/backfill-state.js");
+        await recordUnresolvedDirectories(host, unresolvedDirectoriesOf(report));
+    }
+    catch {
+        // The list is a convenience for the Settings page; the import itself succeeded.
+    }
+}
+async function runUntracked(host, args, run) {
     const at = (path) => resolve(run.cwd, path);
     const project = args.scope === "current-project" ? at(args.project ?? ".") : undefined;
-    const pathMaps = args.pathMaps.map((map) => ({ from: map.from, to: at(map.to) }));
+    const { runPathMaps } = await import("./import-path-maps.js");
+    const pathMaps = await runPathMaps(args.pathMaps, run.cwd, run.savedPathMaps);
     const capture = run.models.capture ?? dryRunCapture;
     if (host === "opencode") {
         const { importOpencodeHistory } = await import("./opencode-import.js");

package/dist/importer/session-loader.d.ts

@@ -1,4 +1,4 @@
-import type { PiSessionEntry } from "../adapters/pi/conversation.js";
+import type { PiSessionEntry } from "./pi-conversation.js";
 /**
  * Loads a Pi session file for import through Pi's own exported session model
  * (`SessionManager.open`), which handles parsing and legacy-version migration

package/dist/importer/web-import-api.d.ts

@@ -6,3 +6,6 @@ export { importReadiness } from "./import-readiness.js";
 export { browseImportSources, validateImportSource } from "./import-sources.js";
 export { listImportSessions, validateSessionListRequest } from "./import-sessions.js";
 export { opencodeSnapshots, sweepOrphanSnapshots } from "./opencode-snapshot.js";
+export { BackfillControls } from "./backfill-controls.js";
+export { directoryMapsView } from "./map-suggestions.js";
+export { testExternalApi } from "./external-api-test.js";

package/dist/importer/web-import-api.js

@@ -6,3 +6,6 @@ export { importReadiness } from "./import-readiness.js";
 export { browseImportSources, validateImportSource } from "./import-sources.js";
 export { listImportSessions, validateSessionListRequest } from "./import-sessions.js";
 export { opencodeSnapshots, sweepOrphanSnapshots } from "./opencode-snapshot.js";
+export { BackfillControls } from "./backfill-controls.js";
+export { directoryMapsView } from "./map-suggestions.js";
+export { testExternalApi } from "./external-api-test.js";

package/dist/importer/web-import-jobs.js

@@ -187,6 +187,7 @@ export class SettingsImportJobs {
                     cwd: directory,
                     models,
                     signal: controller.signal,
+                    track: { surface: "web" },
                     selection: {
                         keys: selection.keys,
                         cutoff: selection.cutoff,

package/dist/index.js

@@ -231,15 +231,20 @@ export const OmmsPlugin = async (ctx) => {
         catch (error) {
             log("Failed to initialize opencode provider state", { error: String(error) });
         }
+        const configModel = async () => {
+            const response = await ctx.client.config.get();
+            return unwrapSdkData(response)?.model ?? null;
+        };
+        // Run now on a Settings page served by this process can use OpenCode's signed-in models.
+        void import("./adapters/opencode/backfill-startup.js")
+            .then(({ registerOpencodeBackfillModels }) => registerOpencodeBackfillModels({ connected, directory, configModel }))
+            .catch(() => { });
         if (CONFIG.autoBackfill && process.env.OMMS_DISABLE_AUTO_BACKFILL !== "1" && isConfigured()) {
             void import("./adapters/opencode/backfill-startup.js")
                 .then(({ startOpencodeBackfill }) => startOpencodeBackfill({
                 connected,
                 directory,
-                configModel: async () => {
-                    const response = await ctx.client.config.get();
-                    return unwrapSdkData(response)?.model ?? null;
-                },
+                configModel,
                 notify: (message) => {
                     void ctx.client.tui
                         ?.showToast({

package/dist/services/ai/live-model-choice.d.ts

@@ -14,7 +14,8 @@ export interface AutoCaptureProviderRuntimeConfig {
 /**
  * Where live capture and profile learning send model calls, the same on both hosts:
  * - `opencode`: the configured host model (`opencodeModel`/`piModel`; "inherit" = session model)
- * - `manual`: no host model, so the external API (`memoryModel`/`memoryApiUrl`/`memoryApiKey`)
+ * - `manual`: the external API (`memoryModel`/`memoryApiUrl`/`memoryApiKey`), because the
+ *   host model is "external" or no host model is set
  * - `session`: neither is set, so the session's own model through the host's sign-in
  */
 export type AutoCaptureProviderStatus = {
@@ -50,3 +51,5 @@ export declare function resolvePiLiveModel(config: AutoCaptureProviderRuntimeCon
 }): PiLiveModelChoice;
 /** True when the external API is fully configured and can serve as a fallback. */
 export declare function isExternalModelReady(config: AutoCaptureProviderRuntimeConfig): boolean;
+/** Why the external API cannot be used as a host's chosen model, or an empty list. */
+export declare function externalModelIssues(config: AutoCaptureProviderRuntimeConfig): string[];