@wirecat/cli-core 0.549.0 → 0.551.0

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

@@ -0,0 +1,244 @@
+import { CliError } from "@wirecat/cli-base";
+import { parseReference } from "../../domain/references.js";
+import { canonicalProjectRef } from "../stored-project-gathering.js";
+import { aliasHits } from "./alias-hits.js";
+import { chatSenders } from "./chat-senders.js";
+import { chatTitle } from "./chat-title.js";
+import { emailDomain } from "./email-domain.js";
+import { mailThread } from "./mail-thread.js";
+import { memberChats } from "./member-chats.js";
+import { memberDialog } from "./member-dialog.js";
+import { sameAccount } from "./shared.js";
+/** A new scorer is one file and one line here. */
+export const SCORERS = [chatTitle, aliasHits, memberChats, memberDialog, chatSenders, mailThread];
+/** What a scan with no project runs: person ↔ person rules. */
+export const PERSON_SCORERS = [emailDomain];
+/** The rule bot every scan proposal is written by: only the owner decides its proposals. */
+export const SCAN_BOT = { bot: "memo-scan", kind: "rule" };
+export const BUILT_IN_PURPOSES = ["work", "sales", "support", "other"];
+export const DEFAULT_THRESHOLD = 0.5;
+/** A person ↔ person scan keeps the old rule's reach: one weak signal is enough to ask the owner. */
+export const PERSON_THRESHOLD = 0.3;
+export const DEFAULT_LIMIT = 20;
+const projectOf = async (store, reference) => {
+    const ref = await canonicalProjectRef(store, reference);
+    const entry = (await store.knowledge.vocabulary({ kind: "project" })).entries.find((one) => one.id === ref.slice(8));
+    if (!entry)
+        throw new CliError("not_found", `no project ${reference}`);
+    return { ref, name: entry.name, key: entry.key, aliases: entry.aliases.map((alias) => alias.name) };
+};
+const confirmedOf = async (store, project) => {
+    if (!project)
+        return { chats: [], people: [] };
+    const members = (await store.knowledge.relations(null, project.ref)).filter((one) => one.confirmed && one.kind === "member-of" && one.to === project.ref);
+    return {
+        chats: [...new Set(members.map((one) => one.from).filter((ref) => ref.startsWith("chat:")))].sort(),
+        people: [...new Set(members.map((one) => one.from).filter((ref) => ref.startsWith("person:")))].sort(),
+    };
+};
+const checkedSources = async (store, sources) => {
+    const stored = await store.accounts.accounts();
+    const choices = stored.map((one) => `${one.provider}:${one.account}`);
+    if (!Array.isArray(sources) || sources.length === 0)
+        throw new CliError("validation_error", "a scan names the accounts it reads; none is picked for you", {
+            param: "source",
+            choices,
+        });
+    for (const source of sources)
+        if (!stored.some((one) => one.provider === source.provider && String(one.account) === String(source.account)))
+            throw new CliError("not_found", `the store holds no account ${source.provider}:${source.account}`, {
+                param: "source",
+                choices,
+            });
+    return sources;
+};
+const pairKey = ({ from, to, kind }) => `${from}\u0000${to}\u0000${kind}`;
+/** 1 − Π(1 − wᵢ), over each scorer's strongest signal for the pair. */
+export const combinedScore = (weights) => Math.round((1 - weights.reduce((left, weight) => left * (1 - weight), 1)) * 1000) / 1000;
+/**
+ * Runs the scorers for one project over the sources named, combines their signals per pair, and proposes what scores
+ * `threshold` or more, highest first, at most `limit` new ones. A pair a link joins, or that was rejected once, is
+ * never proposed; a pending one is updated in place. People are matched by identity only. With `write: false`
+ * nothing is written.
+ */
+export const scanProjectLinks = async (store, input) => {
+    const limit = input.limit ?? DEFAULT_LIMIT;
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > 50)
+        throw new CliError("validation_error", "a scan proposes 1–50 links a run", { param: "limit" });
+    const threshold = input.threshold ?? (input.project === null ? PERSON_THRESHOLD : DEFAULT_THRESHOLD);
+    if (typeof threshold !== "number" || !(threshold > 0 && threshold <= 1))
+        throw new CliError("validation_error", "a scan's threshold is more than 0 and at most 1", { param: "threshold" });
+    const since = Date.parse(input.since);
+    if (Number.isNaN(since))
+        throw new CliError("validation_error", "a scan's window starts at an ISO 8601 time", { param: "since" });
+    const sources = await checkedSources(store, input.sources);
+    const project = input.project === null ? null : await projectOf(store, input.project);
+    const owner = await store.people.owner();
+    const scorerInput = {
+        store,
+        project,
+        confirmed: await confirmedOf(store, project),
+        sources,
+        since: new Date(since).toISOString(),
+        purposes: input.purposes ?? BUILT_IN_PURPOSES,
+        owner: owner ? `person:${owner.uid}` : null,
+        ...(input.signal ? { signal: input.signal } : {}),
+    };
+    const scorers = input.scorers ?? (project ? SCORERS : PERSON_SCORERS);
+    const skipped = {
+        confirmed: 0,
+        rejected: 0,
+        belowThreshold: 0,
+        overLimit: 0,
+        nameOnly: 0,
+        unresolved: 0,
+    };
+    const pairs = new Map();
+    const nameOnly = new Set();
+    for (const scorer of scorers) {
+        input.signal?.throwIfAborted();
+        for (const candidate of await scorer.candidates(scorerInput)) {
+            const key = pairKey(candidate);
+            const verdict = await admissible(store, scorerInput, candidate);
+            if (verdict === "owner")
+                continue;
+            if (verdict === "name-only") {
+                if (!nameOnly.has(key))
+                    skipped.nameOnly++;
+                nameOnly.add(key);
+                continue;
+            }
+            if (verdict !== "ok") {
+                skipped.unresolved++;
+                continue;
+            }
+            const weight = Math.min(1, Math.max(0, candidate.weight));
+            const held = pairs.get(key) ?? { candidate, signals: new Map() };
+            const scorerId = `${scorer.id}@${scorer.version}`;
+            const before = held.signals.get(scorerId);
+            if (!before || before.weight < weight)
+                held.signals.set(scorerId, {
+                    scorer: scorerId,
+                    weight,
+                    why: candidate.why.slice(0, 500),
+                    ...(candidate.purpose && scorerInput.purposes.includes(candidate.purpose)
+                        ? { purpose: candidate.purpose }
+                        : {}),
+                });
+            held.candidate = {
+                ...held.candidate,
+                evidence: [...new Set([...held.candidate.evidence, ...candidate.evidence])],
+            };
+            pairs.set(key, held);
+        }
+    }
+    const scored = [...pairs.values()]
+        .map(({ candidate, signals }) => {
+        const list = [...signals.values()].sort((a, b) => b.weight - a.weight || a.scorer.localeCompare(b.scorer));
+        const purpose = list.find((one) => one.purpose)?.purpose;
+        return {
+            candidate,
+            purpose,
+            signals: list.map(({ scorer, weight, why }) => ({ scorer, weight, why })),
+            score: combinedScore(list.map((one) => one.weight)),
+        };
+    })
+        .sort((a, b) => b.score - a.score || a.candidate.from.localeCompare(b.candidate.from));
+    const proposals = [];
+    let fresh = 0;
+    for (const { candidate, purpose, signals, score } of scored) {
+        const state = await store.knowledge.relationState(null, candidate);
+        if (!state) {
+            skipped.unresolved++;
+            continue;
+        }
+        if (state.linked) {
+            skipped.confirmed++;
+            continue;
+        }
+        if (state.rejected || (await rejectedReversed(store, candidate))) {
+            skipped.rejected++;
+            continue;
+        }
+        if (score < threshold) {
+            skipped.belowThreshold++;
+            continue;
+        }
+        if (!state.pending && fresh >= limit) {
+            skipped.overLimit++;
+            continue;
+        }
+        if (!state.pending)
+            fresh++;
+        const { identity: _identity, purpose: _purpose, weight: _weight, why: _why, ...pair } = candidate;
+        const evidence = candidate.evidence.slice(0, 5);
+        const proposal = {
+            ...pair,
+            weight: score,
+            why: signals.map((one) => one.why).join("; "),
+            evidence,
+            ...(purpose ? { purpose } : {}),
+            score,
+            signals,
+        };
+        if (!input.write) {
+            proposals.push({ ...proposal, id: state.pending?.id ?? null, state: "dry-run" });
+            continue;
+        }
+        const written = await store.knowledge.proposeRelation(null, {
+            from: pair.from,
+            to: pair.to,
+            kind: pair.kind,
+            evidence,
+            reason: proposal.why.slice(0, 2000),
+            score,
+            signals,
+            ...(purpose ? { purpose } : {}),
+        }, SCAN_BOT);
+        proposals.push({
+            ...proposal,
+            id: written.id,
+            state: !state.pending
+                ? "new"
+                : JSON.stringify(written.payload) === JSON.stringify(state.pending.payload)
+                    ? "unchanged"
+                    : "updated",
+        });
+    }
+    return { project: project?.ref ?? null, proposals, skipped };
+};
+/** A person candidate stands only on an identity that is that person's; a chat only in a source the scan reads. */
+const admissible = async (store, input, candidate) => {
+    if (candidate.from === candidate.to || !Number.isFinite(candidate.weight))
+        return "unresolved";
+    if (input.project && candidate.to !== input.project.ref && !candidate.to.startsWith("person:"))
+        return "unresolved";
+    if (candidate.from === input.owner || candidate.to === input.owner)
+        return "owner";
+    if (candidate.from.startsWith("person:")) {
+        const identity = candidate.identity === undefined ? undefined : referenceOf(candidate.identity);
+        if (identity?.type !== "contact")
+            return "name-only";
+        const person = await store.people.personOf({ provider: identity.provider, id: identity.id });
+        return person !== undefined && `person:${person.uid}` === candidate.from ? "ok" : "name-only";
+    }
+    if (candidate.from.startsWith("chat:")) {
+        const chat = referenceOf(candidate.from);
+        return chat?.type === "chat" && input.sources.some((source) => sameAccount(source, chat)) ? "ok" : "unresolved";
+    }
+    return "unresolved";
+};
+const referenceOf = (text) => {
+    try {
+        return parseReference(text);
+    }
+    catch {
+        return undefined;
+    }
+};
+/** A person ↔ person relation reads both ways: rejecting B → A also rejects A → B. */
+const rejectedReversed = async (store, candidate) => candidate.kind === "related-to" &&
+    candidate.to.startsWith("person:") &&
+    ((await store.knowledge.relationState(null, { from: candidate.to, to: candidate.from, kind: candidate.kind }))
+        ?.rejected ??
+        false);

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

@@ -0,0 +1,26 @@
+import type { Id } from "../../domain/models.js";
+import type { MessageStore } from "../../store/store.js";
+import type { AccountKey } from "../../store/types.js";
+import type { ScannedProject } from "./types.js";
+/** A whole-word test, the rule the evidence lanes and meeting candidates use: «Harbour» is not in «Harbourside». */
+export declare const wholeWords: (term: string) => RegExp;
+/** The project's name, key and aliases, each once. */
+export declare const projectTerms: (project: ScannedProject) => string[];
+/** The first of the project's terms a text names as whole words. */
+export declare const namesProject: (project: ScannedProject) => ((text: string | null | undefined) => string | undefined);
+export declare const chatRef: (key: AccountKey, chat: Id) => string;
+export declare const contactRef: (provider: string, id: Id) => string;
+export declare const sameAccount: (a: AccountKey, b: {
+    provider: string;
+    account: string;
+}) => boolean;
+/** The person an identity is, as `person:<uid>`; `undefined` when the store has no person for it. */
+export declare const personRefOf: (store: MessageStore, provider: string, id: Id) => Promise<string | undefined>;
+/** How many projects a person is a confirmed member of. */
+export declare const projectsOf: (store: MessageStore, person: string) => Promise<number>;
+/** Each confirmed member's identities in one messenger, by member. */
+export declare const identitiesIn: (store: MessageStore, people: readonly string[], provider: string) => Promise<{
+    person: string;
+    id: string;
+}[]>;
+export declare const aborted: (signal: AbortSignal | undefined) => void;

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

@@ -0,0 +1,48 @@
+import { formatReference } from "../../domain/references.js";
+import { normalizeVocabularyName } from "../../domain/vocabulary.js";
+const escaped = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const folded = (text) => text.normalize("NFKC").toLowerCase().replace(/\s+/gu, " ");
+/** A whole-word test, the rule the evidence lanes and meeting candidates use: «Harbour» is not in «Harbourside». */
+export const wholeWords = (term) => new RegExp(`(?<![\\p{L}\\p{N}\\p{M}_])${escaped(normalizeVocabularyName(term))}(?![\\p{L}\\p{N}\\p{M}_])`, "u");
+/** The project's name, key and aliases, each once. */
+export const projectTerms = (project) => {
+    const terms = new Map();
+    for (const term of [project.name, project.key, ...project.aliases])
+        if (term?.trim())
+            terms.set(normalizeVocabularyName(term), term);
+    return [...terms.values()];
+};
+/** The first of the project's terms a text names as whole words. */
+export const namesProject = (project) => {
+    const patterns = projectTerms(project).map((term) => ({ term, pattern: wholeWords(term) }));
+    return (text) => {
+        if (!text)
+            return undefined;
+        const value = folded(text);
+        return patterns.find(({ pattern }) => pattern.test(value))?.term;
+    };
+};
+export const chatRef = (key, chat) => formatReference({ type: "chat", provider: key.provider, account: String(key.account), chat: String(chat) });
+export const contactRef = (provider, id) => formatReference({ type: "contact", provider, id: String(id) });
+export const sameAccount = (a, b) => a.provider === b.provider && String(a.account) === b.account;
+/** The person an identity is, as `person:<uid>`; `undefined` when the store has no person for it. */
+export const personRefOf = async (store, provider, id) => {
+    const person = await store.people.personOf({ provider, id });
+    return person ? `person:${person.uid}` : undefined;
+};
+/** How many projects a person is a confirmed member of. */
+export const projectsOf = async (store, person) => new Set((await store.knowledge.relations(null, person))
+    .filter((one) => one.confirmed && one.kind === "member-of" && one.from === person && one.to.startsWith("project:"))
+    .map((one) => one.to)).size;
+/** Each confirmed member's identities in one messenger, by member. */
+export const identitiesIn = async (store, people, provider) => {
+    const found = [];
+    for (const person of people) {
+        const record = await store.people.personByUid(person.slice("person:".length));
+        for (const identity of record?.identities ?? [])
+            if (identity.provider === provider)
+                found.push({ person, id: String(identity.id) });
+    }
+    return found;
+};
+export const aborted = (signal) => signal?.throwIfAborted();

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/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 })),
+    };
+};