@wirecat/cli-core 0.550.0 → 0.552.0

package/dist/services/link-scorers/types.d.ts

@@ -0,0 +1,77 @@
+import type { MessageStore } from "../../store/store.js";
+import type { AccountKey } from "../../store/types.js";
+import type { ProposalRow } from "../proposals/types.js";
+/** One scorer's reason to link a chat, a mail thread or a person to a project, or a person to a person. */
+export interface LinkCandidate {
+    /** `chat:…` (a mail thread is `chat:email/…`) or `person:…`. */
+    from: string;
+    /** `project:…`, or `person:…` for a person ↔ person rule. */
+    to: string;
+    kind: "member-of" | "related-to";
+    /** 0..1. */
+    weight: number;
+    /** Ids and counts only, never message text. */
+    why: string;
+    evidence: string[];
+    /**
+     * The `contact:<provider>/<id>` a person candidate was found by. A person candidate without one, or with one that
+     * is not that person's, is refused: people are matched by identity, never by name.
+     */
+    identity?: string;
+    /** What the chat is for in the project, one of the configured purposes; absent means the default, `work`. */
+    purpose?: string;
+}
+export interface ScannedProject {
+    ref: string;
+    name: string;
+    key: string | null;
+    aliases: string[];
+}
+export interface ScorerInput {
+    store: MessageStore;
+    /** `null` for a scan with no project, which only person ↔ person rules answer. */
+    project: ScannedProject | null;
+    confirmed: {
+        chats: string[];
+        people: string[];
+    };
+    /** Explicit; never a default account. */
+    sources: AccountKey[];
+    /** ISO 8601: the start of the window message signals count in. */
+    since: string;
+    /** The purposes the host's config lists; a candidate's purpose outside them is dropped. */
+    purposes: readonly string[];
+    /** The owner's `person:` reference, never a candidate. */
+    owner: string | null;
+    signal?: AbortSignal;
+}
+export interface LinkScorer {
+    readonly id: string;
+    readonly version: number;
+    candidates(input: ScorerInput): Promise<LinkCandidate[]>;
+}
+export type Signal = NonNullable<ProposalRow["signals"]>[number];
+export interface ScannedProposal extends LinkCandidate {
+    score: number;
+    signals: Signal[];
+    /** The stored proposal; `null` in a dry run for a pair nothing holds yet. */
+    id: string | null;
+    state: "new" | "updated" | "unchanged" | "dry-run";
+}
+export interface ScanResult {
+    project: string | null;
+    proposals: ScannedProposal[];
+    skipped: {
+        /** A link already joins the pair. */
+        confirmed: number;
+        /** The owner (or an agent for the owner) rejected the pair once; it is never proposed again. */
+        rejected: number;
+        belowThreshold: number;
+        /** Over the limit of new proposals for one run, lowest scores first. */
+        overLimit: number;
+        /** A person candidate with no identity behind it. */
+        nameOnly: number;
+        /** An end the store does not hold, or a chat outside the sources. */
+        unresolved: number;
+    };
+}

package/dist/services/link-scorers/types.js

@@ -0,0 +1 @@
+export {};

package/dist/services/messages-archive-search.js

@@ -1,5 +1,6 @@
-import { CliError, isCliError } from "@wirecat/cli-base";
+import { CliError } from "@wirecat/cli-base";
 import { parseLocator } from "../domain/locator.js";
+import { isQueryLimit } from "../search/lucene/types.js";
 import { TOTAL_CAP, totalOf } from "../search/total.js";
 import { discoveryRequest, searchDiscovery } from "./messages-discovery.js";
 import { countLucene, searchLucene, statsLucene } from "./messages-search.js";
@@ -53,7 +54,7 @@ export const searchStore = async (store, account, request, messenger = {}, meani
     const total = discovery
         ? totalOf(discovery.candidates, found.items.length, found.hasMore, !discovery.truncated)
         : totalOf(await countLucene(store, account, { ...(request.discover ? discoveryRequest(request) : request), limit: request.limit + offset }, messenger, TOTAL_CAP).catch((error) => {
-            if (isCliError(error) && error.details.reason === "query.too-large")
+            if (isQueryLimit(error))
                 return undefined;
             throw error;
         }), found.items.length, found.hasMore);

package/dist/services/messages-combined.js

@@ -4,7 +4,7 @@ import { parseLocator } from "../domain/locator.js";
 import { correctWords } from "../search/correct.js";
 import { PRESET_VERSION } from "../search/lucene/presets.js";
 import { FIELD_VERSION } from "../search/lucene/registry.js";
-import { exhausted, QUERY_LIMITS } from "../search/lucene/types.js";
+import { exhausted, outOfTime, QUERY_LIMITS } from "../search/lucene/types.js";
 import { normalize } from "../store/normalize.js";
 import { withExcerpt } from "./excerpt.js";
 import { coverageOf, prepareLucene } from "./messages-search.js";
@@ -31,7 +31,7 @@ export const searchCombined = async (store, account, request, messenger = {}, op
         if (request.signal?.aborted)
             throw new CliError("validation_error", "search was aborted", { reason: "query.aborted", complete: false });
         if (performance.now() - started > QUERY_LIMITS.milliseconds)
-            exhausted("milliseconds");
+            outOfTime();
     };
     check();
     const spans = request.ast === undefined && !request.exact && request.text !== undefined

package/dist/services/messages-discovery.js

@@ -3,7 +3,7 @@ import { implicitTextTerms, parseLucene, walkQuery } from "@wirecat/cli-base/que
 import { parseLocator } from "../domain/locator.js";
 import { fieldsOfQuery, meaningWords } from "../search/lucene/meaning-parts.js";
 import { validateFields } from "../search/lucene/registry.js";
-import { exhausted, MESSAGE_PARSING, QUERY_LIMITS } from "../search/lucene/types.js";
+import { exhausted, MESSAGE_PARSING, outOfTime, QUERY_LIMITS } from "../search/lucene/types.js";
 import { planQuestion, words } from "../search/question-plan.js";
 import { searchCombined } from "./messages-combined.js";
 import { prepareLucene, searchLucene } from "./messages-search.js";
@@ -101,7 +101,7 @@ export const searchDiscovery = async (store, account, asked, messenger = {}, mea
         if (request.signal?.aborted)
             throw new CliError("validation_error", "search was aborted", { reason: "query.aborted", complete: false });
         if (performance.now() - started > QUERY_LIMITS.milliseconds)
-            exhausted("milliseconds");
+            outOfTime();
     };
     const union = new Map();
     let truncated = false;

package/dist/services/notes-search.js

@@ -1,4 +1,4 @@
-import { CliError, isCliError } from "@wirecat/cli-base";
+import { CliError } from "@wirecat/cli-base";
 import { dateRange, parseLucene, timezoneOf } from "@wirecat/cli-base/query";
 import { INTERNAL_NOTES } from "../domain/providers.js";
 import { normalizeTag } from "../domain/tags.js";
@@ -9,7 +9,7 @@ import { entriesOfList, fitting } from "../search/account-list.js";
 import { fieldsOfQuery as fieldsOf, meaningWords } from "../search/lucene/meaning-parts.js";
 import { validateFields } from "../search/lucene/registry.js";
 import { hasStems } from "../search/lucene/resolved.js";
-import { SEARCH_QUERY } from "../search/lucene/types.js";
+import { isQueryLimit, SEARCH_QUERY } from "../search/lucene/types.js";
 import { createStemmer, DEFAULT_STEMMERS } from "../search/stem.js";
 import { TOTAL_CAP, totalOf } from "../search/total.js";
 import { openPictureEmbedderFor } from "./document-pictures.js";
@@ -286,12 +286,11 @@ const filterRefs = async (store, narrowing, scope) => {
         return found.hasMore ? undefined : found.refs;
     }
     catch (error) {
-        if (tooLarge(error))
+        if (isQueryLimit(error))
             return undefined;
         throw error;
     }
 };
-const tooLarge = (error) => isCliError(error) && error.details.reason === "query.too-large";
 /**
  * The notes the words find, with those found by meaning: every note the search would list, paged to the end. Never
  * below what the page already showed; a count the store refuses as too costly is that lower bound.
@@ -313,7 +312,7 @@ const notesTotal = async (store, text, { exact, scope, shown, hasMore, }, others
         });
     }
     catch (error) {
-        if (tooLarge(error))
+        if (isQueryLimit(error))
             return totalOf(undefined, shown, hasMore);
         throw error;
     }

package/dist/services/project-status/index.d.ts

@@ -0,0 +1,71 @@
+import type { AccountKey, MessageStore } from "../../store/store.js";
+import { STATUS_SIGNALS } from "./signals/index.js";
+import type { StatusAttention, StatusChat, StatusItem, StatusProject, StatusSignal } from "./types.js";
+export type * from "./types.js";
+export { STATUS_SIGNALS };
+/** Messages read per chat; the newest of the window. */
+export declare const STATUS_WINDOW = 300;
+/** Linked chats read at most, as `projects evidence` reads. */
+export declare const STATUS_CHATS = 16;
+/** What `projects status` reads when no purpose is asked for (built in; memo's config may change it). */
+export declare const DEFAULT_PURPOSES: readonly string[];
+export interface ProjectStatusInput {
+    /** An id, key, name or alias, as `canonicalProjectRef` takes it. */
+    project: string;
+    /** tg and max: the profile's own; left out, every account the links name. */
+    accounts?: AccountKey[];
+    days?: number;
+    after?: number;
+    asOf?: number;
+    contextQueries?: string[];
+    /** The chat purposes read; `all` reads every one. Default `DEFAULT_PURPOSES`. */
+    purposes?: readonly string[];
+    /** Default `STATUS_SIGNALS`; tests pass their own. */
+    signals?: readonly StatusSignal[];
+}
+export type StatusChatSummary = Omit<StatusChat, "messages" | "account">;
+export interface MoneyTotal {
+    direction: string;
+    currency: string | null;
+    amount: string;
+    rows: number;
+}
+export interface ProjectStatus {
+    project: StatusProject;
+    children: (StatusProject & {
+        chats: number;
+    })[];
+    window: {
+        since: string;
+        until: string;
+    };
+    /** Every account a read chat is in, `provider/account`. */
+    accounts: string[];
+    chats: StatusChatSummary[];
+    /** Every signal's items, in signal order, then chat order. */
+    items: StatusItem[];
+    /** Open amounts and expected payment facts, summed per direction and currency. */
+    money: {
+        open: MoneyTotal[];
+    };
+    outOfScope: {
+        chat: string;
+        reason: "other-account" | "linked-chat-limit" | "purpose";
+        purpose?: string;
+    }[];
+    failed: {
+        signal: string;
+        why: string;
+    }[];
+    /** Chats worth reading next, highest first. */
+    attention: StatusAttention[];
+    signals: {
+        id: string;
+        version: number;
+    }[];
+}
+/**
+ * Where a project stands, from the store alone: its linked chats and its children's, each read once, then every
+ * signal on its own. A signal that fails is named in `failed` and the others still answer. No model call.
+ */
+export declare const projectStatus: (store: MessageStore, input: ProjectStatusInput) => Promise<ProjectStatus>;

package/dist/services/project-status/index.js

@@ -0,0 +1,196 @@
+import { CliError } from "@wirecat/cli-base";
+import { formatReference } from "../../domain/references.js";
+import { chatCoverage } from "../chat-coverage.js";
+import { canonicalProjectRef, linkedChatsOf } from "../stored-project-gathering.js";
+import { centsText } from "./signals/amounts.js";
+import { STATUS_SIGNALS } from "./signals/index.js";
+export { STATUS_SIGNALS };
+const DAY = 86_400_000;
+/** Messages read per chat; the newest of the window. */
+export const STATUS_WINDOW = 300;
+/** Linked chats read at most, as `projects evidence` reads. */
+export const STATUS_CHATS = 16;
+const CHILD_DEPTH = 2;
+const CHILDREN = 8;
+/** What `projects status` reads when no purpose is asked for (built in; memo's config may change it). */
+export const DEFAULT_PURPOSES = ["work"];
+const projectsCatalog = async (store) => new Map((await store.knowledge.vocabulary({ kind: "project" })).entries.map((entry) => [`project:${entry.id}`, entry]));
+/** Confirmed `member-of` links from another project; depth two, eight at most, a project seen twice skipped. */
+const childrenOf = async (store, root, catalog) => {
+    const children = [];
+    const cut = [];
+    const seen = new Set([root.ref]);
+    let level = [root.ref];
+    for (let depth = 1; level.length > 0; depth++) {
+        const below = [];
+        for (const parent of level)
+            for (const relation of await store.knowledge.relations(null, parent)) {
+                if (!relation.confirmed || relation.kind !== "member-of" || relation.to !== parent)
+                    continue;
+                if (!relation.from.startsWith("project:"))
+                    continue;
+                const ref = relation.from;
+                const entry = catalog.get(ref);
+                if (!entry)
+                    continue;
+                if (seen.has(ref)) {
+                    if (!cut.some((one) => one.ref === ref) && !children.some((one) => one.ref === ref))
+                        cut.push({ ref, reason: "cycle" });
+                    continue;
+                }
+                seen.add(ref);
+                if (depth > CHILD_DEPTH)
+                    cut.push({ ref, reason: "depth" });
+                else if (children.length >= CHILDREN)
+                    cut.push({ ref, reason: "limit" });
+                else {
+                    children.push({ ref, key: entry.key, name: entry.name, parent, depth });
+                    below.push(ref);
+                }
+            }
+        level = below;
+    }
+    return { children, cut };
+};
+const inAccounts = (accounts, provider, account) => accounts === undefined || accounts.some((one) => one.provider === provider && one.account === account);
+const failure = (error) => (error instanceof Error ? error.message : String(error));
+/** An open ask, or an expected payment fact; an ask that a payment fact cites is counted once, as the fact. */
+const counted = (items) => {
+    const recorded = new Set(items.filter((item) => item.signal === "payments").flatMap((item) => item.evidence.slice(1).map((one) => one.ref)));
+    return (item, state) => item.signal === "payments"
+        ? state === "expected"
+        : item.signal === "amounts" && state === "open" && !item.evidence.some((one) => recorded.has(one.ref));
+};
+const totalsOf = (items) => {
+    const totals = new Map();
+    const open = counted(items);
+    for (const item of items) {
+        const data = item.data;
+        if (!open(item, data.state) || data.amount === undefined)
+            continue;
+        const key = `${data.direction}|${data.currency ?? ""}`;
+        const total = totals.get(key) ?? {
+            direction: data.direction ?? "unknown",
+            currency: data.currency ?? null,
+            amount: "0.00",
+            rows: 0,
+            cents: 0,
+        };
+        total.cents += Math.round(Number(data.amount) * 100);
+        total.rows += 1;
+        totals.set(key, total);
+    }
+    return [...totals.values()].map(({ cents, ...total }) => ({ ...total, amount: centsText(cents) }));
+};
+/**
+ * Where a project stands, from the store alone: its linked chats and its children's, each read once, then every
+ * signal on its own. A signal that fails is named in `failed` and the others still answer. No model call.
+ */
+export const projectStatus = async (store, input) => {
+    const now = input.asOf ?? Date.now();
+    const since = input.after ?? now - (input.days ?? 60) * DAY;
+    if (!(since < now))
+        throw new CliError("validation_error", "the window must start before it ends");
+    const signals = input.signals ?? STATUS_SIGNALS;
+    const purposes = new Set(input.purposes ?? DEFAULT_PURPOSES);
+    const catalog = await projectsCatalog(store);
+    const ref = await canonicalProjectRef(store, input.project);
+    const entry = catalog.get(ref);
+    if (!entry)
+        throw new CliError("not_found", "the owner project is unavailable");
+    const root = { ref, key: entry.key, name: entry.name };
+    const { children, cut } = await childrenOf(store, root, catalog);
+    const outOfScope = [];
+    const linked = new Map();
+    for (const project of [root, ...children])
+        for (const link of await linkedChatsOf(store, project.ref)) {
+            const chat = formatReference({ type: "chat", provider: link.provider, account: link.account, chat: link.chat });
+            if (!linked.has(chat))
+                linked.set(chat, { ...link, project: project.ref });
+        }
+    const chosen = [];
+    for (const [chat, link] of linked) {
+        // Links carry no purpose yet; every one is `work`, as a link without one will be.
+        const purpose = "work";
+        if (!purposes.has("all") && !purposes.has(purpose))
+            outOfScope.push({ chat, reason: "purpose", purpose });
+        else if (!inAccounts(input.accounts, link.provider, link.account))
+            outOfScope.push({ chat, reason: "other-account" });
+        else if (chosen.length >= STATUS_CHATS)
+            outOfScope.push({ chat, reason: "linked-chat-limit" });
+        else
+            chosen.push([chat, link]);
+    }
+    const sinceIso = new Date(since).toISOString();
+    const chats = [];
+    for (const [chat, link] of chosen) {
+        const account = { provider: link.provider, account: link.account };
+        const [coverage] = await chatCoverage(store, account, [link.chat]);
+        const page = await store.messages.messages(account, link.chat, { limit: STATUS_WINDOW, since: sinceIso });
+        chats.push({
+            ref: chat,
+            account,
+            chatId: link.chat,
+            title: coverage?.title ?? null,
+            kind: (await store.chats.chatKind(account, link.chat)) ?? "unknown",
+            role: link.role,
+            purpose: "work",
+            project: link.project,
+            coverage: coverage,
+            messages: page.items.filter((message) => Date.parse(message.timestamp) <= now),
+        });
+    }
+    const context = {
+        now,
+        since,
+        chats,
+        project: { ...root, children, cut },
+        store,
+        contextQueries: input.contextQueries ?? [],
+    };
+    const items = [];
+    const failed = [];
+    const weights = new Map();
+    for (const signal of signals) {
+        try {
+            const found = signal.scope === "chat"
+                ? (await Promise.all(chats.map((chat) => signal.read(context, chat)))).flat()
+                : await signal.read(context);
+            for (const one of signal.attention?.(found, context) ?? []) {
+                const held = weights.get(one.chat) ?? { weight: 0, why: [] };
+                held.weight += Math.max(0, Math.min(3, one.weight));
+                if (!held.why.includes(one.why))
+                    held.why.push(one.why);
+                weights.set(one.chat, held);
+            }
+            for (const one of found)
+                items.push(one);
+        }
+        catch (error) {
+            failed.push({ signal: signal.id, why: failure(error) });
+        }
+    }
+    const order = new Map(chats.map((chat, index) => [chat.ref, index]));
+    const attention = [...weights]
+        .filter(([, { weight }]) => weight > 0)
+        .map(([chat, { weight, why }]) => ({ chat, weight, why: why.join(", ") }))
+        .sort((a, b) => b.weight - a.weight || (order.get(a.chat) ?? 0) - (order.get(b.chat) ?? 0));
+    return {
+        project: root,
+        children: children.map(({ ref, key, name }) => ({
+            ref,
+            key,
+            name,
+            chats: chats.filter((chat) => chat.project === ref).length,
+        })),
+        window: { since: sinceIso, until: new Date(now).toISOString() },
+        accounts: [...new Set(chats.map((chat) => `${chat.account.provider}/${chat.account.account}`))],
+        chats: chats.map(({ messages: _messages, account: _account, ...chat }) => chat),
+        items,
+        money: { open: totalsOf(items) },
+        outOfScope,
+        failed,
+        attention,
+        signals: signals.map(({ id, version }) => ({ id, version })),
+    };
+};

package/dist/services/project-status/items.d.ts

@@ -0,0 +1,10 @@
+import type { Message } from "../../domain/models.js";
+import type { StatusChat, StatusItem, StatusWho } from "./types.js";
+/** The most of a message's text any status item carries. */
+export declare const EXCERPT_CHARS = 80;
+export declare const excerpt: (text: string) => string;
+export declare const messageRef: (chat: StatusChat, message: Pick<Message, "id">) => string;
+export declare const evidenceOf: (chat: StatusChat, ...messages: Pick<Message, "id">[]) => StatusItem["evidence"];
+export declare const whoOf: (message: Pick<Message, "outgoing" | "senderName">) => StatusWho;
+export declare const fromOwner: (message: Pick<Message, "outgoing">) => boolean;
+export declare const day: (at: number | string) => string;

package/dist/services/project-status/items.js

@@ -0,0 +1,23 @@
+import { formatLocator } from "../../domain/locator.js";
+/** The most of a message's text any status item carries. */
+export const EXCERPT_CHARS = 80;
+export const excerpt = (text) => {
+    const flat = text.replace(/\s+/g, " ").trim();
+    const letters = Array.from(flat);
+    return letters.length <= EXCERPT_CHARS ? flat : `${letters.slice(0, EXCERPT_CHARS - 1).join("")}…`;
+};
+export const messageRef = (chat, message) => formatLocator({
+    provider: chat.account.provider,
+    account: chat.account.account,
+    chat: chat.chatId,
+    message: message.id,
+});
+export const evidenceOf = (chat, ...messages) => messages.slice(0, 8).map((message) => ({ ref: messageRef(chat, message), fingerprint: null }));
+// Person refs wait for the shared ref summaries; until then the sender's stored name is the label.
+export const whoOf = (message) => ({
+    ref: null,
+    name: message.outgoing === true ? null : message.senderName,
+    owner: message.outgoing === true,
+});
+export const fromOwner = (message) => message.outgoing === true;
+export const day = (at) => new Date(at).toISOString().slice(0, 10);

package/dist/services/project-status/signals/amounts.d.ts

@@ -0,0 +1,20 @@
+import type { StatusSignal } from "../types.js";
+export type MoneyDirection = "to_us" | "from_us" | "unknown";
+export interface AmountsData {
+    /** Decimal as text, two places: money is never a float. */
+    amount: string;
+    currency: string | null;
+    direction: MoneyDirection;
+    /** `paid-mentioned` is a message saying so, never a payment the owner recorded. */
+    state: "open" | "paid-mentioned" | "mentioned";
+    /** The first ask, or the first mention when nobody asked. */
+    since: string;
+    lastAsked: string | null;
+    asks: number;
+}
+export declare const centsText: (cents: number) => string;
+/**
+ * Every message with an amount and a money word, folded by amount and currency per chat: the first ask is `since`, a
+ * later "paid" message naming the same amount makes it `paid-mentioned`. Instalments are not summed into a total.
+ */
+export declare const amounts: StatusSignal<AmountsData>;

package/dist/services/project-status/signals/amounts.js

@@ -0,0 +1,91 @@
+import { MONEY_DONE, MONEY_REQUEST } from "../../../domain/money-words.js";
+import { MONEY_DONE_FORMS } from "../../../domain/status-words.js";
+import { DEFAULT_TASK_CATEGORIES } from "../../../domain/task-categories.js";
+import { amountsOf } from "../../../search/task-signature.js";
+import { moneyClassesOf } from "../../money-words.js";
+import { listsHit } from "../../task-categories.js";
+import { evidenceOf, fromOwner, whoOf } from "../items.js";
+const MONEY = DEFAULT_TASK_CATEGORIES.filter((category) => category.name === "money");
+// Past forms first: their stem is also a request's (`оплатил` and `оплати` → `оплат`).
+const verbOf = (text) => {
+    if (MONEY_DONE_FORMS.test(text))
+        return "done";
+    const classes = moneyClassesOf(text);
+    if (classes.includes(MONEY_DONE))
+        return "done";
+    return classes.includes(MONEY_REQUEST) ? "request" : "none";
+};
+const roleDirection = (role) => {
+    const named = role?.trim().toLowerCase();
+    return named === "client" ? "to_us" : named === "contractor" ? "from_us" : "unknown";
+};
+/** The sender's side decides: a stem cannot tell an ask from a report, so who wrote it is the evidence. */
+const directionOf = (verb, owner, role) => {
+    if (verb === "request")
+        return owner ? "to_us" : "from_us";
+    if (verb === "done")
+        return owner ? "from_us" : "to_us";
+    return roleDirection(role);
+};
+const rowsOf = (chat) => chat.messages.flatMap((message) => {
+    const found = amountsOf(message.text);
+    if (!found.length)
+        return [];
+    const verb = verbOf(message.text);
+    if (verb === "none" && !listsHit(message.text, MONEY).length)
+        return [];
+    const direction = directionOf(verb, fromOwner(message), chat.role);
+    return found.map(({ value, currency }) => ({
+        message,
+        cents: Math.round(value * 100),
+        currency,
+        verb,
+        direction,
+    }));
+});
+export const centsText = (cents) => `${Math.floor(cents / 100)}.${String(cents % 100).padStart(2, "0")}`;
+/**
+ * Every message with an amount and a money word, folded by amount and currency per chat: the first ask is `since`, a
+ * later "paid" message naming the same amount makes it `paid-mentioned`. Instalments are not summed into a total.
+ */
+export const amounts = {
+    id: "amounts",
+    version: 1,
+    scope: "chat",
+    read: async (_context, chat) => {
+        if (!chat)
+            return [];
+        const groups = new Map();
+        for (const row of rowsOf(chat)) {
+            const key = `${row.cents}|${row.currency ?? ""}`;
+            groups.set(key, [...(groups.get(key) ?? []), row]);
+        }
+        return [...groups.values()].map((rows) => {
+            const asks = rows.filter((row) => row.verb === "request");
+            const done = rows.filter((row) => row.verb === "done");
+            const lastAsk = asks.at(-1);
+            const first = (asks[0] ?? done[0] ?? rows[0]);
+            const paidAfter = done.some((row) => !lastAsk || Date.parse(row.message.timestamp) >= Date.parse(lastAsk.message.timestamp));
+            const state = asks.length ? (paidAfter ? "paid-mentioned" : "open") : done.length ? "paid-mentioned" : "mentioned";
+            const cited = asks.length ? [...asks, ...(paidAfter ? done.slice(-1) : [])] : rows;
+            return {
+                signal: "amounts",
+                chat: chat.ref,
+                at: first.message.timestamp,
+                who: whoOf(first.message),
+                evidence: evidenceOf(chat, ...new Set(cited.map((row) => row.message))),
+                basis: "pattern",
+                data: {
+                    amount: centsText(first.cents),
+                    currency: first.currency,
+                    direction: first.direction,
+                    state,
+                    since: first.message.timestamp,
+                    lastAsked: lastAsk?.message.timestamp ?? null,
+                    asks: asks.length,
+                },
+            };
+        });
+    },
+    attention: (items) => items.flatMap((item) => item.chat !== null && item.data.state === "open" ? [{ chat: item.chat, weight: 2, why: "money open" }] : []),
+};

package/dist/services/project-status/signals/children.d.ts

@@ -0,0 +1,13 @@
+import type { StatusSignal } from "../types.js";
+export interface ChildrenData {
+    child: string;
+    key: string | null;
+    name: string | null;
+    depth: number | null;
+    /** Linked chats read for it; a chat linked to two projects counts once, under the first. */
+    chats: number | null;
+    /** Why it was not read: deeper than two levels, seen twice, or past eight children. */
+    cut: "depth" | "cycle" | "limit" | null;
+}
+/** Child projects (a confirmed `member-of` link to this one) that were read, and those cut. */
+export declare const children: StatusSignal<ChildrenData>;

package/dist/services/project-status/signals/children.js

@@ -0,0 +1,28 @@
+/** Child projects (a confirmed `member-of` link to this one) that were read, and those cut. */
+export const children = {
+    id: "children",
+    version: 1,
+    scope: "project",
+    read: async (context) => {
+        const item = (data) => ({
+            signal: "children",
+            chat: null,
+            at: null,
+            who: null,
+            evidence: [{ ref: data.child, fingerprint: null }],
+            basis: "store",
+            data,
+        });
+        return [
+            ...context.project.children.map((child) => item({
+                child: child.ref,
+                key: child.key,
+                name: child.name,
+                depth: child.depth,
+                chats: context.chats.filter((chat) => chat.project === child.ref).length,
+                cut: null,
+            })),
+            ...context.project.cut.map(({ ref, reason }) => item({ child: ref, key: null, name: null, depth: null, chats: null, cut: reason })),
+        ];
+    },
+};

package/dist/services/project-status/signals/coverage.d.ts

@@ -0,0 +1,13 @@
+import type { StatusSignal } from "../types.js";
+export interface CoverageData {
+    state: "complete" | "partial" | "unknown";
+    held: {
+        messages: number;
+        oldestAt: string | null;
+        newestAt: string | null;
+    };
+    /** The window starts before the oldest message the store holds, so the window is not read whole. */
+    beforeHeld: boolean;
+}
+/** What the store holds of a chat it does not hold whole; the answer adds the line that syncs it. */
+export declare const coverage: StatusSignal<CoverageData>;