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

package/README.md

@@ -1,4 +1,4 @@
-# OMMS — Opinionated Modular Memory System
+# OMMS: Opinionated Modular Memory System
 
 [![npm version](https://img.shields.io/npm/v/om-memory-system.svg)](https://www.npmjs.com/package/om-memory-system)
 [![npm downloads](https://img.shields.io/npm/dm/om-memory-system.svg)](https://www.npmjs.com/package/om-memory-system)
@@ -26,7 +26,8 @@ the other. Everything is stored locally on your machine.
   OpenCode v1.
 - **Learns your preferences.** A user profile of your habits builds up over
   time and follows you across projects.
-- **Imports your past sessions.** Pi and OpenCode import older history after startup. A command provides a preview and manual control.
+- **Imports your past sessions.** Pi and OpenCode import older history after
+  startup. A command gives you a preview and manual control.
 - **Lets you look and edit.** A local web page shows every memory and your
   profile.
 - **Keeps private things private.** Text inside `<private>` tags is never
@@ -74,6 +75,14 @@ pi install npm:om-memory-system
 
 Restart Pi. You can install OMMS in both agents; they share the same memory.
 
+**Terminal command (optional, recommended).** A global install lets the login
+web app and the `om-memory-system` terminal commands run without `npx`:
+
+```bash
+npm i -g om-memory-system      # or: bun add -g om-memory-system
+om-memory-system --version
+```
+
 ### 2. Choose which model writes memories (optional)
 
 With no settings, OMMS uses the model of the session you are working in. To
@@ -91,18 +100,22 @@ config file yet, OMMS creates this one with comments on first start.
 }
 ```
 
-You can also use any OpenAI-compatible or Anthropic API with your own key.
-See [Configuration](docs/configuration.md#choosing-the-model).
+You can also use any OpenAI-compatible or Anthropic API with your own key, set
+up on the Settings page's **External API** card, and choose `"external"` as a
+host's model. See [Configuration](docs/configuration.md#choosing-the-model).
 
 ### 3. Check it works
 
 Work normally for a few turns, then open `http://127.0.0.1:4747` in your
-browser. OpenCode or the login web app serves this page. New memories appear on the timeline.
-You can also ask the agent: "search memory for what we changed today".
+browser. OpenCode or the login web app serves this page. New memories appear
+on the timeline. You can also ask the agent: "search memory for what we changed today".
 
 ## Import your past history
 
-Older sessions import automatically after a host starts. This makes model calls. To opt out, set `"autoBackfill": false` in `~/.config/omms/omms.jsonc` before starting. For a manual import or custom source, preview inside the agent:
+Older sessions import automatically after a host starts. This makes model
+calls. To turn it off, set `"autoBackfill": false` in
+`~/.config/omms/omms.jsonc` before you start the agent. For a manual import or
+a custom source, preview it inside the agent:
 
 ```text
 /memory-import-opencode-history --dry-run
@@ -134,6 +147,7 @@ backup first. See [Updating and upgrading](docs/upgrading.md) and
 | [Using memory day to day](docs/using-memory.md)            | How capture and recall work, the `memory` tool, the user profile |
 | [Configuration](docs/configuration.md)                     | Settings, choosing the model, embeddings, troubleshooting        |
 | [Web UI](docs/web-ui.md)                                   | The memory explorer, opening it on a network safely              |
+| [Settings page](docs/web-ui-settings.md)                   | Every card and control on the web Settings page                  |
 | [Moving projects](docs/moving-projects.md)                 | Nested repositories, moved folders, backup and restore           |
 | [Updating and upgrading](docs/upgrading.md)                | Updates, pinning a version, older stores                         |
 | [OpenCode adapter](docs/opencode-adapter.md)               | How the OpenCode plugin hooks in                                 |

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

@@ -4,7 +4,7 @@ import { resolveOpencodeHostModel } from "../../services/ai/live-model-choice.js
 import { buildBoundedSummaryPrompt } from "../../core/capture-context.js";
 import { classifyCaptureReply, normalizeStopReason, parseCaptureSummary, } from "../../core/extraction.js";
 import { log } from "../../services/logger.js";
-import { loadOpencodeProvider } from "../../services/ai/opencode-provider-loader.js";
+import { loadOpencodeProvider } from "./opencode-provider-loader.js";
 function buildSystemPrompt(languageName) {
     return `You are a technical memory recorder for a software development project.
 

package/dist/adapters/opencode/backfill-models.d.ts

@@ -1,6 +1,6 @@
 import { selectImportModel } from "../../importer/model-selection.js";
 import type { HistoryImportModels } from "../../importer/run-import.js";
-import { createOpencodeImportModels } from "../../services/ai/opencode-import-models.js";
+import { createOpencodeImportModels } from "./opencode-import-models.js";
 interface BackfillConfig {
     opencodeBackfillModel?: string;
     opencodeProvider?: string;

package/dist/adapters/opencode/backfill-models.js

@@ -1,11 +1,15 @@
 import { CONFIG } from "../../config.js";
 import { parseBackfillModel } from "../../importer/backfill-model.js";
+import { resolveExternalBackfillModels } from "../../importer/external-backfill-models.js";
 import { selectImportModel } from "../../importer/model-selection.js";
 import { getAutoCaptureProviderStatus } from "../../services/ai/live-model-choice.js";
-import { createOpencodeImportModels, } from "../../services/ai/opencode-import-models.js";
+import { createOpencodeImportModels } from "./opencode-import-models.js";
 /** Apply the live-model rule when inherit is selected; named models need sign-in. */
 export async function resolveOpencodeBackfillModels(config = CONFIG, context) {
     const choice = parseBackfillModel(config, "opencode");
+    if (choice === "external") {
+        return resolveExternalBackfillModels("opencode", config, context.externalModels);
+    }
     let ref;
     if (choice === "inherit") {
         const live = getAutoCaptureProviderStatus(config);
@@ -24,7 +28,7 @@ export async function resolveOpencodeBackfillModels(config = CONFIG, context) {
         if (!selected)
             throw new Error("OpenCode backfill: no configured default model");
         const parsed = parseBackfillModel({ opencodeBackfillModel: selected }, "opencode");
-        if (parsed === "inherit")
+        if (typeof parsed === "string")
             throw new Error("OpenCode backfill: no configured default model");
         ref = { providerID: parsed.provider, modelID: parsed.model };
     }

package/dist/adapters/opencode/backfill-startup.d.ts

@@ -5,3 +5,11 @@ export declare function startOpencodeBackfill(input: {
     configModel: () => Promise<string | null>;
     notify: (message: string) => void;
 }): Promise<void>;
+/** Let Run now on a Settings page served by this process use OpenCode's models. */
+export declare function registerOpencodeBackfillModels(input: {
+    directory: string;
+    connected: string[];
+    configModel: () => Promise<string | null>;
+}): void;
+/** Let web imports, Health, and Settings in this process use OpenCode's signed-in models. */
+export declare function registerOpencodeImportModels(): void;

package/dist/adapters/opencode/backfill-startup.js

@@ -1,6 +1,10 @@
 import { CONFIG } from "../../config.js";
 import { scheduleAutoBackfill } from "../../importer/auto-backfill.js";
+import { registerHostBackfillModels, registerOpencodeHostModels, } from "../../importer/backfill-controls.js";
+import { listOpencodeClientModels } from "../../importer/settings-models.js";
 import { resolveOpencodeBackfillModels } from "./backfill-models.js";
+import { createOpencodeImportModels } from "./opencode-import-models.js";
+import { getV2Client, isProviderConnected } from "./opencode-provider.js";
 /** Start after connected providers load, without delaying plugin initialisation. */
 export function startOpencodeBackfill(input) {
     return scheduleAutoBackfill({
@@ -10,3 +14,18 @@ export function startOpencodeBackfill(input) {
         notify: input.notify,
     });
 }
+/** Let Run now on a Settings page served by this process use OpenCode's models. */
+export function registerOpencodeBackfillModels(input) {
+    registerHostBackfillModels("opencode", () => resolveOpencodeBackfillModels(CONFIG, input));
+}
+/** Let web imports, Health, and Settings in this process use OpenCode's signed-in models. */
+export function registerOpencodeImportModels() {
+    registerOpencodeHostModels({
+        isProviderConnected: (providerID) => isProviderConnected(providerID),
+        createImportModels: (ref, directory) => createOpencodeImportModels(ref, directory),
+        async listSettingsModels() {
+            const client = getV2Client();
+            return client ? listOpencodeClientModels(client) : null;
+        },
+    });
+}

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

@@ -1,6 +1,6 @@
-import { type OpencodeModelRef } from "../../services/ai/opencode-import-models.js";
-export { createOpencodeImportModels } from "../../services/ai/opencode-import-models.js";
-export type { OpencodeModelRef } from "../../services/ai/opencode-import-models.js";
+import { type OpencodeModelRef } from "./opencode-import-models.js";
+export { createOpencodeImportModels } from "./opencode-import-models.js";
+export type { OpencodeModelRef } from "./opencode-import-models.js";
 /**
  * OpenCode command surface for the historical-session importer:
  *

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

@@ -1,9 +1,9 @@
 import { isConfigured } from "../../config.js";
 import { historyImportUsage, importNeedsModel, parseHistoryImportArgs, tokenizeImportArgs, } from "../../importer/import-args.js";
 import { formatHistoryImportReport, summarizeHistoryImportReport, runHistoryImport, } from "../../importer/run-import.js";
-import { createOpencodeImportModels, } from "../../services/ai/opencode-import-models.js";
-export { createOpencodeImportModels } from "../../services/ai/opencode-import-models.js";
-import { loadOpencodeProvider } from "../../services/ai/opencode-provider-loader.js";
+import { createOpencodeImportModels } from "./opencode-import-models.js";
+export { createOpencodeImportModels } from "./opencode-import-models.js";
+import { loadOpencodeProvider } from "./opencode-provider-loader.js";
 import { beginManualImport } from "../../importer/manual-import-guard.js";
 import { memoryClient } from "../../services/client.js";
 import { log } from "../../services/logger.js";
@@ -68,6 +68,7 @@ export async function runOpencodeImportCommand(input) {
         const report = await runHistoryImport("opencode", parsed, {
             cwd: input.directory,
             models,
+            track: { surface: "slash" },
             onProgress: (processed, total, promptPreview) => {
                 if (processed - lastProgress >= 25 || processed === total) {
                     lastProgress = processed;

package/dist/adapters/opencode/internal-capture-sessions.d.ts

@@ -0,0 +1,4 @@
+export { INTERNAL_CAPTURE_SESSION_TITLE, INTERNAL_CAPTURE_SESSION_TITLES, isInternalCaptureSessionTitle, } from "../../importer/opencode-internal-sessions.js";
+export declare function trackInternalCaptureSession(sessionID: string): void;
+export declare function untrackInternalCaptureSession(sessionID: string): void;
+export declare function isTrackedInternalCaptureSession(sessionID: string): boolean;

package/dist/{services/ai → adapters/opencode}/internal-capture-sessions.js

@@ -1,21 +1,8 @@
-/** 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";
+export { INTERNAL_CAPTURE_SESSION_TITLE, INTERNAL_CAPTURE_SESSION_TITLES, isInternalCaptureSessionTitle, } from "../../importer/opencode-internal-sessions.js";
 /** Grace period so session.idle can still match after best-effort delete. */
 const UNTRACK_GRACE_MS = 60_000;
 const trackedSessionIDs = new Set();
 const untrackTimers = new Map();
-/** 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);
-}
 export function trackInternalCaptureSession(sessionID) {
     const pending = untrackTimers.get(sessionID);
     if (pending) {

package/dist/{services/ai → adapters/opencode}/opencode-import-models.js

@@ -9,7 +9,7 @@ export async function createOpencodeImportModels(ref, directory) {
         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("../language-detector.js");
+    const { detectLanguage, getLanguageName } = await import("../../services/language-detector.js");
     const captureSchema = z.object({
         summary: z.string().optional(),
         type: z.string(),

package/dist/{services/user-memory-learning.d.ts → adapters/opencode/profile-learning.d.ts}

@@ -1,7 +1,7 @@
 import type { PluginInput } from "@opencode-ai/plugin";
 export declare function shouldRunAutomaticProfileCleanup(previousPromptCount: number, addedPromptCount: number, interval?: number): boolean;
 export declare function performUserProfileLearning(ctx: PluginInput, directory: string): Promise<void>;
-import { createUserProfileAnalysisSchema, USER_PROFILE_LLM_CONFIDENCE_MAX } from "../core/extraction.js";
+import { createUserProfileAnalysisSchema, USER_PROFILE_LLM_CONFIDENCE_MAX } from "../../core/extraction.js";
 export { createUserProfileAnalysisSchema, USER_PROFILE_LLM_CONFIDENCE_MAX };
 export declare function createUserProfileToolSchema(existingProfile: boolean): {
     type: "function";

package/dist/{services/user-memory-learning.js → adapters/opencode/profile-learning.js}

@@ -1,11 +1,11 @@
-import { getTags } from "./tags.js";
-import { log } from "./logger.js";
-import { CONFIG, refreshConfigIfChanged } from "../config.js";
-import { resolveOpencodeHostModel } from "./ai/live-model-choice.js";
-import { userPromptManager } from "./user-prompt/user-prompt-manager.js";
-import { userProfileManager } from "./user-profile/user-profile-manager.js";
-import { sortProfileItems } from "../utils/profile.js";
-import { loadOpencodeProvider } from "./ai/opencode-provider-loader.js";
+import { getTags } from "../../services/tags.js";
+import { log } from "../../services/logger.js";
+import { CONFIG, refreshConfigIfChanged } from "../../config.js";
+import { resolveOpencodeHostModel } from "../../services/ai/live-model-choice.js";
+import { userPromptManager } from "../../services/user-prompt/user-prompt-manager.js";
+import { userProfileManager } from "../../services/user-profile/user-profile-manager.js";
+import { sortProfileItems } from "../../utils/profile.js";
+import { loadOpencodeProvider } from "./opencode-provider-loader.js";
 let isLearningRunning = false;
 export function shouldRunAutomaticProfileCleanup(previousPromptCount, addedPromptCount, interval = CONFIG.userProfileAutoCleanupInterval) {
     if (!CONFIG.userProfileAutoCleanupEnabled || !Number.isInteger(interval) || interval <= 0) {
@@ -23,7 +23,7 @@ async function runAutomaticProfileCleanup(userId) {
         const itemCount = profileData.preferences.length + profileData.patterns.length + profileData.workflows.length;
         if (itemCount < 2)
             return;
-        const { aiCleanupProfile } = await import("./user-profile/ai-cleanup.js");
+        const { aiCleanupProfile } = await import("../../services/user-profile/ai-cleanup.js");
         const result = await aiCleanupProfile(profileData);
         if (result.diff.merged.length === 0 && result.diff.removed.length === 0)
             return;
@@ -338,7 +338,7 @@ CRITICAL: Only output observations grounded in the RECENT PROMPTS above. Write d
     }
     return truncate(base);
 }
-import { createUserProfileAnalysisSchema, USER_PROFILE_LLM_CONFIDENCE_MAX, } from "../core/extraction.js";
+import { createUserProfileAnalysisSchema, USER_PROFILE_LLM_CONFIDENCE_MAX, } from "../../core/extraction.js";
 export { createUserProfileAnalysisSchema, USER_PROFILE_LLM_CONFIDENCE_MAX };
 export function createUserProfileToolSchema(existingProfile) {
     return {
@@ -497,7 +497,7 @@ async function analyzeUserProfile(context, existingProfile) {
         log("user-profile-learning: trying opencode provider");
         try {
             const { generateStructuredOutput } = await loadOpencodeProvider();
-            const { getOpenCodeClient } = await import("./ai/profile-llm-client.js");
+            const { getOpenCodeClient } = await import("./profile-llm-client.js");
             log("user-profile-learning: opencode provider diag", {
                 provider: resolveOpencodeHostModel(CONFIG)?.providerID,
                 model: resolveOpencodeHostModel(CONFIG)?.modelID,
@@ -556,8 +556,8 @@ Use the update_user_profile tool to save the ${existingProfile ? "updated" : "ne
         });
         throw new Error("External API not configured for user memory learning");
     }
-    const { AIProviderFactory } = await import("./ai/ai-provider-factory.js");
-    const { buildMemoryProviderConfig } = await import("./ai/provider-config.js");
+    const { AIProviderFactory } = await import("../../services/ai/ai-provider-factory.js");
+    const { buildMemoryProviderConfig } = await import("../../services/ai/provider-config.js");
     const providerConfig = buildMemoryProviderConfig(CONFIG);
     const provider = AIProviderFactory.createProvider(CONFIG.memoryProvider, providerConfig);
     const systemPrompt = `You are a user behavior analyst for a coding assistant.
@@ -597,7 +597,7 @@ If no clear chains, return { "paths": [] }.`;
         try {
             const { z } = await import("zod");
             const { generateStructuredOutput } = await loadOpencodeProvider();
-            const { getOpenCodeClient } = await import("./ai/profile-llm-client.js");
+            const { getOpenCodeClient } = await import("./profile-llm-client.js");
             let v2Client;
             try {
                 v2Client = await getOpenCodeClient();

package/dist/{services/ai → adapters/opencode}/profile-llm-client.js

@@ -1,5 +1,5 @@
 import { CONFIG } from "../../config.js";
-import { resolveOpencodeHostModel } from "./live-model-choice.js";
+import { resolveOpencodeHostModel } from "../../services/ai/live-model-choice.js";
 import { loadOpencodeProvider } from "./opencode-provider-loader.js";
 let _cachedClient = null;
 let _cachedProvider = null;

package/dist/adapters/opencode/profile-model.d.ts

@@ -0,0 +1,23 @@
+import type { ModelPort } from "../../core/profile-analysis.js";
+import type { OpencodeModelRef } from "./opencode-import-models.js";
+type PromptInfo = {
+    error?: {
+        name: string;
+        data?: {
+            message?: string;
+        };
+    };
+};
+/**
+ * Extract assistant text from an OpenCode session.prompt result.
+ * AssistantMessage has no `text` field; content lives in `parts` (#177).
+ */
+export declare function extractTextFromPromptResult(promptResult: unknown): {
+    info: PromptInfo | undefined;
+    rawText: string;
+};
+/** Adapt OpenCode's host model to the shared profile code, as `adaptPiProfileModel` does for Pi. */
+export declare function adaptOpencodeProfileModel(v2Client: unknown, hostModel: OpencodeModelRef): ModelPort;
+/** Route shared profile calls in this process to OpenCode's host model while one is configured. */
+export declare function registerOpencodeProfileModel(): void;
+export {};

package/dist/adapters/opencode/profile-model.js

@@ -0,0 +1,117 @@
+import { CONFIG } from "../../config.js";
+import { resolveOpencodeHostModel } from "../../services/ai/live-model-choice.js";
+import { log } from "../../services/logger.js";
+import { OPENCODE_PROFILE_CLEANUP_TIMEOUT_MS } from "../../services/request-timeouts.js";
+import { registerHostProfileModel } from "../../services/user-profile/profile-model.js";
+import { loadOpencodeProvider } from "./opencode-provider-loader.js";
+import { getOpenCodeClient } from "./profile-llm-client.js";
+/**
+ * Extract assistant text from an OpenCode session.prompt result.
+ * AssistantMessage has no `text` field; content lives in `parts` (#177).
+ */
+export function extractTextFromPromptResult(promptResult) {
+    const result = promptResult;
+    const info = result?.data?.info ?? result?.info;
+    const parts = result?.data?.parts ?? result?.parts ?? [];
+    const rawText = parts
+        .filter((p) => p.type === "text" && p.text)
+        .map((p) => p.text)
+        .join("\n")
+        .trim();
+    return { info, rawText };
+}
+function raceWithTimeout(promise, ms, message) {
+    let timer;
+    const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(message)), ms);
+    });
+    return Promise.race([promise, timeout]).finally(() => {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    });
+}
+/**
+ * Plain-text reply through a transient OpenCode session. Only AI profile cleanup
+ * calls it, so the session carries the cleanup title the history reader skips.
+ */
+async function completeViaSession(v2Client, hostModel, systemPrompt, userPrompt) {
+    const t0 = Date.now();
+    // Only "inherit" (or no model configured) needs resolving to the session's recent model.
+    const model = hostModel.modelID === "inherit"
+        ? (await loadOpencodeProvider()).resolveOpencodeModelRef(hostModel)
+        : hostModel;
+    const created = (await raceWithTimeout(v2Client.session.create({
+        title: "omms profile cleanup",
+        directory: process.cwd(),
+    }), 30000, "session.create timeout"));
+    log("AI cleanup: session.create result", {
+        rawType: typeof created,
+        keys: Object.keys(created || {}),
+        hasData: !!created?.data,
+        dataId: created?.data?.id,
+    });
+    const sessionID = created?.data?.id || created?.id || created?.sessionID;
+    if (!sessionID)
+        throw new Error("session.create returned no session id");
+    log("AI cleanup: session created", { sessionID, createMs: Date.now() - t0 });
+    try {
+        const TIMEOUT_MS = OPENCODE_PROFILE_CLEANUP_TIMEOUT_MS;
+        const promptResult = await raceWithTimeout(v2Client.session.prompt({
+            sessionID,
+            model,
+            system: systemPrompt,
+            parts: [{ type: "text", text: userPrompt }],
+            // `noReply` suppresses assistant generation; cleanup needs the JSON reply (#177).
+            noReply: false,
+        }), TIMEOUT_MS, `opencodeClient prompt timeout after ${TIMEOUT_MS}ms`);
+        log("AI cleanup: session.prompt done", { promptMs: Date.now() - t0 });
+        const { info, rawText } = extractTextFromPromptResult(promptResult);
+        if (!info)
+            throw new Error("prompt response missing info");
+        if (info.error)
+            throw new Error(`opencode reported ${info.error.name}: ${info.error.data?.message ?? ""}`);
+        return rawText;
+    }
+    finally {
+        try {
+            await v2Client.session.delete({ sessionID });
+        }
+        catch {
+            // ignore cleanup failures for ephemeral sessions
+        }
+    }
+}
+/** Adapt OpenCode's host model to the shared profile code, as `adaptPiProfileModel` does for Pi. */
+export function adaptOpencodeProfileModel(v2Client, hostModel) {
+    return {
+        provider: hostModel.providerID,
+        modelId: hostModel.modelID,
+        complete: (systemPrompt, userPrompt) => completeViaSession(v2Client, hostModel, systemPrompt, userPrompt),
+        async completeStructured(systemPrompt, userPrompt, schema) {
+            const client = await getOpenCodeClient();
+            const { generateStructuredOutput } = await loadOpencodeProvider();
+            return generateStructuredOutput({
+                client,
+                providerID: hostModel.providerID,
+                modelID: hostModel.modelID,
+                systemPrompt,
+                userPrompt,
+                schema,
+            });
+        },
+    };
+}
+/** Route shared profile calls in this process to OpenCode's host model while one is configured. */
+export function registerOpencodeProfileModel() {
+    registerHostProfileModel(async () => {
+        const hostModel = resolveOpencodeHostModel(CONFIG);
+        if (!hostModel)
+            return null;
+        const v2Client = (await loadOpencodeProvider()).getV2Client();
+        if (!v2Client) {
+            log("profile model: opencode client unavailable, falling back to external API");
+            return null;
+        }
+        return adaptOpencodeProfileModel(v2Client, hostModel);
+    });
+}

package/dist/adapters/opencode/user-prompt.d.ts

@@ -1,4 +1,5 @@
-export declare function isStructuredSummaryPromptMessage(userMessage: string): boolean;
+import { isStructuredSummaryPromptMessage } from "../../core/internal-prompt.js";
+export { isStructuredSummaryPromptMessage };
 /** True when a prompt is omms's own internal traffic and must not be recorded or searched. */
 export declare function isInternalPrompt(sessionID: string, userMessage: string): boolean;
 /**

package/dist/adapters/opencode/user-prompt.js

@@ -1,14 +1,7 @@
-import { isInternalStructuredSession } from "../../services/ai/opencode-provider.js";
+import { isStructuredSummaryPromptMessage } from "../../core/internal-prompt.js";
+import { isInternalStructuredSession } from "./opencode-provider.js";
 import { userPromptManager } from "../../services/user-prompt/user-prompt-manager.js";
-export function isStructuredSummaryPromptMessage(userMessage) {
-    // This is the plugin's own structured-summary or profile-analysis request.
-    // OpenCode echoes it through chat.message like a normal user message, but
-    // capturing it would create self-referential memories / an infinite learning loop.
-    if (userMessage.includes("# User Profile Analysis")) {
-        return true;
-    }
-    return userMessage.includes("Analyze this conversation.") && userMessage.includes('type="skip"');
-}
+export { isStructuredSummaryPromptMessage };
 /** True when a prompt is omms's own internal traffic and must not be recorded or searched. */
 export function isInternalPrompt(sessionID, userMessage) {
     return isStructuredSummaryPromptMessage(userMessage) || isInternalStructuredSession(sessionID);

package/dist/adapters/pi/backfill-models.d.ts

@@ -3,6 +3,10 @@ import { type PiModelContext } from "./provider.js";
 /** Resolve the Pi backfill independently of the manual import's session-model rule. */
 export declare function resolvePiBackfillModels(ctx: PiModelContext, config?: {
     piBackfillModel?: string;
+    memoryProvider?: string;
+    memoryModel?: string;
+    memoryApiUrl?: string;
+    memoryApiKey?: string;
 }): Promise<{
     model: string;
     models: HistoryImportModels;

package/dist/adapters/pi/backfill-models.js

@@ -1,11 +1,14 @@
 import { CONFIG } from "../../config.js";
 import { parseBackfillModel } from "../../importer/backfill-model.js";
+import { resolveExternalBackfillModels } from "../../importer/external-backfill-models.js";
 import { createPiLiveModels } from "./live-model.js";
 import { adaptPiProfileModel } from "./profile.js";
 import { createPiCaptureProvider, resolveImportModel } from "./provider.js";
 /** Resolve the Pi backfill independently of the manual import's session-model rule. */
 export async function resolvePiBackfillModels(ctx, config = CONFIG) {
     const choice = parseBackfillModel(config, "pi");
+    if (choice === "external")
+        return resolveExternalBackfillModels("pi", config);
     if (choice === "inherit") {
         const live = createPiLiveModels(ctx);
         const profile = live.profile();

package/dist/adapters/pi/capture.d.ts

@@ -1,5 +1,5 @@
 import type { CaptureSummaryProvider } from "../../core/host.js";
-import { type PiSessionEntry } from "./conversation.js";
+import { type PiSessionEntry } from "../../importer/pi-conversation.js";
 export interface PiCaptureState {
     /** User entry IDs terminally handled by a settled capture for this session. */
     handledUserEntries: Set<string>;

package/dist/adapters/pi/capture.js

@@ -2,7 +2,7 @@ import { CONFIG } from "../../config.js";
 import { captureConversation } from "../../core/capture.js";
 import { log } from "../../services/logger.js";
 import { memoryClient } from "../../services/client.js";
-import { extractPiConversation } from "./conversation.js";
+import { extractPiConversation } from "../../importer/pi-conversation.js";
 export function createPiCaptureState() {
     return { handledUserEntries: new Set(), running: false };
 }

package/dist/adapters/pi/extension.js

@@ -111,6 +111,13 @@ export default function ommsPiExtension(pi) {
                     code: error instanceof Error ? error.name : "unknown",
                 }));
             }
+            // Run now on a Settings page served by this process can use Pi's signed-in models.
+            void Promise.all([
+                import("../../importer/backfill-controls.js"),
+                import("./backfill-models.js"),
+            ])
+                .then(([{ registerHostBackfillModels }, { resolvePiBackfillModels }]) => registerHostBackfillModels("pi", () => resolvePiBackfillModels(ctx)))
+                .catch(() => { });
             const globalScope = globalThis;
             const sessionId = ctx.sessionManager.getSessionId();
             if (isConfigured() &&

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

@@ -90,6 +90,7 @@ export function registerPiHistoryImportCommand(pi, getExtensionContext) {
                 let lastProgressNotify = 0;
                 const report = await runHistoryImport("pi", parsed, {
                     cwd: ctx.cwd,
+                    track: { surface: "slash" },
                     models: selectedModel && !parsed.dryRun
                         ? {
                             capture: createPiCaptureProvider(() => selectedModel),

package/dist/cli/index.js

@@ -14,6 +14,9 @@ Commands:
   web                       Start the web app in the foreground
   web install|uninstall|status  Manage the web app login item
 
+Options:
+  --version, -v             Print the installed version
+
 Import commands take the same options; run one with --help to see them.
 Inside a session, /memory-import-opencode-history and /memory-import-pi-history
 use that session's model instead of an API key.`;
@@ -28,6 +31,11 @@ export function parseImportArgs(argv) {
     return { host, args };
 }
 export async function runCli(argv) {
+    if (argv[0] === "--version" || argv[0] === "-v") {
+        const { packageVersion } = await import("../services/package-version.js");
+        console.log(packageVersion());
+        return 0;
+    }
     if (argv.length === 0 || argv[0] === "--help" || argv[0] === "-h") {
         console.log(usage);
         return 0;
@@ -73,7 +81,11 @@ export async function runCli(argv) {
             console.log(`Import model: ${model}`);
         }
         const { formatHistoryImportReport, historyImportFailed, runHistoryImport } = await import("../importer/run-import.js");
-        const report = await runHistoryImport(host, args, { cwd: process.cwd(), models });
+        const report = await runHistoryImport(host, args, {
+            cwd: process.cwd(),
+            models,
+            track: { surface: "cli" },
+        });
         console.log(formatHistoryImportReport(host, report, model));
         return historyImportFailed(report) ? 1 : 0;
     }