@wirecat/cli-core 0.399.0 → 0.401.0

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

@@ -83,8 +83,8 @@ export const callsCommand = (messenger) => {
 /** `chats delete` and `chats clear` — for this account only; at the default level they ask first. */
 export const chatDeletionCommands = (messenger) => [
     annotate(new Command("delete"), {
+        output: { entity: "chat_removal" },
         effects: REMOTE_WRITE,
-        mcp: false,
         examples: [`${messenger.app.command} personal chats delete "Book club"`],
     })
         .description("delete a chat from this account; the others in it keep it and its messages")
@@ -95,8 +95,8 @@ export const chatDeletionCommands = (messenger) => [
         renderAnswer(this, context, itemOf(snakeKeys(await context.withServices((services) => services.admin.deleteChat(chat)))));
     }),
     annotate(new Command("clear"), {
+        output: { entity: "chat_removal" },
         effects: REMOTE_WRITE,
-        mcp: false,
         examples: [`${messenger.app.command} personal chats clear "Book club"`],
     })
         .description("delete every message in a chat for this account; the others in it keep theirs")
@@ -110,6 +110,7 @@ export const chatDeletionCommands = (messenger) => [
 /** `chats mute` and `unmute` — the owner's own notifications for one chat; nobody in it is told. */
 export const muteCommands = (messenger) => [
     annotate(new Command("mute"), {
+        output: { entity: "chat_muting" },
         effects: REMOTE_WRITE,
         examples: [
             `${messenger.app.command} chats mute "Book club"`,
@@ -126,6 +127,7 @@ export const muteCommands = (messenger) => [
         renderAnswer(this, context, itemOf(snakeKeys(await context.withServices((services) => services.account.mute(chat, when)))));
     }),
     annotate(new Command("unmute"), {
+        output: { entity: "chat_muting" },
         effects: REMOTE_WRITE,
         examples: [`${messenger.app.command} chats unmute "Book club"`],
     })
@@ -136,7 +138,8 @@ export const muteCommands = (messenger) => [
         renderAnswer(this, context, itemOf(snakeKeys(await context.withServices((services) => services.account.mute(chat, null)))));
     }),
 ];
-const onChatCommand = (messenger, name, description, change) => annotate(new Command(name), {
+const onChatCommand = (messenger, name, description, entity, change) => annotate(new Command(name), {
+    output: { entity },
     effects: REMOTE_WRITE,
     examples: [`${messenger.app.command} chats ${name} 123456789`],
 })
@@ -148,16 +151,16 @@ const onChatCommand = (messenger, name, description, change) => annotate(new Com
 });
 /** `chats archive` and `unarchive` — the messenger's archive of chats, not the local store. */
 export const archiveCommands = (messenger) => [
-    onChatCommand(messenger, "archive", "move a chat into the archive; nobody in it is told", (services, chat) => services.account.archive(chat, true)),
-    onChatCommand(messenger, "unarchive", "bring an archived chat back to the chat list", (services, chat) => services.account.archive(chat, false)),
+    onChatCommand(messenger, "archive", "move a chat into the archive; nobody in it is told", "chat_archive", (services, chat) => services.account.archive(chat, true)),
+    onChatCommand(messenger, "unarchive", "bring an archived chat back to the chat list", "chat_archive", (services, chat) => services.account.archive(chat, false)),
 ];
 /** `chats pin` and `unpin` — where the chat sits in the owner's list; `messages pin` pins a message for everyone. */
 export const chatPinCommands = (messenger) => [
-    onChatCommand(messenger, "pin", "keep a chat at the top of your chat list; nobody in it is told", (services, chat) => services.account.pinChat(chat, true)),
-    onChatCommand(messenger, "unpin", "let a pinned chat move down the chat list again", (services, chat) => services.account.pinChat(chat, false)),
+    onChatCommand(messenger, "pin", "keep a chat at the top of your chat list; nobody in it is told", "chat_pin", (services, chat) => services.account.pinChat(chat, true)),
+    onChatCommand(messenger, "unpin", "let a pinned chat move down the chat list again", "chat_pin", (services, chat) => services.account.pinChat(chat, false)),
 ];
 /** `chats mark-unread` — undone by `chats mark-read`, which the other side does see. */
-export const markUnreadCommand = (messenger) => onChatCommand(messenger, "mark-unread", "mark a chat unread on your own devices; nobody in it is told", (services, chat) => services.account.markUnread(chat));
+export const markUnreadCommand = (messenger) => onChatCommand(messenger, "mark-unread", "mark a chat unread on your own devices; nobody in it is told", "chat_unread", (services, chat) => services.account.markUnread(chat));
 const AUDIENCES = ["everyone", "contacts", "nobody"];
 const audienceOf = (flag, value) => {
     if (!AUDIENCES.includes(value))
@@ -202,6 +205,7 @@ export const privacyCommand = (messenger) => {
     const keys = messenger.privacySettings ?? PRIVACY_SETTINGS;
     const privacy = new Command("privacy").description("who may find, call or add the account");
     annotate(privacy.command("show"), {
+        output: { entity: "account_privacy" },
         effects: REMOTE_READ,
         examples: [`${tool} account privacy show`, `${tool} account privacy show --json`],
     })
@@ -214,6 +218,7 @@ export const privacyCommand = (messenger) => {
     const audience = keys.find((key) => !SWITCHES.has(key));
     const toggle = keys.find((key) => SWITCHES.has(key));
     const set = annotate(new Command("set"), {
+        output: { entity: "account_privacy_change" },
         effects: REMOTE_WRITE,
         examples: [audience, toggle].flatMap((key) => (key === undefined ? [] : [exampleOf(tool, key)])),
     }).description("change who may find, call or add the account; the settings not named stay");

package/dist/cli/messenger/review.js

@@ -113,7 +113,7 @@ const notes = (found, pretty, renderer) => {
             renderer.note(`${chat.title ?? chat.id}: its admins are not known, so only your answers count`);
     if (found.tasks && found.tasks.added + found.tasks.closed > 0)
         renderer.note(`tasks: ${found.tasks.added} opened, ${found.tasks.closed} closed by the rules` +
-            (found.tasks.review > 0 ? `, ${found.tasks.review} pair(s) to review — tasks duplicates` : ""));
+            (found.tasks.review > 0 ? `, ${found.tasks.review} pair(s) to review — tasks duplicates list` : ""));
     if (found.partial && pretty)
         renderer.warn(PARTIAL_NOTE);
     if (found.offline && pretty)

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

@@ -192,7 +192,7 @@ export const scheduleCommand = (messenger) => {
                 .join("\n");
         });
     });
-    annotate(command.command("run"), { effects: REMOTE_WRITE, mcp: false })
+    annotate(command.command("run"), { effects: REMOTE_WRITE })
         .description("run a schedule now, as its timer would, and wait for it")
         .argument("<name>")
         .action(async function (name) {
@@ -216,7 +216,7 @@ export const scheduleCommand = (messenger) => {
         rmSync(file, { force: true });
         say({ name, removed: true }, [`Removed ${name}.`]);
     });
-    annotate(command.command("exec"), { effects: REMOTE_WRITE, mcp: false })
+    annotate(command.command("exec"), { effects: REMOTE_WRITE })
         .description("what a timer runs, given the schedule's file; to run one by hand, use run")
         .argument("<file>")
         .action(async function (file) {

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

@@ -147,6 +147,8 @@ export const allHitItem = (item) => item.kind === "meeting"
         timestamp: item.timestamp,
         excerpt: item.text,
         offset_ms: item.startMs,
+        scope: item.scope,
+        id: String(item.id),
     }
     : defined({
         kind: item.kind,

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

@@ -6,6 +6,7 @@ import { searchNotesOf } from "../../services/notes-search.js";
 import { LOCAL_READ, REMOTE_READ } from "../effects.js";
 import { renderAnswer } from "../envelope.js";
 import { positiveCount } from "../paging.js";
+import { runsSearchCommand } from "../runs/search-command.js";
 import { commandAt } from "../steps.js";
 import { messengerContext } from "./context.js";
 import { conversationsSearchCommand } from "./conversations-command.js";
@@ -159,7 +160,8 @@ export const searchCommand = (messenger, { topics = false } = {}) => {
         .addCommand(allCommand(messenger))
         .addCommand(messagesSearchCommand(messenger))
         .addCommand(notesCommand(messenger))
-        .addCommand(conversationsSearchCommand(messenger));
+        .addCommand(conversationsSearchCommand(messenger))
+        .addCommand(runsSearchCommand(messenger.app));
     if (topics)
         search.addCommand(topicsSearchCommand(messenger));
     for (const [path, args] of Object.entries({

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

@@ -124,7 +124,11 @@ export const searchesCommand = (messenger) => {
         const deleted = await context.withServices((services) => services.searches.delete(reference));
         renderAnswer(this, context, itemOf(savedSearchItem(deleted)), () => `deleted ${deleted.name ?? `run ${deleted.id}`}\n`);
     });
-    annotate(searches.command("clear"), { effects: LOCAL_WRITE, examples: [`${tool} searches clear`] })
+    annotate(searches.command("clear"), {
+        output: { entity: "search_history_clear" },
+        effects: LOCAL_WRITE,
+        examples: [`${tool} searches clear`],
+    })
         .description("empty the history; saved searches stay")
         .action(async function () {
         const context = messengerContext(this, messenger);

package/dist/cli/messenger/sends-query.d.ts

@@ -0,0 +1,5 @@
+import { type QueryRegistry } from "@wirecat/cli-base/query";
+import type { SendFilter } from "../../sends/journal.js";
+import { type QueryWords } from "../list-query.js";
+export declare const SENDS_QUERY: QueryRegistry;
+export declare const sendFilter: (words: QueryWords) => SendFilter | undefined;

package/dist/cli/messenger/sends-query.js

@@ -0,0 +1,33 @@
+import { queryFieldsOf } from "@wirecat/cli-base/query";
+import { sendAttempt } from "../../entities/index.js";
+import { queryTerms } from "../list-query.js";
+export const SENDS_QUERY = {
+    entity: "send_attempt",
+    backend: "native",
+    fields: queryFieldsOf(sendAttempt, {
+        native: ["outcome", "chat_id", "operation_id", "error_code", "key"],
+        examples: {
+            outcome: "outcome:failed",
+            chat_id: "chat_id:7",
+            operation_id: "operation_id:op-1",
+            error_code: "error_code:timeout",
+            key: "key:messages.send",
+        },
+    }).map((field) => field.native
+        ? { ...field, operators: field.operators.filter((operator) => operator === "term" || operator === "phrase") }
+        : field),
+};
+export const sendFilter = (words) => {
+    const terms = queryTerms(words, SENDS_QUERY, "sends list");
+    if (terms.size === 0)
+        return undefined;
+    const outcome = sendAttempt.entries.outcome.options.find((value) => value === terms.get("outcome"));
+    const chatId = terms.get("chat_id"), operationId = terms.get("operation_id"), errorCode = terms.get("error_code"), key = terms.get("key");
+    return {
+        ...(outcome === undefined ? {} : { outcome }),
+        ...(chatId === undefined ? {} : { chatId }),
+        ...(operationId === undefined ? {} : { operationId }),
+        ...(errorCode === undefined ? {} : { errorCode }),
+        ...(key === undefined ? {} : { key }),
+    };
+};

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

@@ -31,6 +31,7 @@ export { lockPath, readLock, servingProfiles } from "../../background/lock.js";
  */
 export const serveCommand = (messenger) => {
     const command = annotate(new Command("serve"), {
+        output: { entity: "serve_summary" },
         effects: REMOTE_WRITE,
         lifetime: "persistent",
         examples: [`${messenger.app.command} personal serve`],

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

@@ -185,7 +185,6 @@ export const serverCommand = (messenger, options = {}) => {
     const withIdle = (sub) => options.idle ? sub.option("--idle <duration>", "stop after this long with nobody using it — 15m, 1h") : sub;
     withIdle(destroysNothing(annotate(command.command("start"), {
         effects: LOCAL_WRITE,
-        mcp: false,
         examples: [`${app.command} personal server start`],
     }))
         .summary("start this profile's background server")
@@ -194,7 +193,6 @@ export const serverCommand = (messenger, options = {}) => {
     });
     destroysNothing(annotate(command.command("stop"), {
         effects: LOCAL_WRITE,
-        mcp: false,
         examples: [`${app.command} personal server stop`],
     }))
         .description("stop this profile's serve — through the unit if it runs under one")
@@ -202,7 +200,6 @@ export const serverCommand = (messenger, options = {}) => {
         await stop(prepare(this));
     });
     withIdle(destroysNothing(annotate(command.command("restart"), {
-        mcp: false,
         effects: LOCAL_WRITE,
         examples: [`${app.command} personal server restart`],
     })).description("stop it and start it again")).action(async function () {

package/dist/cli/messenger/statistics-query.d.ts

@@ -0,0 +1,14 @@
+import type { Command } from "commander";
+import { type QueryWords } from "../list-query.js";
+export type StatisticsQuery = "contacts-top" | "messages-top" | "discussion" | "unanswered" | "responses";
+export declare const withStatisticsQuery: (command: Command, report: StatisticsQuery) => Command;
+/** Report predicates become the existing source/aggregate parameters; the message query keeps its syntax. */
+export interface StatisticsFilters {
+    text?: string;
+    messageKind?: string;
+    minMessages?: number;
+    minViews?: number;
+    maxReplies?: number;
+    olderThan?: string;
+}
+export declare const statisticsQuery: (words: QueryWords, report: StatisticsQuery) => StatisticsFilters;

package/dist/cli/messenger/statistics-query.js

@@ -0,0 +1,143 @@
+import { annotate } from "@wirecat/cli-base/commands";
+import { defineQuery, fieldsHelp, parseLucene, queryError, validateQuery, walkQuery, } from "@wirecat/cli-base/query";
+import { QUERY_FIELDS } from "../../search/lucene/registry.js";
+import { MESSAGE_PARSING } from "../../search/lucene/types.js";
+import { LIST_QUERY_GUIDE, typedQuery } from "../list-query.js";
+const FIELDS = {
+    "contacts-top": ["message_kind", "min_messages"],
+    "messages-top": ["message_kind"],
+    discussion: ["min_views", "max_replies"],
+    unanswered: ["older_than"],
+    responses: [],
+};
+const PATHS = {
+    "contacts-top": "stats contacts top",
+    "messages-top": "stats messages top",
+    discussion: "stats messages discussion",
+    unanswered: "stats messages unanswered",
+    responses: "stats contacts responses",
+};
+const FIELD_SPECS = [
+    {
+        name: "message_kind",
+        type: "enum",
+        values: ["all", "posts", "comments"],
+        operators: ["term", "phrase"],
+        example: "message_kind:posts",
+        placement: "and",
+        relation: "proven posts or comments selected before ranking",
+    },
+    {
+        name: "min_messages",
+        type: "num",
+        operators: ["term"],
+        example: "min_messages:5",
+        placement: "and",
+        relation: "minimum selected messages per ranked author",
+    },
+    {
+        name: "min_views",
+        type: "num",
+        operators: ["term"],
+        example: "min_views:10",
+        placement: "and",
+        relation: "minimum known cumulative views of a discussion post",
+    },
+    {
+        name: "max_replies",
+        type: "num",
+        operators: ["term"],
+        example: "max_replies:0",
+        placement: "and",
+        relation: "maximum observed discussion replies",
+    },
+    {
+        name: "older_than",
+        type: "kw",
+        operators: ["term", "phrase"],
+        example: "older_than:24h",
+        placement: "and",
+        relation: "minimum age of an unanswered question; positive duration",
+    },
+];
+const fieldsFor = (report) => FIELD_SPECS.filter(({ name }) => FIELDS[report].includes(name));
+export const withStatisticsQuery = (command, report) => {
+    const extra = fieldsFor(report);
+    const query = defineQuery({
+        entity: report.endsWith("top") ? "ranking" : "admin_report",
+        backend: "sql",
+        fields: [
+            ...QUERY_FIELDS.map((field) => ({
+                ...field,
+                example: field.name === "text" ? "text:invoice" : field.name === "topic" ? "topic:42" : field.example,
+            })),
+            ...extra,
+        ],
+    });
+    annotate(command, { query });
+    command.addHelpText("after", `\n${fieldsHelp({ fields: extra }, LIST_QUERY_GUIDE)}\nReport predicates are positive AND terms; the remaining query selects stored messages.\n`);
+    return command;
+};
+export const statisticsQuery = (words, report) => {
+    const source = typedQuery(words);
+    if (!source.trim())
+        return {};
+    const ast = parseLucene(source, MESSAGE_PARSING);
+    const reserved = new Set(FIELD_SPECS.map(({ name }) => name));
+    const hasReport = (node) => walkQuery(node).some(({ field }) => reserved.has(field));
+    if (!hasReport(ast.root))
+        return { text: source };
+    const context = { command: PATHS[report], guide: LIST_QUERY_GUIDE };
+    const values = new Map();
+    const original = (node) => {
+        const piece = source.slice(node.span.start, node.span.end);
+        if (node.kind === "boolean") {
+            const prefix = /(?:^|[\s(])([a-z_][a-z0-9_-]*)\s*:\s*$/i.exec(source.slice(0, node.span.start));
+            return prefix ? `${prefix[1]}:${piece}` : piece;
+        }
+        const named = /^([a-z_][a-z0-9_-]*)\s*[:<>]/i.exec(piece)?.[1];
+        return node.implicit || named?.toLowerCase() === node.field.toLowerCase() ? piece : `${node.field}:${piece}`;
+    };
+    const prune = (node) => {
+        if (!hasReport(node))
+            return original(node);
+        if (node.kind === "boolean") {
+            if (node.clauses.some(({ occur, node: child }) => occur === "should" || (occur === "must_not" && hasReport(child))))
+                queryError("query.unsupported-placement", node.span, "report predicates must be positive AND terms", context);
+            const kept = node.clauses
+                .map(({ occur, node: child }) => {
+                const part = prune(child);
+                return part === undefined ? undefined : occur === "must_not" ? `NOT (${part})` : part;
+            })
+                .filter((part) => part !== undefined);
+            return kept.length ? kept.map((part) => `(${part})`).join(" AND ") : undefined;
+        }
+        if (!FIELDS[report].includes(node.field))
+            queryError("query.unsupported-field", node.span, `${node.field} is not a filter for ${PATHS[report]}`, context);
+        validateQuery({ ...ast, root: node }, { entity: "statistics", backend: "sql", fields: fieldsFor(report) }, context);
+        if (values.has(node.field))
+            queryError("query.unsupported-placement", node.span, `${node.field} only once here`, context);
+        if (["min_messages", "min_views", "max_replies"].includes(node.field)) {
+            const value = Number(node.value);
+            if (!Number.isSafeInteger(value) || value < (node.field === "min_messages" ? 1 : 0))
+                queryError("query.invalid-number", node.span, `${node.field} takes a ${node.field === "min_messages" ? "positive" : "nonnegative"} integer`, context);
+        }
+        if (node.field === "older_than") {
+            const units = { s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000, w: 604_800_000 };
+            const duration = Number(node.value.slice(0, -1)) * (units[node.value.at(-1) ?? ""] ?? 0);
+            if (!/^\d+(?:\.\d+)?[smhdw]$/.test(node.value) || !Number.isSafeInteger(duration) || duration <= 0)
+                queryError("query.invalid-duration", node.span, "older_than takes a positive duration such as 4h or 7d", context);
+        }
+        values.set(node.field, node.value);
+        return undefined;
+    };
+    const text = prune(ast.root);
+    return {
+        ...(text ? { text } : {}),
+        ...(values.has("message_kind") ? { messageKind: values.get("message_kind")?.toLowerCase() } : {}),
+        ...(values.has("min_messages") ? { minMessages: Number(values.get("min_messages")) } : {}),
+        ...(values.has("min_views") ? { minViews: Number(values.get("min_views")) } : {}),
+        ...(values.has("max_replies") ? { maxReplies: Number(values.get("max_replies")) } : {}),
+        ...(values.has("older_than") ? { olderThan: values.get("older_than") } : {}),
+    };
+};

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

@@ -91,15 +91,15 @@ export const statsCommand = (messenger, loadRenderer = chartRenderer) => {
         "chats retention": '"Book club"',
         "chats show": '"Book club"',
         "contacts evidence": '101 --selection "$selection" --component messages',
-        "contacts responses": '--chat "Project room"',
-        "contacts top": '--chat "Book club" --limit 10',
+        "contacts responses": 'chat:"Project room"',
+        "contacts top": 'chat:"Book club" --limit 10',
         "messages counters refresh": '--chat "Book club" --dry-run',
         "messages counters show": '--chat "Book club" --limit 10',
-        "messages discussion": '--chat "Book club"',
+        "messages discussion": 'chat:"Book club"',
         "messages evidence": '"$message" --selection "$selection" --component reactions',
         "messages show": '--chat "Book club" --by day',
-        "messages top": '--chat "Book club" --limit 10',
-        "messages unanswered": '--chat "Project room"',
+        "messages top": 'chat:"Book club" --limit 10',
+        "messages unanswered": 'chat:"Project room"',
         "tasks show": '--chat "Project room"',
     };
     for (const [path, args] of Object.entries(examples)) {

package/dist/cli/messenger/store-maintenance-command.js

@@ -92,7 +92,7 @@ const refuseWhileServing = (command, messenger) => {
         throw new CliError("validation_error", `${messenger.app.command} serve is running for ${serving.join(", ")} — ${serving.map((profile) => `\`${messenger.app.command} ${profile} server stop\``).join(", ")} first`);
     }
 };
-const repairCommand = (messenger) => annotate(new Command("repair"), { effects: LOCAL_WRITE, mcp: false })
+const repairCommand = (messenger) => annotate(new Command("repair"), { output: { entity: "store_repair" }, effects: LOCAL_WRITE })
     .summary("repair table shapes while keeping the old tables")
     .description("bring every table to this build's shape, deleting nothing: a table of the wrong shape is kept as a copy beside a new one")
     .option("--dry-run", "say what it would do, and change nothing")
@@ -142,7 +142,7 @@ const notesOf = (report, command) => {
     }
     return notes;
 };
-const copiesCommand = () => new Command("copies").description("the tables `store repair` kept as copies").addCommand(annotate(new Command("delete"), { effects: LOCAL_WRITE, mcp: false })
+const copiesCommand = () => new Command("copies").description("the tables `store repair` kept as copies").addCommand(annotate(new Command("delete"), { output: { entity: "store_copy_removal" }, effects: LOCAL_WRITE })
     .description("delete one copy `store repair` kept, named exactly; refuses any other table")
     .argument("<name>", "the copy's name, as `store repair` printed it")
     .action(async function (name) {
@@ -152,7 +152,7 @@ const copiesCommand = () => new Command("copies").description("the tables `store
     const deleted = await reading(path, (database) => deleteCopy(database, name));
     result(this, { path, deleted });
 }));
-const infoCommand = () => annotate(new Command("info"), { effects: LOCAL_READ })
+const infoCommand = () => annotate(new Command("info"), { output: { entity: "store_info" }, effects: LOCAL_READ })
     .summary("the local archive's format, size and contents")
     .description("the store file: where it is, its size, its schema and how many rows it holds; changes nothing")
     .action(async function () {
@@ -182,7 +182,7 @@ const infoCommand = () => annotate(new Command("info"), { effects: LOCAL_READ })
  * fetched" (NEED-399 A). Times are the chat's newest message by the messenger's list against the
  * newest message held, not `sync_ranges`: those are in message ids, which a chat list does not give.
  */
-const checkCommand = (messenger) => annotate(new Command("check"), { effects: LOCAL_READ })
+const checkCommand = (messenger) => annotate(new Command("check"), { output: { entity: "store_check" }, effects: LOCAL_READ })
     .summary("check the local archive for problems")
     .description("whether the store is healthy — integrity, search indexes, disk, and which chats are behind")
     .action(async function () {
@@ -362,7 +362,7 @@ const chatsBehind = (database) => database
     held: row.held === null ? null : isoOf(row.held),
     refreshed: isoOf(row.refreshed),
 }));
-const migrateCommand = (messenger) => annotate(new Command("migrate"), { effects: LOCAL_WRITE, mcp: false })
+const migrateCommand = (messenger) => annotate(new Command("migrate"), { output: { entity: "store_migration" }, effects: LOCAL_WRITE })
     .summary("migrate an older local archive")
     .description("bring the store up to this build's schema, then normalize, index and stem the messages and notes stored before it")
     .action(async function () {
@@ -431,7 +431,7 @@ const buildNoteIndex = (database, note, { reset = false } = {}) => {
         note(`indexing ${pending} notes`);
     return { notesIndexed: drainNoteIndex(database, stemmerCache()) };
 };
-const reindexCommand = (messenger) => destroysNothing(annotate(new Command("reindex"), { effects: LOCAL_WRITE }))
+const reindexCommand = (messenger) => destroysNothing(annotate(new Command("reindex"), { output: { entity: "store_reindex" }, effects: LOCAL_WRITE }))
     .summary("rebuild the local archive's search indexes")
     .description("rebuild the word index, its typo vocabulary, the stems, the files' word index, the notes' indexes and who took part in what, from what is stored; loses nothing")
     .action(async function () {
@@ -478,7 +478,7 @@ const vacuumInto = async (path, target) => {
     }
 };
 const stampNow = () => new Date().toISOString().replace(/[:.]/g, "-");
-const backupCommand = () => destroysNothing(annotate(new Command("backup"), { effects: LOCAL_WRITE, mcp: false }))
+const backupCommand = () => destroysNothing(annotate(new Command("backup"), { output: { entity: "store_backup" }, effects: LOCAL_WRITE }))
     .description("copy the store into a new file, while it is in use; never overwrites a file")
     .argument("<file>", "the new file")
     .option(...ENCRYPT_OPTION)
@@ -522,7 +522,7 @@ const backupCommand = () => destroysNothing(annotate(new Command("backup"), { ef
     }
 });
 /** The only way back into a sealed file: the format is this tool's own. */
-const decryptCommand = () => annotate(new Command("decrypt"), { effects: LOCAL_WRITE, mcp: false })
+const decryptCommand = () => annotate(new Command("decrypt"), { output: { entity: "store_decrypt" }, effects: LOCAL_WRITE })
     .description("open a file written with --encrypt into a new file; asks for its password")
     .argument("<file>", "a file `store backup --encrypt` or `store export --encrypt` wrote")
     .requiredOption("--output <file>", "the new file, readable only by you")
@@ -544,7 +544,7 @@ const decryptCommand = () => annotate(new Command("decrypt"), { effects: LOCAL_W
  * process has the file open — it would go on writing to the file set aside — or while this CLI's
  * `serve` runs: that opens the store on its first write, so until then it holds nothing to see.
  */
-const restoreCommand = (messenger) => annotate(new Command("restore"), { effects: LOCAL_WRITE, mcp: false })
+const restoreCommand = (messenger) => annotate(new Command("restore"), { output: { entity: "store_restore" }, effects: LOCAL_WRITE })
     .summary("restore a backup while keeping the current store")
     .description("put a backup in place of the store; the store it replaces is kept beside it, never deleted")
     .argument("<file>", "a file `store backup` wrote; one written with --encrypt asks for its password")
@@ -661,7 +661,7 @@ const quiesce = async (path, messenger, then, warn, waitMs = STORE_LOCK_WAIT_MS)
  * For a store this build cannot migrate: a backup beside it, then an empty store at this build's
  * schema. The backup is made before anything is deleted, and its path is said before the delete.
  */
-const resetCommand = (messenger) => annotate(new Command("reset"), { effects: LOCAL_WRITE, mcp: false })
+const resetCommand = (messenger) => annotate(new Command("reset"), { output: { entity: "store_reset" }, effects: LOCAL_WRITE })
     .summary("back up the local archive and replace it with an empty one")
     .description("back the store up beside itself, then delete it and start an empty one at this build's schema; asks first, or --yes")
     .option("--no-backup", "delete the store without backing it up first")

package/dist/cli/messenger/stored.js

@@ -417,7 +417,10 @@ export const stored = (messenger, { account, store, warn, events, pending, annou
             const sent = await messenger.send(chatId, text, options);
             // A scheduled message is not in the chat yet, and it will arrive under another id.
             if (options.at === undefined) {
-                await save("messages.send", (opened) => saveSent(opened, account, chatId, sent.message, { via: "send" }));
+                await save("messages.send", async (opened) => {
+                    for (const message of sent.messages ?? [sent.message])
+                        await saveSent(opened, account, chatId, message, { via: "send" });
+                });
             }
             return sent;
         },

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

@@ -32,7 +32,11 @@ export const tagsCommand = (messenger) => {
     const tags = new Command("tags")
         .summary("tags on stored messages and other records")
         .description("your own labels on chats, people, messages and tasks, kept in the local store and never sent; tag: in a search finds them");
-    changesStore(annotate(tags.command("auto"), { effects: FETCH, examples: [`${tool} tags auto --chat "Book club" --dry-run`] }))
+    changesStore(annotate(tags.command("auto"), {
+        output: { entity: "automatic_tags" },
+        effects: FETCH,
+        examples: [`${tool} tags auto --chat "Book club" --dry-run`],
+    }))
         .description("derive local group/channel tags from cached metadata using keyword rules")
         .option("--chat <chat>", "a stored group/channel; repeat to select several", (value, previous) => [...previous, value], [])
         .option("--limit <n>", "process at most 1–500 chats", positiveCount("--limit"), 50)
@@ -47,6 +51,7 @@ export const tagsCommand = (messenger) => {
         renderAnswer(this, context, itemOf(snakeKeys(done)));
     });
     targetOptions(annotate(tags.command("add"), {
+        output: { entity: "tag_change" },
         effects: LOCAL_WRITE,
         examples: [`${tool} tags add reading --chat "Book club"`],
     }).description("put tags on one chat, person, message or task"), messenger, "tag").action(async function (given) {
@@ -59,6 +64,7 @@ export const tagsCommand = (messenger) => {
             context.renderer.note(`already there: ${done.unchanged.join(", ")}`);
     });
     targetOptions(annotate(tags.command("remove"), {
+        output: { entity: "tag_change" },
         effects: LOCAL_WRITE,
         examples: [`${tool} tags remove reading --chat "Book club"`],
     }).description("take tags off one chat, person, message or task"), messenger, "untag")