@wirecat/cli-core 0.546.0 → 0.547.0

package/dist/services/documents/ingestion.js

@@ -37,7 +37,7 @@ export const documentIngestion = (store, options) => {
             for (let batch = 0;; batch++) {
                 const memories = await store.memories.list({ subject: ref, status, limit: 500 });
                 for (const memory of memories)
-                    await store.memories.markStale(memory.ref);
+                    await store.memories.markStale(memory.ref, "owner");
                 if (memories.length < 500)
                     break;
                 if (batch >= 20)

package/dist/services/documents/knowledge.d.ts

@@ -1,5 +1,5 @@
 import type { QueryAst } from "@wirecat/cli-base/query";
-import type { Author, Fact, Link, LinkInput, LinkListFilter, Memory, MemoryInput, MessageStore, Note } from "../../store/index.js";
+import type { Author, Decider, Fact, Link, LinkInput, LinkListFilter, Memory, MemoryInput, MessageStore, Note } from "../../store/index.js";
 export interface DocumentKnowledge {
     documents(principal: string, query: QueryAst | undefined, page: {
         limit: number;
@@ -14,7 +14,7 @@ export interface DocumentKnowledge {
     }): Promise<string[]>;
     links(principal: string, ref: string, filter?: Omit<LinkListFilter, "from" | "to">): Promise<Link[]>;
     addLink(principal: string, ref: string, input: Omit<LinkInput, "from" | "origin">): Promise<Link>;
-    removeLink(principal: string, ref: string, id: string): Promise<unknown>;
+    removeLink(principal: string, ref: string, id: string, by: Decider): Promise<unknown>;
     notes(principal: string, ref: string, options?: {
         search?: string;
         limit?: number;
@@ -28,7 +28,7 @@ export interface DocumentKnowledge {
     editNote(principal: string, ref: string, noteRef: string, text: string, revision: number): Promise<Note>;
     removeNote(principal: string, ref: string, noteRef: string): Promise<unknown>;
     addMemory(principal: string, ref: string, input: Pick<MemoryInput, "body" | "kind" | "scope" | "status" | "supersedes"> & {
-        author?: MemoryInput["author"];
+        author: MemoryInput["author"];
     }): Promise<Memory>;
     memories(principal: string, ref: string, options?: {
         scope?: Memory["scope"];
@@ -36,7 +36,9 @@ export interface DocumentKnowledge {
         status?: Memory["status"];
         limit?: number;
     }): Promise<Memory[]>;
-    memory(principal: string, ref: string, memoryRef: string, action?: "show" | "confirm" | "stale"): Promise<Memory>;
+    memory(principal: string, ref: string, memoryRef: string, action?: "show"): Promise<Memory>;
+    /** `by` decides: the owner, or an agent for the owner that did not propose it. */
+    memory(principal: string, ref: string, memoryRef: string, action: "confirm" | "stale", by: Decider): Promise<Memory>;
     searchMemories(principal: string, ref: string, query: string, scope?: Memory["scope"]): Promise<{
         items: Memory[];
         limit_reached: boolean;
@@ -45,7 +47,7 @@ export interface DocumentKnowledge {
         statement: string;
         type: Fact["type"];
         scope?: Memory["scope"];
-        by?: Author;
+        by: Author;
         supersedes?: string;
         occurredAt?: string;
     }): Promise<Fact>;
@@ -54,6 +56,8 @@ export interface DocumentKnowledge {
         status?: Fact["status"];
         limit?: number;
     }): Promise<Fact[]>;
-    fact(principal: string, ref: string, factRef: string, action?: "show" | "confirm" | "reverse"): Promise<Fact>;
+    fact(principal: string, ref: string, factRef: string, action?: "show"): Promise<Fact>;
+    /** `by` decides: the owner, or an agent for the owner that did not propose it; only the owner reverses. */
+    fact(principal: string, ref: string, factRef: string, action: "confirm" | "reverse", by: Decider): Promise<Fact>;
 }
 export declare const documentKnowledge: (store: Pick<MessageStore, "notes" | "facts" | "memories" | "knowledge">, folder: (principal: string) => Promise<string | undefined>) => DocumentKnowledge;

package/dist/services/documents/knowledge.js

@@ -1,4 +1,18 @@
 import { CliError } from "@wirecat/cli-base";
+const writer = (by) => {
+    if (by === undefined)
+        throw new CliError("validation_error", "name who writes it: the owner or an agent; there is no default", {
+            reason: "proposal.decider-required",
+        });
+    return by;
+};
+const decider = (by) => {
+    if (by === undefined)
+        throw new CliError("validation_error", "a confirm names who decides: the owner or an agent with a reason", {
+            reason: "proposal.decider-required",
+        });
+    return by;
+};
 export const documentKnowledge = (store, folder) => {
     const document = async (principal, ref) => {
         const note = await store.notes.resolveNote(ref);
@@ -62,13 +76,13 @@ export const documentKnowledge = (store, folder) => {
         },
         addLink: async (principal, ref, input) => {
             await document(principal, ref);
-            return store.notes.addLink({ ...input, from: ref, origin: "owner" });
+            return store.notes.addLink({ ...input, from: ref, origin: input.by === "owner" ? "owner" : "suggested" });
         },
-        removeLink: async (principal, ref, id) => {
+        removeLink: async (principal, ref, id, by) => {
             const links = await port.links(principal, ref);
             if (!links.some((link) => link.id === id && link.origin === "owner"))
                 throw new CliError("not_found", "owner link is not attached to this document");
-            return store.notes.removeLink(id);
+            return store.notes.removeLink(id, by);
         },
         notes: async (principal, ref, options) => {
             await document(principal, ref);
@@ -91,18 +105,18 @@ export const documentKnowledge = (store, folder) => {
             await document(principal, ref);
             if (input.supersedes)
                 await memoryFor(principal, ref, input.supersedes);
-            return store.memories.add({ ...input, subject: ref, evidence: [ref], author: input.author ?? "owner" });
+            return store.memories.add({ ...input, subject: ref, evidence: [ref], author: writer(input.author) });
         },
         memories: async (principal, ref, options) => {
             await document(principal, ref);
             return store.memories.list({ ...options, subject: ref });
         },
-        memory: async (principal, ref, memoryRef, action = "show") => {
+        memory: async (principal, ref, memoryRef, action = "show", by) => {
             const memory = await memoryFor(principal, ref, memoryRef);
             if (action === "confirm")
-                return store.memories.confirm(memory.ref);
+                return store.memories.confirm(memory.ref, decider(by));
             if (action === "stale")
-                return store.memories.markStale(memory.ref);
+                return store.memories.markStale(memory.ref, decider(by));
             return memory;
         },
         searchMemories: async (principal, ref, query, scope) => {
@@ -117,7 +131,7 @@ export const documentKnowledge = (store, folder) => {
             return store.facts.add({
                 type,
                 statement,
-                by: by ?? "owner",
+                by: writer(by),
                 ...(supersedes === undefined ? {} : { supersedes }),
                 ...(occurredAt === undefined ? {} : { occurredAt }),
                 subject: ref,
@@ -129,12 +143,12 @@ export const documentKnowledge = (store, folder) => {
             await document(principal, ref);
             return store.facts.list({ ...options, subject: ref });
         },
-        fact: async (principal, ref, factRef, action = "show") => {
+        fact: async (principal, ref, factRef, action = "show", by) => {
             const fact = await factFor(principal, ref, factRef);
             if (action === "confirm")
-                return store.facts.accept(fact.ref);
+                return store.facts.accept(fact.ref, decider(by));
             if (action === "reverse")
-                return store.facts.reverse(fact.ref);
+                return store.facts.reverse(fact.ref, decider(by));
             return fact;
         },
     };

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 {};