@wirecat/cli-core 0.550.0 → 0.551.0

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

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

@@ -0,0 +1,30 @@
+/** What the store holds of a chat it does not hold whole; the answer adds the line that syncs it. */
+export const coverage = {
+    id: "coverage",
+    version: 1,
+    scope: "chat",
+    read: async (context, chat) => {
+        if (!chat || chat.coverage.completeness.state === "complete")
+            return [];
+        const { completeness, held } = chat.coverage;
+        const oldest = held.oldestAt === null ? null : Date.parse(held.oldestAt);
+        return [
+            {
+                signal: "coverage",
+                chat: chat.ref,
+                at: completeness.fetchedAt,
+                who: null,
+                evidence: [],
+                basis: "store",
+                data: {
+                    state: completeness.state,
+                    held,
+                    beforeHeld: completeness.state !== "complete" && (oldest === null || context.since < oldest),
+                },
+            },
+        ];
+    },
+    attention: (items) => items.flatMap((item) => item.chat !== null && item.data.state !== "complete" && item.data.beforeHeld
+        ? [{ chat: item.chat, weight: 3, why: "held in part" }]
+        : []),
+};

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

@@ -0,0 +1,3 @@
+import type { StatusSignal } from "../types.js";
+/** The registry; its order is the answer's order. A new signal is one file here and its row in the CLI. */
+export declare const STATUS_SIGNALS: readonly StatusSignal[];

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

@@ -0,0 +1,21 @@
+import { amounts } from "./amounts.js";
+import { children } from "./children.js";
+import { coverage } from "./coverage.js";
+import { lastMessage } from "./last-message.js";
+import { payments } from "./payments.js";
+import { promises } from "./promises.js";
+import { questions } from "./questions.js";
+import { replyNext } from "./reply-next.js";
+import { topics } from "./topics.js";
+/** The registry; its order is the answer's order. A new signal is one file here and its row in the CLI. */
+export const STATUS_SIGNALS = [
+    lastMessage,
+    replyNext,
+    questions,
+    promises,
+    amounts,
+    payments,
+    topics,
+    coverage,
+    children,
+];

package/dist/services/project-status/signals/last-message.d.ts

@@ -0,0 +1,4 @@
+import type { StatusSignal } from "../types.js";
+export type LastMessageData = Record<string, never>;
+/** The newest stored message in the window: when, and who wrote it. A chat held in part says so through `coverage`. */
+export declare const lastMessage: StatusSignal<LastMessageData>;

package/dist/services/project-status/signals/last-message.js

@@ -0,0 +1,22 @@
+import { evidenceOf, whoOf } from "../items.js";
+/** The newest stored message in the window: when, and who wrote it. A chat held in part says so through `coverage`. */
+export const lastMessage = {
+    id: "last-message",
+    version: 1,
+    scope: "chat",
+    read: async (_context, chat) => {
+        const last = chat?.messages.at(-1);
+        if (!chat || !last)
+            return [];
+        const item = {
+            signal: "last-message",
+            chat: chat.ref,
+            at: last.timestamp,
+            who: whoOf(last),
+            evidence: evidenceOf(chat, last),
+            basis: "store",
+            data: {},
+        };
+        return [item];
+    },
+};

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

@@ -0,0 +1,9 @@
+import { type Payment } from "../../../meetings/index.js";
+import type { StatusSignal } from "../types.js";
+export interface PaymentsData extends Payment {
+    title: string;
+    /** The fact's review status: proposed or accepted. */
+    status: string;
+}
+/** Payment facts of the project and its children, proposed or accepted. Only what someone recorded. */
+export declare const payments: StatusSignal<PaymentsData>;

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

@@ -0,0 +1,24 @@
+import { paymentTitle } from "../../../meetings/index.js";
+const HOLDING = new Set(["proposed", "accepted"]);
+/** Payment facts of the project and its children, proposed or accepted. Only what someone recorded. */
+export const payments = {
+    id: "payments",
+    version: 2,
+    scope: "project",
+    read: async (context) => {
+        const projects = [context.project.ref, ...context.project.children.map((child) => child.ref)];
+        const facts = (await Promise.all(projects.map((project) => context.store.facts.list({ project, type: "payment", limit: 500 })))).flat();
+        return facts
+            .filter((fact) => fact.payment !== null && HOLDING.has(fact.status))
+            .map((fact) => ({
+            signal: "payments",
+            chat: null,
+            at: fact.occurredAt ?? fact.createdAt,
+            who: null,
+            // The fact first, then what it cites, so an amount read from a cited message is not counted twice.
+            evidence: [fact.ref, ...fact.evidence].map((ref) => ({ ref, fingerprint: null })),
+            basis: "fact",
+            data: { ...fact.payment, title: paymentTitle(fact), status: fact.status },
+        }));
+    },
+};

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

@@ -0,0 +1,17 @@
+import type { StatusSignal } from "../types.js";
+export interface PromisesData {
+    /** Where it came from: a stored task, a recorded fact, or a word match in a message (a guess). */
+    source: "task" | "fact" | "pattern";
+    /** `promise` or `request` for a task; a fact's and a pattern's are promises. */
+    kind: string;
+    title: string;
+    /** Who promised, for a pattern: the owner (`yours`) or the other side. */
+    side: "yours" | "theirs" | null;
+    due: string | null;
+    status: string;
+}
+/**
+ * Open promise and request tasks of the project or from its chats, promise facts proposed or accepted, and up to
+ * three promises per chat found by first person future words ("сделаю", "I'll send"), marked as patterns.
+ */
+export declare const promises: StatusSignal<PromisesData>;

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

@@ -0,0 +1,109 @@
+import { CliError } from "@wirecat/cli-base";
+import { isLocator, parseLocator } from "../../../domain/locator.js";
+import { PROMISE_FORMS } from "../../../domain/status-words.js";
+import { dueDayOf } from "../../../search/task-signature.js";
+import { normalize } from "../../../store/normalize.js";
+import { inboxKey } from "../../../store/store.js";
+import { taskAccount } from "../../task-rules.js";
+import { day, evidenceOf, excerpt, fromOwner, whoOf } from "../items.js";
+const PATTERNS_PER_CHAT = 3;
+const DAY = 86_400_000;
+const KINDS = new Set(["promise", "request"]);
+const OPEN = new Set(["open", "todo", "in_progress"]);
+const chatOfSource = (context, source) => {
+    if (source === null || !isLocator(source))
+        return undefined;
+    const { provider, account, chat } = parseLocator(source);
+    return context.chats.find((one) => one.account.provider === provider && one.account.account === account && one.chatId === chat);
+};
+// An account that never had a task has no inbox project yet.
+const orNone = (error) => {
+    if (error instanceof CliError && error.code === "not_found")
+        return [];
+    throw error;
+};
+const tasksOf = async (context) => {
+    const projects = [context.project.ref, ...context.project.children.map((child) => child.ref)];
+    const accounts = new Map(context.chats.map((chat) => [taskAccount(chat.account), chat.account]));
+    const inboxes = [...accounts.keys()].map(inboxKey);
+    const found = await Promise.all([...projects, ...inboxes].map((project) => context.store.tasks.find({ project, limit: 500 }).catch(orNone)));
+    const projectRefs = new Set(projects);
+    return found
+        .flat()
+        .filter((task) => KINDS.has(task.type) && OPEN.has(task.status))
+        .filter((task) => projectRefs.has(task.project) || chatOfSource(context, task.source) !== undefined);
+};
+const taskItem = (context, task) => ({
+    signal: "promises",
+    chat: chatOfSource(context, task.source)?.ref ?? null,
+    at: task.createdAt,
+    who: null,
+    evidence: [{ ref: task.ref, fingerprint: null }, ...(task.source ? [{ ref: task.source, fingerprint: null }] : [])],
+    basis: "task",
+    data: {
+        source: "task",
+        kind: task.type,
+        title: excerpt(task.title),
+        side: null,
+        due: task.dueAt === null ? null : day(task.dueAt),
+        status: task.status,
+    },
+});
+const patternItems = (chat) => chat.messages
+    .filter((message) => !message.text.includes("?") && PROMISE_FORMS.test(message.text))
+    .slice(-PATTERNS_PER_CHAT)
+    .reverse()
+    .map((message) => {
+    const due = dueDayOf(normalize(message.text), Date.parse(message.timestamp));
+    return {
+        signal: "promises",
+        chat: chat.ref,
+        at: message.timestamp,
+        who: whoOf(message),
+        evidence: evidenceOf(chat, message),
+        basis: "pattern",
+        data: {
+            source: "pattern",
+            kind: "promise",
+            title: excerpt(message.text),
+            side: fromOwner(message) ? "yours" : "theirs",
+            due: due === null ? null : day(due * DAY),
+            status: "open",
+        },
+    };
+});
+/**
+ * Open promise and request tasks of the project or from its chats, promise facts proposed or accepted, and up to
+ * three promises per chat found by first person future words ("сделаю", "I'll send"), marked as patterns.
+ */
+export const promises = {
+    id: "promises",
+    version: 1,
+    scope: "project",
+    read: async (context) => {
+        const projects = [context.project.ref, ...context.project.children.map((child) => child.ref)];
+        const facts = (await Promise.all(projects.map((project) => context.store.facts.list({ type: "promise", project }))))
+            .flat()
+            .filter((fact) => fact.status === "proposed" || fact.status === "accepted");
+        return [
+            ...(await tasksOf(context)).map((task) => taskItem(context, task)),
+            ...facts.map((fact) => ({
+                signal: "promises",
+                chat: null,
+                at: fact.occurredAt ?? fact.createdAt,
+                who: null,
+                evidence: [{ ref: fact.ref, fingerprint: null }],
+                basis: "fact",
+                data: {
+                    source: "fact",
+                    kind: "promise",
+                    title: excerpt(fact.statement),
+                    side: null,
+                    due: null,
+                    status: fact.status,
+                },
+            })),
+            ...context.chats.flatMap(patternItems),
+        ];
+    },
+};

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

@@ -0,0 +1,8 @@
+import type { StatusSignal } from "../types.js";
+export interface QuestionsData {
+    /** `theirs`: someone asked and the owner has not answered; `yours`: the owner asked and nobody answered. */
+    side: "theirs" | "yours";
+    excerpt: string;
+}
+/** Open questions both ways, newest first, at most five a side. A question answered in another chat stays open. */
+export declare const questions: StatusSignal<QuestionsData>;