@wirecat/cli-core 0.557.0 → 0.558.0

package/CHANGELOG.md

@@ -7,6 +7,22 @@ shape of this file.
 
 ## Unreleased
 
+## 0.558.0 — 02.11.2026
+
+### Changed — may break callers
+
+- **A payment is no longer a fact (store version 46).** Money lives only in `store.finance`. `facts.add` refuses type
+  `payment` with reason `fact.payment-retired`, naming `store.finance.addPayment`, and a trigger refuses one from an
+  older build. `FACT_TYPES`, the `fact` entity and `Fact` lose `payment`; `PaymentFilter`, `facts.list({ payment })`,
+  `PAYMENT_QUERY_FIELDS` and `paymentFilterOf` are gone. The first writable open moves stored payment facts into rows.
+- **An accepted payment finding writes a finance row, not a fact.** A paid one is a `payment:` row, an expected one
+  an `invoice:` of one line, proposed by the agent and confirmed by the owner's acceptance. `supersedes` now names
+  the `invoice:` a paid one settles or a cancelled one voids, not a `fact:`. An expected one needs a `person:` or
+  `organization:` counterparty, and the amount must fit the currency's decimals. New optional field `paid_at`.
+- **`projects status` reads money from `store.finance`.** The `payments` signal (version 3) lists payments and open
+  invoices by their `payment:` and `invoice:` refs, `status` being `proposed` or `confirmed`; the open total counts
+  confirmed invoices only. Finance rows gain `evidence`, and `addInvoice` and `addPayment` take it.
+
 ## 0.557.0 — 02.11.2026
 
 ### Added

package/dist/cli/index.d.ts

@@ -111,7 +111,6 @@ export { type Saving, stored } from "./messenger/stored.js";
 export { dateOrNone } from "./messenger/tasks-command.js";
 export { MODEL_CATALOGUE_QUERY, type ModelCatalogueOptions } from "./model-catalogue-command.js";
 export { positiveCount, window, withPaging } from "./paging.js";
-export { PAYMENT_QUERY_FIELDS, paymentFilterOf } from "./payment-query.js";
 export { type CommandPermissions, commandPathKey, commandPermissions, knownBeside, knownPermissionKeys, type PermissionKeyOf, type PermissionKeySource, refuseUnknownPermissionKeys, unknownPermissionIssues, unknownPermissionKeys, } from "./permission-keys.js";
 export { asFirstWord, commandWords, liftProfile, profileFree, refuseCommandName, rootOf, takesProfile, usableProfileName, } from "./profile.js";
 export { createProgram, type ProgramDefinition, type ProgramOptions, type RunOptions, run } from "./program.js";

package/dist/cli/index.js

@@ -101,7 +101,6 @@ export { stored } from "./messenger/stored.js";
 export { dateOrNone } from "./messenger/tasks-command.js";
 export { MODEL_CATALOGUE_QUERY } from "./model-catalogue-command.js";
 export { positiveCount, window, withPaging } from "./paging.js";
-export { PAYMENT_QUERY_FIELDS, paymentFilterOf } from "./payment-query.js";
 export { commandPathKey, commandPermissions, knownBeside, knownPermissionKeys, refuseUnknownPermissionKeys, unknownPermissionIssues, unknownPermissionKeys, } from "./permission-keys.js";
 export { asFirstWord, commandWords, liftProfile, profileFree, refuseCommandName, rootOf, takesProfile, usableProfileName, } from "./profile.js";
 export { createProgram, run } from "./program.js";

package/dist/entities/fact.d.ts

@@ -2,7 +2,7 @@ import * as v from "valibot";
 export declare const fact: v.StrictObjectSchema<{
     readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
     readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
-    readonly kind: v.PicklistSchema<readonly ["fact", "statement", "question", "decision", "promise", "payment"], undefined>;
+    readonly kind: v.PicklistSchema<readonly ["fact", "statement", "question", "decision", "promise"], undefined>;
     readonly text: v.StringSchema<undefined>;
     readonly status: v.PicklistSchema<readonly ["proposed", "accepted", "superseded", "reversed", "rejected"], undefined>;
     readonly project: v.NullableSchema<v.StringSchema<undefined>, undefined>;
@@ -29,17 +29,6 @@ export declare const fact: v.StrictObjectSchema<{
     /** Who recorded it: the owner, or an agent whose fact waits as proposed. */
     readonly origin: v.PicklistSchema<["owner", "agent"], undefined>;
     readonly evidence: v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
-    /** A `payment` fact's fields. */
-    readonly payment: v.OptionalSchema<v.NullableSchema<v.StrictObjectSchema<{
-        readonly amount: v.StringSchema<undefined>;
-        readonly currency: v.StringSchema<undefined>;
-        readonly direction: v.PicklistSchema<readonly ["to_us", "from_us"], undefined>;
-        readonly counterparty: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
-        readonly counterparty_name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-        readonly due_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-        readonly state: v.PicklistSchema<readonly ["expected", "paid", "cancelled"], undefined>;
-        readonly item: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-    }, undefined>, undefined>, undefined>;
     /** With `--sources`: each piece of evidence read back. */
     readonly sources: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
         readonly ref: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;

package/dist/entities/fact.js

@@ -1,17 +1,6 @@
 import * as v from "valibot";
 import { FACT_STATUSES, FACT_TYPES, MEMORY_SCOPES } from "../domain/knowledge.js";
-import { PAYMENT_DIRECTIONS, PAYMENT_STATES } from "../meetings/index.js";
 import { author, evidenceSource, id, reference, text, time } from "./fields.js";
-const payment = v.strictObject({
-    amount: text,
-    currency: text,
-    direction: v.picklist(PAYMENT_DIRECTIONS),
-    counterparty: v.nullable(reference),
-    counterparty_name: v.nullable(text),
-    due_at: v.nullable(text),
-    state: v.picklist(PAYMENT_STATES),
-    item: v.nullable(text),
-});
 export const fact = v.strictObject({
     ref: reference,
     id,
@@ -35,8 +24,6 @@ export const fact = v.strictObject({
     /** Who recorded it: the owner, or an agent whose fact waits as proposed. */
     origin: v.picklist(["owner", "agent"]),
     evidence: v.array(reference),
-    /** A `payment` fact's fields. */
-    payment: v.optional(v.nullable(payment)),
     /** With `--sources`: each piece of evidence read back. */
     sources: v.optional(v.array(evidenceSource)),
     created_at: time,

package/dist/entities/index.d.ts

@@ -5761,7 +5761,7 @@ export declare const ENTITIES: {
     readonly fact: v.StrictObjectSchema<{
         readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
         readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
-        readonly kind: v.PicklistSchema<readonly ["fact", "statement", "question", "decision", "promise", "payment"], undefined>;
+        readonly kind: v.PicklistSchema<readonly ["fact", "statement", "question", "decision", "promise"], undefined>;
         readonly text: v.StringSchema<undefined>;
         readonly status: v.PicklistSchema<readonly ["proposed", "accepted", "superseded", "reversed", "rejected"], undefined>;
         readonly project: v.NullableSchema<v.StringSchema<undefined>, undefined>;
@@ -5784,16 +5784,6 @@ export declare const ENTITIES: {
         readonly scope: v.NullableSchema<v.PicklistSchema<readonly ["personal", "work"], undefined>, undefined>;
         readonly origin: v.PicklistSchema<["owner", "agent"], undefined>;
         readonly evidence: v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
-        readonly payment: v.OptionalSchema<v.NullableSchema<v.StrictObjectSchema<{
-            readonly amount: v.StringSchema<undefined>;
-            readonly currency: v.StringSchema<undefined>;
-            readonly direction: v.PicklistSchema<readonly ["to_us", "from_us"], undefined>;
-            readonly counterparty: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
-            readonly counterparty_name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-            readonly due_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-            readonly state: v.PicklistSchema<readonly ["expected", "paid", "cancelled"], undefined>;
-            readonly item: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-        }, undefined>, undefined>, undefined>;
         readonly sources: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
             readonly ref: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
             readonly kind: v.StringSchema<undefined>;
@@ -6589,7 +6579,7 @@ export declare const ENTITIES: {
                     readonly fingerprint: v.StringSchema<undefined>;
                 }, undefined>, undefined>;
                 readonly kind: v.LiteralSchema<"fact", undefined>;
-                readonly type: v.PicklistSchema<readonly ["fact", "statement", "question", "decision", "promise", "payment"], undefined>;
+                readonly type: v.PicklistSchema<readonly ["fact", "statement", "question", "decision", "promise"], undefined>;
                 readonly statement: v.StringSchema<undefined>;
             }, undefined>, v.StrictObjectSchema<{
                 readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;

package/dist/entities/meeting-findings.d.ts

@@ -17,7 +17,7 @@ export declare const meetingFindings: v.StrictObjectSchema<{
                 readonly fingerprint: v.StringSchema<undefined>;
             }, undefined>, undefined>;
             readonly kind: v.LiteralSchema<"fact", undefined>;
-            readonly type: v.PicklistSchema<readonly ["fact", "statement", "question", "decision", "promise", "payment"], undefined>;
+            readonly type: v.PicklistSchema<readonly ["fact", "statement", "question", "decision", "promise"], undefined>;
             readonly statement: v.StringSchema<undefined>;
         }, undefined>, v.StrictObjectSchema<{
             readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;

package/dist/errors/reasons.js

@@ -138,6 +138,7 @@ const OTHERS = [
     validation("input.required", "the command needs an answer and cannot ask for one"),
     validation("input.too-large", "the input is over its size limit"),
     ["meeting-project.stale", "configuration_error", "the meeting's project changed meanwhile"],
+    validation("fact.payment-retired", "a payment is a payments row in store.finance, not a fact"),
     validation("finance.allocate", "the invoice or payment cannot take an allocation in its state"),
     validation("finance.currency", "the payment and the invoice are in different currencies; nothing is converted"),
     validation("finance.field", "a field of the invoice or payment is not valid"),

package/dist/meetings/findings-rules.d.ts

@@ -14,16 +14,19 @@ interface FindingBase {
 }
 export interface FactFinding extends FindingBase {
     kind: "fact";
-    type: Exclude<(typeof FACT_TYPES)[number], "payment">;
+    type: (typeof FACT_TYPES)[number];
     statement: string;
 }
-/** A payment an agent read; confirming it records a `payment` fact. A paid one supersedes the expected one. */
+/**
+ * A payment an agent read. Confirming it writes money through `store.finance`, never a fact: a paid one a `payments`
+ * row, an expected one an invoice; a paid one that supersedes an invoice settles it, a cancelled one voids it.
+ */
 export interface PaymentFinding extends FindingBase {
     kind: "payment";
-    /** The fact's full sentence; without one, the payment's title. */
+    /** The full sentence, kept as the proposal's reason; without one, the payment's title. */
     statement?: string;
     payment: Payment;
-    /** The `fact:` of the expected payment this one replaces, once it is paid or cancelled. */
+    /** The `invoice:` of the expected payment this one settles (paid) or voids (cancelled). */
     supersedes?: string;
 }
 export interface TaskFinding extends FindingBase {

package/dist/meetings/findings-rules.js

@@ -70,20 +70,27 @@ export const validateFindings = (input, rules) => {
         if (finding.kind === "fact") {
             fields(finding, ["id", "project", "subject", "evidence", "kind", "type", "statement"], rules.singular);
             if (finding.type === "payment")
-                return invalid("a payment is a finding of kind payment");
+                return invalid("a payment is a finding of kind payment; money is a payments row, not a fact");
             if (!FACT_TYPES.includes(finding.type))
                 return invalid("unknown fact finding type");
             return { ...base, kind: "fact", type: finding.type, statement: text(finding.statement, 2000) };
         }
         if (finding.kind === "payment" && rules.payments) {
             fields(finding, ["id", "project", "subject", "evidence", "kind", "statement", "payment", "supersedes"], rules.singular);
-            if (finding.supersedes !== undefined && !/^fact:[1-9]\d*$/.test(String(finding.supersedes)))
-                return invalid("a payment finding supersedes a fact: reference");
+            if (finding.supersedes !== undefined && !/^invoice:[1-9]\d*$/.test(String(finding.supersedes)))
+                return invalid("a payment finding supersedes an invoice: reference, the expected payment it settles or voids");
+            const payment = validatePayment(finding.payment);
+            if (payment.state === "expected" && finding.supersedes !== undefined)
+                return invalid("an expected payment supersedes nothing; a paid or cancelled one supersedes its invoice");
+            if (payment.state === "cancelled" && finding.supersedes === undefined)
+                return invalid("a cancelled payment names the invoice: it cancels in supersedes");
+            if (payment.state === "expected" && !/^(person|organization):/.test(payment.counterparty ?? ""))
+                return invalid("an expected payment becomes an invoice, which names its counterparty as a person: or organization:");
             return {
                 ...base,
                 kind: "payment",
                 ...(finding.statement === undefined ? {} : { statement: text(finding.statement, 2000) }),
-                payment: validatePayment(finding.payment),
+                payment,
                 ...(finding.supersedes === undefined ? {} : { supersedes: finding.supersedes }),
             };
         }

package/dist/meetings/payment.d.ts

@@ -1,8 +1,11 @@
-/** Every fact type the store takes; findings and meeting changes check against the same list. */
-export declare const FACT_TYPES: readonly ["fact", "statement", "question", "decision", "promise", "payment"];
+/** Every fact type the store takes; findings and meeting changes check against the same list. Money is not a fact. */
+export declare const FACT_TYPES: readonly ["fact", "statement", "question", "decision", "promise"];
 export declare const PAYMENT_DIRECTIONS: readonly ["to_us", "from_us"];
 export declare const PAYMENT_STATES: readonly ["expected", "paid", "cancelled"];
-/** A payment fact's fields, kept in `facts.metadata.payment`. */
+/**
+ * A payment finding's fields, as an agent reads them from evidence. Confirmed by the owner, a paid one becomes a
+ * `payments` row, an expected one an invoice, a cancelled one voids the invoice it supersedes.
+ */
 export interface Payment {
     /** A decimal as text with two places, "50000.00": money is never a float. */
     amount: string;
@@ -14,14 +17,15 @@ export interface Payment {
     counterparty_name: string | null;
     /** An ISO date. */
     due_at: string | null;
-    /** A change of state is a new fact that supersedes this one, so the history and its evidence stay. */
     state: (typeof PAYMENT_STATES)[number];
-    /** What it is for, short: "support, September". The fact's statement is the full sentence. */
+    /** What it is for, short: "support, September". The finding's statement is the full sentence. */
     item: string | null;
+    /** When a paid one was paid, an ISO date; without it the due date, else the day the owner confirms it. */
+    paid_at?: string;
 }
 /** A payment as stored: the amount with two decimals, the currency upper case; refuses what is not one. */
 export declare const validatePayment: (input: unknown) => Payment;
-/** One line for a payment, as a list or an inbox shows it: "1 200 EUR to us from Ana, due 31.10 (expected)". */
+/** One line for a payment finding, as a list or an inbox shows it: "1 200 EUR to us from Ana, due 31.10 (expected)". */
 export declare const paymentTitle: (fact: {
     payment: Payment | null;
 }) => string;

package/dist/meetings/payment.js

@@ -1,6 +1,6 @@
 import { CliError } from "@wirecat/cli-base";
-/** Every fact type the store takes; findings and meeting changes check against the same list. */
-export const FACT_TYPES = ["fact", "statement", "question", "decision", "promise", "payment"];
+/** Every fact type the store takes; findings and meeting changes check against the same list. Money is not a fact. */
+export const FACT_TYPES = ["fact", "statement", "question", "decision", "promise"];
 export const PAYMENT_DIRECTIONS = ["to_us", "from_us"];
 export const PAYMENT_STATES = ["expected", "paid", "cancelled"];
 const invalid = (message) => {
@@ -21,7 +21,7 @@ const amountOf = (value) => {
 const dateOf = (value) => {
     const date = typeof value === "string" ? value.trim() : "";
     if (!/^\d{4}-\d{2}-\d{2}$/.test(date) || new Date(`${date}T00:00:00Z`).toISOString().slice(0, 10) !== date)
-        return invalid("a payment's due date is an ISO date, such as 2026-10-31");
+        return invalid("a payment's dates are ISO dates, such as 2026-10-31");
     return date;
 };
 const optionalText = (value, what, limit) => {
@@ -36,7 +36,17 @@ const oneOf = (value, allowed, what) => {
         return invalid(`a payment's ${what} is one of ${allowed.join(", ")}`);
     return value;
 };
-const FIELDS = ["amount", "currency", "direction", "counterparty", "counterparty_name", "due_at", "state", "item"];
+const FIELDS = [
+    "amount",
+    "currency",
+    "direction",
+    "counterparty",
+    "counterparty_name",
+    "due_at",
+    "state",
+    "item",
+    "paid_at",
+];
 /** A payment as stored: the amount with two decimals, the currency upper case; refuses what is not one. */
 export const validatePayment = (input) => {
     if (!input || typeof input !== "object" || Array.isArray(input))
@@ -51,6 +61,9 @@ export const validatePayment = (input) => {
     const counterparty = optionalText(raw.counterparty, "counterparty", 80);
     if (counterparty !== null && !COUNTERPARTY.test(counterparty))
         return invalid("a payment's counterparty is a person:, organization: or project: reference");
+    const state = oneOf(raw.state, PAYMENT_STATES, "state");
+    if (raw.paid_at != null && state !== "paid")
+        return invalid("only a paid payment has paid_at");
     return {
         amount: amountOf(raw.amount),
         currency,
@@ -58,8 +71,10 @@ export const validatePayment = (input) => {
         counterparty,
         counterparty_name: optionalText(raw.counterparty_name, "counterparty name", 200),
         due_at: raw.due_at === undefined || raw.due_at === null ? null : dateOf(raw.due_at),
-        state: oneOf(raw.state, PAYMENT_STATES, "state"),
+        state,
         item: optionalText(raw.item, "item", 200),
+        // Left out when absent, so a finding staged before the field keeps its fingerprint.
+        ...(raw.paid_at == null ? {} : { paid_at: dateOf(raw.paid_at) }),
     };
 };
 const grouped = (amount) => {
@@ -67,7 +82,7 @@ const grouped = (amount) => {
     const digits = whole.replace(/\B(?=(\d{3})+(?!\d))/g, " ");
     return cents === "00" ? digits : `${digits}.${cents}`;
 };
-/** One line for a payment, as a list or an inbox shows it: "1 200 EUR to us from Ana, due 31.10 (expected)". */
+/** One line for a payment finding, as a list or an inbox shows it: "1 200 EUR to us from Ana, due 31.10 (expected)". */
 export const paymentTitle = (fact) => {
     const payment = fact.payment;
     if (!payment)

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

@@ -60,7 +60,7 @@ export interface ProjectStatus {
     chats: StatusChatSummary[];
     /** Every signal's items, in signal order, then chat order. */
     items: StatusItem[];
-    /** Open amounts and expected payment facts, summed per direction and currency. */
+    /** Open amounts and what confirmed open invoices still owe, summed per direction and currency. */
     money: {
         open: MoneyTotal[];
     };

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

@@ -53,11 +53,15 @@ const childrenOf = async (store, root, catalog) => {
 };
 const inAccounts = (accounts, provider, account) => accounts === undefined || accounts.some((one) => one.provider === provider && one.account === account);
 const failure = (error) => (error instanceof Error ? error.message : String(error));
-/** An open ask, or an expected payment fact; an ask that a payment fact cites is counted once, as the fact. */
+/**
+ * An open ask, or a confirmed open invoice; an ask that a confirmed row cites is counted once, as the row. A proposed
+ * row promises nothing yet, so the ask it cites still counts.
+ */
 const counted = (items) => {
-    const recorded = new Set(items.filter((item) => item.signal === "payments").flatMap((item) => item.evidence.slice(1).map((one) => one.ref)));
+    const confirmed = (item) => item.signal === "payments" && item.data.status === "confirmed";
+    const recorded = new Set(items.filter(confirmed).flatMap((item) => item.evidence.slice(1).map((one) => one.ref)));
     return (item, state) => item.signal === "payments"
-        ? state === "expected"
+        ? state === "expected" && confirmed(item)
         : item.signal === "amounts" && state === "open" && !item.evidence.some((one) => recorded.has(one.ref));
 };
 const totalsOf = (items) => {

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

@@ -1,9 +1,9 @@
-import { type Payment } from "../../../meetings/index.js";
+import type { Payment } from "../../../meetings/index.js";
 import type { StatusSignal } from "../types.js";
 export interface PaymentsData extends Payment {
     title: string;
-    /** The fact's review status: proposed or accepted. */
+    /** The row's review: proposed or confirmed. */
     status: string;
 }
-/** Payment facts of the project and its children, proposed or accepted. Only what someone recorded. */
+/** Payments and open invoices of the project and its children from `store.finance`, proposed or confirmed. */
 export declare const payments: StatusSignal<PaymentsData>;

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

@@ -1,24 +1,50 @@
-import { paymentTitle } from "../../../meetings/index.js";
-const HOLDING = new Set(["proposed", "accepted"]);
-/** Payment facts of the project and its children, proposed or accepted. Only what someone recorded. */
+const holding = (row) => row.review !== "rejected";
+const item = (row, at, data) => ({
+    signal: "payments",
+    chat: null,
+    at,
+    who: null,
+    // The row first, then what it cites, so an amount read from a cited message is not counted twice.
+    evidence: [row.ref, ...row.evidence].map((ref) => ({ ref, fingerprint: null })),
+    basis: "store",
+    data: { ...data, title: row.title, status: row.review },
+});
+const paid = (row) => {
+    const party = row.direction === "in" ? row.payer : row.payee;
+    return item(row, `${row.date}T00:00:00.000Z`, {
+        amount: row.amount,
+        currency: row.currency,
+        direction: row.direction === "in" ? "to_us" : "from_us",
+        counterparty: party?.ref ?? null,
+        counterparty_name: party?.name ?? null,
+        due_at: null,
+        state: "paid",
+        item: row.reference,
+        paid_at: row.date,
+    });
+};
+/** What an open invoice still owes is the expected payment. */
+const expected = (row) => item(row, row.issueDate === null ? row.createdAt : `${row.issueDate}T00:00:00.000Z`, {
+    amount: row.open,
+    currency: row.currency,
+    direction: row.direction === "receivable" ? "to_us" : "from_us",
+    counterparty: row.counterparty.ref,
+    counterparty_name: row.counterparty.name,
+    due_at: row.dueDate,
+    state: "expected",
+    item: row.number,
+});
+/** Payments and open invoices of the project and its children from `store.finance`, proposed or confirmed. */
 export const payments = {
     id: "payments",
-    version: 2,
+    version: 3,
     scope: "project",
     read: async (context) => {
         const projects = [context.project.ref, ...context.project.children.map((child) => child.ref)];
-        const facts = (await Promise.all(projects.map((project) => context.store.facts.list({ project, type: "payment", limit: 500 })))).flat();
-        return facts
-            .filter((fact) => fact.payment !== null && HOLDING.has(fact.status))
-            .map((fact) => ({
-            signal: "payments",
-            chat: null,
-            at: fact.occurredAt ?? fact.createdAt,
-            who: null,
-            // The fact first, then what it cites, so an amount read from a cited message is not counted twice.
-            evidence: [fact.ref, ...fact.evidence].map((ref) => ({ ref, fingerprint: null })),
-            basis: "fact",
-            data: { ...fact.payment, title: paymentTitle(fact), status: fact.status },
-        }));
+        const rows = await Promise.all(projects.map(async (project) => [
+            ...(await context.store.finance.payments({ project, limit: 500 })).filter(holding).map(paid),
+            ...(await context.store.finance.invoices({ project, open: true, limit: 500 })).filter(holding).map(expected),
+        ]));
+        return rows.flat();
     },
 };

package/dist/store/evidence-findings.js

@@ -1,6 +1,7 @@
 import { CliError } from "@wirecat/cli-base";
 import { formatLocator, parseLocator } from "../domain/locator.js";
 import { validateFindings } from "../meetings/index.js";
+import { entryAmount } from "./sqlite/payment-entries.js";
 export const EVIDENCE_FINDINGS_KIND = "evidence_findings";
 const reference = (raw) => {
     if (/^(document|note):[1-9]\d*$/.test(raw))
@@ -12,11 +13,18 @@ const reference = (raw) => {
         throw new CliError("validation_error", "finding evidence is a msg:, document: or note: reference");
     }
 };
-export const validateEvidenceFindings = (input) => validateFindings(input, {
-    plural: "evidence findings",
-    singular: "evidence finding",
-    cited: "reference",
-    reference,
-    anySubject: true,
-    payments: true,
-});
+export const validateEvidenceFindings = (input) => {
+    const valid = validateFindings(input, {
+        plural: "evidence findings",
+        singular: "evidence finding",
+        cited: "reference",
+        reference,
+        anySubject: true,
+        payments: true,
+    });
+    // Refused at staging rather than when the owner accepts, which would fail the whole batch.
+    for (const finding of valid.findings)
+        if (finding.kind === "payment")
+            entryAmount(finding.payment);
+    return valid;
+};

package/dist/store/index.d.ts

@@ -36,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, PaymentFilter } from "./sqlite/facts.js";
+export type { Fact, FactInput, FactsStore } from "./sqlite/facts.js";
 export type { FileListQuery, FilesStore, StoredFile } from "./sqlite/files.js";
 export type { Allocation, FinanceStore, Invoice, InvoiceDetail, InvoiceInput, InvoiceLine, InvoiceLineInput, OpenTotal, Party, Payment as FinancePayment, PaymentDetail as FinancePaymentDetail, PaymentInput as FinancePaymentInput, } from "./sqlite/finance.js";
 export { IMPORTED_DOCUMENT_QUERY, type ImportedDocuments } from "./sqlite/imported-documents.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" | "payment" | "promise" | "question" | "statement";
+            type: "decision" | "fact" | "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", "payment"], undefined>;
+        readonly type: v.PicklistSchema<readonly ["fact", "statement", "question", "decision", "promise"], 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" | "payment" | "promise" | "question" | "statement";
+        type: "decision" | "fact" | "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", "payment"], undefined>;
+        readonly type: v.PicklistSchema<readonly ["fact", "statement", "question", "decision", "promise"], 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" | "payment" | "promise" | "question" | "statement";
+        type: "decision" | "fact" | "promise" | "question" | "statement";
         statement: string;
         status: "accepted" | "proposed" | "rejected" | "reversed" | "superseded";
         subject: string | null;

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

@@ -1,5 +1,4 @@
 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";
@@ -35,8 +34,6 @@ 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;
 }
@@ -55,14 +52,6 @@ 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>;
@@ -73,8 +62,6 @@ 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,7 +1,6 @@
 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";
@@ -36,7 +35,6 @@ 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),
     });
@@ -54,7 +52,6 @@ export const factOperationsOver = (context) => {
     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) => {
@@ -83,6 +80,8 @@ export const factOperationsOver = (context) => {
     };
     return {
         add: (input) => {
+            if (input.type === "payment")
+                throw new CliError("validation_error", "a payment is not a fact: record it with store.finance.addPayment, a payment: row, or an invoice: for one expected", { reason: "fact.payment-retired" });
             const type = oneOf(input.type, FACT_TYPES, "a fact's type");
             const statement = input.statement?.trim() ?? "";
             if (!statement || statement.length > 2000)
@@ -91,7 +90,6 @@ 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")
@@ -100,10 +98,6 @@ 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();
@@ -111,7 +105,7 @@ export const factOperationsOver = (context) => {
                     .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, 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);
+                    .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", 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");
@@ -132,12 +126,11 @@ 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}${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))
+                `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))
                 .map(factOf);
         },
         accept: (reference, by, reason) => {
@@ -195,52 +188,6 @@ 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);

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

@@ -28,6 +28,8 @@ interface Reviewed {
     source: string;
     /** Why an agent or an import proposed it. */
     reason: string | null;
+    /** What it was read from: the messages, documents or notes an agent or the owner cited. */
+    evidence: string[];
     project: string | null;
     projectName: string | null;
     createdAt: string;
@@ -97,6 +99,8 @@ interface Written {
     source?: string;
     /** Why a bot proposes it, kept for the reviewer. */
     reason?: string;
+    /** References it was read from, linked as `evidence`. */
+    evidence?: string[];
 }
 export interface InvoiceLineInput {
     description: string;

package/dist/store/sqlite/finance.js

@@ -3,7 +3,7 @@ import { FINANCE_REVIEWS, INVOICE_DIRECTIONS, INVOICE_STATUSES, invoiceTitle, MO
 import { currencyOf, formatDecimal, lineUnits, minorUnits, moneyLabel, moneyOf, quantityOf, scaleOf, } from "../../domain/money.js";
 import { assertMayDecide, botKey, deciderAuthor } from "../decisions.js";
 import { proposedBySql, proposerOf } from "./actors.js";
-import { authorActor, authorOf, projectId, projectOf, subjectOf } from "./memories.js";
+import { authorActor, authorOf, evidenceOf, linkEvidence, projectId, projectOf, subjectOf, } from "./memories.js";
 import { requiredThing } from "./notes.js";
 import { write } from "./transaction.js";
 const refuse = (message, reason, code = "validation_error") => {
@@ -30,6 +30,13 @@ const isoDate = (value, what) => {
     return date;
 };
 const iso = (value) => new Date(Number(value)).toISOString();
+const evidenceList = (value) => {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value) || value.length > 8 || value.some((one) => typeof one !== "string" || !one.trim()))
+        return refuse("evidence is a list of at most 8 references", "finance.field");
+    return [...new Set(value.map((one) => one.trim()))];
+};
 const MAX_LINES = 500;
 const reasonOf = (metadata) => {
     if (metadata == null)
@@ -65,7 +72,7 @@ export const financeOperationsOver = (context) => {
             return refuse(`${what} is a person: or organization: reference, not ${reference}`, "finance.party");
         return thing;
     };
-    const reviewedOf = (row) => ({
+    const reviewedOf = (row, type) => ({
         review: row.review,
         author: authorOf(row),
         model: row.model == null ? null : String(row.model),
@@ -74,6 +81,7 @@ export const financeOperationsOver = (context) => {
             : { type: row.confirmed_by_type, id: String(row.confirmed_by_id) },
         source: String(row.source),
         reason: reasonOf(row.metadata),
+        evidence: evidenceOf(context, { type, id: Number(row.id) }),
         ...projectOf(database, row),
         createdAt: iso(row.created_at),
         updatedAt: iso(row.updated_at),
@@ -109,7 +117,7 @@ export const financeOperationsOver = (context) => {
             issueDate: row.issue_date == null ? null : String(row.issue_date),
             dueDate: fields.dueDate,
             status: fields.status,
-            ...reviewedOf(row),
+            ...reviewedOf(row, "invoice"),
         };
     };
     const paymentOf = (row) => {
@@ -140,7 +148,7 @@ export const financeOperationsOver = (context) => {
             reference: row.reference == null ? null : String(row.reference),
             allocated: formatDecimal(allocated, scale),
             unallocated: formatDecimal(amount - allocated, scale),
-            ...reviewedOf(row),
+            ...reviewedOf(row, "payment"),
         };
     };
     const allocationsWhere = (column, id) => database
@@ -236,8 +244,13 @@ export const financeOperationsOver = (context) => {
             confirmedId: owner ? actor.id : null,
             metadata: reason === null ? null : JSON.stringify({ reason }),
             project: input.project === undefined ? null : projectId(database, input.project),
+            evidence: evidenceList(input.evidence),
         };
     };
+    const keepEvidence = (type, id, by) => {
+        if (by.evidence.length)
+            linkEvidence(context, { type, id }, by.evidence, by.owner ? "owner" : "agent");
+    };
     const ownerOnly = (by, what) => {
         if (by !== "owner")
             refuse(`only the owner ${what}`, "finance.owner-only", "permission_error");
@@ -361,6 +374,7 @@ export const financeOperationsOver = (context) => {
                     "VALUES (?, ?, ?, ?, ?, ?, ?, ?)");
                 for (const [index, line] of lines.entries())
                     insert.run(made, index + 1, line.description, line.quantity, line.unitPrice, line.amount, at, at);
+                keepEvidence("invoice", made, by);
                 return made;
             });
             return invoiceDetail(`invoice:${id}`);
@@ -436,6 +450,7 @@ export const financeOperationsOver = (context) => {
                     "reference, project_id, review, author_type, author_id, model, confirmed_by_type, confirmed_by_id, source, " +
                     "metadata, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING *")
                     .get(direction, payer?.type ?? null, payer?.id ?? null, payee?.type ?? null, payee?.id ?? null, amount, currency, date, reference, by.project, by.review, by.actor.type, by.actor.id, by.model, by.confirmedType, by.confirmedId, by.source, by.metadata, at, at);
+                keepEvidence("payment", Number(made.id), by);
                 const touched = allocations.map(({ invoice, units }) => allocateRow(made, invoice, units, by.actor));
                 for (const invoice of touched)
                     settle(invoice);

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

@@ -1,8 +1,9 @@
 import { CliError } from "@wirecat/cli-base";
-import { findingFingerprint, findingHash, paymentTitle, } from "../../meetings/index.js";
+import { findingFingerprint, findingHash, } from "../../meetings/index.js";
 import { factOperationsOver } from "./facts.js";
 import { linkEvidence } from "./memories.js";
 import { requiredThing } from "./notes.js";
+import { paymentEntriesOver } from "./payment-entries.js";
 import { taskRowOf } from "./things.js";
 import { workTaskOperationsOver } from "./work-tasks.js";
 const invalid = (message) => {
@@ -27,6 +28,7 @@ export const findingsCoreOver = (context, kind) => {
     const { database } = context;
     const facts = factOperationsOver(context);
     const tasks = workTaskOperationsOver(context);
+    const recordPayment = paymentEntriesOver(context);
     const cited = (input, cite) => {
         const seen = new Map();
         for (const finding of input.findings) {
@@ -81,19 +83,8 @@ export const findingsCoreOver = (context, kind) => {
             });
             return facts.acceptChecked(fact.ref, decidedBy).ref;
         }
-        if (finding.kind === "payment") {
-            const fact = facts.add({
-                type: "payment",
-                statement: finding.statement ?? paymentTitle(finding),
-                payment: finding.payment,
-                ...(finding.project === undefined ? {} : { project: finding.project }),
-                ...(finding.subject === undefined ? {} : { subject: finding.subject }),
-                ...(finding.supersedes === undefined ? {} : { supersedes: finding.supersedes }),
-                evidence,
-                by: agent,
-            });
-            return facts.acceptChecked(fact.ref, decidedBy).ref;
-        }
+        if (finding.kind === "payment")
+            return recordPayment({ ...finding, evidence }, agent, { confirm: true, by: decidedBy });
         if (finding.project === undefined)
             return invalid("a task finding names the project the task goes in");
         const task = tasks.create({

package/dist/store/sqlite/manifest.js

@@ -61,6 +61,7 @@ export const MANIFEST = [
     { name: "20261102050534_version-44-suggested-links-move", version: 44, minCompatible: 34 },
     { name: "20261102173102_version-45-finance", version: 45, minCompatible: 34 },
     { name: "20261102173113_version-45-finance-rules", version: 45, minCompatible: 34 },
+    { name: "20261102185954_version-46-payment-facts", version: 46, minCompatible: 34 },
 ];
 export const generatedMigrations = (manifest = MANIFEST, generated = GENERATED) => {
     const migrations = [];

package/dist/store/sqlite/migrations.generated.js

@@ -924,5 +924,13 @@ export const GENERATED = [
             "CREATE TRIGGER payment_allocations_valid_bi BEFORE INSERT ON payment_allocations\n  WHEN new.amount <= 0\n    OR (SELECT currency FROM payments WHERE id = new.payment_id)\n      IS NOT (SELECT currency FROM invoices WHERE id = new.invoice_id)\n    OR (SELECT coalesce(sum(amount), 0) FROM payment_allocations WHERE payment_id = new.payment_id) + new.amount\n      > (SELECT amount FROM payments WHERE id = new.payment_id)\n    OR (SELECT coalesce(sum(a.amount), 0) FROM payment_allocations a JOIN payments p ON p.id = a.payment_id\n      WHERE a.invoice_id = new.invoice_id\n        AND ((p.review = 'confirmed' AND p.deleted_at IS NULL) OR a.payment_id = new.payment_id)) + new.amount\n      > (SELECT total FROM invoices WHERE id = new.invoice_id) BEGIN\n  SELECT RAISE(ABORT, 'payment_allocations: above 0, one currency, within the payment and within the invoice');\nEND;",
             "CREATE TRIGGER payment_allocations_valid_bu BEFORE UPDATE ON payment_allocations\n  WHEN new.amount <= 0 OR new.payment_id IS NOT old.payment_id OR new.invoice_id IS NOT old.invoice_id\n    OR (SELECT coalesce(sum(amount), 0) FROM payment_allocations WHERE payment_id = new.payment_id AND id <> old.id)\n      + new.amount > (SELECT amount FROM payments WHERE id = new.payment_id)\n    OR (SELECT coalesce(sum(a.amount), 0) FROM payment_allocations a JOIN payments p ON p.id = a.payment_id\n      WHERE a.invoice_id = new.invoice_id AND a.id <> old.id\n        AND ((p.review = 'confirmed' AND p.deleted_at IS NULL) OR a.payment_id = new.payment_id)) + new.amount\n      > (SELECT total FROM invoices WHERE id = new.invoice_id) BEGIN\n  SELECT RAISE(ABORT, 'payment_allocations: above 0, within the payment and within the invoice, sides unchanged');\nEND;"
         ]
+    },
+    {
+        "name": "20261102185954_version-46-payment-facts",
+        "statements": [
+            "-- Money lives in `payments` and `invoices`, not facts. An older build still takes a payment fact, so the triggers\n-- refuse one; the facts already stored need the finance code's minor units and rules, so the next writable open moves\n-- them and deletes this key (movePaymentFacts).\nCREATE TRIGGER facts_no_payment_bi BEFORE INSERT ON facts WHEN new.type = 'payment' BEGIN\n  SELECT RAISE(ABORT, 'facts: a payment is a payments row in store.finance, not a fact; upgrade the CLI');\nEND;",
+            "CREATE TRIGGER facts_no_payment_bu BEFORE UPDATE OF type ON facts WHEN new.type = 'payment' BEGIN\n  SELECT RAISE(ABORT, 'facts: a payment is a payments row in store.finance, not a fact; upgrade the CLI');\nEND;",
+            "INSERT OR REPLACE INTO store_settings (key, value, at) VALUES ('payment_facts_to_move', '1', unixepoch() * 1000);"
+        ]
     }
 ];

package/dist/store/sqlite/open-store.js

@@ -12,6 +12,7 @@ import { fillFolded } from "./folded.js";
 import { fillJoinKeys } from "./join-keys.js";
 import { logPruner } from "./log-pruning.js";
 import { openSqlite } from "./open.js";
+import { movePaymentFacts } from "./payment-facts.js";
 import { loadProviders } from "./providers.js";
 import { assertReadCompatible } from "./read-compatibility.js";
 import { stemsState } from "./stems.js";
@@ -57,6 +58,7 @@ export const openStoreContext = async ({ path, env, now = Date.now, command, ver
             fillFolded(database);
             fillJoinKeys(database);
             moveSuggestedLinks(database, now);
+            movePaymentFacts({ ...opened, now, decisions });
             const pending = pendingNormalization(database);
             if (pending > 0 && pending <= BACKFILL_ON_OPEN)
                 backfillNormalized(database);

package/dist/store/sqlite/payment-entries.d.ts

@@ -0,0 +1,26 @@
+import { type Payment } from "../../meetings/index.js";
+import type { Decider } from "../decisions.js";
+import type { Author } from "./memories.js";
+import type { StoreContext } from "./open.js";
+/** A payment as an agent's finding or a retired payment fact holds it. */
+export interface PaymentEntry {
+    payment: Payment;
+    statement?: string;
+    project?: string;
+    evidence: string[];
+    /** The `invoice:` a paid entry settles or a cancelled one voids. */
+    supersedes?: string;
+}
+/** What becomes of the proposal: confirmed or rejected by the decider, or left proposed. */
+export type PaymentOutcome = {
+    confirm: boolean;
+    by: Decider;
+} | "proposed";
+/** The finding's two-decimal amount in the currency's own scale: "1200.00" JPY is "1200", "1200.50" JPY is refused. */
+export declare const entryAmount: (payment: Payment) => string;
+/**
+ * Money from a payment finding goes to `store.finance`, never into a fact: a paid one is a payment, allocated to the
+ * invoice it supersedes as far as that is open; an expected one is an invoice of one line; a cancelled one voids its
+ * invoice, which only the owner does. The author proposes; `outcome` is the owner's decision on it.
+ */
+export declare const paymentEntriesOver: (context: StoreContext) => (entry: PaymentEntry, by: Author, outcome: PaymentOutcome) => string;

package/dist/store/sqlite/payment-entries.js

@@ -0,0 +1,91 @@
+import { CliError } from "@wirecat/cli-base";
+import { formatDecimal, minorUnits, parseDecimal, scaleOf } from "../../domain/money.js";
+import { paymentTitle } from "../../meetings/index.js";
+import { financeOperationsOver } from "./finance.js";
+const refuse = (message, reason) => {
+    throw new CliError("validation_error", message, { reason });
+};
+/** The finding's two-decimal amount in the currency's own scale: "1200.00" JPY is "1200", "1200.50" JPY is refused. */
+export const entryAmount = (payment) => {
+    const scale = scaleOf(payment.currency);
+    const cents = parseDecimal(payment.amount, 2);
+    if (cents === undefined)
+        return refuse(`${payment.amount} is not an amount`, "money.amount");
+    const shift = 10n ** BigInt(Math.abs(scale - 2));
+    if (scale >= 2)
+        return formatDecimal(cents * shift, scale);
+    if (cents % shift !== 0n)
+        return refuse(`${payment.currency} has ${scale} decimals; ${payment.amount} does not fit`, "money.amount");
+    return formatDecimal(cents / shift, scale);
+};
+const party = (payment) => /^(person|organization):/.test(payment.counterparty ?? "") ? payment.counterparty : null;
+/**
+ * Money from a payment finding goes to `store.finance`, never into a fact: a paid one is a payment, allocated to the
+ * invoice it supersedes as far as that is open; an expected one is an invoice of one line; a cancelled one voids its
+ * invoice, which only the owner does. The author proposes; `outcome` is the owner's decision on it.
+ */
+export const paymentEntriesOver = (context) => {
+    const finance = financeOperationsOver(context);
+    const today = () => new Date(context.now()).toISOString().slice(0, 10);
+    const decided = (ref, outcome) => {
+        if (outcome === "proposed")
+            return ref;
+        return (outcome.confirm ? finance.confirm(ref, outcome.by) : finance.reject(ref, outcome.by)).ref;
+    };
+    /** As much of the payment as the invoice still has open; nothing when it is already covered. */
+    const settled = (reference, amount, currency) => {
+        const invoice = finance.invoice(reference);
+        const units = Math.min(minorUnits(amount, currency), minorUnits(invoice.open, invoice.currency));
+        return units > 0 ? [{ invoice: invoice.ref, amount: formatDecimal(units, scaleOf(currency)) }] : [];
+    };
+    return (entry, by, outcome) => {
+        const { payment } = entry;
+        const amount = entryAmount(payment);
+        const project = entry.project ?? (payment.counterparty?.startsWith("project:") ? payment.counterparty : undefined);
+        const written = {
+            by,
+            ...(project === undefined ? {} : { project }),
+            ...(by === "owner" ? {} : { source: "agent", reason: entry.statement ?? paymentTitle(entry) }),
+            evidence: entry.evidence,
+        };
+        const counterparty = party(payment);
+        if (payment.state === "cancelled") {
+            if (entry.supersedes === undefined)
+                return refuse("a cancelled payment names the invoice it cancels", "finance.ref");
+            if (outcome === "proposed" || !outcome.confirm)
+                return entry.supersedes;
+            if (outcome.by !== "owner")
+                throw new CliError("permission_error", "only the owner voids an invoice", { reason: "finance.owner-only" });
+            return finance.voidInvoice(entry.supersedes, "owner").ref;
+        }
+        if (payment.state === "expected") {
+            if (counterparty === null)
+                return refuse("an expected payment is an invoice, which names a person: or organization:", "finance.party");
+            const invoice = finance.addInvoice({
+                ...written,
+                direction: payment.direction === "to_us" ? "receivable" : "payable",
+                counterparty,
+                currency: payment.currency,
+                ...(payment.due_at === null ? {} : { dueDate: payment.due_at }),
+                lines: [{ description: (payment.item ?? entry.statement ?? paymentTitle(entry)).slice(0, 500), amount }],
+            });
+            return decided(invoice.ref, outcome);
+        }
+        const settles = entry.supersedes === undefined ? [] : settled(entry.supersedes, amount, payment.currency);
+        const made = finance.addPayment({
+            ...written,
+            direction: payment.direction === "to_us" ? "in" : "out",
+            ...(counterparty === null
+                ? {}
+                : payment.direction === "to_us"
+                    ? { payer: counterparty }
+                    : { payee: counterparty }),
+            amount,
+            currency: payment.currency,
+            date: payment.paid_at ?? payment.due_at ?? today(),
+            ...(payment.item === null ? {} : { reference: payment.item }),
+            allocations: settles,
+        });
+        return decided(made.ref, outcome);
+    };
+};

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

@@ -0,0 +1,12 @@
+import type { StoreContext } from "./open.js";
+/** Set by store version 46 and deleted once the move ran. */
+export declare const PAYMENT_FACTS_TO_MOVE = "payment_facts_to_move";
+/**
+ * Moves the payment facts store versions 44–45 took into `store.finance`, as a payment finding is recorded now: a
+ * paid one a payment, an expected one an invoice, a cancelled one voids the invoice it supersedes. An accepted fact
+ * becomes a confirmed row and a proposed one stays proposed; a rejected one, or one a correction superseded, is
+ * rejected. An expected fact that a payment or a cancellation superseded held until then, so its invoice is
+ * confirmed and the payment settles it. What cannot be a row (no party for an invoice, a pending cancellation, an
+ * owner's fact that no longer holds) stays a `statement` fact with the fields under `metadata.retired_payment`.
+ */
+export declare const movePaymentFacts: (context: StoreContext) => number;

package/dist/store/sqlite/payment-facts.js

@@ -0,0 +1,92 @@
+import { validatePayment } from "../../meetings/index.js";
+import { dropLinksOf, evidenceOf, keepHighestId } from "./memories.js";
+import { paymentEntriesOver } from "./payment-entries.js";
+import { write } from "./transaction.js";
+/** Set by store version 46 and deleted once the move ran. */
+export const PAYMENT_FACTS_TO_MOVE = "payment_facts_to_move";
+const paymentOf = (metadata) => {
+    try {
+        return validatePayment(JSON.parse(String(metadata)).payment);
+    }
+    catch {
+        return undefined;
+    }
+};
+/**
+ * Moves the payment facts store versions 44–45 took into `store.finance`, as a payment finding is recorded now: a
+ * paid one a payment, an expected one an invoice, a cancelled one voids the invoice it supersedes. An accepted fact
+ * becomes a confirmed row and a proposed one stays proposed; a rejected one, or one a correction superseded, is
+ * rejected. An expected fact that a payment or a cancellation superseded held until then, so its invoice is
+ * confirmed and the payment settles it. What cannot be a row (no party for an invoice, a pending cancellation, an
+ * owner's fact that no longer holds) stays a `statement` fact with the fields under `metadata.retired_payment`.
+ */
+export const movePaymentFacts = (context) => {
+    const { database, now } = context;
+    if (!database.prepare("SELECT 1 AS found FROM store_settings WHERE key = ?").get(PAYMENT_FACTS_TO_MOVE))
+        return 0;
+    const record = paymentEntriesOver(context);
+    return write(database, () => {
+        const rows = database
+            .prepare("SELECT f.*, b.name AS bot_name, b.kind AS bot_kind FROM facts f " +
+            "LEFT JOIN bots b ON f.author_type = 'bot' AND b.id = f.author_id WHERE f.type = 'payment' ORDER BY f.id")
+            .all();
+        const nextState = (id) => paymentOf(database
+            .prepare("SELECT metadata FROM facts WHERE supersedes_id = ? AND type = 'payment' ORDER BY id DESC LIMIT 1")
+            .get(id)?.metadata)?.state;
+        const outcomeOf = (row, payment) => {
+            if (row.status === "proposed")
+                return "proposed";
+            if (row.status === "accepted")
+                return { confirm: true, by: "owner" };
+            const settled = row.status === "superseded" && payment.state === "expected" && nextState(Number(row.id));
+            return { confirm: settled === "paid" || settled === "cancelled", by: "owner" };
+        };
+        const moved = new Map();
+        for (const row of rows) {
+            const id = Number(row.id);
+            const payment = paymentOf(row.metadata);
+            if (!payment)
+                continue;
+            const by = row.author_type === "bot" && row.bot_name != null
+                ? {
+                    bot: String(row.bot_name),
+                    kind: row.bot_kind === "rule" ? "rule" : "agent",
+                    ...(row.model == null ? {} : { model: String(row.model) }),
+                }
+                : "owner";
+            const outcome = outcomeOf(row, payment);
+            const holds = outcome !== "proposed" && outcome.confirm;
+            if ((by === "owner" && !holds) || (payment.state === "cancelled" && !holds))
+                continue;
+            const target = row.supersedes_id == null ? undefined : moved.get(Number(row.supersedes_id));
+            const entry = {
+                payment,
+                statement: String(row.statement),
+                ...(row.project_id == null ? {} : { project: `project:${row.project_id}` }),
+                evidence: evidenceOf(context, { type: "fact", id }),
+                ...(payment.state !== "expected" && target?.startsWith("invoice:") ? { supersedes: target } : {}),
+            };
+            try {
+                moved.set(id, write(database, () => record(entry, by, by === "owner" ? "proposed" : outcome)));
+            }
+            catch {
+                // Kept below as a statement: an unknown currency or a party that is gone is no reason to lose the fact.
+            }
+        }
+        if (moved.size)
+            keepHighestId(database, "facts", now());
+        for (const id of moved.keys()) {
+            database.prepare("UPDATE facts SET supersedes_id = NULL WHERE supersedes_id = ?").run(id);
+            dropLinksOf(database, { type: "fact", id });
+            database.prepare("DELETE FROM links WHERE from_type = 'fact' AND from_id = ?").run(id);
+            database.prepare("DELETE FROM taggings WHERE taggable_type = 'fact' AND taggable_id = ?").run(id);
+            database.prepare("DELETE FROM facts WHERE id = ?").run(id);
+        }
+        database
+            .prepare("UPDATE facts SET type = 'statement', updated_at = ?, metadata = json_remove(json_set(coalesce(metadata, '{}'), " +
+            "'$.retired_payment', json(json_extract(metadata, '$.payment'))), '$.payment') WHERE type = 'payment'")
+            .run(now());
+        database.prepare("DELETE FROM store_settings WHERE key = ?").run(PAYMENT_FACTS_TO_MOVE);
+        return moved.size;
+    });
+};

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

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

package/dist/store/store.d.ts

@@ -115,7 +115,6 @@ export interface MessageStore {
     forAccount(key: AccountKey): AccountStore;
     close(): Promise<void>;
 }
-export type { PaymentFilter } from "./sqlite/facts.js";
 export type { ChatHistoryShape, StoredHistorySkip } from "./sqlite/history-skips.js";
 export { BACKFILL_ON_OPEN, type StoreOptions } from "./sqlite/open-store.js";
 export { fileFacts, readStoreTables, type TableKind } from "./sqlite/store-tables.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.557.0",
+  "version": "0.558.0",
   "description": "The messenger-neutral half of a messaging CLI: domain model, message locators, rendering, name resolution, the SQLite seam, the command skeleton and shared read commands, the send guard, run records and the message store",
   "license": "Apache-2.0",
   "author": "Viacheslav Ptsarev",

package/dist/cli/payment-query.d.ts

@@ -1,8 +0,0 @@
-import type { PaymentFilter } from "../store/store.js";
-/**
- * The terms a facts list adds for payments. `state` is the payment's, not `status`, which stays the review status
- * (proposed, accepted).
- */
-export declare const PAYMENT_QUERY_FIELDS: import("@wirecat/cli-base/query").FieldSpec[];
-/** The store's payment filter from `queryTerms`' answer; `undefined` when no payment term was given. */
-export declare const paymentFilterOf: (terms: Map<string, string>) => PaymentFilter | undefined;

package/dist/cli/payment-query.js

@@ -1,27 +0,0 @@
-import { CliError } from "@wirecat/cli-base";
-import { PAYMENT_DIRECTIONS, PAYMENT_STATES } from "../meetings/index.js";
-import { termField } from "./list-query.js";
-/**
- * The terms a facts list adds for payments. `state` is the payment's, not `status`, which stays the review status
- * (proposed, accepted).
- */
-export const PAYMENT_QUERY_FIELDS = [
-    termField("open", "bool", "open:true"),
-    termField("direction", "enum", "direction:to_us", { values: PAYMENT_DIRECTIONS }),
-    termField("state", "enum", "state:paid", { values: PAYMENT_STATES }),
-];
-/** The store's payment filter from `queryTerms`' answer; `undefined` when no payment term was given. */
-export const paymentFilterOf = (terms) => {
-    const open = terms.get("open");
-    const direction = terms.get("direction");
-    const state = terms.get("state");
-    if (open === undefined && direction === undefined && state === undefined)
-        return undefined;
-    if (open !== undefined && open !== "true" && open !== "false")
-        throw new CliError("validation_error", "open takes true or false");
-    return {
-        ...(open === undefined ? {} : { open: open === "true" }),
-        ...(direction === undefined ? {} : { direction }),
-        ...(state === undefined ? {} : { state }),
-    };
-};