@wirecat/cli-core 0.552.0 → 0.554.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/cli/schedule/schedule-command.d.ts

@@ -1,7 +1,6 @@
 import { Command } from "commander";
 import { type AppIdentity } from "../../ports/app.js";
 import { type AnswerOutput } from "../envelope.js";
-/** What the schedule command needs of a CLI: who it is and, per command, where it prints and which profile runs. */
 export interface ScheduleHost {
     app: AppIdentity;
     context(command: Command, resolving?: {

package/dist/cli/schedule/schedule-command.js

@@ -68,6 +68,11 @@ const withWhen = (command) => command
     .option("--every <duration>", "repeat: 30m, 2h, 1d")
     .option("--at <HH:MM>", "every day at this local time")
     .option("--at-time <time>", "one run: 30m, 2d from now, or an ISO time; the schedule removes itself after it");
+/** What the schedule command needs of a CLI: who it is and, per command, where it prints and which profile runs. */
+/** `skill show follow-ups` exists only for messenger CLIs; any other CLI gets a read-only summary it can run. */
+const promptExample = (app) => app.messenger === false
+    ? `summarize what came in during the last day: ${app.command} personal search messages 'date>1d' --newest --limit 20`
+    : `run the daily follow-up review: ${app.command} skill show follow-ups`;
 /**
  * Runs the CLI's own commands, or an agent, later or on a timer — through systemd (Linux), launchd
  * (macOS) or Task Scheduler (Windows). Every timer runs `schedule exec <file>`; the schedule file holds
@@ -142,7 +147,7 @@ export const scheduleCommandFor = ({ app, context: contextOf }) => {
         .description(`start an agent (claude or codex) with a prompt on a timer; it runs with ${app.envPrefix}_READ_ONLY=1, so it reads and drafts and cannot send — its answer is kept and you are notified`)
         .argument("<name>", "lowercase letters, digits and dashes")
         .addArgument(new Argument("<harness>", "the agent to start").choices(HARNESSES))
-        .argument("<prompt>", `what to do, e.g. "run the daily follow-up review: ${app.command} skill show follow-ups"`)
+        .argument("<prompt>", `what to do, e.g. "${promptExample(app)}"`)
         .addOption(new Option("--max-cost <usd>", "claude only: stop a run that costs more than this, in US dollars").argParser(Number))).action(async function (name, harness, prompt) {
         const { context, system, environment, save } = prepare(this);
         const options = this.opts();

package/dist/mail/email-input.d.ts

@@ -1,5 +1,7 @@
 import type { EmailInput } from "../store/index.js";
 import type { ParsedMail } from "./parse.js";
 import type { Listed } from "./source.js";
+/** The Date header, or the server's internal date when the header is missing or unreadable. */
+export declare const sentAtOf: (date: string | null, receivedAt: string) => number;
 /** What one read email stores of itself, whichever run read it; where it is filed is the caller's. */
 export declare const parsedEmail: (mail: ParsedMail, item: Listed, header: Record<string, string | boolean>, address: string) => Omit<EmailInput, "mailboxes">;

package/dist/mail/email-input.js

@@ -1,4 +1,9 @@
 import { addressOf } from "./attachments.js";
+/** The Date header, or the server's internal date when the header is missing or unreadable. */
+export const sentAtOf = (date, receivedAt) => {
+    const sent = date === null ? Number.NaN : Date.parse(date);
+    return Number.isNaN(sent) ? Date.parse(receivedAt) : sent;
+};
 /** What one read email stores of itself, whichever run read it; where it is filed is the caller's. */
 export const parsedEmail = (mail, item, header, address) => ({
     externalId: item.messageId,
@@ -7,7 +12,7 @@ export const parsedEmail = (mail, item, header, address) => ({
     to: mail.to.map(addressOf),
     cc: mail.cc.map(addressOf),
     bcc: mail.bcc.map(addressOf),
-    sentAt: null,
+    sentAt: sentAtOf(mail.date, item.receivedAt),
     receivedAt: Date.parse(item.receivedAt),
     bodyText: mail.text || null,
     size: item.size ?? null,

package/dist/mail/retry.js

@@ -1,6 +1,7 @@
 import { CliError } from "@wirecat/cli-base";
 import { mailAccountKey } from "./account-key.js";
 import { addressOf, FETCH_CHUNK, readAttachments } from "./attachments.js";
+import { sentAtOf } from "./email-input.js";
 import { mailFolders } from "./folders.js";
 import { mailHeadersOf } from "./headers.js";
 import { parseMail } from "./parse.js";
@@ -74,7 +75,7 @@ export const retryUnread = async ({ store, source, account, since, max, maxBodyC
                         to: mail.to.map(addressOf),
                         cc: mail.cc.map(addressOf),
                         bcc: mail.bcc.map(addressOf),
-                        sentAt: null,
+                        sentAt: sentAtOf(mail.date, item.receivedAt),
                         receivedAt: Date.parse(item.receivedAt),
                         bodyText: mail.text || null,
                         size: item.size ?? stored.size,

package/dist/mail/sync.js

@@ -24,6 +24,8 @@ const DAY = 86_400_000;
 const EDGE = 2 * DAY;
 /** How often a long run saves where it is, so a kill costs at most this much listing again. */
 const SAVE_EVERY_MS = 30_000;
+/** About 55 runs clear a 276,000-email account; each is a short write that does not hold the sync up. */
+const SENT_AT_BACKFILL_PER_RUN = 5000;
 const SLICE_SIZE = 50;
 const SLICE_PAUSE_MS = 100;
 /** About a minute of listing; the 30-day window of the timer stays below it. */
@@ -682,7 +684,7 @@ const syncRound = async (source, store, { account, since, max = 200, maxBodyChar
                     // Subject and text stay out of the columns search reads, so recorded mail is never a search hit.
                     subject: null,
                     from: headers?.from === undefined ? null : { address: headers.from, name: headers.fromName ?? null },
-                    sentAt: null,
+                    sentAt: Date.parse(item.receivedAt),
                     receivedAt: Date.parse(item.receivedAt),
                     bodyText: null,
                     size: item.size ?? null,
@@ -816,6 +818,8 @@ const syncRound = async (source, store, { account, since, max = 200, maxBodyChar
         await store.mail.setMailboxes(accountId, [bulkBox], bulk, startedAt);
     if (!snapshot)
         await store.sync.setSyncState(key, "mail_folder_scope", scope);
+    if (!snapshot)
+        await store.mail.backfillSentAt(accountId, SENT_AT_BACKFILL_PER_RUN);
     await stopIfAborted();
     const indexed = await index?.(store, key);
     const coverage = {

package/dist/mail/testing/fake.d.ts

@@ -12,6 +12,8 @@ export interface FakeMail {
     from: FakePerson;
     to: FakePerson[];
     cc?: FakePerson[];
+    /** The Date header, when it differs from the server's internal date `receivedAt`. */
+    date?: string;
     text?: string;
     html?: string;
     listId?: string;

package/dist/mail/testing/fake.js

@@ -31,7 +31,7 @@ export const rawOf = (m) => {
         ...(m.listId ? [`List-Id: News <${m.listId}>`, `List-Unsubscribe: <mailto:leave@${m.listId}>`] : []),
         `Subject: ${m.subject}`,
         `Message-ID: <${m.messageId}@example.test>`,
-        `Date: ${new Date(m.receivedAt).toUTCString()}`,
+        `Date: ${m.date ?? new Date(m.receivedAt).toUTCString()}`,
         "MIME-Version: 1.0",
         ...(m.extraHeaders ?? []),
     ];

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 })),