@wirecat/cli-core 0.555.0 → 0.557.0

package/dist/cli/messenger/tasks-analysis-command.js

@@ -0,0 +1,184 @@
+import { annotate } from "@wirecat/cli-base/commands";
+import { formatLocator } from "../../domain/locator.js";
+import { storedChatId } from "../../services/message-resolution.js";
+import { momentOf } from "../../services/moment.js";
+import { ANALYSIS_PAGE, ANALYSIS_PAGE_MAX, acknowledgeTaskAnalysis, taskAnalysisList, unanalysedMessages, } from "../../services/task-analysis.js";
+import { TASK_QUERY } from "../../services/tasks.js";
+import { actorOf } from "../author.js";
+import { destroysNothing, LOCAL_READ, LOCAL_WRITE } from "../effects.js";
+import { itemOf, renderAnswer } from "../envelope.js";
+import { listQuery, pagedList, pageOf, typedQuery } from "../list-query.js";
+import { positiveCount } from "../paging.js";
+import { nextStep } from "../steps.js";
+import { messengerContext, refuseLocalWrite } from "./context.js";
+const when = (at) => (at === null ? "—" : at.slice(0, 16).replace("T", " "));
+const sinceOf = (typed) => typed === undefined ? undefined : new Date(momentOf(typed, "--since-time")).toISOString();
+const markItem = (mark) => ({
+    chat: mark.chatId,
+    from: mark.from,
+    through: mark.through,
+    through_id: mark.throughId,
+    by: mark.by,
+    checked_at: mark.checkedAt,
+    checked_through: mark.checkedThrough,
+    at: mark.at,
+});
+const analysisItem = (chat) => ({
+    chat: chat.chatId,
+    title: chat.title,
+    kind: chat.kind,
+    newest_at: chat.newestAt,
+    mark: chat.mark === null ? null : markItem(chat.mark),
+    waiting: chat.waiting,
+    late: chat.late,
+    untrusted: ["title"],
+});
+/**
+ * Each chat's own point of reading for tasks (`../../services/task-analysis.ts`): how far it was read, what waits, and
+ * the step that moves it. Apart from `inbox --new`, `review --new` and the messenger's read state, which other
+ * readers move.
+ */
+export const analysisCommands = (tasks, messenger) => {
+    const tool = messenger.app.command;
+    annotate(tasks.command("status"), {
+        output: { entity: "task_analysis" },
+        effects: LOCAL_READ,
+        examples: [`${tool} personal tasks status`],
+    })
+        .summary("how far each chat was read for tasks, and how much waits")
+        .description("every chat that can hold your tasks — not a channel or Saved Messages — with the point its messages were read " +
+        "for tasks through, who read them, how many stored messages wait after it, and how many arrived late inside " +
+        "the stretch already read (history fetched afterwards). Its own point: reading a chat, marking it read, " +
+        "inbox --new and review --new never move it; tasks acknowledge does. Reads only the local store")
+        .option("--limit <n>", "how many chats", positiveCount("--limit"))
+        .action(async function () {
+        const context = messengerContext(this, messenger);
+        const { limit, offset } = pageOf(context.settings);
+        const chats = await context.withStore((store, account) => taskAnalysisList(store, account), {
+            name: "tasks status",
+        });
+        const shown = chats.slice(offset, offset + limit);
+        renderAnswer(this, context, pagedList("tasks status", context.settings, {
+            items: shown.map(analysisItem),
+            has_more: chats.length > offset + limit,
+        }), () => shown.length === 0
+            ? ""
+            : `${shown
+                .map((one) => `${(one.title ?? one.chatId).slice(0, 30).padEnd(30)}  read through ${when(one.mark?.through ?? null)}` +
+                `  ${one.waiting} waiting${one.late > 0 ? `, ${one.late} late` : ""}`)
+                .join("\n")}\n`);
+    });
+    annotate(tasks.command("review"), {
+        output: { entity: "task_review" },
+        effects: LOCAL_READ,
+        examples: [`${tool} personal tasks review <chat>`, `${tool} personal tasks review <chat> --since-time 30d`],
+    })
+        .summary("a chat's stored messages not yet read for tasks, with its open tasks")
+        .description("the stored messages after the chat's task point, oldest first, and the chat's open tasks, so one read can open " +
+        "new tasks and update or close the old ones. A chat never read starts 14 days back. Moves nothing: when done, " +
+        "tasks acknowledge <chat> <through> records it. Reads only the local store; messages sync or backfill fetch " +
+        "what it lacks")
+        .argument("<chat>", messenger.chatArgument)
+        .option("--limit <n>", `how many messages (default ${ANALYSIS_PAGE}, ${ANALYSIS_PAGE_MAX} with --since-time; at most ${ANALYSIS_PAGE_MAX})`, positiveCount("--limit"))
+        .option("--since-time <time>", "read again from this ISO 8601 time, or 30d ago, whatever the point says; what the point already passed only " +
+        "updates and closes tasks, unless tasks add is given --open-new")
+        .action(async function (chat) {
+        const context = messengerContext(this, messenger);
+        const { sinceTime, ...options } = this.opts();
+        const since = sinceOf(sinceTime);
+        // A read again clears late messages only when one acknowledge covers the whole stretch, so it takes one page.
+        const limit = options.limit ?? (since === undefined ? ANALYSIS_PAGE : ANALYSIS_PAGE_MAX);
+        const { id, page, sourceOf } = await context.withStore(async (store, account) => {
+            const id = await storedChatId(messenger, chat, store, account, { includeLeft: true });
+            return {
+                id,
+                page: await unanalysedMessages(store, account, id, {
+                    limit: Math.min(limit, ANALYSIS_PAGE_MAX),
+                    ...(since === undefined ? {} : { since }),
+                }),
+                sourceOf: (message) => formatLocator({ ...account, chat: id, message }),
+            };
+        }, { name: "tasks review" });
+        const open = await context.withServices((services) => services.tasks.list({
+            query: listQuery(typedQuery([`chat:${JSON.stringify(id)}`, "state:open"]), TASK_QUERY, "tasks review"),
+            limit: 100,
+            offset: 0,
+        }));
+        const last = page.messages.at(-1);
+        renderAnswer(this, context, itemOf({
+            chat: id,
+            from: page.from,
+            mark: page.mark === null ? null : markItem(page.mark),
+            late: page.late,
+            has_more: page.more,
+            through: last ? sourceOf(last.id) : null,
+            messages: page.messages.map((one) => ({
+                ref: sourceOf(one.id),
+                at: one.timestamp,
+                sender: one.senderName,
+                outgoing: one.outgoing === true,
+                reply_to: one.replyTo?.id ?? one.replyToId ?? null,
+                text: one.text,
+            })),
+            open_tasks: open.items.map(({ key = null, kind, title, source_message }) => ({
+                key,
+                kind,
+                title,
+                source: source_message,
+            })),
+            untrusted: ["messages.text", "messages.sender"],
+        }, {
+            next: last && !(since !== undefined && page.more)
+                ? [
+                    nextStep("tasks.acknowledge", {
+                        args: { chat: id, message: last.id, since_time: since },
+                        values: { shown: page.messages.length },
+                    }),
+                ]
+                : [],
+        }), () => [
+            `from ${when(page.from)}: ${page.messages.length} message(s)${page.more ? ", more after them" : ""}` +
+                (page.late > 0
+                    ? `; ${page.late} arrived late inside the stretch read: --since-time ${page.mark?.from} reads it again`
+                    : ""),
+            ...page.messages.map((one) => `  ${when(one.timestamp)}  ${one.outgoing ? "you" : (one.senderName ?? "?")}: ${one.text.replace(/\s+/g, " ").slice(0, 100)}`),
+            `open tasks (${open.items.length})`,
+            ...open.items.map((task) => `  ${task.key}  ${task.kind}  ${task.title ?? ""}`),
+            ...(since !== undefined && page.more
+                ? [
+                    `this read again does not reach the point in one page: acknowledging it moves nothing and late ` +
+                        "messages stay until a later version pages a read again (tell the owner)",
+                ]
+                : last
+                    ? [`done reading: ${tool} tasks acknowledge ${id} ${last.id}`]
+                    : []),
+            "",
+        ].join("\n"));
+    });
+    destroysNothing(annotate(tasks.command("acknowledge"), {
+        output: { entity: "task_analysis_mark" },
+        effects: LOCAL_WRITE,
+        examples: [`${tool} personal tasks acknowledge <chat> <message>`],
+    }))
+        .summary("record that a chat was read for tasks through a message")
+        .description("moves the chat's task point to this message once its tasks are opened, updated or closed; it never moves " +
+        "back. With --since-time, the read started there: a read again from the start of the stretch clears what " +
+        "arrived late inside it")
+        .argument("<chat>", messenger.chatArgument)
+        .argument("<message>", "the id of the last message read, as tasks review shows it")
+        .option("--since-time <time>", "where the read started, when tasks review was given --since-time")
+        .action(async function (chat, message) {
+        const context = messengerContext(this, messenger);
+        refuseLocalWrite(context, messenger.app.command, "tasks.acknowledge");
+        const { sinceTime } = this.opts();
+        const since = sinceOf(sinceTime);
+        const by = actorOf(this);
+        const { mark, moved } = await context.withStore(async (store, account) => {
+            const id = await storedChatId(messenger, chat, store, account, { includeLeft: true });
+            return acknowledgeTaskAnalysis(store, account, id, message, { by, ...(since === undefined ? {} : { since }) });
+        }, { name: "tasks acknowledge" });
+        renderAnswer(this, context, itemOf({ ...markItem(mark), moved }), () => moved
+            ? `read for tasks from ${when(mark.from)} through ${when(mark.through)}\n`
+            : `already read through ${when(mark.through)}; the point stays\n`);
+    });
+};

package/dist/cli/messenger/tasks-command.js

@@ -5,6 +5,7 @@ import { readOnlyLockOf, readOnlyRefusal } from "../../ports/app.js";
 import { AGENDA_QUERY, agendaItem } from "../../services/agenda.js";
 import { storedChatId } from "../../services/message-resolution.js";
 import { aheadOf, momentOf } from "../../services/moment.js";
+import { refuseAlreadyRead } from "../../services/task-analysis.js";
 import { unlistedNote } from "../../services/task-categories.js";
 import { ARRIVAL_WINDOW, applyTaskRulesToChats } from "../../services/task-rules.js";
 import { CLAIM_LEASE_MS, closedStateOf, TASK_PAIR_QUERY, TASK_QUERY, taskLinkKindOf, taskTypeOf, } from "../../services/tasks.js";
@@ -18,6 +19,7 @@ import { positiveCount } from "../paging.js";
 import { messengerContext, refuseLocalWrite } from "./context.js";
 import { coverageGaps } from "./search-answers.js";
 import { refuseJsonl, taskStatsAnswer } from "./stats-answers.js";
+import { analysisCommands } from "./tasks-analysis-command.js";
 const line = ({ id, key, state, kind, group, createdAt, message, note }) => [
     key ?? id.slice(0, 8),
     state.padEnd(9),
@@ -175,11 +177,17 @@ export const tasksCommand = (messenger) => {
         .requiredOption("--type <type>", "the task's type: question, request, mention or promise", taskTypeOf)
         .requiredOption("--category <name>", categoryHelp)
         .option("--into <id>", "when tasks add listed tasks that may be the same job: link the message to this one instead of opening a task")
-        .option("--new", "when tasks add listed tasks that may be the same job: open the task anyway"), "send Alex the API token").action(async function (message) {
+        .option("--new", "when tasks add listed tasks that may be the same job: open the task anyway")
+        .option("--open-new", "open a task from a message the chat's task point already passed (a read again with tasks review " +
+        "--since-time); without it such a read only updates and closes tasks"), "send Alex the API token").action(async function (message) {
         const context = messengerContext(this, messenger);
         refuseLocalWrite(context, messenger.app.command, "tasks.add");
         const options = this.opts();
-        const { into, new: anyway, ...rest } = options;
+        const { into, new: anyway, openNew, ...rest } = options;
+        if (!openNew)
+            await context.withStore((store, account) => refuseAlreadyRead(store, account, message), {
+                name: "tasks add",
+            });
         const plan = planFrom(rest);
         const { task, created, attached, review, followUpOf, card: planned, } = await context.withServices((services) => services.tasks.add(message, options.type, writerOf(this), plan, {
             ...(into === undefined ? {} : { attach: into }),
@@ -440,6 +448,7 @@ export const tasksCommand = (messenger) => {
         }, { name: "tasks scan" });
         renderAnswer(this, context, listOf("tasks scan", { items: passes.map(snakeKeys), limit: passes.length, has_more: false }), () => `${passes.map((pass) => applyText(pass, yes, tool)).join("\n")}\n`);
     });
+    analysisCommands(tasks, messenger);
     destroysNothing(annotate(tasks.command("claim"), {
         output: { entity: "task_card" },
         effects: LOCAL_WRITE,

package/dist/cli/steps.js

@@ -209,6 +209,16 @@ export const STEPS = defineSteps([
         args: [],
         why: "serve still runs an older version; a restart runs the one installed now",
     },
+    {
+        id: "tasks.acknowledge",
+        command: "tasks acknowledge",
+        args: [
+            { name: "chat", required: true },
+            { name: "message", required: true },
+            { name: "since_time", required: false },
+        ],
+        why: "once the tasks these {shown} messages hold are opened, updated or closed, so the next review starts after them",
+    },
     {
         id: "search.meetings",
         command: "*",

package/dist/domain/finance.d.ts

@@ -0,0 +1,40 @@
+export declare const INVOICE_DIRECTIONS: readonly ["receivable", "payable"];
+export declare const INVOICE_STATUSES: readonly ["draft", "issued", "partly_paid", "paid", "void"];
+/** `in` is money to the owner, `out` money from the owner. */
+export declare const MONEY_DIRECTIONS: readonly ["in", "out"];
+/** The owner's entry is confirmed at once; an agent's or an import's waits as proposed. */
+export declare const FINANCE_REVIEWS: readonly ["proposed", "confirmed", "rejected"];
+export type InvoiceDirection = (typeof INVOICE_DIRECTIONS)[number];
+export type InvoiceStatus = (typeof INVOICE_STATUSES)[number];
+export type MoneyDirection = (typeof MONEY_DIRECTIONS)[number];
+export type FinanceReview = (typeof FINANCE_REVIEWS)[number];
+/** An invoice's status from what confirmed payments settle; `draft` and `void` are the owner's and stay. */
+export declare const settledStatus: (current: InvoiceStatus, total: number, paid: number) => InvoiceStatus;
+export interface InvoiceTitleFields {
+    id: number;
+    number: string | null;
+    direction: InvoiceDirection;
+    total: number;
+    currency: string;
+    counterpartyName: string | null;
+    dueDate: string | null;
+    status: InvoiceStatus;
+    review: FinanceReview;
+}
+/** "42 · 50 000.00 RUB to ООО Ромашка, due 15.11 (partly paid)": a ref summary's title, which `refLabel` prefixes. */
+export declare const invoiceLine: (invoice: InvoiceTitleFields) => string;
+export interface PaymentTitleFields {
+    direction: MoneyDirection;
+    amount: number;
+    currency: string;
+    /** Who paid the owner, or whom the owner paid. */
+    partyName: string | null;
+    date: string;
+    review: FinanceReview;
+}
+/** "50 000.00 RUB from ООО Ромашка, 14.11 (proposed)". */
+export declare const paymentLine: (payment: PaymentTitleFields) => string;
+/** "Invoice 42 · 50 000.00 RUB to ООО Ромашка, due 15.11 (partly paid)". */
+export declare const invoiceTitle: (invoice: InvoiceTitleFields) => string;
+/** "Payment · 50 000.00 RUB from ООО Ромашка, 14.11 (proposed)". */
+export declare const paymentEntryTitle: (payment: PaymentTitleFields) => string;

package/dist/domain/finance.js

@@ -0,0 +1,39 @@
+import { moneyLabel } from "./money.js";
+export const INVOICE_DIRECTIONS = ["receivable", "payable"];
+export const INVOICE_STATUSES = ["draft", "issued", "partly_paid", "paid", "void"];
+/** `in` is money to the owner, `out` money from the owner. */
+export const MONEY_DIRECTIONS = ["in", "out"];
+/** The owner's entry is confirmed at once; an agent's or an import's waits as proposed. */
+export const FINANCE_REVIEWS = ["proposed", "confirmed", "rejected"];
+/** An invoice's status from what confirmed payments settle; `draft` and `void` are the owner's and stay. */
+export const settledStatus = (current, total, paid) => {
+    if (current === "draft" || current === "void")
+        return current;
+    if (paid <= 0)
+        return "issued";
+    return paid < total ? "partly_paid" : "paid";
+};
+const dayMonth = (date) => (date === null ? null : `${date.slice(8, 10)}.${date.slice(5, 7)}`);
+const notes = (...words) => {
+    const kept = words.filter((word) => word !== null);
+    return kept.length === 0 ? "" : ` (${kept.join(", ")})`;
+};
+/** "42 · 50 000.00 RUB to ООО Ромашка, due 15.11 (partly paid)": a ref summary's title, which `refLabel` prefixes. */
+export const invoiceLine = (invoice) => {
+    const party = invoice.counterpartyName === null
+        ? ""
+        : `${invoice.direction === "receivable" ? " to" : " from"} ${invoice.counterpartyName}`;
+    const due = invoice.dueDate === null ? "" : `, due ${dayMonth(invoice.dueDate)}`;
+    return (`${invoice.number ?? `#${invoice.id}`} · ${moneyLabel(invoice.total, invoice.currency)}${party}${due}` +
+        notes(invoice.status.replace("_", " "), invoice.review === "confirmed" ? null : invoice.review));
+};
+/** "50 000.00 RUB from ООО Ромашка, 14.11 (proposed)". */
+export const paymentLine = (payment) => {
+    const party = payment.partyName === null ? "" : `${payment.direction === "in" ? " from" : " to"} ${payment.partyName}`;
+    return (`${moneyLabel(payment.amount, payment.currency)}${party}, ${dayMonth(payment.date)}` +
+        notes(payment.review === "confirmed" ? null : payment.review));
+};
+/** "Invoice 42 · 50 000.00 RUB to ООО Ромашка, due 15.11 (partly paid)". */
+export const invoiceTitle = (invoice) => `Invoice ${invoiceLine(invoice)}`;
+/** "Payment · 50 000.00 RUB from ООО Ромашка, 14.11 (proposed)". */
+export const paymentEntryTitle = (payment) => `Payment · ${paymentLine(payment)}`;

package/dist/domain/money.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Minor-unit digits per ISO 4217 for the currencies the store keeps money in. A currency outside the list is refused
+ * rather than guessed: a wrong scale would store every amount 100 times off.
+ */
+export declare const CURRENCY_SCALES: Readonly<Record<string, number>>;
+/** An exact amount as callers read and write it: a decimal string with the currency's scale, never a float. */
+export interface Money {
+    amount: string;
+    currency: string;
+}
+/** A non-negative decimal as an integer of `scale` decimal places; `undefined` when it is not one. */
+export declare const parseDecimal: (text: string, scale: number) => bigint | undefined;
+export declare const formatDecimal: (units: bigint | number, scale: number) => string;
+/** `50000.00` as `50 000.00`: groups of three in the whole part, as a list prints an amount. */
+export declare const groupDigits: (decimal: string) => string;
+export declare const currencyOf: (text: unknown) => string;
+export declare const scaleOf: (currency: string) => number;
+/** Minor units of `currency` for a decimal string such as "50000.00"; refuses more decimals than the currency has. */
+export declare const minorUnits: (amount: unknown, currency: string, what?: string) => number;
+export declare const moneyOf: (units: number, currency: string) => Money;
+/** "50 000.00 RUB". */
+export declare const moneyLabel: (units: number, currency: string) => string;
+/** A quantity such as "1.5" (hours, days), kept as text: at most 3 decimals, more than 0. */
+export declare const quantityOf: (text: unknown) => {
+    text: string;
+    thousandths: bigint;
+};
+/** Quantity times unit price in minor units, half rounded up. */
+export declare const lineUnits: (thousandths: bigint, unitPrice: number) => number;

package/dist/domain/money.js

@@ -0,0 +1,98 @@
+import { CliError } from "@wirecat/cli-base";
+/**
+ * Minor-unit digits per ISO 4217 for the currencies the store keeps money in. A currency outside the list is refused
+ * rather than guessed: a wrong scale would store every amount 100 times off.
+ */
+export const CURRENCY_SCALES = {
+    AED: 2,
+    AMD: 2,
+    AUD: 2,
+    BHD: 3,
+    BYN: 2,
+    CAD: 2,
+    CHF: 2,
+    CLP: 0,
+    CNY: 2,
+    CZK: 2,
+    DKK: 2,
+    EUR: 2,
+    GBP: 2,
+    GEL: 2,
+    HUF: 2,
+    ILS: 2,
+    INR: 2,
+    ISK: 0,
+    JPY: 0,
+    KGS: 2,
+    KRW: 0,
+    KWD: 3,
+    KZT: 2,
+    NOK: 2,
+    PLN: 2,
+    RSD: 2,
+    RUB: 2,
+    SEK: 2,
+    THB: 2,
+    TRY: 2,
+    UAH: 2,
+    USD: 2,
+    UZS: 2,
+    VND: 0,
+};
+const refuse = (message, reason) => {
+    throw new CliError("validation_error", message, { reason });
+};
+const DECIMAL = /^(\d{1,15})(?:\.(\d+))?$/;
+/** A non-negative decimal as an integer of `scale` decimal places; `undefined` when it is not one. */
+export const parseDecimal = (text, scale) => {
+    const match = DECIMAL.exec(text.trim());
+    if (!match || (match[2] ?? "").length > scale)
+        return undefined;
+    return BigInt(`${match[1]}${(match[2] ?? "").padEnd(scale, "0")}`);
+};
+export const formatDecimal = (units, scale) => {
+    const digits = BigInt(units)
+        .toString()
+        .padStart(scale + 1, "0");
+    return scale === 0 ? digits : `${digits.slice(0, -scale)}.${digits.slice(-scale)}`;
+};
+/** `50000.00` as `50 000.00`: groups of three in the whole part, as a list prints an amount. */
+export const groupDigits = (decimal) => {
+    const [whole = "0", fraction] = decimal.split(".");
+    const grouped = whole.replace(/\B(?=(\d{3})+(?!\d))/g, " ");
+    return fraction === undefined ? grouped : `${grouped}.${fraction}`;
+};
+export const currencyOf = (text) => {
+    const code = typeof text === "string" ? text.trim().toUpperCase() : "";
+    if (CURRENCY_SCALES[code] === undefined)
+        return refuse(`${typeof text === "string" && text.trim() ? text.trim() : "an empty currency"} is not a currency the store keeps; ` +
+            `use one of ${Object.keys(CURRENCY_SCALES).join(", ")}`, "money.currency");
+    return code;
+};
+export const scaleOf = (currency) => CURRENCY_SCALES[currencyOf(currency)];
+/** Minor units of `currency` for a decimal string such as "50000.00"; refuses more decimals than the currency has. */
+export const minorUnits = (amount, currency, what = "an amount") => {
+    const scale = scaleOf(currency);
+    const units = typeof amount === "string" ? parseDecimal(amount, scale) : undefined;
+    if (units === undefined || units > BigInt(Number.MAX_SAFE_INTEGER))
+        return refuse(`${what} is a decimal string with at most ${scale} decimal${scale === 1 ? "" : "s"} for ${currency}, ` +
+            `such as "${formatDecimal(5_000 * 10 ** scale, scale)}"`, "money.amount");
+    return Number(units);
+};
+export const moneyOf = (units, currency) => ({
+    amount: formatDecimal(units, scaleOf(currency)),
+    currency,
+});
+/** "50 000.00 RUB". */
+export const moneyLabel = (units, currency) => `${groupDigits(formatDecimal(units, scaleOf(currency)))} ${currency}`;
+const QUANTITY_SCALE = 3;
+/** A quantity such as "1.5" (hours, days), kept as text: at most 3 decimals, more than 0. */
+export const quantityOf = (text) => {
+    const thousandths = typeof text === "string" ? parseDecimal(text, QUANTITY_SCALE) : undefined;
+    if (thousandths === undefined || thousandths === 0n)
+        return refuse('a quantity is a decimal string above 0 with at most 3 decimals, such as "1.5"', "money.quantity");
+    const plain = formatDecimal(thousandths, QUANTITY_SCALE).replace(/\.?0+$/, "");
+    return { text: plain, thousandths };
+};
+/** Quantity times unit price in minor units, half rounded up. */
+export const lineUnits = (thousandths, unitPrice) => Number((thousandths * BigInt(unitPrice) + 500n) / 1000n);

package/dist/domain/ref-summaries.js

@@ -49,6 +49,8 @@ const WORDS = {
     memory: "Memory",
     fact: "Fact",
     bot: "Bot",
+    invoice: "Invoice",
+    payment: "Payment",
     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", "entity"];
+export declare const SIMPLE_REFERENCES: readonly ["note", "document", "person", "organization", "project", "task", "memory", "fact", "bot", "event", "invoice", "payment", "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

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

package/dist/entities/index.d.ts

@@ -81,14 +81,14 @@ import { automaticTags, tagChange } from "./tag-change.js";
 import { tagging } from "./tagging.js";
 import { task } from "./task.js";
 import { taskPair } from "./task-pair.js";
-import { taskCard, taskCategories, taskClosed, taskCreated, taskLinks, taskMerge, taskScan, taskSimilar, taskUnmerge } from "./task-results.js";
+import { taskAnalysis, taskAnalysisMark, taskCard, taskCategories, taskClosed, taskCreated, taskLinks, taskMerge, taskScan, taskSimilar, taskUnmerge } from "./task-results.js";
 import { topic } from "./topic.js";
 /**
  * One schema per thing a command can answer with. A command returns an entity or one of its views — a
  * subset of its fields, never a renamed one. Commands move onto these one by one; until then, a schema
  * is the target, not a description of today's output.
  */
-export { account, accountChange, accountPrivacy, accountPrivacyChange, accountProfile, accountSession, adminReport, agenda, analysisConsent, analysisConsentRevocation, attachment, attachmentBytes, attachmentExtraction, attachmentTextChange, automaticTags, botAdmin, botMenuEntry, botProfile, botSeenChat, botTemplate, botWebhook, cachedChatMetadata, callRecord, chart, chat, chatAdminChange, chatArchive, chatEvent, chatFolderChange, chatFolderOrder, chatFolderRemoval, chatGroupChange, chatInspection, chatInvite, chatInviteChange, chatMembersChange, chatMembersFetch, chatMetadata, chatMetadataRefresh, chatModeration, chatMuting, chatPin, chatRead, chatRemoval, chatRequestChange, chatRules, chatSender, chatStats, chatTracking, chatUnread, contact, contactActivity, contactAlias, contactCheck, contactContext, contactImport, contactLookup, contactNote, contactNoteRemoval, contactPreparation, contactStateChange, contactSync, contactUpdate, conversation, conversationBatch, conversationBatchStatus, conversationBuildResult, conversationChange, conversationDetails, conversationEmbedding, conversationEmbeddingStatus, conversationHit, conversationPreparation, conversationReadiness, counterRefresh, counters, document, documentLink, endedAccountSessions, evidence, evidencePacket, fact, folder, hit, identity, imageEmbedding, inviteLink, job, joinRequest, linkedPerson, mediaArchive, mediaArchiveCheck, mediaArchiveMove, mediaArchiveTimer, meeting, meetingProjectCandidates, meetingSeriesInventory, member, memory, mention, mentionDecision, mentionDetails, mentionDomain, mentionRebuild, message, messageContext, messageCounts, messageDeletion, messageDownload, messageEvent, messageLink, messageLinks, messagePin, messageStar, messageSync, messageTranscript, messageWrite, model, modelKey, note, officialStats, organization, person, place, poll, pollChange, pollVote, project, ranking, reaction, reactionChange, recipient, recipientAdded, recipientChange, recipientOff, recipientRemoved, recordedRun, reference, relationship, reminder, removedModelKey, retention, runDetails, runHit, runLocation, savedSearch, scheduledJob, searchHistoryClear, sendAttempt, serveSummary, stickerInventory, storeBackup, storeChatStatus, storeCheck, storeClear, storeCopyRemoval, storeDecrypt, storedModelKey, storeExport, storeGapPlan, storeGapRepair, storeInfo, storeJobCancel, storeJobClear, storeJobDetails, storeJobRetry, storeMigration, storeReindex, storeRepair, storeReset, storeRestore, storeTable, tagChange, tagging, task, taskCard, taskCategories, taskClosed, taskCreated, taskLinks, taskMerge, taskPair, taskScan, taskSimilar, taskStats, taskUnmerge, topic, topicIcon, trackedChat, trackedChatHistory, watchedMessage, watchItem, };
+export { account, accountChange, accountPrivacy, accountPrivacyChange, accountProfile, accountSession, adminReport, agenda, analysisConsent, analysisConsentRevocation, attachment, attachmentBytes, attachmentExtraction, attachmentTextChange, automaticTags, botAdmin, botMenuEntry, botProfile, botSeenChat, botTemplate, botWebhook, cachedChatMetadata, callRecord, chart, chat, chatAdminChange, chatArchive, chatEvent, chatFolderChange, chatFolderOrder, chatFolderRemoval, chatGroupChange, chatInspection, chatInvite, chatInviteChange, chatMembersChange, chatMembersFetch, chatMetadata, chatMetadataRefresh, chatModeration, chatMuting, chatPin, chatRead, chatRemoval, chatRequestChange, chatRules, chatSender, chatStats, chatTracking, chatUnread, contact, contactActivity, contactAlias, contactCheck, contactContext, contactImport, contactLookup, contactNote, contactNoteRemoval, contactPreparation, contactStateChange, contactSync, contactUpdate, conversation, conversationBatch, conversationBatchStatus, conversationBuildResult, conversationChange, conversationDetails, conversationEmbedding, conversationEmbeddingStatus, conversationHit, conversationPreparation, conversationReadiness, counterRefresh, counters, document, documentLink, endedAccountSessions, evidence, evidencePacket, fact, folder, hit, identity, imageEmbedding, inviteLink, job, joinRequest, linkedPerson, mediaArchive, mediaArchiveCheck, mediaArchiveMove, mediaArchiveTimer, meeting, meetingProjectCandidates, meetingSeriesInventory, member, memory, mention, mentionDecision, mentionDetails, mentionDomain, mentionRebuild, message, messageContext, messageCounts, messageDeletion, messageDownload, messageEvent, messageLink, messageLinks, messagePin, messageStar, messageSync, messageTranscript, messageWrite, model, modelKey, note, officialStats, organization, person, place, poll, pollChange, pollVote, project, ranking, reaction, reactionChange, recipient, recipientAdded, recipientChange, recipientOff, recipientRemoved, recordedRun, reference, relationship, reminder, removedModelKey, retention, runDetails, runHit, runLocation, savedSearch, scheduledJob, searchHistoryClear, sendAttempt, serveSummary, stickerInventory, storeBackup, storeChatStatus, storeCheck, storeClear, storeCopyRemoval, storeDecrypt, storedModelKey, storeExport, storeGapPlan, storeGapRepair, storeInfo, storeJobCancel, storeJobClear, storeJobDetails, storeJobRetry, storeMigration, storeReindex, storeRepair, storeReset, storeRestore, storeTable, tagChange, tagging, task, taskAnalysis, taskAnalysisMark, taskCard, taskCategories, taskClosed, taskCreated, taskLinks, taskMerge, taskPair, taskScan, taskSimilar, taskStats, taskUnmerge, topic, topicIcon, trackedChat, trackedChatHistory, watchedMessage, watchItem, };
 export declare const ENTITIES: {
     readonly meeting_ingestion: v.StrictObjectSchema<{
         readonly meetings: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
@@ -5696,6 +5696,68 @@ export declare const ENTITIES: {
             readonly category: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         }, undefined>, undefined>;
     }, undefined>;
+    readonly task_analysis: v.StrictObjectSchema<{
+        readonly chat: v.StringSchema<undefined>;
+        readonly title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly kind: v.StringSchema<undefined>;
+        readonly newest_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
+        readonly mark: v.NullableSchema<v.StrictObjectSchema<{
+            readonly chat: v.StringSchema<undefined>;
+            readonly from: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+            readonly through: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+            readonly through_id: v.StringSchema<undefined>;
+            readonly by: v.StringSchema<undefined>;
+            readonly checked_at: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+            readonly checked_through: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+            readonly at: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+        }, undefined>, undefined>;
+        readonly waiting: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly late: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly untrusted: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+    }, undefined>;
+    readonly task_analysis_mark: v.StrictObjectSchema<{
+        readonly chat: v.StringSchema<undefined>;
+        readonly from: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+        readonly through: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+        readonly through_id: v.StringSchema<undefined>;
+        readonly by: v.StringSchema<undefined>;
+        readonly checked_at: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+        readonly checked_through: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+        readonly at: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+        readonly moved: v.BooleanSchema<undefined>;
+    }, undefined>;
+    readonly task_review: v.StrictObjectSchema<{
+        readonly chat: v.StringSchema<undefined>;
+        readonly from: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+        readonly mark: v.NullableSchema<v.StrictObjectSchema<{
+            readonly chat: v.StringSchema<undefined>;
+            readonly from: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+            readonly through: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+            readonly through_id: v.StringSchema<undefined>;
+            readonly by: v.StringSchema<undefined>;
+            readonly checked_at: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+            readonly checked_through: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+            readonly at: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+        }, undefined>, undefined>;
+        readonly late: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly has_more: v.BooleanSchema<undefined>;
+        readonly through: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
+        readonly messages: v.ArraySchema<v.StrictObjectSchema<{
+            readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
+            readonly at: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
+            readonly sender: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly outgoing: v.BooleanSchema<undefined>;
+            readonly reply_to: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly text: v.StringSchema<undefined>;
+        }, undefined>, undefined>;
+        readonly open_tasks: v.ArraySchema<v.StrictObjectSchema<{
+            readonly key: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly kind: v.StringSchema<undefined>;
+            readonly title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly source: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+        readonly untrusted: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+    }, undefined>;
     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>]>;

package/dist/entities/index.js

@@ -87,14 +87,14 @@ import { automaticTags, tagChange } from "./tag-change.js";
 import { tagging } from "./tagging.js";
 import { task } from "./task.js";
 import { taskPair } from "./task-pair.js";
-import { taskCard, taskCategories, taskClosed, taskCreated, taskLinks, taskMerge, taskScan, taskSimilar, taskUnmerge, } from "./task-results.js";
+import { taskAnalysis, taskAnalysisMark, taskAnalysisMarkMoved, taskCard, taskCategories, taskClosed, taskCreated, taskLinks, taskMerge, taskReview, taskScan, taskSimilar, taskUnmerge, } from "./task-results.js";
 import { topic } from "./topic.js";
 /**
  * One schema per thing a command can answer with. A command returns an entity or one of its views — a
  * subset of its fields, never a renamed one. Commands move onto these one by one; until then, a schema
  * is the target, not a description of today's output.
  */
-export { account, accountChange, accountPrivacy, accountPrivacyChange, accountProfile, accountSession, adminReport, agenda, analysisConsent, analysisConsentRevocation, attachment, attachmentBytes, attachmentExtraction, attachmentTextChange, automaticTags, botAdmin, botMenuEntry, botProfile, botSeenChat, botTemplate, botWebhook, cachedChatMetadata, callRecord, chart, chat, chatAdminChange, chatArchive, chatEvent, chatFolderChange, chatFolderOrder, chatFolderRemoval, chatGroupChange, chatInspection, chatInvite, chatInviteChange, chatMembersChange, chatMembersFetch, chatMetadata, chatMetadataRefresh, chatModeration, chatMuting, chatPin, chatRead, chatRemoval, chatRequestChange, chatRules, chatSender, chatStats, chatTracking, chatUnread, contact, contactActivity, contactAlias, contactCheck, contactContext, contactImport, contactLookup, contactNote, contactNoteRemoval, contactPreparation, contactStateChange, contactSync, contactUpdate, conversation, conversationBatch, conversationBatchStatus, conversationBuildResult, conversationChange, conversationDetails, conversationEmbedding, conversationEmbeddingStatus, conversationHit, conversationPreparation, conversationReadiness, counterRefresh, counters, document, documentLink, endedAccountSessions, evidence, evidencePacket, fact, folder, hit, identity, imageEmbedding, inviteLink, job, joinRequest, linkedPerson, mediaArchive, mediaArchiveCheck, mediaArchiveMove, mediaArchiveTimer, meeting, meetingProjectCandidates, meetingSeriesInventory, member, memory, mention, mentionDecision, mentionDetails, mentionDomain, mentionRebuild, message, messageContext, messageCounts, messageDeletion, messageDownload, messageEvent, messageLink, messageLinks, messagePin, messageStar, messageSync, messageTranscript, messageWrite, model, modelKey, note, officialStats, organization, person, place, poll, pollChange, pollVote, project, ranking, reaction, reactionChange, recipient, recipientAdded, recipientChange, recipientOff, recipientRemoved, recordedRun, reference, relationship, reminder, removedModelKey, retention, runDetails, runHit, runLocation, savedSearch, scheduledJob, searchHistoryClear, sendAttempt, serveSummary, stickerInventory, storeBackup, storeChatStatus, storeCheck, storeClear, storeCopyRemoval, storeDecrypt, storedModelKey, storeExport, storeGapPlan, storeGapRepair, storeInfo, storeJobCancel, storeJobClear, storeJobDetails, storeJobRetry, storeMigration, storeReindex, storeRepair, storeReset, storeRestore, storeTable, tagChange, tagging, task, taskCard, taskCategories, taskClosed, taskCreated, taskLinks, taskMerge, taskPair, taskScan, taskSimilar, taskStats, taskUnmerge, topic, topicIcon, trackedChat, trackedChatHistory, watchedMessage, watchItem, };
+export { account, accountChange, accountPrivacy, accountPrivacyChange, accountProfile, accountSession, adminReport, agenda, analysisConsent, analysisConsentRevocation, attachment, attachmentBytes, attachmentExtraction, attachmentTextChange, automaticTags, botAdmin, botMenuEntry, botProfile, botSeenChat, botTemplate, botWebhook, cachedChatMetadata, callRecord, chart, chat, chatAdminChange, chatArchive, chatEvent, chatFolderChange, chatFolderOrder, chatFolderRemoval, chatGroupChange, chatInspection, chatInvite, chatInviteChange, chatMembersChange, chatMembersFetch, chatMetadata, chatMetadataRefresh, chatModeration, chatMuting, chatPin, chatRead, chatRemoval, chatRequestChange, chatRules, chatSender, chatStats, chatTracking, chatUnread, contact, contactActivity, contactAlias, contactCheck, contactContext, contactImport, contactLookup, contactNote, contactNoteRemoval, contactPreparation, contactStateChange, contactSync, contactUpdate, conversation, conversationBatch, conversationBatchStatus, conversationBuildResult, conversationChange, conversationDetails, conversationEmbedding, conversationEmbeddingStatus, conversationHit, conversationPreparation, conversationReadiness, counterRefresh, counters, document, documentLink, endedAccountSessions, evidence, evidencePacket, fact, folder, hit, identity, imageEmbedding, inviteLink, job, joinRequest, linkedPerson, mediaArchive, mediaArchiveCheck, mediaArchiveMove, mediaArchiveTimer, meeting, meetingProjectCandidates, meetingSeriesInventory, member, memory, mention, mentionDecision, mentionDetails, mentionDomain, mentionRebuild, message, messageContext, messageCounts, messageDeletion, messageDownload, messageEvent, messageLink, messageLinks, messagePin, messageStar, messageSync, messageTranscript, messageWrite, model, modelKey, note, officialStats, organization, person, place, poll, pollChange, pollVote, project, ranking, reaction, reactionChange, recipient, recipientAdded, recipientChange, recipientOff, recipientRemoved, recordedRun, reference, relationship, reminder, removedModelKey, retention, runDetails, runHit, runLocation, savedSearch, scheduledJob, searchHistoryClear, sendAttempt, serveSummary, stickerInventory, storeBackup, storeChatStatus, storeCheck, storeClear, storeCopyRemoval, storeDecrypt, storedModelKey, storeExport, storeGapPlan, storeGapRepair, storeInfo, storeJobCancel, storeJobClear, storeJobDetails, storeJobRetry, storeMigration, storeReindex, storeRepair, storeReset, storeRestore, storeTable, tagChange, tagging, task, taskAnalysis, taskAnalysisMark, taskCard, taskCategories, taskClosed, taskCreated, taskLinks, taskMerge, taskPair, taskScan, taskSimilar, taskStats, taskUnmerge, topic, topicIcon, trackedChat, trackedChatHistory, watchedMessage, watchItem, };
 export const ENTITIES = {
     sync_progress: syncProgress,
     ...MEETING_RESULT_ENTITIES,
@@ -233,6 +233,9 @@ export const ENTITIES = {
     task_unmerge: taskUnmerge,
     task_categories: taskCategories,
     task_scan: taskScan,
+    task_analysis: taskAnalysis,
+    task_analysis_mark: taskAnalysisMarkMoved,
+    task_review: taskReview,
     fact,
     memory,
     meeting,