@wirecat/cli-core 0.557.0 → 0.559.0

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,8 @@ 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 },
+    { name: "20261102192959_version-47-records", version: 47, minCompatible: 34 },
 ];
 export const generatedMigrations = (manifest = MANIFEST, generated = GENERATED) => {
     const migrations = [];

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

@@ -924,5 +924,23 @@ 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);"
+        ]
+    },
+    {
+        "name": "20261102192959_version-47-records",
+        "statements": [
+            "CREATE TABLE `record_relations` (\n\t`id` integer PRIMARY KEY,\n\t`record_id` integer NOT NULL,\n\t`role` text NOT NULL,\n\t`target_type` text NOT NULL,\n\t`target_external_id` text NOT NULL,\n\t`target_id` integer,\n\t`created_at` integer NOT NULL,\n\tCONSTRAINT `fk_record_relations_record_id_records_id_fk` FOREIGN KEY (`record_id`) REFERENCES `records`(`id`),\n\tCONSTRAINT `fk_record_relations_target_id_records_id_fk` FOREIGN KEY (`target_id`) REFERENCES `records`(`id`),\n\tCONSTRAINT `record_relations_record_id_role_target_type_target_external_id_unique` UNIQUE(`record_id`,`role`,`target_type`,`target_external_id`)\n);",
+            "CREATE TABLE `records` (\n\t`id` integer PRIMARY KEY,\n\t`account_id` integer NOT NULL,\n\t`type` text NOT NULL,\n\t`external_id` text NOT NULL,\n\t`fields` text NOT NULL,\n\t`revision` integer,\n\t`fingerprint` text NOT NULL,\n\t`entity_type` text,\n\t`entity_id` integer,\n\t`projected_fingerprint` text,\n\t`batch_id` text NOT NULL,\n\t`created_at` integer NOT NULL,\n\t`updated_at` integer NOT NULL,\n\t`deleted_at` integer,\n\tCONSTRAINT `fk_records_account_id_accounts_id_fk` FOREIGN KEY (`account_id`) REFERENCES `accounts`(`id`),\n\tCONSTRAINT `records_account_id_type_external_id_unique` UNIQUE(`account_id`,`type`,`external_id`)\n);",
+            "CREATE INDEX `record_relations_by_target_type_target_external_id` ON `record_relations` (`target_type`,`target_external_id`);",
+            "CREATE INDEX `record_relations_by_target_id` ON `record_relations` (`target_id`);",
+            "CREATE INDEX `records_by_entity_type_entity_id` ON `records` (`entity_type`,`entity_id`);"
+        ]
     }
 ];

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/sqlite/records.d.ts

@@ -0,0 +1,81 @@
+import { type EnvelopeRecord, type EnvelopeSource, type IngestError } from "../../domain/records.js";
+import type { Author } from "./memories.js";
+import type { StoreContext } from "./open.js";
+export interface RecordKey {
+    provider: string;
+    account: string;
+    type: string;
+    externalId: string;
+}
+export interface SourceRecord extends RecordKey {
+    fields: Record<string, unknown>;
+    revision: number | null;
+    fingerprint: string;
+    relations: {
+        role: string;
+        type: string;
+        externalId: string;
+        resolved: boolean;
+    }[];
+    /** The entity made from it or mapped to it by the owner; `null` while it waits or for a type without a table. */
+    entity: string | null;
+    /** The source changed or deleted it after its entity was made: the owner should look at the entity. */
+    flagged: boolean;
+    batchId: string;
+    createdAt: string;
+    updatedAt: string;
+    deletedAt: string | null;
+}
+export interface RecordOutcome {
+    /** The record's place in the envelope's `records`. */
+    index: number;
+    key: string;
+    status: "created" | "updated" | "unchanged" | "deleted" | "refused";
+    error?: IngestError;
+}
+export interface RecordsWritten {
+    outcomes: RecordOutcome[];
+    /** `invoice:` and `payment:` refs this import proposed, also for records of earlier imports it completed. */
+    proposed: string[];
+    /** Kept, with no entity yet: the roles whose target is not imported or has no entity. */
+    waiting: {
+        index: number;
+        key: string;
+        missing: string[];
+    }[];
+    /** Changed or deleted at the source after its entity was made. */
+    flagged: {
+        index: number;
+        key: string;
+        entity: string;
+    }[];
+    /** A record of an earlier import this one completed, whose entity was still refused. */
+    laterErrors: IngestError[];
+}
+export interface RecordStore {
+    /** Writes validated records of one source, per chunk in one transaction; a dry run rolls everything back. */
+    write(source: EnvelopeSource, records: {
+        index: number;
+        record: EnvelopeRecord;
+    }[], options?: {
+        dryRun?: boolean;
+        chunk?: number;
+    }): Promise<RecordsWritten>;
+    get(key: RecordKey): Promise<SourceRecord | undefined>;
+    list(filter: {
+        provider: string;
+        account: string;
+        type?: string;
+        /** Only records whose entity waits for a reference. */
+        waiting?: boolean;
+        flagged?: boolean;
+        /** 1–500, 100 by default. */
+        limit?: number;
+    }): Promise<SourceRecord[]>;
+    /**
+     * The owner says which entity a record is: `person:4` for a payer a sheet names. Never done by name. Records that
+     * waited for it get their entity, as proposals.
+     */
+    map(key: RecordKey, entity: string, by: Author): Promise<SourceRecord>;
+}
+export declare const recordStoreOver: (context: StoreContext) => RecordStore;