@wirecat/cli-core 0.552.0 → 0.553.0

package/dist/cli/project-status.js

@@ -49,7 +49,16 @@ export const projectStatusSchema = v.looseObject({
         attention: v.number(),
         why: v.nullable(v.string()),
     })),
-    out_of_scope: v.optional(v.array(v.strictObject({ chat: v.string(), reason: v.string(), purpose: v.optional(v.string()) }))),
+    purposes: v.union([v.literal("all"), v.array(v.string())]),
+    out_of_scope: v.optional(v.array(v.strictObject({
+        chat: v.string(),
+        reason: v.string(),
+        purpose: v.optional(v.string()),
+        messages: v.optional(v.number()),
+        first_at: v.optional(v.nullable(v.string())),
+        last_at: v.optional(v.nullable(v.string())),
+        read_command: v.optional(v.nullable(v.string())),
+    }))),
     failed: v.optional(v.array(v.strictObject({ signal: v.string(), why: v.string() }))),
     ...Object.fromEntries(Object.keys(STATUS_SIGNAL_ROWS).map((name) => [listKey(name.slice(7)), v.optional(v.array(statusItem))])),
 });
@@ -78,9 +87,21 @@ const nextOf = (found, hints) => {
     const reads = top.flatMap(({ chat, why }) => partial(found, chat) ? [] : because(hints.read(chat, readFrom(found, chat.ref)), why));
     return [...syncs, ...reads].slice(0, 2);
 };
-const missingOf = (found) => {
+const leftOutOf = (found) => found.outOfScope.filter((one) => one.reason === "purpose");
+const readLine = (found, one, hints) => {
+    const step = hints.readChat?.({ ref: one.chat, account: one.account, chatId: one.chatId }, day(found.window.since));
+    return step ? hints.line(step) : null;
+};
+/** `12 messages 2026-10-03…2026-11-01`, or that the window holds none. */
+export const heldInWindow = (one) => one.messages && one.firstAt && one.lastAt
+    ? `${one.messages} message${one.messages === 1 ? "" : "s"} ${day(one.firstAt)}…${day(one.lastAt)}`
+    : "no messages in the window";
+const leftOutWhy = (one, read) => `${one.chat}, purpose ${one.purpose}, not read: ${heldInWindow(one)}` +
+    (read ? `; read it: ${read}` : "; add its purpose to --purpose to read it");
+const missingOf = (found, hints) => {
     const held = found.chats.filter((chat) => partial(found, chat));
     const [first] = held;
+    const others = found.outOfScope.filter((one) => one.reason !== "purpose");
     return [
         ...(first
             ? [
@@ -92,16 +113,20 @@ const missingOf = (found) => {
                 },
             ]
             : []),
-        ...(found.outOfScope.length
+        ...(others.length
             ? [
                 {
                     field: "chats",
-                    why: `${found.outOfScope.length} linked chats were not read here (${[
-                        ...new Set(found.outOfScope.map((one) => one.reason)),
+                    why: `${others.length} linked chats were not read here (${[
+                        ...new Set(others.map((one) => one.reason)),
                     ].join(", ")}); memo projects status reads every account`,
                 },
             ]
             : []),
+        ...leftOutOf(found).map((one) => {
+            const read = readLine(found, one, hints);
+            return { field: "chats", why: leftOutWhy(one, read), ...(read ? { step: "messages.list" } : {}) };
+        }),
         ...found.failed.map((one) => ({ field: `signal:${one.signal}`, why: one.why })),
     ];
 };
@@ -145,11 +170,26 @@ export const projectStatusAnswer = (found, hints) => {
             attention: weights.get(chat.ref)?.weight ?? 0,
             why: weights.get(chat.ref)?.why ?? null,
         })),
-        ...(found.outOfScope.length ? { outOfScope: found.outOfScope } : {}),
+        purposes: found.purposes,
+        ...(found.outOfScope.length
+            ? {
+                outOfScope: found.outOfScope.map((one) => one.reason === "purpose"
+                    ? {
+                        chat: one.chat,
+                        reason: one.reason,
+                        purpose: one.purpose,
+                        messages: one.messages,
+                        firstAt: one.firstAt,
+                        lastAt: one.lastAt,
+                        readCommand: readLine(found, one, hints),
+                    }
+                    : one),
+            }
+            : {}),
         ...(found.failed.length ? { failed: found.failed } : {}),
         ...lists,
     });
-    const missing = missingOf(found);
+    const missing = missingOf(found, hints);
     const complete = found.failed.length === 0 && !found.chats.some((chat) => partial(found, chat));
     return {
         item,
@@ -235,8 +275,11 @@ export const projectStatusText = (found, hints) => {
         const cut = one.data.cut;
         lines.push(`  ${cut ? `${data.child} not read (${cut})` : `${data.key ?? data.child} · ${data.name} · ${data.chats} chats`}`);
     }
-    if (found.outOfScope.length)
-        lines.push(`Not read here: ${found.outOfScope.map((one) => `${one.chat} (${one.reason})`).join(", ")}`);
+    const others = found.outOfScope.filter((one) => one.reason !== "purpose");
+    if (others.length)
+        lines.push(`Not read here: ${others.map((one) => `${one.chat} (${one.reason})`).join(", ")}`);
+    for (const one of leftOutOf(found))
+        lines.push(`Left out: ${leftOutWhy(one, readLine(found, one, hints))}`);
     for (const one of found.failed)
         lines.push(`Signal ${one.signal} failed: ${one.why}`);
     if (next.length)

package/dist/services/index.d.ts

@@ -6,7 +6,7 @@ export { type ChatCoverage, chatCoverage } from "./chat-coverage.js";
 export type { ContextEvidenceItem, ContextEvidencePage, ContextEvidenceReader, ContextEvidenceRequest, ContextEvidenceSender, ContextIndex, ContextReadLimits, ContextReadUsage, ContextRecordReader, ContextSource, ScopedContextEvidenceReader, } from "./context-evidence.js";
 export { contextEvidenceFingerprint, createContextEvidenceReader } from "./context-evidence.js";
 export { excerpt } from "./excerpt.js";
-export { aliasHits, BUILT_IN_PURPOSES, chatSenders, chatTitle, combinedScore, DEFAULT_LIMIT as DEFAULT_LINK_SCAN_LIMIT, DEFAULT_THRESHOLD as DEFAULT_LINK_SCAN_THRESHOLD, emailDomain, type LinkCandidate, type LinkScorer, mailThread, memberChats, memberDialog, PERSON_SCORERS, PERSON_THRESHOLD as PERSON_LINK_SCAN_THRESHOLD, SCAN_BOT, SCORERS, type ScanInput as LinkScanInput, type ScannedProject, type ScannedProposal, type ScanResult as LinkScanResult, type ScorerInput, type Signal as LinkSignal, scanProjectLinks, } from "./link-scorers/index.js";
+export { aliasHits, chatSenders, chatTitle, combinedScore, DEFAULT_LIMIT as DEFAULT_LINK_SCAN_LIMIT, DEFAULT_THRESHOLD as DEFAULT_LINK_SCAN_THRESHOLD, emailDomain, type LinkCandidate, type LinkScorer, mailThread, memberChats, memberDialog, PERSON_SCORERS, PERSON_THRESHOLD as PERSON_LINK_SCAN_THRESHOLD, SCAN_BOT, SCORERS, type ScanInput as LinkScanInput, type ScannedProject, type ScannedProposal, type ScanResult as LinkScanResult, type ScorerInput, type Signal as LinkSignal, scanProjectLinks, } from "./link-scorers/index.js";
 export type { MediaArchiveOptions, MediaArchivePorts } from "./media-archive.js";
 export { archiveMedia, checkMediaArchive } from "./media-archive.js";
 export type { MediaArchiveEntry, MediaIdentity } from "./media-archive-manifest.js";
@@ -21,9 +21,10 @@ export { documentPassage, storedMessageNeighbours, storedNeighbours } from "./pr
 export type { EvidenceMention, EvidenceMentions } from "./project-gathering-mentions.js";
 export { findEvidenceMentions } from "./project-gathering-mentions.js";
 export type { ProjectChatFetched, ProjectGatheringBudgets, ProjectGatheringRequest, ProjectLane, ProjectLaneKind, ProjectLinkedChat, ProjectPerson, ProjectSender, ProjectUnitState, } from "./project-gathering-request.js";
-export { DEFAULT_PURPOSES, type MoneyTotal, type ProjectStatus, type ProjectStatusInput, projectStatus, STATUS_CHATS, STATUS_SIGNALS, STATUS_WINDOW, type StatusAttention, type StatusChat, type StatusChatSummary, type StatusContext, type StatusItem, type StatusSignal, } from "./project-status/index.js";
+export { BUILT_IN_PURPOSE_CONFIG, BUILT_IN_PURPOSES, DEFAULT_PURPOSES, LINK_PURPOSE, type PurposeChoice, type PurposeConfig, purposeList, purposeRead, purposesOf, } from "./project-purposes.js";
+export { type MoneyTotal, type OutOfScope, type ProjectStatus, type ProjectStatusInput, projectStatus, STATUS_CHATS, STATUS_SIGNALS, STATUS_WINDOW, type StatusAttention, type StatusChat, type StatusChatSummary, type StatusContext, type StatusItem, type StatusSignal, } from "./project-status/index.js";
 export { questions } from "./questions.js";
-export { canonicalProjectRef, gatherStoredProject, type LinkedChat, linkedChatsOf, type StoredProjectGathering, type StoredProjectInput, } from "./stored-project-gathering.js";
+export { type ChatCount, type ChatCounter, canonicalProjectRef, gatherStoredProject, type LeftOutChat, type LinkedChat, linkedChatsOf, type ProjectMember, type StoredProjectGathering, type StoredProjectInput, storedChatCount, } from "./stored-project-gathering.js";
 import { type AccountService } from "./account.js";
 import { type AdminService } from "./admin.js";
 import { type AdminStatisticsService } from "./admin-statistics.js";

package/dist/services/index.js

@@ -5,7 +5,7 @@ export { AGENDA_DEFAULTS } from "./agenda.js";
 export { chatCoverage } from "./chat-coverage.js";
 export { contextEvidenceFingerprint, createContextEvidenceReader } from "./context-evidence.js";
 export { excerpt } from "./excerpt.js";
-export { aliasHits, BUILT_IN_PURPOSES, chatSenders, chatTitle, combinedScore, DEFAULT_LIMIT as DEFAULT_LINK_SCAN_LIMIT, DEFAULT_THRESHOLD as DEFAULT_LINK_SCAN_THRESHOLD, emailDomain, mailThread, memberChats, memberDialog, PERSON_SCORERS, PERSON_THRESHOLD as PERSON_LINK_SCAN_THRESHOLD, SCAN_BOT, SCORERS, scanProjectLinks, } from "./link-scorers/index.js";
+export { aliasHits, chatSenders, chatTitle, combinedScore, DEFAULT_LIMIT as DEFAULT_LINK_SCAN_LIMIT, DEFAULT_THRESHOLD as DEFAULT_LINK_SCAN_THRESHOLD, emailDomain, mailThread, memberChats, memberDialog, PERSON_SCORERS, PERSON_THRESHOLD as PERSON_LINK_SCAN_THRESHOLD, SCAN_BOT, SCORERS, scanProjectLinks, } from "./link-scorers/index.js";
 export { archiveMedia, checkMediaArchive } from "./media-archive.js";
 export { moveMediaArchive } from "./media-archive-move.js";
 export { downloadImageModel, downloadTextModel, } from "./model-downloads.js";
@@ -13,9 +13,10 @@ export { MONEY_DONE, MONEY_REQUEST, MONEY_WORDS, moneyClassesOf, PROMISE } from
 export { gatherProjectEvidence } from "./project-gathering.js";
 export { documentPassage, storedMessageNeighbours, storedNeighbours } from "./project-gathering-around.js";
 export { findEvidenceMentions } from "./project-gathering-mentions.js";
-export { DEFAULT_PURPOSES, projectStatus, STATUS_CHATS, STATUS_SIGNALS, STATUS_WINDOW, } from "./project-status/index.js";
+export { BUILT_IN_PURPOSE_CONFIG, BUILT_IN_PURPOSES, DEFAULT_PURPOSES, LINK_PURPOSE, purposeList, purposeRead, purposesOf, } from "./project-purposes.js";
+export { projectStatus, STATUS_CHATS, STATUS_SIGNALS, STATUS_WINDOW, } from "./project-status/index.js";
 export { questions } from "./questions.js";
-export { canonicalProjectRef, gatherStoredProject, linkedChatsOf, } from "./stored-project-gathering.js";
+export { canonicalProjectRef, gatherStoredProject, linkedChatsOf, storedChatCount, } from "./stored-project-gathering.js";
 import { accountService } from "./account.js";
 import { adminService } from "./admin.js";
 import { adminStatisticsService } from "./admin-statistics.js";

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

@@ -5,5 +5,5 @@ export { emailDomain } from "./email-domain.js";
 export { mailThread } from "./mail-thread.js";
 export { memberChats } from "./member-chats.js";
 export { memberDialog } from "./member-dialog.js";
-export { BUILT_IN_PURPOSES, combinedScore, DEFAULT_LIMIT, DEFAULT_THRESHOLD, PERSON_SCORERS, PERSON_THRESHOLD, SCAN_BOT, SCORERS, type ScanInput, scanProjectLinks, } from "./scan.js";
+export { combinedScore, DEFAULT_LIMIT, DEFAULT_THRESHOLD, PERSON_SCORERS, PERSON_THRESHOLD, SCAN_BOT, SCORERS, type ScanInput, scanProjectLinks, } from "./scan.js";
 export type { LinkCandidate, LinkScorer, ScannedProject, ScannedProposal, ScanResult, ScorerInput, Signal, } from "./types.js";

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

@@ -5,4 +5,4 @@ export { emailDomain } from "./email-domain.js";
 export { mailThread } from "./mail-thread.js";
 export { memberChats } from "./member-chats.js";
 export { memberDialog } from "./member-dialog.js";
-export { BUILT_IN_PURPOSES, combinedScore, DEFAULT_LIMIT, DEFAULT_THRESHOLD, PERSON_SCORERS, PERSON_THRESHOLD, SCAN_BOT, SCORERS, scanProjectLinks, } from "./scan.js";
+export { combinedScore, DEFAULT_LIMIT, DEFAULT_THRESHOLD, PERSON_SCORERS, PERSON_THRESHOLD, SCAN_BOT, SCORERS, scanProjectLinks, } from "./scan.js";

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

@@ -10,7 +10,6 @@ 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;

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

@@ -1,5 +1,6 @@
 import { CliError } from "@wirecat/cli-base";
 import { parseReference } from "../../domain/references.js";
+import { BUILT_IN_PURPOSES } from "../project-purposes.js";
 import { canonicalProjectRef } from "../stored-project-gathering.js";
 import { aliasHits } from "./alias-hits.js";
 import { chatSenders } from "./chat-senders.js";
@@ -15,7 +16,6 @@ export const SCORERS = [chatTitle, aliasHits, memberChats, memberDialog, chatSen
 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;

package/dist/services/project-purposes.d.ts

@@ -0,0 +1,28 @@
+/** What a chat can be for in a project, when the host's config names none. */
+export declare const BUILT_IN_PURPOSES: readonly string[];
+/** What `projects evidence` and `projects status` read when no purpose is asked for (built in; memo's config may change it). */
+export declare const DEFAULT_PURPOSES: readonly string[];
+/** A link with no purpose is a work chat. */
+export declare const LINK_PURPOSE = "work";
+/** The purposes a host's config lists; core knows only the built-in ones and takes the rest as given. */
+export interface PurposeConfig {
+    purposes: readonly string[];
+    /** Read when no `--purpose` is given. */
+    defaults: readonly string[];
+    /** A project's own defaults, by its key or `project:<id>`. */
+    projects?: Readonly<Record<string, readonly string[]>>;
+}
+export declare const BUILT_IN_PURPOSE_CONFIG: PurposeConfig;
+/** The purposes one run reads: `all`, or a set. */
+export type PurposeChoice = "all" | ReadonlySet<string>;
+/**
+ * The purposes a run reads: the asked ones, each checked against the config's list, else the project's own defaults,
+ * else the config's. `all` reads every purpose, a link's unlisted one too.
+ */
+export declare const purposesOf: (asked: readonly string[] | undefined, config?: PurposeConfig, project?: {
+    ref: string | null;
+    key: string | null;
+}) => PurposeChoice;
+export declare const purposeRead: (choice: PurposeChoice, purpose: string | null) => boolean;
+/** `a,b` and repeated flags as one list. */
+export declare const purposeList: (value: string, previous?: string[]) => string[];

package/dist/services/project-purposes.js

@@ -0,0 +1,41 @@
+import { CliError } from "@wirecat/cli-base";
+/** What a chat can be for in a project, when the host's config names none. */
+export const BUILT_IN_PURPOSES = ["work", "sales", "support", "other"];
+/** What `projects evidence` and `projects status` read when no purpose is asked for (built in; memo's config may change it). */
+export const DEFAULT_PURPOSES = ["work"];
+/** A link with no purpose is a work chat. */
+export const LINK_PURPOSE = "work";
+export const BUILT_IN_PURPOSE_CONFIG = { purposes: BUILT_IN_PURPOSES, defaults: DEFAULT_PURPOSES };
+const unknown = (asked, config) => {
+    const wrong = asked.filter((one) => !config.purposes.includes(one));
+    if (wrong.length)
+        throw new CliError("validation_error", `unknown purpose ${wrong.join(", ")}; the configured ones are ${config.purposes.join(", ")}, or all`, { param: "purpose", purposes: [...config.purposes] });
+};
+/**
+ * The purposes a run reads: the asked ones, each checked against the config's list, else the project's own defaults,
+ * else the config's. `all` reads every purpose, a link's unlisted one too.
+ */
+export const purposesOf = (asked, config = BUILT_IN_PURPOSE_CONFIG, project) => {
+    const words = (asked ?? []).map((one) => one.trim()).filter(Boolean);
+    if (words.includes("all")) {
+        if (words.length > 1)
+            throw new CliError("validation_error", "--purpose all reads every purpose; give it alone");
+        return "all";
+    }
+    if (words.length) {
+        unknown(words, config);
+        return new Set(words);
+    }
+    const own = (project?.key ? config.projects?.[project.key] : undefined) ??
+        (project?.ref ? config.projects?.[project.ref] : undefined);
+    return new Set(own ?? config.defaults);
+};
+export const purposeRead = (choice, purpose) => choice === "all" || choice.has(purpose ?? LINK_PURPOSE);
+/** `a,b` and repeated flags as one list. */
+export const purposeList = (value, previous = []) => [
+    ...previous,
+    ...value
+        .split(",")
+        .map((one) => one.trim())
+        .filter(Boolean),
+];

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

@@ -1,4 +1,7 @@
+import type { Id } from "../../domain/models.js";
 import type { AccountKey, MessageStore } from "../../store/store.js";
+import { type PurposeConfig } from "../project-purposes.js";
+import { type ChatCount, type ChatCounter } from "../stored-project-gathering.js";
 import { STATUS_SIGNALS } from "./signals/index.js";
 import type { StatusAttention, StatusChat, StatusItem, StatusProject, StatusSignal } from "./types.js";
 export type * from "./types.js";
@@ -7,8 +10,6 @@ export { STATUS_SIGNALS };
 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;
@@ -18,12 +19,27 @@ export interface ProjectStatusInput {
     after?: number;
     asOf?: number;
     contextQueries?: string[];
-    /** The chat purposes read; `all` reads every one. Default `DEFAULT_PURPOSES`. */
+    /** The chat purposes read; `["all"]` reads every one. Left out, the config's defaults. */
     purposes?: readonly string[];
+    /** The host's purposes; core's built-in ones when left out. */
+    purposeConfig?: PurposeConfig;
+    /** How many messages a chat left out by purpose holds in the window; the store's own count when left out. */
+    count?: ChatCounter;
     /** Default `STATUS_SIGNALS`; tests pass their own. */
     signals?: readonly StatusSignal[];
 }
 export type StatusChatSummary = Omit<StatusChat, "messages" | "account">;
+/** A linked chat not read; one left out by its purpose says how much it holds in the window. */
+export type OutOfScope = {
+    chat: string;
+    reason: "other-account" | "linked-chat-limit";
+} | ({
+    chat: string;
+    reason: "purpose";
+    purpose: string;
+    account: AccountKey;
+    chatId: Id;
+} & ChatCount);
 export interface MoneyTotal {
     direction: string;
     currency: string | null;
@@ -48,11 +64,9 @@ export interface ProjectStatus {
     money: {
         open: MoneyTotal[];
     };
-    outOfScope: {
-        chat: string;
-        reason: "other-account" | "linked-chat-limit" | "purpose";
-        purpose?: string;
-    }[];
+    outOfScope: OutOfScope[];
+    /** The purposes read: `all`, or the list. */
+    purposes: "all" | string[];
     failed: {
         signal: string;
         why: string;

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

@@ -1,7 +1,8 @@
 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 { LINK_PURPOSE, purposeRead, purposesOf } from "../project-purposes.js";
+import { canonicalProjectRef, linkedChatsOf, storedChatCount, } from "../stored-project-gathering.js";
 import { centsText } from "./signals/amounts.js";
 import { STATUS_SIGNALS } from "./signals/index.js";
 export { STATUS_SIGNALS };
@@ -12,8 +13,6 @@ export const STATUS_WINDOW = 300;
 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) => {
@@ -92,13 +91,14 @@ export const projectStatus = async (store, input) => {
     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 purposes = purposesOf(input.purposes, input.purposeConfig, root);
+    const count = input.count ?? storedChatCount(store);
     const { children, cut } = await childrenOf(store, root, catalog);
     const outOfScope = [];
     const linked = new Map();
@@ -110,10 +110,17 @@ export const projectStatus = async (store, input) => {
         }
     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 });
+        if (!purposeRead(purposes, link.purpose)) {
+            const account = { provider: link.provider, account: link.account };
+            outOfScope.push({
+                chat,
+                reason: "purpose",
+                purpose: link.purpose ?? LINK_PURPOSE,
+                account,
+                chatId: link.chat,
+                ...(await count(account, link.chat, { since, until: now })),
+            });
+        }
         else if (!inAccounts(input.accounts, link.provider, link.account))
             outOfScope.push({ chat, reason: "other-account" });
         else if (chosen.length >= STATUS_CHATS)
@@ -134,7 +141,7 @@ export const projectStatus = async (store, input) => {
             title: coverage?.title ?? null,
             kind: (await store.chats.chatKind(account, link.chat)) ?? "unknown",
             role: link.role,
-            purpose: "work",
+            purpose: link.purpose ?? LINK_PURPOSE,
             project: link.project,
             coverage: coverage,
             messages: page.items.filter((message) => Date.parse(message.timestamp) <= now),
@@ -189,6 +196,7 @@ export const projectStatus = async (store, input) => {
         items,
         money: { open: totalsOf(items) },
         outOfScope,
+        purposes: purposes === "all" ? "all" : [...purposes],
         failed,
         attention,
         signals: signals.map(({ id, version }) => ({ id, version })),

package/dist/services/stored-project-gathering.d.ts

@@ -1,7 +1,8 @@
 import type { ContextSource } from "../context/evidence.js";
-import type { MessageStore } from "../store/store.js";
+import type { AccountKey, MessageStore } from "../store/store.js";
 import { gatherProjectEvidence, type ProjectChatFetcher, type ProjectGatheringPorts } from "./project-gathering.js";
 import { type EvidenceMentions } from "./project-gathering-mentions.js";
+import { type PurposeConfig } from "./project-purposes.js";
 export interface StoredProjectInput {
     project: string;
     /** The sources the host resolved from its `--source`, and those it could not read. */
@@ -31,19 +32,81 @@ export interface StoredProjectInput {
     maxFetchMs?: number;
     onFetchProgress?: ProjectGatheringPorts["onFetchProgress"];
     signal?: AbortSignal;
+    /** The linked chats' purposes to read; `["all"]` reads every one. Left out, the config's defaults. */
+    purposes?: readonly string[];
+    /** The host's purposes; core's built-in ones when left out. */
+    purposeConfig?: PurposeConfig;
+    /** Proposed `member-of` links count as linked chats and members too, after the confirmed ones, every item marked. */
+    includeProposed?: boolean;
+    /** How many messages a left-out chat holds in the window; the store's own count when left out. */
+    count?: ChatCounter;
 }
+export interface ChatCount {
+    messages: number;
+    firstAt: string | null;
+    lastAt: string | null;
+}
+export type ChatCounter = (account: AccountKey, chatId: string, window: {
+    since: number;
+    until: number;
+}) => Promise<ChatCount>;
+/** The store's count of one chat's messages in a window, `until` exclusive, and the first and last of them. */
+export declare const storedChatCount: (store: MessageStore) => ChatCounter;
 /** `project:<id>`, or the one project a key, name or alias names; several or none is refused, never guessed. */
 export declare const canonicalProjectRef: (store: MessageStore, reference: string) => Promise<string>;
+export interface ProjectMember {
+    person: string;
+    state: "read" | "member-limit" | "no-identity";
+    /** The proposal that names this person a member; read only with `includeProposed`. */
+    proposed?: string;
+    score?: number;
+}
 export interface LinkedChat {
     provider: string;
     account: string;
     chat: string;
     /** The link's free role (`source report`, `what worked`), if the owner set one. */
     role: string | null;
+    /** What the chat is for in the project; `null` means `work`. */
+    purpose: string | null;
+    /** The confirmed link's id; null for a proposed one. */
+    relationship: string | null;
+    /** The proposal that links the chat; only with `includeProposed`. */
+    proposed?: string;
+    score?: number;
+}
+/**
+ * Links the owner confirmed, then, when asked, the proposed ones: a suggestion would put a whole chat into the
+ * evidence on a guess, so it is read only on request and marked.
+ */
+export declare const linkedChatsOf: (store: MessageStore, project: string | null, options?: {
+    includeProposed?: boolean;
+}) => Promise<LinkedChat[]>;
+/** A linked chat whose purpose this run did not read: counted, never listed. */
+export interface LeftOutChat {
+    ref: string;
+    provider: string;
+    account: string;
+    chat: string;
+    title: string | null;
+    purpose: string;
+    relationship: string | null;
+    proposed?: string;
+    messages: number;
+    firstAt: string | null;
+    lastAt: string | null;
 }
-/** Only links the owner confirmed: a suggested one would put a whole chat into the evidence on a guess. */
-export declare const linkedChatsOf: (store: MessageStore, project: string | null) => Promise<LinkedChat[]>;
-export type StoredProjectGathering = Awaited<ReturnType<typeof gatherProjectEvidence>> & {
+type Gathered = Awaited<ReturnType<typeof gatherProjectEvidence>>;
+export type StoredProjectGathering = Omit<Gathered, "items" | "linkedChats"> & {
+    /** `proposed`: the proposal whose link alone brought the item in; only with `includeProposed`. */
+    items: (Gathered["items"][number] & {
+        proposed?: string;
+    })[];
+    linkedChats: (Gathered["linkedChats"][number] & {
+        purpose: string;
+        proposed?: string;
+        score?: number;
+    })[];
     projectRef: string | null;
     unreadSources: {
         source: string;
@@ -51,9 +114,21 @@ export type StoredProjectGathering = Awaited<ReturnType<typeof gatherProjectEvid
         reason?: "out-of-scope" | "linked-chat-limit" | "member-limit" | "no-identity" | "unknown-provider";
     }[];
     mentions: EvidenceMentions;
+    /** The purposes read: `all`, or the list. */
+    purposes: "all" | string[];
+    leftOut: LeftOutChat[];
+    members: ProjectMember[];
+    /** One linked chat with no purpose set gave most of this run's items; a first run only, so it is said once. */
+    purposeHint: {
+        chat: string;
+        relationship: string;
+        items: number;
+        of: number;
+    } | null;
 };
 /**
  * `projects evidence` over a whole store: the project's names, key and aliases, the given words and contacts, its
  * confirmed person members and its confirmed linked chats, in the sources the host resolved.
  */
 export declare const gatherStoredProject: (store: MessageStore, input: StoredProjectInput) => Promise<StoredProjectGathering>;
+export {};