@wirecat/cli-core 0.546.0 → 0.548.0

package/dist/services/index.d.ts

@@ -181,6 +181,7 @@ export { type PackageUpgradeOutcome, type PackageUpgradePorts, type PackageUpgra
 export { type PersonMeetingContext, type PersonMeetingContextItem, type PersonMeetingContextOptions, type PersonMeetingReadStore, personMeetingContext, } from "./person-meeting-context.js";
 export { privatePeopleService } from "./private-people.js";
 export { approveAsTask, type ProposalTaskStore, proposalSource } from "./proposal-tasks.js";
+export { type Decided, type Decision, emptyProposalRegistry, type ProposalFilter, type ProposalKind, type ProposalRegistry, type ProposalRow, parseProposalIds, proposalRegistry, } from "./proposals/index.js";
 export type { RetentionQuery, RetentionService } from "./retention.js";
 export { retentionService } from "./retention.js";
 export { RESOURCES_SEARCHED, type SearchAllFound, type SearchAllItem, type SearchAllMessenger, type SearchAllRequest, type SearchedResource, searchAll, } from "./search-all.js";

package/dist/services/index.js

@@ -139,6 +139,7 @@ export { upgradePackage, } from "./package-upgrade.js";
 export { personMeetingContext, } from "./person-meeting-context.js";
 export { privatePeopleService } from "./private-people.js";
 export { approveAsTask, proposalSource } from "./proposal-tasks.js";
+export { emptyProposalRegistry, parseProposalIds, proposalRegistry, } from "./proposals/index.js";
 export { retentionService } from "./retention.js";
 export { RESOURCES_SEARCHED, searchAll, } from "./search-all.js";
 export { RESOURCES_SEARCHED_WITH_MEETINGS, searchAllIncludingMeetings, searchAllWithMeetings, } from "./search-all-meetings.js";

package/dist/services/messages.d.ts

@@ -24,6 +24,8 @@ export interface ListWindow {
     beforeTime?: number;
     /** Read forward from this message or moment, parsed by the caller in its own words (`afterOf`). */
     after?: After;
+    /** The window's last moment, epoch milliseconds, inclusive: a forward read stops here. */
+    until?: number;
     /** Only the messages the owner starred (true) or did not (false); the store answers it, never the messenger. */
     starred?: boolean;
     /** Only this forum topic. */

package/dist/services/messages.js

@@ -10,7 +10,7 @@ import { codeOf, guardedWrite, sentIds } from "../sends/guarded.js";
 import { sendAsCheck } from "../sends/send-as.js";
 import { newOperationId, newSendId } from "../sends/send-id.js";
 import { uploadSize } from "../sends/upload.js";
-import { crossAccount, fromStore, PUSHED } from "./deps.js";
+import { crossAccount, fromStore } from "./deps.js";
 import { readChatId, storedChatId } from "./message-resolution.js";
 import { accountOf, keyOf, searchStore, statsStore, topUp } from "./messages-archive-search.js";
 import { meaningLane } from "./messages-meaning.js";
@@ -84,8 +84,8 @@ export const messagesService = (deps) => {
         await guardedWrite(guard, { operationId, chatId, kind: "pin", key: pinned ? "messages.pin" : "messages.unpin", messageId: message, notify }, () => act(chatId, message, { notify, ...(duration === undefined ? {} : { duration }) }));
         return { operationId, chatId, messageId: message, pinned };
     };
-    const topicPage = async (chat, threadId, { limit, before, beforeTime, after }) => {
-        if (beforeTime !== undefined || after !== undefined)
+    const topicPage = async (chat, threadId, { limit, before, beforeTime, after, until }) => {
+        if (beforeTime !== undefined || after !== undefined || until !== undefined)
             throw new CliError("validation_error", "a topic is read back from its newest message, or from --before-id");
         if (threadId === "1")
             throw new CliError("validation_error", "the General topic's messages carry no topic id — read the whole chat without --topic");
@@ -95,11 +95,11 @@ export const messagesService = (deps) => {
         }
         return capability(await deps.connection(), "topicHistory", "read one forum topic")(chat, threadId, window);
     };
-    const listPage = async (chat, { limit, before, beforeTime, after, threadId: typedThread, starred }) => {
+    const listPage = async (chat, { limit, before, beforeTime, after, until, threadId: typedThread, starred }) => {
         if (starred !== undefined) {
             if (!fromStore(deps))
                 throw new CliError("validation_error", "starred: reads the local store; not while reading from the messenger");
-            if (typedThread !== undefined || beforeTime !== undefined || after !== undefined)
+            if (typedThread !== undefined || beforeTime !== undefined || after !== undefined || until !== undefined)
                 throw new CliError("validation_error", "starred: pages back through the whole chat; give only id< with it");
             return inStore(async (store, account) => store.messages.messages(account, await readChatId(deps, chat, store, account), {
                 limit,
@@ -109,28 +109,30 @@ export const messagesService = (deps) => {
         }
         const threadId = threadIdOf(typedThread);
         if (threadId !== undefined)
-            return topicPage(chat, threadId, { limit, before, beforeTime, after });
-        if (beforeTime !== undefined) {
-            if (deps.offline)
-                throw new CliError("validation_error", "reading back from a time asks the messenger; not with --offline");
-            if (fromStore(deps))
-                throw new CliError("validation_error", `${PUSHED}, which pages back from a message only`);
-            const connection = await deps.connection();
-            return capability(connection, "historyBefore", "read back from a time")(chat, { limit, time: beforeTime });
+            return topicPage(chat, threadId, { limit, before, beforeTime, after, until });
+        if (fromStore(deps)) {
+            const window = after
+                ? { limit, after, ...(until === undefined ? {} : { until }) }
+                : {
+                    limit,
+                    ...(before === undefined ? {} : { before }),
+                    // historyBefore reads strictly before its moment; the store's end is inclusive.
+                    ...(beforeTime === undefined ? {} : { until: beforeTime - 1 }),
+                };
+            return inStore(async (store, account) => store.messages.messages(account, await readChatId(deps, chat, store, account), window));
         }
+        const connection = await deps.connection();
+        if (beforeTime !== undefined)
+            return capability(connection, "historyBefore", "read back from a time")(chat, { limit, time: beforeTime });
         if (after !== undefined) {
-            if (deps.offline)
-                throw new CliError("validation_error", "reading forward asks the messenger; the store pages only backwards");
-            if (fromStore(deps))
-                throw new CliError("validation_error", `${PUSHED}, which pages only backwards`);
-            const connection = await deps.connection();
-            return capability(connection, "historyAfter", "read forward from a message")(chat, { limit, after });
+            const page = await capability(connection, "historyAfter", "read forward from a message")(chat, { limit, after });
+            if (until === undefined)
+                return page;
+            const items = page.items.filter((one) => Date.parse(one.timestamp) <= until);
+            return { items, hasMore: page.hasMore && items.length === page.items.length };
         }
         const window = { limit, ...(before === undefined ? {} : { before }) };
-        if (fromStore(deps)) {
-            return inStore(async (store, account) => store.messages.messages(account, await readChatId(deps, chat, store, account), window));
-        }
-        return capability(await deps.connection(), "history", "read a chat's history")(chat, window);
+        return capability(connection, "history", "read a chat's history")(chat, window);
     };
     return {
         // A provider caps its pages (Telegram at 100), so a larger --limit reads on from the last page's edge.

package/dist/services/proposal-tasks.d.ts

@@ -1,13 +1,14 @@
+import { type Decider } from "../store/decisions.js";
 import type { MessageStore, ProposedAction } from "../store/store.js";
 import { type Task } from "../tasks/index.js";
-export type ProposalTaskStore = Pick<MessageStore, "proposedActions" | "tasks">;
+export type ProposalTaskStore = Pick<MessageStore, "proposedActions" | "tasks" | "decisionPolicy">;
 /** The source a proposal's task keeps: found again on a retry, so one proposal never makes two tasks. */
 export declare const proposalSource: (id: string) => string;
 /**
  * Approving a proposal makes it the owner's task in the account that would act; nothing is carried out.
  * The task comes first, so an approval that failed half-way finds the same task when it is run again.
  */
-export declare const approveAsTask: (store: ProposalTaskStore, id: string) => Promise<{
+export declare const approveAsTask: (store: ProposalTaskStore, id: string, by: Decider) => Promise<{
     proposal: ProposedAction;
     task: Task;
 }>;

package/dist/services/proposal-tasks.js

@@ -1,6 +1,8 @@
 import { CliError } from "@wirecat/cli-base";
 import { MEETING_FINDINGS_KIND } from "../meetings/index.js";
+import { assertMayDecide } from "../store/decisions.js";
 import { EVIDENCE_FINDINGS_KIND } from "../store/evidence-findings.js";
+import { proposerOfAction } from "../store/index.js";
 import { createTaskService } from "../tasks/index.js";
 import { taskAccount } from "./task-rules.js";
 /** The source a proposal's task keeps: found again on a retry, so one proposal never makes two tasks. */
@@ -9,7 +11,7 @@ export const proposalSource = (id) => `proposed-action:${id}`;
  * Approving a proposal makes it the owner's task in the account that would act; nothing is carried out.
  * The task comes first, so an approval that failed half-way finds the same task when it is run again.
  */
-export const approveAsTask = async (store, id) => {
+export const approveAsTask = async (store, id, by) => {
     const proposal = await store.proposedActions.get(id);
     if (proposal.kind === MEETING_FINDINGS_KIND)
         throw new CliError("validation_error", "review meeting findings through the dedicated findings command", {
@@ -23,6 +25,7 @@ export const approveAsTask = async (store, id) => {
         throw new CliError("validation_error", `a ${proposal.status} action cannot be approved`, {
             reason: "proposal.wrong-state",
         });
+    assertMayDecide({ id: proposal.id, proposedBy: proposerOfAction(proposal) }, by, store.decisionPolicy);
     if (proposal.account === null)
         throw new CliError("validation_error", "a proposal names the account that would act; this one names none");
     const { task } = await createTaskService({ store: store.tasks }).add({
@@ -33,5 +36,5 @@ export const approveAsTask = async (store, id) => {
         kind: "request",
         origin: "agent",
     });
-    return { proposal: await store.proposedActions.approve(proposal.id, { task: task.id }), task };
+    return { proposal: await store.proposedActions.approve(proposal.id, by, { task: task.id }), task };
 };

package/dist/services/proposals/ids.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Proposal ids from the command line, before any reference parsing: `17070-17079,fact:500-502,17080/f1` becomes
+ * each id once, in the order given.
+ */
+export declare const parseProposalIds: (text: readonly string[]) => string[];

package/dist/services/proposals/ids.js

@@ -0,0 +1,43 @@
+import { CliError } from "@wirecat/cli-base";
+const MAX_IDS = 500;
+const refuse = (message) => {
+    throw new CliError("validation_error", message, { reason: "proposal.ids" });
+};
+const range = (prefix, from, to) => {
+    const [start, end] = [Number(from), Number(to)];
+    if (start > end)
+        return refuse(`a range runs upwards: ${from}-${to}`);
+    if (end - start + 1 > MAX_IDS)
+        return refuse(`a range takes at most ${MAX_IDS} ids`);
+    return Array.from({ length: end - start + 1 }, (_, n) => `${prefix}${start + n}`);
+};
+const one = (token) => {
+    const bare = /^([1-9]\d*)(?:-([1-9]\d*))?$/.exec(token);
+    if (bare?.[1])
+        return bare[2] ? range("", bare[1], bare[2]) : [bare[1]];
+    const part = /^([1-9]\d*)\/([A-Za-z0-9_-]{1,64})$/.exec(token);
+    if (part)
+        return [token];
+    const prefixed = /^([a-z][a-z_]*):([1-9]\d*)(?:-(?:([a-z][a-z_]*):)?([1-9]\d*))?$/.exec(token);
+    if (prefixed?.[1] && prefixed[2]) {
+        const [, prefix, from, other, to] = prefixed;
+        if (other !== undefined && other !== prefix)
+            return refuse(`a range stays inside one prefix: ${token}`);
+        return to ? range(`${prefix}:`, from, to) : [`${prefix}:${from}`];
+    }
+    if (/^[1-9]\d*-[a-z]/.test(token))
+        return refuse(`a range stays inside one prefix: ${token}`);
+    return refuse(`not a proposal id: ${token}; use 17070, 17070-17079, fact:512 or 17080/f2`);
+};
+/**
+ * Proposal ids from the command line, before any reference parsing: `17070-17079,fact:500-502,17080/f1` becomes
+ * each id once, in the order given.
+ */
+export const parseProposalIds = (text) => {
+    const ids = [...new Set(text.flatMap((arg) => arg.split(",")).flatMap((token) => one(token.trim())))];
+    if (ids.length === 0)
+        return refuse("name at least one proposal id");
+    if (ids.length > MAX_IDS)
+        return refuse(`decide at most ${MAX_IDS} proposals at once`);
+    return ids;
+};

package/dist/services/proposals/index.d.ts

@@ -0,0 +1,3 @@
+export { parseProposalIds } from "./ids.js";
+export { emptyProposalRegistry, proposalRegistry } from "./registry.js";
+export type { Decided, Decision, ProposalFilter, ProposalKind, ProposalRegistry, ProposalRow } from "./types.js";

package/dist/services/proposals/index.js

@@ -0,0 +1,2 @@
+export { parseProposalIds } from "./ids.js";
+export { emptyProposalRegistry, proposalRegistry } from "./registry.js";

package/dist/services/proposals/kinds/action.d.ts

@@ -0,0 +1,7 @@
+import { type MessageStore } from "../../../store/index.js";
+import type { ProposalKind } from "../types.js";
+/**
+ * Every stored proposal no other kind claims: a reply, a ban, a task to create. Confirming makes it the owner's task
+ * in the account that would act; nothing is carried out. Meeting findings are reviewed with their meeting.
+ */
+export declare const actionKind: (store: Pick<MessageStore, "proposedActions" | "tasks" | "decisionPolicy">, claimed: () => readonly string[]) => ProposalKind;

package/dist/services/proposals/kinds/action.js

@@ -0,0 +1,45 @@
+import { MEETING_FINDINGS_KIND } from "../../../meetings/index.js";
+import { proposerOfAction } from "../../../store/index.js";
+import { approveAsTask } from "../../proposal-tasks.js";
+import { actionStatus, kept, projectOf, pushed, storedStatus } from "./shared.js";
+const rowOf = (action) => ({
+    id: action.id,
+    kind: "action",
+    status: actionStatus(action.status),
+    project: projectOf(action.target),
+    subject: action.target ?? `action:${action.id}`,
+    object: null,
+    summary: action.kind,
+    proposedBy: proposerOfAction(action),
+    reason: action.reason,
+    evidence: [],
+    score: null,
+    signals: null,
+    parts: null,
+    createdAt: action.createdAt,
+});
+/**
+ * Every stored proposal no other kind claims: a reply, a ban, a task to create. Confirming makes it the owner's task
+ * in the account that would act; nothing is carried out. Meeting findings are reviewed with their meeting.
+ */
+export const actionKind = (store, claimed) => ({
+    kind: "action",
+    list: async (filter) => {
+        const status = storedStatus(filter);
+        const actions = await store.proposedActions.list({
+            except: [...claimed(), MEETING_FINDINGS_KIND],
+            ...(status === undefined ? {} : { status }),
+            ...pushed(filter),
+        });
+        return kept(actions.map(rowOf), filter);
+    },
+    get: async (id) => rowOf(await store.proposedActions.get(id)),
+    decide: async (id, { confirm, by, reason }) => {
+        if (!confirm) {
+            await store.proposedActions.reject(id, by, reason);
+            return { id, kind: "action", status: "rejected", made: [] };
+        }
+        const { task } = await approveAsTask(store, id, by);
+        return { id, kind: "action", status: "confirmed", made: [`task:${task.key ?? task.id}`] };
+    },
+});

package/dist/services/proposals/kinds/fact.d.ts

@@ -0,0 +1,4 @@
+import type { MessageStore } from "../../../store/index.js";
+import type { ProposalKind } from "../types.js";
+/** Facts keep their own table and lifecycle; an agent's waits as `proposed`. */
+export declare const factKind: (store: Pick<MessageStore, "facts">) => ProposalKind;

package/dist/services/proposals/kinds/fact.js

@@ -0,0 +1,43 @@
+import { kept, proposerOfAuthor, pushed } from "./shared.js";
+const STATUS = {
+    proposed: "proposed",
+    accepted: "confirmed",
+    superseded: "confirmed",
+    reversed: "confirmed",
+    rejected: "rejected",
+};
+const rowOf = (fact) => ({
+    id: fact.ref,
+    kind: "fact",
+    status: STATUS[fact.status],
+    project: fact.project,
+    subject: fact.subject ?? fact.ref,
+    object: null,
+    summary: fact.statement,
+    proposedBy: proposerOfAuthor(fact.author),
+    reason: null,
+    evidence: fact.evidence.slice(0, 5),
+    score: null,
+    signals: null,
+    parts: null,
+    createdAt: fact.createdAt,
+});
+/** Facts keep their own table and lifecycle; an agent's waits as `proposed`. */
+export const factKind = (store) => ({
+    kind: "fact",
+    prefix: "fact",
+    list: async (filter) => {
+        const status = filter.status ?? "proposed";
+        const facts = await store.facts.list({
+            ...pushed(filter),
+            ...(status === "all" ? {} : { status: status === "confirmed" ? "accepted" : status }),
+            order: "created",
+        });
+        return kept(facts.map(rowOf), filter);
+    },
+    get: async (id) => rowOf(await store.facts.get(id)),
+    decide: async (id, { confirm, by, reason }) => {
+        const fact = confirm ? await store.facts.accept(id, by, reason) : await store.facts.reject(id, by, reason);
+        return { id, kind: "fact", status: confirm ? "confirmed" : "rejected", made: confirm ? [fact.ref] : [] };
+    },
+});

package/dist/services/proposals/kinds/findings.d.ts

@@ -0,0 +1,7 @@
+import { type MessageStore } from "../../../store/index.js";
+import type { ProposalKind } from "../types.js";
+/**
+ * An agent's batch of cited facts and tasks from stored messages, mail and documents. Confirming accepts the parts
+ * named, or every finding not rejected before; the rest are rejected. Meeting findings stay with their meeting.
+ */
+export declare const findingsKind: (store: Pick<MessageStore, "evidenceFindings" | "proposedActions">) => ProposalKind;

package/dist/services/proposals/kinds/findings.js

@@ -0,0 +1,75 @@
+import { EVIDENCE_FINDINGS_KIND } from "../../../store/index.js";
+import { kept, proposerOfAuthor } from "./shared.js";
+const statusOf = (batch) => batch.status === "proposed" ? "proposed" : batch.receipt?.accepted.length ? "confirmed" : "rejected";
+const rowOf = (batch, createdAt) => {
+    const findings = batch.input.findings;
+    const outcome = (id) => batch.receipt?.items.find((item) => item.id === id)?.status ?? null;
+    return {
+        id: batch.id,
+        kind: "findings",
+        status: statusOf(batch),
+        project: batch.project,
+        subject: batch.subject ?? batch.project ?? `findings:${batch.id}`,
+        object: null,
+        summary: `${findings.length} finding${findings.length === 1 ? "" : "s"}`,
+        proposedBy: proposerOfAuthor(batch.author),
+        reason: null,
+        evidence: [...new Set(findings.flatMap((finding) => finding.evidence.map((one) => one.reference)))].slice(0, 5),
+        score: null,
+        signals: null,
+        parts: findings.map((finding) => ({
+            id: finding.id,
+            kind: finding.kind,
+            summary: finding.kind === "fact" ? finding.statement : finding.title,
+            outcome: outcome(finding.id),
+        })),
+        createdAt,
+    };
+};
+/**
+ * An agent's batch of cited facts and tasks from stored messages, mail and documents. Confirming accepts the parts
+ * named, or every finding not rejected before; the rest are rejected. Meeting findings stay with their meeting.
+ */
+export const findingsKind = (store) => {
+    // The batch view carries no staging time; its stored proposal does.
+    const created = async (batch) => rowOf(batch, (await store.proposedActions.get(batch.id)).createdAt);
+    return {
+        kind: "findings",
+        stored: [EVIDENCE_FINDINGS_KIND],
+        parts: true,
+        list: async (filter) => {
+            const status = filter.status ?? "proposed";
+            const rows = [];
+            // The findings list filters by project and status only; a proposer filter is applied page by page until full.
+            for (let offset = 0; rows.length < filter.limit; offset += 50) {
+                const page = await store.evidenceFindings.list({
+                    ...(filter.project === undefined ? {} : { project: filter.project }),
+                    ...(status === "proposed" ? { status: "proposed" } : {}),
+                    ...(status === "confirmed" || status === "rejected" ? { status: "reviewed" } : {}),
+                    limit: 50,
+                    offset,
+                });
+                rows.push(...kept(await Promise.all(page.items.map(created)), { ...filter, limit: 50 }));
+                if (!page.hasMore)
+                    break;
+            }
+            return kept(rows, filter);
+        },
+        get: async (id) => created(await store.evidenceFindings.get(id)),
+        decide: async (id, { confirm, by, parts, reason }) => {
+            const batch = await store.evidenceFindings.get(id);
+            const turnedDown = new Set(batch.previous.filter((one) => one.status === "rejected").map((one) => one.id));
+            const accept = !confirm
+                ? []
+                : (parts ?? batch.input.findings.map((finding) => finding.id).filter((one) => !turnedDown.has(one)));
+            const reviewed = await store.evidenceFindings.review(id, {
+                fingerprint: batch.fingerprint,
+                accept,
+                by,
+                ...(reason === undefined ? {} : { reason }),
+            });
+            const made = (reviewed.receipt?.items ?? []).flatMap((item) => item.status === "accepted" && item.reference && !item.reused ? [item.reference] : []);
+            return { id, kind: "findings", status: accept.length ? "confirmed" : "rejected", made };
+        },
+    };
+};

package/dist/services/proposals/kinds/key-document.d.ts

@@ -0,0 +1,9 @@
+import type { MessageStore } from "../../../store/index.js";
+import type { ProposalKind } from "../types.js";
+type KeyDocumentStore = Pick<MessageStore, "knowledge" | "notes" | "proposedActions">;
+/**
+ * A note, document or message proposed as one of a project's key documents. Stored `key_document` rows are the new
+ * home; older suggestions are unconfirmed `key` links, shown as `key:<id>`.
+ */
+export declare const keyDocumentKind: (store: KeyDocumentStore) => ProposalKind;
+export {};

package/dist/services/proposals/kinds/key-document.js

@@ -0,0 +1,75 @@
+import { CliError } from "@wirecat/cli-base";
+import { proposerOfAction } from "../../../store/index.js";
+import { actionStatus, kept, proposedLink, pushed, storedStatus } from "./shared.js";
+const linkRow = (link) => ({
+    id: `key:${link.id}`,
+    kind: "key_document",
+    status: "proposed",
+    project: link.to,
+    subject: link.from,
+    object: link.to,
+    summary: null,
+    proposedBy: { type: "unknown" },
+    reason: link.evidence,
+    evidence: [link.from],
+    score: null,
+    signals: null,
+    parts: null,
+    createdAt: link.createdAt,
+});
+const storedRow = (action) => {
+    const payload = action.payload;
+    return {
+        id: action.id,
+        kind: "key_document",
+        status: actionStatus(action.status),
+        project: payload.project,
+        subject: payload.ref,
+        object: payload.project,
+        summary: null,
+        proposedBy: proposerOfAction(action),
+        reason: action.reason ?? payload.reason ?? null,
+        evidence: [payload.ref],
+        score: null,
+        signals: null,
+        parts: null,
+        createdAt: action.createdAt,
+    };
+};
+/**
+ * A note, document or message proposed as one of a project's key documents. Stored `key_document` rows are the new
+ * home; older suggestions are unconfirmed `key` links, shown as `key:<id>`.
+ */
+export const keyDocumentKind = (store) => {
+    const legacy = async () => (await store.notes.links({ kind: "related-to", role: "key", confirmed: false })).filter((link) => link.to?.startsWith("project:") && proposedLink(link.provenance));
+    const legacyLink = async (id) => {
+        const link = (await legacy()).find((one) => `key:${one.id}` === id);
+        if (!link)
+            throw new CliError("not_found", `no suggested key document ${id}`);
+        return link;
+    };
+    return {
+        kind: "key_document",
+        prefix: "key",
+        stored: ["key_document"],
+        list: async (filter) => {
+            const status = storedStatus(filter);
+            const stored = await store.proposedActions.list({
+                kinds: ["key_document"],
+                ...(status === undefined ? {} : { status }),
+                ...pushed(filter),
+            });
+            const links = (filter.status ?? "proposed") === "rejected" ? [] : await legacy();
+            return kept([...stored.map(storedRow), ...links.map(linkRow)], filter);
+        },
+        get: async (id) => id.startsWith("key:") ? linkRow(await legacyLink(id)) : storedRow(await store.proposedActions.get(id)),
+        decide: async (id, { confirm, by, reason }) => {
+            const status = confirm ? "confirmed" : "rejected";
+            const decision = { confirm, by, ...(reason === undefined ? {} : { reason }) };
+            const link = id.startsWith("key:")
+                ? await store.knowledge.decideSuggestedLink(id.slice("key:".length), decision)
+                : (await store.knowledge.decideLinkProposal(id, decision)).link;
+            return { id, kind: "key_document", status, made: link ? [`link:${link.id}`] : [] };
+        },
+    };
+};

package/dist/services/proposals/kinds/memory.d.ts

@@ -0,0 +1,4 @@
+import type { MessageStore } from "../../../store/index.js";
+import type { ProposalKind } from "../types.js";
+/** Memories keep their own table; rejecting one marks it stale. */
+export declare const memoryKind: (store: Pick<MessageStore, "memories">) => ProposalKind;

package/dist/services/proposals/kinds/memory.js

@@ -0,0 +1,42 @@
+import { kept, proposerOfAuthor, pushed } from "./shared.js";
+/** A stale memory is the one a person turned down; a superseded one held until another replaced it. */
+const STATUS = {
+    proposed: "proposed",
+    confirmed: "confirmed",
+    superseded: "confirmed",
+    stale: "rejected",
+};
+const rowOf = (memory) => ({
+    id: memory.ref,
+    kind: "memory",
+    status: STATUS[memory.status],
+    project: memory.project,
+    subject: memory.subject ?? memory.ref,
+    object: null,
+    summary: null,
+    proposedBy: proposerOfAuthor(memory.author),
+    reason: null,
+    evidence: memory.evidence.slice(0, 5),
+    score: null,
+    signals: null,
+    parts: null,
+    createdAt: memory.createdAt,
+});
+/** Memories keep their own table; rejecting one marks it stale. */
+export const memoryKind = (store) => ({
+    kind: "memory",
+    prefix: "memory",
+    list: async (filter) => {
+        const status = filter.status ?? "proposed";
+        const memories = await store.memories.list({
+            ...pushed(filter),
+            ...(status === "all" ? {} : { status: status === "rejected" ? "stale" : status }),
+        });
+        return kept(memories.map(rowOf), filter);
+    },
+    get: async (id) => rowOf(await store.memories.get(id)),
+    decide: async (id, { confirm, by }) => {
+        const memory = confirm ? await store.memories.confirm(id, by) : await store.memories.markStale(id, by);
+        return { id, kind: "memory", status: confirm ? "confirmed" : "rejected", made: confirm ? [memory.ref] : [] };
+    },
+});

package/dist/services/proposals/kinds/relationship.d.ts

@@ -0,0 +1,10 @@
+import type { MessageStore } from "../../../store/index.js";
+import type { ProposalKind } from "../types.js";
+type RelationshipStore = Pick<MessageStore, "knowledge" | "notes" | "proposedActions">;
+/**
+ * A person, organization, chat or mail thread proposed as related to another thing. New proposals are stored
+ * `relationship` rows; suggestions written before them are unconfirmed links, shown as `link:<id>` until the store
+ * moves them.
+ */
+export declare const relationshipKind: (store: RelationshipStore) => ProposalKind;
+export {};

package/dist/services/proposals/kinds/relationship.js

@@ -0,0 +1,82 @@
+import { CliError } from "@wirecat/cli-base";
+import { proposerOfAction } from "../../../store/index.js";
+import { actionStatus, kept, projectOf, proposedLink, pushed, storedStatus } from "./shared.js";
+const linkRow = (link) => ({
+    id: `link:${link.id}`,
+    kind: "relationship",
+    status: "proposed",
+    project: projectOf(link.to, link.from),
+    subject: link.from,
+    object: link.to,
+    summary: link.role,
+    proposedBy: { type: "unknown" },
+    reason: link.evidence,
+    evidence: [],
+    score: null,
+    signals: null,
+    parts: null,
+    createdAt: link.createdAt,
+});
+const storedRow = (action) => {
+    const payload = action.payload;
+    return {
+        id: action.id,
+        kind: "relationship",
+        status: actionStatus(action.status),
+        project: projectOf(payload.to, payload.from),
+        subject: payload.from,
+        object: payload.to,
+        summary: payload.role ?? null,
+        proposedBy: proposerOfAction(action),
+        reason: action.reason,
+        evidence: (payload.evidence ?? []).slice(0, 5),
+        score: payload.score ?? null,
+        signals: payload.signals ?? null,
+        parts: null,
+        createdAt: action.createdAt,
+    };
+};
+/**
+ * A person, organization, chat or mail thread proposed as related to another thing. New proposals are stored
+ * `relationship` rows; suggestions written before them are unconfirmed links, shown as `link:<id>` until the store
+ * moves them.
+ */
+export const relationshipKind = (store) => {
+    const legacy = async () => {
+        const [members, related] = await Promise.all([
+            store.notes.links({ kind: "member-of", confirmed: false }),
+            store.notes.links({ kind: "related-to", confirmed: false }),
+        ]);
+        return [...members, ...related].filter((link) => link.to !== null && link.role !== "key" && proposedLink(link.provenance));
+    };
+    const legacyLink = async (id) => {
+        const link = (await legacy()).find((one) => `link:${one.id}` === id);
+        if (!link)
+            throw new CliError("not_found", `no proposed relationship ${id}`);
+        return link;
+    };
+    return {
+        kind: "relationship",
+        prefix: "link",
+        stored: ["relationship"],
+        list: async (filter) => {
+            const status = storedStatus(filter);
+            const stored = await store.proposedActions.list({
+                kinds: ["relationship"],
+                ...(status === undefined ? {} : { status }),
+                ...pushed(filter),
+            });
+            const links = (filter.status ?? "proposed") === "rejected" ? [] : await legacy();
+            return kept([...stored.map(storedRow), ...links.map(linkRow)], filter);
+        },
+        get: async (id) => id.startsWith("link:") ? linkRow(await legacyLink(id)) : storedRow(await store.proposedActions.get(id)),
+        decide: async (id, { confirm, by, reason }) => {
+            const status = confirm ? "confirmed" : "rejected";
+            const decision = { confirm, by, ...(reason === undefined ? {} : { reason }) };
+            const link = id.startsWith("link:")
+                ? await store.knowledge.decideSuggestedLink(id.slice("link:".length), decision)
+                : (await store.knowledge.decideLinkProposal(id, decision)).link;
+            return { id, kind: "relationship", status, made: link ? [`relationship:${link.id}`] : [] };
+        },
+    };
+};