@wirecat/cli-core 0.399.0 → 0.400.0

package/CHANGELOG.md

@@ -5,6 +5,88 @@ 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.400.0 — 24.10.2026
+
+### Fixed
+
+- **Downloads skip service events and keyboards.** A message whose only attachment is a group event (`control`) or an inline keyboard no longer makes a media archive or `attachments download` fail with `provider.invalid-response`; both count as non-files like polls and links.
+
+- Account lists accept profile and current-profile query terms, and declare their answer fields for discovery and projection.
+
+- **Account change and privacy schemas.** Profile updates, ended sessions and privacy reads and writes declare their existing answers for field discovery and projection. Privacy fields remain optional where a messenger does not expose a setting.
+
+- **`contacts timeline` stays in its account for tasks.** A task assigned to the person now shows only when its project belongs to the asked account or to no account; before, tasks from another account of the same messenger showed too. Task rows now also name the account of their project.
+
+### Added
+
+- **Meeting answer schemas.** `review`, `mentions list`, `stats meetings show` and `top`, `meetings people`, `meetings passage` and `meetings task-proposal` declare their answer entities (`meeting_review`, `meeting_link`, `meeting_stats`, `meeting_speaker`, `meeting_participants`, `meeting_passage`, `meeting_task_proposal`) for field discovery and projection. `meetings/` exports the item builders the meeting CLIs share: `meetingReviewItem`, `meetingLinkItem`, `meetingStatsItem`, `meetingSpeakerItem`.
+
+- **Listener answers declare their fields.** Live messages and events, and the final serve summary, expose exact schemas for discovery and cross-CLI output contracts. Provider-only attachment references stay private.
+
+- **Poll answer schemas.** Poll reads, vote and close receipts, and newly sent poll messages declare their answer entities for field discovery and projection.
+
+- **Image embedding progress has declared fields.** Discovery and projection describe the bounded batch’s model, embedded, skipped and failed counts, and whether more pictures remain. The existing receipt and processing behavior stay unchanged.
+
+- **Model key receipt schemas.** Storing or removing a model-provider key declares its provider and storage sources for field discovery and projection. No credential value appears in either schema or answer.
+
+- Recipient lists accept ID and title queries without changing the allowlist state. Recipient commands declare their answer schemas for discovery and field projection.
+
+- **Cached chat metadata declares its answers.** Cached reads describe absent or populated metadata; refresh receipts describe each successful chat or failure and whether more chats remain. Existing keys and cached-read behavior stay unchanged.
+
+- **Contact answers have declared fields.** Address-book writes, private aliases and note removal, activity, bot checks, identity links, context and preparation expose their exact answer schemas. Context describes both the cross-account report and selected-chat message windows at every detail level. Field projection recognizes both shapes and refuses unknown fields before reading contact data. CLI, SDK and MCP receipts keep their existing shapes.
+
+- **Mention answers have declared fields.** Mentions, details, linked domains, confirmed places, decisions and rebuild receipts expose their existing schemas for discovery, JSON field projection and MCP. Numeric local IDs and cross-account decision behavior stay unchanged.
+
+- **Reaction answer schemas.** Add and remove declare the same reaction-change entity, including the operation id and a null reaction when removed. Field discovery and projection now describe these write receipts.
+
+- **Tag changes declare their results.** Add and remove expose precise chat, contact, message and task target shapes. Automatic tagging describes each classification or failed chat, including preview status and remaining work; existing receipts and ownership claims stay unchanged.
+
+- Send history includes a concrete example in help and command discovery.
+
+- Chat document lists accept a source-message reference query, filtered in the store before link pagination, and declare their document-link answer fields.
+
+- Doctor reports include a concrete creation example in help and command discovery.
+
+- Send-attempt lists accept queries over their stored metadata before pagination. Continuation steps keep the query, and discovery declares the answer fields.
+
+- **Clearing search history declares its receipt.** Discovery and JSON projection expose the existing cleared count; saved searches remain untouched.
+
+- Recorded-run lists accept metadata queries before pagination, and recorded-run commands declare their answer schemas. Continuation steps keep the query.
+
+- **Message read and write schemas.** Showing a message, sending, editing, forwarding, pinning, starring and deleting declare their existing answer entities for field discovery and projection. Write receipts retain their operation id.
+
+- **Chat-state write schemas.** Muting, archiving, pinning, marking unread, deleting a chat and clearing its history declare their existing write receipts for field discovery and projection, including their operation ids.
+
+- **Chat administration declares its answers.** Invite inspection, posting identities, read receipts, roster fetches, membership and group changes, invitations, join requests, administrators, folder writes and moderation expose their exact existing result fields, including operation identifiers and partial outcomes.
+
+- **Message read schemas.** Evidence packets, voice transcripts and conversation links declare separate answer entities for field discovery and projection, preserving existing response keys.
+
+- **Conversation results have declared schemas.** Builds, analysis, message batches, link changes, embedding progress, readiness, related conversations and search hits describe their existing answer fields for discovery and projection, including bounded preparation and empty batches.
+
+- **Message context, downloads and sync have declared answers.** Context describes both message windows and bounded thread reports. Downloads retain file paths and partial extraction results; sync describes estimates, chat and all-chat progress, preparation and background jobs. General chat evidence packets and exact statistics evidence now explain their separate purposes in help and the guide.
+
+- Analysis-consent lists accept chat and provider-identity queries, and consent commands declare their answer fields. Reading a filtered list leaves remembered permissions unchanged.
+
+- **Attachment and media archive results have declared fields.** Extraction reports and streamed file rows, retained-file transfers, saved text, archive downloads, integrity checks, relocations and timer management describe their existing receipts. MCP resource/image transfers keep byte metadata in the same shape while carrying bytes separately.
+
+- Tracked-chat lists accept a query over chat IDs and titles, filtered in the store. Tracking commands declare their answer schemas for field projection and discovery.
+
+- **Task actions declare their answers.** Task cards, source previews, creation and close receipts, relationships, similarity and duplicate decisions, merges, categories and rule scans expose their exact existing fields for discovery and projection. Stored tasks and actions keep their behavior.
+
+- **Store commands declare their answers.** Archive coverage, exports, selected-chat clearing, gap plans and repairs, background jobs, health checks, maintenance and backup/restore receipts describe their existing result fields. Missing-file and partial-result variants remain explicit; stored data and command behavior stay unchanged.
+
+### Changed — may break callers
+
+- **Watch uses the shared JSONL contract.** Read each message or event from `{ type: "item", data }` and wait for the final `type: "end"` record. Message and event fields are snake_case, message values use the canonical read shape with references, and live counter observations remain available. Normal stops and timeouts finish complete; a source failure finishes incomplete and returns its failure code. Update readers of the old raw lines.
+
+- **MCP offers the commands that change what a later run may do, behind `mcp.authority`.** `config set|unset`, `schedule command|agent|remove`, auto-reply rules and consents, recipients, chat rules, `server install`, `skill install`, model keys, media archive timers and `flood clear` are MCP tools again, offered only where the profile sets `permissions.mcp.authority` to `allow`; it is `deny` by default, so nothing changes until the owner turns it on. An agent cannot change that key through `config set`. What to change in a CLI: `grantsAuthority` no longer adds `mcp: false`, so `commands --json` no longer marks these commands, and a catalogue built with `toolsFromCommands` without `levels` lists them; update a pinned catalogue and a document that lists what MCP leaves out. A command of the CLI's own marked `grantsAuthority` (max `recipients add`) is gated the same way. A caller of `createBotServer` passes `authority: changesAuthorityAt(root)` to hide them; without it they are listed and refuse when called.
+
+- **Diagnostic search is `search runs`.** Replace `runs search`; saved MCP requests use the new command path. Filters are query terms: `status:failed`, `error_code:timeout`, `operation:messages.download` and `profile:work`, alongside literal diagnostic words. Unsupported operators are refused; time bounds and paging remain options. The local search still needs no linked messenger profile, filters before pagination and returns diagnostic fields without message contents. No alias remains for the retired path.
+
+- **Statistics select rows through their query.** Rankings use `message_kind:` with `posts`, `comments` or `all`, and author rankings `min_messages:5`; discussion uses `min_views:10` and `max_replies:0`; unanswered questions use `older_than:24h`. These predicates replace the corresponding filter flags and reach the existing SQL selection before aggregation or row limits. The same reports select chats with `chat:` and exact words with `exact:` instead of `--chat` and `--exact`; source and timezone remain options. Saved CLI/MCP requests must migrate. Stored selections and SDK parameters retain their meanings.
+
 ## 0.399.0 — 23.10.2026
 
 ### Changed — may break callers

package/dist/analysis/consents.d.ts

@@ -4,9 +4,14 @@ export interface AnalysisConsent {
     provider: string;
     at: string;
 }
-export declare const analysisConsents: (store: MessageStore, account: AccountKey) => {
-    list: () => Promise<AnalysisConsent[]>;
-    has: (chat: string, provider: string) => Promise<boolean>;
-    remember: (chat: string, provider: string) => Promise<void>;
-    revoke: (chat?: string, provider?: string) => Promise<void>;
-};
+export interface AnalysisConsentFilter {
+    chat?: string;
+    provider?: string;
+}
+export interface AnalysisConsents {
+    list(filter?: AnalysisConsentFilter): Promise<AnalysisConsent[]>;
+    has(chat: string, provider: string): Promise<boolean>;
+    remember(chat: string, provider: string): Promise<void>;
+    revoke(chat?: string, provider?: string): Promise<void>;
+}
+export declare const analysisConsents: (store: MessageStore, account: AccountKey) => AnalysisConsents;

package/dist/analysis/consents.js

@@ -1,7 +1,7 @@
 import { CliError } from "@wirecat/cli-base";
 const KEY = "analysis-consents-v1";
 export const analysisConsents = (store, account) => {
-    const list = async () => {
+    const list = async (filter) => {
         const state = await store.sync.syncState(account, KEY);
         if (!state)
             return [];
@@ -10,7 +10,10 @@ export const analysisConsents = (store, account) => {
             if (!Array.isArray(items) ||
                 items.some((item) => !item || typeof item.chat !== "string" || typeof item.provider !== "string" || typeof item.at !== "string"))
                 throw new Error("invalid");
-            return items;
+            return filter === undefined
+                ? items
+                : items.filter((item) => (filter.chat === undefined || item.chat === filter.chat) &&
+                    (filter.provider === undefined || item.provider === filter.provider));
         }
         catch {
             throw new CliError("configuration_error", "stored analysis consent is invalid; revoke it before running analysis");

package/dist/cli/bot/mcp.js

@@ -3,7 +3,7 @@ import { CliError } from "@wirecat/cli-base";
 import { annotate, describeProgram } from "@wirecat/cli-base/commands";
 import { Command } from "commander";
 import { environmentOf } from "../context.js";
-import { LOCAL_READ, REMOTE_WRITE } from "../effects.js";
+import { changesAuthorityAt, LOCAL_READ, REMOTE_WRITE } from "../effects.js";
 import { itemOf, renderAnswer } from "../envelope.js";
 import { serverEntry } from "../messenger/mcp-command.js";
 import { nextStep, rootOf } from "../steps.js";
@@ -28,6 +28,7 @@ export const botMcpCommand = (bot) => {
         await serveBotOverStdio({
             bot,
             program: { run, commands: describeProgram(rootOf(this)) },
+            authority: changesAuthorityAt(rootOf(this)),
             settings: context.settings,
             levels: () => bot.resolveSettings(this.optsWithGlobals(), { env: context.env, kind: "bot" }).permissions,
             env: context.env,

package/dist/cli/config-command.js

@@ -2,8 +2,9 @@ import { CliError, pathsAreOverridden } from "@wirecat/cli-base";
 import { annotate } from "@wirecat/cli-base/commands";
 import { Command } from "commander";
 import { envName } from "../ports/app.js";
+import { AUTHORITY_KEY } from "../sends/permissions.js";
 import { loadSnakeCaseConfig } from "./config-keys.js";
-import { baseContext } from "./context.js";
+import { baseContext, environmentOf } from "./context.js";
 import { grantsAuthority, LOCAL_READ, LOCAL_WRITE } from "./effects.js";
 import { itemOf, renderAnswer } from "./envelope.js";
 import { knownBeside, knownPermissionKeys } from "./permission-keys.js";
@@ -94,6 +95,8 @@ export const configCommand = (app, config, { permissionKey } = {}) => {
                 // The defaults are every other profile's settings too, and default_profile picks one of them.
                 throw new CliError("permission_error", `this process is locked to profile ${settings.profile} (${lock}) — ${setting === "default_profile" ? setting : "--defaults"} changes other profiles`);
             }
+            if (environmentOf(this).agent)
+                refuseAuthorityKey(setting, action === "set" ? String(given) : undefined);
             if (action === "set")
                 refuseUnknownKey(this, setting, String(given), permissionKey);
             const saved = config.changeSetting(settings.configPath, {
@@ -133,6 +136,22 @@ export const refuseUnknownKey = (command, setting, value, permissionKey) => {
             (beside.length > 0 ? ` — the known ones there are ${beside.join(", ")}` : ""));
     }
 };
+/**
+ * An agent may hold `mcp.authority` and change other settings, but never the key that let it in: on any profile, in
+ * the defaults, or by replacing `permissions` whole. Only the owner, in a terminal, turns it on or off (NEED-1662).
+ */
+const refuseAuthorityKey = (setting, value) => {
+    const keys = setting.startsWith("permissions.")
+        ? [setting.slice("permissions.".length)]
+        : setting === "permissions"
+            ? value === undefined
+                ? ["mcp"]
+                : objectKeys(value)
+            : [];
+    if (!keys.some((key) => key === "mcp" || key.startsWith("mcp.")))
+        return;
+    throw new CliError("permission_error", `an agent cannot change permissions.${AUTHORITY_KEY} — the owner sets it in a terminal`, { permission: AUTHORITY_KEY });
+};
 /** The keys of a `permissions` object given whole; anything else is left to the schema to refuse. */
 const objectKeys = (value) => {
     try {

package/dist/cli/context.d.ts

@@ -85,6 +85,8 @@ export interface AgentRun {
     failure: (error: ErrorObject) => void;
     /** The server's own stricter levels, `key=level`, as `mcp --permission` takes them; they never loosen. */
     overrides?: readonly string[];
+    /** The server's levels allow `mcp.authority`: a command that changes what a later run may do may run. */
+    authority?: boolean;
 }
 export interface RelayedRun {
     /** The profile serve holds; a command for another is refused before it touches the connection. */

package/dist/cli/context.js

@@ -72,7 +72,7 @@ export const baseContext = (command, resolveSettings) => {
         run: (body, { unbounded = false, name } = {}) => environment.app
             ? recorded({
                 app: environment.app,
-                // An agent's run is named `mcp <command>`, so `runs search` and `sends list` tell it from the owner's.
+                // An agent's run is named `mcp <command>`, so `search runs` and `sends list` tell it from the owner's.
                 command: name ?? `${environment.agent ? "mcp " : ""}${commandPath(command)}`,
                 profile: settings.profile,
                 record: settings.record,

package/dist/cli/effects.d.ts

@@ -14,13 +14,16 @@ export declare const NO_EFFECTS: Effects;
 /**
  * Marks a local write that changes what a later run may do: a schedule, a setting, the recipient list, an
  * auto-reply, an agent's setup. `<PREFIX>_READ_ONLY` refuses it, or an agent under the lock could hand an
- * unlocked run the send it may not make itself (SEC-47). For the same reason no MCP server offers it (`mcp: false`).
+ * unlocked run the send it may not make itself (SEC-47). For the same reason an MCP server offers it only where the
+ * profile allows `mcp.authority`, which is off until the owner turns it on (NEED-1662).
  * `unless` names a flag that makes the run only look (`upgrade --check`), which the lock lets through.
  */
 export declare const grantsAuthority: <T extends Command>(command: T, { unless }?: {
     unless?: string;
 }) => T;
 export declare const changesAuthority: (command: Command) => boolean;
+/** `changesAuthority` by command path under `root`, as an MCP catalogue asks it; an unknown path is not one. */
+export declare const changesAuthorityAt: (root: Command) => (path: readonly string[]) => boolean;
 export declare const changesAuthorityNow: (command: Command) => boolean;
 /**
  * Marks a command that links or unlinks the account — `session start`, `session end`, a setup that logs in. It never

package/dist/cli/effects.js

@@ -16,14 +16,22 @@ const AUTHORITY = new WeakMap();
 /**
  * Marks a local write that changes what a later run may do: a schedule, a setting, the recipient list, an
  * auto-reply, an agent's setup. `<PREFIX>_READ_ONLY` refuses it, or an agent under the lock could hand an
- * unlocked run the send it may not make itself (SEC-47). For the same reason no MCP server offers it (`mcp: false`).
+ * unlocked run the send it may not make itself (SEC-47). For the same reason an MCP server offers it only where the
+ * profile allows `mcp.authority`, which is off until the owner turns it on (NEED-1662).
  * `unless` names a flag that makes the run only look (`upgrade --check`), which the lock lets through.
  */
 export const grantsAuthority = (command, { unless } = {}) => {
     AUTHORITY.set(command, unless);
-    return annotate(command, { mcp: false });
+    return command;
 };
 export const changesAuthority = (command) => AUTHORITY.has(command);
+/** `changesAuthority` by command path under `root`, as an MCP catalogue asks it; an unknown path is not one. */
+export const changesAuthorityAt = (root) => (path) => {
+    let at = root;
+    for (const word of path)
+        at = at?.commands.find((one) => one.name() === word);
+    return at !== undefined && changesAuthority(at);
+};
 export const changesAuthorityNow = (command) => {
     if (!AUTHORITY.has(command))
         return false;

package/dist/cli/index.d.ts

@@ -53,7 +53,7 @@ export { loadSnakeCaseConfig } from "./config-keys.js";
 export { type AgentRun, type BaseContext, type BaseEnvironment, baseContext, environmentOf, outputFor, provide, secretInputOf, } from "./context.js";
 export { type Closeable, withDeadline } from "./deadline.js";
 export { DEFAULT_CONFIG, ensureDefaultConfig } from "./default-config.js";
-export { changesAuthority, destroysNothing, FETCH, grantsAuthority, isLogin, isOtherServiceCall, isStoreChange, judgedEffects, judgedTargets, LOCAL_READ, LOCAL_WRITE, logsInOrOut, NO_EFFECTS, ownerOnlyOption, REMOTE_READ, REMOTE_WRITE, reachesOtherService, refuseUnderReadOnly, } from "./effects.js";
+export { changesAuthority, changesAuthorityAt, destroysNothing, FETCH, grantsAuthority, isLogin, isOtherServiceCall, isStoreChange, judgedEffects, judgedTargets, LOCAL_READ, LOCAL_WRITE, logsInOrOut, NO_EFFECTS, ownerOnlyOption, REMOTE_READ, REMOTE_WRITE, reachesOtherService, refuseUnderReadOnly, } from "./effects.js";
 export { type AnswerOutput, answerSchema, type Body, type ItemBody, itemAnswer, itemOf, jsonlRecords, judgedAnswer, type ListBody, type ListInput, listOf, metaNow, printItem, renderAnswer, sealed, snakeKeys, snakeKeysKeeping, } from "./envelope.js";
 export { withAbort } from "./execution.js";
 export { checkGuide, checkStep, type GuideOptions, type GuideReference, type GuideStep, guideCommand, loadScenarios, MEMO_SCENARIOS, type Scenario, shellProblems, } from "./guide.js";

package/dist/cli/index.js

@@ -48,7 +48,7 @@ export { loadSnakeCaseConfig } from "./config-keys.js";
 export { baseContext, environmentOf, outputFor, provide, secretInputOf, } from "./context.js";
 export { withDeadline } from "./deadline.js";
 export { DEFAULT_CONFIG, ensureDefaultConfig } from "./default-config.js";
-export { changesAuthority, destroysNothing, FETCH, grantsAuthority, isLogin, isOtherServiceCall, isStoreChange, judgedEffects, judgedTargets, LOCAL_READ, LOCAL_WRITE, logsInOrOut, NO_EFFECTS, ownerOnlyOption, REMOTE_READ, REMOTE_WRITE, reachesOtherService, refuseUnderReadOnly, } from "./effects.js";
+export { changesAuthority, changesAuthorityAt, destroysNothing, FETCH, grantsAuthority, isLogin, isOtherServiceCall, isStoreChange, judgedEffects, judgedTargets, LOCAL_READ, LOCAL_WRITE, logsInOrOut, NO_EFFECTS, ownerOnlyOption, REMOTE_READ, REMOTE_WRITE, reachesOtherService, refuseUnderReadOnly, } from "./effects.js";
 export { answerSchema, itemAnswer, itemOf, jsonlRecords, judgedAnswer, listOf, metaNow, printItem, renderAnswer, sealed, snakeKeys, snakeKeysKeeping, } from "./envelope.js";
 export { withAbort } from "./execution.js";
 export { checkGuide, checkStep, guideCommand, loadScenarios, MEMO_SCENARIOS, shellProblems, } from "./guide.js";

package/dist/cli/json-fields.js

@@ -21,6 +21,17 @@ export const entityFields = (table) => {
         return name !== undefined && Object.hasOwn(table, name) ? namesOf(table[name]) : undefined;
     };
 };
+const schemaFields = (schema) => {
+    if (typeof schema !== "object" || schema === null)
+        return undefined;
+    if ("entries" in schema && typeof schema.entries === "object" && schema.entries !== null)
+        return Object.keys(schema.entries);
+    if ("type" in schema && schema.type === "union" && "options" in schema && Array.isArray(schema.options)) {
+        const branches = schema.options.map(schemaFields);
+        return branches.every((fields) => fields !== undefined) ? [...new Set(branches.flat())] : undefined;
+    }
+    return undefined;
+};
 /** The fields of the answer a command declares (`annotate(…, { output })`); nothing until it declares one. */
 export const answerFields = (command, resolve) => {
     const own = resolve?.(command);
@@ -28,7 +39,7 @@ export const answerFields = (command, resolve) => {
         return [...own];
     const name = declaredEntity(command);
     const schema = name === undefined ? undefined : ENTITIES[name];
-    return schema && "entries" in schema ? namesOf(schema) : undefined;
+    return schemaFields(schema);
 };
 const PATHS = /^[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*)*(,[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*)*)*$/;
 const topOf = (fields, known) => fields.split(",").map((path) => {

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

@@ -6,7 +6,9 @@ import { storePath } from "../../store/path.js";
 import { openStore } from "../../store/store.js";
 import { REMOTE_READ, REMOTE_WRITE } from "../effects.js";
 import { itemOf, renderAnswer } from "../envelope.js";
+import { queryTerms, withQuery } from "../list-query.js";
 import { NONE_NAMED } from "../settings.js";
+import { ACCOUNT_PROFILES_QUERY } from "./account-profile-query.js";
 import { accountSessionsCommand } from "./account-sessions-command.js";
 import { recalledAccount } from "./accounts.js";
 import { photoHelp, readProfilePhoto } from "./admin-commands.js";
@@ -18,16 +20,19 @@ export const accountCommand = (messenger) => {
     const tool = `${messenger.app.command} personal`;
     const account = new Command("account")
         .description("the logged-in account")
-        .addCommand(annotate(new Command("list"), { effects: REMOTE_READ, examples: [`${tool} account list`] })
+        .addCommand(withQuery(annotate(new Command("list"), { effects: REMOTE_READ, examples: [`${tool} account list`] }), ACCOUNT_PROFILES_QUERY)
         .summary("profiles on this computer and their signed-in accounts")
         .description("every profile on this computer, and the account each is logged in as; asks the messenger nothing")
-        .action(async function () {
+        .action(async function (words) {
+        const terms = queryTerms(words, ACCOUNT_PROFILES_QUERY, "account list");
         const context = messengerContext(this, messenger, { needsProfile: false });
         const { app, provider } = messenger;
         const current = context.settings.sources.profile === NONE_NAMED ? undefined : context.settings.profile;
-        const profiles = [
-            ...new Set([...(current === undefined ? [] : [current]), ...context.settings.profilesHere]),
-        ].sort();
+        const profiles = [...new Set([...(current === undefined ? [] : [current]), ...context.settings.profilesHere])]
+            .filter((profile) => terms.get("profile") === undefined || profile === terms.get("profile"))
+            .filter((profile) => terms.get("current") === undefined ||
+            (profile === current) === (terms.get("current")?.toLowerCase() === "true"))
+            .sort();
         const store = existsSync(storePath(context.env))
             ? await openStore({ env: context.env }).catch(() => undefined)
             : undefined;
@@ -61,7 +66,11 @@ export const accountCommand = (messenger) => {
         const account = await context.withMessenger((connection) => connection.me());
         renderAnswer(this, context, itemOf(accountAnswer(messenger.provider, whole ? account : maskedAccount(account))));
     }))
-        .addCommand(annotate(new Command("update"), { effects: REMOTE_WRITE, examples: [`${tool} account update --first-name Alex`] })
+        .addCommand(annotate(new Command("update"), {
+        effects: REMOTE_WRITE,
+        output: { entity: "account_change" },
+        examples: [`${tool} account update --first-name Alex`],
+    })
         .description("change the name, the description or the photo everyone sees on your profile")
         .option("--first-name <name>", "your first name")
         .option("--last-name <name>", "your last name")

package/dist/cli/messenger/account-profile-query.d.ts

@@ -0,0 +1,2 @@
+import { type QueryRegistry } from "@wirecat/cli-base/query";
+export declare const ACCOUNT_PROFILES_QUERY: QueryRegistry;

package/dist/cli/messenger/account-profile-query.js

@@ -0,0 +1,13 @@
+import { queryFieldsOf } from "@wirecat/cli-base/query";
+import { accountProfile } from "../../entities/index.js";
+export const ACCOUNT_PROFILES_QUERY = {
+    entity: "account_profile",
+    backend: "native",
+    fields: queryFieldsOf(accountProfile, {
+        native: ["profile", "current"],
+        examples: { profile: "profile:work", current: "current:true" },
+    }).map((field) => ({
+        ...field,
+        operators: field.operators.filter((operator) => operator === "term" || operator === "phrase"),
+    })),
+};

package/dist/cli/messenger/account-sessions-command.js

@@ -26,6 +26,7 @@ export const accountSessionsCommand = (messenger) => {
     // No MCP tool, at any permission level: it logs the owner out of the phone.
     sessions.addCommand(annotate(new Command("end"), {
         effects: REMOTE_WRITE,
+        output: { entity: "ended_account_sessions" },
         mcp: false,
         examples: [`${tool} account sessions end --others`],
     })

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

@@ -57,7 +57,7 @@ export const readProfilePhoto = (messenger, path, env) => readUpload("photo", pa
 });
 const updateCommand = (messenger) => {
     const keys = messenger.groupSettings ?? GROUP_SETTINGS;
-    const update = annotate(new Command("update"), { effects: REMOTE_WRITE })
+    const update = annotate(new Command("update"), { output: { entity: "chat_group_change" }, effects: REMOTE_WRITE })
         .summary("change a group or channel's profile and settings")
         .description("rename a group or channel, change its description, or turn one of its settings on or off")
         .argument("<chat>", messenger.chatArgument)
@@ -93,7 +93,7 @@ const updateCommand = (messenger) => {
 };
 const linkCommand = (messenger) => {
     const link = new Command("link").description("a group's invite link");
-    annotate(link.command("show"), { effects: REMOTE_READ })
+    annotate(link.command("show"), { output: { entity: "chat_invite" }, effects: REMOTE_READ })
         .description("the invite link, if you may see it")
         .argument("<chat>", messenger.chatArgument)
         .action(async function (chat) {
@@ -101,7 +101,7 @@ const linkCommand = (messenger) => {
         renderItem(this, context, await context.withServices((services) => services.admin.link(chat)));
     });
     if (messenger.inviteLinkCreate !== false)
-        link.addCommand(annotate(new Command("create"), { effects: REMOTE_WRITE })
+        link.addCommand(annotate(new Command("create"), { output: { entity: "chat_invite_change" }, effects: REMOTE_WRITE })
             .description("make another invite link; nobody is told until you share it")
             .argument("<chat>", messenger.chatArgument)
             .option("--approval", "who joins by it asks first, and an admin lets them in; it then has no use limit")
@@ -132,7 +132,7 @@ const linkCommand = (messenger) => {
             ].join("  ")));
         }));
     if (messenger.inviteLinkRevoke !== false)
-        link.addCommand(annotate(new Command("revoke"), { effects: REMOTE_WRITE })
+        link.addCommand(annotate(new Command("revoke"), { output: { entity: "chat_invite_change" }, effects: REMOTE_WRITE })
             .description("stop one link; for the group's own link, the answer is the new one")
             .argument("<chat>", messenger.chatArgument)
             .argument("<link>", "the link, as `chats link list` shows it")
@@ -141,7 +141,7 @@ const linkCommand = (messenger) => {
             renderItem(this, context, await context.withServices((services) => services.admin.revokeLink(chat, link)));
         }));
     if (messenger.inviteLinkUpdate === true)
-        link.addCommand(annotate(new Command("update"), { effects: REMOTE_WRITE })
+        link.addCommand(annotate(new Command("update"), { output: { entity: "chat_invite_change" }, effects: REMOTE_WRITE })
             .description("change one of your invite links, the group's own one too")
             .argument("<chat>", messenger.chatArgument)
             .argument("<link>", "the link, as `chats link list` shows it")
@@ -158,7 +158,7 @@ const linkCommand = (messenger) => {
                 ...(maxUses === undefined ? {} : { maxUses }),
             })));
         }));
-    link.addCommand(annotate(new Command("reset"), { effects: REMOTE_WRITE })
+    link.addCommand(annotate(new Command("reset"), { output: { entity: "chat_group_change" }, effects: REMOTE_WRITE })
         .description("replace the invite link; the old one stops working")
         .argument("<chat>", messenger.chatArgument)
         .action(async function (chat) {
@@ -171,7 +171,7 @@ const adminsCommand = (messenger) => {
     const offered = messenger.adminRights ?? ADMIN_RIGHTS;
     const admins = new Command("admins").description("give or take back a member's admin rights");
     const picks = messenger.pickAdminRights !== false;
-    const add = annotate(new Command("add"), { effects: REMOTE_WRITE })
+    const add = annotate(new Command("add"), { output: { entity: "chat_admin_change" }, effects: REMOTE_WRITE })
         .summary(picks ? "make a member an admin with these rights" : "make a member an admin, with every right")
         .description(picks
         ? "make a member an admin with these rights"
@@ -185,7 +185,7 @@ const adminsCommand = (messenger) => {
         const rights = picks ? rightsOf(offered, this.opts().can) : [...offered];
         renderItem(this, context, await context.withServices((services) => services.admin.addAdmin(chat, person, rights)));
     }));
-    admins.addCommand(annotate(new Command("remove"), { effects: REMOTE_WRITE })
+    admins.addCommand(annotate(new Command("remove"), { output: { entity: "chat_admin_change" }, effects: REMOTE_WRITE })
         .description("take an admin's rights back; they stay a member")
         .argument("<chat>", messenger.chatArgument)
         .argument("<person>", "an id, or part of a name")
@@ -223,7 +223,7 @@ const requestsCommand = (messenger) => {
         ["accept", true, "let them in; the group sees them join"],
         ["decline", false, "turn the request away"],
     ]) {
-        const answer = annotate(new Command(verb), { effects: REMOTE_WRITE })
+        const answer = annotate(new Command(verb), { output: { entity: "chat_request_change" }, effects: REMOTE_WRITE })
             .description(help)
             .argument("<chat>", messenger.chatArgument)
             .argument(everyone ? "[person]" : "<person>", "who asked: an id from `chats requests list`");
@@ -247,7 +247,7 @@ const requestsCommand = (messenger) => {
 };
 /** `chats create`, `join`, `leave`, `update` and `link`: the help text is max-cli's, the one both tools say (standard, help rule 2). */
 export const groupCommands = (messenger) => [
-    annotate(new Command("create"), { effects: REMOTE_WRITE })
+    annotate(new Command("create"), { output: { entity: "chat_group_change" }, effects: REMOTE_WRITE })
         .description("create a group or a channel; the people added are told")
         .argument("<title>", "the group's name")
         .argument("[person...]", "people to add: an id, or part of a name")
@@ -257,14 +257,14 @@ export const groupCommands = (messenger) => [
         const { channel } = this.opts();
         renderItem(this, context, await context.withServices((services) => services.admin.create({ title, people, channel: channel === true })));
     }),
-    annotate(new Command("join"), { effects: REMOTE_WRITE })
+    annotate(new Command("join"), { output: { entity: "chat_group_change" }, effects: REMOTE_WRITE })
         .description("join a group or channel by its link; the others in it see that you joined")
         .argument("<link>", `an invite link, or a public one`)
         .action(async function (link) {
         const context = messengerContext(this, messenger);
         renderItem(this, context, await context.withServices((services) => services.admin.join(link)));
     }),
-    annotate(new Command("leave"), { effects: REMOTE_WRITE })
+    annotate(new Command("leave"), { output: { entity: "chat_removal" }, effects: REMOTE_WRITE })
         .description("leave a group or channel; the others in it see that you left")
         .argument("<chat>", messenger.chatArgument)
         .action(async function (chat) {

package/dist/cli/messenger/admin-contacts-command.js

@@ -18,7 +18,10 @@ export const contactWriteCommands = (messenger) => {
         ["remove", "remove a person from your contacts; the chat stays, a name you gave them may not"],
         ["block", "stop a person from writing to you — they need not be a contact"],
         ["unblock", "let a blocked person write to you again"],
-    ].map(([name, description, summary]) => annotate(new Command(name), { effects: REMOTE_WRITE })
+    ].map(([name, description, summary]) => annotate(new Command(name), {
+        effects: REMOTE_WRITE,
+        output: { entity: name === "add" ? "contact_update" : "contact_state_change" },
+    })
         .summary(summary ?? description)
         .description(description)
         .argument("<person>", PERSON)
@@ -27,7 +30,7 @@ export const contactWriteCommands = (messenger) => {
         const done = await context.withServices((services) => services.people[name](person));
         renderAnswer(this, context, itemOf(snakeKeys(done)));
     }));
-    const rename = annotate(new Command("rename"), { effects: REMOTE_WRITE })
+    const rename = annotate(new Command("rename"), { effects: REMOTE_WRITE, output: { entity: "contact_update" } })
         .summary("change a contact's name in the messenger address book")
         .description("rename the contact in the messenger address book; use contacts alias for a private local name")
         .argument("<person>", PERSON)
@@ -39,7 +42,7 @@ export const contactWriteCommands = (messenger) => {
         renderAnswer(this, context, itemOf(snakeKeys(renamed)));
     });
     /** A file rather than argv: these are phone numbers, and argv is read by `ps` and kept by the shell. */
-    const importing = annotate(new Command("import"), { effects: REMOTE_WRITE })
+    const importing = annotate(new Command("import"), { effects: REMOTE_WRITE, output: { entity: "contact_import" } })
         .description("upload phone numbers and add the people the messenger has under them")
         .argument("<file>", "one person per line: number, then a comma, a tab or a semicolon, then the name")
         .action(async function (file) {

package/dist/cli/messenger/admin-folders-command.js

@@ -57,7 +57,7 @@ export const foldersCommand = (messenger) => {
         const found = await context.withServices((services) => services.folders.show(folder));
         renderAnswer(this, context, itemOf(folderAnswer(found)));
     }));
-    folders.addCommand(withRules(annotate(new Command("create"), { effects: REMOTE_WRITE })
+    folders.addCommand(withRules(annotate(new Command("create"), { output: { entity: "chat_folder_change" }, effects: REMOTE_WRITE })
         .description("create a chat folder")
         .argument("<title>", "the folder's name; the app may refuse a long one")
         .option("--chat <chat>", "a chat to put in it, by id or name; repeat it for more", collect), messenger, false).action(async function (title) {
@@ -66,7 +66,7 @@ export const foldersCommand = (messenger) => {
         const rules = rulesOf(this);
         renderItem(this, context, await context.withServices((services) => services.folders.create(title, chat, rules)));
     }));
-    folders.addCommand(withRules(annotate(new Command("update"), { effects: REMOTE_WRITE })
+    folders.addCommand(withRules(annotate(new Command("update"), { output: { entity: "chat_folder_change" }, effects: REMOTE_WRITE })
         .description("rename a folder, or change which chats are in it")
         .argument("<folder>", "folder id, or its title exactly")
         .option("--title <title>", "a new name")
@@ -82,7 +82,7 @@ export const foldersCommand = (messenger) => {
         };
         renderItem(this, context, await context.withServices((services) => services.folders.update(folder, edit)));
     }));
-    folders.addCommand(annotate(new Command("delete"), { effects: REMOTE_WRITE })
+    folders.addCommand(annotate(new Command("delete"), { output: { entity: "chat_folder_removal" }, effects: REMOTE_WRITE })
         .description("delete a folder; the chats in it stay")
         .argument("<folder>", "folder id, or its title exactly")
         .action(async function (folder) {
@@ -90,7 +90,7 @@ export const foldersCommand = (messenger) => {
         renderItem(this, context, await context.withServices((services) => services.folders.delete(folder)));
     }));
     if (messenger.folderOrder !== false)
-        folders.addCommand(annotate(new Command("order"), { effects: REMOTE_WRITE })
+        folders.addCommand(annotate(new Command("order"), { output: { entity: "chat_folder_order" }, effects: REMOTE_WRITE })
             .description("put folders in this order; the ones not named keep theirs after them")
             .argument("<folders...>", "folder ids, or titles exactly, first one first")
             .action(async function (typed) {
@@ -98,7 +98,7 @@ export const foldersCommand = (messenger) => {
             renderItem(this, context, await context.withServices((services) => services.folders.order(typed)));
         }));
     if (messenger.folderJoin !== false)
-        folders.addCommand(annotate(new Command("join"), { effects: REMOTE_WRITE })
+        folders.addCommand(annotate(new Command("join"), { output: { entity: "chat_folder_change" }, effects: REMOTE_WRITE })
             .description("add a folder someone shared by a link; joins every chat in it, and the others there see you joined")
             .argument("<link>", "the folder's link, as t.me/addlist/…")
             .action(async function (link) {

package/dist/cli/messenger/admin-moderation-command.js

@@ -12,14 +12,14 @@ import { messengerContext } from "./context.js";
 /** `chats rules show|set|unset`: the rules live in a file of this profile, and only the chat's id is asked of the messenger. */
 export const rulesCommand = (messenger) => {
     const rules = new Command("rules").description("what `chats moderate` judges a group by, kept in a file of this profile");
-    annotate(rules.command("show"), { effects: LOCAL_READ })
+    annotate(rules.command("show"), { output: { entity: "chat_rules" }, effects: LOCAL_READ })
         .description("the group's rules; the defaults, marked not saved, if it has none yet")
         .argument("<chat>", messenger.chatArgument)
         .action(async function (chat) {
         const context = messengerContext(this, messenger);
         renderItem(this, context, await context.withServices((services) => services.moderation.rules(chat)));
     });
-    rules.addCommand(grantsAuthority(annotate(new Command("set"), { effects: LOCAL_WRITE }))
+    rules.addCommand(grantsAuthority(annotate(new Command("set"), { output: { entity: "chat_rules" }, effects: LOCAL_WRITE }))
         .description("change one rule; the group's first change writes every rule with its default")
         .argument("<chat>", messenger.chatArgument)
         .argument("<key>", `one of: ${RULE_KEYS.join(", ")}`)
@@ -28,7 +28,7 @@ export const rulesCommand = (messenger) => {
         const context = messengerContext(this, messenger);
         renderItem(this, context, await context.withServices((services) => services.moderation.set(chat, key, value)));
     }));
-    rules.addCommand(grantsAuthority(annotate(new Command("unset"), { effects: LOCAL_WRITE }))
+    rules.addCommand(grantsAuthority(annotate(new Command("unset"), { output: { entity: "chat_rules" }, effects: LOCAL_WRITE }))
         .description("put one rule back to its default")
         .argument("<chat>", messenger.chatArgument)
         .argument("<key>", `one of: ${RULE_KEYS.join(", ")}`)
@@ -43,7 +43,7 @@ export const rulesCommand = (messenger) => {
  * for what the rules name, within each action's level in the group's rules. Nothing watches groups
  * in the background.
  */
-export const moderateCommand = (messenger) => annotate(new Command("moderate"), { effects: REMOTE_WRITE })
+export const moderateCommand = (messenger) => annotate(new Command("moderate"), { output: { entity: "chat_moderation" }, effects: REMOTE_WRITE })
     .description("judge a group's new messages and members by its rules, and act as they allow")
     .argument("<chat>", messenger.chatArgument)
     .option("--since-time <time>", "judge what came after this ISO 8601 time, or 2h / 1d ago; the saved point stays")