om-memory-system 3.4.0-next.23 → 3.4.0-next.27

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/{services/ai/internal-capture-sessions.d.ts → importer/opencode-internal-sessions.d.ts}

@@ -3,6 +3,3 @@ export declare const INTERNAL_CAPTURE_SESSION_TITLE = "omms capture";
 /** Every title omms has used for its own sessions (capture, profile learning, profile cleanup). */
 export declare const INTERNAL_CAPTURE_SESSION_TITLES: readonly ["omms capture", "opencode-mem capture", "omms profile cleanup", "opencode-mem profile cleanup"];
 export declare function isInternalCaptureSessionTitle(title: string | undefined | null): boolean;
-export declare function trackInternalCaptureSession(sessionID: string): void;
-export declare function untrackInternalCaptureSession(sessionID: string): void;
-export declare function isTrackedInternalCaptureSession(sessionID: string): boolean;

package/dist/importer/opencode-internal-sessions.js

@@ -0,0 +1,14 @@
+/** Title used for transient structured-output sessions (capture / profile learning). */
+export const INTERNAL_CAPTURE_SESSION_TITLE = "omms capture";
+/** Title used by opencode-mem builds; sessions left by older versions stay internal. */
+const LEGACY_INTERNAL_CAPTURE_SESSION_TITLE = "opencode-mem capture";
+/** Every title omms has used for its own sessions (capture, profile learning, profile cleanup). */
+export const INTERNAL_CAPTURE_SESSION_TITLES = [
+    INTERNAL_CAPTURE_SESSION_TITLE,
+    LEGACY_INTERNAL_CAPTURE_SESSION_TITLE,
+    "omms profile cleanup",
+    "opencode-mem profile cleanup",
+];
+export function isInternalCaptureSessionTitle(title) {
+    return (title === INTERNAL_CAPTURE_SESSION_TITLE || title === LEGACY_INTERNAL_CAPTURE_SESSION_TITLE);
+}

package/dist/importer/opencode-reader.js

@@ -3,7 +3,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { pathToFileURL } from "node:url";
 import { DatabaseSync } from "node:sqlite";
-import { INTERNAL_CAPTURE_SESSION_TITLES } from "../services/ai/internal-capture-sessions.js";
+import { INTERNAL_CAPTURE_SESSION_TITLES } from "./opencode-internal-sessions.js";
 import { acquirePrivateSnapshot, opencodeSnapshots, OpencodeSnapshotError, } from "./opencode-snapshot.js";
 export const DEFAULT_OPENCODE_DB = join(homedir(), ".local/share/opencode/opencode.db");
 function validateSchema(db) {

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/settings-health.js

@@ -4,6 +4,13 @@ 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.";
+async function createOpencodeImportModels(ref, directory) {
+    const { getOpencodeHostModels } = await import("./backfill-controls.js");
+    const opencode = getOpencodeHostModels();
+    if (!opencode)
+        throw new Error("the OpenCode client is not ready; retry in a moment");
+    return opencode.createImportModels(ref, directory);
+}
 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);
@@ -93,7 +100,7 @@ export async function runSettingsHealth(input) {
             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 createOpencodeImportModels(ref, input.directory)).capture
                 : (await import("./model-selection.js")).selectImportModel({}).capture;
             await capture.summarize({
                 userPrompt: PROBE,

package/dist/{services → importer}/settings-models.d.ts

@@ -1,15 +1,14 @@
 import type { OpencodeClient } from "@opencode-ai/sdk/v2/client";
+import type { SettingsModel } from "./backfill-controls.js";
+/** Connected models from an OpenCode client; null when the client returns no list. */
+export declare function listOpencodeClientModels(client: Pick<OpencodeClient, "provider">): Promise<SettingsModel[] | null>;
 export declare function listOpencodeSettingsModels(client?: Pick<OpencodeClient, "provider">): Promise<{
     available: false;
     reason: string;
     models?: undefined;
 } | {
     available: true;
-    models: {
-        provider: string;
-        model: string;
-        name: string;
-    }[];
+    models: SettingsModel[];
     reason?: undefined;
 }>;
 export declare function listPiSettingsModels(loadSdk?: () => Promise<typeof import("@earendil-works/pi-coding-agent")>): Promise<{

package/dist/{services → importer}/settings-models.js

@@ -1,19 +1,30 @@
+/** Connected models from an OpenCode client; null when the client returns no list. */
+export async function listOpencodeClientModels(client) {
+    const result = await client.provider.list();
+    if (!result.data)
+        return null;
+    const connected = new Set(result.data.connected);
+    return result.data.all
+        .filter((provider) => connected.has(provider.id))
+        .flatMap((provider) => Object.entries(provider.models).map(([model, info]) => ({
+        provider: provider.id,
+        model,
+        name: info.name,
+    })));
+}
 export async function listOpencodeSettingsModels(client) {
     try {
-        const active = client ?? (await import("./ai/opencode-provider.js")).getV2Client();
-        if (!active)
-            return { available: false, reason: "OpenCode model list unavailable" };
-        const result = await active.provider.list();
-        if (!result.data)
+        let models;
+        if (client) {
+            models = await listOpencodeClientModels(client);
+        }
+        else {
+            const { getOpencodeHostModels } = await import("./backfill-controls.js");
+            const opencode = getOpencodeHostModels();
+            models = opencode ? await opencode.listSettingsModels() : null;
+        }
+        if (!models)
             return { available: false, reason: "OpenCode model list unavailable" };
-        const connected = new Set(result.data.connected);
-        const models = result.data.all
-            .filter((provider) => connected.has(provider.id))
-            .flatMap((provider) => Object.entries(provider.models).map(([model, info]) => ({
-            provider: provider.id,
-            model,
-            name: info.name,
-        })));
         return { available: true, models };
     }
     catch {

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

@@ -173,12 +173,11 @@ export class SettingsImportJobs {
                     }
                     else {
                         const [providerID = "", ...id] = input.modelChoice.split("/");
-                        const { loadOpencodeProvider } = await import("../services/ai/opencode-provider-loader.js");
-                        const { isProviderConnected } = await loadOpencodeProvider();
-                        if (!isProviderConnected(providerID))
+                        const { getOpencodeHostModels } = await import("./backfill-controls.js");
+                        const opencode = getOpencodeHostModels();
+                        if (!opencode?.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);
+                        models = await opencode.createImportModels({ providerID, modelID: id.join("/") }, directory);
                     }
                     const { memoryClient } = await import("../services/client.js");
                     await memoryClient.warmup();
@@ -187,6 +186,7 @@ export class SettingsImportJobs {
                     cwd: directory,
                     models,
                     signal: controller.signal,
+                    track: { surface: "web" },
                     selection: {
                         keys: selection.keys,
                         cutoff: selection.cutoff,

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import type { Plugin } from "@opencode-ai/plugin";
 import { isStructuredSummaryPromptMessage } from "./adapters/opencode/user-prompt.js";
-import { INTERNAL_CAPTURE_SESSION_TITLE, isInternalCaptureSessionTitle } from "./services/ai/internal-capture-sessions.js";
+import { INTERNAL_CAPTURE_SESSION_TITLE, isInternalCaptureSessionTitle } from "./adapters/opencode/internal-capture-sessions.js";
 export { INTERNAL_CAPTURE_SESSION_TITLE, isInternalCaptureSessionTitle };
 export { isStructuredSummaryPromptMessage };
 /**

package/dist/index.js

@@ -8,7 +8,7 @@ import { isInternalPrompt, isStructuredSummaryPromptMessage, recordUserPrompt, }
 import { executeMemoryOperation } from "./core/memory-operations.js";
 import { OPENCODE_IMPORT_COMMAND, OPENCODE_IMPORT_DESCRIPTION, latestUserMessageModel, runOpencodeImportCommand, } from "./adapters/opencode/import-command.js";
 import { formatMemoriesForCompaction } from "./core/retrieval.js";
-import { performUserProfileLearning } from "./services/user-memory-learning.js";
+import { performUserProfileLearning } from "./adapters/opencode/profile-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";
@@ -19,10 +19,11 @@ import { isConfigured, CONFIG, initConfigWithLegacyMigration } from "./config.js
 import { resolveOpencodeHostModel } from "./services/ai/live-model-choice.js";
 import { log } from "./services/logger.js";
 import { getLanguageName } from "./services/language-detector.js";
-import { getHostClientConfig } from "./services/ai/opencode-host-config.js";
-import { loadOpencodeProvider } from "./services/ai/opencode-provider-loader.js";
-import { STRUCTURED_OUTPUT_AGENT, STRUCTURED_OUTPUT_TOOLS, } from "./services/ai/opencode-provider.js";
-import { INTERNAL_CAPTURE_SESSION_TITLE, isInternalCaptureSessionTitle, isTrackedInternalCaptureSession, } from "./services/ai/internal-capture-sessions.js";
+import { getHostClientConfig } from "./adapters/opencode/opencode-host-config.js";
+import { loadOpencodeProvider } from "./adapters/opencode/opencode-provider-loader.js";
+import { STRUCTURED_OUTPUT_AGENT, STRUCTURED_OUTPUT_TOOLS, } from "./adapters/opencode/opencode-provider.js";
+import { INTERNAL_CAPTURE_SESSION_TITLE, isInternalCaptureSessionTitle, isTrackedInternalCaptureSession, } from "./adapters/opencode/internal-capture-sessions.js";
+import { registerOpencodeProfileModel } from "./adapters/opencode/profile-model.js";
 export { INTERNAL_CAPTURE_SESSION_TITLE, isInternalCaptureSessionTitle };
 export { isStructuredSummaryPromptMessage };
 function extractSessionTitle(response) {
@@ -209,6 +210,13 @@ export const OmmsPlugin = async (ctx) => {
         })();
     }
     await configureOpencodeHostTransport(ctx);
+    // Shared profile dedup, conflict, description, and cleanup calls use OpenCode's host model.
+    registerOpencodeProfileModel();
+    // Web imports, Health, and Settings served by this process can list and use OpenCode's models.
+    // Awaited so the web server never serves those routes before the registry is filled.
+    await import("./adapters/opencode/backfill-startup.js")
+        .then(({ registerOpencodeImportModels }) => registerOpencodeImportModels())
+        .catch(() => { });
     (async () => {
         let connected = [];
         try {
@@ -231,15 +239,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[];

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

@@ -33,12 +33,21 @@ function getManualProviderStatus(config) {
         issues,
     };
 }
+/** The host chose the external API: it is the primary call, so there is no fallback. */
+function externalChoiceStatus(config) {
+    const manual = getManualProviderStatus(config);
+    return manual.ready
+        ? { ready: true, mode: "manual", issues: [] }
+        : { ready: false, issues: manual.issues };
+}
 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 (config.opencodeModel?.trim() === "external")
+        return externalChoiceStatus(config);
     if (hasOpencodeProvider && hasOpencodeModel) {
         return { ready: true, mode: "opencode", issues: [] };
     }
@@ -70,6 +79,10 @@ export function resolveOpencodeHostModel(config) {
 export function resolvePiLiveModel(config) {
     if (config.piModel?.trim() === "inherit")
         return { kind: "session" };
+    if (config.piModel?.trim() === "external") {
+        const status = externalChoiceStatus(config);
+        return status.ready ? { kind: "manual" } : { kind: "unready", issues: status.issues };
+    }
     if (hasValue(config.piProvider) && hasValue(config.piModel)) {
         return { kind: "pi", provider: config.piProvider.trim(), model: config.piModel.trim() };
     }
@@ -84,3 +97,8 @@ export function resolvePiLiveModel(config) {
 export function isExternalModelReady(config) {
     return getManualProviderStatus(config).ready;
 }
+/** Why the external API cannot be used as a host's chosen model, or an empty list. */
+export function externalModelIssues(config) {
+    const manual = getManualProviderStatus(config);
+    return manual.ready ? [] : manual.issues;
+}

package/dist/services/api-handlers.d.ts

@@ -41,7 +41,7 @@ interface PaginatedResponse<T> {
 export declare function handleListTags(): Promise<ApiResponse<{
     project: TagInfo[];
 }>>;
-export declare function handleListMemories(tag?: string, page?: number, pageSize?: number, includePrompts?: boolean): Promise<ApiResponse<PaginatedResponse<Memory | any>>>;
+export declare function handleListMemories(tag?: string, page?: number, pageSize?: number, includePrompts?: boolean, keyword?: string): Promise<ApiResponse<PaginatedResponse<Memory | any>>>;
 export declare function handleAddMemory(data: {
     content: string;
     containerTag: string;
@@ -178,6 +178,11 @@ interface MigrationProgress {
     errors: string[];
 }
 export declare function handleGetTagMigrationProgress(): Promise<ApiResponse<MigrationProgress>>;
+/**
+ * Tag the memories that have no tags, a few per request. Only untagged
+ * memories are touched: tagged ones keep their vectors. A memory that fails
+ * is recorded and passed over, so one bad row cannot stall the run.
+ */
 export declare function handleRunTagMigrationBatch(batchSize?: number): Promise<ApiResponse<{
     processed: number;
     total: number;