om-memory-system 3.0.0 → 3.1.0-next.3

package/dist/adapters/opencode/auto-capture-summary.js

@@ -1,6 +1,8 @@
 import { randomUUID } from "node:crypto";
 import { CONFIG } from "../../config.js";
+import { resolveOpencodeHostModel } from "../../services/ai/live-model-choice.js";
 import { buildBoundedSummaryPrompt } from "../../core/capture-context.js";
+import { parseCaptureSummary } from "../../core/extraction.js";
 import { log } from "../../services/logger.js";
 import { loadOpencodeProvider } from "../../services/ai/opencode-provider-loader.js";
 function buildSystemPrompt(languageName) {
@@ -26,21 +28,18 @@ CAPTURE if: code changed, bug fixed, feature added, decision made`;
 }
 export async function generateOpenCodeAutoCaptureSummary(request, notify) {
     let opencodeProviderError;
-    if (CONFIG.opencodeProvider && CONFIG.opencodeModel) {
+    const hostModel = resolveOpencodeHostModel(CONFIG);
+    if (hostModel) {
         try {
-            if (CONFIG.memoryModel) {
+            if (CONFIG.memoryModel && CONFIG.opencodeProvider) {
                 log("opencodeProvider takes precedence over memoryModel for auto-capture");
             }
-            const { isProviderConnected, getV2Client, generateStructuredOutput } = await loadOpencodeProvider();
-            let providerID = CONFIG.opencodeProvider;
-            let modelID = CONFIG.opencodeModel;
-            if (modelID === "inherit") {
-                if (!request.prompt?.providerId || !request.prompt?.modelId) {
-                    throw new Error("omms: opencodeModel is 'inherit' but no session model was recorded for this prompt");
-                }
-                providerID = request.prompt.providerId;
-                modelID = request.prompt.modelId;
-            }
+            const { isProviderConnected, getV2Client, generateStructuredOutput, resolveOpencodeModelRef, } = await loadOpencodeProvider();
+            // "inherit" (explicit, or no model configured at all) follows this prompt's session model.
+            const { providerID, modelID } = resolveOpencodeModelRef({
+                ...hostModel,
+                prompt: request.prompt,
+            });
             if (!isProviderConnected(providerID)) {
                 throw new Error(`opencode provider '${providerID}' is not connected. Check your opencode provider configuration.`);
             }
@@ -139,9 +138,16 @@ export async function generateOpenCodeAutoCaptureSummary(request, notify) {
     if (!result.success || !result.data) {
         throw new Error(result.error || "Failed to generate summary");
     }
-    return {
-        summary: result.data.summary,
-        type: result.data.type,
-        tags: (result.data.tags || []).map((tag) => tag.toLowerCase().trim()),
-    };
+    const rawReply = JSON.stringify(result.data);
+    const summary = parseCaptureSummary(rawReply);
+    if (!summary) {
+        log("OpenCode capture: model reply was not a valid capture summary", {
+            provider: CONFIG.memoryProvider,
+            modelId: CONFIG.memoryModel,
+            // The reply can carry conversation content, so log only its size.
+            replyLength: rawReply.length,
+        });
+        throw new Error("omms: OpenCode extraction returned an invalid summary payload");
+    }
+    return summary;
 }

package/dist/adapters/opencode/import-command.d.ts

@@ -0,0 +1,42 @@
+import { type HistoryImportModels } from "../../importer/run-import.js";
+/**
+ * OpenCode command surface for the historical-session importer:
+ *
+ *   /memory-import-opencode-history --dry-run
+ *   /memory-import-opencode-history
+ *
+ * The same options and model rules as Pi's command: this session's model by
+ * default, or `--model provider/id` from OpenCode's connected providers. Model
+ * calls go through OpenCode's own sign-in, so no omms API key is involved.
+ */
+export declare const OPENCODE_IMPORT_COMMAND = "memory-import-opencode-history";
+export declare const OPENCODE_IMPORT_DESCRIPTION = "Import historical OpenCode sessions into the shared memory store (try --dry-run first)";
+export declare const OPENCODE_IMPORT_USAGE: string;
+export interface OpencodeModelRef {
+    providerID: string;
+    modelID: string;
+}
+export interface OpencodeImportCommandInput {
+    argsText: string;
+    /** Session directory; relative paths and the default project resolve here. */
+    directory: string;
+    /** The model the invoking session currently uses, if the host can tell. */
+    sessionModel: () => Promise<OpencodeModelRef | null>;
+    notify?: (message: string) => void;
+}
+/** Capture and profile calls routed through OpenCode's structured-output sessions. */
+export declare function createOpencodeImportModels(ref: OpencodeModelRef, directory: string): Promise<Required<HistoryImportModels>>;
+/** Parse, run, and describe one import; always resolves to text for the session. */
+export declare function runOpencodeImportCommand(input: OpencodeImportCommandInput): Promise<string>;
+/** The model of the session's latest user message, from the V1 message list. */
+export declare function latestUserMessageModel(client: {
+    session: {
+        messages: (input: {
+            path: {
+                id: string;
+            };
+        }) => Promise<{
+            data?: any;
+        }>;
+    };
+}, sessionID: string): Promise<OpencodeModelRef | null>;

package/dist/adapters/opencode/import-command.js

@@ -0,0 +1,154 @@
+import { CONFIG, isConfigured } from "../../config.js";
+import { buildBoundedSummaryPrompt } from "../../core/capture-context.js";
+import { historyImportUsage, importNeedsModel, parseHistoryImportArgs, tokenizeImportArgs, } from "../../importer/import-args.js";
+import { formatHistoryImportReport, summarizeHistoryImportReport, runHistoryImport, } from "../../importer/run-import.js";
+import { loadOpencodeProvider } from "../../services/ai/opencode-provider-loader.js";
+import { memoryClient } from "../../services/client.js";
+import { log } from "../../services/logger.js";
+/**
+ * OpenCode command surface for the historical-session importer:
+ *
+ *   /memory-import-opencode-history --dry-run
+ *   /memory-import-opencode-history
+ *
+ * The same options and model rules as Pi's command: this session's model by
+ * default, or `--model provider/id` from OpenCode's connected providers. Model
+ * calls go through OpenCode's own sign-in, so no omms API key is involved.
+ */
+export const OPENCODE_IMPORT_COMMAND = "memory-import-opencode-history";
+export const OPENCODE_IMPORT_DESCRIPTION = "Import historical OpenCode sessions into the shared memory store (try --dry-run first)";
+export const OPENCODE_IMPORT_USAGE = historyImportUsage("opencode", "session");
+let importCommandRunning = false;
+function splitModel(value) {
+    const separator = value.indexOf("/");
+    return { providerID: value.slice(0, separator), modelID: value.slice(separator + 1) };
+}
+/** Capture and profile calls routed through OpenCode's structured-output sessions. */
+export async function createOpencodeImportModels(ref, directory) {
+    const { getV2Client, generateStructuredOutput } = await loadOpencodeProvider();
+    const client = getV2Client();
+    if (!client)
+        throw new Error("the OpenCode client is not ready; retry in a moment");
+    const { z } = await import("zod");
+    const { buildCaptureSystemPrompt, createUserProfileAnalysisSchema, parseCaptureSummary } = await import("../../core/extraction.js");
+    const { detectLanguage, getLanguageName } = await import("../../services/language-detector.js");
+    const captureSchema = z.object({
+        summary: z.string().optional(),
+        type: z.string(),
+        tags: z.array(z.string()).optional(),
+    });
+    const capture = {
+        async summarize(request) {
+            const target = CONFIG.autoCaptureLanguage && CONFIG.autoCaptureLanguage !== "auto"
+                ? CONFIG.autoCaptureLanguage
+                : detectLanguage(request.userPrompt);
+            const systemPrompt = buildCaptureSystemPrompt(getLanguageName(target));
+            const result = await generateStructuredOutput({
+                client,
+                ...ref,
+                systemPrompt,
+                userPrompt: buildBoundedSummaryPrompt(request.context, systemPrompt, z.toJSONSchema(captureSchema)),
+                schema: captureSchema,
+                directory,
+            });
+            const parsed = parseCaptureSummary(JSON.stringify(result));
+            if (!parsed)
+                throw new Error("History capture returned an invalid summary");
+            return parsed;
+        },
+    };
+    const profileSchema = createUserProfileAnalysisSchema(z);
+    const profile = {
+        provider: ref.providerID,
+        modelId: ref.modelID,
+        async complete(systemPrompt, userPrompt) {
+            const result = await generateStructuredOutput({
+                client,
+                ...ref,
+                systemPrompt,
+                userPrompt,
+                schema: profileSchema,
+                directory,
+            });
+            return JSON.stringify(result);
+        },
+    };
+    return { capture, profile };
+}
+/** Parse, run, and describe one import; always resolves to text for the session. */
+export async function runOpencodeImportCommand(input) {
+    const name = OPENCODE_IMPORT_COMMAND;
+    // Some hosts pass the command name through with its arguments.
+    const argsText = input.argsText.trim().replace(new RegExp(`^/?${name}(\\s|$)`), "");
+    const parsed = parseHistoryImportArgs(tokenizeImportArgs(argsText), {
+        host: "opencode",
+        surface: "session",
+    });
+    if (parsed.help)
+        return OPENCODE_IMPORT_USAGE;
+    if (parsed.errors.length > 0)
+        return `${name}: ${parsed.errors.join("; ")}`;
+    if (!isConfigured())
+        return `${name}: memory system not configured`;
+    if (importCommandRunning)
+        return `${name}: an import is already running`;
+    importCommandRunning = true;
+    try {
+        let ref = null;
+        if (parsed.model || importNeedsModel(parsed)) {
+            ref = parsed.model ? splitModel(parsed.model) : await input.sessionModel();
+            if (!ref)
+                return `${name}: this session has no model yet; pass --model provider/id`;
+            const { isProviderConnected } = await loadOpencodeProvider();
+            if (!isProviderConnected(ref.providerID)) {
+                return `${name}: OpenCode provider "${ref.providerID}" is not connected`;
+            }
+        }
+        const models = ref && !parsed.dryRun ? await createOpencodeImportModels(ref, input.directory) : {};
+        if (!parsed.dryRun) {
+            try {
+                await memoryClient.warmup();
+            }
+            catch (error) {
+                log("OpenCode import: memory warmup failed", { error: String(error) });
+            }
+        }
+        let lastProgress = 0;
+        const report = await runHistoryImport("opencode", parsed, {
+            cwd: input.directory,
+            models,
+            onProgress: (processed, total, promptPreview) => {
+                if (processed - lastProgress >= 25 || processed === total) {
+                    lastProgress = processed;
+                    input.notify?.(`OpenCode import: ${processed}/${total} units (${promptPreview})`);
+                }
+            },
+        });
+        log("OpenCode history import report", summarizeHistoryImportReport(report));
+        return formatHistoryImportReport("opencode", report, ref ? `${ref.providerID}/${ref.modelID}` : undefined);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        log("OpenCode history import failed", { error: message });
+        return `${name} failed: ${message}`;
+    }
+    finally {
+        importCommandRunning = false;
+    }
+}
+/** The model of the session's latest user message, from the V1 message list. */
+export async function latestUserMessageModel(client, sessionID) {
+    try {
+        const messages = (await client.session.messages({ path: { id: sessionID } })).data ?? [];
+        for (let i = messages.length - 1; i >= 0; i--) {
+            const model = messages[i]?.info?.role === "user" ? messages[i].info.model : undefined;
+            if (model?.providerID && model?.modelID) {
+                return { providerID: model.providerID, modelID: model.modelID };
+            }
+        }
+    }
+    catch (error) {
+        log("OpenCode import: could not read the session model", { error: String(error) });
+    }
+    return null;
+}

package/dist/adapters/pi/extension.js

@@ -5,8 +5,7 @@ import { getLanguageName } from "../../services/language-detector.js";
 import { log } from "../../services/logger.js";
 import { memoryClient } from "../../services/client.js";
 import { capturePiSettledWorkUnit, createPiCaptureState } from "./capture.js";
-import { createPiCaptureProvider } from "./provider.js";
-import { resolveModelFromContext } from "./provider.js";
+import { createPiLiveModels } from "./live-model.js";
 import { registerPiHistoryImportCommand } from "./import-command.js";
 import { performPiProfileLearning } from "./profile.js";
 import { buildRetrievalSection, wrapRetrievalSection } from "../../core/retrieval.js";
@@ -93,7 +92,6 @@ export default function ommsPiExtension(pi) {
         const level = notification.variant === "success" ? "info" : notification.variant;
         ctx.ui.notify(`${notification.title}: ${notification.message}`, level);
     };
-    const resolveModel = (ctx) => resolveModelFromContext(ctx);
     pi.on("session_start", async (_event, ctx) => {
         const status = startStatus(ctx, "warming");
         try {
@@ -148,7 +146,8 @@ export default function ommsPiExtension(pi) {
         const status = startStatus(ctx, "capturing");
         try {
             const entries = toSessionEntries(ctx.sessionManager.getBranch());
-            const provider = createPiCaptureProvider(() => resolveModel(ctx));
+            const liveModels = createPiLiveModels(ctx, notify(ctx));
+            const provider = liveModels.capture;
             const captureResult = await capturePiSettledWorkUnit({
                 sessionId: ctx.sessionManager.getSessionId(),
                 directory: ctx.cwd,
@@ -172,7 +171,7 @@ export default function ommsPiExtension(pi) {
                     await performPiProfileLearning({
                         directory: ctx.cwd,
                         prompts: batch,
-                        resolveModel: () => resolveModel(ctx),
+                        resolveProfileModel: liveModels.profile,
                         notify: notify(ctx),
                     });
                 }

package/dist/adapters/pi/import-command.d.ts

@@ -1,29 +1,17 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { type ImportPathMap } from "../../importer/importer.js";
+import { type HistoryImportArgs } from "../../importer/import-args.js";
 /**
  * Pi command surface for the historical-session importer:
  *
  *   /memory-import-pi-history --dry-run
  *   /memory-import-pi-history
  *
- * Runs over the shared importer service. Extraction inherits the active Pi
- * model (or the piProvider/piModel override). Source session files are only
- * ever read.
+ * Runs over the shared importer service with the same options as the OpenCode
+ * command and the CLI. Extraction uses this session's current model, or
+ * `--model provider/id` from Pi's signed-in models. Source session files are
+ * only ever read.
  */
 export declare const PI_IMPORT_COMMAND = "memory-import-pi-history";
-export declare const PI_IMPORT_USAGE = "Usage: /memory-import-pi-history [options]\n\nOptions:\n  --dry-run                    Discover, map, and report; write nothing\n  --force                      Reprocess units with terminal ledger states\n  --scope=current-project      Import only sessions from this project (default)\n  --scope=all-projects         Import every discovered session\n  --session=<id-or-file>       Import one exact session\n  --since=<date>               Only work units at/after this time\n  --until=<date>               Only work units at/before this time\n  --max-sessions=<n>           Limit discovery to the oldest n sessions\n  --map=<oldPath>=<newPath>    Remap a recorded cwd that no longer exists\n  --root=<dir>                 Session root (default ~/.pi/agent/sessions)\n\nDates accept ISO 8601 (2026-01-01, 2026-01-01T10:00:00Z) or epoch\nmilliseconds. --since/--until filter on each work unit's user-entry\ntimestamp, inclusive. Unresolvable recorded cwds are skipped and listed\nin the report; use --map to import them into an existing directory.";
-export interface ParsedImportArgs {
-    dryRun: boolean;
-    force: boolean;
-    scope: "current-project" | "all-projects";
-    session?: string;
-    since?: number;
-    until?: number;
-    maxSessions?: number;
-    root?: string;
-    pathMaps: ImportPathMap[];
-    help: boolean;
-    errors: string[];
-}
-export declare function parseImportArgs(raw: string): ParsedImportArgs;
+export declare const PI_IMPORT_USAGE: string;
+export declare function parseImportArgs(raw: string): HistoryImportArgs;
 export declare function registerPiHistoryImportCommand(pi: ExtensionAPI, getExtensionContext: () => ExtensionContext | null): void;

package/dist/adapters/pi/import-command.js

@@ -1,149 +1,25 @@
-import { initConfigWithLegacyMigration, isConfigured } from "../../config.js";
+import { initConfig, initConfigWithLegacyMigration, isConfigured } from "../../config.js";
 import { log } from "../../services/logger.js";
 import { memoryClient } from "../../services/client.js";
-import { importPiHistory, } from "../../importer/importer.js";
-import { loadPiSessionForImport } from "../../importer/session-loader.js";
-import { createPiCaptureProvider, resolveModelFromContext } from "./provider.js";
+import { historyImportUsage, importNeedsModel, parseHistoryImportArgs, tokenizeImportArgs, } from "../../importer/import-args.js";
+import { formatHistoryImportReport, summarizeHistoryImportReport, runHistoryImport, } from "../../importer/run-import.js";
+import { createPiCaptureProvider, resolveImportModel } from "./provider.js";
+import { adaptPiProfileModel } from "./profile.js";
 /**
  * Pi command surface for the historical-session importer:
  *
  *   /memory-import-pi-history --dry-run
  *   /memory-import-pi-history
  *
- * Runs over the shared importer service. Extraction inherits the active Pi
- * model (or the piProvider/piModel override). Source session files are only
- * ever read.
+ * Runs over the shared importer service with the same options as the OpenCode
+ * command and the CLI. Extraction uses this session's current model, or
+ * `--model provider/id` from Pi's signed-in models. Source session files are
+ * only ever read.
  */
 export const PI_IMPORT_COMMAND = "memory-import-pi-history";
-export const PI_IMPORT_USAGE = `Usage: /${PI_IMPORT_COMMAND} [options]
-
-Options:
-  --dry-run                    Discover, map, and report; write nothing
-  --force                      Reprocess units with terminal ledger states
-  --scope=current-project      Import only sessions from this project (default)
-  --scope=all-projects         Import every discovered session
-  --session=<id-or-file>       Import one exact session
-  --since=<date>               Only work units at/after this time
-  --until=<date>               Only work units at/before this time
-  --max-sessions=<n>           Limit discovery to the oldest n sessions
-  --map=<oldPath>=<newPath>    Remap a recorded cwd that no longer exists
-  --root=<dir>                 Session root (default ~/.pi/agent/sessions)
-
-Dates accept ISO 8601 (2026-01-01, 2026-01-01T10:00:00Z) or epoch
-milliseconds. --since/--until filter on each work unit's user-entry
-timestamp, inclusive. Unresolvable recorded cwds are skipped and listed
-in the report; use --map to import them into an existing directory.`;
-function parseTimestamp(raw) {
-    if (!raw)
-        return undefined;
-    if (/^\d+$/.test(raw))
-        return Number(raw);
-    const parsed = Date.parse(raw);
-    return Number.isNaN(parsed) ? undefined : parsed;
-}
+export const PI_IMPORT_USAGE = historyImportUsage("pi", "session");
 export function parseImportArgs(raw) {
-    const result = {
-        dryRun: false,
-        force: false,
-        scope: "current-project",
-        pathMaps: [],
-        help: false,
-        errors: [],
-    };
-    for (const token of raw.trim().split(/\s+/).filter(Boolean)) {
-        if (token === "--help" || token === "-h") {
-            result.help = true;
-            continue;
-        }
-        if (token === "--dry-run") {
-            result.dryRun = true;
-            continue;
-        }
-        if (token === "--force") {
-            result.force = true;
-            continue;
-        }
-        const equals = token.indexOf("=");
-        const flag = equals === -1 ? token : token.slice(0, equals);
-        const value = equals === -1 ? "" : token.slice(equals + 1);
-        switch (flag) {
-            case "--scope":
-                if (value === "current-project" || value === "all-projects") {
-                    result.scope = value;
-                }
-                else {
-                    result.errors.push(`--scope must be current-project or all-projects, got "${value}"`);
-                }
-                break;
-            case "--session":
-                if (value)
-                    result.session = value;
-                else
-                    result.errors.push("--session requires a value");
-                break;
-            case "--since":
-                result.since = parseTimestamp(value);
-                if (result.since === undefined)
-                    result.errors.push(`--since is not a valid date: "${value}"`);
-                break;
-            case "--until":
-                result.until = parseTimestamp(value);
-                if (result.until === undefined)
-                    result.errors.push(`--until is not a valid date: "${value}"`);
-                break;
-            case "--max-sessions": {
-                const parsed = Number(value);
-                if (Number.isInteger(parsed) && parsed >= 0)
-                    result.maxSessions = parsed;
-                else
-                    result.errors.push(`--max-sessions must be a non-negative integer, got "${value}"`);
-                break;
-            }
-            case "--root":
-                if (value)
-                    result.root = value;
-                else
-                    result.errors.push("--root requires a value");
-                break;
-            case "--map": {
-                const separator = value.indexOf("=");
-                if (separator > 0 && separator < value.length - 1) {
-                    result.pathMaps.push({
-                        from: value.slice(0, separator),
-                        to: value.slice(separator + 1),
-                    });
-                }
-                else {
-                    result.errors.push(`--map must be <oldPath>=<newPath>, got "${value}"`);
-                }
-                break;
-            }
-            default:
-                result.errors.push(`Unknown option: "${token}"`);
-        }
-    }
-    return result;
-}
-function formatReport(report) {
-    const lines = [
-        `Pi history import ${report.dryRun ? "(dry-run)" : ""}`.trim(),
-        `  sessions: ${report.sessionsLoaded} loaded, ${report.sessionsFilteredOut} filtered, ` +
-            `${report.sessionsUnrecognized} unrecognized, ` +
-            `${report.unresolvableSessions.length} unresolvable cwd`,
-        `  work units: ${report.unitsTotal} total, ` +
-            (report.dryRun
-                ? `${report.unitsWouldImport} would import`
-                : `${report.unitsImported} imported, ${report.unitsSkipped} skipped, ` +
-                    `${report.unitsFailed} failed`) +
-            `, ${report.unitsAlreadyHandled} already handled`,
-    ];
-    for (const project of report.projects) {
-        lines.push(`  project ${project.tag} (${project.sessions} sessions, ${project.units} units) -> ${project.directory}`);
-    }
-    if (report.loadErrors.length > 0) {
-        lines.push(`  load errors: ${report.loadErrors.length}`);
-    }
-    return lines.join("\n");
+    return parseHistoryImportArgs(tokenizeImportArgs(raw), { host: "pi", surface: "session" });
 }
 let importCommandRunning = false;
 export function registerPiHistoryImportCommand(pi, getExtensionContext) {
@@ -177,47 +53,56 @@ export function registerPiHistoryImportCommand(pi, getExtensionContext) {
                 notify("memory-import-pi-history: an import is already running");
                 return;
             }
-            // Import against the current session's project and configuration.
-            initConfigWithLegacyMigration(ctx.cwd);
+            // A dry-run must not trigger the one-time storage migration.
+            if (parsed.dryRun)
+                initConfig(ctx.cwd);
+            else
+                initConfigWithLegacyMigration(ctx.cwd);
             if (typeof commandCtx.waitForIdle === "function") {
                 await commandCtx.waitForIdle();
             }
+            // The command context carries the live session model; fall back to the
+            // last session context for hosts whose command context lacks a registry.
+            const modelCtx = commandCtx?.modelRegistry ? commandCtx : ctx;
+            const selectedModel = parsed.model || importNeedsModel(parsed)
+                ? resolveImportModel(modelCtx, parsed.model)
+                : null;
+            if ((parsed.model || importNeedsModel(parsed)) && !selectedModel) {
+                notify(parsed.model
+                    ? `memory-import-pi-history: model not found: ${parsed.model}`
+                    : "memory-import-pi-history: this session has no model; pass --model provider/id");
+                return;
+            }
             importCommandRunning = true;
             try {
                 // Best-effort warmup so failures surface as per-unit errors instead of
                 // every unit failing on embedding initialisation.
-                try {
-                    await memoryClient.warmup();
-                }
-                catch (error) {
-                    log("Pi import: memory warmup failed", { error: String(error) });
+                if (!parsed.dryRun) {
+                    try {
+                        await memoryClient.warmup();
+                    }
+                    catch (error) {
+                        log("Pi import: memory warmup failed", { error: String(error) });
+                    }
                 }
-                const filters = {
-                    scope: parsed.scope,
-                    currentDirectory: ctx.cwd,
-                    ...(parsed.session !== undefined ? { session: parsed.session } : {}),
-                    ...(parsed.since !== undefined ? { since: parsed.since } : {}),
-                    ...(parsed.until !== undefined ? { until: parsed.until } : {}),
-                    ...(parsed.maxSessions !== undefined ? { maxSessions: parsed.maxSessions } : {}),
-                    ...(parsed.root !== undefined ? { root: parsed.root } : {}),
-                    ...(parsed.force ? { force: true } : {}),
-                    ...(parsed.dryRun ? { dryRun: true } : {}),
-                    pathMaps: parsed.pathMaps,
-                };
-                const provider = createPiCaptureProvider(() => resolveModelFromContext(ctx));
                 let lastProgressNotify = 0;
-                const report = await importPiHistory({
-                    loadSession: loadPiSessionForImport,
-                    provider,
+                const report = await runHistoryImport("pi", parsed, {
+                    cwd: ctx.cwd,
+                    models: selectedModel && !parsed.dryRun
+                        ? {
+                            capture: createPiCaptureProvider(() => selectedModel),
+                            profile: adaptPiProfileModel(selectedModel),
+                        }
+                        : {},
                     onProgress: (processed, total, promptPreview) => {
                         if (processed - lastProgressNotify >= 25 || processed === total) {
                             lastProgressNotify = processed;
                             notify(`Pi import: ${processed}/${total} units (${promptPreview})`);
                         }
                     },
-                }, filters);
-                log("Pi history import report", { report });
-                notify(formatReport(report));
+                });
+                log("Pi history import report", summarizeHistoryImportReport(report));
+                notify(formatHistoryImportReport("pi", report, selectedModel ? `${selectedModel.provider}/${selectedModel.modelId}` : undefined));
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);

package/dist/adapters/pi/live-model.d.ts

@@ -0,0 +1,17 @@
+import type { AutoCaptureNotification, CaptureSummaryProvider } from "../../core/host.js";
+import type { ModelPort } from "../../core/profile-analysis.js";
+import { type PiModelContext } from "./provider.js";
+/**
+ * Pi live capture and profile learning, by the same rule as OpenCode:
+ * `piProvider`/`piModel` ("inherit" = this session's model), else the
+ * external API (`memoryModel`/`memoryApiUrl`/`memoryApiKey`), else this
+ * session's model. A failing Pi model falls back to the external API when it
+ * is configured, as a failing OpenCode model does.
+ */
+export interface PiLiveModels {
+    capture: CaptureSummaryProvider;
+    profile: () => ModelPort | null;
+}
+type Notify = (notification: AutoCaptureNotification) => Promise<void> | void;
+export declare function createPiLiveModels(ctx: PiModelContext, notify?: Notify): PiLiveModels;
+export {};