om-memory-system 3.2.0-next.9 → 3.3.0-next.18

package/README.md

@@ -26,8 +26,7 @@ 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.** One command turns old OpenCode or Pi
-  history into memories and a profile.
+- **Imports your past sessions.** Pi and OpenCode import older history after startup. A command provides 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
@@ -98,13 +97,12 @@ 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 serves this page). New memories appear on the timeline.
+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
 
-To turn earlier sessions into memories, preview first and then run it inside
-the agent:
+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:
 
 ```text
 /memory-import-opencode-history --dry-run

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

@@ -2,7 +2,7 @@ import { randomUUID } from "node:crypto";
 import { CONFIG } from "../../config.js";
 import { resolveOpencodeHostModel } from "../../services/ai/live-model-choice.js";
 import { buildBoundedSummaryPrompt } from "../../core/capture-context.js";
-import { parseCaptureSummary } from "../../core/extraction.js";
+import { classifyCaptureReply, normalizeStopReason, parseCaptureSummary, } from "../../core/extraction.js";
 import { log } from "../../services/logger.js";
 import { loadOpencodeProvider } from "../../services/ai/opencode-provider-loader.js";
 function buildSystemPrompt(languageName) {
@@ -26,8 +26,19 @@ FORMAT:
 SKIP if: greetings, casual chat, no code/decisions made
 CAPTURE if: code changed, bug fixed, feature added, decision made`;
 }
+/** Reason code for an error thrown on the OpenCode host-model path. */
+function hostModelFailureReason(error) {
+    if (error instanceof Error && error.name === "ZodError")
+        return "schema-mismatch";
+    if (String(error).includes("returned no structured output"))
+        return "empty-text";
+    return "call-error";
+}
 export async function generateOpenCodeAutoCaptureSummary(request, notify) {
     let opencodeProviderError;
+    // Filled per path; when the host model falls back, the external API attempt
+    // overwrites it, so the record describes the call that decided the outcome.
+    const diagnostics = request.diagnostics ?? {};
     const hostModel = resolveOpencodeHostModel(CONFIG);
     if (hostModel) {
         try {
@@ -40,6 +51,9 @@ export async function generateOpenCodeAutoCaptureSummary(request, notify) {
                 ...hostModel,
                 prompt: request.prompt,
             });
+            diagnostics.path = "host-model";
+            diagnostics.provider = providerID;
+            diagnostics.model = modelID;
             if (!isProviderConnected(providerID)) {
                 throw new Error(`opencode provider '${providerID}' is not connected. Check your opencode provider configuration.`);
             }
@@ -59,6 +73,8 @@ export async function generateOpenCodeAutoCaptureSummary(request, notify) {
                 tags: z.array(z.string()),
             });
             const aiPrompt = buildBoundedSummaryPrompt(request.context, systemPrompt, z.toJSONSchema(schema));
+            diagnostics.systemPrompt = systemPrompt;
+            diagnostics.userPrompt = aiPrompt;
             const result = await generateStructuredOutput({
                 client: v2Client,
                 providerID,
@@ -66,6 +82,12 @@ export async function generateOpenCodeAutoCaptureSummary(request, notify) {
                 systemPrompt,
                 userPrompt: aiPrompt,
                 schema,
+                onReply: (reply) => {
+                    diagnostics.stopReason = normalizeStopReason(reply.finish);
+                    diagnostics.blockTypes = reply.partTypes;
+                    diagnostics.rawReply =
+                        reply.structuredOutput === undefined ? "" : JSON.stringify(reply.structuredOutput);
+                },
             });
             return {
                 summary: result.summary,
@@ -75,6 +97,7 @@ export async function generateOpenCodeAutoCaptureSummary(request, notify) {
         }
         catch (error) {
             opencodeProviderError = error;
+            diagnostics.failureReason = hostModelFailureReason(error);
             log("auto-capture: opencode provider failed, falling back to external API", {
                 error: String(error),
             });
@@ -134,19 +157,38 @@ export async function generateOpenCodeAutoCaptureSummary(request, notify) {
     };
     const aiPrompt = buildBoundedSummaryPrompt(request.context, systemPrompt, toolSchema);
     const captureSessionID = `auto-capture-${request.prompt?.id ?? request.sessionId}-${randomUUID()}`;
-    const result = await provider.executeToolCall(systemPrompt, aiPrompt, toolSchema, captureSessionID);
+    // Replace whatever the failed host-model attempt recorded.
+    Object.assign(diagnostics, {
+        path: "external-api",
+        provider: CONFIG.memoryProvider,
+        model: CONFIG.memoryModel,
+        systemPrompt,
+        userPrompt: aiPrompt,
+        stopReason: undefined,
+        blockTypes: undefined,
+        rawReply: undefined,
+        failureReason: undefined,
+    });
+    let result;
+    try {
+        result = await provider.executeToolCall(systemPrompt, aiPrompt, toolSchema, captureSessionID);
+    }
+    catch (error) {
+        diagnostics.failureReason = "call-error";
+        throw error;
+    }
+    diagnostics.stopReason = normalizeStopReason(result.stopReason);
     if (!result.success || !result.data) {
+        diagnostics.failureReason = diagnostics.stopReason === "length" ? "truncated" : "call-error";
         throw new Error(result.error || "Failed to generate summary");
     }
     const rawReply = JSON.stringify(result.data);
+    diagnostics.rawReply = rawReply;
     const summary = parseCaptureSummary(rawReply);
     if (!summary) {
-        log("OpenCode capture: model reply was not a valid capture summary", {
-            provider: CONFIG.memoryProvider,
-            modelId: CONFIG.memoryModel,
-            // The reply can carry conversation content, so log only its size.
-            replyLength: rawReply.length,
-        });
+        // The capture pipeline logs the attempt's metadata; never the reply.
+        diagnostics.failureReason =
+            classifyCaptureReply({ text: rawReply, stopReason: result.stopReason }) ?? "schema-mismatch";
         throw new Error("omms: OpenCode extraction returned an invalid summary payload");
     }
     return summary;

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

@@ -0,0 +1,25 @@
+import { selectImportModel } from "../../importer/model-selection.js";
+import type { HistoryImportModels } from "../../importer/run-import.js";
+import { createOpencodeImportModels } from "../../services/ai/opencode-import-models.js";
+interface BackfillConfig {
+    opencodeBackfillModel?: string;
+    opencodeProvider?: string;
+    opencodeModel?: string;
+    memoryProvider?: string;
+    memoryModel?: string;
+    memoryApiUrl?: string;
+    memoryApiKey?: string;
+}
+export interface OpenCodeBackfillContext {
+    connected: string[];
+    directory: string;
+    configModel: () => Promise<string | null>;
+    makeModels?: typeof createOpencodeImportModels;
+    externalModels?: typeof selectImportModel;
+}
+/** Apply the live-model rule when inherit is selected; named models need sign-in. */
+export declare function resolveOpencodeBackfillModels(config: BackfillConfig | undefined, context: OpenCodeBackfillContext): Promise<{
+    model: string;
+    models: HistoryImportModels;
+}>;
+export {};

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

@@ -0,0 +1,39 @@
+import { CONFIG } from "../../config.js";
+import { parseBackfillModel } from "../../importer/backfill-model.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";
+/** 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");
+    let ref;
+    if (choice === "inherit") {
+        const live = getAutoCaptureProviderStatus(config);
+        if (!live.ready)
+            throw new Error(`OpenCode backfill: ${live.issues.join("; ")}`);
+        if (live.mode === "manual") {
+            const external = (context.externalModels ?? selectImportModel)({});
+            return {
+                model: `${external.provider}/${external.modelId}`,
+                models: { capture: external.capture, profile: external.profile },
+            };
+        }
+        const selected = live.mode === "opencode"
+            ? `${config.opencodeProvider}/${config.opencodeModel}`
+            : await context.configModel();
+        if (!selected)
+            throw new Error("OpenCode backfill: no configured default model");
+        const parsed = parseBackfillModel({ opencodeBackfillModel: selected }, "opencode");
+        if (parsed === "inherit")
+            throw new Error("OpenCode backfill: no configured default model");
+        ref = { providerID: parsed.provider, modelID: parsed.model };
+    }
+    else {
+        ref = { providerID: choice.provider, modelID: choice.model };
+    }
+    if (!context.connected.includes(ref.providerID)) {
+        throw new Error(`OpenCode backfill provider ${ref.providerID} is not connected`);
+    }
+    const models = await (context.makeModels ?? createOpencodeImportModels)(ref, context.directory);
+    return { model: `${ref.providerID}/${ref.modelID}`, models };
+}

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

@@ -0,0 +1,7 @@
+/** Start after connected providers load, without delaying plugin initialisation. */
+export declare function startOpencodeBackfill(input: {
+    directory: string;
+    connected: string[];
+    configModel: () => Promise<string | null>;
+    notify: (message: string) => void;
+}): Promise<void>;

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

@@ -0,0 +1,12 @@
+import { CONFIG } from "../../config.js";
+import { scheduleAutoBackfill } from "../../importer/auto-backfill.js";
+import { resolveOpencodeBackfillModels } from "./backfill-models.js";
+/** Start after connected providers load, without delaying plugin initialisation. */
+export function startOpencodeBackfill(input) {
+    return scheduleAutoBackfill({
+        host: "opencode",
+        cwd: input.directory,
+        resolveModels: () => resolveOpencodeBackfillModels(CONFIG, input),
+        notify: input.notify,
+    });
+}

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

@@ -1,4 +1,6 @@
-import { type HistoryImportModels } from "../../importer/run-import.js";
+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";
 /**
  * OpenCode command surface for the historical-session importer:
  *
@@ -12,10 +14,6 @@ import { type HistoryImportModels } from "../../importer/run-import.js";
 export declare const OPENCODE_IMPORT_COMMAND = "memory-import-opencode-history";
 export declare const OPENCODE_IMPORT_DESCRIPTION = "Import historical OpenCode sessions into the shared memory store (try --dry-run first)";
 export declare const OPENCODE_IMPORT_USAGE: string;
-export interface OpencodeModelRef {
-    providerID: string;
-    modelID: string;
-}
 export interface OpencodeImportCommandInput {
     argsText: string;
     /** Session directory; relative paths and the default project resolve here. */
@@ -24,8 +22,6 @@ export interface OpencodeImportCommandInput {
     sessionModel: () => Promise<OpencodeModelRef | null>;
     notify?: (message: string) => void;
 }
-/** Capture and profile calls routed through OpenCode's structured-output sessions. */
-export declare function createOpencodeImportModels(ref: OpencodeModelRef, directory: string): Promise<Required<HistoryImportModels>>;
 /** Parse, run, and describe one import; always resolves to text for the session. */
 export declare function runOpencodeImportCommand(input: OpencodeImportCommandInput): Promise<string>;
 /** The model of the session's latest user message, from the V1 message list. */

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

@@ -1,8 +1,10 @@
-import { CONFIG, isConfigured } from "../../config.js";
-import { buildBoundedSummaryPrompt } from "../../core/capture-context.js";
+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 { beginManualImport } from "../../importer/manual-import-guard.js";
 import { memoryClient } from "../../services/client.js";
 import { log } from "../../services/logger.js";
 /**
@@ -23,58 +25,6 @@ function splitModel(value) {
     const separator = value.indexOf("/");
     return { providerID: value.slice(0, separator), modelID: value.slice(separator + 1) };
 }
-/** Capture and profile calls routed through OpenCode's structured-output sessions. */
-export async function createOpencodeImportModels(ref, directory) {
-    const { getV2Client, generateStructuredOutput } = await loadOpencodeProvider();
-    const client = getV2Client();
-    if (!client)
-        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("../../services/language-detector.js");
-    const captureSchema = z.object({
-        summary: z.string().optional(),
-        type: z.string(),
-        tags: z.array(z.string()).optional(),
-    });
-    const capture = {
-        async summarize(request) {
-            const target = CONFIG.autoCaptureLanguage && CONFIG.autoCaptureLanguage !== "auto"
-                ? CONFIG.autoCaptureLanguage
-                : detectLanguage(request.userPrompt);
-            const systemPrompt = buildCaptureSystemPrompt(getLanguageName(target));
-            const result = await generateStructuredOutput({
-                client,
-                ...ref,
-                systemPrompt,
-                userPrompt: buildBoundedSummaryPrompt(request.context, systemPrompt, z.toJSONSchema(captureSchema)),
-                schema: captureSchema,
-                directory,
-            });
-            const parsed = parseCaptureSummary(JSON.stringify(result));
-            if (!parsed)
-                throw new Error("History capture returned an invalid summary");
-            return parsed;
-        },
-    };
-    const profileSchema = createUserProfileAnalysisSchema(z);
-    const profile = {
-        provider: ref.providerID,
-        modelId: ref.modelID,
-        async complete(systemPrompt, userPrompt) {
-            const result = await generateStructuredOutput({
-                client,
-                ...ref,
-                systemPrompt,
-                userPrompt,
-                schema: profileSchema,
-                directory,
-            });
-            return JSON.stringify(result);
-        },
-    };
-    return { capture, profile };
-}
 /** Parse, run, and describe one import; always resolves to text for the session. */
 export async function runOpencodeImportCommand(input) {
     const name = OPENCODE_IMPORT_COMMAND;
@@ -93,6 +43,7 @@ export async function runOpencodeImportCommand(input) {
     if (importCommandRunning)
         return `${name}: an import is already running`;
     importCommandRunning = true;
+    const endManualImport = beginManualImport("opencode");
     try {
         let ref = null;
         if (parsed.model || importNeedsModel(parsed)) {
@@ -133,6 +84,7 @@ export async function runOpencodeImportCommand(input) {
         return `${name} failed: ${message}`;
     }
     finally {
+        endManualImport();
         importCommandRunning = false;
     }
 }

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

@@ -0,0 +1,9 @@
+import type { HistoryImportModels } from "../../importer/run-import.js";
+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;
+}): Promise<{
+    model: string;
+    models: HistoryImportModels;
+}>;

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

@@ -0,0 +1,30 @@
+import { CONFIG } from "../../config.js";
+import { parseBackfillModel } from "../../importer/backfill-model.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 === "inherit") {
+        const live = createPiLiveModels(ctx);
+        const profile = live.profile();
+        if (!profile)
+            throw new Error("Pi backfill: no live-capture model is available");
+        const model = profile.modelId || CONFIG.memoryModel;
+        return {
+            model: `${profile.provider}/${model ?? "unknown"}`,
+            models: { capture: live.capture, profile },
+        };
+    }
+    const selected = resolveImportModel(ctx, `${choice.provider}/${choice.model}`);
+    if (!selected)
+        throw new Error(`Pi backfill model not found: ${choice.provider}/${choice.model}`);
+    return {
+        model: `${selected.provider}/${selected.modelId}`,
+        models: {
+            capture: createPiCaptureProvider(() => selected),
+            profile: adaptPiProfileModel(selected),
+        },
+    };
+}

package/dist/adapters/pi/extension.js

@@ -1,5 +1,6 @@
 import { Type } from "typebox";
 import { CONFIG, initConfigWithLegacyMigration, isConfigured } from "../../config.js";
+import { pruneTraces } from "../../services/capture-diagnostics.js";
 import { executeMemoryOperation } from "../../core/memory-operations.js";
 import { getLanguageName } from "../../services/language-detector.js";
 import { log } from "../../services/logger.js";
@@ -10,6 +11,7 @@ import { registerPiHistoryImportCommand } from "./import-command.js";
 import { performPiProfileLearning } from "./profile.js";
 import { buildRetrievalSection, wrapRetrievalSection } from "../../core/retrieval.js";
 const GLOBAL_PLUGIN_WARMUP_KEY = Symbol.for("omms.plugin.warmedup");
+const GLOBAL_PI_BACKFILL_KEY = Symbol.for("omms.pi.backfill.scheduled");
 const OMMS_STATUS_KEY = "omms";
 const MEMORY_TOOL_MODES = [
     "add",
@@ -69,6 +71,7 @@ export default function ommsPiExtension(pi) {
     // Latest session context, refreshed on session_start and consumed by the
     // import command (command contexts do not expose the model registry).
     let latestCtx = null;
+    let backfillSessionId = null;
     let statusVersion = 0;
     const startStatus = (ctx, status) => {
         const version = ++statusVersion;
@@ -97,8 +100,53 @@ export default function ommsPiExtension(pi) {
         try {
             latestCtx = ctx;
             initConfigWithLegacyMigration(ctx.cwd);
+            // Runs even with tracing off, so turning it off does not leave old traces behind.
+            pruneTraces(CONFIG);
             captureState = createPiCaptureState();
+            if (CONFIG.webServerAutoStart !== undefined &&
+                process.env.OMMS_DISABLE_WEB_AUTOSTART !== "1") {
+                void import("../../services/web-autostart.js")
+                    .then(({ reconcileWebAutostart }) => reconcileWebAutostart(CONFIG))
+                    .catch((error) => log("Pi login item reconciliation failed", {
+                    code: error instanceof Error ? error.name : "unknown",
+                }));
+            }
             const globalScope = globalThis;
+            const sessionId = ctx.sessionManager.getSessionId();
+            if (isConfigured() &&
+                CONFIG.autoBackfill &&
+                process.env.OMMS_DISABLE_AUTO_BACKFILL !== "1" &&
+                !globalScope[GLOBAL_PI_BACKFILL_KEY] &&
+                backfillSessionId !== sessionId) {
+                backfillSessionId = sessionId;
+                const controller = new AbortController();
+                const task = { controller, promise: Promise.resolve() };
+                globalScope[GLOBAL_PI_BACKFILL_KEY] = task;
+                task.promise = (async () => {
+                    const { scheduleAutoBackfill } = await import("../../importer/auto-backfill.js");
+                    await scheduleAutoBackfill({
+                        host: "pi",
+                        cwd: ctx.cwd,
+                        signal: controller.signal,
+                        resolveModels: async () => {
+                            const { resolvePiBackfillModels } = await import("./backfill-models.js");
+                            return resolvePiBackfillModels(ctx);
+                        },
+                        notify: (message) => {
+                            if (!controller.signal.aborted && ctx.hasUI)
+                                ctx.ui.notify(message, "info");
+                        },
+                    });
+                })()
+                    .catch((error) => log("Pi backfill failed", {
+                    error: error instanceof Error ? error.message : String(error),
+                }))
+                    .finally(() => {
+                    if (globalScope[GLOBAL_PI_BACKFILL_KEY] === task) {
+                        delete globalScope[GLOBAL_PI_BACKFILL_KEY];
+                    }
+                });
+            }
             if (!globalScope[GLOBAL_PLUGIN_WARMUP_KEY] && isConfigured()) {
                 (async () => {
                     try {
@@ -189,6 +237,11 @@ export default function ommsPiExtension(pi) {
         captureState = createPiCaptureState();
         promptsSinceProfileAnalysis = [];
         globalThis[GLOBAL_PLUGIN_WARMUP_KEY] = false;
+        const task = globalThis[GLOBAL_PI_BACKFILL_KEY];
+        task?.controller.abort();
+        if (task)
+            await task.promise;
+        backfillSessionId = null;
         try {
             await memoryClient.close();
         }

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

@@ -5,6 +5,7 @@ import { historyImportUsage, importNeedsModel, parseHistoryImportArgs, tokenizeI
 import { formatHistoryImportReport, summarizeHistoryImportReport, runHistoryImport, } from "../../importer/run-import.js";
 import { createPiCaptureProvider, resolveImportModel } from "./provider.js";
 import { adaptPiProfileModel } from "./profile.js";
+import { beginManualImport } from "../../importer/manual-import-guard.js";
 /**
  * Pi command surface for the historical-session importer:
  *
@@ -74,6 +75,7 @@ export function registerPiHistoryImportCommand(pi, getExtensionContext) {
                 return;
             }
             importCommandRunning = true;
+            const endManualImport = beginManualImport("pi");
             try {
                 // Best-effort warmup so failures surface as per-unit errors instead of
                 // every unit failing on embedding initialisation.
@@ -110,6 +112,7 @@ export function registerPiHistoryImportCommand(pi, getExtensionContext) {
                 notify(`memory-import-pi-history failed: ${message}`);
             }
             finally {
+                endManualImport();
                 importCommandRunning = false;
             }
         },

package/dist/adapters/pi/profile.js

@@ -1,4 +1,4 @@
-import { CONFIG } from "../../config.js";
+import { CONFIG, refreshConfigIfChanged } from "../../config.js";
 import { analyzeProfile, } from "../../core/profile-analysis.js";
 import { log } from "../../services/logger.js";
 import { getTags } from "../../services/tags.js";
@@ -47,6 +47,7 @@ export async function performPiProfileLearning(input) {
     if (input.prompts.length === 0)
         return;
     try {
+        refreshConfigIfChanged(input.directory);
         const tags = getTags(input.directory);
         if (!tags.user.userEmail) {
             log("pi profile learning: skipped (no user email resolved)", {

package/dist/adapters/pi/provider.js

@@ -1,8 +1,7 @@
 import { CONFIG } from "../../config.js";
 import { buildBoundedSummaryPrompt } from "../../core/capture-context.js";
-import { buildCaptureSystemPrompt, captureSummaryToolSchema, parseCaptureSummary, } from "../../core/extraction.js";
+import { buildCaptureReplyInstruction, buildCaptureSystemPrompt, captureSummaryToolSchema, classifyCaptureReply, normalizeStopReason, parseCaptureSummary, } from "../../core/extraction.js";
 import { detectLanguage, getLanguageName } from "../../services/language-detector.js";
-import { log } from "../../services/logger.js";
 /**
  * Active-model-first resolution: the explicit `piProvider`/`piModel`
  * configuration when both are set, otherwise the active `ctx.model`.
@@ -80,23 +79,51 @@ export function createPiCaptureProvider(resolveModel) {
                 ? detectLanguage(request.userPrompt)
                 : CONFIG.autoCaptureLanguage;
             const systemPrompt = buildCaptureSystemPrompt(getLanguageName(targetLang));
-            const userPrompt = buildBoundedSummaryPrompt(request.context, systemPrompt, captureSummaryToolSchema);
-            const reply = await model.complete({
-                systemPrompt,
-                messages: [{ role: "user", content: userPrompt, timestamp: Date.now() }],
-            });
+            const replyInstruction = buildCaptureReplyInstruction();
+            // The instruction is counted as schema bytes so the context budget leaves room for it.
+            const userPrompt = `${buildBoundedSummaryPrompt(request.context, systemPrompt, {
+                schema: captureSummaryToolSchema,
+                replyInstruction,
+            })}\n\n${replyInstruction}`;
+            const diagnostics = request.diagnostics;
+            if (diagnostics) {
+                diagnostics.path = "host-model";
+                diagnostics.provider = model.provider;
+                diagnostics.model = model.modelId;
+                diagnostics.systemPrompt = systemPrompt;
+                diagnostics.userPrompt = userPrompt;
+            }
+            let reply;
+            try {
+                reply = await model.complete({
+                    systemPrompt,
+                    messages: [{ role: "user", content: userPrompt, timestamp: Date.now() }],
+                });
+            }
+            catch (error) {
+                if (diagnostics)
+                    diagnostics.failureReason = "call-error";
+                throw error;
+            }
+            const rawReply = replyText(reply);
+            if (diagnostics) {
+                diagnostics.stopReason = normalizeStopReason(reply.stopReason);
+                diagnostics.blockTypes = reply.content.map((block) => block.type);
+                diagnostics.rawReply = rawReply;
+            }
             if (reply.stopReason === "error") {
+                if (diagnostics)
+                    diagnostics.failureReason = "call-error";
                 throw new Error(`omms: Pi extraction call failed: ${reply.errorMessage || "unknown error"}`);
             }
-            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,
-                });
+                // The capture pipeline logs the attempt's metadata; never the reply.
+                if (diagnostics) {
+                    diagnostics.failureReason =
+                        classifyCaptureReply({ text: rawReply, stopReason: reply.stopReason }) ??
+                            "schema-mismatch";
+                }
                 throw new Error("omms: Pi extraction returned an invalid summary payload");
             }
             return summary;

package/dist/cli/index.js

@@ -11,8 +11,10 @@ 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
+  web                       Start the web app in the foreground
+  web install|uninstall|status  Manage the web app login item
 
-Both commands take the same options; run one with --help to see them.
+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.`;
 export function parseImportArgs(argv) {
@@ -30,6 +32,16 @@ export async function runCli(argv) {
         console.log(usage);
         return 0;
     }
+    if (argv[0] === "web") {
+        try {
+            const { runWebCommand } = await import("./web-command.js");
+            return await runWebCommand(argv.slice(1));
+        }
+        catch (error) {
+            console.error(`OMMS web command failed: ${error instanceof Error ? error.message : String(error)}`);
+            return 1;
+        }
+    }
     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 {

package/dist/cli/web-command.d.ts

@@ -0,0 +1,3 @@
+import type { WebAutostartOptions } from "../services/web-autostart.js";
+/** Run the standalone web app or manage its per-user login item. */
+export declare function runWebCommand(args: string[], options?: WebAutostartOptions, online?: () => Promise<boolean>): Promise<number>;