@wirecat/cli-core 0.548.0 → 0.550.0

package/CHANGELOG.md

@@ -7,6 +7,238 @@ shape of this file.
 
 ## Unreleased
 
+## 0.550.0 — 02.11.2026
+
+### Changed — may break callers
+
+- **cli-core registers `mail.search-refused`.** A CLI that listed it in its own reasons gets "listed twice" from
+  `defineReasons` and must drop its entry; mail does.
+- **`MailStore` has `markPartial(accountId, externalId, mark)`, and `partialEmails` answers `stuck` and leaves out an
+  email marked `partial.stuck`.** A store of its own must add both. `PartialOutcome` (`syncMail`'s `partial`) gains
+  `stuck`, and `partial` is answered whenever any of `completed`, `left` or `stuck` is not 0.
+- **cli-core now needs `@wirecat/cli-base` 0.74.0**, which holds the `--compact` switch's name. A CLI that pins
+  cli-base bumps it to 0.74.0 together with cli-core.
+
+### Fixed
+
+- **A partial email the server no longer gives at its stored place is given up on instead of read whole on every
+  sync.** `completePartial` reads it at its newest stored location under that location's UIDVALIDITY (the new optional
+  `Quick.validity`, which a source checks before reading), counts each failed read in `metadata.partial.tries`, and
+  after 3, or at once when the place holds another message, marks it `partial.stuck`: it stays readable as it is, is
+  counted in `partial.stuck`, and no longer takes one of the 100 places a run reads, so it never holds back newer ones.
+  An email with no stored location is given up on at once.
+- **A server search never stores a partial copy over an email already stored whole.** A sync in another process could
+  save the email between the search's check and its write; the write then dropped every attachment. The store now
+  keeps a live whole email as it is when a copy marked `partial` is saved over it.
+- **`--brief` now cuts a messenger search hit.** It only knew mail's camelCase hits, so `search messages --brief` in
+  tg, max and wa printed every field; it now keeps `ref`, `chat_title`, `timestamp`, `sender_name`, `excerpt` and
+  `score`. The default and `--full` answers are unchanged. Commands that print through `outputFor` now honour
+  `--brief` and `--full` too, and refuse them together as the others do.
+
+### Added
+
+- **`--compact`: one line per item for an agent, from the same answer `--json` prints.** `messages list <chat>
+  --compact` prints `#<id> · 10-01 09:12 · Анна · <text>` under one header line that names the shared ref prefix
+  (`ref: msg:max/500/-1001/<id>`), what every row has in common (the chat's title), the date span and the zone. Rows
+  from several chats keep their whole refs. Text stays on one line with control and direction characters made
+  visible, and is cut at 400 characters with `…(+N)`; `--full` keeps it whole. The paging, `missing`, the next steps
+  and an incomplete answer follow as `# more:`, `# missing:`, `# next:` and `# complete: false` lines on stdout, and
+  each command line in them carries `--compact` again. On 1 000 messages of one chat it is about 48 % of the JSON
+  bytes; the texts alone are 40 %. `--compact` with `--json`, `--json=…`, `--jsonl` or `--brief` fails with
+  `validation_error` (`output.conflict`); it never prompts, and exits with the code JSON would. MCP keeps JSON.
+  - **Every command that answers through `renderAnswer` gets it.** A command draws with its own row
+    (`answerEntity(cmd, name, schema, { row })`), its app's (`rows: { name: shape }` in the program definition,
+    which also draws an app entity listed inside one thing), the shared one in `SHARED_ROWS` (`message`,
+    `message.summary`, `message.hit`, `chat`), or the generic row: key, ref or id · title, name or path · state,
+    status or due date · text. A record or a list is never printed as a column's value. `RowShape` is data, and `compactText(body, shape,
+    options)` is pure, for an app that prints its own answers.
+  - What a command prints without `renderAnswer` stays JSON under `--compact`.
+
+## 0.549.0 — 02.11.2026
+
+### Added
+
+- **A calendar CLI can mount `search all`.** Given `app` (its identity) beside `messages`, `addCalendarCommands` adds
+  `search all` beside `search events`: calendar events, messages from the other WireCat tools and notes in the shared
+  store, and a meeting account's transcripts only when `--source` names one, ranked together as a messenger's
+  `search all` ranks them. It takes the same `--only`, `--source`, `--max-meetings`, `--limit`, `--page`, `--exact`
+  and `--timezone` (`searchAllOptions`, now shared with the messenger's), refuses mail as the messenger's does, and
+  answers each account it read in `meta.accounts`. Without a messenger server it reads the local store only. A process
+  locked to one profile reads only its own calendar and refuses `--source`. `CalendarCommandDeps` gains `app`, `note`
+  (the "searched:" and "not searched:" lines for a person) and a `view` argument to `write`, the text a person reads.
+- **A server's refused SEARCH fails that folder, not the run, and proves nothing.** A mail source throws
+  `mail.search-refused` (`SEARCH_REFUSED`, `searchRefused`) when the server answers SEARCH with NO or BAD. `syncMail`
+  reads the other folders, answers `state: "partial"` with `refusedFolders`, and for the refused folder marks no mail
+  deleted, changes no membership, moves no resume point and leaves `mail_coverage` as it was. Before, a mail source that
+  read the refusal as "nothing found" made the folder look empty.
+- **Server search reads big mail text-first, and the next sync completes it.** A candidate is read up to
+  `SERVER_BOUNDS.textBytes` (256 KiB, `fetchRaw(items, { bytes })`); one cut short is stored with its text and no
+  attachments, marked `metadata.partial`, and `meta.issues` says `search.server-partial`. `syncMail` then reads up to
+  100 partial emails whole and clears the mark (`partial: { completed, left }`; `completePartial: false` skips it).
+  `MailStore.partialEmails` lists them. No store migration: the mark is a JSON key older builds ignore.
+- **`readClientFile` (from `@wirecat/cli-core/oauth`) reads a user's own Google Desktop OAuth client file** (the
+  `{ "installed": { client_id, client_secret } }` JSON from Google's console). It refuses a file other users can read
+  (`sign-in.client-file-open`) and a file of the wrong shape (`sign-in.client-file-invalid`), and never puts the file's
+  contents in an error. gcal, drive and mail each kept a copy of this reader.
+- **`openBrowser(url, browser?)` is exported from `@wirecat/cli-core/cli`**, so a CLI that does not start through
+  `startCli` opens the sign-in page the same way: `open`, `rundll32` or `xdg-open`, or the named browser.
+- **iCalendar feeds as read-only calendars.** With `deps.feeds` (`icsFeeds`), `calendars add <url> [--title]` follows a
+  public holiday calendar, a sports schedule or a published `.ics` address, and `calendars remove <calendar>` stops.
+  `sync` reads each feed after the provider (`syncWithFeeds`), so its events show in `events list`,
+  `search events`, `overlapping:` and `events remind`. Repeating events are expanded here (`expandSeries`: RRULE in
+  the event's own zone, RDATE, EXDATE and overrides). The address is a secret input, kept by the CLI and never
+  printed; a fetch follows redirects only to https and stops at 10 MB and 30 s. `readIcs` takes
+  `{ overrides: true }` and returns the calendar's `name`. See `docs/dev/CALENDARS.md`, "Feeds".
+- **History limits for pushed history, per profile.** A messenger whose history is pushed (`history: "store"`,
+  WhatsApp) saves one-to-one chats back `history_dialog_days` (1095 by default), groups of more than two people back
+  `history_group_days` (365) and nothing of a group above `history_group_members_max` people (50); at most 1095 days.
+  The chat row stays, so the chat is still listed. Live messages, `messages sync` and what the store already holds are
+  never dropped. `messages sync <chat> --full-history` fetches a chat and keeps its pushed history in full from then on
+  (`history_included` in the answer). `ChatsStore` gains `historySkips`, `historyShapes`, `recordHistorySkips` and
+  `setHistoryIncluded`; `Saving` takes `historyLimits`.
+- **Helpers for reading money and questions in a chat, for the project status work.** `amountsOf(text)` returns
+  every amount in a text, in order (`amountOf` is its first). `MONEY_REQUEST`, `MONEY_DONE` and `PROMISE` word lists
+  (ru, en, es) with `moneyClassesOf(text)` say which a text uses. `questions(messages, { asker: "owner" })` lists the
+  owner's own questions and whether anyone but the owner answered them, by a reply or by speaking next; the default,
+  `"others"`, is what it did before. `linkedChatsOf` is exported, now with each link's `role`, and so is
+  `AGENDA_DEFAULTS`, the silence `tasks agenda` waits before it lists a chat.
+- **A command's own history handler learns whether each batch reached the store**: `HistoryBatchHandler` takes
+  `saved`, a promise of the same `true` or `false` the messenger gets, so a link can count only what was kept.
+- **Every messenger command that takes a chat or a message also takes the reference other WireCat CLIs print**:
+  `chat:<provider>/<account>/<chat>` wherever a chat is named (`messages list chat:max/34871122/63488582`, bot
+  commands too), and `msg:<provider>/<account>/<chat>/<message>` wherever a chat or a message is, online and offline. A person lookup takes `contact:<provider>/<id>`. A reference of another
+  account is refused, naming the account it belongs to and the profiles of this CLI the store saw on it; it never
+  switches account. One of another messenger is refused with the command that opens it (`open it with tg <profile>
+  messages list chat:telegram/…`), and another kind (`document:413` given as a chat) with what the argument takes.
+- **`event:<id>` and `meeting:<account>/<meeting>[/<transcript>[/<cue>]]` parse with `parseReference`** and
+  `canonicalReference`, as every other kind: `event:N` was printed by the calendar and person answers and could not be
+  read back. The kinds are one table, `REF_KINDS`; `looksLikeReference(text)` tells a reference from a title such as
+  `Note: plan`. Reference errors carry a reason: `ref.malformed`, `ref.unknown-kind` (with the kind meant:
+  `"doc:413" … did you mean document:413?`), `ref.wrong-kind`, `ref.wrong-provider`, `ref.wrong-account`.
+- **`messages list` reads a window bounded on both sides, offline too.** The query takes a start and an end,
+  `'date>=2026-10-01 date<2026-10-20'` or `'date:[2026-10-01 TO 2026-10-19]'`, and `id>` with `date<`. A start reads
+  forward, oldest first, and stops at the end; an end alone reads back from it, newest page first, as before.
+  `--offline` and a messenger whose history is read from the store (WhatsApp) now answer both ways from the store
+  instead of refusing. A forward cursor carries the end, `after:<id>~<epoch ms>`, so the next page stops at the same
+  place. `--since`, `--since-time`, `--until`, `--until-time`, `--after-time` and `--before-time` on `messages list`
+  fail with the query form to type instead. The store's `messages()` window takes `after` (a message or a moment)
+  and `until`.
+- **One proposal inbox behind one check: `proposalRegistry(store, policy)`, `ProposalKind`, `parseProposalIds`
+  (`@wirecat/cli-core/services`) and `mayDecide` (`@wirecat/cli-core/store`).** The registry lists every pending
+  proposal newest first across kinds (`relationship`, `key_document`, `fact`, `memory`, `findings` for evidence
+  findings, and `action` for every other stored proposal), and decides many ids at once, each on its own: the answer
+  lists `decided` and `refused`, and one refusal never undoes the others. A new kind registers itself with its id
+  `prefix` or the `stored` proposal kinds it owns; nothing else changes. `parseProposalIds` reads
+  `17070-17079,fact:500-502,17080/f2` and refuses a range across prefixes. Unconfirmed agent and rule links show as
+  `link:<id>` (relationships) and `key:<id>` (key documents) until the store moves them.
+- **`knowledge.proposeRelation(scope, input, by)`**: an agent's or a rule's relationship is a stored `relationship`
+  proposal for the owner, not a link; the same pending pair returns the proposal already held. Removing a link to a
+  project, or rejecting any suggested link, leaves a rejected `relationship` proposal, so a later scan can skip it.
+- **`proposedActions.list({ kinds, except, project, proposedBy })`**, `proposedBy` on `facts.list` and
+  `memories.list`, `order: "created"` on `facts.list`, and the bot's `kind` (`agent` or `rule`) on the author of a
+  proposed action, a fact, a memory and an evidence findings batch; bots may have the kind `rule`, and an `Author` may
+  name it.
+- **`knowledge.decideLinkProposal(id, decision)`** decides a stored `relationship` or `key_document` proposal, and
+  **`knowledge.decideSuggestedLink(id, decision)`** an older unconfirmed link, each in one transaction: the link and
+  the decision land together or not at all. A decision's `reason` is kept: on a rejected proposal as its result, on a
+  fact in `metadata.decision`, on an evidence findings receipt.
+- **`store.refs.summaries(refs, { excerpt? })` says what any ref names**, a page at a time: kind, title, what holds
+  it, when, provider, account, the CLI that opens it and whether it is `available`, `deleted` or `unavailable`. One
+  statement per kind present, offline. A malformed ref comes back `unknown`, never thrown, so one bad row cannot fail
+  a page. Titles hold no message text; `{ excerpt: true }` adds at most 280 characters. Read once per page.
+- **`refLabel(summary)` and `openOf(summary, { profilesFor, local? })`** (`./cli`): the one label
+  (`Chat «Title» (MAX)`) and the command that opens a ref. `openOf` never picks a profile: with none or several,
+  `argv` keeps `<profile>` and `profiles` lists the choices. Kinds no CLI owns open with the caller's `local` words.
+- **`ProviderEntry.opens`**: the read command that opens each kind of ref (`{ document: "documents show" }`). A CLI
+  writes it with `registerProvider`; tg, max and wa open `chat`, `message` and `contact` from the built-ins. A kind
+  this build does not know is dropped, so an older build still reads a newer entry.
+- **A relationship's purpose (store version 44).** `links.purpose`, read as `purpose` on a relationship, a link and
+  the `relationship` entity, says what a chat is for in a project; `null` means `work`. The store keeps no list of
+  purposes: the caller checks one against its config. `relate` and `proposeRelation` take `purpose`.
+- **`knowledge.updateRelation(scope, id, { role?, purpose?, by })`** sets a relationship's role and purpose; `null`
+  clears one. The owner's change applies; an agent's is a `relationship_update` proposal, listed and decided through
+  the proposal registry, and `knowledge.decideRelationUpdate(id, decision)` decides it in one transaction.
+
+### Changed — may break callers
+
+- **`SERVER_BOUNDS.maxMessageBytes`, `ServerSearched.tooLarge` and `search.server-too-large` are gone**: a big
+  candidate is no longer left on the server; see `textBytes`, `ServerSearched.partial` and `search.server-partial`.
+- **An option after `--` is read as the option.** `messages sync -- -100 --json` now syncs `-100` and answers in JSON;
+  it failed with "too many arguments". After `--`, a word that is exactly one of the command's options, its own or a
+  global one (`--json`, `--limit 5`, `--json=id`), moves in front of `--`; every other word stays a positional. A
+  negative id needs no `--` at all. Commands that take free text keep every word after `--` literal: `messages send` and
+  `edit` (also the bot's), `polls create`, `topics create`, `chats create`, `chats folders create`, `contacts rename`,
+  `contacts aliases set`, `messages press`, `bot commands set`, `schedule command`, `events remind`, `complete`, and the
+  notes templates. Mark such a command with `annotate(command, { literal_after_dashes: true })`; MCP calls are never
+  lifted. A script that passed the literal word `--json` as a positional of another command now gets the option instead.
+- **A write to a calendar the account may only read refuses before anything is asked or journaled**
+  (`calendar.read-only`): create, quick add, import, update, delete, respond and move, for a feed and for a provider's
+  `reader` or `free-busy` calendar alike. Before, only the target of a move was checked; the provider refused the rest.
+  `calendars busy` and `search --backend server` leave feed calendars out.
+- **A locator of another account or messenger is refused with a new text and a reason.** `messages show`, `context`,
+  `link` and `download` said "that locator belongs to another account; select its profile first" or "…belongs to
+  another messenger"; they now say `<ref> belongs to account <id>; profile <name> is account <id>` (`ref.wrong-account`)
+  or `<ref> is a <messenger> message; open it with …` (`ref.wrong-provider`). A script matching the old text matches
+  the reason instead.
+- **A text of the form `<kind>:<no spaces>` given as a chat is read as a reference**, so a chat titled `note:plan` is
+  no longer found by that title; give its id or a part of the title.
+- The provider seeds of `telegram`, `max` and `whatsapp` name their CLI (`command: tg`, `max`, `wa`), which a
+  provider clash message now shows (`telegram (messages, from tg)`).
+- **Every decide method takes who decides, a `Decider`** (`"owner"` or `{ bot, model?, reason }`):
+  `facts.accept(ref, by)`, `facts.reject(ref, by)`, `memories.confirm(ref, by)`, `knowledge.confirmRelation(scope, id,
+  by)`, `knowledge.removeRelation(scope, id, by)`, `proposedActions.approve(id, by, result?)`,
+  `proposedActions.reject(id, by)`, `approveAsTask(store, id, by)`, and `by` is now required in
+  `evidenceFindings.review` and `meetingFindings.review`. `DocumentKnowledge.fact` and `.memory` take `by` for a
+  `confirm`, and `memories.markStale(ref, by)` and `.memory(…, "stale", by)` take it too: marking an agent's memory
+  stale is how it is turned down. `knowledge.relate` needs `by`: the owner's relationship is a link, an agent's is a
+  `relationship` proposal it returns instead. `notes.addLink` refuses any confirmed link without `by: "owner"`, so an
+  agent writes `confirmed: false` (the task service now does). `notes.removeLink(id, by)`, `facts.reverse(ref, by)`,
+  `facts.remove(ref, by)` and `memories.remove(ref, by)` take who removes; the document port's `addMemory` needs
+  `author`, `addFact` and `addLink` need `by`, with no owner default. `proposalRegistry(store)` takes no policy: the
+  host sets it once with `openStore({ decisions })`, and `store.decisionPolicy` is what the registry and every store
+  check read. A host passes the owner only when the owner runs the command, and
+  the agent's bot and reason otherwise.
+  An agent's confirmation of a relationship is recorded in the link's provenance, and of a fact or proposal as its
+  decider.
+- **Evidence sources read through `store.refs`.** `memories.sources`, `facts.sources` and `evidenceFindings.sources`
+  keep their shape; a contact now says `kind: "contact"` (was `identity`), a mail ref the store lacks says `email`
+  (was `message`), and kinds that had no title before (person, project, task, chat…) now have one.
+- **Unconfirmed agent and rule links move into proposals (store version 44).** The first writable open after the
+  upgrade turns each into a `relationship` or `key_document` proposal with its bot, reason and time, and deletes the
+  link; Drive's editor links stay. Only the owner decides a moved one, since its bot came from free text. An older
+  build no longer lists or confirms these as relationships, and a project transfer no longer carries them. Decide them
+  through the proposal registry by their new ids; `link:<id>` and `key:<id>` remain only for suggestions an older
+  build writes later.
+
+### Fixed
+
+- **A sum written in groups of three read as the wrong amount: `50 000 ₽` was `0` and `4 300 ₽` was `300`**, because
+  only the last group was read. Groups after a space, a no-break or thin space, a dot or a comma (`50 000`,
+  `1.200 €`, `$1,200`) are one number now, a decimal part after them is kept (`5 000.50 ₽`), and amounts keep two
+  decimals instead of a whole number (`15.5 eur` was 16). This is the amount the duplicate check compares between
+  two tasks, so a reminder worded with a grouped sum is no longer compared on the wrong figure.
+- **`page.next` of `messages list` and `messages comments` runs as written.** It repeated the query's `id`/`date`
+  bound beside `--cursor`, which the command refuses as two starting points; it now keeps only `topic:` and
+  `starred:`.
+- **An inclusive start keeps a message sent exactly at it.** `messages list 'date>=2026-10-01'` skipped a message
+  sent at the first millisecond of the day, and `date<="…"` one sent at that moment.
+
+### Security
+
+- **An agent can no longer decide its own proposal.** Before, `facts.accept`/`reject`,
+  `memories.confirm`, `knowledge.confirmRelation`, `proposedActions.approve`/`reject`, `approveAsTask` and both
+  findings reviews never asked who decided, so over MCP an agent could confirm what it had proposed itself. Every one
+  of them, and the registry, now runs `mayDecide`: the owner always may; an agent needs a reason
+  (`proposal.reason-required`), is refused its own bot's proposal (`proposal.own`), a rule scorer's proposal and one
+  that names no author (`proposal.owner-only`), and every decision when the host turns agent decisions off
+  (`proposals.agent-decisions-off`). An agent can no longer add a memory already `confirmed`, mark its own memory
+  stale, write a confirmed project link itself, or remove a link. A link records only free-text provenance, which
+  anyone can write, so only the owner decides an unconfirmed link or removes a link; the rejected record a removal
+  leaves names who removed it. Findings an agent accepted for the owner record that agent, not the owner. Only the
+  owner removes or reverses an accepted fact or another bot's memory; an agent withdraws only its own row while it is
+  proposed. Turning agent decisions off now holds for every store method, not only the registry, and a bot is the
+  same bot whatever its letter case (`Claude-Code` is `claude-code`).
+
 ## 0.548.0 — 02.11.2026
 
 ### Added

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

@@ -1,5 +1,6 @@
 import { type Command } from "commander";
 import type { EventStore } from "../../meetings/index.js";
+import type { AppIdentity } from "../../ports/app.js";
 import type { AccountKey, MessageStore } from "../../store/store.js";
 import { type CalendarFeeds } from "../feeds.js";
 import type { CalendarExpander, CalendarSource } from "../source.js";
@@ -39,7 +40,15 @@ export interface CalendarCommandDeps {
         embedded: number;
         left: boolean;
     }>;
-    write: (value: unknown, format: "json" | "jsonl" | "text") => void;
+    /** `view` is the text a person reads in place of the default rendering, where a command has one. */
+    write: (value: unknown, format: "json" | "jsonl" | "text", view?: () => string) => void;
+    /** A line for the person beside the answer, never in it: which accounts `search all` read and which it skipped. */
+    note?: (text: string) => void;
+    /**
+     * The CLI itself. With it and `messages`, `search` also has `all`: messages, notes, events and named meetings in the
+     * shared store, as a messenger's `search all`.
+     */
+    app?: AppIdentity;
     now?: () => number;
     /** The zone `today`, `week` and a bare date are read in; the computer's when absent. */
     timezone?: string;

package/dist/calendar/cli/index.js

@@ -23,6 +23,7 @@ import { calendarStatus } from "../sync.js";
 import { createEvent, createEventFromText, deleteEvent, EVENT_RESPONSES, IMPORT_MAX, importEvents, moveEvent, respondToEvent, updateEvent, } from "../writes.js";
 import { CALENDARS_QUERY, declareCalendarAnswers, PEOPLE_QUERY } from "./answers.js";
 import { addRemind } from "./remind.js";
+import { addSearchAll } from "./search-all.js";
 const LOCAL_READ = { remote: "none", local: "read" };
 const LOCAL_WRITE = { remote: "none", local: "write" };
 const FETCH = { remote: "read", local: "write" };
@@ -343,9 +344,14 @@ const addCalendarCommandsDefinition = (program, deps) => {
     });
     if (deps.writes)
         addRemind(events, deps.writes, { deps, now, zone, print, example });
-    const searches = annotate(program.command("search").description("find stored things by text: events"), {
-        effects: GROUP,
-    });
+    const app = deps.messages ? deps.app : undefined;
+    const searches = annotate(program
+        .command("search")
+        .description(app
+        ? "find stored things by text: events, or all of messages, notes and events"
+        : "find stored things by text: events"), { effects: GROUP });
+    if (app)
+        addSearchAll(searches, { deps, app, zone, messages, example });
     const search = example(annotate(searches.command("events"), { effects: deps.serverSearch ? LOCAL_OR_REMOTE_READ : LOCAL_READ })
         .description(deps.serverSearch
         ? "find stored events by words, and by meaning when its model is downloaded; with --backend server, ask " +

package/dist/calendar/cli/search-all.d.ts

@@ -0,0 +1,17 @@
+import { Command } from "commander";
+import type { AppIdentity } from "../../ports/app.js";
+import type { CalendarCommandDeps } from "./index.js";
+interface SearchAllHelpers {
+    /** Read through, never copied: a CLI's deps may be getters that work only once a profile is open. */
+    deps: CalendarCommandDeps;
+    app: AppIdentity;
+    zone: () => string;
+    messages: (what: string) => NonNullable<CalendarCommandDeps["messages"]>;
+    example: (command: Command, ...lines: string[]) => Command;
+}
+/**
+ * `search all` beside `search events`: the messenger's shared search over the store, without a messenger server.
+ * Events are the calendar's own kind and always read; meeting transcripts only when `--source` names a meeting account.
+ */
+export declare const addSearchAll: (searches: Command, { deps, app, zone, messages, example }: SearchAllHelpers) => void;
+export {};

package/dist/calendar/cli/search-all.js

@@ -0,0 +1,72 @@
+import { CliError } from "@wirecat/cli-base";
+import { annotate } from "@wirecat/cli-base/commands";
+import { Command } from "commander";
+import { LOCAL_READ } from "../../cli/effects.js";
+import { historySkipsOf } from "../../cli/messenger/history-gaps.js";
+import { allAnswer, offsetOf, SOURCE_SEARCHED } from "../../cli/messenger/search-answers.js";
+import { searchAllLine, searchAllOptions } from "../../cli/messenger/search-command.js";
+import { SAVE_HELP } from "../../meetings/index.js";
+import { meaningLane } from "../../services/messages-meaning.js";
+import { searchAllWithMeetings } from "../../services/search-all-meetings.js";
+const DEFAULT_LIMIT = 20;
+/**
+ * `search all` beside `search events`: the messenger's shared search over the store, without a messenger server.
+ * Events are the calendar's own kind and always read; meeting transcripts only when `--source` names a meeting account.
+ */
+export const addSearchAll = (searches, { deps, app, zone, messages, example }) => {
+    const all = annotate(new Command("all"), { effects: LOCAL_READ, partial: true, output: { entity: "hit" } })
+        .summary("search stored messages, notes, calendar events and selected meeting transcripts")
+        .description("search calendar events, messages from the other WireCat tools and notes in the local store, and a meeting " +
+        "account's transcripts when --source names one — best match first; not mail (the separate memo CLI " +
+        "searches it: memo search mail). Use it when you do not know where something was written; search events " +
+        "reads the calendar with all its fields")
+        .argument("<query...>", 'strict Lucene query: words, "phrases", AND/OR/NOT, field groups and date ranges')
+        .addHelpText("after", SAVE_HELP)
+        .addHelpText("after", "--json: the list is items; each result's reference is ref, with its kind.");
+    searches.addCommand(searchAllOptions(all));
+    example(all, "search all roadmap", 'search all "quarterly review" --source telegram,gcal --json');
+    all.action(async (words, _opts, leaf) => {
+        const opts = leaf.opts();
+        if (deps.locked && opts.source !== undefined)
+            throw new CliError("permission_error", "this process is locked to one profile; search all reads its own calendar only, without --source", { reason: "profile.locked" });
+        const store = messages("search all");
+        const limit = opts.limit ?? DEFAULT_LIMIT;
+        const offset = offsetOf(opts.page, limit);
+        const env = deps.writes?.env ?? process.env;
+        const found = await searchAllWithMeetings(store, deps.account, {
+            text: words.join(" "),
+            limit,
+            ...(offset === undefined ? {} : { offset }),
+            ...(opts.exact ? { exact: true } : {}),
+            timezone: opts.timezone ?? zone(),
+            env,
+            only: opts.only ?? SOURCE_SEARCHED,
+            ...(opts.source === undefined ? {} : { source: opts.source }),
+            ...(opts.maxMeetings === undefined ? {} : { maxMeetings: opts.maxMeetings }),
+            ...(deps.locked ? { scope: { events: [deps.account] } } : {}),
+        }, { app }, undefined, meaningLane({ env, messenger: { app }, store: async () => store }));
+        const note = deps.note ?? (() => undefined);
+        const globals = leaf.optsWithGlobals();
+        const format = globals.json ? "json" : globals.jsonl ? "jsonl" : "text";
+        if (format === "text")
+            note(`searched: ${found.accounts.map(({ provider, account }) => `${provider}:${account}`).join(", ") || "nothing"}`);
+        for (const { resource, source, reason } of found.skipped)
+            note(`${resource ?? source} not searched: ${reason}`);
+        if (found.notes?.meaningSkipped)
+            note(`notes by words only: ${found.notes.meaningSkipped}`);
+        if (found.events?.meaningSkipped)
+            note(`events by words only: ${found.events.meaningSkipped}`);
+        const again = {
+            query: words.join(" "),
+            ...(opts.only === undefined ? {} : { only: opts.only.join(",") }),
+            ...(opts.source === undefined ? {} : { source: opts.source }),
+            ...(opts.maxMeetings === undefined ? {} : { max_meetings: opts.maxMeetings }),
+            ...(opts.exact ? { exact: true } : {}),
+            ...(opts.timezone === undefined ? {} : { timezone: opts.timezone }),
+        };
+        if (!found.items.length)
+            note("nothing found in what the local store holds");
+        const skips = await historySkipsOf(store, found.accounts).catch(() => []);
+        deps.write(allAnswer("search all", found, { limit, page: opts.page ?? 1, again }, opts.exact === true, skips), format, () => found.items.map(searchAllLine).join(""));
+    });
+};

package/dist/cli/answer-entity.d.ts

@@ -1,8 +1,12 @@
 import type { Command } from "commander";
 import type * as v from "valibot";
+import type { RowShape } from "./compact.js";
 /** Provider-specific wire fields must not redefine an entity shared by every CLI. */
 export declare const answerEntity: (command: Command, name: string, schema: v.GenericSchema, options?: {
     project?: v.GenericSchema;
+    row?: RowShape;
 }) => Command;
 export declare const answerEntitySchema: (command: Command | undefined) => v.GenericSchema | undefined;
 export declare const answerProjectionSchema: (command: Command | undefined) => v.GenericSchema | undefined;
+/** The row a command declared with `answerEntity(…, { row })`, while it still answers that entity. */
+export declare const answerRow: (command: Command | undefined) => RowShape | undefined;

package/dist/cli/answer-entity.js

@@ -29,3 +29,8 @@ export const answerProjectionSchema = (command) => {
     const own = command && schemas.get(command);
     return own && metaOf(command).output?.entity === own.name ? own.project : undefined;
 };
+/** The row a command declared with `answerEntity(…, { row })`, while it still answers that entity. */
+export const answerRow = (command) => {
+    const own = command && schemas.get(command);
+    return own && metaOf(command).output?.entity === own.name ? own.row : undefined;
+};

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

@@ -15,6 +15,8 @@ export declare const botContext: (command: Command, bot: BotMessenger) => {
     format: import("@wirecat/cli-base").RenderFormat;
     color: boolean;
     streams: import("@wirecat/cli-base").Streams;
+    compact?: boolean;
+    full?: boolean;
     env: NodeJS.ProcessEnv;
     keyring?: import("@wirecat/cli-base").KeyringStore;
     run: <T>(body: (events: import("../index.js").EventSink) => Promise<T>, options?: {

package/dist/cli/compact.d.ts

@@ -0,0 +1,41 @@
+import type { Command } from "commander";
+import type { Body } from "./envelope.js";
+/** How one column prints. `text` by default. */
+export type RowValue = "text" | "time" | "day" | "count" | "files" | "reply" | "forward";
+export interface RowColumn {
+    /** A snake_case field path in the item (`sender_name`, `last.timestamp`); of several, the first that is set. */
+    field: string | readonly string[];
+    as?: RowValue;
+    /** Printed for a field that is `true`, and after a count: `{ field: ["sender_is_me", "sender_name"], tag: "me" }`. */
+    tag?: string;
+}
+export interface RowShape {
+    /** Printed in order, joined by " · "; the first is the ref. A missing value is left out. */
+    columns: readonly RowColumn[];
+    /** The free text, printed last; the first non-empty field wins. */
+    text?: readonly string[];
+    /** An item answer's lists, drawn as rows of another entity: `{ items: "evidence_item" }`. */
+    sections?: Readonly<Record<string, string>>;
+}
+export interface CompactOptions {
+    /** IANA zone for times; the answer's `meta.timezone` wins. */
+    timezone: string;
+    /** Characters of text kept per row; 0 keeps all (`--full`). Default 400. */
+    textChars?: number;
+}
+export declare const TEXT_CHARS = 400;
+/** Rows for cli-core's shared entities. */
+export declare const SHARED_ROWS: Readonly<Record<string, RowShape>>;
+/** Any record: what names it, what it is called, what state it is in, then what it says. */
+export declare const GENERIC_ROW: RowShape;
+export type RowsResolver = (command: Command | undefined) => RowShape | undefined;
+/** An app's own rows by entity name (or `name.view`). */
+export type RowTable = Readonly<Record<string, RowShape>>;
+/** The row an entity named in a section is drawn with: the app's, the shared one, else the generic one. */
+export declare const rowsOfEntity: (table?: RowTable) => (entity: string) => RowShape;
+/** An app's own rows by entity name, as `entityFields` takes its fields; a shared name is refused. */
+export declare const entityRows: (table: RowTable) => RowsResolver;
+/** The row a command's answer is drawn with: its own, its app's, the shared one, else the generic one. */
+export declare const rowShapeOf: (command: Command | undefined, resolve?: RowsResolver) => RowShape;
+/** The whole answer as compact text: header, rows, footer. Pure: no store, no clock. */
+export declare const compactText: <T>(body: Body<T>, shape: RowShape, options: CompactOptions, rowsOf?: (entity: string) => RowShape) => string;