@wirecat/cli-core 0.552.0 → 0.554.0

package/CHANGELOG.md

@@ -7,6 +7,42 @@ shape of this file.
 
 ## Unreleased
 
+## 0.554.0 — 02.11.2026
+
+### Fixed
+
+- **`schedule agent` help no longer shows `skill show follow-ups` to a CLI without that skill.** The prompt example is
+  the follow-up review for a messenger and a read-only `search messages` summary for a CLI with `messenger: false`
+  (mail).
+- **Mail sync stores `sent_at`.** It is the Date header, or the server's internal date when the header is missing or
+  unreadable; `received_at` is unchanged. Each sync also gives up to 5,000 emails stored without `sent_at` the internal
+  date (`MailStore.backfillSentAt`), so the `emails_by_time` index becomes useful and an account fills in about a day.
+  No schema change.
+
+## 0.553.0 — 02.11.2026
+
+### Added
+
+- **`projects evidence` and `projects status` read the linked chats of the purposes asked.** `--purpose sales,work`
+  or `--purpose all` picks them; without it, the configured defaults (built in: `work`). A chat left out is one
+  `missing` row with its purpose, message count, dates and the command that reads it; an unknown purpose is refused
+  with the configured list. `gatherStoredProject` and `projectStatus` take `purposes`, `purposeConfig` and a `count`
+  port (`storedChatCount`); `purposesOf`, `BUILT_IN_PURPOSE_CONFIG` and `Messenger.purposes` let a host pass its list.
+  When one linked chat with no purpose gives most of a run's items, the answer suggests a purpose once.
+- **`projects evidence --include-proposed` reads chats and members proposed for the project**, after the confirmed
+  ones. Each linked chat and member row carries `proposed` and `score`, and each item only they brought `proposed`.
+  `gatherStoredProject` takes `includeProposed`; `linkedChatsOf` takes `{ includeProposed }`.
+- **`--compact` rows for `projects evidence`**: items, linked chats, chats left out by purpose and members. A row
+  column may take a `prefix`, a shape may print fields `whole` (the cursor), and `time`/`day` columns read epoch ms.
+- `countMessages` takes `until`.
+
+### Changed — may break callers
+
+- **`LinkedChat` gains `purpose` and `relationship`, `ProjectStatus` gains `purposes`, and a status chat left out by
+  purpose carries its account, chat id and counts.** `StoredProjectGathering` gains `leftOut`, `members`, `purposes`
+  and `purposeHint`. A caller that builds these by hand adds the fields. `DEFAULT_PURPOSES` moved to
+  `project-purposes`, still exported from `@wirecat/cli-core/services`.
+
 ## 0.552.0 — 02.11.2026
 
 ### Added

package/dist/cli/compact.d.ts

@@ -8,6 +8,8 @@ export interface RowColumn {
     as?: RowValue;
     /** Printed for a field that is `true`, and after a count: `{ field: ["sender_is_me", "sender_name"], tag: "me" }`. */
     tag?: string;
+    /** Printed before a text value, so a bare id says what it is: `proposed 17079`. */
+    prefix?: string;
 }
 export interface RowShape {
     /** Printed in order, joined by " · "; the first is the ref. A missing value is left out. */
@@ -16,6 +18,8 @@ export interface RowShape {
     text?: readonly string[];
     /** An item answer's lists, drawn as rows of another entity: `{ items: "evidence_item" }`. */
     sections?: Readonly<Record<string, string>>;
+    /** An item answer's fields printed whole, never cut: a cursor that is pasted back. */
+    whole?: readonly string[];
 }
 export interface CompactOptions {
     /** IANA zone for times; the answer's `meta.timezone` wins. */

package/dist/cli/compact.js

@@ -17,6 +17,61 @@ const messageRow = {
     ],
     text: ["text", "transcript", "excerpt"],
 };
+const linkedChatColumns = [
+    { field: "ref" },
+    { field: "title" },
+    { field: "purpose" },
+    { field: "proposed", prefix: "proposed" },
+];
+/** `projects evidence`: its items, the chats it read and left out, and its members. */
+const EVIDENCE_ROWS = {
+    project_evidence: {
+        columns: [],
+        sections: {
+            items: "evidence_item",
+            linked_chats: "linked_chat",
+            left_out: "linked_chat.left_out",
+            members: "evidence_member",
+        },
+        whole: ["checkpoint"],
+    },
+    evidence_item: {
+        columns: [
+            { field: "ref" },
+            { field: "at", as: "day" },
+            { field: "context" },
+            { field: "proposed", prefix: "proposed" },
+        ],
+        text: ["text"],
+    },
+    linked_chat: {
+        columns: [
+            ...linkedChatColumns,
+            { field: "state" },
+            { field: "items", as: "count", tag: "items" },
+            { field: "capped", tag: "capped" },
+            { field: "score", prefix: "score" },
+            { field: "sync_command" },
+        ],
+    },
+    "linked_chat.left_out": {
+        columns: [
+            ...linkedChatColumns,
+            { field: "messages", as: "count", tag: "messages" },
+            { field: "first_at", as: "day" },
+            { field: "last_at", as: "day" },
+            { field: "read_command" },
+        ],
+    },
+    evidence_member: {
+        columns: [
+            { field: "person" },
+            { field: "state" },
+            { field: "proposed", prefix: "proposed" },
+            { field: "score", prefix: "score" },
+        ],
+    },
+};
 /** Rows for cli-core's shared entities. */
 export const SHARED_ROWS = {
     message: messageRow,
@@ -41,6 +96,7 @@ export const SHARED_ROWS = {
         ],
     },
     ...STATUS_ROWS,
+    ...EVIDENCE_ROWS,
 };
 /** Any record: what names it, what it is called, what state it is in, then what it says. */
 export const GENERIC_ROW = {
@@ -136,11 +192,13 @@ const cellOf = (item, column, clock) => {
     switch (column.as) {
         case "time":
         case "day": {
-            if (typeof value !== "string")
+            // Some answers keep their times as epoch milliseconds.
+            const iso = typeof value === "number" && Number.isFinite(value) ? new Date(value).toISOString() : value;
+            if (typeof iso !== "string")
                 return undefined;
-            const parts = clock.parts(value);
+            const parts = clock.parts(iso);
             if (!parts)
-                return { text: clean(value) };
+                return { text: clean(iso) };
             const day = parts.date.slice(5);
             return { text: column.as === "day" ? day : `${day} ${parts.time}`, date: parts.date };
         }
@@ -164,7 +222,7 @@ const cellOf = (item, column, clock) => {
             if (value === true)
                 return column.tag ? { text: column.tag } : undefined;
             if (typeof value === "string" || typeof value === "number")
-                return { text: clean(String(value)) };
+                return { text: clean(column.prefix ? `${column.prefix} ${value}` : String(value)) };
             return undefined;
     }
 };
@@ -233,7 +291,7 @@ const rowsOfItems = (items, shape, clock, chars) => {
 };
 const blockLine = (fields, chars) => blockOf(fields, chars).join("  ");
 /** A record as `field: value` lines; a nested record is indented under its field, a list of records counted. */
-const blockOf = (fields, chars, indent = "") => Object.entries(fields)
+const blockOf = (fields, chars, indent = "", whole = []) => Object.entries(fields)
     .filter(([name]) => !(name === "priority" && "priority_label" in fields))
     .filter(([, value]) => present(value) || value === false)
     .flatMap(([name, value]) => {
@@ -244,7 +302,7 @@ const blockOf = (fields, chars, indent = "") => Object.entries(fields)
         return value.every((one) => !isFields(one) && !Array.isArray(one))
             ? [`${label} ${cut(clean(value.join(", ")), chars)}`]
             : [`${label} ${value.length} — --json shows them`];
-    return [`${label} ${cut(clean(String(value)), chars)}`];
+    return [`${label} ${whole.includes(name) ? clean(String(value)) : cut(clean(String(value)), chars)}`];
 });
 const footerOf = (body) => {
     const lines = [];
@@ -300,7 +358,7 @@ export const compactText = (body, shape, options, rowsOf = rowsOfEntity()) => {
     else if (isFields(body.item)) {
         const sections = shape.sections ?? {};
         const rest = Object.fromEntries(Object.entries(body.item).filter(([name]) => !Object.hasOwn(sections, name)));
-        lines = blockOf(rest, chars).map(guarded);
+        lines = blockOf(rest, chars, "", shape.whole).map(guarded);
         for (const [name, entity] of Object.entries(sections)) {
             const list = body.item[name];
             if (!Array.isArray(list))

package/dist/cli/messenger/context.d.ts

@@ -6,6 +6,7 @@ import { type Asker, type SendGuard } from "../../sends/guard.js";
 import { type PaceRate } from "../../sends/pace.js";
 import { type PermissionKey } from "../../sends/permissions.js";
 import { type ServiceMessenger, type Services } from "../../services/index.js";
+import type { PurposeConfig } from "../../services/project-purposes.js";
 import type { OpenRecognizer } from "../../speech/transcribe.js";
 import { type AccountKey, type DeletionScope, type MessageStore } from "../../store/store.js";
 import { type BaseContext, type BaseEnvironment } from "../context.js";
@@ -76,6 +77,8 @@ export interface Messenger extends ServiceMessenger {
     profileState?: (profile: string, env: NodeJS.ProcessEnv) => ProfileState;
     /** The help for a `<chat>` argument, in this messenger's words. */
     chatArgument: string;
+    /** The chat purposes `projects evidence` and `projects status` know; core's built-in ones when unset. */
+    purposes?: PurposeConfig;
     /** The group settings this messenger has, as `chats update` offers them; every one when unset. */
     groupSettings?: readonly GroupSettingKey[];
     /** Whether `polls create` makes quizzes (`--quiz --correct --solution`); no when unset. */

package/dist/cli/messenger/projects-command.js

@@ -3,6 +3,7 @@ import { annotate, annotateOption } from "@wirecat/cli-base/commands";
 import { Command, Option } from "commander";
 import { parseDuration } from "../../domain/duration.js";
 import { FETCHING } from "../../services/archive.js";
+import { BUILT_IN_PURPOSES, purposeList } from "../../services/project-purposes.js";
 import { projectStatus, STATUS_SIGNALS } from "../../services/project-status/index.js";
 import { gatherStoredProject } from "../../services/stored-project-gathering.js";
 import { answerEntity } from "../answer-entity.js";
@@ -61,6 +62,8 @@ const archiveFetcher = (withServices, messenger) => {
         },
     };
 };
+const purposeHelp = (messenger) => `the linked chats' purposes to read, comma separated (${(messenger.purposes?.purposes ?? BUILT_IN_PURPOSES).join(", ")}), ` +
+    "or all; the configured defaults if not given, and a chat left out is counted, never dropped silently";
 /** Off MCP: a tool call ends at about a minute, too soon for a sync, which would fail the whole answer. */
 const cliOnly = (flags, description, value) => {
     const option = new Option(flags, description);
@@ -88,6 +91,8 @@ export const projectsCommand = (messenger) => {
         .option("--alias <name>", "another name of the project, searched on its own; repeat for more", collect, [])
         .option("--context-query <words>", "more words that all appear in one text; repeat for another", collect, [])
         .option("--contact <person>", "a name to search, or person:<id> to read what that person wrote", collect, [])
+        .option("--purpose <purposes>", purposeHelp(messenger), purposeList, [])
+        .option("--include-proposed", "also read chats and members proposed for the project and not yet confirmed; each item they bring is marked")
         .option("--since-time <time>", "how far back: days (90d, at most 730d) or a start date (2026-09-01)", "60d")
         .option("--before-time <time>", "fixed exclusive end: ISO 8601 timestamp with UTC offset")
         .option("--limit <n>", "new references at most, up to 500; 100 if not given", positiveCount("--limit"))
@@ -116,20 +121,31 @@ export const projectsCommand = (messenger) => {
             ...(options.contact.length ? { people: options.contact } : {}),
             ...(options.maxPages === undefined ? {} : { maxReads: options.maxPages }),
             ...(options.cursor === undefined ? {} : { checkpoint: options.cursor }),
+            ...(options.purpose.length ? { purposes: options.purpose } : {}),
+            ...(messenger.purposes ? { purposeConfig: messenger.purposes } : {}),
+            ...(options.includeProposed ? { includeProposed: true } : {}),
             ...(fetcher ? { fetcher, maxFetchMs, onFetchProgress: progressNote(context.renderer.note) } : {}),
         }));
         const fetcher = options.syncFirst
             ? archiveFetcher((work) => context.withServices(work, { name: "projects evidence fetch" }), messenger)
             : undefined;
-        const found = await context.withStore((store, account) => gather(store, account, fetcher));
-        const parts = projectAnswerParts(options.sinceTime, found);
+        let profile;
+        const found = await context.withStore((store, account) => {
+            profile = account;
+            return gather(store, account, fetcher);
+        });
+        const root = rootOf(this);
         const hints = {
             sync: (one, since) => one.provider === messenger.provider
                 ? lineOf(this, `projects evidence ${quote(project)} --since-time ${since} --sync-first`)
                 : null,
+            read: (one, since) => one.provider === profile?.provider && one.account === profile.account
+                ? lineOf(this, wordsOf(root, readStep(one.chat, since)))
+                : null,
             showDocument: "the notes app that imported it",
         };
-        renderAnswer(this, context, itemOf(snakeKeys(withSyncCommands(found, hints.sync)), parts), () => projectEvidenceText(found, hints));
+        const parts = projectAnswerParts(options.sinceTime, found, hints);
+        renderAnswer(this, context, itemOf(snakeKeys(withSyncCommands(found, hints.sync, hints.read)), parts), () => projectEvidenceText(found, hints));
     }));
     projects.addCommand(statusCommand(messenger));
     return projects;
@@ -149,26 +165,37 @@ const statusCommand = (messenger) => answerEntity(annotate(new Command("status")
     .argument("<project>", "an existing project's id, key, exact name or alias")
     .option("--since-time <time>", "how far back: days (60d, at most 730d) or a start date (2026-09-01)", "60d")
     .option("--before-time <time>", "fixed exclusive end: ISO 8601 timestamp with UTC offset")
+    .option("--purpose <purposes>", purposeHelp(messenger), purposeList, [])
     .option("--context-query <words>", "words that all appear in one text; reports their last mention per side. Repeat for another", collect, [])
     .action(async function (project) {
     const options = this.opts();
     const context = messengerContext(this, messenger);
-    const found = await context.withStore((store, account) => projectStatus(store, {
-        project,
-        accounts: [account],
-        ...projectWindowOf(options.sinceTime),
-        ...(options.beforeTime === undefined ? {} : { asOf: projectCutoffTime(options.beforeTime) }),
-        contextQueries: options.contextQuery,
-    }));
+    let profile;
+    const found = await context.withStore((store, account) => {
+        profile = account;
+        return projectStatus(store, {
+            project,
+            accounts: [account],
+            ...projectWindowOf(options.sinceTime),
+            ...(options.beforeTime === undefined ? {} : { asOf: projectCutoffTime(options.beforeTime) }),
+            contextQueries: options.contextQuery,
+            ...(options.purpose.length ? { purposes: options.purpose } : {}),
+            ...(messenger.purposes ? { purposeConfig: messenger.purposes } : {}),
+        });
+    });
     const root = rootOf(this);
     const hints = {
         sync: (chat, since) => nextStep("messages.sync", { args: { chat: chat.chatId, since_time: since } }),
-        read: (chat, since) => nextStep("messages.list", { args: { chat: chat.chatId, query: `date>=${since}` } }),
+        read: (chat, since) => readStep(chat.chatId, since),
+        readChat: (chat, since) => chat.account.provider === profile?.provider && chat.account.account === profile.account
+            ? readStep(chat.chatId, since)
+            : null,
         line: (step) => (step.kind === "command" ? lineOf(this, wordsOf(root, step)) : step.why),
     };
     const { item, ...parts } = projectStatusAnswer(found, hints);
     renderAnswer(this, context, itemOf(item, parts), () => projectStatusText(found, hints));
 }), "project_status", projectStatusSchema, { row: projectStatusRow(STATUS_SIGNALS) });
+const readStep = (chat, since) => nextStep("messages.list", { args: { chat, query: `date>=${since}` } });
 /** A step's words after the tool and the profile, so `lineOf` names the profile the run used. */
 const wordsOf = (root, step) => {
     const profile = root.getOptionValue("profile");

package/dist/cli/messenger/serve-relay.d.ts

@@ -41,6 +41,7 @@ export declare const serveRelay: (command: Command, messenger: Messenger) => {
         resolveSettings: (flags: import("../settings.js").GlobalFlags, options?: import("../settings.js").ResolveOptions) => import("../settings.js").Settings;
         profileState?: (profile: string, env: NodeJS.ProcessEnv) => import("./context.js").ProfileState;
         chatArgument: string;
+        purposes?: import("../../services/project-purposes.js").PurposeConfig;
         groupSettings?: readonly import("../../domain/models.js").GroupSettingKey[];
         pollQuiz?: boolean;
         pollCloseSeconds?: readonly [min: number, max: number];

package/dist/cli/project-evidence.d.ts

@@ -1,4 +1,4 @@
-import type { StoredProjectGathering } from "../services/stored-project-gathering.js";
+import type { LeftOutChat, StoredProjectGathering } from "../services/stored-project-gathering.js";
 /** Days back (`90d`) or a start date (`2026-09-01`); either way the run freezes its end, so a resume keeps it. */
 export declare const projectWindowOf: (value: string) => {
     days: number;
@@ -10,7 +10,7 @@ export declare const projectCutoffTime: (value: string) => number;
  * The zone a typed start date was read in, and the window the run used, in UTC. `complete` is "the answer is whole":
  * reads finished and every linked chat held in full; the answer's own `complete` stays "reads finished".
  */
-export declare const projectAnswerParts: (sinceTime: string, found: StoredProjectGathering) => {
+export declare const projectAnswerParts: (sinceTime: string, found: StoredProjectGathering, hints?: Pick<ProjectTextHints, "read">) => {
     next?: ({
         kind: "command";
         step: string;
@@ -45,7 +45,7 @@ export declare const projectAnswerParts: (sinceTime: string, found: StoredProjec
  * The gathering with each linked chat's `syncCommand`: the line that syncs a chat held in part back to the window
  * start, or null when it needs none or no command here can. JSON readers get what the text says per chat.
  */
-export declare const withSyncCommands: (found: StoredProjectGathering, sync: ProjectTextHints["sync"]) => {
+export declare const withSyncCommands: (found: StoredProjectGathering, sync: ProjectTextHints["sync"], read?: ProjectTextHints["read"]) => {
     schemaVersion: 1;
     runKey: string;
     fingerprint: string;
@@ -80,7 +80,6 @@ export declare const withSyncCommands: (found: StoredProjectGathering, sync: Pro
         pages: number;
         issue: string | null;
     }[];
-    items: import("../services/project-gathering.js").ProjectEvidenceItem[];
     people: import("../services/project-gathering.js").ProjectEvidencePerson[];
     peopleOmitted: number;
     oversized: {
@@ -110,6 +109,9 @@ export declare const withSyncCommands: (found: StoredProjectGathering, sync: Pro
     complete: boolean;
     completeness: "complete" | "partial" | "unknown";
     checkpoint: string | null;
+    items: (import("../services/project-gathering.js").ProjectEvidenceItem & {
+        proposed?: string;
+    })[];
     projectRef: string | null;
     unreadSources: {
         source: string;
@@ -117,6 +119,14 @@ export declare const withSyncCommands: (found: StoredProjectGathering, sync: Pro
         reason?: "out-of-scope" | "linked-chat-limit" | "member-limit" | "no-identity" | "unknown-provider";
     }[];
     mentions: import("../services/project-gathering-mentions.js").EvidenceMentions;
+    purposes: "all" | string[];
+    members: import("../services/stored-project-gathering.js").ProjectMember[];
+    purposeHint: {
+        chat: string;
+        relationship: string;
+        items: number;
+        of: number;
+    } | null;
     linkedChats: {
         provider: string;
         account: string;
@@ -134,13 +144,32 @@ export declare const withSyncCommands: (found: StoredProjectGathering, sync: Pro
         } | null;
         items?: number | undefined;
         capped?: boolean | undefined;
+        purpose: string;
+        proposed?: string;
+        score?: number;
         syncCommand: string | null;
     }[];
+    leftOut: {
+        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;
+        readCommand: string | null;
+    }[];
 };
 export interface ProjectTextHints {
     /** The command that syncs one linked chat back to `since` (`YYYY-MM-DD`), or null when no command here can. */
     sync: (chat: StoredProjectGathering["linkedChats"][number], since: string) => string | null;
     /** How to open a document too large to read here. */
     showDocument: string;
+    /** The command that reads a chat left out by its purpose from `since`, or null when no command here can. */
+    read?: (chat: LeftOutChat, since: string) => string | null;
 }
 export declare const projectEvidenceText: (found: StoredProjectGathering, hints: ProjectTextHints) => string;

package/dist/cli/project-evidence.js

@@ -1,7 +1,9 @@
 import { CliError } from "@wirecat/cli-base";
+import { MAX_NEXT_STEPS } from "@wirecat/cli-base/standards";
 import * as v from "valibot";
 import { dateWindow, momentOf } from "../services/moment.js";
 import { coverageGaps, heldPhrase } from "./messenger/search-answers.js";
+import { heldInWindow } from "./project-status.js";
 /** Days back (`90d`) or a start date (`2026-09-01`); either way the run freezes its end, so a resume keeps it. */
 export const projectWindowOf = (value) => {
     const days = /^([1-9]\d{0,2})d$/.exec(value)?.[1];
@@ -33,10 +35,24 @@ const coverageRows = ({ linkedChats }) => linkedChats.flatMap((one) => one.compl
  * The zone a typed start date was read in, and the window the run used, in UTC. `complete` is "the answer is whole":
  * reads finished and every linked chat held in full; the answer's own `complete` stays "reads finished".
  */
-export const projectAnswerParts = (sinceTime, found) => {
+export const projectAnswerParts = (sinceTime, found, hints) => {
     const { window } = found;
     const { timezone } = dateWindow({ sinceTime }).meta;
-    const { next, missing } = coverageGaps(coverageRows(found), 0, new Date(window.after).toISOString());
+    const gaps = coverageGaps(coverageRows(found), 0, new Date(window.after).toISOString());
+    const next = [...gaps.next];
+    const missing = [
+        ...gaps.missing,
+        ...found.leftOut.map((one) => {
+            const read = hints?.read?.(one, day(window.after)) ?? null;
+            return { field: "linked_chats", why: leftOutLine(one, read), ...(read ? { step: "messages.list" } : {}) };
+        }),
+    ];
+    if (found.purposeHint) {
+        const why = purposeHintLine(found.purposeHint);
+        missing.push({ field: "purpose", why });
+        if (next.length < MAX_NEXT_STEPS)
+            next.push({ kind: "user_action", step: "relationships.purpose", why, safe_to_auto_execute: false });
+    }
     return {
         ...(next.length ? { next } : {}),
         ...(missing.length ? { missing } : {}),
@@ -51,19 +67,27 @@ export const projectAnswerParts = (sinceTime, found) => {
  * The gathering with each linked chat's `syncCommand`: the line that syncs a chat held in part back to the window
  * start, or null when it needs none or no command here can. JSON readers get what the text says per chat.
  */
-export const withSyncCommands = (found, sync) => ({
+export const withSyncCommands = (found, sync, read) => ({
     ...found,
     linkedChats: found.linkedChats.map((one) => ({
         ...one,
         syncCommand: one.completeness === null || one.completeness.state === "complete" ? null : sync(one, day(found.window.after)),
     })),
+    leftOut: found.leftOut.map((one) => ({ ...one, readCommand: read?.(one, day(found.window.after)) ?? null })),
 });
+/** One line for a chat left out by its purpose: what it holds in the window and how to read it. */
+const leftOutLine = (one, read) => `${one.title ? `«${one.title}» (${one.ref})` : one.ref}, purpose ${one.purpose}` +
+    `${one.proposed ? `, proposed ${one.proposed}` : ""}, not read: ${heldInWindow(one)}` +
+    (read ? `; read it: ${read}` : `; add --purpose ${one.purpose} to read it here`);
+const purposeHintLine = (hint) => `${hint.chat} gave ${hint.items} of ${hint.of} items by membership alone; if it is not a work chat, ask the owner ` +
+    `to set its purpose: memo relationships update ${hint.relationship} --purpose <purpose>`;
 const LABELS = {
     "person-only": "  [person only]",
     sender: "  [sent by contact]",
     "linked-chat": "  [linked chat]",
 };
 const day = (at) => new Date(at).toISOString().slice(0, 10);
+const PROPOSED = "  [proposed, not confirmed]";
 const FETCH_STATES = {
     complete: "synced",
     partial: "synced in part",
@@ -84,7 +108,7 @@ export const projectEvidenceText = (found, hints) => {
             `${day(found.window.after)} to ${day(found.window.before)}, ${found.scope.sources.length} sources`,
         `as of: ${new Date(found.window.asOf).toISOString()} (exclusive end; reuse --before-time to repeat this window)`,
         `searched: ${[...lanes.values()].join("; ")}`,
-        ...found.items.map((item) => `${day(item.at)}  ${item.ref}${LABELS[item.context] ?? ""}\n    ${item.text}` +
+        ...found.items.map((item) => `${day(item.at)}  ${item.ref}${LABELS[item.context] ?? ""}${item.proposed ? PROPOSED : ""}\n    ${item.text}` +
             (item.around ?? [])
                 .map((one) => `\n      ${one.found ? "(hit) " : ""}${one.sender ? `${one.sender}: ` : ""}${one.text}`)
                 .join("")),
@@ -138,6 +162,16 @@ export const projectEvidenceText = (found, hints) => {
             lines.push(`${one.title ?? one.ref}: ${held}${one.state === "pending" ? ", not read this run" : ""}` +
                 (sync ? ` — sync it: ${sync}` : ""));
         }
+    const proposed = [
+        ...found.linkedChats.flatMap((one) => (one.proposed ? [`${one.title ?? one.ref} (${one.proposed})`] : [])),
+        ...found.members.flatMap((one) => (one.proposed ? [`${one.person} (${one.proposed})`] : [])),
+    ];
+    if (proposed.length)
+        lines.push(`read as proposed, not confirmed: ${proposed.join(", ")}`);
+    for (const one of found.leftOut)
+        lines.push(`left out: ${leftOutLine(one, hints.read?.(one, day(found.window.after)) ?? null)}`);
+    if (found.purposeHint)
+        lines.push(purposeHintLine(found.purposeHint));
     const capped = found.linkedChats.filter((one) => one.capped);
     if (capped.length)
         lines.push(`linked chats with more to read, left for --cursor so one chat does not fill the run: ${capped

package/dist/cli/project-status-rows.js

@@ -97,6 +97,16 @@ export const STATUS_ROWS = {
         ],
     },
     "status.signal": { columns: [{ field: "id" }, { field: "version" }] },
-    "status.out-of-scope": { columns: [{ field: "chat" }, { field: "reason" }, { field: "purpose" }] },
+    "status.out-of-scope": {
+        columns: [
+            { field: "chat" },
+            { field: "reason" },
+            { field: "purpose" },
+            { field: "messages", as: "count", tag: "messages" },
+            { field: "first_at", as: "day" },
+            { field: "last_at", as: "day" },
+            { field: "read_command" },
+        ],
+    },
     "status.failed": { columns: [{ field: "signal" }], text: ["why"] },
 };

package/dist/cli/project-status.d.ts

@@ -1,6 +1,8 @@
 import type { NextStep } from "@wirecat/cli-base/standards";
 import * as v from "valibot";
+import type { Id } from "../domain/models.js";
 import type { ProjectStatus, StatusChatSummary } from "../services/project-status/index.js";
+import type { AccountKey } from "../store/store.js";
 import type { RowShape } from "./compact.js";
 export interface ProjectStatusHints {
     /** The step that syncs a chat held in part back to `since` (`YYYY-MM-DD`); null when no command here can. */
@@ -9,6 +11,12 @@ export interface ProjectStatusHints {
     read: (chat: StatusChatSummary, since: string) => NextStep | null;
     /** The command line a step runs, for the text form. */
     line: (step: NextStep) => string;
+    /** The step that reads a chat left out by its purpose from `since`; null when no command here can. */
+    readChat?: (chat: {
+        ref: string;
+        account: AccountKey;
+        chatId: Id;
+    }, since: string) => NextStep | null;
 }
 /** The `project_status` answer drawn by `--compact`: each signal's list with that signal's row. */
 export declare const projectStatusRow: (signals: readonly {
@@ -44,10 +52,15 @@ export declare const projectStatusSchema: v.LooseObjectSchema<{
         readonly attention: v.NumberSchema<undefined>;
         readonly why: v.NullableSchema<v.StringSchema<undefined>, undefined>;
     }, undefined>, undefined>;
+    readonly purposes: v.UnionSchema<[v.LiteralSchema<"all", undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>;
     readonly out_of_scope: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
         readonly chat: v.StringSchema<undefined>;
         readonly reason: v.StringSchema<undefined>;
         readonly purpose: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly messages: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+        readonly first_at: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+        readonly last_at: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+        readonly read_command: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
     }, undefined>, undefined>, undefined>;
     readonly failed: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
         readonly signal: v.StringSchema<undefined>;
@@ -55,6 +68,12 @@ export declare const projectStatusSchema: v.LooseObjectSchema<{
     }, undefined>, undefined>, undefined>;
 }, undefined>;
 export type ProjectStatusItem = v.InferOutput<typeof projectStatusSchema>;
+/** `12 messages 2026-10-03…2026-11-01`, or that the window holds none. */
+export declare const heldInWindow: (one: {
+    messages: number;
+    firstAt: string | null;
+    lastAt: string | null;
+}) => string;
 /** The answer of `projects status`: the item, two steps at most, what is missing, and the window. */
 export declare const projectStatusAnswer: (found: ProjectStatus, hints: ProjectStatusHints) => {
     item: {
@@ -86,10 +105,15 @@ export declare const projectStatusAnswer: (found: ProjectStatus, hints: ProjectS
             attention: number;
             why: string | null;
         }[];
+        purposes: "all" | string[];
         out_of_scope?: {
             chat: string;
             reason: string;
             purpose?: string | undefined;
+            messages?: number | undefined;
+            first_at?: string | null | undefined;
+            last_at?: string | null | undefined;
+            read_command?: string | null | undefined;
         }[] | undefined;
         failed?: {
             signal: string;