om-memory-system 3.4.0-next.26 → 3.4.2

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

@@ -3,7 +3,7 @@ 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");

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

@@ -11,3 +11,5 @@ export declare function registerOpencodeBackfillModels(input: {
     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,7 +1,10 @@
 import { CONFIG } from "../../config.js";
 import { scheduleAutoBackfill } from "../../importer/auto-backfill.js";
-import { registerHostBackfillModels } from "../../importer/backfill-controls.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({
@@ -15,3 +18,14 @@ export function startOpencodeBackfill(input) {
 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";

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.js

@@ -1,5 +1,5 @@
 import { isStructuredSummaryPromptMessage } from "../../core/internal-prompt.js";
-import { isInternalStructuredSession } from "../../services/ai/opencode-provider.js";
+import { isInternalStructuredSession } from "./opencode-provider.js";
 import { userPromptManager } from "../../services/user-prompt/user-prompt-manager.js";
 export { isStructuredSummaryPromptMessage };
 /** True when a prompt is omms's own internal traffic and must not be recorded or searched. */

package/dist/core/profile-analysis.d.ts

@@ -1,8 +1,11 @@
+import { z } from "zod";
 import type { UserProfileData } from "../services/user-profile/types.js";
 export interface ModelPort {
     provider: string;
     modelId: string;
     complete(systemPrompt: string, userPrompt: string): Promise<string>;
+    /** Host-enforced JSON output; callers fall back to `complete` and parse when absent. */
+    completeStructured?<T>(systemPrompt: string, userPrompt: string, schema: z.ZodType<T>): Promise<T>;
 }
 export interface ExistingProfileInput {
     id: string;

package/dist/importer/backfill-controls.d.ts

@@ -6,6 +6,22 @@ type ResolveModels = () => Promise<{
     models: HistoryImportModels;
 }>;
 export declare function registerHostBackfillModels(host: BackfillHost, resolve: ResolveModels): void;
+export interface SettingsModel {
+    provider: string;
+    model: string;
+    name: string;
+}
+/** OpenCode's model access for web imports, Health, and Settings, when OpenCode runs this process. */
+export interface OpencodeHostModels {
+    isProviderConnected(providerID: string): boolean;
+    createImportModels(ref: {
+        providerID: string;
+        modelID: string;
+    }, directory: string): Promise<Required<HistoryImportModels>>;
+    listSettingsModels(): Promise<SettingsModel[] | null>;
+}
+export declare function registerOpencodeHostModels(models: OpencodeHostModels | null): void;
+export declare function getOpencodeHostModels(): OpencodeHostModels | null;
 /** A control request the page cannot carry out; `status` is the HTTP status. */
 export declare class BackfillControlError extends Error {
     readonly status: number;

package/dist/importer/backfill-controls.js

@@ -8,6 +8,13 @@ const hostResolvers = new Map();
 export function registerHostBackfillModels(host, resolve) {
     hostResolvers.set(host, resolve);
 }
+let opencodeHostModels = null;
+export function registerOpencodeHostModels(models) {
+    opencodeHostModels = models;
+}
+export function getOpencodeHostModels() {
+    return opencodeHostModels;
+}
 /** A control request the page cannot carry out; `status` is the HTTP status. */
 export class BackfillControlError extends Error {
     status;

package/dist/importer/import-readiness.js

@@ -24,7 +24,7 @@ export async function importReadiness(deps = {}) {
     const [state, opencode, piReader] = await Promise.all([
         externalApiState(deps.supportedProviders),
         (deps.listOpencodeModels ??
-            (async () => (await import("../services/settings-models.js")).listOpencodeSettingsModels()))(),
+            (async () => (await import("./settings-models.js")).listOpencodeSettingsModels()))(),
         (deps.loadPiSdk ?? (() => import("@earendil-works/pi-coding-agent")))().then(() => ({ available: true }), () => ({
             available: false,
             reason: "The Pi SDK (@earendil-works/pi-coding-agent) is not installed for OpenCode",

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/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-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();

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 {

package/dist/services/user-profile/ai-cleanup.d.ts

@@ -35,22 +35,6 @@ interface AIMapping {
     merged: string[][];
     removed: string[];
 }
-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;
-};
 export declare function rebuildProfileUsing(mapping: AIMapping, cleanedById: Map<string, IndexedProfileItem>, originalById: Map<string, IndexedProfileItem>, counters?: {
     cleaned: number;
     original: number;

package/dist/services/user-profile/ai-cleanup.js

@@ -1,8 +1,7 @@
 import { CONFIG } from "../../config.js";
-import { resolveOpencodeHostModel } from "../ai/live-model-choice.js";
 import { log } from "../logger.js";
-import { loadOpencodeProvider } from "../ai/opencode-provider-loader.js";
-import { EXTERNAL_PROFILE_CLEANUP_TIMEOUT_MS, OPENCODE_PROFILE_CLEANUP_TIMEOUT_MS, } from "../request-timeouts.js";
+import { resolveHostProfileModel } from "./profile-model.js";
+import { EXTERNAL_PROFILE_CLEANUP_TIMEOUT_MS } from "../request-timeouts.js";
 import { applySafeExtraParams } from "../ai/providers/base-provider.js";
 export async function aiCleanupProfile(profileData) {
     const t0 = Date.now();
@@ -149,16 +148,12 @@ function formatForAI(item) {
     return { id, category, description, frequency };
 }
 async function callAICleanup(prompt) {
-    // Use opencode internal session when opencodeProvider is configured (same pattern as auto-capture).
-    // When the client is available, surface OpenCode errors instead of masking them as
+    // Use the host model when the host registered one (same pattern as auto-capture).
+    // When it is available, surface its errors instead of masking them as
     // "No AI provider configured" via a silent fallback (#177).
-    if (resolveOpencodeHostModel(CONFIG)) {
-        const { getV2Client } = await loadOpencodeProvider();
-        const v2Client = getV2Client();
-        if (v2Client) {
-            return callViaOpencodeWithClient(v2Client, prompt);
-        }
-        log("AI cleanup: opencode client unavailable, falling back to external API");
+    const hostModel = await resolveHostProfileModel();
+    if (hostModel) {
+        return callViaHostModel(hostModel, prompt);
     }
     if (CONFIG.memoryModel && CONFIG.memoryApiUrl) {
         return callViaExternalAPI(prompt);
@@ -208,86 +203,17 @@ async function callViaExternalAPI(prompt) {
         mapping: normalizeAIMapping(parsed.mapping),
     };
 }
-/**
- * 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);
-    });
-}
-async function callViaOpencodeWithClient(v2Client, prompt) {
-    const t0 = Date.now();
-    const hostModel = resolveOpencodeHostModel(CONFIG) ?? { providerID: "", modelID: "inherit" };
-    // Only "inherit" (or no model configured) needs resolving to the session's recent model.
-    const model = hostModel.modelID === "inherit"
-        ? (await loadOpencodeProvider()).resolveOpencodeModelRef(hostModel)
-        : hostModel;
+async function callViaHostModel(model, prompt) {
     const systemPrompt = "You are a user profile cleanup assistant. Merge duplicate entries and return only JSON without markdown wrapping.";
-    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: prompt }],
-            // `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 ?? ""}`);
-        const jsonMatch = rawText.match(/\{[\s\S]*\}/);
-        if (!jsonMatch)
-            throw new Error("AI response did not contain valid JSON");
-        const parsed = JSON.parse(jsonMatch[0]);
-        return {
-            profile: parsed,
-            mapping: normalizeAIMapping(parsed.mapping),
-        };
-    }
-    finally {
-        try {
-            await v2Client.session.delete({ sessionID });
-        }
-        catch {
-            // ignore cleanup failures for ephemeral sessions
-        }
-    }
+    const rawText = await model.complete(systemPrompt, prompt);
+    const jsonMatch = rawText.match(/\{[\s\S]*\}/);
+    if (!jsonMatch)
+        throw new Error("AI response did not contain valid JSON");
+    const parsed = JSON.parse(jsonMatch[0]);
+    return {
+        profile: parsed,
+        mapping: normalizeAIMapping(parsed.mapping),
+    };
 }
 function buildItemIndex(profile) {
     const map = new Map();

package/dist/services/user-profile/profile-model.d.ts

@@ -0,0 +1,8 @@
+import type { z } from "zod";
+import type { ModelPort } from "../../core/profile-analysis.js";
+type ResolveProfileModel = () => Promise<ModelPort | null>;
+export declare function registerHostProfileModel(resolve: ResolveProfileModel | null): void;
+/** A host model that fails to resolve counts as unavailable, so callers keep their external API fallback. */
+export declare function resolveHostProfileModel(): Promise<ModelPort | null>;
+export declare function completeStructured<T>(model: ModelPort, systemPrompt: string, userPrompt: string, schema: z.ZodType<T>): Promise<T>;
+export {};

package/dist/services/user-profile/profile-model.js

@@ -0,0 +1,31 @@
+import { extractJsonObject } from "../../core/extraction.js";
+import { log } from "../logger.js";
+/**
+ * The host model for profile dedup, conflict, description, and cleanup calls in
+ * this process. A host registers it at start-up; with none, or when it resolves
+ * to null, those calls use the external API.
+ */
+let hostProfileModel = null;
+export function registerHostProfileModel(resolve) {
+    hostProfileModel = resolve;
+}
+/** A host model that fails to resolve counts as unavailable, so callers keep their external API fallback. */
+export async function resolveHostProfileModel() {
+    if (!hostProfileModel)
+        return null;
+    try {
+        return await hostProfileModel();
+    }
+    catch (error) {
+        log("profile model: host model unavailable, falling back to external API", {
+            error: String(error),
+        });
+        return null;
+    }
+}
+export async function completeStructured(model, systemPrompt, userPrompt, schema) {
+    if (model.completeStructured) {
+        return model.completeStructured(systemPrompt, userPrompt, schema);
+    }
+    return schema.parse(extractJsonObject(await model.complete(systemPrompt, userPrompt)));
+}

package/dist/services/user-profile/user-profile-manager.d.ts

@@ -59,7 +59,7 @@ export declare class UserProfileManager {
     private checkConflict;
     private evolveDescription;
     evolveAndUpdate(item: any, itemType: string, profileId?: string): Promise<void>;
-    private callOpencodeProvider;
+    private callHostModel;
     private callExternalAPI;
 }
 export declare const userProfileManager: UserProfileManager;

package/dist/services/user-profile/user-profile-manager.js

@@ -2,12 +2,11 @@ import { join } from "node:path";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { tursoConnectionManager } from "../turso/connection-manager.js";
 import { CONFIG } from "../../config.js";
-import { resolveOpencodeHostModel } from "../ai/live-model-choice.js";
+import { completeStructured, resolveHostProfileModel } from "./profile-model.js";
 import { safeArray } from "./profile-utils.js";
 import { EmbeddingService } from "../embedding.js";
 import { log } from "../logger.js";
 import { cosineSimilarityNumbers, l2Normalize } from "../../utils/math.js";
-import { loadOpencodeProvider } from "../ai/opencode-provider-loader.js";
 const CENTROID_EMA_WEIGHT = 0.85;
 const CENTROID_EMA_WEIGHT_COMPLEMENT = 0.15;
 const THREE_WAY_CENTROID_W1 = 0.45;
@@ -1179,32 +1178,15 @@ A: "${descA}"
 B: "${descB}"
 
 Answer JSON only: { "duplicate": true|false, "reason": "one sentence explanation" }`;
-        if (resolveOpencodeHostModel(CONFIG)) {
+        const hostModel = await resolveHostProfileModel();
+        if (hostModel) {
             try {
                 const { z } = await import("zod");
-                const { generateStructuredOutput } = await loadOpencodeProvider();
-                const { getOpenCodeClient } = await import("../ai/profile-llm-client.js");
-                let v2Client;
-                try {
-                    v2Client = await getOpenCodeClient();
-                }
-                catch (e) {
-                    log("profile dedup check: native provider not connected", { error: String(e) });
-                }
-                if (v2Client) {
-                    const result = await Promise.race([
-                        generateStructuredOutput({
-                            client: v2Client,
-                            providerID: resolveOpencodeHostModel(CONFIG).providerID,
-                            modelID: resolveOpencodeHostModel(CONFIG).modelID,
-                            systemPrompt: "You are a semantic duplicate detector. Output valid JSON.",
-                            userPrompt: prompt,
-                            schema: z.object({ duplicate: z.boolean(), reason: z.string() }),
-                        }),
-                        new Promise((_, reject) => setTimeout(() => reject(new Error("dedup check timeout")), 30000)),
-                    ]);
-                    return result.duplicate || false;
-                }
+                const result = await Promise.race([
+                    completeStructured(hostModel, "You are a semantic duplicate detector. Output valid JSON.", prompt, z.object({ duplicate: z.boolean(), reason: z.string() })),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error("dedup check timeout")), 30000)),
+                ]);
+                return result.duplicate || false;
             }
             catch (e) {
                 log("profile dedup check: native provider failed", { error: String(e) });
@@ -1366,32 +1348,15 @@ A: "${descA}"
 B: "${descB}"
 
 Answer JSON only: { "conflict": true|false, "reason": "one sentence explanation" }`;
-        if (resolveOpencodeHostModel(CONFIG)) {
+        const hostModel = await resolveHostProfileModel();
+        if (hostModel) {
             try {
                 const { z } = await import("zod");
-                const { generateStructuredOutput } = await loadOpencodeProvider();
-                const { getOpenCodeClient } = await import("../ai/profile-llm-client.js");
-                let v2Client;
-                try {
-                    v2Client = await getOpenCodeClient();
-                }
-                catch (e) {
-                    log("profile conflict check: native provider not connected", { error: String(e) });
-                }
-                if (v2Client) {
-                    const result = await Promise.race([
-                        generateStructuredOutput({
-                            client: v2Client,
-                            providerID: resolveOpencodeHostModel(CONFIG).providerID,
-                            modelID: resolveOpencodeHostModel(CONFIG).modelID,
-                            systemPrompt: "You are a preference contradiction detector. Output valid JSON.",
-                            userPrompt: prompt,
-                            schema: z.object({ conflict: z.boolean(), reason: z.string() }),
-                        }),
-                        new Promise((_, reject) => setTimeout(() => reject(new Error("conflict check timeout")), 30000)),
-                    ]);
-                    return result.conflict || false;
-                }
+                const result = await Promise.race([
+                    completeStructured(hostModel, "You are a preference contradiction detector. Output valid JSON.", prompt, z.object({ conflict: z.boolean(), reason: z.string() })),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error("conflict check timeout")), 30000)),
+                ]);
+                return result.conflict || false;
             }
             catch (e) {
                 log("profile conflict check: native provider failed", { error: String(e) });
@@ -1482,9 +1447,10 @@ ${evidenceList}
 
 Generate a concise, abstract description of the user's general behavioral tendency.`;
         let newDescription = null;
-        if (resolveOpencodeHostModel(CONFIG)) {
+        const hostModel = await resolveHostProfileModel();
+        if (hostModel) {
             try {
-                newDescription = await this.callOpencodeProvider(systemPrompt, userPrompt);
+                newDescription = await this.callHostModel(hostModel, systemPrompt, userPrompt);
             }
             catch (e) {
                 log("profile description evolution: native provider failed, trying external API", {
@@ -1594,31 +1560,11 @@ Generate a concise, abstract description of the user's general behavioral tenden
             log("profile description evolve error", { type: itemType, error: String(e) });
         }
     }
-    async callOpencodeProvider(systemPrompt, userPrompt) {
-        const { generateStructuredOutput } = await loadOpencodeProvider();
-        const { getOpenCodeClient } = await import("../ai/profile-llm-client.js");
-        let v2Client;
-        try {
-            v2Client = await getOpenCodeClient();
-        }
-        catch (e) {
-            log("profile description evolution: native provider not connected", {
-                provider: resolveOpencodeHostModel(CONFIG)?.providerID,
-                error: String(e),
-            });
-            return null;
-        }
+    async callHostModel(model, systemPrompt, userPrompt) {
         const { z } = await import("zod");
         const schema = z.object({ description: z.string() });
         const result = await Promise.race([
-            generateStructuredOutput({
-                client: v2Client,
-                providerID: resolveOpencodeHostModel(CONFIG).providerID,
-                modelID: resolveOpencodeHostModel(CONFIG).modelID,
-                systemPrompt,
-                userPrompt,
-                schema,
-            }),
+            completeStructured(model, systemPrompt, userPrompt, schema),
             new Promise((_, reject) => setTimeout(() => reject(new Error("evolve description timeout")), 120000)),
         ]);
         return result.description || null;

package/dist/services/web-server.js

@@ -533,7 +533,7 @@ export class WebServer {
                 return this.jsonResponse(await directoryMapsView());
             }
             if (path === "/api/settings/models" && method === "GET") {
-                const { listOpencodeSettingsModels, listPiSettingsModels } = await import("./settings-models.js");
+                const { listOpencodeSettingsModels, listPiSettingsModels } = await import("../importer/settings-models.js");
                 const host = url.searchParams.get("host");
                 if (host === "pi")
                     return this.jsonResponse(await listPiSettingsModels());

package/dist/shared/api/schemas.d.ts

@@ -259,8 +259,8 @@ export declare const ApplyCleanupRequestSchema: z.ZodObject<{
 }, z.core.$strip>;
 export declare const UpdateProfileItemRequestSchema: z.ZodObject<{
     type: z.ZodEnum<{
-        preferences: "preferences";
         patterns: "patterns";
+        preferences: "preferences";
         workflows: "workflows";
     }>;
     index: z.ZodNumber;

package/dist/v2/plugin.js

@@ -1,5 +1,5 @@
 import { OmmsPlugin } from "../index.js";
-import { loadOpencodeProvider } from "../services/ai/opencode-provider-loader.js";
+import { loadOpencodeProvider } from "../adapters/opencode/opencode-provider-loader.js";
 import { registerV2Adapter } from "./adapter.js";
 import { createV2MemoryBridge } from "./memory-bridge.js";
 import { createLegacyClient } from "./legacy-client.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "om-memory-system",
-  "version": "3.4.0-next.26",
+  "version": "3.4.2",
   "description": "Opinionated modular memory system for coding agents (OpenCode + Pi)",
   "type": "module",
   "main": "dist/plugin.js",