opencode-courier 0.7.3 → 0.9.0

package/dist/memory/ports.d.ts

@@ -0,0 +1,55 @@
+/** The memory's ports: what refreshing a record and courier_recall need of the plugin context, and what the process shares. */
+import type { Plugin } from "@opencode/plugin";
+import type { Storage } from "../platform/storage.js";
+import type { ModelWindow } from "../tree/index.js";
+import type { Pinned, ReadKind, Reads, StoredRecord, TreeRecord } from "./domain.js";
+export type { Lesson, PartRecord, PartStatus, Pinned, ReadKind, Reads, Recalled, Revision, StoredRecord, TreeRecord } from "./domain.js";
+type Context = Plugin.Context;
+/** What refreshing a record runs on: every hub-v2 member's watch ports have these, so the event module runs through any. */
+export interface RefreshPorts {
+    readonly storage: Storage;
+    readonly session: Pick<Context["session"], "get" | "context">;
+    readonly now: () => number;
+    readonly log: (message: string) => void;
+}
+/** What courier_recall and courier_note run on: one instance's ports. */
+export interface MemoryPorts extends RefreshPorts {
+    /** The project of the plugin's location, whose records the tools read and write. */
+    readonly projectID: string;
+    /** The `memory` option: off, and the tools write and list nothing. */
+    readonly memory: boolean;
+    /** The tree's `maxDepth` limit: a session at it is a leaf, which courier_note refuses. */
+    readonly maxDepth: number;
+}
+/** What every plugin instance in the process shares of the memory, under a fixed key outside the hub. */
+export interface MemoryState {
+    /** The context windows of the models known, by `<providerID>/<modelID>`, filled as each instance loads. */
+    readonly windows: Map<string, ModelWindow>;
+    /** The directories of the locations whose instance has memory off: no record is written for a tree whose top runs there. */
+    readonly off: Set<string>;
+    /** The top sessions that called courier_recall, whose turn ends refresh their record before they have started a session. */
+    readonly tops: Set<string>;
+    /** The turn ends recorded, so the hub's two subscriptions refresh once. */
+    readonly seen: Set<string>;
+}
+/** The records, by project and top session, each read with its reads and pin, which lie beside it and are written apart. */
+export interface MemoryStore {
+    get(projectID: string, sessionID: string): Promise<TreeRecord | undefined>;
+    /** Writes the record's facts; its `reads` and `pinned` are left out, as nothing but `noteRead` and `pin` write them. */
+    put(projectID: string, sessionID: string, record: TreeRecord): Promise<void>;
+    /** Removes the record with its reads and pin. */
+    remove(projectID: string, sessionID: string): Promise<void>;
+    /** Counts a listing or a full read of the record by the tree under `by` at `at`; gives that tree's reads of it. */
+    noteRead(projectID: string, sessionID: string, by: string, kind: ReadKind, at: number): Promise<Reads>;
+    /** Pins the record, or with `undefined` unpins it. */
+    pin(projectID: string, sessionID: string, pinned: Pinned | undefined): Promise<void>;
+    /** A project's records, in key order. */
+    ofProject(projectID: string): Promise<StoredRecord[]>;
+    /** Every project's records. */
+    all(): Promise<StoredRecord[]>;
+    /** The trees with reads or a pin but no record, left by a record removed while it was read or pinned. */
+    strays(): Promise<Array<{
+        projectID: string;
+        sessionID: string;
+    }>>;
+}

package/dist/memory/ports.js

@@ -0,0 +1 @@
+export {};

package/dist/memory/recall.d.ts

@@ -0,0 +1,27 @@
+import { type StoredRecord } from "./domain.js";
+import type { MemoryPorts, MemoryState } from "./ports.js";
+export interface RecallInput {
+    readonly sessionID?: string;
+}
+/** What courier_recall gives: the option is off, the project's records with the caller's tree named, one record in full, or none under that session. */
+export type Recall = {
+    readonly kind: "off";
+} | {
+    readonly kind: "list";
+    readonly projectID: string;
+    readonly top: string;
+    readonly records: ReadonlyArray<StoredRecord>;
+} | {
+    readonly kind: "record";
+    readonly projectID: string;
+    readonly record: StoredRecord;
+} | {
+    readonly kind: "missing";
+    readonly projectID: string;
+    readonly sessionID: string;
+};
+/**
+ * courier_recall: notes the call on the caller's tree, then lists the project's records, pinned first and then newest first,
+ * or gives the one under `sessionID` in full, each counted on the other trees' records; with the memory option off, nothing is written or read.
+ */
+export declare function recall(ports: MemoryPorts, state: Pick<MemoryState, "tops">, callerID: string, input: RecallInput): Promise<Recall>;

package/dist/memory/recall.js

@@ -0,0 +1,67 @@
+import { addBounded, SEEN_MAX } from "../platform/bounded.js";
+import { finite, millis } from "../platform/json.js";
+import { lineage } from "../tree/index.js";
+import { NOT_STATED, noteRead, noteRecall, pinnedFirst } from "./domain.js";
+import { memoryStore } from "./store.js";
+/** The top of the caller's tree: the top of its lineage, or itself. */
+async function topOfCaller(ports, callerID) {
+    return (await lineage(ports.storage, callerID)).at(-1)?.parentID ?? callerID;
+}
+/** Notes the call on the caller's tree's record, which is written now if the tree has none yet, so the call is remembered before any session is started. */
+async function note(ports, top, byTop) {
+    const store = memoryStore(ports.storage);
+    const now = ports.now();
+    const previous = await store.get(ports.projectID, top);
+    const recalled = noteRecall(previous?.recalled, byTop, now);
+    if (previous)
+        return store.put(ports.projectID, top, { ...previous, recalled });
+    const info = await ports.session.get({ sessionID: top }).catch(() => undefined);
+    await store.put(ports.projectID, top, {
+        startedAt: finite(millis(info?.time.created)) ?? now,
+        movedAt: now,
+        title: info?.title ?? "",
+        split: NOT_STATED,
+        finished: false,
+        recalled,
+        parts: [],
+    });
+}
+/**
+ * Counts, on each record of another tree, that this call listed it or gave it in full, best effort: a count lost is
+ * logged, never the call's failure. Gives the reads of the reader's tree on each, in order, or undefined where it failed.
+ */
+function count(ports, top, kind, sessionIDs) {
+    const store = memoryStore(ports.storage);
+    const now = ports.now();
+    return Promise.all(sessionIDs.map((sessionID) => store.noteRead(ports.projectID, sessionID, top, kind, now).catch((error) => {
+        ports.log(`courier memory: could not count the ${kind === "shown" ? "listing" : "read"} of the record under ${sessionID}: ${String(error)}`);
+        return undefined;
+    })));
+}
+/**
+ * courier_recall: notes the call on the caller's tree, then lists the project's records, pinned first and then newest first,
+ * or gives the one under `sessionID` in full, each counted on the other trees' records; with the memory option off, nothing is written or read.
+ */
+export async function recall(ports, state, callerID, input) {
+    if (!ports.memory)
+        return { kind: "off" };
+    const top = await topOfCaller(ports, callerID);
+    await note(ports, top, top === callerID);
+    addBounded(state.tops, top, SEEN_MAX);
+    const store = memoryStore(ports.storage);
+    const { projectID } = ports;
+    // Some models send null, or an empty string, for an optional field they leave out.
+    const wanted = typeof input.sessionID === "string" ? input.sessionID.trim() : "";
+    if (wanted) {
+        const record = await store.get(projectID, wanted);
+        if (!record)
+            return { kind: "missing", projectID, sessionID: wanted };
+        // Another tree's record is given with this read added to the reads just read; the caller's own is not counted.
+        const [counted] = wanted === top ? [undefined] : await count(ports, top, "read", [wanted]);
+        const reads = counted ? noteRead(record.reads, "read", counted.at) : record.reads;
+        return { kind: "record", projectID, record: { ...record, ...(reads ? { reads } : {}), projectID, sessionID: wanted } };
+    }
+    const records = pinnedFirst(await store.ofProject(projectID));
+    await count(ports, top, "shown", records.flatMap((record) => (record.sessionID === top ? [] : [record.sessionID])));
+    return { kind: "list", projectID, top, records };
+}

package/dist/memory/record.d.ts

@@ -0,0 +1,7 @@
+import { type TreeRecord } from "./domain.js";
+import type { MemoryState, RefreshPorts } from "./ports.js";
+/**
+ * Writes the record of the tree under `top` as it stands at `at`, after the turn of `ended`; a part the roster has forgotten
+ * keeps its last recorded state, unless found gone before it settled. Nothing for a top unknown to OpenCode or with memory off.
+ */
+export declare function refresh(ports: RefreshPorts, state: Pick<MemoryState, "windows" | "off">, top: string, at: number, ended?: string): Promise<TreeRecord | undefined>;

package/dist/memory/record.js

@@ -0,0 +1,124 @@
+import { finite, isNotFound, millis } from "../platform/json.js";
+import { busy, contextOf, reportState, stalledAmong, subtree } from "../tree/index.js";
+import { isSettled, isStated, mergeParts, NOT_STATED, partStatus, replacingMention, revise, splitLinesOf, splitOf, unreadPart } from "./domain.js";
+import { memoryStore } from "./store.js";
+/** A session's replies, in order, each with when it was created, for its split lines; only the `finished` ones when asked. */
+const repliesOf = (messages, finished) => messages.flatMap((message) => message.type === "assistant" && (!finished || message.time?.completed !== undefined)
+    ? [{ text: message.content.flatMap((part) => (part.type === "text" ? [part.text] : [])).join("\n"), at: finite(millis(message.time?.created)) }]
+    : []);
+/** The lines in the replies that begin with `split:`, each with its reply's time. */
+const statedIn = (replies) => replies.flatMap(({ text, at }) => splitLinesOf(text).map((line) => (at === undefined ? { text: line } : { text: line, at })));
+/** How many courier_spawn calls of a session failed, refused by a limit mostly. */
+const refusedIn = (messages) => messages.reduce((n, message) => (message.type === "assistant" ? n + message.content.filter((part) => part.type === "tool" && part.name === "courier_spawn" && part.state.status === "error").length : n), 0);
+/** A part's context use and refused spawns, as its messages show them. */
+function useOf(messages, windows) {
+    const context = contextOf(messages, windows);
+    const refused = refusedIn(messages);
+    return { ...(context !== undefined ? { context: Math.round(context * 100) / 100 } : {}), ...(refused ? { refused } : {}) };
+}
+/** A part's use as last recorded. */
+const keptUse = (last) => ({
+    ...(last?.context !== undefined ? { context: last.context } : {}),
+    ...(last?.refused ? { refused: last.refused } : {}),
+});
+/** A session's info, or `gone` when OpenCode no longer knows it; neither when it could not be read for another reason. */
+const infoOf = (ports, sessionID) => ports.session.get({ sessionID }).then((info) => ({ info, gone: false }), (error) => ({ gone: isNotFound(error) }));
+/**
+ * One session of the tree as its record keeps it, without its use when its messages were not read (only when its turn
+ * `ended` or it is `known` to no record yet), without a duration when its info was not, and whether it runs now.
+ */
+async function part(ports, windows, { entry, depth }, stalled, at, known, ended) {
+    const { sessionID } = entry;
+    const [{ info, gone }, use, report] = await Promise.all([
+        infoOf(ports, sessionID),
+        ended || !known ? ports.session.context({ sessionID }).then((messages) => useOf(messages, windows), () => undefined) : undefined,
+        reportState(ports.storage, sessionID).catch(() => undefined),
+    ]);
+    const running = info !== undefined && busy(info.time);
+    const created = finite(millis(info?.time.created)) ?? entry.createdAt;
+    const end = info && !running && info.time.idle !== undefined ? millis(info.time.idle) : at;
+    const cost = finite(info?.cost);
+    const record = {
+        sessionID,
+        title: info?.title ?? entry.title,
+        depth,
+        isolated: entry.isolated,
+        ...(entry.group ? { group: entry.group } : {}),
+        status: partStatus({ stopped: report?.stopped ?? false, stalled, report }),
+        ...(info ? { duration: Math.max(0, end - created) } : {}),
+        ...(cost !== undefined ? { cost } : {}),
+    };
+    return { record, use, running, unread: info === undefined, gone };
+}
+/** Of the parts last recorded, those the roster has forgotten before they settled whose session OpenCode no longer knows. */
+async function goneSince(ports, parts, onRoster) {
+    const unsettled = parts.filter((one) => !onRoster.has(one.sessionID) && !isSettled(one.status));
+    const looked = await Promise.all(unsettled.map(async ({ sessionID }) => ({ sessionID, ...(await infoOf(ports, sessionID)) })));
+    return new Set(looked.flatMap((one) => (one.gone ? [one.sessionID] : [])));
+}
+/**
+ * Writes the record of the tree under `top` as it stands at `at`, after the turn of `ended`; a part the roster has forgotten
+ * keeps its last recorded state, unless found gone before it settled. Nothing for a top unknown to OpenCode or with memory off.
+ */
+export async function refresh(ports, state, top, at, ended) {
+    let info;
+    try {
+        info = await ports.session.get({ sessionID: top });
+    }
+    catch (error) {
+        if (isNotFound(error))
+            return undefined;
+        throw error;
+    }
+    if (state.off.has(info.location.directory))
+        return undefined;
+    const store = memoryStore(ports.storage);
+    const [previous, { nodes }] = await Promise.all([store.get(info.projectID, top), subtree(ports.storage, top)]);
+    // The split lines are in the top's own replies, so only its own turn end can revise one stated already; another's reads
+    // them while none is stated, and only the replies finished, never a line the top is still writing.
+    const own = ended === top;
+    const replies = own || !isStated(previous?.split ?? NOT_STATED)
+        ? ports.session.context({ sessionID: top }).then((messages) => repliesOf(messages, !own), () => [])
+        : [];
+    const stalled = await stalledAmong(ports, nodes.map((node) => node.entry.sessionID));
+    const windows = [...state.windows.values()];
+    const known = new Set(previous?.parts.map((one) => one.sessionID));
+    const [read, lost] = await Promise.all([
+        Promise.all(nodes.map((node) => part(ports, windows, node, stalled.has(node.entry.sessionID), at, known.has(node.entry.sessionID), node.entry.sessionID === ended))),
+        goneSince(ports, previous?.parts ?? [], new Set(nodes.map((node) => node.entry.sessionID))),
+    ]);
+    const said = await replies;
+    // Read again just before the write: a courier_recall or courier_note call, or another turn end's refresh, wrote meanwhile.
+    const latest = (await store.get(info.projectID, top).catch(() => previous)) ?? previous;
+    const last = new Map(latest?.parts.map((one) => [one.sessionID, one]));
+    const current = read.map(({ record, use, unread, gone }) => {
+        const before = last.get(record.sessionID);
+        return { ...(unread ? unreadPart(record, before, gone) : record), ...(use ?? keptUse(before)) };
+    });
+    const forgotten = (latest?.parts ?? []).filter((one) => lost.has(one.sessionID)).map((one) => unreadPart(one, one, true));
+    const parts = mergeParts(latest?.parts ?? [], [...current, ...forgotten]);
+    const recalled = latest?.recalled ?? previous?.recalled;
+    const lesson = latest?.lesson ?? previous?.lesson;
+    // The first stated line stays even when compaction has dropped its reply; a later one is a revision.
+    const first = latest?.split ?? NOT_STATED;
+    const found = splitOf(first, said.map((reply) => reply.text).join("\n"));
+    const stated = statedIn(said);
+    const replaced = found !== first;
+    const { split, revisions: recorded } = replaced ? replacingMention(found, latest?.revisions) : { split: first, revisions: latest?.revisions };
+    // The line that replaced a mention is the first stated, so beside revisions already recorded it is not one of them too.
+    const since = replaced && recorded ? stated.slice(1) : stated;
+    const revisions = split === NOT_STATED ? undefined : revise({ split, revisions: recorded }, since, at, parts.length);
+    const record = {
+        startedAt: finite(millis(info.time.created)) ?? previous?.startedAt ?? at,
+        movedAt: at,
+        title: info.title ?? previous?.title ?? "",
+        split,
+        ...(revisions ? { revisions } : {}),
+        finished: !busy(info.time) && !read.some(({ running }) => running) && parts.every((one) => isSettled(one.status)),
+        ...(recalled ? { recalled } : {}),
+        ...(lesson ? { lesson } : {}),
+        parts,
+    };
+    await store.put(info.projectID, top, record);
+    return record;
+}

package/dist/memory/rpc-handlers.d.ts

@@ -0,0 +1,179 @@
+import type { Plugin } from "@opencode/plugin";
+import type { MemoryPorts } from "./ports.js";
+import { type Records } from "./rpc.js";
+/** What the memory's RPC runs on: one instance's ports. */
+export type MemoryRpcPorts = Pick<MemoryPorts, "storage" | "projectID" | "memory" | "now">;
+/**
+ * The records of the ports' project, pinned first and then newest first, as the memory view lists them; nothing, and
+ * `memory` false, with the option off. Read from the store alone: unlike courier_recall, a look from the terminal is noted on no record.
+ */
+export declare function records(ports: Pick<MemoryRpcPorts, "storage" | "projectID" | "memory">): Promise<Records>;
+/** Serves the memory's RPC at the plugin's location, after the tree's and the person's; disposed with the plugin. */
+export declare function registerMemoryRpc(rpc: Pick<Plugin.Context["rpc"], "register">, ports: MemoryRpcPorts): Promise<import("@opencode/plugin/promise/rpc").RpcRegistration<{
+    readonly id: "courier-memory";
+    readonly methods: {
+        readonly records: {
+            readonly input: import("effect/StandardSchema").StandardSchemaV1<{}, {}> & import("effect/Schema").Struct<{}>;
+            readonly output: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly memory: boolean;
+                readonly projectID: string;
+                readonly records: readonly {
+                    readonly sessionID: string;
+                    readonly split: string;
+                    readonly title: string;
+                    readonly startedAt: number;
+                    readonly movedAt: number;
+                    readonly finished: boolean;
+                    readonly parts: readonly {
+                        readonly sessionID: string;
+                        readonly status: "done" | "partial" | "blocked" | "failed" | "interrupted" | "out" | "stopped" | "gone" | "stalled";
+                        readonly title: string;
+                        readonly isolated: boolean;
+                        readonly depth: number;
+                        readonly context?: number | undefined;
+                        readonly group?: string | undefined;
+                        readonly cost?: number | undefined;
+                        readonly refused?: number | undefined;
+                        readonly duration?: number | undefined;
+                    }[];
+                    readonly recalled?: {
+                        readonly calls: number;
+                        readonly at?: number | undefined;
+                    } | undefined;
+                    readonly lesson?: {
+                        readonly at: number;
+                        readonly text: string;
+                        readonly depth?: number | undefined;
+                    } | undefined;
+                    readonly reads?: {
+                        readonly shown: number;
+                        readonly read: number;
+                        readonly at: number;
+                    } | undefined;
+                    readonly pinned?: {
+                        readonly at: number;
+                    } | undefined;
+                }[];
+            }, {
+                readonly memory: boolean;
+                readonly projectID: string;
+                readonly records: readonly {
+                    readonly sessionID: string;
+                    readonly split: string;
+                    readonly title: string;
+                    readonly startedAt: number;
+                    readonly movedAt: number;
+                    readonly finished: boolean;
+                    readonly parts: readonly {
+                        readonly sessionID: string;
+                        readonly status: "done" | "partial" | "blocked" | "failed" | "interrupted" | "out" | "stopped" | "gone" | "stalled";
+                        readonly title: string;
+                        readonly isolated: boolean;
+                        readonly depth: number;
+                        readonly context?: number | undefined;
+                        readonly group?: string | undefined;
+                        readonly cost?: number | undefined;
+                        readonly refused?: number | undefined;
+                        readonly duration?: number | undefined;
+                    }[];
+                    readonly recalled?: {
+                        readonly calls: number;
+                        readonly at?: number | undefined;
+                    } | undefined;
+                    readonly lesson?: {
+                        readonly at: number;
+                        readonly text: string;
+                        readonly depth?: number | undefined;
+                    } | undefined;
+                    readonly reads?: {
+                        readonly shown: number;
+                        readonly read: number;
+                        readonly at: number;
+                    } | undefined;
+                    readonly pinned?: {
+                        readonly at: number;
+                    } | undefined;
+                }[];
+            }> & import("effect/Schema").Struct<{
+                readonly memory: import("effect/Schema").Boolean;
+                readonly projectID: import("effect/Schema").String;
+                readonly records: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+                    readonly sessionID: import("effect/Schema").String;
+                    readonly startedAt: import("effect/Schema").Number;
+                    readonly movedAt: import("effect/Schema").Number;
+                    readonly title: import("effect/Schema").String;
+                    readonly split: import("effect/Schema").String;
+                    readonly finished: import("effect/Schema").Boolean;
+                    readonly recalled: import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+                        readonly at: import("effect/Schema").optionalKey<import("effect/Schema").Number>;
+                        readonly calls: import("effect/Schema").Int;
+                    }>>;
+                    readonly lesson: import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+                        readonly text: import("effect/Schema").String;
+                        readonly at: import("effect/Schema").Number;
+                        readonly depth: import("effect/Schema").optionalKey<import("effect/Schema").Int>;
+                    }>>;
+                    readonly reads: import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+                        readonly shown: import("effect/Schema").Int;
+                        readonly read: import("effect/Schema").Int;
+                        readonly at: import("effect/Schema").Number;
+                    }>>;
+                    readonly pinned: import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+                        readonly at: import("effect/Schema").Number;
+                    }>>;
+                    readonly parts: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+                        readonly sessionID: import("effect/Schema").String;
+                        readonly title: import("effect/Schema").String;
+                        readonly depth: import("effect/Schema").Int;
+                        readonly isolated: import("effect/Schema").Boolean;
+                        readonly group: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+                        readonly status: import("effect/Schema").Literals<readonly ["done", "partial", "blocked", "failed", "interrupted", "stopped", "gone", "stalled", "out"]>;
+                        readonly duration: import("effect/Schema").optionalKey<import("effect/Schema").Number>;
+                        readonly cost: import("effect/Schema").optionalKey<import("effect/Schema").Number>;
+                        readonly context: import("effect/Schema").optionalKey<import("effect/Schema").Number>;
+                        readonly refused: import("effect/Schema").optionalKey<import("effect/Schema").Int>;
+                    }>>;
+                }>>;
+            }>;
+        };
+        readonly forget: {
+            readonly input: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly sessionID: string;
+                readonly lesson?: boolean | undefined;
+            }, {
+                readonly sessionID: string;
+                readonly lesson?: boolean | undefined;
+            }> & import("effect/Schema").Struct<{
+                readonly sessionID: import("effect/Schema").String;
+                readonly lesson: import("effect/Schema").optionalKey<import("effect/Schema").Boolean>;
+            }>;
+            readonly output: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly outcome: "record" | "lesson" | "none";
+            }, {
+                readonly outcome: "record" | "lesson" | "none";
+            }> & import("effect/Schema").Struct<{
+                readonly outcome: import("effect/Schema").Literals<readonly ["record", "lesson", "none"]>;
+            }>;
+        };
+        readonly pin: {
+            readonly input: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly sessionID: string;
+                readonly pinned: boolean;
+            }, {
+                readonly sessionID: string;
+                readonly pinned: boolean;
+            }> & import("effect/Schema").Struct<{
+                readonly sessionID: import("effect/Schema").String;
+                readonly pinned: import("effect/Schema").Boolean;
+            }>;
+            readonly output: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly outcome: "pinned" | "unpinned" | "none";
+            }, {
+                readonly outcome: "pinned" | "unpinned" | "none";
+            }> & import("effect/Schema").Struct<{
+                readonly outcome: import("effect/Schema").Literals<readonly ["pinned", "unpinned", "none"]>;
+            }>;
+        };
+    };
+    readonly events: {};
+}>>;

package/dist/memory/rpc-handlers.js

@@ -0,0 +1,25 @@
+import { pinnedFirst } from "./domain.js";
+import { forget } from "./forget.js";
+import { pin } from "./pin.js";
+import { memoryRpc } from "./rpc.js";
+import { memoryStore } from "./store.js";
+/** A stored record as the RPC gives it: without its project, which the listing names once, nor the split line's revisions, which its schema lacks. */
+const toRecord = ({ projectID: _project, revisions: _revisions, ...record }) => record;
+/**
+ * The records of the ports' project, pinned first and then newest first, as the memory view lists them; nothing, and
+ * `memory` false, with the option off. Read from the store alone: unlike courier_recall, a look from the terminal is noted on no record.
+ */
+export async function records(ports) {
+    const { projectID } = ports;
+    if (!ports.memory)
+        return { memory: false, projectID, records: [] };
+    return { memory: true, projectID, records: pinnedFirst(await memoryStore(ports.storage).ofProject(projectID)).map(toRecord) };
+}
+/** Serves the memory's RPC at the plugin's location, after the tree's and the person's; disposed with the plugin. */
+export function registerMemoryRpc(rpc, ports) {
+    return rpc.register(memoryRpc, {
+        records: () => records(ports),
+        forget: async ({ sessionID, lesson }) => ({ outcome: await forget(ports, sessionID, { lesson: lesson === true }) }),
+        pin: async ({ sessionID, pinned }) => ({ outcome: await pin(ports, sessionID, pinned) }),
+    });
+}