@wirecat/cli-core 0.562.0 → 0.564.0

package/CHANGELOG.md

@@ -5,6 +5,145 @@ Notable changes to `@wirecat/cli-core` (`@wirecat/cli-messaging` up to 0.261.0,
 minor version may break callers, and says how under "Changed — may break callers". `pnpm docs:check` checks the
 shape of this file.
 
+## Unreleased
+
+## 0.564.0 — 05.11.2026
+
+### Changed — may break callers
+
+- **`search all` ranks its sources as one list** (MEMO-37). Each source's hit at one rank used to get the same score,
+  so the sources took turns in the order they were read (messages, mail, notes, events). Now hits at the same rank
+  are ordered by cosine, since one model scores every source; a hit meaning did not find comes after those it did.
+  Each source's own order is kept. Without the model nothing changes. `search notes` and `search events` hits found
+  by meaning carry `meaning_score`, the cosine.
+- **tg, max and wa `search all` change with the bump, with no code change in them.** Mail is searched by meaning when
+  the store holds mail, a question's message found both by words and by meaning gets one vote, and once vectors
+  exist the hits at one rank are ordered by meaning score.
+- **`search all` searches mail by meaning too** (MEMO-38). Mail was only ever searched by words there, though its
+  threads had vectors. The meaning lane now reads a mail account's thread vectors through the mail store, and
+  `search all` fuses them with the word hits as it does for messages; the answer says how in `mail`. For a question,
+  a mail or message found by words gets no second vote from meaning, as in notes.
+- **`search all` finds records for a question typed as a sentence.** When the text is a question in natural language
+  and not `exact`, messages and mail go through discovery (as `search messages --discover`), and notes and calendar
+  events search any of the question's content words, ranked by the store. Before, every word had to be in one record,
+  so a question found nothing (MEMO-36). tg, max and wa still ask the messenger's server with the question as typed.
+  For a question, a note found by both words and meaning gets one vote, not two, so notes found by words alone are not
+  buried. Plain words, query syntax and `exact` are searched strictly, as before. `searchNotes` and `searchEvents`
+  take `discover`.
+
+### Added
+
+- **The proposal registry reviews meeting findings and task close suggestions.** `proposalRegistry` registers
+  `meeting_findings` (a meeting's staged batch, decided part by part as in `meetings actions confirm`) and
+  `task_close` (an agent's suggested close, id `close:<task key>`; confirming closes the task as suggested, rejecting
+  clears the suggestion). Both are owner only: `isOwnerOnlyKind` now names `task_close` too, so `mayDecide` refuses an
+  agent by the row's kind. `parseProposalIds` takes a task key after a prefix (`close:Q-15`). Moved from cli-memo,
+  which registered both itself; a host that registers a kind of the same name now gets `configuration_error`.
+
+- **A mail CLI's `messages show` can read an email again when a sync's limit left its attachment unread.**
+  `mailReadCommands` takes `whole(command, store, mailbox, emailId)`; with it the command is a fetch, reads such an
+  email from the server before it answers (`readEmailWhole`), and shows the new text. When that read fails it shows
+  the stored email with `meta.complete: false` and an issue `mail.attachments-unread`. Without `whole` nothing changes.
+  `readEmailWhole`'s body and text limits, reader and clock now default as sync's do.
+- **`has:transcript` in the messages query language** finds a voice message that has a transcription, so
+  `stats messages show --by day -- has:transcript date>=30d` counts transcribed voice messages per day. In mail it
+  finds nothing.
+- **`store chats status`** counts the account's searchable chats of every kind, channels included, by how much of each
+  the archive holds: `{ chats, fetched, partial, never, oldest_message_at }`. `fetched` is held back to the first
+  message, up to date and without gaps; `never` has no fetch recorded and no message held; the rest is `partial`,
+  including WhatsApp chats whose history was pushed. One statement over the store, no list of chats. tg, max and wa
+  get it with the bump.
+- **Meeting counts per day, week or series.** `readMeetingCounts` (services) and `store.meetings.meetingCounts`
+  answer meetings, minutes, mean minutes and meetings with a transcript, in total and per row, over the same
+  selection as `readMeetingStats`, reading `meetings` alone through `meetings_by_time`. `meetingCountsItem` and the
+  `meeting_counts` entity are the answer, for zoom-cli's `stats meetings history`. A meeting with no end counts in
+  `meetings`, not in `minutes`. `MeetingStatsStore` gains `meetingCounts`; only cli-core's own store implements it.
+- **`stats tasks show` counts by chat, meeting or project, over a period.** `--by meeting` keys a row by the meeting a
+  task came from (`meeting:<account>/<meeting>`); `--by project` reads the owner's project tasks, every project
+  (`project:<id>`). A query after `--` takes the task query's fields and `created` for the period: `created` counts
+  the tasks opened in it, `closed` those closed in it, `open` is always open now (`-- created>=30d`). The item gains
+  `created`, `closed`, `median_close_ms` and `mean_open_age_ms`; each row gains `key`, `name` (chat title, meeting
+  title, project name), `created`, `closed` and `mean_open_age_ms`. Rows of `--by chat` keep `chat`; the others have
+  none. `--timezone` places calendar days such as `created>=today`.
+- **`created:` in the project task query** (`PROJECT_TASK_FIELDS`), beside `closed:`: `created>=30d`.
+- **`mailStats` from `./mail`**: stored mail received and sent per calendar day, week (by its Monday) or sender, for
+  the `search mail` query, counts only and no search recorded; `mailStatsItem` turns it into the new `mail_counts`
+  entity, `{ by, received, sent, rows: [{ key, name, received, sent }] }`. By sender it counts received mail only.
+- **`mailOwnText(body)` (`@wirecat/cli-core/mail`): what an email says itself, without quoted earlier mail and the
+  signature.** It drops `>` lines, cuts at a reply header ("On … wrote:", "Le … a écrit :", "Am … schrieb …:",
+  "… написал(а):", Gmail's Russian "<address>:") and at an Outlook From/Sent block in English, German, French, Spanish
+  and Russian, and drops the `-- ` signature, sign-offs and mobile footers. A forwarded message stays whole; an email
+  that is only a quote keeps its body.
+
+### Security
+
+- **`review --holder` gives each email's own text** (`mailOwnText`), so an agent's model does not read earlier mail
+  or signatures. The fingerprint a finding cites is still taken over the stored body; other reads show the whole text.
+- **Review and inbox items say which fields others wrote** (WC-SECR-21): `summaryOf` items, and so every catch-up
+  answer and each mail `review` item, carry `untrusted` (`SUMMARY_UNTRUSTED`: chat title, sender name, text,
+  transcript, attachment names); a mail review item adds the email's subject and the names in its headers, as search
+  hits do. The `message.summary` entity takes the field.
+
+## 0.563.0 — 03.11.2026
+
+### Changed — may break callers
+
+- **Mail sync reads attachments up to 10 MB a file by default, and can skip them.** Until now every attachment was
+  read, whatever its size; at the next bump a file over 10 MB is no longer read into the index unless the caller
+  passes a policy. `MailSyncOptions.attachments` takes a `MailAttachmentPolicy` (`read`, `maxBytes`); left out it is
+  `DEFAULT_ATTACHMENT_POLICY`. A file the policy leaves is stored with its name, type and size but no text, with
+  `extractionError` `not-read` or `too-large` (`POLICY_SKIPS`), and the run's `attachments` log says the same.
+  Partial completion and `retryAttachments` follow it too.
+- **Moving a task to another project moves its subtasks with it.** `tasks.edit(id, { project })` on a task with
+  subtasks no longer refuses with `task.has-subtasks`; that reason is gone. Every subtask, all the way down, takes the
+  next key in the new project and keeps its parent, and its old key still finds it. The answer names them as
+  `movedSubtasks: [{ from, to }]`, old key and new; the field is left out when nothing moved with the task. A subtask
+  moved on its own still needs `parent: null` in the same edit (`task.is-subtask`).
+
+- **Owner-only proposals refuse an agent on every decide path.** `mayDecide` and `assertMayDecide` now read
+  the row's stored `kind`: a `mail_findings` or `meeting_findings` row is the owner's alone, whatever
+  `agent_decisions` says. The registry's `get` and `list` rows carry `ownerOnly` from their kind, and the generic
+  action kind marks a stored findings row too, so a host checking `assertMayDecide(await registry.get(id), …)` is
+  refused. `approveAsTask` and `proposedActions.approve` / `reject` refuse a mail findings batch as they refuse
+  meeting and evidence findings (`mail-findings.dedicated-review`), and the generic action kind no longer lists any
+  findings batch. Meeting findings were open to another agent with a reason before; now only the owner reviews them.
+
+### Added
+
+- **An answer over the output cap says what to run instead (WC-OUT-22).** The `output.too-large` failure now names up
+  to two reads, both safe to run unasked: the same command line with `--compact`, when the command declares a row and
+  was not compact already, and the same line with a `--limit` scaled down to fit. The lines are rebuilt from the
+  words the caller typed, never from the answer. The failure also carries `needed_bytes`.
+- **A JSON answer over 256 KiB adds one step to the compact form.** The answer is still printed whole. Nothing is
+  added when the answer already names two steps, over MCP, or for a command with no declared row.
+- **`search messages --chat` and `search all --chat` say how to search one chat:** `chat:<chat>` in the query.
+
+- **`readEmailWhole` reads one stored email again from its mail server, every attachment of it with no limit.** It
+  saves the new text on the email as a sync does, keeping its mailboxes, flags and rule, and answers each attachment's
+  bytes for the caller to save. Gmail's email is found by id, another server's at its stored place.
+  `store.mail.emailPlace(accountId, externalId)` gives an email's thread and stored places.
+- **`stats messages responses`**: how fast replies come in one-to-one chats, the owner's (`--who me`) or the other
+  side's (`--who others`): count, median, p90, mean and four time buckets, in total or `--by day` in `--timezone`.
+  Several messages in a row followed by one answer are one reply, timed from the first. Reads by index, so all time
+  works on a large store; the query after `--` takes `date:`, `chat:` and `kind:` only.
+- **`stats messages waiting`**: how many chats wait on the owner — a one-to-one chat whose newest message is a
+  question, or a group whose newest message mentions or replies to the owner — with the messages since the owner
+  last wrote, the oldest of them, and the split by kind. Muted or archived one-to-one chats are left out, as in
+  `inbox`.
+- **tg, max, wa, mail, gcal and drive's config file holds every shared setting with its default.** A first run now
+  writes all of them into `defaults`, not five; `config set` and `config unset` add the missing ones (but not the one
+  just unset); and the new `<cli> config migrate` fills an existing file. Your values, their order and unknown keys
+  stay; a file without `defaults` gets that section, and no other section is created. `config show` gives each of
+  these settings its `default` and `description`, and no longer creates the file when there is none. `settingsFor`
+  returns `declaredSettings` and `migrate(path)`; `extension.settings` declares a CLI's own (cli-base WC-CMD-30).
+  Settings with no single default (`timeout_ms`, `color`, `requests_per_minute`, the embedding model) and objects
+  (`permissions`, `models`) are left out.
+- **`MailReads.mount`: the steps a mail review hands on name where the host mounted it.** A host that mounts `review`
+  and `messages acknowledge` elsewhere passes their paths and the option naming the mailbox — memo passes
+  `review: "mail review"`, `conversation: null` (it mounts no thread read) and `mailbox: { option: "source", value }`
+  — and `next` names those paths and `--source email:<account>`. `mailReviewSteps(mount)` gives the definitions for
+  a host's step checks; a mail CLI leaves it out, and its step lines carry the profile as before.
+
 ## 0.562.0 — 03.11.2026
 
 ### Added

package/dist/calendar/mcp/index.d.ts

@@ -10,13 +10,13 @@ export declare const calendarTools: ({
     inputSchema: {
         type: string;
         properties: {
+            limit?: undefined;
             account_id: {
                 type: string;
                 minimum: number;
             };
             query?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             page?: undefined;
             event?: undefined;
         } | {
@@ -45,9 +45,9 @@ export declare const calendarTools: ({
             };
             event?: undefined;
         } | {
+            limit?: undefined;
             query?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             page?: undefined;
             event: {
                 type: string;
@@ -58,9 +58,9 @@ export declare const calendarTools: ({
                 minimum: number;
             };
         } | {
+            limit?: undefined;
             query?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             page?: undefined;
             event?: undefined;
             account_id?: undefined;
@@ -80,13 +80,13 @@ export declare const calendarTools: ({
     inputSchema: {
         type: string;
         properties: {
+            limit?: undefined;
             account_id: {
                 type: string;
                 minimum: number;
             };
             query?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             page?: undefined;
             event?: undefined;
         } | {
@@ -115,9 +115,9 @@ export declare const calendarTools: ({
             };
             event?: undefined;
         } | {
+            limit?: undefined;
             query?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             page?: undefined;
             event: {
                 type: string;
@@ -128,9 +128,9 @@ export declare const calendarTools: ({
                 minimum: number;
             };
         } | {
+            limit?: undefined;
             query?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             page?: undefined;
             event?: undefined;
             account_id?: undefined;
@@ -150,13 +150,13 @@ export declare const calendarTools: ({
     inputSchema: {
         type: string;
         properties: {
+            limit?: undefined;
             account_id: {
                 type: string;
                 minimum: number;
             };
             query?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             page?: undefined;
             event?: undefined;
         } | {
@@ -185,9 +185,9 @@ export declare const calendarTools: ({
             };
             event?: undefined;
         } | {
+            limit?: undefined;
             query?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             page?: undefined;
             event: {
                 type: string;
@@ -198,9 +198,9 @@ export declare const calendarTools: ({
                 minimum: number;
             };
         } | {
+            limit?: undefined;
             query?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             page?: undefined;
             event?: undefined;
             account_id?: undefined;
@@ -220,13 +220,13 @@ export declare const calendarTools: ({
     inputSchema: {
         type: string;
         properties: {
+            limit?: undefined;
             account_id: {
                 type: string;
                 minimum: number;
             };
             query?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             page?: undefined;
             event?: undefined;
         } | {
@@ -255,9 +255,9 @@ export declare const calendarTools: ({
             };
             event?: undefined;
         } | {
+            limit?: undefined;
             query?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             page?: undefined;
             event: {
                 type: string;
@@ -268,9 +268,9 @@ export declare const calendarTools: ({
                 minimum: number;
             };
         } | {
+            limit?: undefined;
             query?: undefined;
             timezone?: undefined;
-            limit?: undefined;
             page?: undefined;
             event?: undefined;
             account_id?: undefined;

package/dist/cli/config-command.js

@@ -30,6 +30,7 @@ export const configCommand = (app, config, { permissionKey = config.permissions,
         const bot = this.opts().bot === true;
         const context = baseContext(this, (flags, options) => config.resolveSettings(flags, {
             ...options,
+            readOnly: true,
             needsProfile: false,
             withIssues: true,
             ...(bot ? { kind: "bot" } : {}),
@@ -48,7 +49,13 @@ export const configCommand = (app, config, { permissionKey = config.permissions,
             paths_overridden: overridden,
             settings: [...config.allSettings, "command_timeout_ms"]
                 .filter((setting) => bot || setting !== "read_other_bots")
-                .map((setting) => sourced(settings, setting)),
+                .map((setting) => {
+                const declared = config.declaredSettings.find(({ key }) => key === `defaults.${setting}`);
+                return {
+                    ...sourced(settings, setting),
+                    ...(declared ? { default: declared.default, description: declared.description } : {}),
+                };
+            }),
             store_settings: await storeSettings(env),
         }));
         for (const issue of [
@@ -144,9 +151,19 @@ export const configCommand = (app, config, { permissionKey = config.permissions,
             }));
         });
     }
+    command.addCommand(migrateCommand(app, config));
     command.addCommand(repairCommand(app, config));
     return command;
 };
+const migrateCommand = (app, config) => profileFree(grantsAuthority(annotate(new Command("migrate"), { effects: LOCAL_WRITE, examples: [`${app.command} config migrate`] })))
+    .description("write each setting the file lacks at its default, keeping yours")
+    .action(function () {
+    const context = baseContext(this, (flags, options) => config.resolveSettings(flags, { ...options, needsProfile: false, withIssues: true }));
+    const file = context.settings.configPath;
+    const added = config.migrate(file);
+    renderAnswer(this, context, itemOf({ config_file: file, added }));
+    context.renderer.note(added.length > 0 ? `added ${added.join(", ")} to ${file}` : `${file} already has every setting`);
+});
 /**
  * Mends JSON syntax with one reading and keeps every value (NEED-2178): no network, no AI, since the file may hold
  * keys. Anything else is refused with nothing changed.

package/dist/cli/envelope.js

@@ -5,6 +5,7 @@ import * as v from "valibot";
 import { currentRun } from "../runs/scope.js";
 import { compactText, entityRows, rowShapeOf, rowsOfEntity, TEXT_CHARS } from "./compact.js";
 import { environmentOf, setExitCode } from "./context.js";
+import { largeAnswerSteps, SOFT_OUTPUT_BYTES } from "./output-budget.js";
 import { withoutProviderRefs } from "./provider-refs.js";
 import { nextStep, rootOf, runnable, stepLine, withLines, withSafety } from "./steps.js";
 /** Every answer: a list or one thing, with items of `item` — any value where the command declares no entity. */
@@ -131,6 +132,16 @@ export const sealed = (value) => {
 };
 /** The steps a compact answer prints, each rerunning in the compact form the caller chose. */
 const compactSteps = (root, steps) => steps.map((step) => step.kind === "command" ? { ...step, line: `${step.line ?? stepLine(root, step)} ${COMPACT_FLAG}` } : step);
+/** A JSON answer past the soft budget, printed whole, with one more step: the same read in the compact form. */
+const withLargeAnswerStep = (command, body) => {
+    if ((body.next?.length ?? 0) >= MAX_NEXT_STEPS)
+        return body;
+    const added = largeAnswerSteps(command);
+    if (added.length === 0 || Buffer.byteLength(JSON.stringify(body)) <= SOFT_OUTPUT_BYTES)
+        return body;
+    const root = rootOf(command);
+    return { ...body, next: [...(body.next ?? []), ...withLines(root, runnable(root, added))] };
+};
 /** An answer as JSON lines: one line per item, then the end line. One thing is a list of one that has no more. */
 const linesOf = (body) => jsonlOf("items" in body ? body : { items: [body.item], page: { mode: "page", limit: 1, has_more: false }, meta: body.meta });
 /** An answer as JSON-lines records, for a writer that streams objects: one per item, then the end record. */
@@ -151,9 +162,10 @@ export const renderAnswer = (command, { renderer, format, streams, compact, full
     const kept = withoutProviderRefs({ ...body, ...(next.length > 0 ? { next } : {}) });
     if (next.length === 0)
         delete kept.next;
-    const whole = sealed(kept);
+    const sealedBody = sealed(kept);
     const environment = environmentOf(command);
     const drawn = compact && !environment.agent;
+    const whole = format === "json" && !drawn && !environment.agent ? withLargeAnswerStep(command, sealedBody) : sealedBody;
     if (drawn) {
         const lined = whole.next ? { ...whole, next: compactSteps(root, whole.next) } : whole;
         const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;

package/dist/cli/execution.js

@@ -116,6 +116,7 @@ export const execution = (streams, { timeoutMs, fields, maxOutputBytes = DEFAULT
                         reason: "output.too-large",
                         max_bytes: maxOutputBytes,
                         emitted_bytes: bytes,
+                        needed_bytes: bytes + size,
                         partial_output: bytes > 0,
                     });
                 bytes += size;

package/dist/cli/messenger/archive-commands.js

@@ -26,6 +26,7 @@ export const storeCommand = (messenger) => {
     const store = new Command("store")
         .description("the local store of messages")
         .addCommand(statusCommand(messenger))
+        .addCommand(storedChatsCommand(messenger))
         .addCommand(gapsCommand(messenger))
         .addCommand(jobsCommand(messenger))
         .addCommand(exportCommand(messenger))
@@ -35,6 +36,7 @@ export const storeCommand = (messenger) => {
     const examples = {
         backup: "./backup.db",
         check: "",
+        "chats status": "",
         clear: "--left --dry-run",
         "copies delete": "messages_copy_1",
         decrypt: "./backup.enc --output ./restored.db",
@@ -93,6 +95,21 @@ const statusCommand = (messenger) => annotate(new Command("status"), { output: {
                 .map((skip) => `  ${skip.title ?? skip.chatId}  ${skip.messages} messages  ${skip.reason}`)
                 .join("\n"));
 });
+/** `store status` summed over the account's chats, for a count of what the archive holds without a list of them. */
+const storedChatsCommand = (messenger) => {
+    const chats = new Command("chats").description("the account's chats as the store holds them");
+    annotate(chats.command("status"), { output: { entity: "chat_coverage" }, effects: LOCAL_READ })
+        .summary("how many chats the archive holds in full, in part, or not at all")
+        .description("over this account's searchable chats of every kind, channels included: fetched (back to the first message, " +
+        "up to date, no gaps), partial, never (no fetch recorded and no message held), and the oldest message held; " +
+        "reads the store only")
+        .action(async function () {
+        const context = messengerContext(this, messenger);
+        const coverage = await context.withStore((store, account) => store.chats.chatCoverage(account));
+        renderAnswer(this, context, itemOf(snakeKeys(coverage)));
+    });
+    return chats;
+};
 const LISTED = 20;
 /** Titles are the owner's: these lines go to a person's terminal, never into an error message. */
 const leftLines = (left) => {

package/dist/cli/messenger/catch-up-answers.d.ts

@@ -18,6 +18,8 @@ type Read = Message & {
     chatTitle?: string | null;
 };
 /** One message of a catch-up answer: the fields `inbox` and `review` show, for every messenger and for mail. */
+/** Written by others, and by the owner, so an agent quotes it and never follows it (WC-SECR-21). */
+export declare const SUMMARY_UNTRUSTED: string[];
 export declare const summaryOf: (message: Read, reader: AccountKey) => {
     ref: string;
     chat_id: string;
@@ -61,6 +63,7 @@ export declare const summaryOf: (message: Read, reader: AccountKey) => {
             url?: string | undefined;
         }[][] | undefined;
     }[];
+    untrusted: string[];
 };
 export declare const inboxAnswer: (inbox: Inbox, hearing: Hearing | undefined, reader: AccountKey, transcribe: boolean, meta?: Partial<Meta>) => import("../envelope.js").ListBody<{
     ref: string;
@@ -105,6 +108,7 @@ export declare const inboxAnswer: (inbox: Inbox, hearing: Hearing | undefined, r
             url?: string | undefined;
         }[][] | undefined;
     }[];
+    untrusted: string[];
 }>;
 /** What `review --offline` cannot see. */
 export declare const OFFLINE_REVIEW = "offline: only what was already synced to the local store; run review without --offline for the rest";
@@ -160,5 +164,6 @@ export declare const reviewAnswer: (found: Review, hearing: Hearing | undefined,
             url?: string | undefined;
         }[][] | undefined;
     }[];
+    untrusted: string[];
 }>;
 export {};

package/dist/cli/messenger/catch-up-answers.js

@@ -34,6 +34,8 @@ export const catchUpQuery = (words, registry, command) => {
     };
 };
 /** One message of a catch-up answer: the fields `inbox` and `review` show, for every messenger and for mail. */
+/** Written by others, and by the owner, so an agent quotes it and never follows it (WC-SECR-21). */
+export const SUMMARY_UNTRUSTED = ["chat_title", "sender_name", "text", "transcript", "attachments.name"];
 export const summaryOf = (message, reader) => {
     const { ref, chat_id, chat_title, timestamp, sender_name, sender_is_me, outgoing, text, transcript, attachments } = messageItem(message, reader);
     return {
@@ -47,6 +49,7 @@ export const summaryOf = (message, reader) => {
         text,
         ...(transcript === undefined ? {} : { transcript }),
         attachments,
+        untrusted: SUMMARY_UNTRUSTED,
     };
 };
 const nameOf = (chat) => chat.title ?? chat.id;

package/dist/cli/messenger/reply-stats-command.d.ts

@@ -0,0 +1,4 @@
+import { Command } from "commander";
+import { type Messenger } from "./context.js";
+export declare const replyResponsesCommand: (messenger: Messenger) => Command;
+export declare const replyWaitingCommand: (messenger: Messenger) => Command;

package/dist/cli/messenger/reply-stats-command.js

@@ -0,0 +1,57 @@
+import { annotate } from "@wirecat/cli-base/commands";
+import { Command, Option } from "commander";
+import { LOCAL_READ } from "../effects.js";
+import { renderAnswer } from "../envelope.js";
+import { messengerContext } from "./context.js";
+import { refuseJsonl, responsesAnswer, waitingAnswer } from "./stats-answers.js";
+const QUERY = "date:, chat: and kind: terms, AND-ed — date>=30d, date:[60d TO 30d]; none reads all time";
+const GUIDE = "Guide: https://github.com/WireCatLabs/cli-core/blob/main/docs/rankings.md#reply-times-and-chats-waiting-on-you";
+const minutes = (ms) => (ms === null ? "—" : `${Math.round(ms / 60_000)} min`);
+export const replyResponsesCommand = (messenger) => annotate(new Command("responses"), { effects: LOCAL_READ, output: { entity: "response_times" } })
+    .summary("how fast replies come in one-to-one chats: median, p90, mean and buckets")
+    .description("how long the owner took to answer (--who me), or the other side took to answer the owner (--who others), in " +
+    "one-to-one chats — the local store only. Several messages in a row followed by one answer count as one " +
+    "reply, timed from the first unanswered message; the day of a row is the day of the reply")
+    .argument("[query...]", QUERY)
+    .addOption(new Option("--who <side>", "whose replies: the owner's or the other side's").choices(["me", "others"]))
+    .addOption(new Option("--by <group>", "one row per calendar day of the reply, or none").choices(["day", "total"]))
+    .option("--timezone <zone>", "the IANA timezone for calendar days and date: bounds")
+    .option("--source <accounts>", "every account of this messenger held in the store; personal, bots or all")
+    .addHelpText("after", GUIDE)
+    .action(async function (words) {
+    const context = messengerContext(this, messenger);
+    refuseJsonl(context.format);
+    const { who, by, timezone, source } = this.opts();
+    const found = await context.withServices((services) => services.replyStats.responses({
+        who: who ?? "me",
+        by: by ?? "total",
+        ...(words.length ? { text: words.join(" ") } : {}),
+        ...(timezone === undefined ? {} : { timezone }),
+        ...(source === undefined ? {} : { source }),
+    }));
+    renderAnswer(this, context, responsesAnswer(found), () => [
+        `${found.replies} replies · median ${minutes(found.medianMs)} · p90 ${minutes(found.p90Ms)} · mean ${minutes(found.meanMs)}`,
+        ...found.rows.map((row) => `${row.key}  ${row.replies} replies · median ${minutes(row.medianMs)}`),
+        "",
+    ].join("\n"));
+});
+export const replyWaitingCommand = (messenger) => annotate(new Command("waiting"), { effects: LOCAL_READ, output: { entity: "waiting_chats" } })
+    .summary("chats whose newest message asks the owner something")
+    .description("how many chats wait on the owner — the local store only: a one-to-one chat whose newest message is a " +
+    "question, or a group whose newest message mentions the owner or replies to them. Muted or archived " +
+    "one-to-one chats are left out, as inbox leaves them out; date: bounds the newest message's time")
+    .argument("[query...]", QUERY)
+    .option("--timezone <zone>", "the IANA timezone for date: bounds")
+    .option("--source <accounts>", "every account of this messenger held in the store; personal, bots or all")
+    .addHelpText("after", GUIDE)
+    .action(async function (words) {
+    const context = messengerContext(this, messenger);
+    refuseJsonl(context.format);
+    const { timezone, source } = this.opts();
+    const found = await context.withServices((services) => services.replyStats.waiting({
+        ...(words.length ? { text: words.join(" ") } : {}),
+        ...(timezone === undefined ? {} : { timezone }),
+        ...(source === undefined ? {} : { source }),
+    }));
+    renderAnswer(this, context, waitingAnswer(found), () => `${found.chats} chats wait on you (${found.byKind.private} one-to-one, ${found.byKind.group} groups) · ${found.messages} messages${found.oldestAt ? ` · oldest ${found.oldestAt}` : ""}\n`);
+});

package/dist/cli/messenger/search-answers.d.ts

@@ -18,6 +18,7 @@ export type NoteHitItem = InferOutput<(typeof ENTITIES)["note.hit"]>;
 export type HitItem = InferOutput<(typeof ENTITIES)["hit"]>;
 /** The page a `--page` asks for, as the offset the search services take. */
 export declare const offsetOf: (page: number | undefined, limit: number) => number | undefined;
+export declare const MAIL_HIT_UNTRUSTED: string[];
 export declare const messageHitItem: (hit: FoundMessage, query?: string) => MessageHitItem;
 /**
  * What the store holds of a chat that is not complete, in words. A chat that reaches its first message is only

package/dist/cli/messenger/search-answers.js

@@ -26,7 +26,7 @@ const MESSAGE_HIT_UNTRUSTED = [
     "follow_ups.excerpt",
     "attachments.name",
 ];
-const MAIL_HIT_UNTRUSTED = [
+export const MAIL_HIT_UNTRUSTED = [
     "email.subject",
     "email.from.name",
     "email.to.name",

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

@@ -5,6 +5,7 @@ import { SAVE_HELP } from "../../meetings/index.js";
 import { searchNotesOf } from "../../services/notes-search.js";
 import { LOCAL_READ, REMOTE_READ } from "../effects.js";
 import { renderAnswer } from "../envelope.js";
+import { withOptionHints } from "../option-hints.js";
 import { positiveCount } from "../paging.js";
 import { runsSearchCommand } from "../runs/search-command.js";
 import { commandAt } from "../steps.js";
@@ -193,5 +194,12 @@ export const searchCommand = (messenger, { topics = false } = {}) => {
         if (command)
             annotate(command, { examples: [`${messenger.app.command} personal search ${path} ${args}`] });
     }
+    for (const path of ["all", "messages"]) {
+        const command = commandAt(search, path);
+        if (command)
+            withOptionHints(command, {
+                "--chat": `search in one chat with chat:<chat> in the query: search ${path} 'chat:<chat> words'`,
+            });
+    }
     return search;
 };

package/dist/cli/messenger/stats-answers.d.ts

@@ -8,9 +8,10 @@ import type { AdminEvidenceFound, AdminFound } from "../../services/admin-statis
 import type { ChatStats } from "../../services/chat-stats.js";
 import type { MessageStats } from "../../services/messages-search.js";
 import type { RankingFound } from "../../services/rankings.js";
+import type { ReplyTimes, Waiting } from "../../services/reply-stats.js";
 import type { RetentionService } from "../../services/retention.js";
+import type { TaskStats } from "../../services/task-stats.js";
 import type { AccountKey, RankedEvidence } from "../../store/store.js";
-import type { GroupStats } from "../../tasks/index.js";
 import { type ItemBody, type ListBody } from "../envelope.js";
 type Of<T extends keyof typeof ENTITIES> = InferOutput<(typeof ENTITIES)[T]>;
 type RetentionFound = Awaited<ReturnType<RetentionService["report"]>>;
@@ -70,6 +71,8 @@ export declare const refuseJsonl: (format: string) => void;
 export declare const chatStatsAnswer: (stats: ChatStats, account: AccountKey, meta?: Partial<Meta>) => ItemBody<Of<"chat_stats">>;
 /** Said where the store has kept no join, leave or other chat event for the chat: a 0 would read as nobody joined. */
 export declare const MEMBERS_UNRECORDED = "joins and leaves are not recorded for this chat yet, so they are not counted";
-/** `stats tasks show`, CLI and MCP alike. */
-export declare const taskStatsAnswer: (rows: GroupStats[], account: AccountKey) => ItemBody<Of<"task_stats">>;
+/** `stats tasks show`, CLI and MCP alike. A row of `--by chat` also names its chat as `chat`, as it always has. */
+export declare const taskStatsAnswer: (stats: TaskStats, account: AccountKey) => ItemBody<Of<"task_stats">>;
+export declare const responsesAnswer: (found: ReplyTimes) => ItemBody<Of<"response_times">>;
+export declare const waitingAnswer: (found: Waiting) => ItemBody<Of<"waiting_chats">>;
 export {};