om-memory-system 3.2.0-next.9 → 3.3.0-next.18

package/dist/importer/run-import.js

@@ -18,6 +18,15 @@ export async function runHistoryImport(host, args, run) {
             ...(args.since !== undefined ? { since: args.since } : {}),
             ...(args.until !== undefined ? { until: args.until } : {}),
             ...(args.session ? { session: args.session } : {}),
+            ...(run.selection
+                ? {
+                    selectionKeys: run.selection.keys,
+                    cutoff: run.selection.cutoff,
+                    ...(run.selection.snapshotKey
+                        ? { snapshot: { key: run.selection.snapshotKey, mode: "reuse" } }
+                        : {}),
+                }
+                : {}),
             ...(project ? { project } : {}),
             ...(args.maxSessions ? { maxSessions: args.maxSessions } : {}),
             ...(args.profileBatch ? { profileBatch: args.profileBatch } : {}),
@@ -25,6 +34,8 @@ export async function runHistoryImport(host, args, run) {
             force: args.force,
             skipMemories: args.skipMemories,
             skipProfile: args.skipProfile,
+            ...(run.signal ? { signal: run.signal } : {}),
+            ...(run.onProgress ? { onProgress: run.onProgress } : {}),
             ...(run.models.capture ? { provider: capture } : {}),
             ...(run.models.profile ? { profileModel: run.models.profile } : {}),
         });
@@ -35,6 +46,7 @@ export async function runHistoryImport(host, args, run) {
         loadSession: loadPiSessionForImport,
         provider: capture,
         ...(run.onProgress ? { onProgress: run.onProgress } : {}),
+        ...(run.signal ? { signal: run.signal } : {}),
         ...(!args.skipProfile
             ? {
                 profile: {
@@ -47,6 +59,7 @@ export async function runHistoryImport(host, args, run) {
         scope: args.scope,
         currentDirectory: project ?? run.cwd,
         ...(args.session ? { session: args.session } : {}),
+        ...(run.selection ? { selectionKeys: run.selection.keys, cutoff: run.selection.cutoff } : {}),
         ...(args.since !== undefined ? { since: args.since } : {}),
         ...(args.until !== undefined ? { until: args.until } : {}),
         ...(args.maxSessions ? { maxSessions: args.maxSessions } : {}),
@@ -79,6 +92,12 @@ export function formatHistoryImportReport(host, report, model) {
     for (const unresolvable of report.unresolvableSessions) {
         lines.push(`  unresolved ${unresolvable.cwd ?? "(no cwd)"}: ${unresolvable.file} (use --map)`);
     }
+    if (report.unitsUntimed) {
+        lines.push(`  turns without a timestamp: ${report.unitsUntimed} (date limits cannot exclude them)`);
+    }
+    if (report.unitsHeldBack) {
+        lines.push(`  newer turns held back: ${report.unitsHeldBack}; list the sessions again and import to include them`);
+    }
     if (report.loadErrors.length > 0)
         lines.push(`  load errors: ${report.loadErrors.length}`);
     if (report.profile) {
@@ -103,6 +122,8 @@ export function summarizeHistoryImportReport(report) {
         unitsSkipped: report.unitsSkipped,
         unitsFailed: report.unitsFailed,
         unitsAlreadyHandled: report.unitsAlreadyHandled,
+        unitsHeldBack: report.unitsHeldBack ?? 0,
+        unitsUntimed: report.unitsUntimed ?? 0,
         projects: report.projects.length,
         unresolved: (report.unresolvedProjects?.length ?? 0) + report.unresolvableSessions.length,
         loadErrors: report.loadErrors.length,

package/dist/importer/settings-health.d.ts

@@ -0,0 +1,24 @@
+export { safeHealthError } from "../services/safe-health-error.js";
+export type HealthRow = {
+    check: string;
+    status: "pass" | "warn" | "fail";
+    reason: string;
+};
+export declare function captureFailureHealth(byModel: Array<{
+    total: number;
+    failed: number;
+}>, byReason: Array<{
+    reason: string;
+    count: number;
+}>): HealthRow;
+export interface HealthInput {
+    directory: string;
+    host: string;
+    authEnabled: boolean;
+    apiTokenSet: boolean;
+    testModels: boolean;
+}
+/** Run checks independently so a failed dependency cannot hide the remaining checks. */
+export declare function runSettingsHealth(input: HealthInput): Promise<{
+    checks: HealthRow[];
+}>;

package/dist/importer/settings-health.js

@@ -0,0 +1,127 @@
+import { CONFIG } from "../config.js";
+import { getAutoCaptureProviderStatus, resolvePiLiveModel, } from "../services/ai/live-model-choice.js";
+import { isLoopbackHost } from "../services/web-api-auth.js";
+import { safeHealthError } from "../services/safe-health-error.js";
+export { safeHealthError } from "../services/safe-health-error.js";
+const PROBE = "Reply with a short acknowledgement.";
+export function captureFailureHealth(byModel, byReason) {
+    const total = byModel.reduce((count, row) => count + row.total, 0);
+    const failed = byModel.reduce((count, row) => count + row.failed, 0);
+    const reason = [...byReason].sort((a, b) => b.count - a.count)[0]?.reason;
+    return {
+        check: "Capture failures (24 hours)",
+        status: total > 0 && failed / total > 0.2 ? "warn" : "pass",
+        reason: total
+            ? `${failed}/${total} failed${reason ? `; most common reason: ${reason}` : ""}`
+            : "No recent attempts",
+    };
+}
+/** Run checks independently so a failed dependency cannot hide the remaining checks. */
+export async function runSettingsHealth(input) {
+    const checks = [];
+    async function check(name, action) {
+        try {
+            checks.push({ check: name, status: "pass", reason: await action() });
+        }
+        catch (error) {
+            checks.push({
+                check: name,
+                status: "fail",
+                reason: safeHealthError(error, [
+                    CONFIG.memoryApiKey,
+                    CONFIG.embeddingApiKey,
+                    CONFIG.webServerApiToken,
+                ]),
+            });
+        }
+    }
+    await check("Config files", async () => {
+        const { getSettingsSnapshot } = await import("../services/settings-snapshot.js");
+        getSettingsSnapshot(input.directory);
+        return "Global and project config parsed";
+    });
+    await check("Memory store", async () => {
+        const { tursoConnectionManager } = await import("../services/turso/connection-manager.js");
+        const { join } = await import("node:path");
+        const db = await tursoConnectionManager.getConnection(join(CONFIG.storagePath, "user-prompts.db"));
+        await db.all("SELECT 1");
+        return "Store opened and queried";
+    });
+    await check("Embedding", async () => {
+        const { embeddingService } = await import("../services/embedding.js");
+        const result = await embeddingService.embedWithTimeout("OMMS health check", { task: "query" });
+        if (!result.length)
+            throw new Error("Embedding returned no values");
+        return "Test text embedded";
+    });
+    const secure = isLoopbackHost(input.host) || input.authEnabled || input.apiTokenSet;
+    checks.push({
+        check: "Web binding",
+        status: secure ? "pass" : "fail",
+        reason: secure
+            ? "Binding and access settings are safe"
+            : "Network binding requires an API token or Basic Auth",
+    });
+    const opencode = getAutoCaptureProviderStatus(CONFIG);
+    checks.push({
+        check: "OpenCode model",
+        status: opencode.ready ? "pass" : "fail",
+        reason: opencode.ready ? `Resolved: ${opencode.mode}` : opencode.issues.join("; "),
+    });
+    const pi = resolvePiLiveModel(CONFIG);
+    checks.push({
+        check: "Pi model",
+        status: pi.kind === "unready" ? "fail" : "pass",
+        reason: pi.kind === "unready" ? pi.issues.join("; ") : `Resolved: ${pi.kind}`,
+    });
+    try {
+        const { queryCaptureAttempts } = await import("../services/capture-attempt-store.js");
+        const { byModel, byReason } = await queryCaptureAttempts(Date.now() - 86400000, Date.now());
+        checks.push(captureFailureHealth(byModel, byReason.map((row) => ({ count: row.count, reason: String(row.reason) }))));
+    }
+    catch (error) {
+        checks.push({
+            check: "Capture failures (24 hours)",
+            status: "fail",
+            reason: safeHealthError(error, [CONFIG.memoryApiKey]),
+        });
+    }
+    if (input.testModels) {
+        await check("OpenCode model test", async () => {
+            const { resolveOpencodeHostModel } = await import("../services/ai/live-model-choice.js");
+            const ref = resolveOpencodeHostModel(CONFIG);
+            if (ref?.modelID === "inherit")
+                throw new Error("A session model needs an active session to test");
+            const capture = ref
+                ? (await (await import("../services/ai/opencode-import-models.js")).createOpencodeImportModels(ref, input.directory)).capture
+                : (await import("./model-selection.js")).selectImportModel({}).capture;
+            await capture.summarize({
+                userPrompt: PROBE,
+                context: PROBE,
+                sessionId: "health",
+                projectDirectory: input.directory,
+            });
+            return "Fixed prompt completed";
+        });
+        if (pi.kind === "manual") {
+            await check("Pi model test", async () => {
+                const { selectImportModel } = await import("./model-selection.js");
+                await selectImportModel({}).capture.summarize({
+                    userPrompt: PROBE,
+                    context: PROBE,
+                    sessionId: "health",
+                    projectDirectory: input.directory,
+                });
+                return "Fixed prompt completed";
+            });
+        }
+        else {
+            checks.push({
+                check: "Pi model test",
+                status: "warn",
+                reason: "Pi models need an active Pi session to test",
+            });
+        }
+    }
+    return { checks };
+}

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

@@ -0,0 +1,8 @@
+/**
+ * The import pieces the web server loads for the Settings page, behind one
+ * dynamic import so the server's boundary with the importer stays small.
+ */
+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";

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

@@ -0,0 +1,8 @@
+/**
+ * The import pieces the web server loads for the Settings page, behind one
+ * dynamic import so the server's boundary with the importer stays small.
+ */
+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";

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

@@ -0,0 +1,53 @@
+import { type ImportHost, type WebImportOptions } from "./import-args.js";
+import { type ImportReadiness } from "./import-readiness.js";
+import { resolveImportSelection, type ImportSelection } from "./import-sessions.js";
+import { runHistoryImport, summarizeHistoryImportReport } from "./run-import.js";
+type JobState = "running" | "cancelling" | "cancelled" | "done" | "failed";
+type Job = {
+    id: string;
+    host: ImportHost;
+    dryRun: boolean;
+    state: JobState;
+    /** Sessions in the resolved selection. */
+    sessions: number;
+    processed: number;
+    total: number;
+    report?: string;
+    summary?: ReturnType<typeof summarizeHistoryImportReport>;
+    error?: string;
+};
+type Request = {
+    host: ImportHost;
+    source: unknown;
+    selection: ImportSelection;
+    options: WebImportOptions;
+    modelChoice?: string;
+};
+type Runner = typeof runHistoryImport;
+/** A refused job; `status` is the HTTP status the page receives. */
+export declare class ImportJobError extends Error {
+    readonly status: number;
+    constructor(message: string, status?: number);
+}
+export declare function validateWebImportRequest(value: unknown): Request;
+export interface ImportJobDeps {
+    runner?: Runner;
+    resolveSelection?: typeof resolveImportSelection;
+    readiness?: () => Promise<ImportReadiness>;
+}
+/** One in-memory slot per web server, shared by previews and imports. */
+export declare class SettingsImportJobs {
+    private job?;
+    private controller?;
+    private starting;
+    private readonly runner;
+    private readonly resolveSelection;
+    private readonly readiness;
+    constructor(deps?: ImportJobDeps);
+    current(): Job | null;
+    private busy;
+    start(request: unknown, directory: string): Promise<Job>;
+    private begin;
+    cancel(): Job;
+}
+export {};

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

@@ -0,0 +1,227 @@
+import { randomUUID } from "node:crypto";
+import { isAbsolute } from "node:path";
+import { CONFIG } from "../config.js";
+import { importNeedsModel, parseHistoryImportArgs, webImportTokens, } from "./import-args.js";
+import { importBlockedReason, importReadiness } from "./import-readiness.js";
+import { resolveImportSelection, validateImportSelection, } from "./import-sessions.js";
+import { importSourceKey } from "./import-sources.js";
+import { formatHistoryImportReport, runHistoryImport, summarizeHistoryImportReport, } from "./run-import.js";
+import { safeHealthError } from "./settings-health.js";
+/** A refused job; `status` is the HTTP status the page receives. */
+export class ImportJobError extends Error {
+    status;
+    constructor(message, status = 400) {
+        super(message);
+        this.status = status;
+        this.name = "ImportJobError";
+    }
+}
+// Selection replaces --session and --max-sessions; the source comes as a token.
+const fields = new Set([
+    "dryRun",
+    "force",
+    "skipMemories",
+    "skipProfile",
+    "scope",
+    "project",
+    "since",
+    "until",
+    "profileBatch",
+    "pathMaps",
+]);
+export function validateWebImportRequest(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("Invalid import request");
+    const input = value;
+    if (input.host !== "pi" && input.host !== "opencode")
+        throw new Error("Choose Pi or OpenCode");
+    if (!input.options || typeof input.options !== "object" || Array.isArray(input.options))
+        throw new Error("Invalid import options");
+    const options = input.options;
+    for (const [key, option] of Object.entries(options)) {
+        if (!fields.has(key))
+            throw new Error(`Unknown import option: ${key}`);
+        if (["dryRun", "force", "skipMemories", "skipProfile"].includes(key)) {
+            if (typeof option !== "boolean")
+                throw new Error(`Invalid ${key}`);
+        }
+        else if (key === "pathMaps") {
+            if (!Array.isArray(option) ||
+                !option.every((map) => map &&
+                    typeof map === "object" &&
+                    typeof map.from === "string" &&
+                    typeof map.to === "string"))
+                throw new Error("Invalid directory maps");
+        }
+        else if (key === "profileBatch") {
+            if (!Number.isSafeInteger(option) || option < 1)
+                throw new Error(`Invalid ${key}`);
+        }
+        else if (key === "since" || key === "until") {
+            if (typeof option !== "string" && typeof option !== "number")
+                throw new Error(`Invalid ${key}`);
+        }
+        else if (typeof option !== "string") {
+            throw new Error(`Invalid ${key}`);
+        }
+        else if (key === "project" && !isAbsolute(option)) {
+            throw new Error("The project must be an absolute path");
+        }
+    }
+    if (input.modelChoice !== undefined &&
+        (typeof input.modelChoice !== "string" ||
+            (input.modelChoice !== "external" && !/^[^/]+\/.+$/.test(input.modelChoice))))
+        throw new Error("Choose a signed-in provider/model or the external API");
+    return {
+        host: input.host,
+        source: input.source,
+        selection: validateImportSelection(input.selection),
+        options: options,
+        modelChoice: input.modelChoice,
+    };
+}
+/** One in-memory slot per web server, shared by previews and imports. */
+export class SettingsImportJobs {
+    job;
+    controller;
+    starting = false;
+    runner;
+    resolveSelection;
+    readiness;
+    constructor(deps = {}) {
+        this.runner = deps.runner ?? runHistoryImport;
+        this.resolveSelection = deps.resolveSelection ?? resolveImportSelection;
+        this.readiness = deps.readiness ?? (() => importReadiness());
+    }
+    current() {
+        return this.job ? { ...this.job } : null;
+    }
+    busy() {
+        return this.starting || this.job?.state === "running" || this.job?.state === "cancelling";
+    }
+    async start(request, directory) {
+        if (this.busy())
+            throw new ImportJobError("An import is already running", 409);
+        this.starting = true;
+        try {
+            return await this.begin(request, directory);
+        }
+        finally {
+            this.starting = false;
+        }
+    }
+    async begin(request, directory) {
+        let input;
+        try {
+            input = validateWebImportRequest(request);
+        }
+        catch (error) {
+            throw new ImportJobError(error.message);
+        }
+        const options = { ...input.options };
+        if (input.modelChoice && input.modelChoice !== "external")
+            options.model = input.modelChoice;
+        const args = parseHistoryImportArgs(webImportTokens(options, input.host), {
+            host: input.host,
+            surface: "web",
+        });
+        if (args.errors.length)
+            throw new ImportJobError(args.errors.join("; "));
+        const needsModel = importNeedsModel(args);
+        const blocked = importBlockedReason(await this.readiness(), {
+            host: input.host,
+            needsModel,
+            ...(input.modelChoice ? { modelChoice: input.modelChoice } : {}),
+        });
+        if (blocked)
+            throw new ImportJobError(blocked);
+        let selection;
+        try {
+            selection = await this.resolveSelection(input.source, input.selection, {
+                host: input.host,
+                scope: args.scope,
+                ...(args.project ? { project: args.project } : {}),
+                pathMaps: args.pathMaps,
+                cwd: directory,
+            });
+        }
+        catch (error) {
+            const status = error.status ?? 400;
+            throw new ImportJobError(error.message, status);
+        }
+        args.source = selection.identity.realPath;
+        const job = {
+            id: randomUUID(),
+            host: input.host,
+            dryRun: args.dryRun,
+            state: "running",
+            sessions: selection.keys.length,
+            processed: 0,
+            total: 0,
+        };
+        const controller = new AbortController();
+        this.job = job;
+        this.controller = controller;
+        void Promise.resolve().then(async () => {
+            try {
+                let models = {};
+                if (needsModel) {
+                    if (input.modelChoice === "external") {
+                        const { selectImportModel } = await import("./model-selection.js");
+                        const selected = selectImportModel({});
+                        models = { capture: selected.capture, profile: selected.profile };
+                    }
+                    else {
+                        const [providerID = "", ...id] = input.modelChoice.split("/");
+                        const { loadOpencodeProvider } = await import("../services/ai/opencode-provider-loader.js");
+                        const { isProviderConnected } = await loadOpencodeProvider();
+                        if (!isProviderConnected(providerID))
+                            throw new Error("OpenCode provider is not connected");
+                        const { createOpencodeImportModels } = await import("../services/ai/opencode-import-models.js");
+                        models = await createOpencodeImportModels({ providerID, modelID: id.join("/") }, directory);
+                    }
+                    const { memoryClient } = await import("../services/client.js");
+                    await memoryClient.warmup();
+                }
+                const report = await this.runner(input.host, args, {
+                    cwd: directory,
+                    models,
+                    signal: controller.signal,
+                    selection: {
+                        keys: selection.keys,
+                        cutoff: selection.cutoff,
+                        ...(selection.identity.kind === "opencode-db"
+                            ? { snapshotKey: importSourceKey(selection.identity) }
+                            : {}),
+                    },
+                    onProgress: (processed, total) => {
+                        job.processed = processed;
+                        job.total = total;
+                    },
+                });
+                job.summary = summarizeHistoryImportReport(report);
+                job.report = safeHealthError(formatHistoryImportReport(input.host, report, input.modelChoice), [CONFIG.memoryApiKey]);
+                job.state = controller.signal.aborted ? "cancelled" : "done";
+            }
+            catch (error) {
+                job.error = safeHealthError(error, [CONFIG.memoryApiKey, CONFIG.embeddingApiKey]);
+                job.state = controller.signal.aborted ? "cancelled" : "failed";
+            }
+            finally {
+                // A preview keeps the OpenCode copy for the import that follows; an import is the end.
+                if (!args.dryRun && selection.identity.kind === "opencode-db") {
+                    const { opencodeSnapshots } = await import("./opencode-snapshot.js");
+                    opencodeSnapshots.discard(importSourceKey(selection.identity));
+                }
+            }
+        });
+        return { ...job };
+    }
+    cancel() {
+        if (!this.job || !this.controller || this.job.state !== "running")
+            throw new Error("No running import");
+        this.controller.abort();
+        this.job.state = "cancelling";
+        return { ...this.job };
+    }
+}

package/dist/index.js

@@ -11,6 +11,7 @@ import { formatMemoriesForCompaction } from "./core/retrieval.js";
 import { performUserProfileLearning } from "./services/user-memory-learning.js";
 import { userPromptManager } from "./services/user-prompt/user-prompt-manager.js";
 import { startWebServer, WebServer } from "./services/web-server.js";
+import { pruneTraces } from "./services/capture-diagnostics.js";
 import { ensureTursoReady } from "./services/turso/ready.js";
 import { tursoConnectionManager } from "./services/turso/connection-manager.js";
 import { WebAuth } from "./services/web-auth.js";
@@ -180,6 +181,15 @@ function logAutoCaptureProviderStatus() {
 export const OmmsPlugin = async (ctx) => {
     const { directory } = ctx;
     initConfigWithLegacyMigration(directory);
+    // Runs even with tracing off, so turning it off does not leave old traces behind.
+    pruneTraces(CONFIG);
+    if (CONFIG.webServerAutoStart !== undefined && process.env.OMMS_DISABLE_WEB_AUTOSTART !== "1") {
+        void import("./services/web-autostart.js")
+            .then(({ reconcileWebAutostart }) => reconcileWebAutostart(CONFIG))
+            .catch((error) => log("OpenCode login item reconciliation failed", {
+            code: error instanceof Error ? error.name : "unknown",
+        }));
+    }
     logAutoCaptureProviderStatus();
     const tags = getTags(directory);
     const autoCaptureHost = createOpenCodeAutoCaptureHost(ctx);
@@ -200,9 +210,11 @@ export const OmmsPlugin = async (ctx) => {
     }
     await configureOpencodeHostTransport(ctx);
     (async () => {
+        let connected = [];
         try {
             const providerResult = await ctx.client.provider.list();
             if (providerResult.data?.connected) {
+                connected = providerResult.data.connected;
                 const { setConnectedProviders } = await loadOpencodeProvider();
                 setConnectedProviders(providerResult.data.connected);
                 log("opencode providers connected", {
@@ -219,6 +231,27 @@ export const OmmsPlugin = async (ctx) => {
         catch (error) {
             log("Failed to initialize opencode provider state", { error: String(error) });
         }
+        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;
+                },
+                notify: (message) => {
+                    void ctx.client.tui
+                        ?.showToast({
+                        body: { title: "Automatic import", message, variant: "info", duration: 5000 },
+                    })
+                        .catch(() => { });
+                },
+            }))
+                .catch((error) => log("OpenCode backfill failed", {
+                error: error instanceof Error ? error.message : String(error),
+            }));
+        }
     })();
     let tursoReadyForWeb = !isConfigured();
     if (CONFIG.webServerEnabled && isConfigured()) {
@@ -248,6 +281,7 @@ export const OmmsPlugin = async (ctx) => {
             username: CONFIG.webServerAuthUsername,
         });
         startWebServer({
+            directory,
             port: CONFIG.webServerPort,
             host: CONFIG.webServerHost,
             enabled: CONFIG.webServerEnabled,

package/dist/services/ai/live-model-choice.js

@@ -36,6 +36,9 @@ function getManualProviderStatus(config) {
 export function getAutoCaptureProviderStatus(config) {
     const hasOpencodeProvider = hasValue(config.opencodeProvider);
     const hasOpencodeModel = hasValue(config.opencodeModel);
+    if (config.opencodeModel?.trim() === "inherit") {
+        return { ready: true, mode: "session", issues: [] };
+    }
     if (hasOpencodeProvider && hasOpencodeModel) {
         return { ready: true, mode: "opencode", issues: [] };
     }
@@ -65,10 +68,10 @@ export function resolveOpencodeHostModel(config) {
 }
 /** Pi's live model, by the same rule as OpenCode's (`piProvider`/`piModel` in place of `opencode*`). */
 export function resolvePiLiveModel(config) {
+    if (config.piModel?.trim() === "inherit")
+        return { kind: "session" };
     if (hasValue(config.piProvider) && hasValue(config.piModel)) {
-        return config.piModel.trim() === "inherit"
-            ? { kind: "session" }
-            : { kind: "pi", provider: config.piProvider.trim(), model: config.piModel.trim() };
+        return { kind: "pi", provider: config.piProvider.trim(), model: config.piModel.trim() };
     }
     const manual = getManualProviderStatus(config);
     if (manual.ready)

package/dist/services/ai/opencode-import-models.d.ts

@@ -0,0 +1,11 @@
+import type { CaptureSummaryProvider } from "../../core/host.js";
+import type { ModelPort } from "../../core/profile-analysis.js";
+export interface OpencodeModelRef {
+    providerID: string;
+    modelID: string;
+}
+/** Capture and profile calls routed through OpenCode's structured-output sessions. */
+export declare function createOpencodeImportModels(ref: OpencodeModelRef, directory: string): Promise<{
+    capture: CaptureSummaryProvider;
+    profile: ModelPort;
+}>;