om-memory-system 5.2.0 → 5.4.0

package/README.md

@@ -82,6 +82,10 @@ Each host starts the shared web app when needed, unless it is disabled. Browse
 captured notes on **Project memories**, or ask your agent to search memory for
 an earlier decision.
 
+Each host adds only the memories that match your prompt. An optional setting
+also adds matching memories to the first message of a new session. See
+[Host differences](docs/using-memory.md#host-differences).
+
 ### Terminal command (optional)
 
 A global install puts `om-memory-system` on your `PATH`:

package/dist/adapters/claude-code/hook-client.d.ts

@@ -1,5 +1,5 @@
 import type { EnsureDeps } from "../../services/web-ensure.js";
-export declare const CLAUDE_HOOK_EVENTS: readonly ["session-start", "user-prompt-submit", "stop"];
+export declare const CLAUDE_HOOK_EVENTS: readonly ["session-start", "user-prompt-submit", "subagent-start", "stop"];
 export type ClaudeHookEvent = (typeof CLAUDE_HOOK_EVENTS)[number];
 /** Claude Code caps added context at 10,000 characters; keep a margin. */
 export declare const CLAUDE_CONTEXT_LIMIT = 9500;

package/dist/adapters/claude-code/hook-client.js

@@ -3,7 +3,12 @@ import { AUTH_HEADER } from "../../services/auth-token.js";
 // Claude Code hook client: read the hook input, find or start the OMMS web
 // app, send one request, print the added context, and log one metadata line.
 // It loads no store, embedding model, or engine; the web app does that work.
-export const CLAUDE_HOOK_EVENTS = ["session-start", "user-prompt-submit", "stop"];
+export const CLAUDE_HOOK_EVENTS = [
+    "session-start",
+    "user-prompt-submit",
+    "subagent-start",
+    "stop",
+];
 /** Claude Code caps added context at 10,000 characters; keep a margin. */
 export const CLAUDE_CONTEXT_LIMIT = 9_500;
 /**
@@ -16,11 +21,13 @@ const MAX_INPUT_BYTES = 1024 * 1024;
 const BUDGETS = {
     "session-start": { startMs: 15_000, requestMs: 3_000 },
     "user-prompt-submit": { startMs: 5_000, requestMs: 3_000 },
+    "subagent-start": { startMs: 5_000, requestMs: 3_000 },
     stop: { startMs: 30_000, requestMs: 5_000 },
 };
 const HOOK_EVENT_NAMES = {
     "session-start": "SessionStart",
     "user-prompt-submit": "UserPromptSubmit",
+    "subagent-start": "SubagentStart",
     stop: "Stop",
 };
 /** Read stdin up to a time and size limit. Late, oversized, or broken input is no input. */
@@ -83,6 +90,12 @@ function parseInput(text, event) {
         return null;
     return input;
 }
+/** The one input field each retrieval event adds to the request, beside the common ones. */
+const RETRIEVE_FIELD = {
+    "session-start": "source",
+    "user-prompt-submit": "prompt",
+    "subagent-start": "agent_type",
+};
 function requestFor(event, input) {
     const optional = (key) => (input[key] === undefined ? {} : { [key]: input[key] });
     if (event === "stop")
@@ -103,7 +116,7 @@ function requestFor(event, input) {
             session_id: input.session_id,
             cwd: input.cwd,
             ...optional("transcript_path"),
-            ...optional(event === "session-start" ? "source" : "prompt"),
+            ...optional(RETRIEVE_FIELD[event]),
         },
     };
 }

package/dist/adapters/opencode/in-process-client.d.ts

@@ -0,0 +1,2 @@
+export declare function markInProcessClient<T extends object>(client: T): T;
+export declare function isInProcessClient(client: unknown): boolean;

package/dist/adapters/opencode/in-process-client.js

@@ -0,0 +1,16 @@
+/**
+ * Marks a host client that talks to OpenCode in-process. The V2 legacy client
+ * is one: it calls the plugin context directly, so it has no HTTP transport
+ * and no fetch to borrow. The transport setup skips its "no host fetch"
+ * warning for it.
+ */
+const IN_PROCESS_CLIENT = Symbol.for("omms.opencode.inProcessClient");
+export function markInProcessClient(client) {
+    Object.defineProperty(client, IN_PROCESS_CLIENT, { value: true });
+    return client;
+}
+export function isInProcessClient(client) {
+    return (typeof client === "object" &&
+        client !== null &&
+        client[IN_PROCESS_CLIENT] === true);
+}

package/dist/adapters/opencode/opencode-host-config.d.ts

@@ -2,6 +2,9 @@ export type HostClientConfig = {
     readonly baseUrl: string | undefined;
     readonly fetch: typeof fetch | undefined;
     readonly headers?: RequestInit["headers"];
+    /** Present when the host client runs in-process (OpenCode v2): no HTTP
+     * transport, so a missing fetch is expected and not worth a warning. */
+    readonly inProcess?: true;
     readonly clientKeys: readonly string[];
     readonly sdkConfigCount: number;
 };

package/dist/adapters/opencode/opencode-host-config.js

@@ -1,3 +1,4 @@
+import { isInProcessClient } from "./in-process-client.js";
 export function getHostClientConfig(ctx) {
     const client = toRecord(ctx.client);
     if (!client) {
@@ -11,6 +12,7 @@ export function getHostClientConfig(ctx) {
         baseUrl: typeof baseUrl === "string" ? baseUrl : undefined,
         fetch: isFetch(customFetch) ? customFetch : undefined,
         ...(isHeadersInit(headers) ? { headers } : {}),
+        ...(isInProcessClient(client) ? { inProcess: true } : {}),
         clientKeys: Object.keys(client),
         sdkConfigCount: configs.length,
     };

package/dist/adapters/opencode/tui-recall.d.ts

@@ -0,0 +1,68 @@
+import { type RecallSummary } from "../../core/recall-summary.js";
+/**
+ * Fold rows for OMMS recalls in the OpenCode terminal TUI (TDR-060). The TUI entry (`opencode/tui.tsx`)
+ * passes its host pieces in, so this module never imports a host SDK, storage, capture or config. Every
+ * host call sits behind a guard: a missing RPC handler, a failing storage call or a throwing render
+ * draws nothing for that part and never throws into the host. Nothing here logs: memory text must not
+ * reach a log.
+ */
+/** Most rows shown at once. Older summaries of the session are dropped from the view. */
+export declare const MAX_ROWS = 5;
+/** Persisted fold state: only open rows are stored, keyed by `rowKey`. */
+export interface FoldState {
+    open: Record<string, boolean>;
+}
+/** The slice of `ctx.client.rpc(recallRpc)` this module uses. */
+export interface RecallRpcClient {
+    list(input: {
+        sessionID: string;
+    }): Promise<{
+        enabled: boolean;
+        items: RecallSummary[];
+    }>;
+    events: {
+        on(name: string, handler: (event: any) => void): unknown;
+    };
+}
+export interface TuiRecallDeps {
+    client: {
+        rpc(definition: unknown): RecallRpcClient;
+    };
+    data: {
+        listen(handler: (event: any) => void): unknown;
+    };
+    ui: {
+        slot(spec: {
+            append: string;
+            render: (input: {
+                sessionID?: string;
+            }) => unknown;
+        }): unknown;
+    };
+    keymap: {
+        layer(factory: () => unknown): unknown;
+    };
+    storage: {
+        store(key: string, options: {
+            initial: FoldState;
+        }): [FoldState, (change: (draft: FoldState) => void) => unknown];
+    };
+    createSignal: <T>(value: T) => [() => T, (next: T | ((previous: T) => T)) => unknown];
+    jsx: (tag: string, props: Record<string, unknown>) => unknown;
+    /** Theme colour for row text; read on each paint. */
+    muted: () => unknown;
+    /** Quiet period that collapses a burst of host events into one `list` call. */
+    debounceMs?: number;
+}
+/**
+ * Stable per-summary key. A summary with a server sequence number is keyed by session id and that
+ * number, so it survives the ring dropping older entries. An older server sends none, so the key
+ * falls back to the session id, a hash of mode, query and each memory's id (or headline when it
+ * has none), and a counter for identical summaries.
+ */
+export declare function rowKeys(sessionID: string, summaries: RecallSummary[]): string[];
+/**
+ * Draw one fold row per recall summary of the session in view. Returns a stop function that removes
+ * every hook it added.
+ */
+export declare function startTuiRecall(deps: TuiRecallDeps): () => void;

package/dist/adapters/opencode/tui-recall.js

@@ -0,0 +1,312 @@
+import { callTitle, unfoldLines } from "../../core/recall-summary.js";
+import { recallRpc } from "../../v2/recall-rpc.js";
+/**
+ * Fold rows for OMMS recalls in the OpenCode terminal TUI (TDR-060). The TUI entry (`opencode/tui.tsx`)
+ * passes its host pieces in, so this module never imports a host SDK, storage, capture or config. Every
+ * host call sits behind a guard: a missing RPC handler, a failing storage call or a throwing render
+ * draws nothing for that part and never throws into the host. Nothing here logs: memory text must not
+ * reach a log.
+ */
+/** Most rows shown at once. Older summaries of the session are dropped from the view. */
+export const MAX_ROWS = 5;
+const FOLD_STORE_KEY = "omms.recall.fold";
+const SLOT = "session.composer.top";
+const APP_SLOT = "app";
+const DEFAULT_DEBOUNCE_MS = 150;
+/**
+ * Host events that pull the recall list. The server records a recall when a model step starts (the
+ * `context` hook), so only the events around a step, plus session creation and view changes, can
+ * coincide with a new recall. The end events catch a missed `recalled` push right after the step.
+ * The failure events are end events too: the summary is recorded in the `context` hook after
+ * `session.step.started` fires, so if the push is absent and the step then fails, no later event
+ * in this set would pull it.
+ * Streaming, part, message, inbox and instruction events fire dozens of times per reply and never
+ * change the list, so they must stay out of this set.
+ */
+const PULL_EVENT_TYPES = new Set([
+    "session.created",
+    "session.viewed",
+    "session.execution.started",
+    "session.step.started",
+    "session.step.ended",
+    "session.execution.succeeded",
+    "session.step.failed",
+    "session.execution.failed",
+]);
+const SUMMARY_MODES = new Set(["search", "recent", "opening", "restore"]);
+function isSummary(value) {
+    const v = value;
+    return (!!v &&
+        SUMMARY_MODES.has(v.mode) &&
+        Array.isArray(v.items) &&
+        v.items.every((item) => !!item && typeof item.headline === "string"));
+}
+/** FNV-1a, 32 bit: short, deterministic, no crypto needed for a fold key. */
+function hash(text) {
+    let h = 0x811c9dc5;
+    for (let i = 0; i < text.length; i++) {
+        h ^= text.charCodeAt(i);
+        h = Math.imul(h, 0x01000193);
+    }
+    return (h >>> 0).toString(16);
+}
+/**
+ * Stable per-summary key. A summary with a server sequence number is keyed by session id and that
+ * number, so it survives the ring dropping older entries. An older server sends none, so the key
+ * falls back to the session id, a hash of mode, query and each memory's id (or headline when it
+ * has none), and a counter for identical summaries.
+ */
+export function rowKeys(sessionID, summaries) {
+    const seen = new Map();
+    return summaries.map((summary) => {
+        if (typeof summary.seq === "number")
+            return `${sessionID}:${summary.seq}`;
+        const body = [
+            summary.mode,
+            summary.query ?? "",
+            ...summary.items.map((item) => item.id ?? item.headline),
+        ].join("\u0000");
+        const base = `${sessionID}:${hash(body)}`;
+        const count = seen.get(base) ?? 0;
+        seen.set(base, count + 1);
+        return count === 0 ? base : `${base}#${count}`;
+    });
+}
+function guard(fn) {
+    try {
+        return fn();
+    }
+    catch {
+        return undefined;
+    }
+}
+function release(handle) {
+    if (typeof handle === "function")
+        guard(() => handle());
+}
+/**
+ * Draw one fold row per recall summary of the session in view. Returns a stop function that removes
+ * every hook it added.
+ */
+export function startTuiRecall(deps) {
+    const debounceMs = deps.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+    const sessions = new Map();
+    const local = new Map();
+    let lastViewed;
+    let stopped = false;
+    let layerHandle;
+    // Two signals: the list changes when summaries arrive, the text changes when a row folds.
+    const [listRevision, setListRevision] = deps.createSignal(0);
+    const [foldRevision, setFoldRevision] = deps.createSignal(0);
+    const repaintList = () => void guard(() => setListRevision((n) => n + 1));
+    const repaintFold = () => void guard(() => setFoldRevision((n) => n + 1));
+    const rpc = guard(() => deps.client.rpc(recallRpc));
+    const fold = guard(() => deps.storage.store(FOLD_STORE_KEY, { initial: { open: {} } }));
+    const sessionState = (id) => {
+        let state = sessions.get(id);
+        if (!state) {
+            state = { enabled: false, summaries: [], inflight: false, dirty: false };
+            sessions.set(id, state);
+        }
+        return state;
+    };
+    const apply = (id, enabled, summaries) => {
+        const state = sessionState(id);
+        state.enabled = enabled;
+        state.summaries = summaries;
+        repaintList();
+    };
+    async function pull(id) {
+        const state = sessionState(id);
+        state.inflight = true;
+        try {
+            const reply = await rpc.list({ sessionID: id });
+            if (stopped)
+                return;
+            const ok = reply?.enabled === true && Array.isArray(reply.items);
+            apply(id, ok, ok ? reply.items.filter(isSummary) : []);
+        }
+        catch {
+            if (!stopped)
+                apply(id, false, []);
+        }
+        finally {
+            state.inflight = false;
+            if (state.dirty && !stopped) {
+                state.dirty = false;
+                request(id, debounceMs);
+            }
+        }
+    }
+    /** At most one `list` per session per window; a request during a call asks for one more after it. */
+    function request(id, delayMs) {
+        if (stopped || !rpc)
+            return;
+        const state = sessionState(id);
+        if (state.timer)
+            return;
+        if (state.inflight) {
+            state.dirty = true;
+            return;
+        }
+        state.timer = setTimeout(() => {
+            state.timer = undefined;
+            void pull(id);
+        }, delayMs);
+        state.timer.unref?.();
+    }
+    const isOpen = (key) => local.get(key) ?? guard(() => fold?.[0]?.open?.[key] === true) ?? false;
+    const persist = (changes) => {
+        if (!fold)
+            return;
+        guard(() => {
+            const done = fold[1]((draft) => {
+                draft.open ??= {};
+                for (const [key, open] of changes) {
+                    if (open)
+                        draft.open[key] = true;
+                    else
+                        delete draft.open[key];
+                }
+            });
+            Promise.resolve(done).catch(() => undefined);
+        });
+    };
+    const rowsFor = (id) => {
+        const state = sessions.get(id);
+        if (!state?.enabled || state.summaries.length === 0)
+            return [];
+        const keys = rowKeys(id, state.summaries);
+        return state.summaries
+            .map((summary, index) => ({ key: keys[index], summary }))
+            .slice(-MAX_ROWS);
+    };
+    const toggle = (key) => {
+        const next = !isOpen(key);
+        local.set(key, next);
+        persist([[key, next]]);
+        repaintFold();
+    };
+    const toggleAll = () => {
+        if (!lastViewed)
+            return;
+        const rows = rowsFor(lastViewed);
+        const target = rows.some((row) => !isOpen(row.key));
+        for (const row of rows)
+            local.set(row.key, target);
+        persist(rows.map((row) => [row.key, target]));
+        repaintFold();
+    };
+    // The host owns a keymap layer through the component that created it and removes it when that
+    // component is disposed. The row slot unmounts on screen changes, so the layer lives in the
+    // "app" slot instead, which stays mounted for the whole TUI.
+    const registerCommand = () => {
+        layerHandle = guard(() => deps.keymap.layer(() => ({
+            mode: "global",
+            commands: [
+                {
+                    id: "omms.recall.fold",
+                    title: "Toggle OMMS recall rows",
+                    palette: true,
+                    slash: { name: "omms-recall" },
+                    run: () => void guard(toggleAll),
+                },
+            ],
+        })));
+    };
+    const drawRow = ({ key, summary }) => deps.jsx("box", {
+        flexDirection: "column",
+        onMouseDown: () => void guard(() => toggle(key)),
+        get children() {
+            return [
+                deps.jsx("text", {
+                    get fg() {
+                        return guard(deps.muted);
+                    },
+                    get children() {
+                        foldRevision();
+                        return guard(() => `${isOpen(key) ? "▾" : "▸"} ● ${callTitle(summary)}`) ?? "";
+                    },
+                }),
+                deps.jsx("text", {
+                    get visible() {
+                        foldRevision();
+                        return isOpen(key);
+                    },
+                    get fg() {
+                        return guard(deps.muted);
+                    },
+                    get children() {
+                        foldRevision();
+                        if (!isOpen(key))
+                            return "";
+                        return (guard(() => unfoldLines(summary)
+                            .map((line) => `  ${line}`)
+                            .join("\n")) ?? "");
+                    },
+                }),
+            ];
+        },
+    });
+    const render = (input) => {
+        try {
+            // The host passes slot input as reactive props and may keep this claim mounted while the
+            // session in view changes, so the id is read on each paint. `tracked` makes the follow-up
+            // idempotent: a repaint with the same id asks for no new pull.
+            let tracked;
+            const follow = () => {
+                const id = guard(() => input?.sessionID);
+                if (id && id !== tracked) {
+                    tracked = id;
+                    lastViewed = id;
+                    request(id, 0);
+                }
+                return id;
+            };
+            follow();
+            return deps.jsx("box", {
+                flexDirection: "column",
+                get children() {
+                    listRevision();
+                    const id = follow();
+                    return (id ? guard(() => rowsFor(id).map(drawRow)) : undefined) ?? [];
+                },
+            });
+        }
+        catch {
+            return null;
+        }
+    };
+    const removeSlot = guard(() => deps.ui.slot({ append: SLOT, render }));
+    // Draws nothing. It exists so the command layer is owned by a component that is not disposed
+    // when the session view changes.
+    const renderCommandOwner = () => {
+        registerCommand();
+        return null;
+    };
+    const removeCommandSlot = guard(() => deps.ui.slot({ append: APP_SLOT, render: renderCommandOwner }));
+    const offPush = guard(() => rpc?.events.on("recalled", (event) => {
+        const id = event?.data?.sessionID;
+        if (typeof id === "string" && sessions.has(id))
+            request(id, debounceMs);
+    }));
+    // Only sessions the slot has drawn are refreshed, and an event without a session id is no hint.
+    const offData = guard(() => deps.data.listen((event) => {
+        const details = event?.details;
+        if (typeof details?.type !== "string" || !PULL_EVENT_TYPES.has(details.type))
+            return;
+        const id = details.data?.sessionID ?? details.properties?.sessionID;
+        if (typeof id === "string" && sessions.has(id))
+            request(id, debounceMs);
+    }));
+    return () => {
+        stopped = true;
+        for (const state of sessions.values())
+            clearTimeout(state.timer);
+        release(offData);
+        release(offPush);
+        release(removeSlot);
+        release(removeCommandSlot);
+        release(layerHandle);
+    };
+}

package/dist/adapters/pi/extension.d.ts

@@ -12,6 +12,7 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
  * - `memory` tool          -> shared add/search/profile/list/forget/help and
  *                             portability operations
  * - `skills` tool          -> shared skill-learning operations (skills-tool.ts)
+ * - `/omms-recall`        -> fold or unfold the recall rows (recall-rows.ts)
  *
  * Pi types are imported type-only: the compiled extension carries no Pi
  * runtime dependency and uses the host Pi runtime provided at load time.

package/dist/adapters/pi/extension.js

@@ -12,7 +12,8 @@ import { createPiLiveModels } from "./live-model.js";
 import { registerPiHistoryImportCommand } from "./import-command.js";
 import { registerPiSkillsTool } from "./skills-tool.js";
 import { performPiProfileLearning } from "./profile.js";
-import { buildRetrievalSection, retrievalWrapperBytes, wrapRetrievalSection, } from "../../core/retrieval.js";
+import { createPiRecallRows } from "./recall-rows.js";
+import { createPiSessionContext } from "./session-context.js";
 import { DEFAULT_RETRIEVAL_MAX_TOKENS, tokensToByteCeiling } from "../../core/context-budget.js";
 import { ommsStatusLabel } from "../../services/status-glyphs.js";
 const GLOBAL_PLUGIN_WARMUP_KEY = Symbol.for("omms.plugin.warmedup");
@@ -67,6 +68,7 @@ function lastSettledUserPrompt(entries) {
  * - `memory` tool          -> shared add/search/profile/list/forget/help and
  *                             portability operations
  * - `skills` tool          -> shared skill-learning operations (skills-tool.ts)
+ * - `/omms-recall`        -> fold or unfold the recall rows (recall-rows.ts)
  *
  * Pi types are imported type-only: the compiled extension carries no Pi
  * runtime dependency and uses the host Pi runtime provided at load time.
@@ -79,6 +81,8 @@ export default function ommsPiExtension(pi) {
     let latestCtx = null;
     let backfillSessionId = null;
     let statusVersion = 0;
+    const recallRows = createPiRecallRows();
+    const sessionContext = createPiSessionContext(recallRows);
     const startStatus = (ctx, status) => {
         const version = ++statusVersion;
         if (ctx.hasUI)
@@ -101,7 +105,7 @@ export default function ommsPiExtension(pi) {
         const level = notification.variant === "success" ? "info" : notification.variant;
         ctx.ui.notify(`${notification.title}: ${notification.message}`, level);
     };
-    pi.on("session_start", async (_event, ctx) => {
+    pi.on("session_start", async (event, ctx) => {
         const status = startStatus(ctx, "warming");
         try {
             latestCtx = ctx;
@@ -221,6 +225,10 @@ export default function ommsPiExtension(pi) {
             else {
                 finishStatus(ctx, status, "connected");
             }
+            if (event.reason === "resume") {
+                sessionContext.markSeen(sessionId);
+                await sessionContext.loadRestore(ctx);
+            }
         }
         catch (error) {
             log("Pi session_start error", { error: String(error) }, "error");
@@ -234,19 +242,13 @@ export default function ommsPiExtension(pi) {
         refreshConfigIfChanged(ctx.cwd);
         // The default guards partial CONFIG stubs in tests.
         const budgetBytes = tokensToByteCeiling(CONFIG.retrievalMaxTokens ?? DEFAULT_RETRIEVAL_MAX_TOKENS);
-        if (!isConfigured() || !CONFIG.chatMessage.enabled)
+        if (!isConfigured() || (!CONFIG.chatMessage.enabled && !CONFIG.compaction?.enabled))
             return;
         const status = startStatus(ctx, "recalling");
         try {
-            // The wrapper counts against the captured allowance, so the packed
-            // section reserves its bytes.
-            const section = await buildRetrievalSection(event.prompt, ctx.cwd, ctx.sessionManager.getSessionId(), { maxBytes: budgetBytes, wrapperBytes: retrievalWrapperBytes() });
+            const extra = await sessionContext.recall(ctx, event.prompt, budgetBytes);
             finishStatus(ctx, status, "connected");
-            if (!section)
-                return;
-            return {
-                systemPrompt: event.systemPrompt + "\n\n" + wrapRetrievalSection(section),
-            };
+            return extra ? { systemPrompt: event.systemPrompt + extra } : undefined;
         }
         catch (error) {
             log("Pi before_agent_start retrieval error", { error: String(error) }, "error");
@@ -254,6 +256,12 @@ export default function ommsPiExtension(pi) {
             return undefined;
         }
     });
+    // OMMS adds memories after compaction; it never replaces Pi's own summary (no
+    // session_before_compact handler).
+    pi.on("session_compact", async (_event, ctx) => {
+        sessionContext.markSeen(ctx.sessionManager.getSessionId());
+        await sessionContext.loadRestore(ctx);
+    });
     pi.on("agent_settled", async (_event, ctx) => {
         if (!isConfigured())
             return;
@@ -301,6 +309,8 @@ export default function ommsPiExtension(pi) {
     });
     pi.on("session_shutdown", async (_event, ctx) => {
         clearStatus(ctx);
+        recallRows.reset(ctx);
+        sessionContext.reset();
         latestCtx = null;
         captureState = createPiCaptureState();
         promptsSinceProfileAnalysis = [];
@@ -350,6 +360,13 @@ export default function ommsPiExtension(pi) {
             };
         },
     });
+    pi.registerCommand("omms-recall", {
+        description: "Unfold or fold the OMMS recall rows",
+        handler: async (_args, ctx) => {
+            refreshConfigIfChanged(ctx.cwd);
+            await recallRows.toggleAll(ctx, CONFIG.visibleRecall !== false);
+        },
+    });
     registerPiSkillsTool(pi);
     registerPiHistoryImportCommand(pi, () => latestCtx);
 }

package/dist/adapters/pi/recall-rows.d.ts

@@ -0,0 +1,31 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { type RecallSummary } from "../../core/recall-summary.js";
+/**
+ * Fold rows for OMMS recalls above the Pi editor (change add-pi-visible-recall, TDR-062).
+ *
+ * Rows are drawn only in Pi's interactive terminal (`ctx.mode === "tui"`). RPC, JSON and print
+ * runs, subagent children among them, record and draw nothing. Summaries and fold state live in
+ * memory only: Pi offers no extension store outside the session file, and a session entry would
+ * write memory text into the session file. Logs carry the session id, mode and count only.
+ */
+export declare const RECALL_WIDGET_KEY = "omms-recall";
+/** Latest summaries kept per session. */
+export declare const MAX_RECALL_SUMMARIES = 20;
+/** Most rows shown at once. */
+export declare const MAX_RECALL_ROWS = 5;
+/** Longest query kept per summary. An unfolded row shows at most 300 characters of it. */
+export declare const MAX_RECALL_QUERY_CHARS = 300;
+export interface PiRecallRows {
+    /**
+     * Record one recall and redraw. Does nothing outside the interactive terminal. `query` is the
+     * prompt for a `search` row, the configured query for an `opening` row, and ignored for `restore`.
+     */
+    record(ctx: ExtensionContext, query: string, section: string | null, enabled: boolean, mode?: "search" | "opening" | "restore"): Promise<void>;
+    /** `/omms-recall`: unfold every shown row, or fold them all when all are open. */
+    toggleAll(ctx: ExtensionContext, enabled: boolean): Promise<void>;
+    /** Forget summaries and fold state, and clear the widget. */
+    reset(ctx: ExtensionContext): void;
+    /** Summaries of the current session, oldest first. */
+    summaries(): readonly RecallSummary[];
+}
+export declare function createPiRecallRows(): PiRecallRows;