@wirecat/cli-core 0.570.0 → 0.572.0

package/CHANGELOG.md

@@ -7,6 +7,37 @@ shape of this file.
 
 ## Unreleased
 
+## 0.572.0 — 05.11.2026
+
+### Changed — may break callers
+
+- **`facts.unconfirm` is now `facts.revoke`**, its refusal reason `fact.unconfirm-correction` is
+  `fact.revoke-correction`, and the step it writes into a fact's `metadata.history` is `revoked`. memo's command is
+  `memo facts revoke`, a word the shared vocabulary has ("take back what was granted"); `unconfirm` is not in it. Nothing
+  called the old names but memo's unreleased command, which moves with this.
+
+## 0.571.0 — 05.11.2026
+
+### Added
+
+- **An imported payment split across invoices settles each by the amount its source gives (store version 49).** A
+  `settles` relation of the v1 records envelope takes an optional `amount`, a decimal in the payment's currency,
+  kept in `record_relations.amount`. Additive within schema version 1: an older build refuses such a relation with
+  `record.invalid` rather than reading it wrongly. Amounts that add up to more than the payment are refused with
+  `record.over-payment` at `/records/<n>/relations/<m>/amount`; an amount on another role with `record.invalid`.
+- **`store.finance.unallocate({ payment, invoice, by })` takes one allocation back** from a payment still proposed,
+  under `allocate`'s rule (the owner any, a bot only its own); a confirmed payment's allocations stay
+  (`finance.unallocate`), and a missing one is `not_found` (`finance.not-allocated`).
+
+### Fixed
+
+- **One import can no longer over-cover an invoice.** A `settles` relation without an amount now takes only what other
+  payments, confirmed or still proposed, leave open on the invoice; before, every proposed payment of a batch saw the
+  whole invoice open, and the owner's confirm then failed with `finance.over-invoice`.
+- **A changed import updates the allocations of a payment the import proposed and the owner has not decided.** Its
+  allocations follow the record's `settles` relations again; it is `flagged` only when more than those changed, or
+  once the owner confirmed or rejected it.
+
 ## 0.570.0 — 05.11.2026
 
 ### Added

package/dist/domain/records.d.ts

@@ -9,6 +9,8 @@ export interface RecordRelation {
     role: string;
     type: string;
     external_id: string;
+    /** A `settles` relation's share of the payment, as a decimal in its currency; without one, as far as both allow. */
+    amount?: string;
 }
 export interface EnvelopeRecord {
     /** The caller's name for this line, unique in the envelope; the receipt cites it. */
@@ -143,6 +145,11 @@ export declare const RECORDS_ENVELOPE_SCHEMA: {
                     readonly minLength: 1;
                     readonly maxLength: 512;
                 };
+                readonly amount: {
+                    readonly type: "string";
+                    readonly pattern: "^[0-9]{1,16}(\\.[0-9]{1,6})?$";
+                    readonly description: "A settles relation's share of the payment, a decimal in its currency";
+                };
             };
         };
     };

package/dist/domain/records.js

@@ -9,6 +9,7 @@ const TYPE = "^(invoice|payment|person|organization|project|custom:[a-z0-9][a-z0
 const MAX_ID = 512;
 const MAX_FIELDS_BYTES = 65_536;
 const MAX_RELATIONS = 100;
+const DECIMAL = "^[0-9]{1,16}(\\.[0-9]{1,6})?$";
 /** The v1 envelope as JSON Schema (Draft 2020-12); `schemas/records-envelope.v1.schema.json` is this, written out. */
 export const RECORDS_ENVELOPE_SCHEMA = {
     $schema: "https://json-schema.org/draft/2020-12/schema",
@@ -59,12 +60,18 @@ export const RECORDS_ENVELOPE_SCHEMA = {
                 role: { type: "string", pattern: WORD },
                 type: { type: "string", pattern: TYPE },
                 external_id: { type: "string", minLength: 1, maxLength: MAX_ID },
+                amount: {
+                    type: "string",
+                    pattern: DECIMAL,
+                    description: "A settles relation's share of the payment, a decimal in its currency",
+                },
             },
         },
     },
 };
 const wordPattern = new RegExp(WORD);
 const typePattern = new RegExp(TYPE);
+const decimalPattern = new RegExp(DECIMAL);
 const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const escapePointer = (segment) => String(segment).replaceAll("~", "~0").replaceAll("/", "~1");
 export const pointerOf = (...segments) => segments.map((s) => `/${escapePointer(s)}`).join("");
@@ -102,15 +109,19 @@ const relationErrors = (relations, at) => {
         const here = [...at, index];
         if (!isObject(relation))
             return [invalid(here, "a relation is an object")];
-        const extra = extraKeys(relation, ["role", "type", "external_id"]);
+        const extra = extraKeys(relation, ["role", "type", "external_id", "amount"]);
         if (extra.length > 0)
-            return [invalid([...here, extra[0]], "a relation holds role, type and external_id")];
+            return [invalid([...here, extra[0]], "a relation holds role, type, external_id and amount")];
         if (typeof relation.role !== "string" || !wordPattern.test(relation.role))
             return [invalid([...here, "role"], "a role is lowercase letters, digits, - and _")];
         if (typeof relation.type !== "string" || !typePattern.test(relation.type))
             return [invalid([...here, "type"], `a type is one of ${RECORD_ENTITY_TYPES.join(", ")} or custom:<name>`)];
         if (!idText(relation.external_id))
             return [invalid([...here, "external_id"], `an external id takes 1–${MAX_ID} characters`)];
+        if (relation.amount !== undefined && (typeof relation.amount !== "string" || !decimalPattern.test(relation.amount)))
+            return [invalid([...here, "amount"], 'an amount is a decimal string, such as "13000.00"')];
+        if (relation.amount !== undefined && relation.role !== "settles")
+            return [invalid([...here, "amount"], "only a settles relation carries an amount")];
         return [];
     });
 };
@@ -202,7 +213,13 @@ export const recordFingerprint = (fields, relations) => createHash("sha256")
     .update(JSON.stringify(canonical({
     fields,
     relations: relations
-        .map((relation) => [relation.role, relation.type, relation.external_id])
+        // A relation without an amount keeps the fingerprint it had before amounts existed.
+        .map((relation) => [
+        relation.role,
+        relation.type,
+        relation.external_id,
+        ...(relation.amount === undefined ? [] : [relation.amount]),
+    ])
         .sort((a, b) => a.join("\0").localeCompare(b.join("\0"))),
 })))
     .digest("hex");

package/dist/errors/reasons.js

@@ -164,15 +164,16 @@ 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.not-accepted", "only an accepted fact can be unconfirmed"),
-    validation("fact.owner-written", "the owner wrote this fact; it was never proposed, so it cannot be unconfirmed"),
+    validation("fact.not-accepted", "only an accepted fact can be revoked"),
+    validation("fact.owner-written", "the owner wrote this fact; it was never proposed, so it cannot be revoked"),
     validation("fact.payment-retired", "a payment is a payments row in store.finance, not a fact"),
-    validation("fact.unconfirm-correction", "an accepted correction cannot be unconfirmed; its superseded fact stays"),
+    validation("fact.revoke-correction", "an accepted correction cannot be revoked; its superseded fact stays"),
     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"),
     validation("finance.line-amount", "the line's amount is not its quantity times its unit price"),
     validation("finance.lines", "the invoice's lines are not valid"),
+    ["finance.not-allocated", "not_found", "the payment is not allocated to that invoice"],
     validation("finance.over-invoice", "the allocation would settle more than the invoice's total"),
     validation("finance.over-payment", "the allocation would use more than the payment's amount"),
     ["finance.owner-only", "permission_error", "only the owner does this with money"],
@@ -180,10 +181,12 @@ const OTHERS = [
     validation("finance.ref", "the reference names no invoice or payment"),
     validation("finance.status", "the invoice's status does not allow this"),
     validation("finance.total", "the invoice's total is not the sum of its lines"),
+    validation("finance.unallocate", "only a proposed payment's allocations are taken back"),
     validation("record.entity", "the invoice or payment the record stands for was refused"),
     ["record.map-owner-only", "permission_error", "only the owner says which entity a source record is"],
     validation("record.map-type", "a record maps only to an entity of its own type"),
     validation("record.mapped", "the record already stands for another entity"),
+    validation("record.over-payment", "the record's settles amounts add up to more than the payment"),
     validation("record.not-found", "the store holds no such record to delete"),
     validation("record.invalid", "a field of the record is not the kind the entity needs"),
     validation("record.reference-not-found", "a reference in the record's fields is not in the store"),

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

@@ -74,7 +74,7 @@ export interface FactsStore {
      * The owner takes back the approval of an accepted fact an agent proposed: it waits as `proposed` again. The step is
      * kept in `metadata.history`, with the decision it took back.
      */
-    unconfirm(reference: string, by: Decider, reason?: string): Promise<Fact>;
+    revoke(reference: string, by: Decider, reason?: string): Promise<Fact>;
     /** The owner, or an agent for the owner, turns down a proposed fact; it stays, marked `rejected`. */
     reject(reference: string, by: Decider, reason?: string): Promise<Fact>;
     /**

package/dist/store/sqlite/facts.js

@@ -154,24 +154,24 @@ export const factOperationsOver = (context) => {
             database.prepare("UPDATE facts SET status = 'reversed', updated_at = ? WHERE id = ?").run(now(), Number(row.id));
             return factOf(rowOf(reference));
         },
-        unconfirm: (reference, by, reason) => {
+        revoke: (reference, by, reason) => {
             const row = rowOf(reference);
             const ref = `fact:${row.id}`;
             assertMayWithdraw({ id: ref, proposedBy: { type: "unknown" }, proposed: false }, by);
             write(database, () => {
                 const current = database.prepare("SELECT * FROM facts WHERE id = ?").get(Number(row.id));
                 if (current.status !== "accepted")
-                    throw new CliError("validation_error", `only an accepted fact can be unconfirmed; ${ref} is ${String(current.status)}`, { reason: "fact.not-accepted" });
+                    throw new CliError("validation_error", `only an accepted fact can be revoked; ${ref} is ${String(current.status)}`, { reason: "fact.not-accepted" });
                 if (current.author_type === "person")
                     throw new CliError("validation_error", `${ref} is the owner's own fact, never proposed; correct it with a fact that supersedes it, or remove it`, { reason: "fact.owner-written" });
                 // Accepting it marked the fact it corrects superseded, and what that one was before is not kept.
                 if (current.supersedes_id != null)
                     throw new CliError("validation_error", `${ref} corrects fact:${current.supersedes_id}, which stopped holding when ${ref} was accepted; ` +
-                        "remove it or correct it with another fact instead", { reason: "fact.unconfirm-correction" });
+                        "remove it or correct it with another fact instead", { reason: "fact.revoke-correction" });
                 const at = now();
                 const { decision, history, ...metadata } = (current.metadata == null ? {} : JSON.parse(String(current.metadata)));
                 const step = {
-                    step: "unconfirmed",
+                    step: "revoked",
                     by: "owner",
                     at: iso(at),
                     confirmedBy: { type: current.confirmed_by_type, id: String(current.confirmed_by_id) },
@@ -236,7 +236,7 @@ export const factsStoreOver = (context) => {
         list: async (options) => operations.list(options),
         accept: async (reference, by, reason) => operations.accept(reference, by, reason),
         reverse: async (reference, by) => operations.reverse(reference, by),
-        unconfirm: async (reference, by, reason) => operations.unconfirm(reference, by, reason),
+        revoke: async (reference, by, reason) => operations.revoke(reference, by, reason),
         reject: async (reference, by, reason) => operations.reject(reference, by, reason),
         remove: async (reference, by) => operations.remove(reference, by),
         sources: async (reference) => operations.sources(reference),

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

@@ -180,6 +180,15 @@ export interface FinanceStore {
         amount: string;
         by: Author;
     }): Promise<Allocation>;
+    /**
+     * Takes one allocation back from a payment still proposed, under the same rule as `allocate`. A confirmed payment's
+     * allocations are decided money and stay.
+     */
+    unallocate(input: {
+        payment: string;
+        invoice: string;
+        by: Author;
+    }): Promise<PaymentDetail>;
     /**
      * The owner confirms a proposed `invoice:` or `payment:`; only the owner decides money. A payment whose allocations
      * would settle more than an invoice's total, given the confirmed payments by then, is refused and stays proposed.

package/dist/store/sqlite/finance.js

@@ -319,6 +319,13 @@ export const financeOperationsOver = (context) => {
         });
         return type === "invoice" ? invoiceDetail(ref) : paymentDetail(ref);
     };
+    const mayAllocate = (row, by) => {
+        if (by === "owner")
+            return;
+        const own = row.author_type === "bot" && row.author_name != null && botKey(String(row.author_name)) === botKey(by.bot);
+        if (row.review !== "proposed" || !own)
+            refuse(`only the owner allocates payment:${row.id}; a bot allocates only from a payment it proposed that is still proposed`, "finance.owner-only", "permission_error");
+    };
     const limitOf = (limit) => Math.min(Math.max(limit ?? 100, 1), 500);
     return {
         addInvoice: (input) => {
@@ -474,11 +481,7 @@ export const financeOperationsOver = (context) => {
         allocate: ({ payment, invoice, amount, by }) => {
             const row = rowOf(payment, "payment");
             const ref = `payment:${row.id}`;
-            if (by !== "owner") {
-                const own = row.author_type === "bot" && row.author_name != null && botKey(String(row.author_name)) === botKey(by.bot);
-                if (row.review !== "proposed" || !own)
-                    refuse(`only the owner allocates ${ref}; a bot allocates only from a payment it proposed that is still proposed`, "finance.owner-only", "permission_error");
-            }
+            mayAllocate(row, by);
             if (row.review === "rejected" || row.deleted_at != null)
                 refuse(`${ref} is ${String(row.review)}`, "finance.allocate");
             const currency = String(row.currency);
@@ -494,6 +497,26 @@ export const financeOperationsOver = (context) => {
             const found = allocationsWhere("payment_id", Number(row.id)).find((one) => one.invoice === `invoice:${invoiceId}`);
             return found;
         },
+        unallocate: ({ payment, invoice, by }) => {
+            const row = rowOf(payment, "payment");
+            const ref = `payment:${row.id}`;
+            mayAllocate(row, by);
+            if (row.review !== "proposed" || row.deleted_at != null)
+                refuse(`${ref} is ${row.deleted_at != null ? "deleted" : String(row.review)}; only a proposed payment's ` +
+                    "allocations are taken back", "finance.unallocate");
+            const target = rowOf(invoice, "invoice");
+            write(database, () => {
+                const gone = database
+                    .prepare("DELETE FROM payment_allocations WHERE payment_id = ? AND invoice_id = ?")
+                    .run(Number(row.id), Number(target.id));
+                if (gone.changes === 0)
+                    throw new CliError("not_found", `${ref} is not allocated to invoice:${target.id}`, {
+                        reason: "finance.not-allocated",
+                    });
+                settle(Number(target.id));
+            });
+            return paymentDetail(ref);
+        },
         confirm: (reference, by, reason) => decide(reference, by, reason, true),
         reject: (reference, by, reason) => decide(reference, by, reason, false),
         openTotals: (filter = {}) => {
@@ -522,6 +545,7 @@ export const financeStoreOver = (context) => {
         payment: async (reference) => operations.payment(reference),
         payments: async (filter) => operations.payments(filter),
         allocate: async (input) => operations.allocate(input),
+        unallocate: async (input) => operations.unallocate(input),
         confirm: async (reference, by, reason) => operations.confirm(reference, by, reason),
         reject: async (reference, by, reason) => operations.reject(reference, by, reason),
         openTotals: async (filter) => operations.openTotals(filter),

package/dist/store/sqlite/manifest.js

@@ -64,6 +64,7 @@ export const MANIFEST = [
     { name: "20261102185954_version-46-payment-facts", version: 46, minCompatible: 34 },
     { 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 },
 ];
 export const generatedMigrations = (manifest = MANIFEST, generated = GENERATED) => {
     const migrations = [];

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

@@ -948,5 +948,11 @@ export const GENERATED = [
         "statements": [
             "-- Tests wrote the fake `chat` messenger of src/testing/shared-program.ts into real stores until a test could no longer\n-- open one (#2438). Deleting an account is the store's own purge, in code (every child row, the people only it saw,\n-- the vectors only it held), so the next writable open removes every `chat` account and deletes this key\n-- (purgeTestAccounts). A store without one gets no key, so a test's own `chat` rows written after this stay.\nINSERT OR REPLACE INTO store_settings (key, value, at)\nSELECT 'test_accounts_to_purge', '1', unixepoch() * 1000 WHERE EXISTS (SELECT 1 FROM accounts WHERE provider = 'chat');"
         ]
+    },
+    {
+        "name": "20261104232153_version-49-relation-amounts",
+        "statements": [
+            "ALTER TABLE `record_relations` ADD `amount` text;"
+        ]
     }
 ];

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

@@ -15,6 +15,7 @@ export interface SourceRecord extends RecordKey {
         role: string;
         type: string;
         externalId: string;
+        amount: string | null;
         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. */

package/dist/store/sqlite/records.js

@@ -23,6 +23,8 @@ const codeOf = (error) => {
         return reason;
     return error.code === "not_found" ? "record.reference-not-found" : "record.entity";
 };
+/** A record's fingerprint without its settles relations: what an import may not change on a payment it proposed. */
+const unsettled = (fields, relations) => recordFingerprint(fields, relations.filter((relation) => relation.role !== "settles"));
 const iso = (value) => new Date(Number(value)).toISOString();
 const stringField = (fields, name) => {
     const value = fields[name];
@@ -87,12 +89,13 @@ export const recordStoreOver = (context) => {
         return statement;
     };
     const entityRef = (type, id) => type == null ? null : (referenceOfThing(database, storedThing(type, id)) ?? `${String(type)}:${String(id)}`);
-    /** Roles a projection needs whose target has no entity yet, and the entities of the rest. */
+    /** Roles a projection needs whose target has no entity yet, the entities of the rest, and what each invoice gets. */
     const relatedOf = (recordId, type) => {
         const { roles, many } = PROJECTED[type];
-        const rows = sql("SELECT rr.role, t.entity_type, t.entity_id FROM record_relations rr " +
-            "LEFT JOIN records t ON t.id = rr.target_id AND t.deleted_at IS NULL WHERE rr.record_id = ?").all(recordId);
+        const rows = sql("SELECT rr.role, rr.amount, t.entity_type, t.entity_id FROM record_relations rr " +
+            "LEFT JOIN records t ON t.id = rr.target_id AND t.deleted_at IS NULL WHERE rr.record_id = ? ORDER BY rr.id").all(recordId);
         const related = new Map();
+        const shares = [];
         const missing = new Set();
         for (const row of rows) {
             const role = String(row.role);
@@ -103,41 +106,106 @@ export const recordStoreOver = (context) => {
                 missing.add(role);
             else
                 related.set(role, [...(related.get(role) ?? []), ref]);
+            if (ref !== null && role === "settles")
+                shares.push({ invoice: ref, amount: row.amount == null ? null : String(row.amount) });
         }
         for (const [role, refs] of related)
             if (refs.length > 1 && !many.includes(role))
                 refusal(`a record has one ${role}`, "record.relation-ambiguous");
-        return { related, missing: [...missing] };
+        return { related, shares, missing: [...missing] };
     };
     /** Makes the proposal a waiting invoice or payment record stands for, once every reference it names has an entity. */
     const project = (row, source) => {
         const type = row.type;
-        const { related, missing } = relatedOf(Number(row.id), type);
+        const { related, shares, missing } = relatedOf(Number(row.id), type);
         if (missing.length > 0)
             return { missing };
         const fields = JSON.parse(String(row.fields));
         for (const name of REFERENCE_FIELDS)
             stringField(fields, name);
-        const ref = type === "invoice" ? finance.addInvoice(invoiceOf(fields, related, source)).ref : settle(fields, related, source);
+        const ref = type === "invoice"
+            ? finance.addInvoice(invoiceOf(fields, related, source)).ref
+            : settle(finance.addPayment(paymentOf(fields, related, source)), shares);
         const entity = requiredThing(database, ref);
         sql("UPDATE records SET entity_type = ?, entity_id = ?, projected_fingerprint = fingerprint WHERE id = ?").run(entity.type, entity.id, Number(row.id));
         return { proposed: ref, missing: [] };
     };
-    /** A payment settles each invoice it names as far as both allow, in the order named. */
-    const settle = (fields, related, source) => {
-        const made = finance.addPayment(paymentOf(fields, related, source));
+    /**
+     * What other payments leave open on an invoice. Proposed ones count too: the owner confirms them later, so payments
+     * of one batch would otherwise each take the whole invoice.
+     */
+    const freeOn = (invoice, payment) => {
+        const [target, own] = [requiredThing(database, invoice), requiredThing(database, payment)];
+        const row = sql("SELECT i.total - (SELECT coalesce(sum(a.amount), 0) FROM payment_allocations a JOIN payments p ON p.id = " +
+            "a.payment_id WHERE a.invoice_id = i.id AND a.payment_id <> ? AND p.deleted_at IS NULL " +
+            "AND p.review <> 'rejected') AS free FROM invoices i WHERE i.id = ?").get(own.id, target.id);
+        return Number(row?.free ?? 0);
+    };
+    /** A payment settles each invoice it names by the amount the source gives, then the rest as far as both allow. */
+    const settle = (made, shares) => {
         const units = (amount) => minorUnits(amount, made.currency);
         let left = units(made.unallocated);
-        for (const invoice of related.get("settles") ?? []) {
-            const share = Math.min(left, units(finance.invoice(invoice).open));
+        const given = shares.filter((one) => one.amount !== null);
+        for (const { invoice, amount } of [...given, ...shares.filter((one) => one.amount === null)]) {
+            const share = amount === null ? Math.min(left, freeOn(invoice, made.ref)) : units(amount);
             if (share <= 0)
                 continue;
-            const amount = formatDecimal(share, scaleOf(made.currency));
-            finance.allocate({ payment: made.ref, invoice, amount, by: IMPORTER });
+            finance.allocate({
+                payment: made.ref,
+                invoice,
+                amount: formatDecimal(share, scaleOf(made.currency)),
+                by: IMPORTER,
+            });
             left -= share;
         }
         return made.ref;
     };
+    /** A payment the import proposed and the owner has not decided yet takes its record's settles relations again. */
+    const resettle = (recordId, ref) => {
+        const payment = finance.payment(ref);
+        if (payment.review !== "proposed" || payment.author.type !== "bot" || payment.author.name !== IMPORTER.bot)
+            return false;
+        for (const { invoice } of payment.allocations)
+            finance.unallocate({ payment: ref, invoice, by: IMPORTER });
+        settle(finance.payment(ref), relatedOf(recordId, "payment").shares);
+        return true;
+    };
+    /** The settles amounts a payment record gives, refused at the first one that is not money or goes past the payment. */
+    const checkShares = (record) => {
+        const relations = record.relations ?? [];
+        if (record.type !== "payment" || !relations.some((relation) => relation.amount !== undefined))
+            return;
+        const fields = record.fields ?? {};
+        if (typeof fields.currency !== "string")
+            return;
+        const currency = fields.currency;
+        let left;
+        try {
+            left = minorUnits(fields.amount, currency);
+        }
+        catch {
+            return;
+        }
+        for (const [index, { amount }] of relations.entries()) {
+            if (amount === undefined)
+                continue;
+            const at = ["relations", index, "amount"];
+            let units = 0;
+            try {
+                units = minorUnits(amount, currency, "a settles amount");
+            }
+            catch (error) {
+                if (!(error instanceof CliError))
+                    throw error;
+                refusal(error.message, codeOf(error), at);
+            }
+            if (units <= 0)
+                refusal("a settles amount is more than 0", "money.amount", at);
+            left -= units;
+            if (left < 0)
+                refusal(`the settles amounts add up to more than the payment's ${String(fields.amount)} ${currency}`, "record.over-payment", at);
+        }
+    };
     /** Records that waited on `target` and may now have their entity, and theirs in turn. */
     const completeDependents = (target, source, proposed, laterErrors) => {
         const queue = [target];
@@ -164,11 +232,19 @@ export const recordStoreOver = (context) => {
             }
         }
     };
+    const storedRelations = (recordId) => sql("SELECT role, target_type, target_external_id FROM record_relations WHERE record_id = ?")
+        .all(recordId)
+        .map((row) => ({
+        role: String(row.role),
+        type: String(row.target_type),
+        external_id: String(row.target_external_id),
+    }));
     const relate = (recordId, accountId, relations, at) => {
         sql("DELETE FROM record_relations WHERE record_id = ?").run(recordId);
         for (const relation of relations)
-            sql("INSERT OR IGNORE INTO record_relations (record_id, role, target_type, target_external_id, target_id, created_at) " +
-                "VALUES (?, ?, ?, ?, (SELECT id FROM records WHERE account_id = ? AND type = ? AND external_id = ?), ?)").run(recordId, relation.role, relation.type, relation.external_id, accountId, relation.type, relation.external_id, at);
+            sql("INSERT OR IGNORE INTO record_relations (record_id, role, target_type, target_external_id, target_id, " +
+                "created_at, amount) VALUES (?, ?, ?, ?, (SELECT id FROM records WHERE account_id = ? AND type = ? " +
+                "AND external_id = ?), ?, ?)").run(recordId, relation.role, relation.type, relation.external_id, accountId, relation.type, relation.external_id, at, relation.amount ?? null);
     };
     const writeOne = (accountId, source, { record }, proposed) => {
         const stored = sql("SELECT * FROM records WHERE account_id = ? AND type = ? AND external_id = ?").get(accountId, record.type, record.external_id);
@@ -197,6 +273,12 @@ export const recordStoreOver = (context) => {
         const fields = JSON.stringify(record.fields);
         if (stored && stored.fingerprint === fingerprint && stored.deleted_at == null)
             return { status: "unchanged", id: Number(stored.id) };
+        checkShares(record);
+        // Whether the payment the record stands for differs in more than whom it settles, against the stored version.
+        const beyondSettles = stored?.entity_id != null &&
+            (stored.projected_fingerprint !== stored.fingerprint ||
+                unsettled(JSON.parse(String(stored.fields)), storedRelations(Number(stored.id))) !==
+                    unsettled(record.fields ?? {}, relations));
         const id = stored
             ? Number(stored.id)
             : Number(sql("INSERT INTO records (account_id, type, external_id, fields, revision, fingerprint, batch_id, created_at, " +
@@ -210,16 +292,27 @@ export const recordStoreOver = (context) => {
                 "AND record_id IN (SELECT id FROM records WHERE account_id = ?)").run(id, record.type, record.external_id, accountId);
         relate(id, accountId, relations, time);
         let projected = false;
+        let flagged = stored?.entity_id != null && stored.projected_fingerprint !== fingerprint;
         if (isProjected(record.type) && stored?.entity_id == null) {
             const done = project({ id, type: record.type, fields, account_id: accountId }, source);
             if (done.proposed)
                 proposed.push(done.proposed);
             projected = done.proposed !== undefined;
         }
+        else if (record.type === "payment" && stored?.entity_type === "payment" && stored.deleted_at == null) {
+            const ref = `payment:${Number(stored.entity_id)}`;
+            if (resettle(id, ref)) {
+                proposed.push(ref);
+                if (!beyondSettles) {
+                    sql("UPDATE records SET projected_fingerprint = fingerprint WHERE id = ?").run(id);
+                    flagged = false;
+                }
+            }
+        }
         return {
             status: stored ? "updated" : "created",
             id,
-            flagged: stored?.entity_id != null && stored.projected_fingerprint !== fingerprint,
+            flagged,
             // Records waiting on this one move only when it has an entity: made now, or back from a delete.
             complete: projected || (stored?.deleted_at != null && stored.entity_id != null),
         };
@@ -265,7 +358,7 @@ export const recordStoreOver = (context) => {
                         if (!(error instanceof CliError))
                             throw error;
                         const at = error.details?.at ?? "fields";
-                        const pointer = pointerOf("records", item.index, at);
+                        const pointer = pointerOf("records", item.index, ...[at].flat());
                         outcomes.push({
                             index: item.index,
                             key: item.record.key,
@@ -292,12 +385,14 @@ export const recordStoreOver = (context) => {
         fields: JSON.parse(String(row.fields)),
         revision: row.revision == null ? null : Number(row.revision),
         fingerprint: String(row.fingerprint),
-        relations: sql("SELECT role, target_type, target_external_id, target_id FROM record_relations WHERE record_id = ? ORDER BY id")
+        relations: sql("SELECT role, target_type, target_external_id, target_id, amount FROM record_relations WHERE record_id = ? " +
+            "ORDER BY id")
             .all(Number(row.id))
             .map((relation) => ({
             role: String(relation.role),
             type: String(relation.target_type),
             externalId: String(relation.target_external_id),
+            amount: relation.amount == null ? null : String(relation.amount),
             resolved: relation.target_id != null,
         })),
         entity: entityRef(row.entity_type, row.entity_id),

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

@@ -15239,6 +15239,22 @@ export declare const recordRelations: import("drizzle-orm/sqlite-core").SQLiteTa
             identity: undefined;
             generated: undefined;
         }, {}>;
+        amount: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "record_relations";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
     };
     dialect: 'sqlite';
     isAlias: false;

package/dist/store/sqlite/schema.js

@@ -1524,6 +1524,7 @@ export const recordRelations = sqliteTable("record_relations", {
     targetExternalId: text("target_external_id").notNull(),
     targetId: integer("target_id").references(() => records.id),
     createdAt: integer("created_at").notNull(),
+    amount: text("amount"),
 }, (table) => [
     unique().on(table.recordId, table.role, table.targetType, table.targetExternalId),
     index("record_relations_by_target_type_target_external_id").on(table.targetType, table.targetExternalId),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.570.0",
+  "version": "0.572.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/schemas/records-envelope.v1.schema.json

@@ -101,6 +101,11 @@
           "type": "string",
           "minLength": 1,
           "maxLength": 512
+        },
+        "amount": {
+          "type": "string",
+          "pattern": "^[0-9]{1,16}(\\.[0-9]{1,6})?$",
+          "description": "A settles relation's share of the payment, a decimal in its currency"
         }
       }
     }