om-memory-system 5.10.1 → 6.1.0-next.237

package/dist/v2/adapter.d.ts

@@ -1,90 +1,22 @@
 import type { Context } from "@opencode/plugin/promise/plugin";
+import { type SessionEvent } from "./session-events.js";
+import { type OpencodeTools } from "./tools.js";
 import type { V2MemoryBridge } from "./memory-bridge.js";
-export declare const memoryInput: {
-    readonly type: "object";
-    readonly properties: {
-        readonly mode: {
-            readonly type: "string";
-            readonly enum: readonly ["add", "memorise", "memorize", "recall", "search", "profile", "list", "forget", "help", "migrate", "list-shards", "export", "import", "space"];
-        };
-        readonly content: {
-            readonly type: "string";
-        };
-        readonly query: {
-            readonly type: "string";
-        };
-        readonly tags: {
-            readonly type: "string";
-        };
-        readonly type: {
-            readonly type: "string";
-        };
-        readonly topic: {
-            readonly type: "string";
-        };
-        readonly done: {
-            readonly type: "string";
-        };
-        readonly doing: {
-            readonly type: "string";
-        };
-        readonly next: {
-            readonly type: "string";
-        };
-        readonly memoryId: {
-            readonly type: "string";
-        };
-        readonly limit: {
-            readonly type: "number";
-        };
-        readonly scope: {
-            readonly type: "string";
-            readonly enum: readonly ["project", "all-projects"];
-        };
-        readonly fromPath: {
-            readonly type: "string";
-        };
-        readonly fromHash: {
-            readonly type: "string";
-        };
-        readonly outputPath: {
-            readonly type: "string";
-        };
-        readonly inputPath: {
-            readonly type: "string";
-        };
-        readonly dryRun: {
-            readonly type: "boolean";
-        };
-        readonly allowLinkedSource: {
-            readonly type: "boolean";
-        };
-        readonly spaceAction: {
-            readonly type: "string";
-        };
-        readonly spaceName: {
-            readonly type: "string";
-        };
-        readonly spaceTo: {
-            readonly type: "string";
-        };
-        readonly spaceSince: {
-            readonly type: "string";
-        };
-        readonly spaceUntil: {
-            readonly type: "string";
-        };
-        readonly spaceProject: {
-            readonly type: "string";
-        };
-        readonly spaceIn: {
-            readonly type: "string";
-        };
-    };
-    readonly additionalProperties: false;
-};
+export { memoryInput } from "./tools.js";
 /** Per-session state is bounded so long-running servers cannot grow it without limit. */
 export declare const MAX_TRACKED_SESSIONS = 256;
 /** Session ids remembered as already seen by this process, for the first-prompt rule. */
 export declare const MAX_SEEN_SESSIONS = 500;
-export declare function registerV2Adapter(ctx: Context, legacy: any, memory: V2MemoryBridge): Promise<() => Promise<void>>;
+/** The OpenCode work the adapter wires into the V2 context. */
+export type V2AdapterDeps = {
+    readonly tools: OpencodeTools;
+    /** Store a model request's model on the recorded prompt row. */
+    readonly recordPromptModel?: (messageID: string, model: {
+        readonly providerID: string;
+        readonly id: string;
+    }) => Promise<void>;
+    /** Session events of this plugin's directory, compaction excluded. */
+    readonly onEvent?: (event: SessionEvent) => Promise<void>;
+    readonly dispose?: () => Promise<void>;
+};
+export declare function registerV2Adapter(ctx: Context, deps: V2AdapterDeps, memory: V2MemoryBridge): Promise<() => Promise<void>>;

package/dist/v2/adapter.js

@@ -1,67 +1,19 @@
 import { OPENCODE_IMPORT_COMMAND, OPENCODE_IMPORT_DESCRIPTION, runOpencodeImportCommand, } from "../adapters/opencode/import-command.js";
 import { addPackageSkill } from "../adapters/opencode/package-skills.js";
-import { SKILLS_TOOL_INPUT_SCHEMA } from "../core/skills-tool.js";
 import { log } from "../services/logger.js";
 import { utf8ByteLength } from "../utils/context-limit.js";
-import { eventBelongsToLocation, legacyToolResult, toLegacyEvent } from "./legacy-client.js";
+import { eventBelongsToLocation, toSessionEvent } from "./session-events.js";
+import { registerOpencodeTools } from "./tools.js";
 import { createRecallReporter } from "./recall-reporter.js";
 import { createSessionParents } from "./session-parent.js";
-export const memoryInput = {
-    type: "object",
-    properties: {
-        mode: {
-            type: "string",
-            enum: [
-                "add",
-                "memorise",
-                "memorize",
-                "recall",
-                "search",
-                "profile",
-                "list",
-                "forget",
-                "help",
-                "migrate",
-                "list-shards",
-                "export",
-                "import",
-                "space",
-            ],
-        },
-        content: { type: "string" },
-        query: { type: "string" },
-        tags: { type: "string" },
-        type: { type: "string" },
-        topic: { type: "string" },
-        done: { type: "string" },
-        doing: { type: "string" },
-        next: { type: "string" },
-        memoryId: { type: "string" },
-        limit: { type: "number" },
-        scope: { type: "string", enum: ["project", "all-projects"] },
-        fromPath: { type: "string" },
-        fromHash: { type: "string" },
-        outputPath: { type: "string" },
-        inputPath: { type: "string" },
-        dryRun: { type: "boolean" },
-        allowLinkedSource: { type: "boolean" },
-        spaceAction: { type: "string" },
-        spaceName: { type: "string" },
-        spaceTo: { type: "string" },
-        spaceSince: { type: "string" },
-        spaceUntil: { type: "string" },
-        spaceProject: { type: "string" },
-        spaceIn: { type: "string" },
-    },
-    additionalProperties: false,
-};
+export { memoryInput } from "./tools.js";
 /** Per-session state is bounded so long-running servers cannot grow it without limit. */
 export const MAX_TRACKED_SESSIONS = 256;
 /** Session ids remembered as already seen by this process, for the first-prompt rule. */
 export const MAX_SEEN_SESSIONS = 500;
 /** Unadmitted prompts kept per session before the oldest is dropped. */
 const MAX_PENDING_PROMPTS = 16;
-/** Compaction is restored natively through the `compaction` hook, never via the V1 event path. */
+/** Compaction is restored through the `compaction` hook, never from the event stream. */
 const COMPACTION_EVENT_TYPES = new Set(["session.compacted", "session.compaction.ended"]);
 const NO_SECTIONS = {
     promptSection: null,
@@ -91,7 +43,7 @@ function deletedSessionID(event) {
     const props = event.properties ?? {};
     return props.sessionID ?? props.info?.id ?? props.session?.id;
 }
-export async function registerV2Adapter(ctx, legacy, memory) {
+export async function registerV2Adapter(ctx, deps, memory) {
     const retrievals = new Map();
     const restored = new Map();
     // Sessions this process has seen a prompt or compaction for. The first prompt of a session not
@@ -184,31 +136,10 @@ export async function registerV2Adapter(ctx, legacy, memory) {
         if (!subagent)
             await loadRestored(sessionID, memory.retrievalTimeoutMs);
     };
-    // Each V1 tool becomes a direct V2 tool, like OpenCode's own read/grep/skill, not a
-    // Code Mode catalog entry, so the model can always see and call it (as on V1 and Pi).
-    const legacyTool = (name, input) => ({
-        name,
-        description: legacy.tool[name].description,
-        input: input,
-        options: { codemode: false },
-        execute: async (args, toolContext) => legacyToolResult(await legacy.tool[name].execute(args, {
-            sessionID: toolContext.sessionID,
-            messageID: toolContext.messageID,
-            agent: toolContext.agent,
-            directory: ctx.location.directory,
-            worktree: ctx.location.project.directory,
-            abort: new AbortController().signal,
-            metadata() { },
-            async ask() { },
-        })),
-    });
-    await ctx.tool.transform((editor) => {
-        editor.add(legacyTool("memory", memoryInput));
-        editor.add(legacyTool("skills", SKILLS_TOOL_INPUT_SCHEMA));
-    });
-    // The omms-memory skill ships in the package; V1 loads it through the config hook.
+    await registerOpencodeTools(ctx, deps.tools);
+    // The omms-memory and omms-remember skills ship in the package.
     await ctx.skill?.transform?.((editor) => addPackageSkill(editor));
-    // Same command as V1 and Pi. V2 runs it natively, so no model turn relays the report.
+    // Same command as Pi. V2 runs it natively, so no model turn relays the report.
     await ctx.command?.transform?.((editor) => editor.add({
         name: OPENCODE_IMPORT_COMMAND,
         description: OPENCODE_IMPORT_DESCRIPTION,
@@ -284,7 +215,7 @@ export async function registerV2Adapter(ctx, legacy, memory) {
         const sessionID = event.sessionID;
         const retrieval = retrievals.get(sessionID);
         const budgetBytes = retrieval?.budgetBytes ?? memory.snapshotRequestBudget();
-        // Before chat.params, which stores the model on the recorded prompt row.
+        // Before the model is stored on the recorded prompt row, below.
         await recordAdmittedPrompts(sessionID, event.messages);
         await decideFirstRequest(sessionID, event.messages, retrieval);
         // The retrieval sections and the restored section share one request budget: the
@@ -312,12 +243,10 @@ export async function registerV2Adapter(ctx, legacy, memory) {
                 recall.record(sessionID, restoredEntry, "restore", null, section);
             }
         }
-        if (legacy["chat.params"]) {
-            await legacy["chat.params"]({
-                message: { id: messageIDs.get(sessionID) ?? sessionID },
-                model: { providerID: event.model.providerID, id: event.model.id },
-            });
-        }
+        await deps.recordPromptModel?.(messageIDs.get(sessionID) ?? sessionID, {
+            providerID: event.model.providerID,
+            id: event.model.id,
+        });
     });
     await ctx.session.hook("compaction", async (event) => {
         memory.snapshotRequestBudget();
@@ -332,14 +261,14 @@ export async function registerV2Adapter(ctx, legacy, memory) {
     const watcher = (async () => {
         try {
             for await (const raw of ctx.event.subscribe({ signal: controller.signal })) {
-                const event = toLegacyEvent(raw);
+                const event = toSessionEvent(raw);
                 const deleted = deletedSessionID(event);
                 if (deleted)
                     forgetSession(deleted);
-                if (!legacy.event || COMPACTION_EVENT_TYPES.has(event.type))
+                if (!deps.onEvent || COMPACTION_EVENT_TYPES.has(event.type))
                     continue;
                 if (await eventBelongsToLocation(ctx, raw)) {
-                    await legacy.event({ event });
+                    await deps.onEvent(event);
                 }
             }
         }
@@ -360,6 +289,6 @@ export async function registerV2Adapter(ctx, legacy, memory) {
         firstPending.clear();
         parents.clear();
         recall.clear();
-        await legacy.dispose?.();
+        await deps.dispose?.();
     };
 }

package/dist/v2/memory-bridge.js

@@ -17,7 +17,7 @@ export function createV2MemoryBridge(directory) {
             return CONFIG.visibleRecall !== false;
         },
         isSubagentMemoryEnabled: () => CONFIG.subagentMemory !== false,
-        isInternalPrompt,
+        isInternalPrompt: (_sessionID, text) => isInternalPrompt(text),
         async recordPrompt(sessionID, messageID, text) {
             await recordUserPrompt(sessionID, messageID, directory, text);
         },

package/dist/v2/plugin.js

@@ -1,9 +1,14 @@
 import { fileURLToPath } from "node:url";
-import { OmmsPlugin } from "../index.js";
-import { loadOpencodeProvider } from "../adapters/opencode/opencode-provider-loader.js";
+import { setOpencodeHost } from "../adapters/opencode/opencode-host.js";
+import { CONFIG } from "../config.js";
+import { recordOpencodePromptModel } from "../adapters/opencode/prompt-model.js";
+import { performUserProfileLearning } from "../adapters/opencode/profile-learning.js";
+import { getLanguageName } from "../services/language-detector.js";
 import { registerV2Adapter } from "./adapter.js";
 import { createV2MemoryBridge } from "./memory-bridge.js";
-import { createLegacyClient } from "./legacy-client.js";
+import { createOpencodeSessionEvents } from "./session-events.js";
+import { startOpencodeRuntime } from "./startup.js";
+import { createOpencodeTools } from "./tools.js";
 /**
  * Remove old OMMS copies from the OpenCode cache. It runs in the background and
  * is not awaited, so a slow or failing clean-up never delays or breaks setup.
@@ -62,19 +67,25 @@ function startServiceSelfUpdate() {
 const OmmsPluginV2 = {
     id: "omms",
     async setup(ctx) {
-        const legacyClient = createLegacyClient(ctx);
-        const legacy = (await OmmsPlugin({
-            client: legacyClient,
-            directory: ctx.location.directory,
-            worktree: ctx.location.project.directory,
-            project: ctx.location.project,
-            serverUrl: undefined,
-        }));
-        // The V1 initializer cannot discover a server URL from a native V2
-        // context. Route internal structured-output calls through the adapter.
-        const { setV2Client } = await loadOpencodeProvider();
-        setV2Client(legacyClient);
-        const adapter = await registerV2Adapter(ctx, legacy, createV2MemoryBridge(ctx.location.directory));
+        const directory = ctx.location.directory;
+        // Capture, profile learning, imports and Settings reach OpenCode through the context.
+        setOpencodeHost(ctx);
+        // The runtime's shutdown drops pending idle work, so it needs the handler created after it.
+        const holder = {};
+        const runtime = await startOpencodeRuntime(ctx, () => holder.events?.dispose());
+        const events = createOpencodeSessionEvents({
+            session: ctx.session,
+            directory,
+            autoCaptureHost: runtime.autoCaptureHost,
+            learnProfile: () => performUserProfileLearning(directory),
+        });
+        holder.events = events;
+        const adapter = await registerV2Adapter(ctx, {
+            tools: createOpencodeTools({ directory, tags: runtime.tags }, getLanguageName(CONFIG.autoCaptureLanguage || "en")),
+            recordPromptModel: recordOpencodePromptModel,
+            onEvent: (event) => events.handle(event),
+            dispose: () => runtime.dispose(),
+        }, createV2MemoryBridge(directory));
         startCacheCleanup();
         startServiceSelfUpdate();
         return adapter;

package/dist/v2/session-events.d.ts

@@ -0,0 +1,30 @@
+import type { Context } from "@opencode/plugin/promise/plugin";
+import type { AutoCaptureHost } from "../core/host.js";
+/** Capture waits this long after a session goes idle, so a quick follow-up prompt wins. */
+export declare const IDLE_CAPTURE_DELAY_MS = 10000;
+export type SessionEvent = {
+    readonly type: string;
+    readonly properties: any;
+};
+/** Map a raw V2 event onto the names the capture path reads. */
+export declare function toSessionEvent(raw: any): SessionEvent;
+/** True when a raw event names this plugin's directory, directly or through its session. */
+export declare function eventBelongsToLocation(ctx: Context, raw: any): Promise<boolean>;
+/**
+ * True for a session that OMMS created for its own model calls. Current versions generate
+ * without a session; older versions left sessions titled `omms capture`.
+ */
+export declare function isInternalOpencodeSession(session: Pick<Context["session"], "get">, sessionID: string): Promise<boolean>;
+export type SessionEventDeps = {
+    readonly session: Pick<Context["session"], "get">;
+    readonly directory: string;
+    readonly autoCaptureHost: AutoCaptureHost;
+    /** Profile learning for this plugin's directory; runs after capture. */
+    readonly learnProfile: () => Promise<void>;
+};
+/** Start capture, skill-turn recording, profile learning and the retry drain from session events. */
+export declare function createOpencodeSessionEvents(deps: SessionEventDeps): {
+    handle(event: SessionEvent): Promise<void>;
+    /** Drop pending idle work; the plugin is unloading. */
+    dispose(): void;
+};

package/dist/v2/session-events.js

@@ -0,0 +1,130 @@
+import { resolve } from "node:path";
+import { CONFIG, isConfigured } from "../config.js";
+import { isInternalCaptureSessionTitle } from "../adapters/opencode/internal-capture-sessions.js";
+import { log } from "../services/logger.js";
+/** Capture waits this long after a session goes idle, so a quick follow-up prompt wins. */
+export const IDLE_CAPTURE_DELAY_MS = 10_000;
+/** Map a raw V2 event onto the names the capture path reads. */
+export function toSessionEvent(raw) {
+    const envelope = raw?.payload ?? raw;
+    const source = envelope?.type === "sync" && envelope.syncEvent ? envelope.syncEvent : envelope;
+    const rawType = typeof source?.type === "string" ? source.type.replace(/\.1$/, "") : source?.type;
+    const data = source?.data ?? {};
+    // OpenCode 2.0.14 ends a turn with `session.execution.succeeded` and emits no
+    // `session.idle`; some builds report idleness through `session.status`. Both
+    // mean the session is idle. Subscribed events carry their payload in `data`;
+    // bus-style ones in `properties`.
+    const payload = source?.data ?? source?.properties ?? {};
+    if (rawType === "session.execution.succeeded" ||
+        (rawType === "session.status" && payload?.status?.type === "idle")) {
+        return { type: "session.idle", properties: { sessionID: payload.sessionID } };
+    }
+    const type = rawType === "session.compaction.ended" ? "session.compacted" : rawType;
+    if (source && typeof source === "object" && "properties" in source) {
+        return { type, properties: source.properties };
+    }
+    if (type === "session.created" || type === "session.updated") {
+        return { type, properties: { info: data.session ?? data.info ?? data } };
+    }
+    return { type, properties: data };
+}
+/** True when a raw event names this plugin's directory, directly or through its session. */
+export async function eventBelongsToLocation(ctx, raw) {
+    const directory = raw?.location?.directory ??
+        raw?.directory ??
+        raw?.payload?.location?.directory ??
+        raw?.payload?.directory ??
+        raw?.data?.info?.directory;
+    if (typeof directory === "string") {
+        return resolve(directory) === resolve(ctx.location.directory);
+    }
+    const data = raw?.data ?? raw?.payload?.data ?? raw?.properties;
+    const sessionID = data?.sessionID ?? data?.session?.id ?? data?.info?.id;
+    if (!sessionID)
+        return false;
+    try {
+        const session = await ctx.session.get({ sessionID });
+        const sessionDirectory = session?.location?.directory ?? session?.directory ?? session?.data?.directory;
+        return (typeof sessionDirectory === "string" &&
+            resolve(sessionDirectory) === resolve(ctx.location.directory));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * True for a session that OMMS created for its own model calls. Current versions generate
+ * without a session; older versions left sessions titled `omms capture`.
+ */
+export async function isInternalOpencodeSession(session, sessionID) {
+    try {
+        const info = await session.get({ sessionID });
+        return isInternalCaptureSessionTitle(info?.title);
+    }
+    catch (error) {
+        log("internal capture session check failed", { sessionID, error: String(error) }, "error");
+        return false;
+    }
+}
+/** Start capture, skill-turn recording, profile learning and the retry drain from session events. */
+export function createOpencodeSessionEvents(deps) {
+    let idleTimeout = null;
+    const onCreated = async (event) => {
+        if (!isConfigured() || !CONFIG.autoCaptureEnabled)
+            return;
+        const sessionID = event.properties?.info?.id ?? event.properties?.sessionID;
+        // OMMS's own structured-output sessions must not start a retry pass.
+        if (sessionID && (await isInternalOpencodeSession(deps.session, sessionID)))
+            return;
+        const { startCaptureRetryDrain } = await import("../services/capture-retry-drain.js");
+        startCaptureRetryDrain("opencode");
+    };
+    const onIdle = async (event) => {
+        // Skill learning records turns even when memory capture is off (ADR-036).
+        if (!isConfigured() || !(CONFIG.autoCaptureEnabled || CONFIG.skillLearning))
+            return;
+        const sessionID = event.properties?.sessionID;
+        if (!sessionID)
+            return;
+        // Internal sessions must not re-trigger capture or learning: that would loop
+        // idle, model call, idle without end.
+        if (await isInternalOpencodeSession(deps.session, sessionID)) {
+            log("Skipping idle processing for internal capture session", { sessionID });
+            return;
+        }
+        if (idleTimeout)
+            clearTimeout(idleTimeout);
+        idleTimeout = setTimeout(async () => {
+            try {
+                const { performAutoCapture } = await import("../services/auto-capture.js");
+                await performAutoCapture(deps.autoCaptureHost, sessionID, deps.directory);
+                if (!CONFIG.autoCaptureEnabled)
+                    return; // Skill turns only; the memory work stays off.
+                await deps.learnProfile();
+                const { cleanupService } = await import("../services/cleanup-service.js");
+                if (await cleanupService.shouldRunCleanup())
+                    await cleanupService.runCleanup();
+            }
+            catch (error) {
+                log("Idle processing error", { error: String(error) }, "error");
+            }
+            finally {
+                idleTimeout = null;
+            }
+        }, IDLE_CAPTURE_DELAY_MS);
+    };
+    return {
+        async handle(event) {
+            if (event.type === "session.created")
+                await onCreated(event);
+            else if (event.type === "session.idle")
+                await onIdle(event);
+        },
+        /** Drop pending idle work; the plugin is unloading. */
+        dispose() {
+            if (idleTimeout)
+                clearTimeout(idleTimeout);
+            idleTimeout = null;
+        },
+    };
+}

package/dist/v2/startup.d.ts

@@ -0,0 +1,14 @@
+import type { Context } from "@opencode/plugin/promise/plugin";
+/**
+ * Start OMMS for an OpenCode V2 plugin: config, traces, runtime record, warm-up, models,
+ * backfill, web app and shutdown handlers. Returns the dispose function for plugin unload.
+ */
+export declare function startOpencodeRuntime(ctx: Context, onCleanup?: () => void): Promise<{
+    directory: string & import("effect/Brand").Brand<"AbsolutePath">;
+    tags: {
+        user: import("../services/tags.js").TagInfo;
+        project: import("../services/tags.js").TagInfo;
+    };
+    autoCaptureHost: import("../core/host.js").AutoCaptureHost;
+    dispose(): Promise<void>;
+}>;