@wirecat/cli-core 0.574.0 → 0.576.0

package/CHANGELOG.md

@@ -7,6 +7,39 @@ shape of this file.
 
 ## Unreleased
 
+## 0.576.0 — 05.11.2026
+
+### Added
+
+- **`review --holder` gives an agent the bulk mail that is not surely a newsletter.** Shops, banks and site forms put
+  List-Unsubscribe on orders, invoices and lead forms too, and the holder read left all of it out. Now
+  `newsletterSorter` scores each bulk email by words in its subject and first lines (Russian, English, Spanish), its
+  sender's address, an emoji or an unsubscribe link: a newsletter is left out and counted under `missing` as
+  `newsletter`; an order word in the subject, an order's or a request's number, or a reply keeps it. A kept email
+  comes after the other mail, as its subject and first lines, with `email.bulk: true` and `email.excerpt_only: true`;
+  `messages show <ref>` reads it whole. At most 30 excerpts a read; the read then ends early and the next gives the
+  rest. `mailWaiting` and `advancePastSkipped` count and stop at excerpts the same way. A host sets it from its config
+  file: `MAIL_BULK_SETTINGS` (`mail_bulk_excerpts`, `mail_bulk_excerpts_per_read`, `mail_bulk_excerpt_chars`,
+  `mail_bulk_newsletter_score`, `mail_bulk_newsletter_words`, `mail_bulk_newsletter_senders`, `mail_bulk_order_words`),
+  read by `bulkTriageOf` into `MailReads.bulkTriage`, and passed to `mailWaiting` and `advancePastSkipped` as their
+  new last argument; without it the defaults apply.
+
+## 0.575.0 — 05.11.2026
+
+### Added
+
+- **Orders in the store (store version 50).** `store.orders` keeps what the owner, his business or a client ordered:
+  for whom (`customer`, the owner when left out) and why (`purpose`: `personal`, `business`, `client`, `other`), the
+  shop as its mail names it with an optional `supplier` reference, the shop's number, amount and currency, the status
+  (`placed`, `shipped`, `delivered`, `cancelled`, `returned`), the order and delivery days, and links to an invoice and
+  a payment. The owner's entry is confirmed at once; an agent's is an `order` proposal (`order:<id>`) only the owner
+  decides. One shop's number is stored once (`order.duplicate`), and only the owner moves an order's status on.
+- **Mail findings take invoices, payments and orders.** A `mail_findings` batch now takes the kinds `invoice`,
+  `payment`, `order` and `order_update` (a later mail's status for a stored order, found by `supplier_name` and
+  `number`). Staging checks each the way `store.finance` and `store.orders` check the owner's own entry and refuses
+  the batch with that reason; nothing is written until the owner accepts, which records the confirmed row with the
+  cited mail as its evidence. The agent still only proposes.
+
 ## 0.574.0 — 05.11.2026
 
 ### Fixed

package/dist/calendar/mcp/index.d.ts

@@ -10,13 +10,13 @@ export declare const calendarTools: ({
     inputSchema: {
         type: string;
         properties: {
+            limit?: undefined;
             account_id: {
                 type: string;
                 minimum: number;
             };
             query?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             page?: undefined;
             event?: undefined;
         } | {
@@ -45,9 +45,9 @@ export declare const calendarTools: ({
             };
             event?: undefined;
         } | {
+            limit?: undefined;
             query?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             page?: undefined;
             event: {
                 type: string;
@@ -58,9 +58,9 @@ export declare const calendarTools: ({
                 minimum: number;
             };
         } | {
+            limit?: undefined;
             query?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             page?: undefined;
             event?: undefined;
             account_id?: undefined;
@@ -80,13 +80,13 @@ export declare const calendarTools: ({
     inputSchema: {
         type: string;
         properties: {
+            limit?: undefined;
             account_id: {
                 type: string;
                 minimum: number;
             };
             query?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             page?: undefined;
             event?: undefined;
         } | {
@@ -115,9 +115,9 @@ export declare const calendarTools: ({
             };
             event?: undefined;
         } | {
+            limit?: undefined;
             query?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             page?: undefined;
             event: {
                 type: string;
@@ -128,9 +128,9 @@ export declare const calendarTools: ({
                 minimum: number;
             };
         } | {
+            limit?: undefined;
             query?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             page?: undefined;
             event?: undefined;
             account_id?: undefined;
@@ -150,13 +150,13 @@ export declare const calendarTools: ({
     inputSchema: {
         type: string;
         properties: {
+            limit?: undefined;
             account_id: {
                 type: string;
                 minimum: number;
             };
             query?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             page?: undefined;
             event?: undefined;
         } | {
@@ -185,9 +185,9 @@ export declare const calendarTools: ({
             };
             event?: undefined;
         } | {
+            limit?: undefined;
             query?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             page?: undefined;
             event: {
                 type: string;
@@ -198,9 +198,9 @@ export declare const calendarTools: ({
                 minimum: number;
             };
         } | {
+            limit?: undefined;
             query?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             page?: undefined;
             event?: undefined;
             account_id?: undefined;
@@ -220,13 +220,13 @@ export declare const calendarTools: ({
     inputSchema: {
         type: string;
         properties: {
+            limit?: undefined;
             account_id: {
                 type: string;
                 minimum: number;
             };
             query?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             page?: undefined;
             event?: undefined;
         } | {
@@ -255,9 +255,9 @@ export declare const calendarTools: ({
             };
             event?: undefined;
         } | {
+            limit?: undefined;
             query?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             page?: undefined;
             event: {
                 type: string;
@@ -268,9 +268,9 @@ export declare const calendarTools: ({
                 minimum: number;
             };
         } | {
+            limit?: undefined;
             query?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             page?: undefined;
             event?: undefined;
             account_id?: undefined;

package/dist/cli/findings-input.js

@@ -8,6 +8,12 @@ const keys = {
     due_evidence: "dueEvidence",
     assignee_evidence: "assigneeEvidence",
     memory_kind: "memoryKind",
+    issue_date: "issueDate",
+    due_date: "dueDate",
+    unit_price: "unitPrice",
+    supplier_name: "supplierName",
+    order_date: "orderDate",
+    fulfilled_date: "fulfilledDate",
 };
 const parseFindingsJson = (text, label, validate) => {
     if (Buffer.byteLength(text, "utf8") > 65536)

package/dist/domain/orders.d.ts

@@ -0,0 +1,19 @@
+import type { FinanceReview } from "./finance.js";
+export declare const ORDER_STATUSES: readonly ["placed", "shipped", "delivered", "cancelled", "returned"];
+/** Why it was ordered: for the owner himself, for his business, for a client, or anything else. */
+export declare const ORDER_PURPOSES: readonly ["personal", "business", "client", "other"];
+export type OrderStatus = (typeof ORDER_STATUSES)[number];
+export type OrderPurpose = (typeof ORDER_PURPOSES)[number];
+export interface OrderTitleFields {
+    id: number;
+    number: string | null;
+    supplierName: string;
+    total: number | null;
+    currency: string | null;
+    status: OrderStatus;
+    review: FinanceReview;
+}
+/** "12345 · Ozon, 2 499.00 RUB (shipped)": a ref summary's title, which `refLabel` prefixes. */
+export declare const orderLine: (order: OrderTitleFields) => string;
+/** "Order 12345 · Ozon, 2 499.00 RUB (shipped)". */
+export declare const orderTitle: (order: OrderTitleFields) => string;

package/dist/domain/orders.js

@@ -0,0 +1,12 @@
+import { moneyLabel } from "./money.js";
+export const ORDER_STATUSES = ["placed", "shipped", "delivered", "cancelled", "returned"];
+/** Why it was ordered: for the owner himself, for his business, for a client, or anything else. */
+export const ORDER_PURPOSES = ["personal", "business", "client", "other"];
+/** "12345 · Ozon, 2 499.00 RUB (shipped)": a ref summary's title, which `refLabel` prefixes. */
+export const orderLine = (order) => {
+    const money = order.total === null || order.currency === null ? "" : `, ${moneyLabel(order.total, order.currency)}`;
+    const notes = [order.status, order.review === "confirmed" ? null : order.review].filter(Boolean).join(", ");
+    return `${order.number ?? `#${order.id}`} · ${order.supplierName}${money} (${notes})`;
+};
+/** "Order 12345 · Ozon, 2 499.00 RUB (shipped)". */
+export const orderTitle = (order) => `Order ${orderLine(order)}`;

package/dist/domain/ref-summaries.js

@@ -51,6 +51,7 @@ const WORDS = {
     bot: "Bot",
     invoice: "Invoice",
     payment: "Payment",
+    order: "Order",
     email: "Email",
     email_thread: "Email thread",
     unknown: "Unknown",

package/dist/domain/references.d.ts

@@ -33,7 +33,7 @@ export type Reference = {
  * Things named by their store id (a task also by its key or the task package's id). `entity` is the name
  * before organizations and projects: it still parses, so an old file's reference resolves as not found.
  */
-export declare const SIMPLE_REFERENCES: readonly ["note", "document", "person", "organization", "project", "task", "memory", "fact", "bot", "event", "invoice", "payment", "entity"];
+export declare const SIMPLE_REFERENCES: readonly ["note", "document", "person", "organization", "project", "task", "memory", "fact", "bot", "event", "invoice", "payment", "order", "entity"];
 export type SimpleReference = (typeof SIMPLE_REFERENCES)[number];
 export type RefKindName = Exclude<Reference["type"], "entity">;
 export interface RefKindSpec<R extends Reference = Reference> {

package/dist/domain/references.js

@@ -18,6 +18,7 @@ export const SIMPLE_REFERENCES = [
     "event",
     "invoice",
     "payment",
+    "order",
     "entity",
 ];
 const malformed = (text, shape) => new CliError("validation_error", `"${singleLine(text)}" is not a reference — expected ${shape}`, {

package/dist/entities/index.d.ts

@@ -5966,6 +5966,81 @@ export declare const ENTITIES: {
                 readonly address: v.StringSchema<undefined>;
                 readonly name: v.StringSchema<undefined>;
                 readonly reason: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            }, undefined>, v.StrictObjectSchema<{
+                readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+                readonly evidence: v.ArraySchema<v.StrictObjectSchema<{
+                    readonly reference: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+                    readonly fingerprint: v.StringSchema<undefined>;
+                }, undefined>, undefined>;
+                readonly kind: v.LiteralSchema<"invoice", undefined>;
+                readonly direction: v.PicklistSchema<readonly ["receivable", "payable"], undefined>;
+                readonly counterparty: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+                readonly currency: v.StringSchema<undefined>;
+                readonly lines: v.ArraySchema<v.StrictObjectSchema<{
+                    readonly description: v.StringSchema<undefined>;
+                    readonly quantity: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly unit_price: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly amount: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, undefined>;
+                readonly total: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                readonly number: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                readonly issue_date: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                readonly due_date: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                readonly project: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+                readonly reason: v.StringSchema<undefined>;
+            }, undefined>, v.StrictObjectSchema<{
+                readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+                readonly evidence: v.ArraySchema<v.StrictObjectSchema<{
+                    readonly reference: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+                    readonly fingerprint: v.StringSchema<undefined>;
+                }, undefined>, undefined>;
+                readonly kind: v.LiteralSchema<"payment", undefined>;
+                readonly direction: v.PicklistSchema<readonly ["in", "out"], undefined>;
+                readonly payer: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+                readonly payee: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+                readonly amount: v.StringSchema<undefined>;
+                readonly currency: v.StringSchema<undefined>;
+                readonly date: v.StringSchema<undefined>;
+                readonly reference: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                readonly allocations: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+                    readonly invoice: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+                    readonly amount: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+                readonly project: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+                readonly reason: v.StringSchema<undefined>;
+            }, undefined>, v.StrictObjectSchema<{
+                readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+                readonly evidence: v.ArraySchema<v.StrictObjectSchema<{
+                    readonly reference: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+                    readonly fingerprint: v.StringSchema<undefined>;
+                }, undefined>, undefined>;
+                readonly kind: v.LiteralSchema<"order", undefined>;
+                readonly purpose: v.PicklistSchema<readonly ["personal", "business", "client", "other"], undefined>;
+                readonly customer: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+                readonly supplier: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+                readonly supplier_name: v.StringSchema<undefined>;
+                readonly number: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                readonly total: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                readonly currency: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                readonly status: v.OptionalSchema<v.PicklistSchema<readonly ["placed", "shipped", "delivered", "cancelled", "returned"], undefined>, undefined>;
+                readonly order_date: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                readonly fulfilled_date: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                readonly invoice: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+                readonly payment: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+                readonly project: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+                readonly reason: v.StringSchema<undefined>;
+            }, undefined>, v.StrictObjectSchema<{
+                readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+                readonly evidence: v.ArraySchema<v.StrictObjectSchema<{
+                    readonly reference: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+                    readonly fingerprint: v.StringSchema<undefined>;
+                }, undefined>, undefined>;
+                readonly kind: v.LiteralSchema<"order_update", undefined>;
+                readonly supplier_name: v.StringSchema<undefined>;
+                readonly number: v.StringSchema<undefined>;
+                readonly status: v.PicklistSchema<readonly ["placed", "shipped", "delivered", "cancelled", "returned"], undefined>;
+                readonly date: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                readonly reason: v.StringSchema<undefined>;
             }, undefined>], undefined>, undefined>;
         }, undefined>;
         readonly fingerprint: v.StringSchema<undefined>;

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

@@ -81,6 +81,81 @@ export declare const mailFindings: v.StrictObjectSchema<{
             readonly address: v.StringSchema<undefined>;
             readonly name: v.StringSchema<undefined>;
             readonly reason: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, v.StrictObjectSchema<{
+            readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+            readonly evidence: v.ArraySchema<v.StrictObjectSchema<{
+                readonly reference: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+                readonly fingerprint: v.StringSchema<undefined>;
+            }, undefined>, undefined>;
+            readonly kind: v.LiteralSchema<"invoice", undefined>;
+            readonly direction: v.PicklistSchema<readonly ["receivable", "payable"], undefined>;
+            readonly counterparty: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+            readonly currency: v.StringSchema<undefined>;
+            readonly lines: v.ArraySchema<v.StrictObjectSchema<{
+                readonly description: v.StringSchema<undefined>;
+                readonly quantity: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                readonly unit_price: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                readonly amount: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            }, undefined>, undefined>;
+            readonly total: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly number: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly issue_date: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly due_date: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly project: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+            readonly reason: v.StringSchema<undefined>;
+        }, undefined>, v.StrictObjectSchema<{
+            readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+            readonly evidence: v.ArraySchema<v.StrictObjectSchema<{
+                readonly reference: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+                readonly fingerprint: v.StringSchema<undefined>;
+            }, undefined>, undefined>;
+            readonly kind: v.LiteralSchema<"payment", undefined>;
+            readonly direction: v.PicklistSchema<readonly ["in", "out"], undefined>;
+            readonly payer: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+            readonly payee: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+            readonly amount: v.StringSchema<undefined>;
+            readonly currency: v.StringSchema<undefined>;
+            readonly date: v.StringSchema<undefined>;
+            readonly reference: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly allocations: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+                readonly invoice: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+                readonly amount: v.StringSchema<undefined>;
+            }, undefined>, undefined>, undefined>;
+            readonly project: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+            readonly reason: v.StringSchema<undefined>;
+        }, undefined>, v.StrictObjectSchema<{
+            readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+            readonly evidence: v.ArraySchema<v.StrictObjectSchema<{
+                readonly reference: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+                readonly fingerprint: v.StringSchema<undefined>;
+            }, undefined>, undefined>;
+            readonly kind: v.LiteralSchema<"order", undefined>;
+            readonly purpose: v.PicklistSchema<readonly ["personal", "business", "client", "other"], undefined>;
+            readonly customer: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+            readonly supplier: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+            readonly supplier_name: v.StringSchema<undefined>;
+            readonly number: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly total: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly currency: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly status: v.OptionalSchema<v.PicklistSchema<readonly ["placed", "shipped", "delivered", "cancelled", "returned"], undefined>, undefined>;
+            readonly order_date: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly fulfilled_date: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly invoice: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+            readonly payment: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+            readonly project: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+            readonly reason: v.StringSchema<undefined>;
+        }, undefined>, v.StrictObjectSchema<{
+            readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+            readonly evidence: v.ArraySchema<v.StrictObjectSchema<{
+                readonly reference: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+                readonly fingerprint: v.StringSchema<undefined>;
+            }, undefined>, undefined>;
+            readonly kind: v.LiteralSchema<"order_update", undefined>;
+            readonly supplier_name: v.StringSchema<undefined>;
+            readonly number: v.StringSchema<undefined>;
+            readonly status: v.PicklistSchema<readonly ["placed", "shipped", "delivered", "cancelled", "returned"], undefined>;
+            readonly date: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly reason: v.StringSchema<undefined>;
         }, undefined>], undefined>, undefined>;
     }, undefined>;
     readonly fingerprint: v.StringSchema<undefined>;

package/dist/entities/mail-findings.js

@@ -1,5 +1,7 @@
 import * as v from "valibot";
+import { INVOICE_DIRECTIONS, MONEY_DIRECTIONS } from "../domain/finance.js";
 import { FACT_TYPES, MEMORY_KINDS, MEMORY_SCOPES, WORK_TASK_TYPES } from "../domain/knowledge.js";
+import { ORDER_PURPOSES, ORDER_STATUSES } from "../domain/orders.js";
 import { author, id, reference, text, time } from "./fields.js";
 const evidence = v.strictObject({ reference, fingerprint: text });
 const base = { id, evidence: v.array(evidence) };
@@ -45,6 +47,66 @@ const finding = v.variant("kind", [
     }),
     v.strictObject({ ...base, kind: v.literal("link"), from: reference, to: reference, reason: text }),
     v.strictObject({ ...base, kind: v.literal("new_contact"), address: text, name: text, reason: v.optional(text) }),
+    v.strictObject({
+        ...base,
+        kind: v.literal("invoice"),
+        direction: v.picklist(INVOICE_DIRECTIONS),
+        counterparty: reference,
+        currency: text,
+        lines: v.array(v.strictObject({
+            description: text,
+            quantity: v.optional(text),
+            unit_price: v.optional(text),
+            amount: v.optional(text),
+        })),
+        total: v.optional(text),
+        number: v.optional(text),
+        issue_date: v.optional(text),
+        due_date: v.optional(text),
+        project: v.optional(reference),
+        reason: text,
+    }),
+    v.strictObject({
+        ...base,
+        kind: v.literal("payment"),
+        direction: v.picklist(MONEY_DIRECTIONS),
+        payer: v.optional(reference),
+        payee: v.optional(reference),
+        amount: text,
+        currency: text,
+        date: text,
+        reference: v.optional(text),
+        allocations: v.optional(v.array(v.strictObject({ invoice: reference, amount: text }))),
+        project: v.optional(reference),
+        reason: text,
+    }),
+    v.strictObject({
+        ...base,
+        kind: v.literal("order"),
+        purpose: v.picklist(ORDER_PURPOSES),
+        customer: v.optional(reference),
+        supplier: v.optional(reference),
+        supplier_name: text,
+        number: v.optional(text),
+        total: v.optional(text),
+        currency: v.optional(text),
+        status: v.optional(v.picklist(ORDER_STATUSES)),
+        order_date: v.optional(text),
+        fulfilled_date: v.optional(text),
+        invoice: v.optional(reference),
+        payment: v.optional(reference),
+        project: v.optional(reference),
+        reason: text,
+    }),
+    v.strictObject({
+        ...base,
+        kind: v.literal("order_update"),
+        supplier_name: text,
+        number: text,
+        status: v.picklist(ORDER_STATUSES),
+        date: v.optional(text),
+        reason: text,
+    }),
 ]);
 const outcome = v.strictObject({
     id,

package/dist/errors/reasons.js

@@ -197,6 +197,11 @@ const OTHERS = [
     validation("money.amount", "the amount is not a decimal string in the currency's scale"),
     validation("money.currency", "the currency is not one the store keeps money in"),
     validation("money.quantity", "the quantity is not a decimal above 0"),
+    validation("order.duplicate", "the shop's order with this number is already stored; change its status instead"),
+    validation("order.field", "a field of the order is not valid"),
+    ["order.not-found", "not_found", "no stored order of that shop has that number"],
+    validation("order.ref", "the reference names no order, or a shop's number names more than one"),
+    validation("order.status", "a rejected or deleted order's status does not change"),
     ["model.not-downloaded", "not_found", "the model is not downloaded on this machine"],
     ["person.no-owner", "not_found", "no person is marked as the owner in the store"],
     ["transcription.no-key", "authentication_error", "no OpenAI key is set for transcription"],

package/dist/index.d.ts

@@ -9,6 +9,7 @@ export { parseMarkdownSpans } from "./domain/markdown-spans.js";
 export type { MessageLink, MessagePermalink } from "./domain/message-link.js";
 export type * from "./domain/models.js";
 export { CURRENCY_SCALES, currencyOf, type Money, minorUnits, moneyLabel, moneyOf, } from "./domain/money.js";
+export { ORDER_PURPOSES, ORDER_STATUSES, type OrderPurpose, type OrderStatus, } from "./domain/orders.js";
 export { countedPoll } from "./domain/polls.js";
 export { FOLDER_PROVIDERS, isFolderProvider, isKind, KINDS, type Kind, kindIn, kindOf, PROVIDERS, type ProviderEntry, providerNamed, providers, UNKNOWN_PROVIDER, useProviders, } from "./domain/providers.js";
 export type { RankingGraphEvidence, RankingGraphLink } from "./domain/rankings-graph.js";

package/dist/index.js

@@ -6,6 +6,7 @@ export { formatLocator, isLocator, parseLocator } from "./domain/locator.js";
 export { parseMarkdown } from "./domain/markdown.js";
 export { parseMarkdownSpans } from "./domain/markdown-spans.js";
 export { CURRENCY_SCALES, currencyOf, minorUnits, moneyLabel, moneyOf, } from "./domain/money.js";
+export { ORDER_PURPOSES, ORDER_STATUSES, } from "./domain/orders.js";
 export { countedPoll } from "./domain/polls.js";
 export { FOLDER_PROVIDERS, isFolderProvider, isKind, KINDS, kindIn, kindOf, PROVIDERS, providerNamed, providers, UNKNOWN_PROVIDER, useProviders, } from "./domain/providers.js";
 export { rankingOptions } from "./domain/rankings-options.js";

package/dist/mail/cli/bulk-settings.d.ts

@@ -0,0 +1,6 @@
+import type { DeclaredSetting } from "../../cli/setting-defaults.js";
+import { type BulkTriage } from "../newsletter.js";
+/** The bulk-mail settings a host that mounts `review --holder` writes into its config file's top level (WC-CMD-30). */
+export declare const MAIL_BULK_SETTINGS: readonly DeclaredSetting[];
+/** `MAIL_BULK_SETTINGS` as the config file gives them; a missing or unusable value is left to the default. */
+export declare const bulkTriageOf: (config: Record<string, unknown>) => BulkTriage;

package/dist/mail/cli/bulk-settings.js

@@ -0,0 +1,65 @@
+import { BULK_TRIAGE_DEFAULTS, NEWSLETTER_DEFAULTS, NEWSLETTER_SENDERS, NEWSLETTER_WORDS, ORDER_WORDS, } from "../newsletter.js";
+const listed = (words) => words.join(", ");
+/** The bulk-mail settings a host that mounts `review --holder` writes into its config file's top level (WC-CMD-30). */
+export const MAIL_BULK_SETTINGS = [
+    {
+        key: "mail_bulk_excerpts",
+        default: BULK_TRIAGE_DEFAULTS.excerpts,
+        description: "review --holder gives an agent bulk mail that is not surely a newsletter as its subject and first lines; " +
+            "false leaves all bulk mail out",
+    },
+    {
+        key: "mail_bulk_excerpts_per_read",
+        default: BULK_TRIAGE_DEFAULTS.perRead,
+        description: "the most bulk excerpts one review --holder gives; the rest come with the next read",
+    },
+    {
+        key: "mail_bulk_excerpt_chars",
+        default: NEWSLETTER_DEFAULTS.excerptChars,
+        description: "how many characters of a bulk email's own text an excerpt shows",
+    },
+    {
+        key: "mail_bulk_newsletter_score",
+        default: NEWSLETTER_DEFAULTS.threshold,
+        description: "bulk mail scoring this or more is left out as a newsletter: a newsletter word counts 2 in the subject, 1 in " +
+            "the first lines, a newsletter's address 2, an emoji in the subject 1, an unsubscribe link at the top 1, " +
+            "an order word in the first lines -2",
+    },
+    {
+        key: "mail_bulk_newsletter_words",
+        default: listed(NEWSLETTER_WORDS),
+        description: "comma-separated words that say advertising; each matches at the start of a word, any case",
+    },
+    {
+        key: "mail_bulk_newsletter_senders",
+        default: listed(NEWSLETTER_SENDERS),
+        description: "comma-separated parts of a sender's address (news, digest) or domains (substack.com) of newsletters",
+    },
+    {
+        key: "mail_bulk_order_words",
+        default: listed(ORDER_WORDS),
+        description: "comma-separated words of orders, invoices and requests: one in the subject keeps a bulk email for the agent",
+    },
+];
+const wordsOf = (value) => typeof value === "string"
+    ? value
+        .split(",")
+        .map((word) => word.trim())
+        .filter(Boolean)
+    : undefined;
+const countOf = (value, least) => typeof value === "number" && Number.isSafeInteger(value) && value >= least ? value : undefined;
+/** `MAIL_BULK_SETTINGS` as the config file gives them; a missing or unusable value is left to the default. */
+export const bulkTriageOf = (config) => {
+    const { cues } = BULK_TRIAGE_DEFAULTS;
+    return {
+        excerpts: typeof config.mail_bulk_excerpts === "boolean" ? config.mail_bulk_excerpts : BULK_TRIAGE_DEFAULTS.excerpts,
+        perRead: countOf(config.mail_bulk_excerpts_per_read, 1) ?? BULK_TRIAGE_DEFAULTS.perRead,
+        cues: {
+            threshold: countOf(config.mail_bulk_newsletter_score, 1) ?? cues.threshold,
+            excerptChars: countOf(config.mail_bulk_excerpt_chars, 40) ?? cues.excerptChars,
+            newsletterWords: wordsOf(config.mail_bulk_newsletter_words) ?? cues.newsletterWords,
+            newsletterSenders: wordsOf(config.mail_bulk_newsletter_senders) ?? cues.newsletterSenders,
+            orderWords: wordsOf(config.mail_bulk_order_words) ?? cues.orderWords,
+        },
+    };
+};

package/dist/mail/cli/index.d.ts

@@ -1,7 +1,9 @@
 import { Command } from "commander";
+import type { BulkTriage } from "../../mail/newsletter.js";
 import { type MailServerAccess } from "../../mail/server-search.js";
 import type { AppIdentity } from "../../ports/app.js";
 import { type AccountKey, type MessageStore } from "../../store/store.js";
+export { bulkTriageOf, MAIL_BULK_SETTINGS } from "./bulk-settings.js";
 export { mailMark, markItem, markText } from "./marks.js";
 export { MAIL_REVIEW_QUERY, MAIL_REVIEW_STEPS, mailReviewSteps } from "./review.js";
 /**
@@ -37,6 +39,8 @@ export interface MailReads {
      * With it, `messages show` reads an email whose attachment a sync's policy left unread before it answers.
      */
     whole?: (command: Command, store: MessageStore, mailbox: AccountKey, emailId: string) => Promise<void>;
+    /** How `review --holder` treats bulk mail, from the host's config file (`MAIL_BULK_SETTINGS`); defaults without it. */
+    bulkTriage?: (command: Command) => BulkTriage;
 }
 export declare const THREAD_QUERY: {
     readonly entity: "mail_thread";

package/dist/mail/cli/index.js

@@ -21,6 +21,7 @@ import { sourceKey } from "../../services/server-search.js";
 import { queryFilter, THREAD_COLUMNS } from "../../store/store.js";
 import { acknowledgeCommand } from "./marks.js";
 import { mailReviewCommand } from "./review.js";
+export { bulkTriageOf, MAIL_BULK_SETTINGS } from "./bulk-settings.js";
 export { mailMark, markItem, markText } from "./marks.js";
 export { MAIL_REVIEW_QUERY, MAIL_REVIEW_STEPS, mailReviewSteps } from "./review.js";
 /** A locked or broken store must fail the command, not read as "nothing stored yet". */