@wirecat/cli-core 0.573.0 → 0.575.0

package/CHANGELOG.md

@@ -7,6 +7,32 @@ shape of this file.
 
 ## Unreleased
 
+## 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
+
+- **A finished request no longer keeps the command in memory until its time limit ends.** The limit was a timer that
+  ran to the end even after the answer came, and it held everything the command had loaded; tg-cli and max-cli
+  already fixed the same thing in their own requests, and tg ran out of memory on macOS before that. This covers the
+  OAuth token and revoke requests, the OpenAI model request, the bot-registry checks, calendar feeds and serve's
+  catch-up on start. `timeLimit` and `withTimeLimit` (`src/http/time-limit.ts`) are the stoppable limit now.
+
 ## 0.573.0 — 05.11.2026
 
 ### Added

package/dist/botcheck/registries.js

@@ -1,3 +1,4 @@
+import { withTimeLimit } from "../http/time-limit.js";
 /** Where each one is documented, for the help text and the MCP description. */
 export const REGISTRIES = {
     cas: { title: "Combot Anti-Spam (CAS)", docs: "https://cas.chat/api" },
@@ -12,17 +13,19 @@ const TIMEOUT_MS = 10_000;
 export const askRegistries = async (id, options = {}) => Promise.all([askCas(id, options), askLols(id, options)]);
 const getJson = async (url, headers, { fetch: fetchFn = fetch, timeoutMs = TIMEOUT_MS }) => {
     try {
-        const response = await fetchFn(url, {
-            headers: { accept: "application/json", ...headers },
-            signal: AbortSignal.timeout(timeoutMs),
-            redirect: "error",
+        const { status, text } = await withTimeLimit(timeoutMs, async (signal) => {
+            const response = await fetchFn(url, {
+                headers: { accept: "application/json", ...headers },
+                signal,
+                redirect: "error",
+            });
+            return { status: response.status, text: await response.text() };
         });
-        const text = await response.text();
         try {
-            return { status: response.status, body: JSON.parse(text) };
+            return { status, body: JSON.parse(text) };
         }
         catch {
-            return { failed: `answered ${response.status} with something that is not JSON` };
+            return { failed: `answered ${status} with something that is not JSON` };
         }
     }
     catch (error) {

package/dist/calendar/feeds.js

@@ -2,6 +2,7 @@ import { createHash, randomBytes } from "node:crypto";
 import { CliError, isCliError } from "@wirecat/cli-base";
 import { zonedMoment } from "@wirecat/cli-base/query";
 import { runBudget } from "../background/budget.js";
+import { timeLimit } from "../http/time-limit.js";
 import { calendarText, joinUrlWithoutQuery } from "../meetings/index.js";
 import { expandSeries, unexpandable } from "./expand.js";
 import { readIcs } from "./ics.js";
@@ -72,8 +73,8 @@ export const fetchFeedIfChanged = async (address, options) => {
         ...(since?.lastModified ? { "if-modified-since": since.lastModified } : {}),
     };
     const run = options.fetch ?? fetch;
-    const timeout = AbortSignal.timeout(limits.timeoutMs);
-    const signal = options.signal ? AbortSignal.any([options.signal, timeout]) : timeout;
+    const timeout = timeLimit(limits.timeoutMs);
+    const signal = options.signal ? AbortSignal.any([options.signal, timeout.signal]) : timeout.signal;
     let url = feedAddress(address);
     try {
         for (let hop = 0;; hop++) {
@@ -122,7 +123,7 @@ export const fetchFeedIfChanged = async (address, options) => {
             throw error;
         if (options.signal?.aborted)
             throw new CliError("cancelled", `reading ${name} was cancelled`);
-        if (timeout.aborted)
+        if (timeout.signal.aborted)
             throw new CliError("timeout", `${name} did not answer within ${Math.round(limits.timeoutMs / 1000)} s`, {
                 reason: "feed.timeout",
                 retryable: true,
@@ -134,6 +135,9 @@ export const fetchFeedIfChanged = async (address, options) => {
             retryable: true,
         });
     }
+    finally {
+        timeout.clear();
+    }
 };
 const SPAN = { start: 0, end: 0 };
 const firstLink = (text) => text?.match(/https?:\/\/[^\s<>"')\]]+/iu)?.[0];

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/cli/messenger/serve-catch-up.js

@@ -1,4 +1,5 @@
 import { failureKey } from "../../errors/failures.js";
+import { withTimeLimit } from "../../http/time-limit.js";
 /** The provider's own catch-up lands first; this pass then finds most chats already current. */
 export const START_SYNC_DELAY_MS = 30_000;
 export const START_SYNC_BUDGET_MS = 5 * 60_000;
@@ -19,8 +20,8 @@ export const startSync = ({ chats, newestHeld, fetch, note, warn, delayMs = STAR
     let pass = Promise.resolve();
     let started = false;
     let done;
-    const run = async () => {
-        const stop = AbortSignal.any([controller.signal, AbortSignal.timeout(budgetMs)]);
+    const run = () => withTimeLimit(budgetMs, (deadline) => catchUp(AbortSignal.any([controller.signal, deadline])));
+    const catchUp = async (stop) => {
         const floor = now() - windowMs;
         const moved = [];
         for (const chat of await chats(stop)) {

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/http/time-limit.d.ts

@@ -0,0 +1,11 @@
+export interface TimeLimit {
+    signal: AbortSignal;
+    clear: () => void;
+}
+/**
+ * A time limit that can be stopped. `AbortSignal.timeout` cannot: its timer runs to the deadline even after the
+ * request is done, and keeps the run's whole async context (everything the command loaded) alive until then.
+ */
+export declare const timeLimit: (ms: number) => TimeLimit;
+/** Runs `run` under a time limit and stops the timer when it settles. Whatever `run` reads from the response belongs inside. */
+export declare const withTimeLimit: <T>(ms: number, run: (deadline: AbortSignal) => Promise<T>) => Promise<T>;

package/dist/http/time-limit.js

@@ -0,0 +1,20 @@
+/**
+ * A time limit that can be stopped. `AbortSignal.timeout` cannot: its timer runs to the deadline even after the
+ * request is done, and keeps the run's whole async context (everything the command loaded) alive until then.
+ */
+export const timeLimit = (ms) => {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(new DOMException("The operation timed out.", "TimeoutError")), ms);
+    timer.unref();
+    return { signal: controller.signal, clear: () => clearTimeout(timer) };
+};
+/** Runs `run` under a time limit and stops the timer when it settles. Whatever `run` reads from the response belongs inside. */
+export const withTimeLimit = async (ms, run) => {
+    const limit = timeLimit(ms);
+    try {
+        return await run(limit.signal);
+    }
+    finally {
+        limit.clear();
+    }
+};

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