@wirecat/cli-core 0.574.0 → 0.575.0

package/dist/mail/findings.js

@@ -1,6 +1,8 @@
 import { CliError } from "@wirecat/cli-base";
+import { INVOICE_DIRECTIONS, MONEY_DIRECTIONS } from "../domain/finance.js";
 import { MEMORY_KINDS, MEMORY_SCOPES } from "../domain/knowledge.js";
 import { formatLocator, parseLocator } from "../domain/locator.js";
+import { ORDER_PURPOSES, ORDER_STATUSES } from "../domain/orders.js";
 import { parseReference } from "../domain/references.js";
 import { findingFields, findingHash, findingId, findingText, meetingTimestamp, validateBatch, validateFinding, validEvidence, } from "../meetings/index.js";
 export { MAIL_FINDINGS_KIND } from "../store/mail-findings.js";
@@ -42,6 +44,18 @@ const LINKS = {
     "chat:email": "project",
 };
 const ADDRESS = /^[^\s@<>]+@[^\s@<>]+$/;
+const PARTY = /^(person|organization):[1-9]\d*$/;
+const INVOICE = /^invoice:[1-9]\d*$/;
+const PAYMENT = /^payment:[1-9]\d*$/;
+const PROJECT = /^project:[1-9]\d*$/;
+const oneOf = (value, allowed, what) => {
+    if (typeof value !== "string" || !allowed.includes(value))
+        return invalid(`${what} is ${allowed.join(", ")}`);
+    return value;
+};
+/** Money and dates stay text here: the store's finance and order services check them as they check the owner's. */
+const word = (value, limit) => findingText(value, limit);
+const optional = (key, value, read) => (value === undefined ? {} : { [key]: read(value) });
 const one = (raw, ids) => {
     if (!raw || typeof raw !== "object")
         return invalid("a finding is an object");
@@ -123,8 +137,157 @@ const one = (raw, ids) => {
                 evidence,
             };
         }
+        case "invoice": {
+            findingFields(raw, [
+                "id",
+                "kind",
+                "direction",
+                "counterparty",
+                "currency",
+                "lines",
+                "total",
+                "number",
+                "issueDate",
+                "dueDate",
+                "project",
+                "reason",
+                "evidence",
+            ], RULES.singular);
+            if (!Array.isArray(raw.lines) || raw.lines.length < 1 || raw.lines.length > 50)
+                return invalid("an invoice finding has 1–50 lines");
+            const lines = raw.lines.map((line) => {
+                if (!line || typeof line !== "object")
+                    return invalid("an invoice line is an object");
+                const fields = line;
+                findingFields(fields, ["description", "quantity", "unitPrice", "amount"], "invoice line");
+                return {
+                    description: word(fields.description, 500),
+                    ...optional("quantity", fields.quantity, (value) => word(value, 20)),
+                    ...optional("unitPrice", fields.unitPrice, (value) => word(value, 30)),
+                    ...optional("amount", fields.amount, (value) => word(value, 30)),
+                };
+            });
+            return {
+                id,
+                kind: "invoice",
+                direction: oneOf(raw.direction, INVOICE_DIRECTIONS, "an invoice's direction"),
+                counterparty: reference(raw.counterparty, PARTY, "an invoice's counterparty"),
+                currency: word(raw.currency, 3),
+                lines,
+                ...optional("total", raw.total, (value) => word(value, 30)),
+                ...optional("number", raw.number, (value) => word(value, 80)),
+                ...optional("issueDate", raw.issueDate, (value) => word(value, 10)),
+                ...optional("dueDate", raw.dueDate, (value) => word(value, 10)),
+                ...optional("project", raw.project, (value) => reference(value, PROJECT, "a project")),
+                reason: findingText(raw.reason, 2000),
+                evidence,
+            };
+        }
+        case "payment": {
+            findingFields(raw, [
+                "id",
+                "kind",
+                "direction",
+                "payer",
+                "payee",
+                "amount",
+                "currency",
+                "date",
+                "reference",
+                "allocations",
+                "project",
+                "reason",
+                "evidence",
+            ], RULES.singular);
+            let allocations;
+            if (raw.allocations !== undefined) {
+                if (!Array.isArray(raw.allocations) || raw.allocations.length < 1 || raw.allocations.length > 8)
+                    return invalid("a payment finding's allocations are 1–8 invoices it settles");
+                allocations = raw.allocations.map((share) => {
+                    if (!share || typeof share !== "object")
+                        return invalid("an allocation is an invoice and an amount");
+                    const fields = share;
+                    findingFields(fields, ["invoice", "amount"], "allocation");
+                    return {
+                        invoice: reference(fields.invoice, INVOICE, "an allocation's invoice"),
+                        amount: word(fields.amount, 30),
+                    };
+                });
+            }
+            return {
+                id,
+                kind: "payment",
+                direction: oneOf(raw.direction, MONEY_DIRECTIONS, "a payment's direction"),
+                ...optional("payer", raw.payer, (value) => reference(value, PARTY, "a payment's payer")),
+                ...optional("payee", raw.payee, (value) => reference(value, PARTY, "a payment's payee")),
+                amount: word(raw.amount, 30),
+                currency: word(raw.currency, 3),
+                date: word(raw.date, 10),
+                ...optional("reference", raw.reference, (value) => word(value, 500)),
+                ...(allocations === undefined ? {} : { allocations }),
+                ...optional("project", raw.project, (value) => reference(value, PROJECT, "a project")),
+                reason: findingText(raw.reason, 2000),
+                evidence,
+            };
+        }
+        case "order": {
+            findingFields(raw, [
+                "id",
+                "kind",
+                "purpose",
+                "customer",
+                "supplier",
+                "supplierName",
+                "number",
+                "total",
+                "currency",
+                "status",
+                "orderDate",
+                "fulfilledDate",
+                "invoice",
+                "payment",
+                "project",
+                "reason",
+                "evidence",
+            ], RULES.singular);
+            return {
+                id,
+                kind: "order",
+                purpose: oneOf(raw.purpose, ORDER_PURPOSES, "an order's purpose"),
+                ...optional("customer", raw.customer, (value) => reference(value, PARTY, "an order's customer")),
+                ...optional("supplier", raw.supplier, (value) => reference(value, PARTY, "an order's supplier")),
+                supplierName: word(raw.supplierName, 200),
+                ...optional("number", raw.number, (value) => word(value, 80)),
+                ...optional("total", raw.total, (value) => word(value, 30)),
+                ...optional("currency", raw.currency, (value) => word(value, 3)),
+                ...optional("status", raw.status, (value) => oneOf(value, ORDER_STATUSES, "an order's status")),
+                ...optional("orderDate", raw.orderDate, (value) => word(value, 10)),
+                ...optional("fulfilledDate", raw.fulfilledDate, (value) => word(value, 10)),
+                ...optional("invoice", raw.invoice, (value) => reference(value, INVOICE, "an order's invoice")),
+                ...optional("payment", raw.payment, (value) => reference(value, PAYMENT, "an order's payment")),
+                ...optional("project", raw.project, (value) => reference(value, PROJECT, "a project")),
+                reason: findingText(raw.reason, 2000),
+                evidence,
+            };
+        }
+        case "order_update": {
+            findingFields(raw, ["id", "kind", "supplierName", "number", "status", "date", "reason", "evidence"], RULES.singular);
+            const status = oneOf(raw.status, ORDER_STATUSES, "an order update's status");
+            if (raw.date !== undefined && status !== "delivered")
+                return invalid("only a delivered order update gives date");
+            return {
+                id,
+                kind: "order_update",
+                supplierName: word(raw.supplierName, 200),
+                number: word(raw.number, 80),
+                status,
+                ...optional("date", raw.date, (value) => word(value, 10)),
+                reason: findingText(raw.reason, 2000),
+                evidence,
+            };
+        }
         default:
-            return invalid("a mail finding is a task, task_update, fact, memory, link or new_contact");
+            return invalid("a mail finding is a task, task_update, fact, memory, link, new_contact, invoice, payment, order or order_update");
     }
 };
 /**

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

@@ -1,5 +1,6 @@
 import { MAIL_FINDINGS_KIND } from "../../../store/index.js";
 import { kept, proposerOfAuthor } from "./shared.js";
+const words = (...parts) => parts.filter(Boolean).join(" ");
 /** A finding's one line in the inbox; never the email's text, only what the agent wrote. */
 const summaryOf = (finding) => {
     switch (finding.kind) {
@@ -15,6 +16,14 @@ const summaryOf = (finding) => {
             return `${finding.from} → ${finding.to}`;
         case "new_contact":
             return `${finding.name} <${finding.address}>`;
+        case "invoice":
+            return words("invoice", finding.number, finding.total, finding.currency, `· ${finding.reason}`);
+        case "payment":
+            return words("payment", finding.amount, finding.currency, finding.date, `· ${finding.reason}`);
+        case "order":
+            return words("order", finding.number, finding.supplierName, finding.status ?? "placed", `· ${finding.reason}`);
+        case "order_update":
+            return words("order", finding.number, finding.supplierName, finding.status, `· ${finding.reason}`);
     }
 };
 const rowOf = (batch, createdAt) => {

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

@@ -0,0 +1,4 @@
+import type { MessageStore } from "../../../store/index.js";
+import type { ProposalKind } from "../types.js";
+/** An agent's order, by its own ref (`order:12`) as invoices are; only the owner decides it. */
+export declare const orderKind: (store: Pick<MessageStore, "orders">) => ProposalKind;

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

@@ -0,0 +1,32 @@
+import { kept, proposerOfAuthor, pushed } from "./shared.js";
+const rowOf = (order) => ({
+    id: order.ref,
+    kind: "order",
+    status: order.review,
+    project: order.project,
+    subject: order.ref,
+    object: order.supplier?.ref ?? null,
+    summary: order.title,
+    proposedBy: proposerOfAuthor(order.author),
+    reason: order.reason,
+    evidence: [],
+    score: null,
+    signals: null,
+    parts: null,
+    createdAt: order.createdAt,
+});
+/** An agent's order, by its own ref (`order:12`) as invoices are; only the owner decides it. */
+export const orderKind = (store) => ({
+    kind: "order",
+    prefix: "order",
+    list: async (filter) => {
+        const status = filter.status ?? "proposed";
+        const orders = await store.orders.list({ ...pushed(filter), ...(status === "all" ? {} : { review: status }) });
+        return kept(orders.map(rowOf), filter);
+    },
+    get: async (id) => rowOf(await store.orders.get(id)),
+    decide: async (id, { confirm, by, reason }) => {
+        const order = confirm ? await store.orders.confirm(id, by, reason) : await store.orders.reject(id, by, reason);
+        return { id, kind: "order", status: confirm ? "confirmed" : "rejected", made: confirm ? [order.ref] : [] };
+    },
+});

package/dist/services/proposals/registry.js

@@ -8,6 +8,7 @@ import { keyDocumentKind } from "./kinds/key-document.js";
 import { mailFindingsKind } from "./kinds/mail-findings.js";
 import { meetingFindingsKind } from "./kinds/meeting-findings.js";
 import { memoryKind } from "./kinds/memory.js";
+import { orderKind } from "./kinds/orders.js";
 import { relationshipKind } from "./kinds/relationship.js";
 import { relationshipUpdateKind } from "./kinds/relationship-update.js";
 import { taskCloseKind } from "./kinds/task-close.js";
@@ -132,6 +133,7 @@ export const proposalRegistry = (store) => {
         factKind(store),
         invoiceKind(store),
         paymentKind(store),
+        orderKind(store),
         memoryKind(store),
         findingsKind(store),
         mailFindingsKind(store),

package/dist/store/index.d.ts

@@ -53,6 +53,7 @@ export type { Author, MemoriesStore, Memory, MemoryInput } from "./sqlite/memori
 export type { NoteIndexState } from "./sqlite/note-index.js";
 export { type NearestNote, NOTE_FIELDS, type NoteChunkToEmbed, type NoteHit, type NoteQuery, type NoteSearch, } from "./sqlite/note-search.js";
 export type { FileNoteInput, Link, LinkInput, LinkListFilter, Note, NoteFolder, NotesStore, NoteTag, } from "./sqlite/notes.js";
+export type { Order, OrderFilter, OrderInput, OrdersStore } from "./sqlite/orders.js";
 export type { PrivateContact, PrivateContactNote } from "./sqlite/private-people.js";
 export { assertGenericAction, PROPOSAL_STATUSES, type ProposalInput, type ProposedAction, type ProposedActionsStore, proposerOfAction, } from "./sqlite/proposed-actions.js";
 export type { RecordKey, RecordOutcome, RecordStore, RecordsWritten, SourceRecord, } from "./sqlite/records.js";

package/dist/store/sqlite/entity-types.d.ts

@@ -27,6 +27,7 @@ export declare const ENTITY_TABLES: {
     readonly memory: "memories";
     readonly message: "messages";
     readonly note: "notes";
+    readonly order: "orders";
     readonly organization: "organizations";
     readonly payment: "payments";
     readonly person: "persons";

package/dist/store/sqlite/entity-types.js

@@ -26,6 +26,7 @@ export const ENTITY_TABLES = {
     memory: "memories",
     message: "messages",
     note: "notes",
+    order: "orders",
     organization: "organizations",
     payment: "payments",
     person: "persons",

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

@@ -11,7 +11,7 @@ export interface Party {
     /** The owner's own person row. */
     owner: boolean;
 }
-interface Reviewed {
+export interface Reviewed {
     review: FinanceReview;
     /** `name` is a bot's handle and `kind` whether it is an agent or a rule; both `null` for a person. */
     author: {
@@ -91,7 +91,7 @@ export interface Payment extends Reviewed {
 export interface PaymentDetail extends Payment {
     allocations: Allocation[];
 }
-interface Written {
+export interface Written {
     /** The owner's entry is confirmed at once; a bot's waits as proposed for the owner. */
     by: Author;
     project?: string;
@@ -204,6 +204,44 @@ export interface FinanceStore {
         payable: OpenTotal[];
     }>;
 }
+type Row = Record<string, unknown>;
+export declare const refuse: (message: string, reason: string, code?: "validation_error" | "permission_error") => never;
+export declare const oneOf: <T extends string>(value: unknown, allowed: readonly T[], what: string) => T;
+export declare const text: (value: unknown, what: string, limit: number) => string | null;
+export declare const isoDate: (value: unknown, what: string) => string | null;
+export declare const iso: (value: unknown) => string;
+/** What invoices, payments and orders share: their parties, who wrote them, and how the owner decides them. */
+export declare const reviewedRowsOver: (context: StoreContext) => {
+    partyOf: (type: unknown, id: unknown) => Party | null;
+    partyThing: (reference: string | undefined, what: string) => import("./things.js").Thing | undefined;
+    reviewedOf: (row: Row, type: "invoice" | "payment" | "order") => Reviewed;
+    written: (input: Written) => {
+        owner: boolean;
+        actor: Actor;
+        model: string | null;
+        source: string;
+        review: string;
+        confirmedType: "bot" | "person" | null;
+        confirmedId: number | null;
+        metadata: string | null;
+        project: number | null;
+        evidence: string[];
+    };
+    keepEvidence: (type: "invoice" | "payment" | "order", id: number, by: ReturnType<(input: Written) => {
+        owner: boolean;
+        actor: Actor;
+        model: string | null;
+        source: string;
+        review: string;
+        confirmedType: "bot" | "person" | null;
+        confirmedId: number | null;
+        metadata: string | null;
+        project: number | null;
+        evidence: string[];
+    }>) => void;
+    ownerOnly: (by: Author, what: string) => void;
+    keepDecision: (table: "invoices" | "payments" | "orders", id: number, by: Decider, reason?: string) => void;
+};
 type FinanceOperations = {
     [K in keyof FinanceStore]: FinanceStore[K] extends (...args: infer A) => Promise<infer R> ? (...args: A) => R : never;
 };

package/dist/store/sqlite/finance.js

@@ -6,22 +6,22 @@ import { proposedBySql, proposerOf } from "./actors.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") => {
+export const refuse = (message, reason, code = "validation_error") => {
     throw new CliError(code, message, { reason });
 };
-const oneOf = (value, allowed, what) => {
+export const oneOf = (value, allowed, what) => {
     if (typeof value !== "string" || !allowed.includes(value))
         return refuse(`${what} is one of ${allowed.join(", ")}`, "finance.field");
     return value;
 };
-const text = (value, what, limit) => {
+export const text = (value, what, limit) => {
     if (value === undefined || value === null)
         return null;
     if (typeof value !== "string" || !value.trim() || value.length > limit || value.includes("\0"))
         return refuse(`${what} takes 1–${limit} characters`, "finance.field");
     return value.trim();
 };
-const isoDate = (value, what) => {
+export const isoDate = (value, what) => {
     if (value === undefined || value === null)
         return null;
     const date = typeof value === "string" ? value.trim() : "";
@@ -29,7 +29,7 @@ const isoDate = (value, what) => {
         return refuse(`${what} is a date such as 2026-11-15`, "finance.field");
     return date;
 };
-const iso = (value) => new Date(Number(value)).toISOString();
+export const iso = (value) => new Date(Number(value)).toISOString();
 const evidenceList = (value) => {
     if (value === undefined)
         return [];
@@ -56,8 +56,9 @@ const INVOICES = `SELECT i.*, ${PAID} AS paid, b.name AS author_name, b.kind AS
     "LEFT JOIN bots b ON i.author_type = 'bot' AND b.id = i.author_id";
 const PAYMENTS = "SELECT p.*, (SELECT coalesce(sum(amount), 0) FROM payment_allocations WHERE payment_id = p.id) AS allocated, " +
     "b.name AS author_name, b.kind AS author_kind FROM payments p LEFT JOIN bots b ON p.author_type = 'bot' AND b.id = p.author_id";
-export const financeOperationsOver = (context) => {
-    const { database, now } = context;
+/** What invoices, payments and orders share: their parties, who wrote them, and how the owner decides them. */
+export const reviewedRowsOver = (context) => {
+    const { database } = context;
     const partyOf = (type, id) => {
         if (type == null)
             return null;
@@ -86,6 +87,46 @@ export const financeOperationsOver = (context) => {
         createdAt: iso(row.created_at),
         updatedAt: iso(row.updated_at),
     });
+    const written = (input) => {
+        const owner = input.by === "owner";
+        const { actor, model } = authorActor(context, input.by);
+        const source = owner ? "owner" : (text(input.source, "a source", 80) ?? "agent");
+        const reason = owner ? null : text(input.reason, "a reason", 2000);
+        return {
+            owner,
+            actor,
+            model,
+            source,
+            review: owner ? "confirmed" : "proposed",
+            confirmedType: owner ? actor.type : null,
+            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");
+    };
+    const keepDecision = (table, id, by, reason) => {
+        const why = [by === "owner" ? undefined : by.reason.trim(), reason?.trim() || undefined].filter(Boolean).join(": ");
+        if (by === "owner" && !why)
+            return;
+        const decision = by === "owner" ? { by: "owner", reason: why } : { by: "agent", bot: by.bot, reason: why };
+        database
+            .prepare(`UPDATE ${table} SET metadata = json_set(coalesce(metadata, '{}'), '$.decision', json(?)) WHERE id = ?`)
+            .run(JSON.stringify(decision), id);
+    };
+    return { partyOf, partyThing, reviewedOf, written, keepEvidence, ownerOnly, keepDecision };
+};
+export const financeOperationsOver = (context) => {
+    const { database, now } = context;
+    const { partyOf, partyThing, reviewedOf, written, keepEvidence, ownerOnly, keepDecision } = reviewedRowsOver(context);
     const invoiceOf = (row) => {
         const currency = String(row.currency);
         const scale = scaleOf(currency);
@@ -229,41 +270,6 @@ export const financeOperationsOver = (context) => {
             .run(Number(payment.id), Number(invoice.id), units, actor.type, actor.id, at, at);
         return Number(invoice.id);
     };
-    const written = (input) => {
-        const owner = input.by === "owner";
-        const { actor, model } = authorActor(context, input.by);
-        const source = owner ? "owner" : (text(input.source, "a source", 80) ?? "agent");
-        const reason = owner ? null : text(input.reason, "a reason", 2000);
-        return {
-            owner,
-            actor,
-            model,
-            source,
-            review: owner ? "confirmed" : "proposed",
-            confirmedType: owner ? actor.type : null,
-            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");
-    };
-    const keepDecision = (table, id, by, reason) => {
-        const why = [by === "owner" ? undefined : by.reason.trim(), reason?.trim() || undefined].filter(Boolean).join(": ");
-        if (by === "owner" && !why)
-            return;
-        const decision = by === "owner" ? { by: "owner", reason: why } : { by: "agent", bot: by.bot, reason: why };
-        database
-            .prepare(`UPDATE ${table} SET metadata = json_set(coalesce(metadata, '{}'), '$.decision', json(?)) WHERE id = ?`)
-            .run(JSON.stringify(decision), id);
-    };
     /** A proposed payment's allocations count once confirmed; by then other confirmed payments may cover the invoice. */
     const coveredElsewhere = (paymentId) => {
         const over = database

package/dist/store/sqlite/knowledge.js

@@ -150,7 +150,8 @@ export const knowledgeStoreOver = (context) => {
             parsed.type === "event" ||
             parsed.type === "meeting" ||
             parsed.type === "invoice" ||
-            parsed.type === "payment")
+            parsed.type === "payment" ||
+            parsed.type === "order")
             return undefined;
         return { type: parsed.type, id: parsed.id };
     };

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

@@ -5,9 +5,11 @@ import { MAIL_FINDINGS_PER_SENDER, mailFindingFingerprint, validateMailFindings,
 import { findingHash } from "../../meetings/index.js";
 import { assertMayDecide } from "../decisions.js";
 import { MAIL_FINDINGS_KIND } from "../mail-findings.js";
+import { financeOperationsOver } from "./finance.js";
 import { findingsAgent, findingsCoreOver } from "./findings-core.js";
-import { authorActor, memoriesStoreOver } from "./memories.js";
+import { authorActor, linkEvidence, memoriesStoreOver } from "./memories.js";
 import { insertLink, requiredThing } from "./notes.js";
+import { orderOfShop, orderOperationsOver } from "./orders.js";
 import { linkIdentityToPerson } from "./person-links.js";
 import { proposalOperationsOver } from "./proposed-actions.js";
 import { addComment } from "./task-comments.js";
@@ -35,6 +37,8 @@ export const mailFindingsStoreOver = (context) => {
     const core = findingsCoreOver(context, MAIL_FINDINGS_KIND);
     const memories = memoriesStoreOver(context);
     const tasks = workTaskOperationsOver(context);
+    const finance = financeOperationsOver(context);
+    const orders = orderOperationsOver(context);
     const mailbox = (key) => {
         if (key?.provider !== "email" || typeof key.account !== "string" || !key.account.trim())
             return invalid("mail findings belong to one email account");
@@ -135,6 +139,60 @@ export const mailFindingsStoreOver = (context) => {
         }
         return read;
     };
+    /** The invoice, payment or order an accepted finding records: the owner's own entry, citing the mail it came from. */
+    const entry = (finding, evidence) => {
+        const by = "owner";
+        switch (finding.kind) {
+            case "invoice":
+                return () => finance.addInvoice({
+                    by,
+                    evidence,
+                    direction: finding.direction,
+                    counterparty: finding.counterparty,
+                    currency: finding.currency,
+                    lines: finding.lines,
+                    ...(finding.total === undefined ? {} : { total: finding.total }),
+                    ...(finding.number === undefined ? {} : { number: finding.number }),
+                    ...(finding.issueDate === undefined ? {} : { issueDate: finding.issueDate }),
+                    ...(finding.dueDate === undefined ? {} : { dueDate: finding.dueDate }),
+                    ...(finding.project === undefined ? {} : { project: finding.project }),
+                });
+            case "payment":
+                return () => finance.addPayment({
+                    by,
+                    evidence,
+                    direction: finding.direction,
+                    amount: finding.amount,
+                    currency: finding.currency,
+                    date: finding.date,
+                    ...(finding.payer === undefined ? {} : { payer: finding.payer }),
+                    ...(finding.payee === undefined ? {} : { payee: finding.payee }),
+                    ...(finding.reference === undefined ? {} : { reference: finding.reference }),
+                    ...(finding.allocations === undefined ? {} : { allocations: finding.allocations }),
+                    ...(finding.project === undefined ? {} : { project: finding.project }),
+                });
+            case "order": {
+                const { id: _id, kind: _kind, evidence: _cited, reason: _reason, ...fields } = finding;
+                return () => orders.add({ ...fields, by, evidence });
+            }
+            default:
+                return undefined;
+        }
+    };
+    /** Runs what accepting would write and rolls it back, so staging refuses what the owner's accept would refuse. */
+    const ROLLBACK = Symbol("rollback");
+    const wouldWrite = (make) => {
+        try {
+            write(database, () => {
+                make();
+                throw ROLLBACK;
+            });
+        }
+        catch (error) {
+            if (error !== ROLLBACK)
+                throw error;
+        }
+    };
     const identityOfAddress = (address) => database
         .prepare("SELECT i.id, l.person_id FROM identities i LEFT JOIN identity_links l ON l.identity_id = i.id " +
         "WHERE i.provider = 'email' AND lower(i.external_id) = ?")
@@ -163,6 +221,14 @@ export const mailFindingsStoreOver = (context) => {
                 thing(finding.from, "the link's source");
                 thing(finding.to, "the link's target");
                 return;
+            case "invoice":
+            case "payment":
+            case "order":
+                wouldWrite(entry(finding, finding.evidence.map((one) => one.reference)));
+                return;
+            case "order_update":
+                orderOfShop(context, finding.supplierName, finding.number);
+                return;
             case "new_contact": {
                 const ids = finding.evidence.map(({ reference }) => Number(read.get(reference)?.id));
                 const marks = ids.map(() => "?").join(",");
@@ -230,6 +296,20 @@ export const mailFindingsStoreOver = (context) => {
                     database.prepare("UPDATE links SET confirmed = 1, updated_at = ? WHERE id = ?").run(now(), Number(link.id));
                 return `link:${link.id}`;
             }
+            case "invoice":
+            case "payment":
+            case "order":
+                return entry(finding, evidence)().ref;
+            case "order_update": {
+                const order = orderOfShop(context, finding.supplierName, finding.number);
+                orders.setStatus(order, {
+                    status: finding.status,
+                    by: "owner",
+                    ...(finding.date === undefined ? {} : { date: finding.date }),
+                });
+                linkEvidence(context, { type: "order", id: Number(order.slice("order:".length)) }, evidence, "owner");
+                return order;
+            }
             case "new_contact": {
                 const person = Number(identityOfAddress(finding.address)?.person_id);
                 database.prepare("UPDATE persons SET name = ?, updated_at = ? WHERE id = ?").run(finding.name, now(), person);

package/dist/store/sqlite/manifest.js

@@ -65,6 +65,8 @@ export const MANIFEST = [
     { name: "20261102192959_version-47-records", version: 47, minCompatible: 34 },
     { name: "20261102222340_version-48-test-accounts", version: 48, minCompatible: 34 },
     { name: "20261104232153_version-49-relation-amounts", version: 49, minCompatible: 34 },
+    { name: "20261105125314_version-50-orders", version: 50, minCompatible: 34 },
+    { name: "20261105125315_version-50-orders-rules", version: 50, minCompatible: 34 },
 ];
 export const generatedMigrations = (manifest = MANIFEST, generated = GENERATED) => {
     const migrations = [];