om-memory-system 5.3.0 → 5.4.0

package/dist/v2/memory-bridge.js

@@ -1,6 +1,7 @@
 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 { buildFirstPromptSections, openingQueryFor } from "../core/opening-context.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";
@@ -15,6 +16,7 @@ export function createV2MemoryBridge(directory) {
             refreshConfigIfChanged(directory);
             return CONFIG.visibleRecall !== false;
         },
+        isSubagentMemoryEnabled: () => CONFIG.subagentMemory !== false,
         isInternalPrompt,
         async recordPrompt(sessionID, messageID, text) {
             await recordUserPrompt(sessionID, messageID, directory, text);
@@ -32,6 +34,21 @@ export function createV2MemoryBridge(directory) {
             });
             return section ? wrapRetrievalSection(section) : null;
         },
+        async retrieveFirstPrompt(prompt, sessionID, budgetBytes) {
+            const openingQuery = openingQueryFor({
+                openingContext: CONFIG.openingContext,
+                openingContextQuery: CONFIG.openingContextQuery,
+            });
+            const sections = await buildFirstPromptSections({
+                prompt,
+                openingQuery,
+                directory,
+                sessionId: sessionID,
+                budget: { maxBytes: budgetBytes, wrapperBytes: retrievalWrapperBytes() },
+                openingReserveBytes: 0,
+            });
+            return { ...sections, openingQuery };
+        },
         async restoreSession(sessionID) {
             const tags = getTags(directory);
             const result = await memoryClient.searchMemoriesBySessionID(sessionID, tags.project.tag, CONFIG.compaction.memoryLimit);

package/dist/v2/recall-reporter.d.ts

@@ -1,5 +1,7 @@
 import type { Context } from "@opencode/plugin/promise/plugin";
+import { type RecallSummary } from "../core/recall-summary.js";
 import type { V2MemoryBridge } from "./memory-bridge.js";
+import type { SessionParents } from "./session-parent.js";
 /** Latest summaries kept per session. The TUI shows recent rows, so older ones are dropped. */
 export declare const MAX_RECALL_SUMMARIES = 20;
 /** Longest query kept per summary. The TUI shows at most 300 characters of it. */
@@ -7,11 +9,12 @@ export declare const MAX_RECALL_QUERY_CHARS = 300;
 type Bound = <V>(map: Map<string, V>, key: string, value: V) => void;
 export interface RecallReporter {
     /**
-     * Record the summary of one prompt retrieval. `token` identifies the retrieval: model steps
+     * Record the summary of one section as `mode`. `token` identifies the section: model steps
      * that reuse it record once. A section with no memory entries records nothing, and neither
      * does a subagent session (one with a parent). The call does not wait for the session lookup.
+     * The query is kept for `search` and `opening`, and dropped for `restore`.
      */
-    record(sessionID: string, token: object, query: string, section: string | null): void;
+    record(sessionID: string, token: object, mode: RecallSummary["mode"], query: string | null, section: string | null): void;
     forget(sessionID: string): void;
     clear(): void;
 }
@@ -20,5 +23,5 @@ export interface RecallReporter {
  * entrypoint. It never throws and never touches what is injected. Logs carry the mode, count and
  * session id only, never memory text or the query.
  */
-export declare function createRecallReporter(ctx: Context, memory: V2MemoryBridge, bound: Bound): Promise<RecallReporter>;
+export declare function createRecallReporter(ctx: Context, memory: V2MemoryBridge, bound: Bound, parents: SessionParents): Promise<RecallReporter>;
 export {};

package/dist/v2/recall-reporter.js

@@ -10,13 +10,11 @@ export const MAX_RECALL_QUERY_CHARS = 300;
  * entrypoint. It never throws and never touches what is injected. Logs carry the mode, count and
  * session id only, never memory text or the query.
  */
-export async function createRecallReporter(ctx, memory, bound) {
+export async function createRecallReporter(ctx, memory, bound, parents) {
     const rings = new Map();
     // Last number given per session. It keeps rising when the ring drops old entries.
     const sequences = new Map();
     const recorded = new WeakSet();
-    // One lookup per session. The promise is cached so concurrent records keep their order.
-    const subagents = new Map();
     // Records waiting on a session lookup. `forget` and `clear` cancel them, so a late lookup cannot
     // store a summary for a session whose state is gone. Entries leave when their lookup settles.
     const pending = new Map();
@@ -42,25 +40,6 @@ export async function createRecallReporter(ctx, memory, bound) {
             log("v2 recall: push failed", { sessionID, error: String(error) }, "error");
         }
     };
-    // A session with a parent is a subagent session. A failed lookup counts as a root session, so
-    // the summary still shows.
-    const isSubagent = (sessionID) => {
-        const known = subagents.get(sessionID);
-        if (known)
-            return known;
-        const lookup = (async () => {
-            try {
-                const info = await ctx.session.get({ sessionID });
-                return Boolean(info?.parentID);
-            }
-            catch (error) {
-                log("v2 recall: session lookup failed", { sessionID, error: String(error) }, "error");
-                return false;
-            }
-        })();
-        bound(subagents, sessionID, lookup);
-        return lookup;
-    };
     const store = (sessionID, built) => {
         const seq = (sequences.get(sessionID) ?? 0) + 1;
         bound(sequences, sessionID, seq);
@@ -75,13 +54,13 @@ export async function createRecallReporter(ctx, memory, bound) {
         notify(sessionID);
     };
     return {
-        record(sessionID, token, query, section) {
+        record(sessionID, token, mode, query, section) {
             if (recorded.has(token))
                 return;
             recorded.add(token);
             try {
                 const summary = section
-                    ? buildRecallSummary(section, "search", query.slice(0, MAX_RECALL_QUERY_CHARS))
+                    ? buildRecallSummary(section, mode, query?.slice(0, MAX_RECALL_QUERY_CHARS) ?? null)
                     : null;
                 if (!summary)
                     return;
@@ -89,7 +68,7 @@ export async function createRecallReporter(ctx, memory, bound) {
                 const tickets = pending.get(sessionID) ?? new Set();
                 tickets.add(ticket);
                 pending.set(sessionID, tickets);
-                void isSubagent(sessionID).then((subagent) => {
+                void parents.isSubagent(sessionID).then((subagent) => {
                     tickets.delete(ticket);
                     if (tickets.size === 0 && pending.get(sessionID) === tickets)
                         pending.delete(sessionID);
@@ -113,7 +92,6 @@ export async function createRecallReporter(ctx, memory, bound) {
             pending.delete(sessionID);
             rings.delete(sessionID);
             sequences.delete(sessionID);
-            subagents.delete(sessionID);
         },
         clear: () => {
             for (const tickets of pending.values())
@@ -122,7 +100,6 @@ export async function createRecallReporter(ctx, memory, bound) {
             pending.clear();
             rings.clear();
             sequences.clear();
-            subagents.clear();
         },
     };
 }

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

@@ -0,0 +1,14 @@
+import type { Context } from "@opencode/plugin/promise/plugin";
+type Bound = <V>(map: Map<string, V>, key: string, value: V) => void;
+export interface SessionParents {
+    /**
+     * Whether the session has a parent, which makes it a subagent session. One lookup per session;
+     * the promise is cached so concurrent callers share it. A failed lookup counts as a root session.
+     */
+    isSubagent(sessionID: string): Promise<boolean>;
+    forget(sessionID: string): void;
+    clear(): void;
+}
+/** The cached parent lookup shared by the recall reporter and the adapter's subagent gate. */
+export declare function createSessionParents(ctx: Context, bound: Bound): SessionParents;
+export {};

package/dist/v2/session-parent.js

@@ -0,0 +1,26 @@
+import { log } from "../services/logger.js";
+/** The cached parent lookup shared by the recall reporter and the adapter's subagent gate. */
+export function createSessionParents(ctx, bound) {
+    const lookups = new Map();
+    return {
+        isSubagent(sessionID) {
+            const known = lookups.get(sessionID);
+            if (known)
+                return known;
+            const lookup = (async () => {
+                try {
+                    const info = await ctx.session.get({ sessionID });
+                    return Boolean(info?.parentID);
+                }
+                catch (error) {
+                    log("v2 session: parent lookup failed", { sessionID, error: String(error) }, "error");
+                    return false;
+                }
+            })();
+            bound(lookups, sessionID, lookup);
+            return lookup;
+        },
+        forget: (sessionID) => void lookups.delete(sessionID),
+        clear: () => lookups.clear(),
+    };
+}