@wirecat/cli-core 0.549.0 → 0.551.0

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

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

@@ -0,0 +1,38 @@
+import { questions as questionsOf } from "../../questions.js";
+import { evidenceOf, excerpt, whoOf } from "../items.js";
+const PER_SIDE = 5;
+const WEEK = 7 * 86_400_000;
+const NOBODY = new Set();
+/** Open questions both ways, newest first, at most five a side. A question answered in another chat stays open. */
+export const questions = {
+    id: "questions",
+    version: 1,
+    scope: "chat",
+    read: async (_context, chat) => {
+        if (!chat)
+            return [];
+        const open = (asker) => questionsOf(chat.messages, { answerers: NOBODY, asker })
+            .filter(({ answer }) => answer === undefined)
+            .map(({ question }) => question)
+            .reverse()
+            .slice(0, PER_SIDE);
+        return [
+            ["theirs", open("others")],
+            ["yours", open("owner")],
+        ].flatMap(([side, asked]) => asked.map((question) => ({
+            signal: "questions",
+            chat: chat.ref,
+            at: question.timestamp,
+            who: whoOf(question),
+            evidence: evidenceOf(chat, question),
+            basis: "store",
+            data: { side, excerpt: excerpt(question.text) },
+        })));
+    },
+    attention: (items, context) => {
+        const stale = new Set(items.flatMap((item) => item.chat !== null && item.data.side === "yours" && item.at && context.now - Date.parse(item.at) > WEEK
+            ? [item.chat]
+            : []));
+        return [...stale].map((chat) => ({ chat, weight: 1, why: "your question unanswered for a week" }));
+    },
+};

package/dist/services/project-status/signals/reply-next.d.ts

@@ -0,0 +1,19 @@
+import type { StatusSignal } from "../types.js";
+export interface ReplyNextData {
+    next: "owner" | "them" | "named" | "nobody";
+    /** Since when the one named has been the one to answer. */
+    waitingSince: string | null;
+    /** In a group: the person the newest message replies to or mentions. */
+    addressed: {
+        ref: string | null;
+        name: string | null;
+    } | null;
+    /** Waited longer than `tasks agenda` does before it lists the chat (a day for you, a week for them). */
+    overdue: boolean;
+}
+/**
+ * Whose move it is, by five rules in order: the owner wrote last → them; a dialog → the owner; in a group a message
+ * that replies to or mentions the owner, or a question right after the owner spoke → the owner; one that names
+ * another member → that member; else nobody. A name typed without a mention is not seen.
+ */
+export declare const replyNext: StatusSignal<ReplyNextData>;

package/dist/services/project-status/signals/reply-next.js

@@ -0,0 +1,75 @@
+import { AGENDA_DEFAULTS } from "../../agenda.js";
+import { evidenceOf, fromOwner, whoOf } from "../items.js";
+/** Whom a message answers or names: the quoted message's sender first, then the first mention. */
+const targetOf = (message, chat, owners) => {
+    const byId = (id) => chat.messages.find((one) => one.id === id);
+    const quoted = message.replyTo ?? (message.replyToId === undefined ? undefined : byId(message.replyToId));
+    if (quoted)
+        return {
+            owner: quoted.outgoing === true || (quoted.senderId !== null && owners.has(quoted.senderId)),
+            id: quoted.senderId,
+            name: quoted.senderName,
+        };
+    const [mentioned] = message.mentions ?? [];
+    if (mentioned === undefined)
+        return undefined;
+    if (owners.has(mentioned))
+        return { owner: true, id: mentioned, name: null };
+    const named = chat.messages.find((one) => one.senderId === mentioned);
+    return { owner: false, id: mentioned, name: named?.senderName ?? null };
+};
+const asksSomething = (message) => message.text.includes("?");
+/**
+ * Whose move it is, by five rules in order: the owner wrote last → them; a dialog → the owner; in a group a message
+ * that replies to or mentions the owner, or a question right after the owner spoke → the owner; one that names
+ * another member → that member; else nobody. A name typed without a mention is not seen.
+ */
+export const replyNext = {
+    id: "reply-next",
+    version: 1,
+    scope: "chat",
+    read: async (context, chat) => {
+        const last = chat?.messages.at(-1);
+        if (!chat || !last)
+            return [];
+        const { messages } = chat;
+        const owners = new Set(messages.flatMap((one) => (fromOwner(one) && one.senderId !== null ? [one.senderId] : [])));
+        const lastOwn = messages.findLastIndex(fromOwner);
+        const firstAfterOwn = messages[lastOwn + 1] ?? messages[0];
+        const target = targetOf(last, chat, owners);
+        const decide = () => {
+            if (last.outgoing === null)
+                return { next: "nobody", addressed: null, since: null };
+            if (fromOwner(last))
+                return {
+                    next: "them",
+                    addressed: chat.kind !== "dialog" && target && !target.owner ? { ref: null, name: target.name } : null,
+                    since: last.timestamp,
+                };
+            const since = firstAfterOwn?.timestamp ?? last.timestamp;
+            if (chat.kind === "dialog")
+                return { next: "owner", addressed: null, since };
+            if (target?.owner || (asksSomething(last) && lastOwn === messages.length - 2))
+                return { next: "owner", addressed: null, since };
+            if (target)
+                return { next: "named", addressed: { ref: null, name: target.name }, since };
+            return { next: "nobody", addressed: null, since };
+        };
+        const { next, addressed, since } = decide();
+        const waited = since === null ? 0 : context.now - Date.parse(since);
+        const overdue = (next === "owner" && waited >= AGENDA_DEFAULTS.unanswered) ||
+            (next === "them" && waited >= AGENDA_DEFAULTS.waiting);
+        return [
+            {
+                signal: "reply-next",
+                chat: chat.ref,
+                at: last.timestamp,
+                who: whoOf(last),
+                evidence: evidenceOf(chat, last),
+                basis: "store",
+                data: { next, waitingSince: since, addressed, overdue },
+            },
+        ];
+    },
+    attention: (items) => items.flatMap((item) => item.chat !== null && item.data.next === "owner" ? [{ chat: item.chat, weight: 2, why: "your move" }] : []),
+};

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

@@ -0,0 +1,10 @@
+import type { StatusSignal } from "../types.js";
+export interface TopicsData {
+    query: string;
+    yoursLast: string | null;
+    theirsLast: string | null;
+    /** Their newest mention, when the owner spoke of it later: the other side went quiet on it. */
+    silentSince: string | null;
+}
+/** Per `--context-query`, the newest message of each side that holds every one of its words, in the window. */
+export declare const topics: StatusSignal<TopicsData>;