om-memory-system 5.2.0 → 5.4.0

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

@@ -0,0 +1,27 @@
+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. */
+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 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, mode: RecallSummary["mode"], query: string | null, section: string | null): void;
+    forget(sessionID: string): void;
+    clear(): void;
+}
+/**
+ * Keeps a bounded per-session ring of recall summaries and serves it over plugin RPC to the TUI
+ * 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, parents: SessionParents): Promise<RecallReporter>;
+export {};

package/dist/v2/recall-reporter.js

@@ -0,0 +1,105 @@
+import { buildRecallSummary } from "../core/recall-summary.js";
+import { log } from "../services/logger.js";
+import { recallRpc } from "./recall-rpc.js";
+/** Latest summaries kept per session. The TUI shows recent rows, so older ones are dropped. */
+export const MAX_RECALL_SUMMARIES = 20;
+/** Longest query kept per summary. The TUI shows at most 300 characters of it. */
+export const MAX_RECALL_QUERY_CHARS = 300;
+/**
+ * Keeps a bounded per-session ring of recall summaries and serves it over plugin RPC to the TUI
+ * 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, 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();
+    // 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();
+    let emit;
+    try {
+        const registration = await ctx.rpc.register(recallRpc, {
+            // The contract is plain JSON schema, so the host types the input as unknown.
+            list: async (input) => ({
+                enabled: memory.isVisibleRecallEnabled(),
+                items: [...(rings.get(input.sessionID) ?? [])],
+            }),
+        });
+        emit = (sessionID) => registration.events.emit("recalled", { sessionID });
+    }
+    catch (error) {
+        log("v2 recall: rpc registration failed", { error: String(error) }, "error");
+    }
+    const notify = (sessionID) => {
+        try {
+            emit?.(sessionID).catch((error) => log("v2 recall: push failed", { sessionID, error: String(error) }, "error"));
+        }
+        catch (error) {
+            log("v2 recall: push failed", { sessionID, error: String(error) }, "error");
+        }
+    };
+    const store = (sessionID, built) => {
+        const seq = (sequences.get(sessionID) ?? 0) + 1;
+        bound(sequences, sessionID, seq);
+        const summary = { ...built, seq };
+        const ring = [...(rings.get(sessionID) ?? []), summary].slice(-MAX_RECALL_SUMMARIES);
+        bound(rings, sessionID, ring);
+        log("v2 recall: summary recorded", {
+            sessionID,
+            mode: summary.mode,
+            count: summary.items.length,
+        });
+        notify(sessionID);
+    };
+    return {
+        record(sessionID, token, mode, query, section) {
+            if (recorded.has(token))
+                return;
+            recorded.add(token);
+            try {
+                const summary = section
+                    ? buildRecallSummary(section, mode, query?.slice(0, MAX_RECALL_QUERY_CHARS) ?? null)
+                    : null;
+                if (!summary)
+                    return;
+                const ticket = { cancelled: false };
+                const tickets = pending.get(sessionID) ?? new Set();
+                tickets.add(ticket);
+                pending.set(sessionID, tickets);
+                void parents.isSubagent(sessionID).then((subagent) => {
+                    tickets.delete(ticket);
+                    if (tickets.size === 0 && pending.get(sessionID) === tickets)
+                        pending.delete(sessionID);
+                    if (subagent || ticket.cancelled)
+                        return;
+                    try {
+                        store(sessionID, summary);
+                    }
+                    catch (error) {
+                        log("v2 recall: could not record summary", { sessionID, error: String(error) }, "error");
+                    }
+                });
+            }
+            catch (error) {
+                log("v2 recall: could not record summary", { sessionID, error: String(error) }, "error");
+            }
+        },
+        forget: (sessionID) => {
+            for (const ticket of pending.get(sessionID) ?? [])
+                ticket.cancelled = true;
+            pending.delete(sessionID);
+            rings.delete(sessionID);
+            sequences.delete(sessionID);
+        },
+        clear: () => {
+            for (const tickets of pending.values())
+                for (const ticket of tickets)
+                    ticket.cancelled = true;
+            pending.clear();
+            rings.clear();
+            sequences.clear();
+        },
+    };
+}

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

@@ -0,0 +1,51 @@
+/**
+ * Plugin RPC contract between the OpenCode v2 server entrypoint (records recall summaries) and the
+ * terminal TUI entrypoint (draws them). Plain data on purpose: no host SDK import, so both sides and
+ * the tests can load it. The TUI pulls `list` and treats `recalled` as a refresh hint only; a missing
+ * push never breaks the rows (TDR-060).
+ */
+export declare const RECALL_RPC_ID = "omms-recall";
+export declare const recallRpc: {
+    readonly id: "omms-recall";
+    readonly methods: {
+        readonly list: {
+            readonly input: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly sessionID: {
+                        readonly type: "string";
+                    };
+                };
+                readonly required: readonly ["sessionID"];
+            };
+            readonly output: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly enabled: {
+                        readonly type: "boolean";
+                    };
+                    readonly items: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "object";
+                        };
+                    };
+                };
+                readonly required: readonly ["enabled", "items"];
+            };
+        };
+    };
+    readonly events: {
+        readonly recalled: {
+            readonly schema: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly sessionID: {
+                        readonly type: "string";
+                    };
+                };
+                readonly required: readonly ["sessionID"];
+            };
+        };
+    };
+};

package/dist/v2/recall-rpc.js

@@ -0,0 +1,38 @@
+/**
+ * Plugin RPC contract between the OpenCode v2 server entrypoint (records recall summaries) and the
+ * terminal TUI entrypoint (draws them). Plain data on purpose: no host SDK import, so both sides and
+ * the tests can load it. The TUI pulls `list` and treats `recalled` as a refresh hint only; a missing
+ * push never breaks the rows (TDR-060).
+ */
+export const RECALL_RPC_ID = "omms-recall";
+export const recallRpc = {
+    id: RECALL_RPC_ID,
+    methods: {
+        // `enabled` is the effective `visibleRecall` setting for the server's project, so the TUI never
+        // reads config. Summaries are recorded and served even when it is false.
+        list: {
+            input: {
+                type: "object",
+                properties: { sessionID: { type: "string" } },
+                required: ["sessionID"],
+            },
+            output: {
+                type: "object",
+                properties: {
+                    enabled: { type: "boolean" },
+                    items: { type: "array", items: { type: "object" } },
+                },
+                required: ["enabled", "items"],
+            },
+        },
+    },
+    events: {
+        recalled: {
+            schema: {
+                type: "object",
+                properties: { sessionID: { type: "string" } },
+                required: ["sessionID"],
+            },
+        },
+    },
+};

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(),
+    };
+}