@wirecat/cli-core 0.550.0 → 0.551.0

package/dist/services/project-status/signals/questions.js

@@ -0,0 +1,38 @@
+import { questions as questionsOf } from "../../questions.js";
+import { evidenceOf, excerpt, whoOf } from "../items.js";
+const PER_SIDE = 5;
+const WEEK = 7 * 86_400_000;
+const NOBODY = new Set();
+/** Open questions both ways, newest first, at most five a side. A question answered in another chat stays open. */
+export const questions = {
+    id: "questions",
+    version: 1,
+    scope: "chat",
+    read: async (_context, chat) => {
+        if (!chat)
+            return [];
+        const open = (asker) => questionsOf(chat.messages, { answerers: NOBODY, asker })
+            .filter(({ answer }) => answer === undefined)
+            .map(({ question }) => question)
+            .reverse()
+            .slice(0, PER_SIDE);
+        return [
+            ["theirs", open("others")],
+            ["yours", open("owner")],
+        ].flatMap(([side, asked]) => asked.map((question) => ({
+            signal: "questions",
+            chat: chat.ref,
+            at: question.timestamp,
+            who: whoOf(question),
+            evidence: evidenceOf(chat, question),
+            basis: "store",
+            data: { side, excerpt: excerpt(question.text) },
+        })));
+    },
+    attention: (items, context) => {
+        const stale = new Set(items.flatMap((item) => item.chat !== null && item.data.side === "yours" && item.at && context.now - Date.parse(item.at) > WEEK
+            ? [item.chat]
+            : []));
+        return [...stale].map((chat) => ({ chat, weight: 1, why: "your question unanswered for a week" }));
+    },
+};

package/dist/services/project-status/signals/reply-next.d.ts

@@ -0,0 +1,19 @@
+import type { StatusSignal } from "../types.js";
+export interface ReplyNextData {
+    next: "owner" | "them" | "named" | "nobody";
+    /** Since when the one named has been the one to answer. */
+    waitingSince: string | null;
+    /** In a group: the person the newest message replies to or mentions. */
+    addressed: {
+        ref: string | null;
+        name: string | null;
+    } | null;
+    /** Waited longer than `tasks agenda` does before it lists the chat (a day for you, a week for them). */
+    overdue: boolean;
+}
+/**
+ * Whose move it is, by five rules in order: the owner wrote last → them; a dialog → the owner; in a group a message
+ * that replies to or mentions the owner, or a question right after the owner spoke → the owner; one that names
+ * another member → that member; else nobody. A name typed without a mention is not seen.
+ */
+export declare const replyNext: StatusSignal<ReplyNextData>;

package/dist/services/project-status/signals/reply-next.js

@@ -0,0 +1,75 @@
+import { AGENDA_DEFAULTS } from "../../agenda.js";
+import { evidenceOf, fromOwner, whoOf } from "../items.js";
+/** Whom a message answers or names: the quoted message's sender first, then the first mention. */
+const targetOf = (message, chat, owners) => {
+    const byId = (id) => chat.messages.find((one) => one.id === id);
+    const quoted = message.replyTo ?? (message.replyToId === undefined ? undefined : byId(message.replyToId));
+    if (quoted)
+        return {
+            owner: quoted.outgoing === true || (quoted.senderId !== null && owners.has(quoted.senderId)),
+            id: quoted.senderId,
+            name: quoted.senderName,
+        };
+    const [mentioned] = message.mentions ?? [];
+    if (mentioned === undefined)
+        return undefined;
+    if (owners.has(mentioned))
+        return { owner: true, id: mentioned, name: null };
+    const named = chat.messages.find((one) => one.senderId === mentioned);
+    return { owner: false, id: mentioned, name: named?.senderName ?? null };
+};
+const asksSomething = (message) => message.text.includes("?");
+/**
+ * Whose move it is, by five rules in order: the owner wrote last → them; a dialog → the owner; in a group a message
+ * that replies to or mentions the owner, or a question right after the owner spoke → the owner; one that names
+ * another member → that member; else nobody. A name typed without a mention is not seen.
+ */
+export const replyNext = {
+    id: "reply-next",
+    version: 1,
+    scope: "chat",
+    read: async (context, chat) => {
+        const last = chat?.messages.at(-1);
+        if (!chat || !last)
+            return [];
+        const { messages } = chat;
+        const owners = new Set(messages.flatMap((one) => (fromOwner(one) && one.senderId !== null ? [one.senderId] : [])));
+        const lastOwn = messages.findLastIndex(fromOwner);
+        const firstAfterOwn = messages[lastOwn + 1] ?? messages[0];
+        const target = targetOf(last, chat, owners);
+        const decide = () => {
+            if (last.outgoing === null)
+                return { next: "nobody", addressed: null, since: null };
+            if (fromOwner(last))
+                return {
+                    next: "them",
+                    addressed: chat.kind !== "dialog" && target && !target.owner ? { ref: null, name: target.name } : null,
+                    since: last.timestamp,
+                };
+            const since = firstAfterOwn?.timestamp ?? last.timestamp;
+            if (chat.kind === "dialog")
+                return { next: "owner", addressed: null, since };
+            if (target?.owner || (asksSomething(last) && lastOwn === messages.length - 2))
+                return { next: "owner", addressed: null, since };
+            if (target)
+                return { next: "named", addressed: { ref: null, name: target.name }, since };
+            return { next: "nobody", addressed: null, since };
+        };
+        const { next, addressed, since } = decide();
+        const waited = since === null ? 0 : context.now - Date.parse(since);
+        const overdue = (next === "owner" && waited >= AGENDA_DEFAULTS.unanswered) ||
+            (next === "them" && waited >= AGENDA_DEFAULTS.waiting);
+        return [
+            {
+                signal: "reply-next",
+                chat: chat.ref,
+                at: last.timestamp,
+                who: whoOf(last),
+                evidence: evidenceOf(chat, last),
+                basis: "store",
+                data: { next, waitingSince: since, addressed, overdue },
+            },
+        ];
+    },
+    attention: (items) => items.flatMap((item) => item.chat !== null && item.data.next === "owner" ? [{ chat: item.chat, weight: 2, why: "your move" }] : []),
+};

package/dist/services/project-status/signals/topics.d.ts

@@ -0,0 +1,10 @@
+import type { StatusSignal } from "../types.js";
+export interface TopicsData {
+    query: string;
+    yoursLast: string | null;
+    theirsLast: string | null;
+    /** Their newest mention, when the owner spoke of it later: the other side went quiet on it. */
+    silentSince: string | null;
+}
+/** Per `--context-query`, the newest message of each side that holds every one of its words, in the window. */
+export declare const topics: StatusSignal<TopicsData>;

package/dist/services/project-status/signals/topics.js

@@ -0,0 +1,50 @@
+import { normalize } from "../../../store/normalize.js";
+import { evidenceOf, fromOwner } from "../items.js";
+const escaped = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const wholeWord = (word) => new RegExp(`(?<![\\p{L}\\p{N}])${escaped(word)}(?![\\p{L}\\p{N}])`, "u");
+/** Every word of the query, folded, as a whole word somewhere in the text: `projects evidence`'s reading. */
+const matcherOf = (query) => {
+    const words = normalize(query).split(" ").filter(Boolean).map(wholeWord);
+    return (text) => {
+        const folded = normalize(text);
+        return words.length > 0 && words.every((word) => word.test(folded));
+    };
+};
+/** Per `--context-query`, the newest message of each side that holds every one of its words, in the window. */
+export const topics = {
+    id: "topics",
+    version: 1,
+    scope: "chat",
+    read: async (context, chat) => {
+        if (!chat)
+            return [];
+        return context.contextQueries.flatMap((query) => {
+            const matches = matcherOf(query);
+            const naming = chat.messages.filter((message) => matches(message.text));
+            const yours = naming.findLast(fromOwner);
+            const theirs = naming.findLast((message) => !fromOwner(message));
+            if (!yours && !theirs)
+                return [];
+            const silent = theirs && yours && Date.parse(yours.timestamp) > Date.parse(theirs.timestamp);
+            const newest = [yours, theirs]
+                .filter((one) => one !== undefined)
+                .sort((a, b) => Date.parse(b.timestamp) - Date.parse(a.timestamp));
+            return [
+                {
+                    signal: "topics",
+                    chat: chat.ref,
+                    at: newest[0]?.timestamp ?? null,
+                    who: null,
+                    evidence: evidenceOf(chat, ...newest),
+                    basis: "store",
+                    data: {
+                        query,
+                        yoursLast: yours?.timestamp ?? null,
+                        theirsLast: theirs?.timestamp ?? null,
+                        silentSince: silent ? theirs.timestamp : null,
+                    },
+                },
+            ];
+        });
+    },
+};

package/dist/services/project-status/types.d.ts

@@ -0,0 +1,84 @@
+import type { ChatKind, Id, Message } from "../../domain/models.js";
+import type { AccountKey, MessageStore } from "../../store/store.js";
+import type { ChatCoverage } from "../chat-coverage.js";
+/** What every chat signal reads; loaded once per chat by the pipeline. Never printed. */
+export interface StatusChat {
+    /** `chat:<provider>/<account>/<chat>` */
+    ref: string;
+    account: AccountKey;
+    chatId: Id;
+    title: string | null;
+    kind: ChatKind;
+    /** The link's role: "client", "contractor", or null. */
+    role: string | null;
+    /** The chat's purpose in the project; `work` until links carry one. */
+    purpose: string;
+    /** `project:<id>`; a child's id when rolled up. */
+    project: string;
+    coverage: ChatCoverage;
+    /** Oldest first, the window, at most `STATUS_WINDOW`. */
+    messages: Message[];
+}
+export interface StatusProject {
+    ref: string;
+    key: string | null;
+    name: string;
+}
+export interface StatusChild extends StatusProject {
+    parent: string;
+    depth: number;
+}
+export interface StatusContext {
+    now: number;
+    /** Window start, ms. */
+    since: number;
+    chats: StatusChat[];
+    project: StatusProject & {
+        children: StatusChild[];
+        /** Children not read: too deep, seen twice, or past the limit. */
+        cut: {
+            ref: string;
+            reason: "depth" | "cycle" | "limit";
+        }[];
+    };
+    /** Read only: facts, tasks, chats. */
+    store: MessageStore;
+    /** `--context-query` texts: every word of one must appear in one message. */
+    contextQueries: string[];
+}
+export interface StatusWho {
+    ref: string | null;
+    name: string | null;
+    owner: boolean;
+}
+/** One finding of a signal. Stable keys; the signal adds its own under `data`. */
+export interface StatusItem<D = Record<string, unknown>> {
+    signal: string;
+    /** Null for a project level finding. */
+    chat: string | null;
+    /** ISO, when it happened. */
+    at: string | null;
+    who: StatusWho | null;
+    /** `msg:`, `fact:`, `task:` refs. */
+    evidence: {
+        ref: string;
+        fingerprint: string | null;
+    }[];
+    /** How sure: `pattern` is a word match, to check before it is trusted. */
+    basis: "store" | "fact" | "task" | "pattern";
+    data: D;
+}
+export interface StatusAttention {
+    chat: string;
+    weight: number;
+    why: string;
+}
+export interface StatusSignal<D = Record<string, unknown>> {
+    id: string;
+    /** Bumped when the logic changes, so a saved answer says which rules made it. */
+    version: number;
+    scope: "chat" | "project";
+    read(context: StatusContext, chat?: StatusChat): Promise<StatusItem<D>[]>;
+    /** Why a chat should be read next, weight 0 to 3; the pipeline sums them per chat. */
+    attention?(items: StatusItem<D>[], context: StatusContext): StatusAttention[];
+}

package/dist/services/project-status/types.js

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

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

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

package/dist/services/proposals/index.js

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

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

@@ -1,5 +1,8 @@
+import type { Finding } from "../../../meetings/index.js";
 import { type MessageStore } from "../../../store/index.js";
 import type { ProposalKind } from "../types.js";
+/** A finding's one line in the inbox, per kind; a new fact kind adds its row here. */
+export declare const FACT_SUMMARIES: Record<string, (finding: Finding) => string>;
 /**
  * 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.

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

@@ -1,5 +1,12 @@
+import { paymentTitle } from "../../../meetings/index.js";
 import { EVIDENCE_FINDINGS_KIND } from "../../../store/index.js";
 import { kept, proposerOfAuthor } from "./shared.js";
+/** A finding's one line in the inbox, per kind; a new fact kind adds its row here. */
+export const FACT_SUMMARIES = {
+    fact: (finding) => finding.statement,
+    task: (finding) => finding.title,
+    payment: (finding) => paymentTitle(finding),
+};
 const statusOf = (batch) => batch.status === "proposed" ? "proposed" : batch.receipt?.accepted.length ? "confirmed" : "rejected";
 const rowOf = (batch, createdAt) => {
     const findings = batch.input.findings;
@@ -20,7 +27,7 @@ const rowOf = (batch, createdAt) => {
         parts: findings.map((finding) => ({
             id: finding.id,
             kind: finding.kind,
-            summary: finding.kind === "fact" ? finding.statement : finding.title,
+            summary: FACT_SUMMARIES[finding.kind]?.(finding) ?? finding.kind,
             outcome: outcome(finding.id),
         })),
         createdAt,

package/dist/store/decisions.d.ts

@@ -38,9 +38,12 @@ export interface Refusal {
  * The one check every decide path runs before it confirms or rejects a proposal. `null` means allowed. Every Claude
  * Code session is the bot `claude-code`, so comparing bot names keeps one session from deciding another's proposal.
  */
-export declare const mayDecide: (row: {
+export declare const mayDecide: (
+/** `ownerOnly`: what only the owner may say, such as that a payment was made. */
+row: {
     id: string;
     proposedBy: Proposer;
+    ownerOnly?: boolean;
 }, by: Decider, policy?: DecisionPolicy) => Refusal | null;
 /** One bot whatever its letter case or spacing: `Claude-Code` is `claude-code`. */
 export declare const botKey: (name: string) => string;
@@ -59,6 +62,7 @@ export declare const assertMayWithdraw: (row: {
 export declare const assertMayDecide: (row: {
     id: string;
     proposedBy: Proposer;
+    ownerOnly?: boolean;
 }, by: Decider, policy?: DecisionPolicy) => void;
 /** The author a decision is recorded under. */
 export declare const deciderAuthor: (by: Decider) => "owner" | {

package/dist/store/decisions.js

@@ -4,7 +4,9 @@ export const DEFAULT_DECISION_POLICY = { agentDecisions: true, ruleProposalsOwne
  * The one check every decide path runs before it confirms or rejects a proposal. `null` means allowed. Every Claude
  * Code session is the bot `claude-code`, so comparing bot names keeps one session from deciding another's proposal.
  */
-export const mayDecide = (row, by, policy = DEFAULT_DECISION_POLICY) => {
+export const mayDecide = (
+/** `ownerOnly`: what only the owner may say, such as that a payment was made. */
+row, by, policy = DEFAULT_DECISION_POLICY) => {
     if (by === "owner")
         return null;
     const refuse = (code, reason, message) => ({
@@ -13,6 +15,8 @@ export const mayDecide = (row, by, policy = DEFAULT_DECISION_POLICY) => {
         reason,
         message,
     });
+    if (row.ownerOnly)
+        return refuse("permission_error", "proposal.owner-only", `only the owner decides ${row.id}`);
     if (!policy.agentDecisions)
         return refuse("permission_error", "proposals.agent-decisions-off", "agent decisions are turned off; the owner decides");
     if (typeof by.reason !== "string" || !by.reason.trim() || by.reason.length > 2000)

package/dist/store/evidence-findings.js

@@ -18,4 +18,5 @@ export const validateEvidenceFindings = (input) => validateFindings(input, {
     cited: "reference",
     reference,
     anySubject: true,
+    payments: true,
 });

package/dist/store/index.d.ts

@@ -6,6 +6,7 @@ export type { TagRedirectIndex, TagRedirectResolution, TagRedirectSnapshot } fro
 export { createTagRedirectIndex } from "../domain/tag-redirects.js";
 export { note } from "../entities/note.js";
 export type { FindingEvidence, FindingOutcome, MeetingFactFinding, MeetingFinding, MeetingFindingsInput, MeetingFindingsReceipt, MeetingTaskFinding, } from "../meetings/index.js";
+export { PAYMENT_DIRECTIONS, PAYMENT_STATES, type Payment, paymentTitle, validatePayment } from "../meetings/index.js";
 export { CLOSED_STATES, isClosedState, PRIORITY_LABELS, type PriorityLabel, priorityLabel, priorityOf, priorityOption, TASK_STATES, type TaskState, } from "../tasks/index.js";
 export type { AccountMail, AccountMeetings, AccountStore } from "./account-store.js";
 export { assertMayDecide, DEFAULT_DECISION_POLICY, type Decider, type DecisionPolicy, mayDecide, type Proposer, type Refusal, } from "./decisions.js";
@@ -35,7 +36,7 @@ export type { ChatMetadata } from "./sqlite/chats.js";
 export type { Email, EmailAddress, EmailAttachment, EmailFacts, EmailFilter, EmailInput, EmailInThread, EmailLocationInput, EmailRecipient, EmailRef, EmailThread, EmailVectorHit, FolderEmail, Mailbox, MailboxInput, MailFilter, MailStore, PartialEmail, SenderScore, ThreadDetails, ThreadSave, } from "./sqlite/emails.js";
 export { EVENT_FIELDS, type EventChunkToEmbed, type EventHit, type EventQuery, type EventSearch, type NearestEvent, } from "./sqlite/event-search.js";
 export type { EvidenceSource } from "./sqlite/evidence-sources.js";
-export type { Fact, FactInput, FactsStore } from "./sqlite/facts.js";
+export type { Fact, FactInput, FactsStore, PaymentFilter } from "./sqlite/facts.js";
 export type { FileListQuery, FilesStore, StoredFile } from "./sqlite/files.js";
 export { IMPORTED_DOCUMENT_QUERY, type ImportedDocuments } from "./sqlite/imported-documents.js";
 export type { Involvement, InvolvementStore } from "./sqlite/involvements.js";

package/dist/store/index.js

@@ -1,6 +1,7 @@
 export { FACT_STATUSES, FACT_TYPES, MEMORY_KINDS, MEMORY_SCOPES, MEMORY_STATUSES, TASK_TYPES, WORK_TASK_TYPES, } from "../domain/knowledge.js";
 export { createTagRedirectIndex } from "../domain/tag-redirects.js";
 export { note } from "../entities/note.js";
+export { PAYMENT_DIRECTIONS, PAYMENT_STATES, paymentTitle, validatePayment } from "../meetings/index.js";
 export { CLOSED_STATES, isClosedState, PRIORITY_LABELS, priorityLabel, priorityOf, priorityOption, TASK_STATES, } from "../tasks/index.js";
 export { assertMayDecide, DEFAULT_DECISION_POLICY, mayDecide, } from "./decisions.js";
 export { applyDocumentTransfer, previewDocumentTransfer } from "./document-transfer/index.js";

package/dist/store/project-transfer/request.d.ts

@@ -4,7 +4,7 @@ export declare const projectAnnotationRequest: (request: ProjectAnnotationTarget
         format: "wirecat.project-annotations";
         facts: {
             ref: string;
-            type: "decision" | "fact" | "promise" | "question" | "statement";
+            type: "decision" | "fact" | "payment" | "promise" | "question" | "statement";
             statement: string;
             status: "accepted" | "proposed" | "rejected" | "reversed" | "superseded";
             subject: string | null;

package/dist/store/project-transfer/schema.d.ts

@@ -23,7 +23,7 @@ export declare const projectAnnotationsSchema: v.StrictObjectSchema<{
     readonly aliases: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, v.MaxLengthAction<string[], 1000, undefined>]>;
     readonly facts: v.SchemaWithPipe<readonly [v.ArraySchema<v.StrictObjectSchema<{
         readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, undefined>]>;
-        readonly type: v.PicklistSchema<readonly ["fact", "statement", "question", "decision", "promise"], undefined>;
+        readonly type: v.PicklistSchema<readonly ["fact", "statement", "question", "decision", "promise", "payment"], undefined>;
         readonly statement: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, undefined>]>;
         readonly status: v.PicklistSchema<readonly ["proposed", "accepted", "superseded", "reversed", "rejected"], undefined>;
         readonly subject: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
@@ -38,7 +38,7 @@ export declare const projectAnnotationsSchema: v.StrictObjectSchema<{
         readonly updated_at: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.SafeIntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
     }, undefined>, undefined>, v.MaxLengthAction<{
         ref: string;
-        type: "decision" | "fact" | "promise" | "question" | "statement";
+        type: "decision" | "fact" | "payment" | "promise" | "question" | "statement";
         statement: string;
         status: "accepted" | "proposed" | "rejected" | "reversed" | "superseded";
         subject: string | null;

package/dist/store/project-transfer/snapshot-model.d.ts

@@ -4,7 +4,7 @@ export declare const projectAnnotationSnapshotSchema: v.StrictObjectSchema<{
     readonly format: v.LiteralSchema<"wirecat.project-annotations", undefined>;
     readonly facts: v.SchemaWithPipe<readonly [v.ArraySchema<v.StrictObjectSchema<{
         readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, undefined>]>;
-        readonly type: v.PicklistSchema<readonly ["fact", "statement", "question", "decision", "promise"], undefined>;
+        readonly type: v.PicklistSchema<readonly ["fact", "statement", "question", "decision", "promise", "payment"], undefined>;
         readonly statement: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, undefined>]>;
         readonly status: v.PicklistSchema<readonly ["proposed", "accepted", "superseded", "reversed", "rejected"], undefined>;
         readonly subject: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
@@ -19,7 +19,7 @@ export declare const projectAnnotationSnapshotSchema: v.StrictObjectSchema<{
         readonly updated_at: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.SafeIntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
     }, undefined>, undefined>, v.MaxLengthAction<{
         ref: string;
-        type: "decision" | "fact" | "promise" | "question" | "statement";
+        type: "decision" | "fact" | "payment" | "promise" | "question" | "statement";
         statement: string;
         status: "accepted" | "proposed" | "rejected" | "reversed" | "superseded";
         subject: string | null;

package/dist/store/sqlite/evidence-findings.js

@@ -167,7 +167,11 @@ export const evidenceFindingsStoreOver = (context) => {
                 : reason && checked.by === "agent"
                     ? { ...checked, reason: `${checked.reason}: ${reason}` }
                     : checked;
-            assertMayDecide({ id, proposedBy: proposals.proposer(id) }, decision.by, context.decisions);
+            assertMayDecide({
+                id,
+                proposedBy: proposals.proposer(id),
+                ownerOnly: batch.input.findings.some((finding) => finding.kind === "payment"),
+            }, decision.by, context.decisions);
             if (batch.receipt) {
                 if (JSON.stringify(batch.receipt.accepted) !== JSON.stringify(accepted))
                     return invalid("this findings batch was already reviewed with a different decision");

package/dist/store/sqlite/facts.d.ts

@@ -1,4 +1,5 @@
 import { type FACT_STATUSES, FACT_TYPES, MEMORY_SCOPES } from "../../domain/knowledge.js";
+import { type PAYMENT_DIRECTIONS, type PAYMENT_STATES, type Payment } from "../../meetings/index.js";
 import { type Decider } from "../decisions.js";
 import { type Actor, type ProposedByFilter } from "./actors.js";
 import { type EvidenceSource } from "./evidence-sources.js";
@@ -34,6 +35,8 @@ export interface Fact {
     scope: (typeof MEMORY_SCOPES)[number] | null;
     source: string;
     evidence: string[];
+    /** Set on a `payment` fact only. */
+    payment: Payment | null;
     createdAt: string;
     updatedAt: string;
 }
@@ -52,6 +55,14 @@ export interface FactInput {
     supersedes?: string;
     /** The memory an agent drew it from: a `created-from` link. */
     createdFrom?: string;
+    /** Required on a `payment` fact, refused on any other; checked as `validatePayment` does. */
+    payment?: Payment;
+}
+/** `open` is an expected payment that still holds: not superseded, rejected or cancelled. */
+export interface PaymentFilter {
+    direction?: (typeof PAYMENT_DIRECTIONS)[number];
+    state?: (typeof PAYMENT_STATES)[number];
+    open?: boolean;
 }
 export interface FactsStore {
     add(input: FactInput): Promise<Fact>;
@@ -62,6 +73,8 @@ export interface FactsStore {
         subject?: string;
         status?: Fact["status"];
         proposedBy?: ProposedByFilter;
+        /** Narrows to payment facts by their fields. */
+        payment?: PaymentFilter;
         /** `created` lists the newest written first; by default the newest by when it happened. */
         order?: "occurred" | "created";
         limit?: number;

package/dist/store/sqlite/facts.js

@@ -1,6 +1,7 @@
 import { CliError } from "@wirecat/cli-base";
 import { FACT_TYPES, MEMORY_SCOPES } from "../../domain/knowledge.js";
 import { calendarMoment } from "../../domain/moment.js";
+import { validatePayment } from "../../meetings/index.js";
 import { assertMayDecide, assertMayWithdraw, deciderAuthor } from "../decisions.js";
 import { proposedBySql, proposerOf } from "./actors.js";
 import { evidenceSourcesOf } from "./evidence-sources.js";
@@ -35,6 +36,7 @@ export const factOperationsOver = (context) => {
         scope: row.scope == null ? null : row.scope,
         source: String(row.source),
         evidence: evidenceOf(context, { type: "fact", id: Number(row.id) }),
+        payment: row.type === "payment" ? paymentOf(row.metadata) : null,
         createdAt: iso(row.created_at),
         updatedAt: iso(row.updated_at),
     });
@@ -49,7 +51,11 @@ export const factOperationsOver = (context) => {
         proposedBy: proposerOf(database, row.author_type, row.author_id),
         proposed: row.status === "proposed",
     }, by);
-    const decided = (row, by) => assertMayDecide({ id: `fact:${row.id}`, proposedBy: proposerOf(database, row.author_type, row.author_id) }, by, context.decisions);
+    const decided = (row, by) => assertMayDecide({
+        id: `fact:${row.id}`,
+        proposedBy: proposerOf(database, row.author_type, row.author_id),
+        ownerOnly: row.type === "payment",
+    }, by, context.decisions);
     /** Keeps who decided for the owner and why in `metadata.decision`; the decider's actor is in `confirmed_by`. */
     const keepDecision = (id, by, reason) => {
         const why = [by === "owner" ? undefined : by.reason.trim(), reason?.trim() || undefined].filter(Boolean).join(": ");
@@ -85,6 +91,7 @@ export const factOperationsOver = (context) => {
             const occurredAt = input.occurredAt === undefined ? null : calendarMoment(input.occurredAt, "occurredAt");
             if (occurredAt !== null && !Number.isFinite(occurredAt))
                 throw new CliError("validation_error", "occurredAt takes an ISO timestamp");
+            const payment = paymentInput(type, input);
             const id = write(database, () => {
                 const project = input.project === undefined ? undefined : requiredThing(database, input.project, "the project");
                 if (project && project.type !== "project")
@@ -93,14 +100,18 @@ export const factOperationsOver = (context) => {
                 const replaced = input.supersedes === undefined ? undefined : rowOf(input.supersedes);
                 if (replaced && replaced.status !== "proposed" && replaced.status !== "accepted")
                     throw new CliError("validation_error", `${input.supersedes} is ${String(replaced.status)}; only a proposed or accepted fact can be corrected`);
+                if (replaced && (replaced.type === "payment") !== (type === "payment"))
+                    throw new CliError("validation_error", "a payment fact corrects a payment fact, and only one");
+                if (payment?.counterparty)
+                    requiredThing(database, payment.counterparty, "the counterparty");
                 const owner = input.by === "owner";
                 const { actor, model } = authorActor(context, input.by);
                 const at = now();
                 const made = Number(database
                     .prepare("INSERT INTO facts (id, type, statement, status, project_id, subject_type, subject_id, occurred_at, supersedes_id, " +
-                    "author_type, author_id, model, scope, source, created_at, updated_at) " +
-                    "VALUES (?, ?, ?, 'proposed', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING id")
-                    .get(nextId(database, "facts"), type, statement, project?.id ?? null, subject?.type ?? null, subject?.id ?? null, occurredAt, replaced === undefined ? null : Number(replaced.id), actor.type, actor.id, model, scope, owner ? "owner" : "agent", at, at)?.id);
+                    "author_type, author_id, model, scope, source, metadata, created_at, updated_at) " +
+                    "VALUES (?, ?, ?, 'proposed', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING id")
+                    .get(nextId(database, "facts"), type, statement, project?.id ?? null, subject?.type ?? null, subject?.id ?? null, occurredAt, replaced === undefined ? null : Number(replaced.id), actor.type, actor.id, model, scope, owner ? "owner" : "agent", payment ? JSON.stringify({ payment }) : null, at, at)?.id);
                 linkEvidence(context, { type: "fact", id: made }, input.evidence ?? [], owner ? "owner" : "agent");
                 if (input.createdFrom !== undefined) {
                     const from = requiredThing(database, input.createdFrom, "the source");
@@ -121,11 +132,12 @@ export const factOperationsOver = (context) => {
             const subject = options.subject === undefined ? undefined : requiredThing(database, options.subject);
             const by = proposedBySql("f.author_type", "f.author_id", options.proposedBy);
             const order = options.order === "created" ? "f.created_at" : "coalesce(f.occurred_at, f.created_at)";
+            const paid = paymentSql(options.payment);
             return database
                 .prepare(`${NAMED} WHERE f.deleted_at IS NULL AND (? IS NULL OR f.type = ?) AND (? IS NULL OR f.project_id = ?) ` +
                 "AND (? IS NULL OR (f.subject_type = ? AND f.subject_id = ?)) AND (? IS NULL OR f.status = ?) " +
-                `AND ${by.sql} ORDER BY ${order} DESC, f.id DESC LIMIT ?`)
-                .all(options.type ?? null, options.type ?? null, project?.id ?? null, project?.id ?? null, subject?.type ?? null, subject?.type ?? null, subject?.id ?? null, options.status ?? null, options.status ?? null, ...by.params, Math.min(Math.max(options.limit ?? 100, 1), 500))
+                `AND ${by.sql}${paid.sql} ORDER BY ${order} DESC, f.id DESC LIMIT ?`)
+                .all(options.type ?? null, options.type ?? null, project?.id ?? null, project?.id ?? null, subject?.type ?? null, subject?.type ?? null, subject?.id ?? null, options.status ?? null, options.status ?? null, ...by.params, ...paid.params, Math.min(Math.max(options.limit ?? 100, 1), 500))
                 .map(factOf);
         },
         accept: (reference, by, reason) => {
@@ -183,6 +195,52 @@ export const factOperationsOver = (context) => {
         sources: (reference) => evidenceSourcesOf(database, { type: "fact", id: Number(rowOf(reference).id) }),
     };
 };
+const paymentInput = (type, input) => {
+    if (type !== "payment") {
+        if (input.payment !== undefined)
+            throw new CliError("validation_error", "only a payment fact takes a payment");
+        return undefined;
+    }
+    if (input.payment === undefined)
+        throw new CliError("validation_error", "a payment fact needs its payment: amount, currency, direction and state");
+    const evidence = input.evidence?.length ?? 0;
+    if (evidence < 1 || evidence > 8)
+        throw new CliError("validation_error", "a payment fact cites 1–8 references: the ask, the transfer or a sheet row");
+    return validatePayment(input.payment);
+};
+const paymentOf = (metadata) => {
+    if (metadata == null)
+        return null;
+    try {
+        const { payment } = JSON.parse(String(metadata));
+        return payment ?? null;
+    }
+    catch {
+        return null;
+    }
+};
+const paymentSql = (filter) => {
+    if (filter === undefined)
+        return { sql: "", params: [] };
+    const parts = ["f.type = 'payment'"];
+    const params = [];
+    const state = filter.open ? "expected" : filter.state;
+    if (filter.open && filter.state !== undefined && filter.state !== "expected")
+        parts.push("0");
+    if (filter.direction !== undefined) {
+        parts.push("json_extract(f.metadata, '$.payment.direction') = ?");
+        params.push(filter.direction);
+    }
+    if (state !== undefined) {
+        parts.push("json_extract(f.metadata, '$.payment.state') = ?");
+        params.push(state);
+    }
+    if (filter.open)
+        parts.push("f.status IN ('proposed', 'accepted')");
+    if (filter.open === false)
+        parts.push("NOT (json_extract(f.metadata, '$.payment.state') = 'expected' AND f.status IN ('proposed', 'accepted'))");
+    return { sql: ` AND ${parts.join(" AND ")}`, params };
+};
 const migratedFrom = (metadata) => {
     try {
         const { memory } = JSON.parse(metadata);