om-memory-system 4.6.0 → 4.8.0

package/dist/v2/adapter.js

@@ -1,6 +1,7 @@
 import { OPENCODE_IMPORT_COMMAND, OPENCODE_IMPORT_DESCRIPTION, runOpencodeImportCommand, } from "../adapters/opencode/import-command.js";
 import { addPackageSkill } from "../adapters/opencode/package-skills.js";
 import { log } from "../services/logger.js";
+import { utf8ByteLength } from "../utils/context-limit.js";
 import { eventBelongsToLocation, legacyToolResult, toLegacyEvent } from "./legacy-client.js";
 const memoryInput = {
     type: "object",
@@ -158,6 +159,7 @@ export async function registerV2Adapter(ctx, legacy, memory) {
         },
     }));
     await ctx.session.hook("prompt", async (event) => {
+        const budgetBytes = memory.snapshotRequestBudget();
         const sessionID = event.sessionID;
         const text = event.prompt.text ?? "";
         setBounded(messageIDs, sessionID, event.messageID);
@@ -173,26 +175,39 @@ export async function registerV2Adapter(ctx, legacy, memory) {
         }
         if (!memory.isInjectionEnabled() || !text.trim())
             return;
-        // Start the search now so it overlaps prompt admission; `context` awaits it.
-        const promise = memory.retrieve(text, sessionID).catch((error) => {
+        // Start the search now with the entry snapshot, so it overlaps prompt admission.
+        // An edit during retrieval must not change this request's allowance.
+        const promise = memory.retrieve(text, sessionID, budgetBytes).catch((error) => {
             log("v2 prompt: memory retrieval failed", { sessionID, error: String(error) });
             return null;
         });
-        setBounded(retrievals, sessionID, { promise });
+        setBounded(retrievals, sessionID, { promise, budgetBytes });
     });
     await ctx.session.hook("context", async (event) => {
         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.
         await recordAdmittedPrompts(sessionID, event.messages);
-        const retrieval = retrievals.get(sessionID);
+        // The retrieval and the restored section share one request budget: the
+        // restored section is formatted here, within what the retrieval left.
+        let remainingBytes = null;
         if (retrieval) {
             const section = await settledRetrieval(retrieval);
+            if (section) {
+                event.system.push({ type: "text", text: section });
+                remainingBytes = retrieval.budgetBytes - utf8ByteLength(section);
+            }
+            else {
+                remainingBytes = retrieval.budgetBytes;
+            }
+        }
+        const restoredMemories = restored.get(sessionID);
+        if (restoredMemories) {
+            const section = memory.formatRestoredSession(restoredMemories, remainingBytes ?? budgetBytes);
             if (section)
                 event.system.push({ type: "text", text: section });
         }
-        const restoredSection = restored.get(sessionID);
-        if (restoredSection)
-            event.system.push({ type: "text", text: restoredSection });
         if (legacy["chat.params"]) {
             await legacy["chat.params"]({
                 message: { id: messageIDs.get(sessionID) ?? sessionID },
@@ -201,13 +216,16 @@ export async function registerV2Adapter(ctx, legacy, memory) {
         }
     });
     await ctx.session.hook("compaction", async (event) => {
+        memory.snapshotRequestBudget();
         if (!memory.isCompactionEnabled())
             return;
         const sessionID = event.sessionID;
         try {
-            const section = await memory.restoreSession(sessionID);
-            if (section)
-                setBounded(restored, sessionID, section);
+            // Load once here; the restored section is formatted when a request
+            // emits it, against that request's captured budget.
+            const memories = await memory.restoreSession(sessionID);
+            if (memories)
+                setBounded(restored, sessionID, memories);
             else
                 restored.delete(sessionID);
         }

package/dist/v2/memory-bridge.d.ts

@@ -10,9 +10,17 @@ export interface V2MemoryBridge {
     isCompactionEnabled(): boolean;
     isInternalPrompt(sessionID: string, text: string): boolean;
     recordPrompt(sessionID: string, messageID: string, text: string): Promise<void>;
-    /** Wrapped per-prompt retrieval section, or null when nothing is relevant. */
-    retrieve(prompt: string, sessionID: string): Promise<string | null>;
-    /** The session's own memories formatted for restore after compaction, or null. */
-    restoreSession(sessionID: string): Promise<string | null>;
+    /**
+     * One request's total byte allowance for memory context, from a fresh
+     * config read. Call once before the request's async memory work starts; an
+     * operation in flight keeps that captured total even if the config changes.
+     */
+    snapshotRequestBudget(): number;
+    /** Wrapped per-prompt retrieval section packed within `budgetBytes`, or null when nothing is relevant. */
+    retrieve(prompt: string, sessionID: string, budgetBytes: number): Promise<string | null>;
+    /** The session's own memories for restore after compaction, loaded once, or null. */
+    restoreSession(sessionID: string): Promise<unknown[] | null>;
+    /** Cached restored memories formatted within `budgetBytes`, or null when nothing fits. */
+    formatRestoredSession(memories: unknown[], budgetBytes: number): string | null;
 }
 export declare function createV2MemoryBridge(directory: string): V2MemoryBridge;

package/dist/v2/memory-bridge.js

@@ -1,5 +1,6 @@
-import { CONFIG, isConfigured } from "../config.js";
-import { buildRetrievalSection, formatMemoriesForCompaction, wrapRetrievalSection, } from "../core/retrieval.js";
+import { CONFIG, isConfigured, refreshConfigIfChanged } from "../config.js";
+import { buildRetrievalSection, formatMemoriesForCompaction, retrievalWrapperBytes, wrapRetrievalSection, } from "../core/retrieval.js";
+import { DEFAULT_RETRIEVAL_MAX_TOKENS, tokensToByteCeiling } from "../core/context-budget.js";
 import { isInternalPrompt, recordUserPrompt } from "../adapters/opencode/user-prompt.js";
 import { memoryClient } from "../services/client.js";
 import { V2_RETRIEVAL_TIMEOUT_MS } from "../services/request-timeouts.js";
@@ -14,8 +15,17 @@ export function createV2MemoryBridge(directory) {
         async recordPrompt(sessionID, messageID, text) {
             await recordUserPrompt(sessionID, messageID, directory, text);
         },
-        async retrieve(prompt, sessionID) {
-            const section = await buildRetrievalSection(prompt, directory, sessionID);
+        snapshotRequestBudget() {
+            refreshConfigIfChanged(directory);
+            // The default guards partial CONFIG stubs in tests.
+            return tokensToByteCeiling(CONFIG.retrievalMaxTokens ?? DEFAULT_RETRIEVAL_MAX_TOKENS);
+        },
+        async retrieve(prompt, sessionID, budgetBytes) {
+            // The wrapper counts against the request budget, so the packed section reserves it.
+            const section = await buildRetrievalSection(prompt, directory, sessionID, {
+                maxBytes: budgetBytes,
+                wrapperBytes: retrievalWrapperBytes(),
+            });
             return section ? wrapRetrievalSection(section) : null;
         },
         async restoreSession(sessionID) {
@@ -23,7 +33,14 @@ export function createV2MemoryBridge(directory) {
             const result = await memoryClient.searchMemoriesBySessionID(sessionID, tags.project.tag, CONFIG.compaction.memoryLimit);
             if (!result.success || result.results.length === 0)
                 return null;
-            return formatMemoriesForCompaction(result.results);
+            // Raw results: the request budget is only known when the restored
+            // section is emitted, so formatting happens in formatRestoredSession.
+            return result.results;
+        },
+        formatRestoredSession(memories, budgetBytes) {
+            if (memories.length === 0)
+                return null;
+            return formatMemoriesForCompaction(memories, { maxBytes: budgetBytes });
         },
     };
 }