@wirecat/cli-core 0.574.0 → 0.576.0

package/dist/mail/newsletter.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Mail sent to many is often an order, an invoice or a site's lead form that carries List-Unsubscribe. This tells a
+ * newsletter from it by words in the subject and the first lines, so a holder can leave out only what is surely a
+ * newsletter and give the rest to its agent as an excerpt. No model: it runs on every read past a mark.
+ */
+/** Words that say "advertising"; each matches at the start of a word, any case. */
+export declare const NEWSLETTER_WORDS: readonly ["скидк", "акци", "распродаж", "вебинар", "рассылк", "промокод", "спецпредложени", "дайджест", "новинк", "подборк", "кешбэк", "кэшбэк", "только сегодня", "успейте", "чёрная пятница", "черная пятница", "выгодн", "newsletter", "unsubscribe", "% off", "sale", "discount", "webinar", "digest", "weekly", "promo", "deal", "limited time", "free shipping", "new arrivals", "black friday", "cyber monday", "coupon", "save up to", "last chance", "don't miss", "descuento", "oferta", "rebaja", "boletín", "seminario web", "novedades", "promoción", "no te pierdas", "últimos días"];
+/** Parts of a sender's address that say "a newsletter": `news@…`, `newsletter.example.com`, `….substack.com`. */
+export declare const NEWSLETTER_SENDERS: readonly ["news", "newsletter", "newsletters", "digest", "weekly", "promo", "marketing", "offers", "deals", "sale", "substack.com"];
+/** Words that say "this is about something of yours"; one of them keeps the email for the agent. */
+export declare const ORDER_WORDS: readonly ["заказ", "счёт", "счет на", "счета", "оплат", "квитанци", "кассовый чек", "электронный чек", "заявк", "форма", "доставк", "трек", "договор", "подтвержд", "код подтверждения", "код для входа", "пароль", "order", "invoice", "receipt", "payment", "shipped", "delivery", "tracking", "booking", "reservation", "confirm", "your account", "verification", "password", "refund", "statement", "pedido", "factura", "recibo", "pago", "envío", "reserva", "confirmación", "contraseña"];
+export interface NewsletterCues {
+    newsletterWords: readonly string[];
+    newsletterSenders: readonly string[];
+    orderWords: readonly string[];
+    /** The score from which an email is surely a newsletter and left out. */
+    threshold: number;
+    /** How much of the email's own text is read, and shown as the excerpt. */
+    excerptChars: number;
+}
+export declare const NEWSLETTER_DEFAULTS: NewsletterCues;
+export interface BulkSorted {
+    /** `newsletter` is left out; `excerpt` goes to the agent as the subject and the first lines. */
+    verdict: "newsletter" | "excerpt";
+    score: number;
+    /** What decided it: the newsletter signs, or what kept the email. */
+    cues: string[];
+    excerpt: string;
+}
+/** The first lines of an email's own text, at most `chars`, cut at a word. */
+export declare const excerptOf: (text: string, chars: number) => string;
+/**
+ * Built once per read, so the word lists compile once. A reply, an order word in the subject or an order's number
+ * keeps the email. Otherwise a newsletter word counts 2 in the subject and 1 in the first lines, a newsletter's
+ * address 2, an emoji in the subject and a browser or unsubscribe link at the top 1 each, and each order word in
+ * the first lines takes 2 off. Measured 2026-11-05 on 30 days of the owner's bulk mail: 99 of 100 sampled
+ * newsletter verdicts were newsletters, and about half of the newsletters were found.
+ */
+export declare const newsletterSorter: (cues?: NewsletterCues) => ({ subject, text, from }: {
+    subject: string | null;
+    text: string;
+    from: string | null;
+}) => BulkSorted;
+/** How a holder's read treats bulk mail. */
+export interface BulkTriage {
+    /** `false` leaves every bulk email out, newsletter or not. */
+    excerpts: boolean;
+    /** At most this many excerpts in one read; the read ends before the next one, which comes with the next read. */
+    perRead: number;
+    cues: NewsletterCues;
+}
+export declare const BULK_TRIAGE_DEFAULTS: BulkTriage;

package/dist/mail/newsletter.js

@@ -0,0 +1,189 @@
+/**
+ * Mail sent to many is often an order, an invoice or a site's lead form that carries List-Unsubscribe. This tells a
+ * newsletter from it by words in the subject and the first lines, so a holder can leave out only what is surely a
+ * newsletter and give the rest to its agent as an excerpt. No model: it runs on every read past a mark.
+ */
+/** Words that say "advertising"; each matches at the start of a word, any case. */
+export const NEWSLETTER_WORDS = [
+    "скидк",
+    "акци",
+    "распродаж",
+    "вебинар",
+    "рассылк",
+    "промокод",
+    "спецпредложени",
+    "дайджест",
+    "новинк",
+    "подборк",
+    "кешбэк",
+    "кэшбэк",
+    "только сегодня",
+    "успейте",
+    "чёрная пятница",
+    "черная пятница",
+    "выгодн",
+    "newsletter",
+    "unsubscribe",
+    "% off",
+    "sale",
+    "discount",
+    "webinar",
+    "digest",
+    "weekly",
+    "promo",
+    "deal",
+    "limited time",
+    "free shipping",
+    "new arrivals",
+    "black friday",
+    "cyber monday",
+    "coupon",
+    "save up to",
+    "last chance",
+    "don't miss",
+    "descuento",
+    "oferta",
+    "rebaja",
+    "boletín",
+    "seminario web",
+    "novedades",
+    "promoción",
+    "no te pierdas",
+    "últimos días",
+];
+/** Parts of a sender's address that say "a newsletter": `news@…`, `newsletter.example.com`, `….substack.com`. */
+export const NEWSLETTER_SENDERS = [
+    "news",
+    "newsletter",
+    "newsletters",
+    "digest",
+    "weekly",
+    "promo",
+    "marketing",
+    "offers",
+    "deals",
+    "sale",
+    "substack.com",
+];
+/** Words that say "this is about something of yours"; one of them keeps the email for the agent. */
+export const ORDER_WORDS = [
+    "заказ",
+    "счёт",
+    "счет на",
+    "счета",
+    "оплат",
+    "квитанци",
+    "кассовый чек",
+    "электронный чек",
+    "заявк",
+    "форма",
+    "доставк",
+    "трек",
+    "договор",
+    "подтвержд",
+    "код подтверждения",
+    "код для входа",
+    "пароль",
+    "order",
+    "invoice",
+    "receipt",
+    "payment",
+    "shipped",
+    "delivery",
+    "tracking",
+    "booking",
+    "reservation",
+    "confirm",
+    "your account",
+    "verification",
+    "password",
+    "refund",
+    "statement",
+    "pedido",
+    "factura",
+    "recibo",
+    "pago",
+    "envío",
+    "reserva",
+    "confirmación",
+    "contraseña",
+];
+/** A number an order, an invoice or a request is known by, after the word that names it. */
+const REFERENCE_NUMBER = /(?<![\p{L}])(?:заказ|заявк|сч[её]т|квитанци|order|invoice|ticket|pedido|factura)\p{L}*\s*(?:№|#|n[o°]\.?)?\s?\d{3,}/iu;
+/** The top of a newsletter: a link to read it in a browser, or to leave the list. */
+const NEWSLETTER_TOP = /в браузере|веб-верси|view (?:it |this email )?(?:in|on) (?:your |a )?browser|unsubscribe|отписаться|darse de baja|ver en (?:el )?navegador/iu;
+const PICTOGRAPH = /\p{Extended_Pictographic}/u;
+/** A reply or a forward is a conversation, whatever it says. */
+const REPLY = /^\s*(?:re|fw|fwd|aw|wg|ответ|отв|rv|res)\s*(?:\[\d+\])?\s*:/iu;
+export const NEWSLETTER_DEFAULTS = {
+    newsletterWords: NEWSLETTER_WORDS,
+    newsletterSenders: NEWSLETTER_SENDERS,
+    orderWords: ORDER_WORDS,
+    threshold: 2,
+    excerptChars: 400,
+};
+const escaped = (word) => word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const matcherOf = (words) => {
+    const list = words.map((word) => word.trim().toLowerCase()).filter(Boolean);
+    if (list.length === 0)
+        return () => [];
+    const pattern = new RegExp(`(?<![\\p{L}\\p{N}])(?:${list.map(escaped).join("|")})`, "giu");
+    return (text) => [...new Set([...text.toLowerCase().matchAll(pattern)].map(([found]) => found))];
+};
+/** The first lines of an email's own text, at most `chars`, cut at a word. */
+export const excerptOf = (text, chars) => {
+    const flat = text
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .join("\n");
+    if (flat.length <= chars)
+        return flat;
+    const cut = flat.slice(0, chars);
+    const space = cut.search(/\s\S*$/);
+    return `${space > chars / 2 ? cut.slice(0, space) : cut}…`;
+};
+/**
+ * Built once per read, so the word lists compile once. A reply, an order word in the subject or an order's number
+ * keeps the email. Otherwise a newsletter word counts 2 in the subject and 1 in the first lines, a newsletter's
+ * address 2, an emoji in the subject and a browser or unsubscribe link at the top 1 each, and each order word in
+ * the first lines takes 2 off. Measured 2026-11-05 on 30 days of the owner's bulk mail: 99 of 100 sampled
+ * newsletter verdicts were newsletters, and about half of the newsletters were found.
+ */
+export const newsletterSorter = (cues = NEWSLETTER_DEFAULTS) => {
+    const advertising = matcherOf(cues.newsletterWords);
+    const ordered = matcherOf(cues.orderWords);
+    const senders = cues.newsletterSenders.map((part) => part.trim().toLowerCase()).filter(Boolean);
+    const fromNewsletter = (address) => {
+        const domain = address.split("@")[1] ?? "";
+        const parts = new Set(address.split(/[.@_+-]/));
+        return senders.some((one) => (one.includes(".") ? domain === one || domain.endsWith(`.${one}`) : parts.has(one)));
+    };
+    return ({ subject, text, from }) => {
+        const excerpt = excerptOf(text, cues.excerptChars);
+        const title = subject ?? "";
+        const number = REFERENCE_NUMBER.exec(`${title}\n${excerpt}`);
+        const kept = [...(REPLY.test(title) ? ["a reply"] : []), ...ordered(title), ...(number ? [number[0]] : [])];
+        if (kept.length > 0)
+            return { verdict: "excerpt", score: 0, cues: kept, excerpt };
+        const inTitle = advertising(title);
+        const signs = [
+            ...inTitle.map((word) => [word, 2]),
+            ...advertising(excerpt)
+                .filter((word) => !inTitle.includes(word))
+                .map((word) => [word, 1]),
+            ...(PICTOGRAPH.test(title) ? [["an emoji in the subject", 1]] : []),
+            ...(NEWSLETTER_TOP.test(excerpt) ? [["a browser or unsubscribe link", 1]] : []),
+            ...(fromNewsletter((from ?? "").toLowerCase()) ? [["a newsletter's address", 2]] : []),
+            ...ordered(excerpt).map((word) => [`-${word}`, -2]),
+        ];
+        const score = signs.reduce((sum, [, weight]) => sum + weight, 0);
+        return {
+            verdict: score >= cues.threshold ? "newsletter" : "excerpt",
+            score,
+            cues: signs.map(([cue]) => cue),
+            excerpt,
+        };
+    };
+};
+export const BULK_TRIAGE_DEFAULTS = { excerpts: true, perRead: 30, cues: NEWSLETTER_DEFAULTS };

package/dist/mail/review.d.ts

@@ -18,8 +18,10 @@ export interface MailReviewOptions {
     now?: number;
 }
 /** A review of mail: each thread a chat, each email a stored hit with its locator. */
+/** `excerptOnly`: a bulk email a holder gets as its subject and first lines, its `text` cut to them. */
 export type MailHit = StoredHit & {
     marks?: EmailMarks;
+    excerptOnly?: true;
 };
 export interface MailReview extends Review {
     chats: (Omit<ReviewChat, "messages"> & {

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 };
     };