@wirecat/cli-core 0.549.0 → 0.551.0

package/dist/cli/project-status.js

@@ -0,0 +1,248 @@
+import * as v from "valibot";
+import { snakeKeys } from "./envelope.js";
+import { heldPhrase } from "./messenger/search-answers.js";
+import { STATUS_SIGNAL_ROWS } from "./project-status-rows.js";
+const day = (at) => new Date(at).toISOString().slice(0, 10);
+const listKey = (signal) => signal.replaceAll("-", "_");
+const SECTIONS = {
+    signals: "status.signal",
+    money: "status.money",
+    chats: "status.chat",
+    out_of_scope: "status.out-of-scope",
+    failed: "status.failed",
+};
+/** The `project_status` answer drawn by `--compact`: each signal's list with that signal's row. */
+export const projectStatusRow = (signals) => ({
+    columns: [],
+    sections: {
+        ...SECTIONS,
+        ...Object.fromEntries(signals.map(({ id }) => [listKey(id), `status.${id}`])),
+    },
+});
+const statusItem = v.looseObject({
+    signal: v.string(),
+    ref: v.nullable(v.string()),
+    chat: v.nullable(v.string()),
+    chat_title: v.nullable(v.string()),
+    at: v.nullable(v.string()),
+    who: v.nullable(v.strictObject({ ref: v.nullable(v.string()), name: v.nullable(v.string()), owner: v.boolean() })),
+    evidence: v.array(v.strictObject({ ref: v.string(), fingerprint: v.nullable(v.string()) })),
+    basis: v.picklist(["store", "fact", "task", "pattern"]),
+    data: v.record(v.string(), v.unknown()),
+});
+/** Where a project stands: per chat signals, open money, and what was left out. Empty lists are left out. */
+export const projectStatusSchema = v.looseObject({
+    project: v.string(),
+    key: v.nullable(v.string()),
+    name: v.string(),
+    window: v.strictObject({ since: v.string(), until: v.string() }),
+    signals: v.array(v.strictObject({ id: v.string(), version: v.number() })),
+    money: v.array(v.strictObject({ direction: v.string(), currency: v.nullable(v.string()), amount: v.string(), rows: v.number() })),
+    chats: v.array(v.strictObject({
+        chat: v.string(),
+        title: v.nullable(v.string()),
+        kind: v.string(),
+        role: v.nullable(v.string()),
+        purpose: v.string(),
+        project: v.string(),
+        coverage: v.string(),
+        attention: v.number(),
+        why: v.nullable(v.string()),
+    })),
+    out_of_scope: v.optional(v.array(v.strictObject({ chat: v.string(), reason: v.string(), purpose: v.optional(v.string()) }))),
+    failed: v.optional(v.array(v.strictObject({ signal: v.string(), why: v.string() }))),
+    ...Object.fromEntries(Object.keys(STATUS_SIGNAL_ROWS).map((name) => [listKey(name.slice(7)), v.optional(v.array(statusItem))])),
+});
+const coverageOf = (found, chat) => found.items.find((one) => one.signal === "coverage" && one.chat === chat)?.data;
+const partial = (found, chat) => {
+    const held = coverageOf(found, chat.ref);
+    return held ? held.state !== "complete" && held.beforeHeld : chat.coverage.completeness.state !== "complete";
+};
+const readFrom = (found, chat) => {
+    const reply = found.items.find((one) => one.signal === "reply-next" && one.chat === chat)?.data;
+    const money = found.items
+        .filter((one) => one.signal === "amounts" && one.chat === chat && one.data.state === "open")
+        .map((one) => one.data.since)
+        .sort()[0];
+    return day([money, reply?.waitingSince, found.window.since].find((one) => typeof one === "string"));
+};
+/** At most two: the chats `attention` weighs highest, a chat held in part synced first. */
+const nextOf = (found, hints) => {
+    const byRef = new Map(found.chats.map((chat) => [chat.ref, chat]));
+    const top = found.attention.slice(0, 2).flatMap((one) => {
+        const chat = byRef.get(one.chat);
+        return chat ? [{ chat, why: one.why }] : [];
+    });
+    const because = (step, why) => (step ? [{ ...step, why }] : []);
+    const syncs = top.flatMap(({ chat, why }) => partial(found, chat) ? because(hints.sync(chat, day(found.window.since)), why) : []);
+    const reads = top.flatMap(({ chat, why }) => partial(found, chat) ? [] : because(hints.read(chat, readFrom(found, chat.ref)), why));
+    return [...syncs, ...reads].slice(0, 2);
+};
+const missingOf = (found) => {
+    const held = found.chats.filter((chat) => partial(found, chat));
+    const [first] = held;
+    return [
+        ...(first
+            ? [
+                {
+                    field: "history",
+                    why: `${held.length} of ${found.chats.length} chats hold only part of the window; ` +
+                        `the first is ${heldPhrase(first.coverage)}`,
+                    step: "messages.sync",
+                },
+            ]
+            : []),
+        ...(found.outOfScope.length
+            ? [
+                {
+                    field: "chats",
+                    why: `${found.outOfScope.length} linked chats were not read here (${[
+                        ...new Set(found.outOfScope.map((one) => one.reason)),
+                    ].join(", ")}); memo projects status reads every account`,
+                },
+            ]
+            : []),
+        ...found.failed.map((one) => ({ field: `signal:${one.signal}`, why: one.why })),
+    ];
+};
+const withPlace = (found, hints) => {
+    const titles = new Map(found.chats.map((chat) => [chat.ref, chat.title]));
+    const sync = (one) => {
+        const chat = found.chats.find((each) => each.ref === one.chat);
+        const step = chat && partial(found, chat) ? hints.sync(chat, day(found.window.since)) : null;
+        return step ? hints.line(step) : null;
+    };
+    return (one) => ({
+        ...one,
+        ref: one.evidence[0]?.ref ?? one.chat,
+        chatTitle: one.chat === null ? null : (titles.get(one.chat) ?? null),
+        ...(one.signal === "coverage" ? { syncCommand: sync(one) } : {}),
+    });
+};
+/** The answer of `projects status`: the item, two steps at most, what is missing, and the window. */
+export const projectStatusAnswer = (found, hints) => {
+    const weights = new Map(found.attention.map((one) => [one.chat, one]));
+    const place = withPlace(found, hints);
+    const lists = Object.fromEntries(found.signals.flatMap(({ id }) => {
+        const items = found.items.filter((one) => one.signal === id).map(place);
+        return items.length ? [[listKey(id), items]] : [];
+    }));
+    const item = snakeKeys({
+        project: found.project.ref,
+        key: found.project.key,
+        name: found.project.name,
+        window: found.window,
+        signals: found.signals,
+        money: found.money.open,
+        chats: found.chats.map((chat) => ({
+            chat: chat.ref,
+            title: chat.title,
+            kind: chat.kind,
+            role: chat.role,
+            purpose: chat.purpose,
+            project: chat.project,
+            coverage: chat.coverage.completeness.state,
+            attention: weights.get(chat.ref)?.weight ?? 0,
+            why: weights.get(chat.ref)?.why ?? null,
+        })),
+        ...(found.outOfScope.length ? { outOfScope: found.outOfScope } : {}),
+        ...(found.failed.length ? { failed: found.failed } : {}),
+        ...lists,
+    });
+    const missing = missingOf(found);
+    const complete = found.failed.length === 0 && !found.chats.some((chat) => partial(found, chat));
+    return {
+        item,
+        next: nextOf(found, hints),
+        missing,
+        meta: { window: found.window, complete, ...(found.accounts.length ? { accounts: found.accounts } : {}) },
+    };
+};
+const NEXT_WORDS = { owner: "YOU", them: "them", nobody: "nobody" };
+const chatLine = (found, chat) => {
+    const of = (signal) => found.items.filter((one) => one.signal === signal && one.chat === chat.ref);
+    const [last] = of("last-message");
+    const reply = of("reply-next")[0]?.data;
+    const head = [
+        `${chat.title ?? chat.ref} (${[chat.role ?? "no role", chat.kind].join(", ")})`,
+        last
+            ? `last ${day(last.at)} ${last.who?.owner ? "you" : (last.who?.name ?? "them")}`
+            : "nothing in the window",
+        ...(reply
+            ? [
+                `next: ${reply.next === "named" ? `${reply.addressed?.name ?? "someone"} (named)` : NEXT_WORDS[reply.next]}` +
+                    (reply.waitingSince ? ` since ${day(reply.waitingSince)}` : ""),
+            ]
+            : []),
+        ...(partial(found, chat) ? [heldPhrase(chat.coverage)] : []),
+    ].join(" · ");
+    const open = [];
+    const asked = of("questions").map((one) => one.data);
+    const yours = asked.filter((one) => one.side === "yours").length;
+    const theirs = asked.length - yours;
+    if (theirs)
+        open.push(`${theirs} question${theirs === 1 ? "" : "s"} to you unanswered`);
+    if (yours)
+        open.push(`${yours} question${yours === 1 ? "" : "s"} of yours unanswered`);
+    for (const topic of of("topics")) {
+        const data = topic.data;
+        if (data.silentSince)
+            open.push(`"${data.query}" quiet on their side since ${day(data.silentSince)}`);
+    }
+    const promised = of("promises").length;
+    if (promised)
+        open.push(`${promised} promise${promised === 1 ? "" : "s"}`);
+    return [`  ${head}`, ...(open.length ? [`    open: ${open.join(" · ")}`] : [])];
+};
+const moneyLine = (one, titles) => {
+    const data = one.data;
+    const asks = data.asks > 1 && data.lastAsked ? ` (asked ${data.asks}×, last ${day(data.lastAsked)})` : "";
+    const where = one.chat === null ? "" : ` · ${titles.get(one.chat) ?? one.chat}`;
+    const words = data.direction.replace("_", " ");
+    const sum = `${data.amount} ${data.currency ?? "?"} ${data.state} since ${day(data.since)}`;
+    return `  ${words.padEnd(7)} ${sum}${asks}${where} · ${one.evidence[0]?.ref ?? ""} [${one.basis}]`;
+};
+/** The human form: header, money, a line per chat with what is open, then the steps. */
+export const projectStatusText = (found, hints) => {
+    const titles = new Map(found.chats.map((chat) => [chat.ref, chat.title]));
+    const { next } = projectStatusAnswer(found, hints);
+    const money = found.items.filter((one) => one.signal === "amounts" && one.data.state !== "mentioned");
+    const payments = found.items.filter((one) => one.signal === "payments");
+    const children = found.items.filter((one) => one.signal === "children");
+    const key = found.project.key ? `${found.project.key} · ` : "";
+    const lines = [
+        `${key}${found.project.name} · ${found.chats.length} linked chats in ${found.accounts.length} accounts, ` +
+            `${day(found.window.since)} to ${day(found.window.until)}`,
+    ];
+    if (money.length || payments.length) {
+        lines.push("Money");
+        for (const one of money)
+            lines.push(moneyLine(one, titles));
+        for (const one of payments) {
+            const data = one.data;
+            lines.push(`  payment ${data.title} · ${one.evidence[0]?.ref ?? ""} [${data.status}]`);
+        }
+    }
+    if (found.chats.length)
+        lines.push("Chats");
+    for (const chat of found.chats)
+        for (const line of chatLine(found, chat))
+            lines.push(line);
+    if (children.length)
+        lines.push("Children");
+    for (const one of children) {
+        const data = one.data;
+        const cut = one.data.cut;
+        lines.push(`  ${cut ? `${data.child} not read (${cut})` : `${data.key ?? data.child} · ${data.name} · ${data.chats} chats`}`);
+    }
+    if (found.outOfScope.length)
+        lines.push(`Not read here: ${found.outOfScope.map((one) => `${one.chat} (${one.reason})`).join(", ")}`);
+    for (const one of found.failed)
+        lines.push(`Signal ${one.signal} failed: ${one.why}`);
+    if (next.length)
+        lines.push("Next");
+    next.forEach((step, index) => {
+        lines.push(`  ${index + 1}. ${hints.line(step)}`);
+    });
+    return lines.join("\n");
+};

package/dist/cli/steps.js

@@ -48,7 +48,10 @@ export const STEPS = defineSteps([
     {
         id: "messages.list",
         command: "messages list",
-        args: [{ name: "chat", required: true }],
+        args: [
+            { name: "chat", required: true },
+            { name: "query", required: false },
+        ],
         why: "only the newest were read here; this reads the chat itself",
     },
     {

package/dist/domain/knowledge.d.ts

@@ -1,4 +1,4 @@
-export declare const FACT_TYPES: readonly ["fact", "statement", "question", "decision", "promise"];
+export { FACT_TYPES } from "../meetings/index.js";
 export declare const FACT_STATUSES: readonly ["proposed", "accepted", "superseded", "reversed", "rejected"];
 export declare const MEMORY_KINDS: readonly ["summary", "digest", "preference"];
 export declare const MEMORY_STATUSES: readonly ["proposed", "confirmed", "stale", "superseded"];

package/dist/domain/knowledge.js

@@ -1,5 +1,5 @@
 import { TASK_KINDS } from "../tasks/index.js";
-export const FACT_TYPES = ["fact", "statement", "question", "decision", "promise"];
+export { FACT_TYPES } from "../meetings/index.js";
 export const FACT_STATUSES = ["proposed", "accepted", "superseded", "reversed", "rejected"];
 export const MEMORY_KINDS = ["summary", "digest", "preference"];
 export const MEMORY_STATUSES = ["proposed", "confirmed", "stale", "superseded"];

package/dist/domain/status-words.d.ts

@@ -0,0 +1,3 @@
+export declare const MONEY_DONE_FORMS: RegExp;
+/** First person future: "I'll send", "сделаю", "lo envío". Labelled a guess wherever it is shown. */
+export declare const PROMISE_FORMS: RegExp;

package/dist/domain/status-words.js

@@ -0,0 +1,44 @@
+/**
+ * Word patterns for project status, ru/en/es, matched on the text as written (case folded here). A stem cannot tell
+ * `оплатил` from `оплати`, so the past forms a money stem shares with a request are listed whole: a message with one
+ * of them reads as "done", whatever stems it also hits.
+ */
+const words = (forms) => new RegExp(`(?<![\\p{L}\\p{N}])(?:${forms.join("|")})(?![\\p{L}\\p{N}])`, "iu");
+export const MONEY_DONE_FORMS = words([
+    "оплатил[аи]?",
+    "заплатил[аи]?",
+    "перевел[аи]?",
+    "перевёл",
+    "отправил[аи]?",
+    "оплачено",
+    "переведено",
+    "paid",
+    "transferred",
+    "pagué",
+    "pagado",
+    "transferí",
+]);
+/** First person future: "I'll send", "сделаю", "lo envío". Labelled a guess wherever it is shown. */
+export const PROMISE_FORMS = words([
+    "сделаю",
+    "пришлю",
+    "отправлю",
+    "подготовлю",
+    "проверю",
+    "напишу",
+    "позвоню",
+    "скину",
+    "вышлю",
+    "оплачу",
+    "будет готов[аоы]?",
+    "i'?ll (?:send|do|check|call|write|pay|prepare|share|fix)",
+    "i will (?:send|do|check|call|write|pay|prepare|share|fix)",
+    "will be ready",
+    "lo envío",
+    "te envío",
+    "enviaré",
+    "haré",
+    "mandaré",
+    "te llamo",
+    "estará listo",
+]);

package/dist/entities/fact.d.ts

@@ -2,7 +2,7 @@ import * as v from "valibot";
 export declare const fact: v.StrictObjectSchema<{
     readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
     readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
-    readonly kind: v.PicklistSchema<readonly ["fact", "statement", "question", "decision", "promise"], undefined>;
+    readonly kind: v.PicklistSchema<readonly ["fact", "statement", "question", "decision", "promise", "payment"], undefined>;
     readonly text: v.StringSchema<undefined>;
     readonly status: v.PicklistSchema<readonly ["proposed", "accepted", "superseded", "reversed", "rejected"], undefined>;
     readonly project: v.NullableSchema<v.StringSchema<undefined>, undefined>;
@@ -29,6 +29,17 @@ export declare const fact: v.StrictObjectSchema<{
     /** Who recorded it: the owner, or an agent whose fact waits as proposed. */
     readonly origin: v.PicklistSchema<["owner", "agent"], undefined>;
     readonly evidence: v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+    /** A `payment` fact's fields. */
+    readonly payment: v.OptionalSchema<v.NullableSchema<v.StrictObjectSchema<{
+        readonly amount: v.StringSchema<undefined>;
+        readonly currency: v.StringSchema<undefined>;
+        readonly direction: v.PicklistSchema<readonly ["to_us", "from_us"], undefined>;
+        readonly counterparty: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+        readonly counterparty_name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly due_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly state: v.PicklistSchema<readonly ["expected", "paid", "cancelled"], undefined>;
+        readonly item: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>, undefined>;
     /** With `--sources`: each piece of evidence read back. */
     readonly sources: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
         readonly ref: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;

package/dist/entities/fact.js

@@ -1,6 +1,17 @@
 import * as v from "valibot";
 import { FACT_STATUSES, FACT_TYPES, MEMORY_SCOPES } from "../domain/knowledge.js";
+import { PAYMENT_DIRECTIONS, PAYMENT_STATES } from "../meetings/index.js";
 import { author, evidenceSource, id, reference, text, time } from "./fields.js";
+const payment = v.strictObject({
+    amount: text,
+    currency: text,
+    direction: v.picklist(PAYMENT_DIRECTIONS),
+    counterparty: v.nullable(reference),
+    counterparty_name: v.nullable(text),
+    due_at: v.nullable(text),
+    state: v.picklist(PAYMENT_STATES),
+    item: v.nullable(text),
+});
 export const fact = v.strictObject({
     ref: reference,
     id,
@@ -24,6 +35,8 @@ export const fact = v.strictObject({
     /** Who recorded it: the owner, or an agent whose fact waits as proposed. */
     origin: v.picklist(["owner", "agent"]),
     evidence: v.array(reference),
+    /** A `payment` fact's fields. */
+    payment: v.optional(v.nullable(payment)),
     /** With `--sources`: each piece of evidence read back. */
     sources: v.optional(v.array(evidenceSource)),
     created_at: time,

package/dist/entities/index.d.ts

@@ -1099,6 +1099,7 @@ export declare const ENTITIES: {
         readonly reached_since: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
         readonly reached_last: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
         readonly stopped: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
+        readonly limited: v.OptionalSchema<v.PicklistSchema<["group_too_large", "older_than_window"], undefined>, undefined>;
         readonly tasks: v.OptionalSchema<v.StrictObjectSchema<{
             readonly added: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
             readonly closed: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
@@ -1145,6 +1146,11 @@ export declare const ENTITIES: {
                 readonly retryable: v.BooleanSchema<undefined>;
                 readonly retry_after_ms: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
             }, v.UnknownSchema, undefined>, undefined>;
+            readonly limited: v.OptionalSchema<v.PicklistSchema<["group_too_large", "older_than_window"], undefined>, undefined>;
+        }, undefined>, undefined>;
+        readonly limited: v.OptionalSchema<v.StrictObjectSchema<{
+            readonly group_too_large: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+            readonly older_than_window: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
         }, undefined>, undefined>;
         readonly tasks: v.OptionalSchema<v.StrictObjectSchema<{
             readonly added: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
@@ -5448,7 +5454,7 @@ export declare const ENTITIES: {
     readonly fact: v.StrictObjectSchema<{
         readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
         readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
-        readonly kind: v.PicklistSchema<readonly ["fact", "statement", "question", "decision", "promise"], undefined>;
+        readonly kind: v.PicklistSchema<readonly ["fact", "statement", "question", "decision", "promise", "payment"], undefined>;
         readonly text: v.StringSchema<undefined>;
         readonly status: v.PicklistSchema<readonly ["proposed", "accepted", "superseded", "reversed", "rejected"], undefined>;
         readonly project: v.NullableSchema<v.StringSchema<undefined>, undefined>;
@@ -5471,6 +5477,16 @@ export declare const ENTITIES: {
         readonly scope: v.NullableSchema<v.PicklistSchema<readonly ["personal", "work"], undefined>, undefined>;
         readonly origin: v.PicklistSchema<["owner", "agent"], undefined>;
         readonly evidence: v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+        readonly payment: v.OptionalSchema<v.NullableSchema<v.StrictObjectSchema<{
+            readonly amount: v.StringSchema<undefined>;
+            readonly currency: v.StringSchema<undefined>;
+            readonly direction: v.PicklistSchema<readonly ["to_us", "from_us"], undefined>;
+            readonly counterparty: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+            readonly counterparty_name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly due_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly state: v.PicklistSchema<readonly ["expected", "paid", "cancelled"], undefined>;
+            readonly item: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>, undefined>;
         readonly sources: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
             readonly ref: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
             readonly kind: v.StringSchema<undefined>;
@@ -6257,7 +6273,7 @@ export declare const ENTITIES: {
                     readonly fingerprint: v.StringSchema<undefined>;
                 }, undefined>, undefined>;
                 readonly kind: v.LiteralSchema<"fact", undefined>;
-                readonly type: v.PicklistSchema<readonly ["fact", "statement", "question", "decision", "promise"], undefined>;
+                readonly type: v.PicklistSchema<readonly ["fact", "statement", "question", "decision", "promise", "payment"], undefined>;
                 readonly statement: v.StringSchema<undefined>;
             }, undefined>, v.StrictObjectSchema<{
                 readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;

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

@@ -17,7 +17,7 @@ export declare const meetingFindings: v.StrictObjectSchema<{
                 readonly fingerprint: v.StringSchema<undefined>;
             }, undefined>, undefined>;
             readonly kind: v.LiteralSchema<"fact", undefined>;
-            readonly type: v.PicklistSchema<readonly ["fact", "statement", "question", "decision", "promise"], undefined>;
+            readonly type: v.PicklistSchema<readonly ["fact", "statement", "question", "decision", "promise", "payment"], undefined>;
             readonly statement: v.StringSchema<undefined>;
         }, undefined>, v.StrictObjectSchema<{
             readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;

package/dist/entities/message-transfer.d.ts

@@ -202,6 +202,8 @@ export declare const messageSyncChat: v.StrictObjectSchema<{
     readonly reached_since: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
     readonly reached_last: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
     readonly stopped: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
+    /** The history limits stopped the read: a group too large to read, or the window's start reached. */
+    readonly limited: v.OptionalSchema<v.PicklistSchema<["group_too_large", "older_than_window"], undefined>, undefined>;
     readonly tasks: v.OptionalSchema<v.StrictObjectSchema<{
         readonly added: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
         readonly closed: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
@@ -250,6 +252,12 @@ export declare const messageSyncAll: v.StrictObjectSchema<{
             readonly retryable: v.BooleanSchema<undefined>;
             readonly retry_after_ms: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
         }, v.UnknownSchema, undefined>, undefined>;
+        readonly limited: v.OptionalSchema<v.PicklistSchema<["group_too_large", "older_than_window"], undefined>, undefined>;
+    }, undefined>, undefined>;
+    /** How many chats the history limits left unread (big groups) or read only to the window's start. */
+    readonly limited: v.OptionalSchema<v.StrictObjectSchema<{
+        readonly group_too_large: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly older_than_window: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
     }, undefined>, undefined>;
     readonly tasks: v.OptionalSchema<v.StrictObjectSchema<{
         readonly added: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
@@ -328,6 +336,8 @@ export declare const messageSync: v.UnionSchema<[v.StrictObjectSchema<{
     readonly reached_since: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
     readonly reached_last: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
     readonly stopped: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
+    /** The history limits stopped the read: a group too large to read, or the window's start reached. */
+    readonly limited: v.OptionalSchema<v.PicklistSchema<["group_too_large", "older_than_window"], undefined>, undefined>;
     readonly tasks: v.OptionalSchema<v.StrictObjectSchema<{
         readonly added: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
         readonly closed: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
@@ -375,6 +385,12 @@ export declare const messageSync: v.UnionSchema<[v.StrictObjectSchema<{
             readonly retryable: v.BooleanSchema<undefined>;
             readonly retry_after_ms: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
         }, v.UnknownSchema, undefined>, undefined>;
+        readonly limited: v.OptionalSchema<v.PicklistSchema<["group_too_large", "older_than_window"], undefined>, undefined>;
+    }, undefined>, undefined>;
+    /** How many chats the history limits left unread (big groups) or read only to the window's start. */
+    readonly limited: v.OptionalSchema<v.StrictObjectSchema<{
+        readonly group_too_large: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly older_than_window: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
     }, undefined>, undefined>;
     readonly tasks: v.OptionalSchema<v.StrictObjectSchema<{
         readonly added: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;

package/dist/entities/message-transfer.js

@@ -46,6 +46,7 @@ const tasks = v.optional(v.strictObject({
     held: v.optional(count),
     held_chats: v.optional(count),
 }));
+const historyLimited = v.picklist(["group_too_large", "older_than_window"]);
 export const messageSyncChat = v.strictObject({
     issue: v.optional(actionableError),
     resume: v.optional(v.strictObject({ before: v.optional(text) })),
@@ -59,6 +60,8 @@ export const messageSyncChat = v.strictObject({
     reached_since: v.optional(v.literal(true)),
     reached_last: v.optional(v.literal(true)),
     stopped: v.optional(v.literal(true)),
+    /** The history limits stopped the read: a group too large to read, or the window's start reached. */
+    limited: v.optional(historyLimited),
     tasks,
     /** `--full-history`: the chat's pushed history is now kept in full; `false` when the store does not know the chat. */
     history_included: v.optional(v.boolean()),
@@ -78,7 +81,10 @@ export const messageSyncAll = v.strictObject({
         stopped: v.optional(v.literal(true)),
         error: v.optional(text),
         issue: v.optional(actionableError),
+        limited: v.optional(historyLimited),
     })),
+    /** How many chats the history limits left unread (big groups) or read only to the window's start. */
+    limited: v.optional(v.strictObject({ group_too_large: count, older_than_window: count })),
     tasks,
 });
 export const messageSyncStarted = v.strictObject({ job: id, pid: count, chat: text, log: text });

package/dist/errors/reasons.js

@@ -50,6 +50,7 @@ const OTHERS = [
     validation("extraction.text-too-long", "the text is too long for memory extraction"),
     validation("file.locked", "another process holds the file's lock"),
     ["mail.source-failed", "provider_error", "the mail server refused or did not complete a request"],
+    ["mail.search-refused", "provider_error", "the mail server refused to search a folder"],
     ["mirror.partial", "provider_error", "some mirrored files were not synced"],
     ["profile.wrong-account", "authentication_error", "the signed-in source account does not match this profile"],
     validation("push.too-many-files", "the folder holds more files than one push takes"),

package/dist/mail/partial.d.ts

@@ -6,16 +6,22 @@ import type { MailSource } from "./source.js";
 export declare const PARTIAL = "partial";
 /** How many partial emails one sync reads whole at most; the rest wait for the next run. */
 export declare const PARTIAL_PER_RUN = 100;
+/** Failed reads after which a partial email is given up on (`partial.stuck`) and stays as it is. */
+export declare const PARTIAL_TRIES = 3;
 export interface PartialOutcome {
     /** Read whole this run, the mark cleared. */
     completed: number;
-    /** Still partial after this run. */
+    /** Still partial after this run, tried again by the next. */
     left: number;
+    /** Given up on: the server no longer gives this email at its stored place. They stay readable as they are. */
+    stuck: number;
 }
 /**
  * Reads whole the emails a server search stored from their first bytes, so the archive holds their attachments too.
- * Sync never reads stored mail again, so without this step a partial email would stay partial. Gmail's are found by
- * their id; elsewhere at a stored location, trusted only when the bytes read there carry the stored id.
+ * Sync never reads stored mail again, so without this step a partial email would stay partial. A source with `find`
+ * finds them by id; elsewhere they are read at their newest stored location under its UIDVALIDITY, trusted only when
+ * `identify` gives the stored id for the bytes read there. Each failed read is counted, and after `PARTIAL_TRIES`, or
+ * at once when the place holds another message, the email is left partial for good.
  */
 export declare const completePartial: ({ store, source, accountId, address, folders, maxBodyChars, maxAttachmentChars, loadEngine, now, take, signal, }: {
     store: MessageStore;