om-memory-system 3.0.0 → 3.1.0-next.3

package/dist/adapters/pi/live-model.js

@@ -0,0 +1,86 @@
+import { CONFIG } from "../../config.js";
+import { resolvePiLiveModel, isExternalModelReady } from "../../services/ai/live-model-choice.js";
+import { log } from "../../services/logger.js";
+import { adaptPiProfileModel } from "./profile.js";
+import { createPiCaptureProvider, resolveImportModel, resolveModelFromContext, } from "./provider.js";
+async function externalModels() {
+    const { selectImportModel } = await import("../../importer/model-selection.js");
+    return selectImportModel({});
+}
+function primaryPiModel(ctx) {
+    const choice = resolvePiLiveModel(CONFIG);
+    switch (choice.kind) {
+        case "manual":
+            return "external";
+        case "session":
+            return resolveImportModel(ctx);
+        case "pi":
+            return resolveModelFromContext(ctx, `${choice.provider}/${choice.model}`);
+        case "unready":
+            throw new Error(`omms: live capture is not configured: ${choice.issues.join("; ")}`);
+    }
+}
+function describeMissing() {
+    const choice = resolvePiLiveModel(CONFIG);
+    return choice.kind === "pi"
+        ? `Pi model ${choice.provider}/${choice.model} was not found`
+        : "this Pi session has no model";
+}
+/** Run the Pi model, switching to the external API when it fails and one is configured. */
+async function withFallback(primary, run, external, notify) {
+    let failure = primary ? null : new Error(`omms: ${describeMissing()}`);
+    if (primary) {
+        try {
+            return await run(primary);
+        }
+        catch (error) {
+            failure = error;
+        }
+    }
+    if (!isExternalModelReady(CONFIG))
+        throw failure;
+    const reason = failure instanceof Error ? failure.message : String(failure);
+    log("Pi live model failed, falling back to external API", { error: reason });
+    await Promise.resolve(notify?.({
+        title: "Using fallback provider",
+        message: `Pi model failed (${reason.length > 100 ? `${reason.slice(0, 100)}...` : reason}); using configured fallback.`,
+        variant: "warning",
+        duration: 5000,
+    })).catch(() => { });
+    return external();
+}
+export function createPiLiveModels(ctx, notify) {
+    const capture = {
+        async summarize(request) {
+            const primary = primaryPiModel(ctx);
+            if (primary === "external")
+                return (await externalModels()).capture.summarize(request);
+            return withFallback(primary, (model) => createPiCaptureProvider(() => model).summarize(request), async () => (await externalModels()).capture.summarize(request), notify);
+        },
+    };
+    const profile = () => {
+        let primary;
+        try {
+            primary = primaryPiModel(ctx);
+        }
+        catch (error) {
+            log("Pi profile learning: no live model", { error: String(error) });
+            return null;
+        }
+        if (primary === "external") {
+            return {
+                provider: "external",
+                modelId: "",
+                complete: async (system, prompt) => (await externalModels()).profile.complete(system, prompt),
+            };
+        }
+        if (!primary && !isExternalModelReady(CONFIG))
+            return null;
+        return {
+            provider: primary?.provider ?? "external",
+            modelId: primary?.modelId ?? "",
+            complete: (system, prompt) => withFallback(primary, (model) => adaptPiProfileModel(model).complete(system, prompt), async () => (await externalModels()).profile.complete(system, prompt), notify),
+        };
+    };
+    return { capture, profile };
+}

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

@@ -1,28 +1,18 @@
-import type { UserProfileData } from "../../services/user-profile/types.js";
+import { type ExistingProfileInput, type ProfileAnalysisResult, type ModelPort } from "../../core/profile-analysis.js";
 import type { PiModelHandle } from "./provider.js";
-export interface ExistingProfileInput {
-    id: string;
-    profileData: string;
-}
-export interface ProfileAnalysisResult {
-    raw: UserProfileData;
-    merged: UserProfileData | null;
-}
+export type { ExistingProfileInput, ProfileAnalysisResult } from "../../core/profile-analysis.js";
 export interface PiProfileAnalyzer {
     analyzeProfile(context: string, existingProfile: ExistingProfileInput | null): Promise<ProfileAnalysisResult | null>;
 }
-/**
- * Bridge the shared user-profile analysis onto Pi's model runtime. Uses the
- * same schema and system prompt as the OpenCode structured-output path, so
- * analysis results are validated with the shared schema before they reach the
- * profile storage layer. Model failures throw (mirroring provider semantics);
- * a missing model returns null so callers can skip without disabling anything.
- */
+export declare function adaptPiProfileModel(model: PiModelHandle): ModelPort;
+/** Adapt Pi's model registry to the shared profile analyser. */
 export declare function createPiProfileAnalyzer(resolveModel: () => PiModelHandle | null, timeoutMs?: number): PiProfileAnalyzer;
 export interface PiProfileLearningInput {
     directory: string;
     prompts: string[];
-    resolveModel: () => PiModelHandle | null;
+    resolveModel?: () => PiModelHandle | null;
+    /** Live model with its external-API fallback; takes precedence over resolveModel. */
+    resolveProfileModel?: () => ModelPort | null;
     notify?: (notification: {
         title: string;
         message: string;

package/dist/adapters/pi/profile.js

@@ -1,25 +1,7 @@
-import { z } from "zod";
 import { CONFIG } from "../../config.js";
-import { createUserProfileAnalysisSchema, extractJsonObject } from "../../core/extraction.js";
+import { analyzeProfile, } from "../../core/profile-analysis.js";
 import { log } from "../../services/logger.js";
 import { getTags } from "../../services/tags.js";
-/**
- * System prompt mirrored from the OpenCode profile-learning path
- * (src/services/user-memory-learning.ts, analyzeUserProfile). Kept local so
- * the Pi adapter does not import an OpenCode-coupled module; update both when
- * the analysis contract changes.
- */
-function buildProfileAnalysisSystemPrompt(existingProfile) {
-    return `You are a user behavior analyst for a coding assistant.
-
-Your task is to analyze user prompts and ${existingProfile ? "update" : "create"} a comprehensive user profile.
-
-CRITICAL: Detect the language used by the user in their prompts. You MUST output all descriptions, categories, and text in the SAME language as the user's prompts.
-
-CRITICAL: All JSON string values MUST escape double quotes with backslash. Do NOT use unescaped quotation marks inside string values.
-
-Respond with a single JSON object matching the update_user_profile contract.`;
-}
 function replyText(reply) {
     return reply.content
         .filter((block) => block.type === "text" && typeof block.text === "string")
@@ -27,58 +9,30 @@ function replyText(reply) {
         .join("\n")
         .trim();
 }
-/**
- * Bridge the shared user-profile analysis onto Pi's model runtime. Uses the
- * same schema and system prompt as the OpenCode structured-output path, so
- * analysis results are validated with the shared schema before they reach the
- * profile storage layer. Model failures throw (mirroring provider semantics);
- * a missing model returns null so callers can skip without disabling anything.
- */
+export function adaptPiProfileModel(model) {
+    return {
+        provider: model.provider,
+        modelId: model.modelId,
+        async complete(systemPrompt, userPrompt) {
+            const reply = await model.complete({
+                systemPrompt,
+                messages: [{ role: "user", content: userPrompt, timestamp: Date.now() }],
+            });
+            if (reply.stopReason === "error") {
+                throw new Error(`pi profile analysis: model call failed: ${reply.errorMessage || "unknown error"}`);
+            }
+            return replyText(reply);
+        },
+    };
+}
+/** Adapt Pi's model registry to the shared profile analyser. */
 export function createPiProfileAnalyzer(resolveModel, timeoutMs = 120000) {
     return {
         async analyzeProfile(context, existingProfile) {
             const model = resolveModel();
             if (!model)
                 return null;
-            // Unref'd and cleared so the losing timeout timer never keeps the host
-            // process alive after the race settles.
-            let timeoutId;
-            try {
-                const reply = await Promise.race([
-                    model.complete({
-                        systemPrompt: buildProfileAnalysisSystemPrompt(Boolean(existingProfile)),
-                        messages: [{ role: "user", content: context, timestamp: Date.now() }],
-                    }),
-                    new Promise((_, reject) => {
-                        timeoutId = setTimeout(() => reject(new Error("pi profile analysis: timeout")), timeoutMs);
-                        timeoutId?.unref?.();
-                    }),
-                ]);
-                if (reply.stopReason === "error") {
-                    throw new Error(`pi profile analysis: model call failed: ${reply.errorMessage || "unknown error"}`);
-                }
-                const schema = createUserProfileAnalysisSchema(z);
-                const parsed = schema.safeParse(extractJsonObject(replyText(reply)));
-                if (!parsed.success) {
-                    log("pi profile analysis: model reply failed shared schema validation", {
-                        provider: model.provider,
-                        modelId: model.modelId,
-                    });
-                    throw new Error("pi profile analysis: invalid profile payload");
-                }
-                const rawData = parsed.data;
-                if (existingProfile) {
-                    const { userProfileManager } = await import("../../services/user-profile/user-profile-manager.js");
-                    const existingData = JSON.parse(existingProfile.profileData);
-                    const merged = await userProfileManager.mergeProfileData(existingData, rawData, undefined, existingProfile.id);
-                    return { raw: rawData, merged };
-                }
-                return { raw: rawData, merged: null };
-            }
-            finally {
-                if (timeoutId)
-                    clearTimeout(timeoutId);
-            }
+            return analyzeProfile(adaptPiProfileModel(model), context, existingProfile, timeoutMs);
         },
     };
 }
@@ -103,7 +57,15 @@ export async function performPiProfileLearning(input) {
         const userId = tags.user.userEmail;
         const { userProfileManager } = await import("../../services/user-profile/user-profile-manager.js");
         const existing = await userProfileManager.getActiveProfile(userId);
-        const analyzer = createPiProfileAnalyzer(input.resolveModel);
+        const resolveProfileModel = input.resolveProfileModel;
+        const analyzer = resolveProfileModel
+            ? {
+                async analyzeProfile(context, existingProfile) {
+                    const model = resolveProfileModel();
+                    return model ? analyzeProfile(model, context, existingProfile) : null;
+                },
+            }
+            : createPiProfileAnalyzer(input.resolveModel ?? (() => null));
         const context = input.prompts.map((prompt, i) => `${i + 1}. ${prompt}`).join("\n");
         const analysis = await analyzer.analyzeProfile(context, existing ? { id: existing.id, profileData: existing.profileData } : null);
         if (!analysis) {

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

@@ -10,8 +10,15 @@ export interface PiModelContext {
 /**
  * Active-model-first resolution: the explicit `piProvider`/`piModel`
  * configuration when both are set, otherwise the active `ctx.model`.
+ * A supplied import override resolves strictly through Pi's model registry.
  */
-export declare function resolveModelFromContext(ctx: PiModelContext): PiModelHandle | null;
+export declare function resolveModelFromContext(ctx: PiModelContext, override?: string): PiModelHandle | null;
+/**
+ * History-import resolution: an explicit `provider/id` through Pi's model
+ * registry, otherwise the session's current model. `piProvider`/`piModel`
+ * steer live capture only; an import follows the session the user is in.
+ */
+export declare function resolveImportModel(ctx: PiModelContext, override?: string): PiModelHandle | null;
 /**
  * Structural view of the pieces we use from Pi's ModelRegistry/Model so the
  * bridge stays testable without importing Pi runtime types.

package/dist/adapters/pi/provider.js

@@ -6,17 +6,42 @@ import { log } from "../../services/logger.js";
 /**
  * Active-model-first resolution: the explicit `piProvider`/`piModel`
  * configuration when both are set, otherwise the active `ctx.model`.
+ * A supplied import override resolves strictly through Pi's model registry.
  */
-export function resolveModelFromContext(ctx) {
+export function resolveModelFromContext(ctx, override) {
     const registry = ctx?.modelRegistry;
     if (!registry)
         return null;
     let model = null;
-    if (CONFIG.piProvider && CONFIG.piModel) {
-        model = registry.find(CONFIG.piProvider, CONFIG.piModel) ?? null;
+    if (override !== undefined) {
+        const separator = override.indexOf("/");
+        if (separator < 1 || separator === override.length - 1)
+            return null;
+        model = registry.find(override.slice(0, separator), override.slice(separator + 1)) ?? null;
+        if (!model)
+            return null;
     }
-    if (!model)
-        model = ctx?.model ?? null;
+    else {
+        if (CONFIG.piProvider && CONFIG.piModel) {
+            model = registry.find(CONFIG.piProvider, CONFIG.piModel) ?? null;
+        }
+        if (!model)
+            model = ctx?.model ?? null;
+    }
+    return toModelHandle(registry, model);
+}
+/**
+ * History-import resolution: an explicit `provider/id` through Pi's model
+ * registry, otherwise the session's current model. `piProvider`/`piModel`
+ * steer live capture only; an import follows the session the user is in.
+ */
+export function resolveImportModel(ctx, override) {
+    if (override !== undefined)
+        return resolveModelFromContext(ctx, override);
+    const registry = ctx?.modelRegistry;
+    return registry ? toModelHandle(registry, ctx.model) : null;
+}
+function toModelHandle(registry, model) {
     if (!model)
         return null;
     return {
@@ -63,11 +88,14 @@ export function createPiCaptureProvider(resolveModel) {
             if (reply.stopReason === "error") {
                 throw new Error(`omms: Pi extraction call failed: ${reply.errorMessage || "unknown error"}`);
             }
-            const summary = parseCaptureSummary(replyText(reply));
+            const rawReply = replyText(reply);
+            const summary = parseCaptureSummary(rawReply);
             if (!summary) {
                 log("Pi capture: model reply was not a valid capture summary", {
                     provider: model.provider,
                     modelId: model.modelId,
+                    // The reply can carry conversation content, so log only its size.
+                    replyLength: rawReply.length,
                 });
                 throw new Error("omms: Pi extraction returned an invalid summary payload");
             }

package/dist/cli/index.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { type HistoryImportArgs, type ImportHost } from "../importer/import-args.js";
+export declare function parseImportArgs(argv: string[]): {
+    host: ImportHost;
+    args: HistoryImportArgs;
+};
+export declare function runCli(argv: string[]): Promise<number>;

package/dist/cli/index.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+import { realpathSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+import { historyImportUsage, importNeedsModel, parseHistoryImportArgs, } from "../importer/import-args.js";
+const COMMANDS = {
+    "import-opencode-history": "opencode",
+    "import-pi-history": "pi",
+};
+const usage = `Usage: om-memory-system <command> [options]
+
+Commands:
+  import-opencode-history   Import OpenCode history into omms
+  import-pi-history         Import Pi history into omms
+
+Both 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.`;
+export function parseImportArgs(argv) {
+    const [command, ...rest] = argv;
+    const host = command ? COMMANDS[command] : undefined;
+    if (!host)
+        throw new Error("Expected import-opencode-history or import-pi-history; use --help");
+    const args = parseHistoryImportArgs(rest, { host, surface: "cli" });
+    if (!args.help && args.errors.length > 0)
+        throw new Error(args.errors.join("; "));
+    return { host, args };
+}
+export async function runCli(argv) {
+    if (argv.length === 0 || argv[0] === "--help" || argv[0] === "-h") {
+        console.log(usage);
+        return 0;
+    }
+    const apiKeyEnv = argv.find((_, index) => argv[index - 1] === "--api-key-env") ??
+        argv.find((value) => value.startsWith("--api-key-env="))?.slice("--api-key-env=".length);
+    try {
+        const { host, args } = parseImportArgs(argv);
+        if (args.help) {
+            console.log(historyImportUsage(host, "cli"));
+            return 0;
+        }
+        const { initConfig, initConfigWithLegacyMigration } = await import("../config.js");
+        if (args.dryRun)
+            initConfig(process.cwd());
+        else
+            initConfigWithLegacyMigration(process.cwd());
+        let models = {};
+        let model;
+        if (importNeedsModel(args)) {
+            const { selectImportModel } = await import("../importer/model-selection.js");
+            const selected = selectImportModel({
+                provider: args.provider,
+                model: args.model,
+                apiUrl: args.apiUrl,
+                apiKeyEnv: args.apiKeyEnv,
+            });
+            models = {
+                ...(!args.skipMemories ? { capture: selected.capture } : {}),
+                ...(!args.skipProfile ? { profile: selected.profile } : {}),
+            };
+            model = `${selected.provider}/${selected.modelId}`;
+            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 });
+        console.log(formatHistoryImportReport(host, report, model));
+        return historyImportFailed(report) ? 1 : 0;
+    }
+    catch (error) {
+        const { CONFIG } = await import("../config.js");
+        const secrets = [apiKeyEnv ? process.env[apiKeyEnv] : undefined, CONFIG.memoryApiKey].filter((value) => Boolean(value));
+        let message = error instanceof Error ? error.message : String(error);
+        for (const secret of secrets)
+            message = message.replaceAll(secret, "[redacted]");
+        console.error(`Import failed: ${message}`);
+        return 1;
+    }
+}
+function isDirectRun() {
+    if (!process.argv[1])
+        return false;
+    try {
+        // Resolve symlinks: npm/npx expose the bin through node_modules/.bin links,
+        // so comparing the raw argv[1] against the module URL would never match.
+        return import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href;
+    }
+    catch {
+        return false;
+    }
+}
+if (isDirectRun()) {
+    runCli(process.argv.slice(2)).then((exitCode) => {
+        process.exitCode = exitCode;
+    });
+}

package/dist/config.d.ts

@@ -31,7 +31,10 @@ interface OmmsConfig {
     memoryExtraParams?: Record<string, unknown>;
     opencodeProvider?: string;
     opencodeModel?: string;
-    /** Pi adapter: explicit provider/model for capture extraction. Default: inherit active Pi model. */
+    /**
+     * Pi adapter: provider/model for live capture and profile learning ("inherit" = session
+     * model). Unset: the external API when configured, otherwise the session model.
+     */
     piProvider?: string;
     piModel?: string;
     aiSessionRetentionDays?: number;
@@ -114,7 +117,7 @@ declare function buildConfig(fileConfig: OmmsConfig): {
     opencodeModel: string | undefined;
     piProvider: string | undefined;
     piModel: string | undefined;
-    autoCaptureProviderStatus: AutoCaptureProviderStatus;
+    autoCaptureProviderStatus: import("./config.js").AutoCaptureProviderStatus;
     aiSessionRetentionDays: number;
     webServerEnabled: boolean;
     webServerPort: number;
@@ -196,7 +199,7 @@ export declare let CONFIG: {
     opencodeModel: string | undefined;
     piProvider: string | undefined;
     piModel: string | undefined;
-    autoCaptureProviderStatus: AutoCaptureProviderStatus;
+    autoCaptureProviderStatus: import("./config.js").AutoCaptureProviderStatus;
     aiSessionRetentionDays: number;
     webServerEnabled: boolean;
     webServerPort: number;
@@ -249,24 +252,8 @@ export declare let CONFIG: {
     };
 };
 type RuntimeConfig = ReturnType<typeof buildConfig>;
-interface AutoCaptureProviderRuntimeConfig {
-    opencodeProvider?: string;
-    opencodeModel?: string;
-    memoryProvider?: string;
-    memoryModel?: string;
-    memoryApiUrl?: string;
-    memoryApiKey?: string;
-}
-export type AutoCaptureProviderStatus = {
-    ready: true;
-    mode: "opencode" | "manual";
-    issues: [];
-} | {
-    ready: false;
-    issues: string[];
-};
+export { getAutoCaptureProviderStatus, type AutoCaptureProviderStatus, } from "./services/ai/live-model-choice.js";
 export { isPlaceholderApiKey };
-export declare function getAutoCaptureProviderStatus(config: AutoCaptureProviderRuntimeConfig): AutoCaptureProviderStatus;
 export declare function hasAutoCaptureProviderConfig(config?: RuntimeConfig): boolean;
 export declare function initConfig(directory: string): void;
 /**

package/dist/config.js

@@ -5,6 +5,7 @@ import { stripJsoncComments } from "./services/jsonc.js";
 import { log } from "./services/logger.js";
 import { resolveSecretValue } from "./services/secret-resolver.js";
 import { isPlaceholderApiKey } from "./services/ai/api-key-placeholder.js";
+import { getAutoCaptureProviderStatus } from "./services/ai/live-model-choice.js";
 import { resolveDefaultStoragePath, runLegacyStoreMigration, legacyMigrationPaths, } from "./services/legacy-migration.js";
 const OMMS_CONFIG_DIR = join(homedir(), ".config", "omms");
 const DATA_DIR = join(homedir(), ".omms");
@@ -229,35 +230,38 @@ const CONFIG_TEMPLATE = `{
   },
 
   // ============================================
-  // OpenCode Provider Settings (RECOMMENDED)
+  // Model for auto-capture and profile learning (same rule in OpenCode and Pi)
   // ============================================
 
-   // Use any provider that is already authenticated in opencode for auto-capture
-   // and user profile learning. The plugin calls opencode's session.prompt API
-   // (with structured output) instead of talking to provider HTTPS endpoints
-   // directly, so opencode owns the auth, token refresh, and provider routing.
+   // Which model summarises your work, in this order:
+   //   1. The host model below: opencodeProvider/opencodeModel in OpenCode,
+   //      piProvider/piModel in Pi. Set the model to "inherit" to follow
+   //      whatever model the session is using.
+   //   2. If no host model is set: the external API (memoryModel/memoryApiUrl/
+   //      memoryApiKey further down).
+   //   3. If neither is set: the session's own model.
+   // If the host model fails and the external API is configured, the external
+   // API is used instead.
    //
-   // No separate API key is needed in this plugin — whatever you configured in
-   // opencode (OAuth like Claude Pro/Max, GitHub Copilot personal/business,
-   // bring-your-own API key, custom provider, ...) just works.
+   // Host models go through OpenCode's or Pi's own sign-in (OAuth like Claude
+   // Pro/Max, GitHub Copilot, ChatGPT, or your own key there), so no separate API
+   // key is needed here.
    //
-   // If NOT set, falls back to the manual config (memoryApiKey/memoryApiUrl/memoryModel below).
-   //
-   // Examples (the provider name must be one returned by 'opencode providers list'):
-   //   Anthropic (OAuth/API key): "opencodeProvider": "anthropic",      "opencodeModel": "claude-haiku-4-5-20251001"
-   //   OpenAI (API key):          "opencodeProvider": "openai",          "opencodeModel": "gpt-4o-mini"
-   //   GitHub Copilot:            "opencodeProvider": "github-copilot",  "opencodeModel": "gpt-4o-mini"
+   // Examples (OpenCode names from 'opencode providers list'; Pi names from its model list):
+   //   "opencodeProvider": "anthropic",    "opencodeModel": "claude-haiku-4-5-20251001"
+   //   "opencodeProvider": "openai",       "opencodeModel": "inherit"
+   //   "piProvider": "openai-codex",       "piModel": "gpt-5.6-luna"
    //
    // "opencodeProvider": "anthropic",
    // "opencodeModel": "claude-haiku-4-5-20251001",
+   // "piProvider": "openai-codex",
+   // "piModel": "gpt-5.6-luna",
 
    // ============================================
    // Auto-Capture Settings
    // ============================================
   
-  // IMPORTANT: Auto-capture only runs after either opencodeProvider/opencodeModel
-  // above is configured, or the manual fallback below is uncommented with real values.
-  // It runs in background without blocking your main session
+  // Auto-capture runs in the background without blocking your main session.
   // Note: Ollama may not support tool calling. Use OpenAI, Anthropic, or Groq for best results.
   
   "autoCaptureEnabled": true,
@@ -267,7 +271,8 @@ const CONFIG_TEMPLATE = `{
   // Any service that follows the OpenAI Chat Completions API can use it via custom "memoryApiUrl".
   "memoryProvider": "openai-chat",
   
-  // Manual fallback. Uncomment all 3 lines and replace memoryApiKey before use:
+  // External API (step 2 above, and the fallback when a host model fails).
+  // Uncomment all 3 lines and replace memoryApiKey before use:
   // "memoryModel": "gpt-4o-mini",
   // "memoryApiUrl": "https://api.openai.com/v1",
   // "memoryApiKey": "sk-...",
@@ -636,50 +641,8 @@ function buildConfig(fileConfig) {
 const _globalFileConfig = loadConfigFromPaths(CONFIG_FILES);
 let lastFileConfig = _globalFileConfig;
 export let CONFIG = buildConfig(_globalFileConfig);
-function hasValue(value) {
-    return typeof value === "string" && value.trim().length > 0;
-}
+export { getAutoCaptureProviderStatus, } from "./services/ai/live-model-choice.js";
 export { isPlaceholderApiKey };
-export function getAutoCaptureProviderStatus(config) {
-    const hasOpencodeProvider = hasValue(config.opencodeProvider);
-    const hasOpencodeModel = hasValue(config.opencodeModel);
-    if (hasOpencodeProvider && hasOpencodeModel) {
-        return { ready: true, mode: "opencode", issues: [] };
-    }
-    const issues = [];
-    if (!hasOpencodeProvider)
-        issues.push("opencodeProvider is not configured");
-    if (!hasOpencodeModel)
-        issues.push("opencodeModel is not configured");
-    const hasMemoryModel = hasValue(config.memoryModel);
-    const hasMemoryApiUrl = hasValue(config.memoryApiUrl);
-    const hasMemoryApiKey = hasValue(config.memoryApiKey);
-    const hasPlaceholderMemoryApiKey = isPlaceholderApiKey(config.memoryApiKey);
-    // The orcarouter provider presets its endpoint and default model, so only
-    // an API key is required for the manual fallback path.
-    if (config.memoryProvider === "orcarouter") {
-        if (!hasMemoryApiKey)
-            issues.push("memoryApiKey is not configured");
-        if (hasPlaceholderMemoryApiKey)
-            issues.push("memoryApiKey contains a placeholder value");
-        if (hasMemoryApiKey && !hasPlaceholderMemoryApiKey) {
-            return { ready: true, mode: "manual", issues: [] };
-        }
-        return { ready: false, issues };
-    }
-    if (!hasMemoryModel)
-        issues.push("memoryModel is not configured");
-    if (!hasMemoryApiUrl)
-        issues.push("memoryApiUrl is not configured");
-    if (!hasMemoryApiKey)
-        issues.push("memoryApiKey is not configured");
-    if (hasPlaceholderMemoryApiKey)
-        issues.push("memoryApiKey contains a placeholder value");
-    if (hasMemoryModel && hasMemoryApiUrl && hasMemoryApiKey && !hasPlaceholderMemoryApiKey) {
-        return { ready: true, mode: "manual", issues: [] };
-    }
-    return { ready: false, issues };
-}
 export function hasAutoCaptureProviderConfig(config = CONFIG) {
     return getAutoCaptureProviderStatus(config).ready;
 }

package/dist/core/extraction.d.ts

@@ -8,9 +8,9 @@ import type { CaptureSummary } from "./host.js";
  * downstream capture pipeline always receives well-formed results.
  */
 export declare const captureSummarySchema: z.ZodObject<{
-    summary: z.ZodString;
+    summary: z.ZodDefault<z.ZodString>;
     type: z.ZodString;
-    tags: z.ZodArray<z.ZodString>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 /**
  * JSON schema description embedded into the summary request prompt. Kept as a

package/dist/core/extraction.js

@@ -6,10 +6,15 @@ import { z } from "zod";
  * the same summary shape and validate model output against this schema so the
  * downstream capture pipeline always receives well-formed results.
  */
-export const captureSummarySchema = z.object({
-    summary: z.string(),
+export const captureSummarySchema = z
+    .object({
+    summary: z.string().default(""),
     type: z.string(),
-    tags: z.array(z.string()),
+    tags: z.array(z.string()).default([]),
+})
+    .refine((value) => value.type === "skip" || value.summary.trim().length > 0, {
+    message: "A non-skip capture needs a summary",
+    path: ["summary"],
 });
 /**
  * JSON schema description embedded into the summary request prompt. Kept as a