@wirecat/cli-core 0.550.0 → 0.551.0

package/dist/services/link-scorers/member-chats.js

@@ -0,0 +1,40 @@
+import { chatRef, identitiesIn } from "./shared.js";
+const WEIGHT = 0.5;
+/** A group or channel where two or more of the project's confirmed person members are members. */
+export const memberChats = {
+    id: "member-chats",
+    version: 1,
+    candidates: async ({ store, project, confirmed, sources, owner, signal }) => {
+        if (!project)
+            return [];
+        const people = confirmed.people.filter((person) => person !== owner);
+        const found = [];
+        for (const key of sources) {
+            const members = new Map();
+            for (const { person, id } of await identitiesIn(store, people, key.provider)) {
+                signal?.throwIfAborted();
+                for (const chat of await store.chats.chatsWith(key, id)) {
+                    if (chat.kind !== "group" && chat.kind !== "channel")
+                        continue;
+                    const held = members.get(String(chat.id)) ?? new Set();
+                    held.add(person);
+                    members.set(String(chat.id), held);
+                }
+            }
+            for (const [chat, held] of members) {
+                if (held.size < 2)
+                    continue;
+                const named = [...held].sort();
+                found.push({
+                    from: chatRef(key, chat),
+                    to: project.ref,
+                    kind: "member-of",
+                    weight: WEIGHT,
+                    why: `a group with ${held.size} confirmed members (${named.slice(0, 3).join(", ")}${held.size > 3 ? ", …" : ""})`,
+                    evidence: named.slice(0, 5),
+                });
+            }
+        }
+        return found;
+    },
+};

package/dist/services/link-scorers/member-dialog.d.ts

@@ -0,0 +1,3 @@
+import type { LinkScorer } from "./types.js";
+/** A dialog with a confirmed person member, divided by how many projects that person is a member of. */
+export declare const memberDialog: LinkScorer;

package/dist/services/link-scorers/member-dialog.js

@@ -0,0 +1,34 @@
+import { chatRef, identitiesIn, projectsOf } from "./shared.js";
+const WEIGHT = 0.6;
+/** A dialog with a confirmed person member, divided by how many projects that person is a member of. */
+export const memberDialog = {
+    id: "member-dialog",
+    version: 1,
+    candidates: async ({ store, project, confirmed, sources, owner, signal }) => {
+        if (!project)
+            return [];
+        const people = confirmed.people.filter((person) => person !== owner);
+        const projects = new Map();
+        const found = [];
+        for (const key of sources)
+            for (const { person, id } of await identitiesIn(store, people, key.provider)) {
+                signal?.throwIfAborted();
+                for (const chat of await store.chats.chatsWith(key, id)) {
+                    if (chat.kind !== "dialog")
+                        continue;
+                    if (!projects.has(person))
+                        projects.set(person, Math.max(1, await projectsOf(store, person)));
+                    const shared = projects.get(person) ?? 1;
+                    found.push({
+                        from: chatRef(key, chat.id),
+                        to: project.ref,
+                        kind: "member-of",
+                        weight: WEIGHT / shared,
+                        why: `a dialog with a member (${person})${shared > 1 ? `, who is in ${shared} projects` : ""}`,
+                        evidence: [person],
+                    });
+                }
+            }
+        return found;
+    },
+};

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

@@ -0,0 +1,41 @@
+import type { MessageStore } from "../../store/store.js";
+import type { AccountKey } from "../../store/types.js";
+import type { LinkScorer, ScanResult } from "./types.js";
+/** A new scorer is one file and one line here. */
+export declare const SCORERS: readonly LinkScorer[];
+/** What a scan with no project runs: person ↔ person rules. */
+export declare const PERSON_SCORERS: readonly LinkScorer[];
+/** The rule bot every scan proposal is written by: only the owner decides its proposals. */
+export declare const SCAN_BOT: {
+    readonly bot: "memo-scan";
+    readonly kind: "rule";
+};
+export declare const BUILT_IN_PURPOSES: readonly ["work", "sales", "support", "other"];
+export declare 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 declare const PERSON_THRESHOLD = 0.3;
+export declare const DEFAULT_LIMIT = 20;
+export interface ScanInput {
+    /** A project's key, name, alias or `project:<id>`; `null` runs the person ↔ person rules. */
+    project: string | null;
+    sources: AccountKey[];
+    since: string;
+    /** `false` reads only: nothing is written, and each proposal says `dry-run`. */
+    write: boolean;
+    scorers?: readonly LinkScorer[];
+    threshold?: number;
+    /** Most new proposals in one run, 1–50. */
+    limit?: number;
+    /** The host's configured purposes; built-in when left out. */
+    purposes?: readonly string[];
+    signal?: AbortSignal;
+}
+/** 1 − Π(1 − wᵢ), over each scorer's strongest signal for the pair. */
+export declare const combinedScore: (weights: readonly number[]) => number;
+/**
+ * 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 declare const scanProjectLinks: (store: MessageStore, input: ScanInput) => Promise<ScanResult>;

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