om-memory-system 3.7.0-next.51 → 3.7.0-next.52

package/dist/core/trivial-prompt.js

@@ -0,0 +1,8 @@
+/**
+ * A prompt too short to say anything about the user, such as "yes go". The
+ * word rule keeps short real preferences such as "use bun not npm".
+ */
+export function isTrivialPrompt(text) {
+    const trimmed = text.trim();
+    return trimmed.length < 20 && trimmed.split(/\s+/).filter(Boolean).length < 3;
+}

package/dist/importer/claude-hook-api.js

@@ -408,6 +408,13 @@ async function learnProfile(directory, deps) {
     const interval = CONFIG.userProfileAnalysisInterval ?? 0;
     if (!(interval > 0) || learning)
         return;
+    const { profileBackoff, profileCatchUpLock, recordProfileFailure } = await import("../core/profile-backoff.js");
+    // A catch-up run, here or in a terminal, analyses the same prompts; skip the live pass meanwhile.
+    if (!profileBackoff.canRun() || profileCatchUpLock.isActive())
+        return;
+    const { CatchUpLease } = await import("../services/user-prompt/profile-catch-up-lease.js");
+    if (await new CatchUpLease().isActive().catch(() => false))
+        return;
     learning = true;
     try {
         const [{ userPromptManager }, { userProfileManager }, { analyzeProfile }] = await Promise.all([
@@ -415,6 +422,7 @@ async function learnProfile(directory, deps) {
             import("../services/user-profile/user-profile-manager.js"),
             import("../core/profile-analysis.js"),
         ]);
+        await userPromptManager.skipTrivialPromptsForLearning();
         if ((await userPromptManager.countUnanalyzedForUserLearning()) < interval)
             return;
         const user = getTags(directory).user;
@@ -422,7 +430,9 @@ async function learnProfile(directory, deps) {
             log("Claude Code profile learning skipped", { code: "no-user-email" });
             return;
         }
-        const batch = await userPromptManager.getPromptsForUserLearning(interval);
+        const batch = await userPromptManager.getPromptsForUserLearning(interval, {
+            recentFirst: true,
+        });
         if (batch.length === 0)
             return;
         const model = deps.profileModel?.() ?? (await externalModels()).profile;
@@ -439,13 +449,14 @@ async function learnProfile(directory, deps) {
             await userProfileManager.createProfile(user.userEmail, user.displayName || user.userEmail, user.userName || user.userEmail, user.userEmail, analysis.raw, batch.length);
         }
         await userPromptManager.markMultipleAsUserLearningCaptured(batch.map((prompt) => prompt.id));
+        profileBackoff.recordSuccess();
         log("Claude Code profile learning finished", {
             prompts: batch.length,
             hadExisting: Boolean(existing),
         });
     }
     catch (error) {
-        log("Claude Code profile learning failed", { code: errorCode(error) });
+        recordProfileFailure("claude-code", "Claude Code profile learning failed", error);
     }
     finally {
         learning = false;

package/dist/importer/model-selection.d.ts

@@ -1,5 +1,7 @@
 import type { CaptureSummaryProvider } from "../core/host.js";
 import type { ModelPort } from "../core/profile-analysis.js";
+/** The same limit the Pi and OpenCode host-model profile paths use. */
+export declare const PROFILE_REQUEST_TIMEOUT_MS = 120000;
 export interface ImportModelFlags {
     provider?: string;
     model?: string;

package/dist/importer/model-selection.js

@@ -3,10 +3,13 @@ import { CONFIG } from "../config.js";
 import { buildBoundedSummaryPrompt } from "../core/capture-context.js";
 import { httpStatusError } from "../core/capture-retry-policy.js";
 import { buildCaptureSystemPrompt, captureSummaryToolSchema, normalizeStopReason, parseCaptureSummary, } from "../core/extraction.js";
+import { ProfileModelError, profileResultCode } from "../core/profile-failure.js";
 import { AIProviderFactory } from "../services/ai/ai-provider-factory.js";
 import { toolCallFailureReason } from "../services/ai/providers/base-provider.js";
 import { buildMemoryProviderConfig } from "../services/ai/provider-config.js";
 import { resolveSecretValue } from "../services/secret-resolver.js";
+/** The same limit the Pi and OpenCode host-model profile paths use. */
+export const PROFILE_REQUEST_TIMEOUT_MS = 120_000;
 /** Merge import-only model settings without changing the saved omms config. */
 export function selectImportModel(flags) {
     const providerName = flags.provider ?? CONFIG.memoryProvider;
@@ -29,15 +32,23 @@ export function selectImportModel(flags) {
     if (!AIProviderFactory.getSupportedProviders().includes(providerName)) {
         throw new Error(`Unsupported import provider: ${providerName}`);
     }
-    const provider = AIProviderFactory.createProvider(providerName, buildMemoryProviderConfig({
+    const settings = {
         ...CONFIG,
         memoryProvider: providerName,
         memoryModel: modelId,
         memoryApiUrl: apiUrl,
         memoryApiKey: key,
-    }));
+    };
+    const provider = AIProviderFactory.createProvider(providerName, buildMemoryProviderConfig(settings));
+    // A profile reply can take over a minute; captures keep autoCaptureIterationTimeout.
+    const profileProvider = AIProviderFactory.createProvider(providerName, buildMemoryProviderConfig(settings, { iterationTimeout: PROFILE_REQUEST_TIMEOUT_MS }));
     const capture = {
         async summarize(request) {
+            if (request.diagnostics) {
+                request.diagnostics.path = "external-api";
+                request.diagnostics.provider = providerName;
+                request.diagnostics.model = modelId ?? "";
+            }
             const { detectLanguage, getLanguageName } = await import("../services/language-detector.js");
             const target = CONFIG.autoCaptureLanguage && CONFIG.autoCaptureLanguage !== "auto"
                 ? CONFIG.autoCaptureLanguage
@@ -84,9 +95,9 @@ export function selectImportModel(flags) {
                     parameters: z.toJSONSchema(createUserProfileAnalysisSchema(z)),
                 },
             };
-            const result = await provider.executeToolCall(system, prompt, tool, `history-profile-${randomUUID()}`);
+            const result = await profileProvider.executeToolCall(system, prompt, tool, `history-profile-${randomUUID()}`);
             if (!result.success || !result.data)
-                throw new Error("History profile model call failed");
+                throw new ProfileModelError(profileResultCode(result));
             return typeof result.data === "string" ? result.data : JSON.stringify(result.data);
         },
     };

package/dist/importer/profile-backlog.d.ts

@@ -0,0 +1,42 @@
+import { type ModelPort } from "../core/profile-analysis.js";
+import { type ProfileFailureCode } from "../core/profile-failure.js";
+import { userProfileManager } from "../services/user-profile/user-profile-manager.js";
+import { userPromptManager } from "../services/user-prompt/user-prompt-manager.js";
+export type BacklogPromptStore = Pick<typeof userPromptManager, "countUnanalyzedForUserLearning" | "getPromptsForUserLearning" | "markMultipleAsUserLearningCaptured"> & Partial<Pick<typeof userPromptManager, "skipTrivialPromptsForLearning">>;
+export type BacklogProfileStore = Pick<typeof userProfileManager, "getActiveProfile" | "createProfile" | "updateProfile">;
+export interface DrainProfileBacklogOptions {
+    user: {
+        userEmail: string;
+        displayName?: string;
+        userName?: string;
+    };
+    model: ModelPort;
+    batchSize?: number;
+    signal?: AbortSignal;
+    /** Names the profile change, for example "History import". */
+    label?: string;
+    promptStore?: BacklogPromptStore;
+    profileStore?: BacklogProfileStore;
+    onProgress?: (progress: {
+        batchesBuilt: number;
+        remaining: number;
+    }) => void;
+    /** Called before each batch; a run that no longer owns the catch-up record stops. */
+    beforeBatch?: () => Promise<"ok" | "superseded" | "aborted">;
+    /** Called after each batch, whatever its outcome. */
+    afterBatch?: () => Promise<void>;
+}
+export interface DrainProfileBacklogReport {
+    batchesBuilt: number;
+    remaining: number;
+    error?: string;
+    reason?: ProfileFailureCode;
+    /** A newer catch-up run took over before the next batch. */
+    superseded?: boolean;
+}
+/**
+ * Analyse every waiting prompt, oldest first, in batches. Each finished batch
+ * stays learned; a batch that fails twice stops the run with its reason code,
+ * so the next run continues from the prompts still waiting.
+ */
+export declare function drainProfileBacklog(options: DrainProfileBacklogOptions): Promise<DrainProfileBacklogReport>;

package/dist/importer/profile-backlog.js

@@ -0,0 +1,79 @@
+import { analyzeProfile } from "../core/profile-analysis.js";
+import { profileFailureCode } from "../core/profile-failure.js";
+import { userProfileManager } from "../services/user-profile/user-profile-manager.js";
+import { userPromptManager } from "../services/user-prompt/user-prompt-manager.js";
+/**
+ * Analyse every waiting prompt, oldest first, in batches. Each finished batch
+ * stays learned; a batch that fails twice stops the run with its reason code,
+ * so the next run continues from the prompts still waiting.
+ */
+export async function drainProfileBacklog(options) {
+    const batchSize = options.batchSize ?? 50;
+    const prompts = options.promptStore ?? userPromptManager;
+    const profiles = options.profileStore ?? userProfileManager;
+    const label = options.label ?? "Profile catch-up";
+    const { user, model } = options;
+    const report = { batchesBuilt: 0, remaining: 0 };
+    await prompts.skipTrivialPromptsForLearning?.();
+    while ((report.remaining = await prompts.countUnanalyzedForUserLearning()) > 0) {
+        if (options.signal?.aborted)
+            break;
+        const start = (await options.beforeBatch?.()) ?? "ok";
+        if (start === "superseded") {
+            report.superseded = true;
+            break;
+        }
+        if (start === "aborted")
+            break;
+        let outcome;
+        try {
+            outcome = await sendBatch();
+        }
+        finally {
+            await options.afterBatch?.();
+        }
+        if (outcome === "failed")
+            return report;
+        if (outcome === "empty")
+            break;
+        options.onProgress?.({
+            batchesBuilt: report.batchesBuilt,
+            remaining: await prompts.countUnanalyzedForUserLearning(),
+        });
+    }
+    return report;
+    /** One batch with one retry; "failed" stops the run with its reason code. */
+    async function sendBatch() {
+        const batch = await prompts.getPromptsForUserLearning(batchSize);
+        if (batch.length === 0)
+            return "empty";
+        let succeeded = false;
+        for (let attempt = 0; attempt < 2 && !succeeded; attempt++) {
+            try {
+                const existing = await profiles.getActiveProfile(user.userEmail);
+                const context = batch.map((item, index) => `${index + 1}. ${item.content}`).join("\n");
+                const analysis = await analyzeProfile(model, context, existing ? { id: existing.id, profileData: existing.profileData } : null);
+                if (existing) {
+                    if (!analysis.merged ||
+                        !(await profiles.updateProfile(existing.id, analysis.merged, batch.length, `${label} of ${batch.length} prompts`)))
+                        throw new Error("Profile update conflict");
+                }
+                else {
+                    await profiles.createProfile(user.userEmail, user.displayName || user.userEmail, user.userName || user.userEmail, user.userEmail, analysis.raw, batch.length);
+                }
+                await prompts.markMultipleAsUserLearningCaptured(batch.map((item) => item.id));
+                report.batchesBuilt++;
+                succeeded = true;
+            }
+            catch (error) {
+                if (attempt === 1) {
+                    report.error = error instanceof Error ? error.message : String(error);
+                    report.reason = profileFailureCode(error);
+                    report.remaining = await prompts.countUnanalyzedForUserLearning();
+                    return "failed";
+                }
+            }
+        }
+        return "sent";
+    }
+}

package/dist/importer/profile-catch-up.d.ts

@@ -0,0 +1,39 @@
+import type { ModelPort } from "../core/profile-analysis.js";
+import type { ProfileFailureCode } from "../core/profile-failure.js";
+import { CatchUpLease } from "../services/user-prompt/profile-catch-up-lease.js";
+export declare const CATCH_UP_BATCH_SIZE = 50;
+export interface CatchUpState {
+    /** "superseded": a newer run, from the page or the terminal, took over. */
+    state: "idle" | "running" | "paused" | "done" | "failed" | "superseded";
+    batchesBuilt: number;
+    remaining: number;
+    reason?: ProfileFailureCode;
+}
+/**
+ * Batch hooks that keep catch-up runs in different processes apart: the
+ * newest run owns the record, and waits for the older run's current batch.
+ */
+export declare function catchUpLeaseHooks(signal?: AbortSignal, lease?: CatchUpLease): Promise<{
+    beforeBatch: () => Promise<import("../services/user-prompt/profile-catch-up-lease.js").BatchStart>;
+    afterBatch: () => Promise<void>;
+    release: () => Promise<void>;
+}>;
+export declare class CatchUpError extends Error {
+    readonly status: number;
+    constructor(message: string, status: number, options?: {
+        cause?: unknown;
+    });
+}
+/** The waiting prompts and the model calls a run would make. */
+export declare function previewCatchUp(): Promise<{
+    waiting: number;
+    calls: number;
+}>;
+export declare function catchUpState(): CatchUpState;
+/**
+ * Start a catch-up run in the background with the saved external API, or
+ * another model. Pause aborts between batches; Resume starts a new run that
+ * continues from the prompts still waiting.
+ */
+export declare function startCatchUp(directory: string, model?: ModelPort, onEnd?: (state: CatchUpState) => void): Promise<CatchUpState>;
+export declare function pauseCatchUp(): CatchUpState;

package/dist/importer/profile-catch-up.js

@@ -0,0 +1,123 @@
+import { profileCatchUpLock } from "../core/profile-backoff.js";
+import { randomUUID } from "node:crypto";
+import { log } from "../services/logger.js";
+import { CatchUpLease } from "../services/user-prompt/profile-catch-up-lease.js";
+import { getTags } from "../services/tags.js";
+import { drainProfileBacklog } from "./profile-backlog.js";
+export const CATCH_UP_BATCH_SIZE = 50;
+/**
+ * Batch hooks that keep catch-up runs in different processes apart: the
+ * newest run owns the record, and waits for the older run's current batch.
+ */
+export async function catchUpLeaseHooks(signal, lease = new CatchUpLease()) {
+    const owner = `${process.pid}-${randomUUID()}`;
+    await lease.take(owner);
+    return {
+        beforeBatch: () => lease.beginBatch(owner, { signal }),
+        afterBatch: () => lease.endBatch(owner),
+        release: () => lease.release(owner),
+    };
+}
+export class CatchUpError extends Error {
+    status;
+    constructor(message, status, options) {
+        super(message, options);
+        this.status = status;
+        this.name = "CatchUpError";
+    }
+}
+/** The waiting prompts and the model calls a run would make. */
+export async function previewCatchUp() {
+    const { userPromptManager } = await import("../services/user-prompt/user-prompt-manager.js");
+    // Trivial prompts are skipped without a model call, so they are not counted.
+    const waiting = (await userPromptManager.countUnanalyzedForUserLearning()) -
+        (await userPromptManager.countTrivialPromptsForLearning());
+    return { waiting, calls: Math.ceil(waiting / CATCH_UP_BATCH_SIZE) };
+}
+let job = { state: "idle", batchesBuilt: 0, remaining: 0 };
+let controller = null;
+export function catchUpState() {
+    return job;
+}
+/**
+ * Start a catch-up run in the background with the saved external API, or
+ * another model. Pause aborts between batches; Resume starts a new run that
+ * continues from the prompts still waiting.
+ */
+export async function startCatchUp(directory, model, onEnd) {
+    const user = getTags(directory).user;
+    if (!user.userEmail)
+        throw new CatchUpError("Profile learning needs a user email", 400);
+    if (!profileCatchUpLock.begin())
+        throw new CatchUpError("A catch-up run is already running", 409);
+    let chosen;
+    try {
+        chosen = model ?? (await import("./model-selection.js")).selectImportModel({}).profile;
+    }
+    catch (error) {
+        profileCatchUpLock.end();
+        throw new CatchUpError(error instanceof Error ? error.message : "No model", 400);
+    }
+    const runController = new AbortController();
+    const signal = runController.signal;
+    let remaining;
+    let hooks;
+    try {
+        remaining = (await previewCatchUp()).waiting;
+        hooks = await catchUpLeaseHooks(signal);
+    }
+    catch (error) {
+        // Setup failed before the run started; free the lock so a retry can start.
+        profileCatchUpLock.end();
+        throw new CatchUpError(error instanceof Error ? error.message : "Catch-up not started", 500, {
+            cause: error,
+        });
+    }
+    controller = runController;
+    job = { state: "running", batchesBuilt: 0, remaining };
+    void drainProfileBacklog({
+        beforeBatch: hooks.beforeBatch,
+        afterBatch: hooks.afterBatch,
+        user: { ...user, userEmail: user.userEmail },
+        model: chosen,
+        batchSize: CATCH_UP_BATCH_SIZE,
+        signal,
+        onProgress: (progress) => {
+            job = { ...job, ...progress };
+        },
+    })
+        .then((report) => {
+        job = {
+            state: report.reason
+                ? "failed"
+                : report.superseded
+                    ? "superseded"
+                    : signal.aborted
+                        ? "paused"
+                        : "done",
+            batchesBuilt: report.batchesBuilt,
+            remaining: report.remaining,
+            ...(report.reason ? { reason: report.reason } : {}),
+        };
+    })
+        .catch(() => {
+        job = { ...job, state: "failed", reason: "error" };
+    })
+        .finally(async () => {
+        await hooks.release().catch(() => { });
+        profileCatchUpLock.end();
+        controller = null;
+        log("Profile catch-up ended", {
+            outcome: job.state,
+            batches: job.batchesBuilt,
+            remaining: job.remaining,
+            ...(job.reason ? { reason: job.reason } : {}),
+        });
+        onEnd?.(job);
+    });
+    return job;
+}
+export function pauseCatchUp() {
+    controller?.abort();
+    return job;
+}

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

@@ -1,4 +1,4 @@
-import { type ModelPort } from "../core/profile-analysis.js";
+import type { ModelPort } from "../core/profile-analysis.js";
 import { userProfileManager } from "../services/user-profile/user-profile-manager.js";
 import { userPromptManager } from "../services/user-prompt/user-prompt-manager.js";
 import type { MemoryHost } from "../types/index.js";

package/dist/importer/profile-import.js

@@ -1,5 +1,4 @@
 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";
 import { userProfileManager } from "../services/user-profile/user-profile-manager.js";
@@ -7,6 +6,7 @@ import { userPromptManager } from "../services/user-prompt/user-prompt-manager.j
 import { buildImportKey } from "./importer.js";
 import { existsSync } from "node:fs";
 import { ImportLedger, importLedgerDbPath } from "./ledger.js";
+import { drainProfileBacklog } from "./profile-backlog.js";
 /** Record historical prompts and build or update the user profile in batches. */
 export async function importProfileFromHistory(source, options) {
     if (!options.dryRun && !options.model)
@@ -80,39 +80,18 @@ export async function importProfileFromHistory(source, options) {
         report.error = "Profile import needs a user email";
         return report;
     }
-    const model = options.model;
-    while ((report.remaining = await prompts.countUnanalyzedForUserLearning()) > 0) {
-        if (options.signal?.aborted)
-            break;
-        const batch = await prompts.getPromptsForUserLearning(batchSize);
-        if (batch.length === 0)
-            break;
-        let succeeded = false;
-        for (let attempt = 0; attempt < 2 && !succeeded; attempt++) {
-            try {
-                const existing = await profiles.getActiveProfile(user.userEmail);
-                const context = batch.map((item, index) => `${index + 1}. ${item.content}`).join("\n");
-                const analysis = await analyzeProfile(model, context, existing ? { id: existing.id, profileData: existing.profileData } : null);
-                if (existing) {
-                    if (!analysis.merged ||
-                        !(await profiles.updateProfile(existing.id, analysis.merged, batch.length, `History import of ${batch.length} prompts`)))
-                        throw new Error("Profile update conflict");
-                }
-                else {
-                    await profiles.createProfile(user.userEmail, user.displayName || user.userEmail, user.userName || user.userEmail, user.userEmail, analysis.raw, batch.length);
-                }
-                await prompts.markMultipleAsUserLearningCaptured(batch.map((item) => item.id));
-                report.batchesBuilt++;
-                succeeded = true;
-            }
-            catch (error) {
-                if (attempt === 1) {
-                    report.error = error instanceof Error ? error.message : String(error);
-                    report.remaining = await prompts.countUnanalyzedForUserLearning();
-                    return report;
-                }
-            }
-        }
-    }
+    const drained = await drainProfileBacklog({
+        user: { ...user, userEmail: user.userEmail },
+        model: options.model,
+        batchSize,
+        signal: options.signal,
+        label: "History import",
+        promptStore: prompts,
+        profileStore: profiles,
+    });
+    report.batchesBuilt += drained.batchesBuilt;
+    report.remaining = drained.remaining;
+    if (drained.error)
+        report.error = drained.error;
     return report;
 }

package/dist/importer/settings-health.js

@@ -23,6 +23,31 @@ export function captureFailureHealth(byModel, byReason) {
             : "No recent attempts",
     };
 }
+/** Claude Code rows from the settings snapshot; missing data is a failure, never a throw. */
+function claudeCodeRows(snapshot) {
+    const model = snapshot.effective?.["claude-code"];
+    const folder = snapshot.claudeFolder;
+    return [
+        {
+            check: "Claude Code model",
+            status: model?.ready ? "pass" : "fail",
+            reason: !model
+                ? "Claude Code model status is unavailable"
+                : model.ready
+                    ? "Resolved: external API"
+                    : (model.issues ?? []).join("; ") || "External API is not configured",
+        },
+        {
+            check: "Claude Code folder",
+            status: !folder ? "fail" : folder.exists ? "pass" : "warn",
+            reason: !folder
+                ? "Claude Code folder status is unavailable"
+                : folder.exists
+                    ? `Found: ${folder.root}`
+                    : `Folder not found: ${folder.root}`,
+        },
+    ];
+}
 /** Run checks independently so a failed dependency cannot hide the remaining checks. */
 export async function runSettingsHealth(input) {
     const checks = [];
@@ -42,9 +67,10 @@ export async function runSettingsHealth(input) {
             });
         }
     }
+    let snapshot = {};
     await check("Config files", async () => {
         const { getSettingsSnapshot } = await import("../services/settings-snapshot.js");
-        getSettingsSnapshot(input.directory);
+        snapshot = (getSettingsSnapshot(input.directory) ?? {});
         return "Global and project config parsed";
     });
     await check("Memory store", async () => {
@@ -81,6 +107,7 @@ export async function runSettingsHealth(input) {
         status: pi.kind === "unready" ? "fail" : "pass",
         reason: pi.kind === "unready" ? pi.issues.join("; ") : `Resolved: ${pi.kind}`,
     });
+    checks.push(...claudeCodeRows(snapshot));
     try {
         const { queryCaptureAttempts } = await import("../services/capture-attempt-store.js");
         const { byModel, byReason } = await queryCaptureAttempts(Date.now() - 86400000, Date.now());
@@ -94,6 +121,16 @@ export async function runSettingsHealth(input) {
         });
     }
     if (input.testModels) {
+        // Pi, Claude Code, and OpenCode may all use the external API; one health run calls it once.
+        let externalProbe;
+        const probeExternal = () => (externalProbe ??= import("./model-selection.js").then(async ({ selectImportModel }) => {
+            await selectImportModel({}).capture.summarize({
+                userPrompt: PROBE,
+                context: PROBE,
+                sessionId: "health",
+                projectDirectory: input.directory,
+            });
+        }));
         const { resolveOpencodeHostModel } = await import("../services/ai/live-model-choice.js");
         const { getOpencodeHostModels } = await import("./backfill-controls.js");
         const opencodeRef = resolveOpencodeHostModel(CONFIG);
@@ -107,9 +144,11 @@ export async function runSettingsHealth(input) {
         }
         else {
             await check("OpenCode model test", async () => {
-                const capture = opencodeRef
-                    ? (await createOpencodeImportModels(opencodeRef, input.directory)).capture
-                    : (await import("./model-selection.js")).selectImportModel({}).capture;
+                if (!opencodeRef) {
+                    await probeExternal();
+                    return "Fixed prompt completed";
+                }
+                const { capture } = await createOpencodeImportModels(opencodeRef, input.directory);
                 await capture.summarize({
                     userPrompt: PROBE,
                     context: PROBE,
@@ -121,13 +160,7 @@ export async function runSettingsHealth(input) {
         }
         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,
-                });
+                await probeExternal();
                 return "Fixed prompt completed";
             });
         }
@@ -138,6 +171,12 @@ export async function runSettingsHealth(input) {
                 reason: "Pi models need an active Pi session to test",
             });
         }
+        if (snapshot.effective?.["claude-code"]?.ready) {
+            await check("Claude Code model test", async () => {
+                await probeExternal();
+                return "Fixed prompt completed";
+            });
+        }
     }
     return { checks };
 }

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

@@ -10,3 +10,4 @@ export { stopStandaloneOpencodeReads } from "./opencode-standalone-models.js";
 export { BackfillControls } from "./backfill-controls.js";
 export { directoryMapsView } from "./map-suggestions.js";
 export { testExternalApi } from "./external-api-test.js";
+export { catchUpState, pauseCatchUp, previewCatchUp, startCatchUp } from "./profile-catch-up.js";

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

@@ -10,3 +10,4 @@ export { stopStandaloneOpencodeReads } from "./opencode-standalone-models.js";
 export { BackfillControls } from "./backfill-controls.js";
 export { directoryMapsView } from "./map-suggestions.js";
 export { testExternalApi } from "./external-api-test.js";
+export { catchUpState, pauseCatchUp, previewCatchUp, startCatchUp } from "./profile-catch-up.js";

package/dist/index.js

@@ -5,6 +5,7 @@ import { performAutoCapture } from "./services/auto-capture.js";
 import { createOpenCodeAutoCaptureHost } from "./adapters/opencode/auto-capture-host.js";
 import { isInternalPrompt, isStructuredSummaryPromptMessage, recordUserPrompt, } from "./adapters/opencode/user-prompt.js";
 import { executeMemoryOperation } from "./core/memory-operations.js";
+import { memoryToolDescription } from "./core/memory-tool-text.js";
 import { OPENCODE_IMPORT_COMMAND, OPENCODE_IMPORT_DESCRIPTION, latestUserMessageModel, runOpencodeImportCommand, } from "./adapters/opencode/import-command.js";
 import { buildRecentMemoriesSection, formatMemoriesForCompaction } from "./core/retrieval.js";
 import { performUserProfileLearning } from "./adapters/opencode/profile-learning.js";
@@ -17,6 +18,7 @@ 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 "./adapters/opencode/opencode-host-config.js";
+import { applySkillsPathConfig } from "./adapters/opencode/package-skills.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";
@@ -372,6 +374,7 @@ export const OmmsPlugin = async (ctx) => {
         config: async (cfg) => {
             applyStructuredOutputAgentConfig(cfg);
             applyHistoryImportCommandConfig(cfg);
+            applySkillsPathConfig(cfg);
         },
         // V1 runs slash commands as a model turn; do the import here and hand the
         // turn only the finished report to relay.
@@ -472,7 +475,7 @@ export const OmmsPlugin = async (ctx) => {
         },
         tool: {
             memory: tool({
-                description: `Manage and query project memory (MATCH USER LANGUAGE: ${getLanguageName(CONFIG.autoCaptureLanguage || "en")}). Use 'search' with technical keywords/tags, 'add' to store knowledge, 'profile' for preferences. Use migrate/list-shards/export/import when a project directory moves. Search/list scope: project or all-projects.`,
+                description: memoryToolDescription(getLanguageName(CONFIG.autoCaptureLanguage || "en")),
                 args: {
                     mode: tool.schema
                         .enum([