@wirecat/cli-core 0.405.0 → 0.407.0

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

@@ -21,7 +21,7 @@ const count = (value) => {
 };
 export const gapsCommand = (messenger) => {
     const group = new Command("gaps").description("inspect recorded interior coverage gaps and explicitly fetch them");
-    annotate(group.command("plan"), { output: { entity: "store_gap_plan" }, effects: LOCAL_READ })
+    annotate(group.command("show"), { output: { entity: "store_gap_plan" }, effects: LOCAL_READ })
         .description("local coverage plan; missing message ids alone do not imply missing history")
         .argument("<chat>", messenger.chatArgument)
         .action(async function (chat) {
@@ -71,7 +71,7 @@ export const gapsCommand = (messenger) => {
         if (prepare) {
             validateCatchUpBounds(preparation);
             refuseLocalWrite(context, messenger.app.command, "conversations.links");
-            refuseLocalWrite(context, messenger.app.command, "conversations.embed");
+            refuseLocalWrite(context, messenger.app.command, "conversations.embeddings");
         }
         if (args.background) {
             const planned = await context.withServices((services) => services.gaps.plan(chat));

package/dist/cli/messenger/hearing-command.d.ts

@@ -2,7 +2,7 @@ import type { Message } from "../../domain/models.js";
 import { type Hearing } from "../../speech/hearing.js";
 import type { Messenger, MessengerContext, ReadConnection } from "./context.js";
 export declare const TRANSCRIBE_OPTION: readonly ["--transcribe", "turn voice messages not heard yet into text — by the messenger where it can, else by a model on this machine; can take minutes"];
-export declare const MODEL_OPTION: readonly ["--model <model>", "which downloaded speech model hears them, with --transcribe; `models audio list` shows them"];
+export declare const MODEL_OPTION: readonly ["--model <model>", "which downloaded speech model hears them, with --transcribe; `models list` shows them"];
 /**
  * Kept transcripts on every read; new ones with `--transcribe`, using the read's connection when
  * supplied. It is released before local recognition. `undefined` when there is no voice message, and then no file is opened.

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

@@ -6,7 +6,7 @@ export const TRANSCRIBE_OPTION = [
 ];
 export const MODEL_OPTION = [
     "--model <model>",
-    "which downloaded speech model hears them, with --transcribe; `models audio list` shows them",
+    "which downloaded speech model hears them, with --transcribe; `models list` shows them",
 ];
 /**
  * Kept transcripts on every read; new ones with `--transcribe`, using the read's connection when

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

@@ -27,7 +27,7 @@ export const imagesCommand = (messenger) => {
         .action(async function () {
         const { chat, limit = DEFAULT_LIMIT } = this.opts();
         const context = messengerContext(this, messenger);
-        refuseLocalWrite(context, messenger.app.command, "conversations.embed");
+        refuseLocalWrite(context, messenger.app.command, "conversations.embeddings");
         const controller = new AbortController();
         context.track({ close: async () => controller.abort() });
         const done = await context.withServices((services) => services.pictures.embed({ ...(chat === undefined ? {} : { chat }), limit, signal: controller.signal }));

package/dist/cli/messenger/inbox.js

@@ -1,8 +1,7 @@
 import { CliError } from "@wirecat/cli-base";
 import { annotate } from "@wirecat/cli-base/commands";
-import { Command, Option } from "commander";
+import { Command } from "commander";
 import { renderMessages } from "../../render/messages.js";
-import { CHAT_KINDS } from "../../services/chats.js";
 import { kindsOf } from "../../services/inbox.js";
 import { modelWith } from "../../speech/hearing.js";
 import { REMOTE_READ } from "../effects.js";
@@ -41,7 +40,6 @@ export const inboxCommand = (messenger) => annotate(new Command("inbox"), {
     .option("--new", "what arrived since the last check, each message once — for scheduled runs")
     .option("--limit <n>", "at most this many per chat, the newest", positiveCount("--limit"))
     .option("--all", "muted and archived chats too — left out unless they mention you or reply to you")
-    .addOption(new Option("--kind <kinds>", `compatibility spelling for kind:; ${CHAT_KINDS.join(", ")}`).hideHelp())
     .option(...TRANSCRIBE_OPTION)
     .option(...MODEL_OPTION)
     .addHelpText("after", "To mark a chat read, use `chats mark-read <chat>`. The other side sees it.")

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

@@ -9,6 +9,7 @@ type Need = readonly [method: keyof MessengerAdapter, what: string];
 export declare const COMMAND_NEEDS: Readonly<Record<string, Need>>;
 interface Lacking {
     channelComments?: boolean;
+    readsComments?: boolean;
     lacks?: readonly (keyof MessengerAdapter)[];
     never?: readonly (keyof MessengerAdapter)[];
     history?: "server" | "store";

package/dist/cli/messenger/lacks.js

@@ -30,7 +30,7 @@ export const lackedNeed = (messenger, path) => {
     const need = COMMAND_NEEDS[path];
     if (!need)
         return undefined;
-    if (path === "messages comments" && messenger?.channelComments === false)
+    if (path === "messages comments" && (messenger?.readsComments ?? messenger?.channelComments) === false)
         return need;
     if (!messenger?.lacks?.includes(need[0]) && !messenger?.never?.includes(need[0]))
         return undefined;

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

@@ -74,9 +74,9 @@ export const mcpCommand = (messenger) => {
         // Pasted into a file, so a person gets the client's own JSON, indented; a script finds it under `config`.
         renderAnswer(this, context, itemOf({ config: entry.config }, { next: entry.nodeBound ? [nextStep("mcp.config", { args: {} })] : [] }), () => JSON.stringify(entry.config, null, 2));
     }));
-    command.addCommand(withFlags(grantsAuthority(annotate(new Command("setup"), {
+    command.addCommand(withFlags(grantsAuthority(annotate(new Command("add"), {
         effects: LOCAL_WRITE,
-        examples: [`${app.command} personal mcp setup codex --allow-writes`],
+        examples: [`${app.command} personal mcp add codex --allow-writes`],
     }))
         .description("add this profile's local MCP server to Codex or Claude Code")
         .argument("<client>", "codex or claude-code")
@@ -108,9 +108,9 @@ export const mcpCommand = (messenger) => {
             throw new CliError("validation_error", error instanceof Error ? error.message : "MCP setup failed");
         }
     }));
-    command.addCommand(withFlags(annotate(new Command("doctor"), {
+    command.addCommand(withFlags(annotate(new Command("check"), {
         effects: LOCAL_READ,
-        examples: [`${app.command} personal mcp doctor`],
+        examples: [`${app.command} personal mcp check`],
     }).description("check this profile's local MCP handshake and tool list")).action(async function () {
         const context = messengerContext(this, messenger);
         const { settings, env } = context;

package/dist/cli/messenger/messages-comments-command.js

@@ -10,15 +10,20 @@ import { messengerContext } from "./context.js";
 import { COMMENTS_QUERY, cursorOf, historyWindow } from "./history-query.js";
 import { messageItems, viewOf } from "./message-items.js";
 export const commentsCommand = (messenger) => {
+    const otherPosts = messenger.readsComments === true && messenger.channelComments === false;
     const command = annotate(new Command("comments"), {
-        examples: [`${messenger.app.command} personal messages comments "News channel" 101 --limit 20`],
+        examples: [
+            `${messenger.app.command} personal messages comments "${otherPosts ? "Announcements" : "News channel"}" 101 --limit 20`,
+        ],
         effects: REMOTE_READ,
     })
-        .summary("comments on a channel post")
-        .description("the comments under a channel post, oldest to newest; they live in its discussion group")
+        .summary(otherPosts ? "comments on a post" : "comments on a channel post")
+        .description(otherPosts
+        ? "the comments received under a post, oldest to newest"
+        : "the comments under a channel post, oldest to newest; they live in its discussion group")
         .addHelpText("after", queryHelp(COMMENTS_QUERY))
-        .argument("<chat>", `the channel: ${messenger.chatArgument}`)
-        .argument("<post>", "the post's message id in the channel")
+        .argument("<chat>", `the ${otherPosts ? "chat" : "channel"}: ${messenger.chatArgument}`)
+        .argument("<post>", otherPosts ? "the post's message id in the chat" : "the post's message id in the channel")
         .argument("[query...]", "where to start: id<42")
         .option("--limit <n>", "how many", positiveCount("--limit"))
         .option("--cursor <cursor>", "go on from where the last page stopped; page.next gives it")

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

@@ -8,10 +8,10 @@ import { messengerContext, refuseLocalWrite } from "./context.js";
 export const metadataCommand = (messenger) => {
     const tool = messenger.app.command;
     const command = new Command("metadata").description("cached group/channel descriptions for local automatic tags");
-    annotate(command.command("get"), {
+    annotate(command.command("show"), {
         output: { entity: "chat_metadata" },
         effects: LOCAL_READ,
-        examples: [`${tool} metadata get --chat 7`],
+        examples: [`${tool} metadata show --chat 7`],
     })
         .description("a stored chat's cached description, as automatic tags read it")
         .requiredOption("--chat <chat>", "a stored chat")
@@ -20,10 +20,10 @@ export const metadataCommand = (messenger) => {
         const { chat } = this.opts();
         renderAnswer(this, context, itemOf(snakeKeys(await context.withServices((services) => services.metadata.get(chat)))));
     });
-    annotate(command.command("refresh"), {
+    annotate(command.command("sync"), {
         output: { entity: "chat_metadata_refresh" },
         effects: FETCH,
-        examples: [`${tool} metadata refresh --chat 7 --chat 8`, `${tool} metadata refresh --only-missing --limit 20`],
+        examples: [`${tool} metadata sync --chat 7 --chat 8`, `${tool} metadata sync --only-missing --limit 20`],
     })
         .description("fetch group and channel descriptions again and cache them")
         .option("--chat <chat>", "stored group/channel; repeat for several", (value, previous) => [...previous, value], [])
@@ -31,7 +31,7 @@ export const metadataCommand = (messenger) => {
         .option("--limit <n>", "process at most 1–500 chats", positiveCount("--limit"), 50)
         .action(async function () {
         const context = messengerContext(this, messenger);
-        refuseLocalWrite(context, messenger.app.command, "metadata.refresh");
+        refuseLocalWrite(context, messenger.app.command, "metadata.sync");
         const options = this.opts();
         const limit = Number(options.limit);
         if (!Number.isSafeInteger(limit) || limit < 1 || limit > 500)

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

@@ -1,7 +1,8 @@
 import { join } from "node:path";
 import { CliError } from "@wirecat/cli-base";
 import { annotate } from "@wirecat/cli-base/commands";
-import { Command, Option } from "commander";
+import { defineQuery } from "@wirecat/cli-base/query";
+import { Command } from "commander";
 import { isTextModelInstalled, textModelsDirectory } from "../../embeddings/embed.js";
 import { embeddingKeys } from "../../embeddings/keys.js";
 import { DEFAULT_TEXT_MODEL, TEXT_MODELS } from "../../embeddings/models.js";
@@ -15,10 +16,19 @@ import { readSecret } from "../../terminal/prompt.js";
 import { baseContext, environmentOf } from "../context.js";
 import { FETCH, grantsAuthority, LOCAL_READ, LOCAL_WRITE, reachesOtherService } from "../effects.js";
 import { itemOf, listOf, renderAnswer } from "../envelope.js";
-import { listQuery, typedQuery, unfilteredQuery, withQuery } from "../list-query.js";
+import { listQuery, nativeTerms, termField, typedQuery, unfilteredQuery, withQuery } from "../list-query.js";
 import { nextStep } from "../steps.js";
 /** A model list is the catalog this version ships. */
 const MODELS_QUERY = unfilteredQuery("model", modelEntity);
+const ROOT_MODELS_QUERY = defineQuery({
+    entity: "model",
+    backend: "native",
+    fields: [
+        termField("kind", "enum", "kind:audio", { values: ["audio", "text"] }),
+        termField("id", "kw", "id:e5-small"),
+        termField("downloaded", "bool", "downloaded:true"),
+    ],
+});
 /** Every model this version knows: a short, fixed list, never paged. */
 const everyModel = (command, items, next = []) => listOf(command, { items, limit: Math.max(1, items.length), has_more: false, next });
 const audioItem = (model, directory, chosen) => ({
@@ -56,97 +66,47 @@ const imageItem = (model, directory) => ({
 const downloaded = (body) => "item" in body ? `${body.item.id}: downloaded and works, in ${body.item.path}\n` : "";
 const modelLine = (item, width) => `${item.default ? "*" : " "} ${item.id.padEnd(width)} ${megabytes(item.size_bytes).padStart(7)}  ` +
     (item.downloaded ? "downloaded" : "—".padEnd(10));
-export const modelsCommand = (messenger) => {
-    const tool = `${messenger.app.command} personal`;
-    const models = new Command("models").description("models that run on this machine");
-    const audio = models.command("audio").description("speech models for transcribing voice messages");
-    withQuery(annotate(audio.command("list"), { effects: LOCAL_READ, examples: [`${tool} models audio list`] }), MODELS_QUERY)
-        .summary("speech models and their download status")
-        .description("the speech models, most suitable first, which are downloaded, and which one is the default")
-        .action(async function (words) {
-        const context = baseContext(this, messenger.resolveSettings);
-        await context.run(async () => {
-            listQuery(typedQuery(words), MODELS_QUERY, "models audio list");
-            const directory = modelsDirectory(context.env);
-            const chosen = choose(messenger, context.settings, {}, context.env).model.id;
-            const items = orderedModels(messenger.speechModels).map((model) => audioItem(model, directory, chosen));
-            renderAnswer(this, context, everyModel("models audio list", items), () => items.map((item) => `${modelLine(item, 14)}  ${item.languages}\n`).join(""));
-            if (context.format === "pretty")
-                context.renderer.note(`kept in ${directory}`);
-        });
-    });
-    reachesOtherService(annotate(audio.command("download"), {
-        effects: FETCH,
-        output: { entity: "model" },
-        examples: [`${tool} models audio download parakeet-v3`],
-    }))
-        .argument("<model>", "a model id from `models audio list`")
-        .description("download a speech model once, checked against the sha256 this version expects")
-        .action(async function (id) {
-        const context = baseContext(this, messenger.resolveSettings);
-        await context.run(async () => {
-            const model = speechModel(id);
-            const directory = modelsDirectory(context.env);
-            if (!isInstalled(model, directory)) {
-                context.renderer.note(`${model.id}: ${megabytes(installedBytes(model) + VAD.bytes)} from Hugging Face and GitHub`);
-                await install(model, directory, { progress: (line) => context.renderer.note(line) });
-            }
-            // Loading is the test — the files, the WebAssembly engine and the memory it needs — on a
-            // second of silence, since no recording ships with the package.
-            context.renderer.note(`${model.id}: loading it once to check it works`);
-            const { openRecognizer, SAMPLE_RATE } = await import("../../speech/recognize.js");
-            const recognizer = openRecognizer(model, modelPath(directory, model), vadPath(directory));
-            try {
-                recognizer.recognize(new Float32Array(SAMPLE_RATE));
-            }
-            finally {
-                recognizer.free();
-            }
-            const chosen = choose(messenger, context.settings, {}, context.env).model.id;
-            renderAnswer(this, context, itemOf(audioItem(model, directory, chosen)), downloaded);
-        }, { unbounded: true });
-    });
-    const text = models.command("text").description("embedding models for searching conversations by meaning");
-    withQuery(annotate(text.command("list"), { effects: LOCAL_READ, examples: [`${tool} models text list`] }), MODELS_QUERY)
-        .summary("embedding models and their download status")
-        .description("the embedding models, most suitable first, which are downloaded, and which one is the default")
-        .action(async function (words) {
-        const context = baseContext(this, messenger.resolveSettings);
-        await context.run(async () => {
-            listQuery(typedQuery(words), MODELS_QUERY, "models text list");
-            const directory = textModelsDirectory(context.env);
-            const items = TEXT_MODELS.map((model) => textItem(model, directory));
-            const missing = items.find((item) => item.default && !item.downloaded);
-            renderAnswer(this, context, everyModel("models text list", items, missing ? [nextStep("models.download", { args: { model: missing.id } })] : []), () => items.map((item) => `${modelLine(item, 16)}  ${item.licence}\n`).join(""));
-            if (context.format === "pretty")
-                context.renderer.note(`kept in ${directory}`);
+const downloadAudioModel = async (command, messenger, id) => {
+    const context = baseContext(command, messenger.resolveSettings);
+    await context.run(async () => {
+        const model = speechModel(id);
+        const directory = modelsDirectory(context.env);
+        if (!isInstalled(model, directory)) {
+            context.renderer.note(`${model.id}: ${megabytes(installedBytes(model) + VAD.bytes)} from Hugging Face and GitHub`);
+            await install(model, directory, { progress: (line) => context.renderer.note(line) });
+        }
+        // Loading is the test — the files, the WebAssembly engine and the memory it needs — on a
+        // second of silence, since no recording ships with the package.
+        context.renderer.note(`${model.id}: loading it once to check it works`);
+        const { openRecognizer, SAMPLE_RATE } = await import("../../speech/recognize.js");
+        const recognizer = openRecognizer(model, modelPath(directory, model), vadPath(directory));
+        try {
+            recognizer.recognize(new Float32Array(SAMPLE_RATE));
+        }
+        finally {
+            recognizer.free();
+        }
+        const chosen = choose(messenger, context.settings, {}, context.env).model.id;
+        renderAnswer(command, context, itemOf(audioItem(model, directory, chosen)), downloaded);
+    }, { unbounded: true });
+};
+const downloadEmbeddingModel = async (command, messenger, id, options) => {
+    const context = baseContext(command, messenger.resolveSettings);
+    await context.run(async () => {
+        const { model, directory } = await downloadTextModel(id, {
+            env: context.env,
+            acceptTerms: options.acceptTerms === true,
+            progress: (line) => context.renderer.note(line),
         });
-    });
-    reachesOtherService(annotate(text.command("download"), {
-        effects: FETCH,
-        output: { entity: "model" },
-        examples: [`${tool} models text download ${DEFAULT_TEXT_MODEL}`],
-    }))
-        .argument("<model>", "a model id from `models text list`")
-        .addOption(new Option("--accept-terms", "accept the model's licence terms, for a model that has its own"))
-        .summary("download and verify an embedding model")
-        .description("download an embedding model once, checked against the sha256 this version expects")
-        .action(async function (id, options) {
-        const context = baseContext(this, messenger.resolveSettings);
-        await context.run(async () => {
-            const { model, directory } = await downloadTextModel(id, {
-                env: context.env,
-                acceptTerms: options.acceptTerms === true,
-                progress: (line) => context.renderer.note(line),
-            });
-            renderAnswer(this, context, itemOf(textItem(model, directory)), downloaded);
-        }, { unbounded: true });
-    });
-    const key = text.command("key").description("API keys for embedding and analysis providers");
+        renderAnswer(command, context, itemOf(textItem(model, directory)), downloaded);
+    }, { unbounded: true });
+};
+const modelKeysCommand = (messenger, tool) => {
+    const key = new Command("keys").description("API keys for embedding and analysis providers");
     grantsAuthority(annotate(key.command("set"), {
         effects: LOCAL_WRITE,
         output: { entity: "model_key", view: "stored" },
-        examples: [`${tool} models text key set openai`],
+        examples: [`${tool} models keys set openai`],
     }))
         .argument("<provider>", "openai, anthropic, or the host of a --base-url server that wants a key")
         .description("store a key, typed at a hidden prompt or piped on stdin — never as an argument")
@@ -164,7 +124,7 @@ export const modelsCommand = (messenger) => {
     grantsAuthority(annotate(key.command("remove"), {
         effects: LOCAL_WRITE,
         output: { entity: "model_key", view: "removed" },
-        examples: [`${tool} models text key remove openai`],
+        examples: [`${tool} models keys remove openai`],
     }))
         .argument("<provider>", "openai, anthropic, or a server's host")
         .description("forget a stored key")
@@ -174,6 +134,57 @@ export const modelsCommand = (messenger) => {
             renderAnswer(this, context, itemOf({ provider, removed: embeddingKeys(messenger.app, context.env, context.keyring).remove(provider) }));
         });
     });
+    return key;
+};
+export const modelsCommand = (messenger) => {
+    const tool = `${messenger.app.command} personal`;
+    const models = new Command("models").description("models that run on this machine");
+    models.addCommand(modelKeysCommand(messenger, tool));
+    withQuery(annotate(models.command("list"), {
+        effects: LOCAL_READ,
+        examples: [`${tool} models list`, `${tool} models list kind:audio`],
+    }), ROOT_MODELS_QUERY)
+        .description("speech and embedding models, their download status and the default of each kind")
+        .action(async function (words) {
+        const terms = nativeTerms(listQuery(typedQuery(words), ROOT_MODELS_QUERY, "models list"), "models list");
+        const context = baseContext(this, messenger.resolveSettings);
+        await context.run(async () => {
+            const kinds = terms.get("kind")?.value;
+            const id = terms.get("id")?.value;
+            const kept = terms.get("downloaded")?.value;
+            const audioModels = kinds === undefined || kinds === "audio"
+                ? orderedModels(messenger.speechModels).filter((model) => id === undefined || model.id === id)
+                : [];
+            const textModels = kinds === undefined || kinds === "text"
+                ? TEXT_MODELS.filter((model) => id === undefined || model.id === id)
+                : [];
+            const chosen = audioModels.length > 0 ? choose(messenger, context.settings, {}, context.env).model.id : "";
+            const catalogue = [
+                ...audioModels.map((model) => audioItem(model, modelsDirectory(context.env), chosen)),
+                ...textModels.map((model) => textItem(model, textModelsDirectory(context.env))),
+            ];
+            const items = catalogue.filter((item) => kept === undefined || item.downloaded === (kept === "true"));
+            const next = items
+                .filter((item) => item.default && !item.downloaded)
+                .map((item) => nextStep("models.download", { args: { model: item.id } }));
+            renderAnswer(this, context, everyModel("models list", items, next), () => items.map((item) => `${item.kind.padEnd(5)} ${modelLine(item, 18)}  ${item.languages}\n`).join(""));
+        });
+    });
+    reachesOtherService(annotate(models.command("download"), {
+        effects: FETCH,
+        output: { entity: "model" },
+        examples: [`${tool} models download parakeet-v3`, `${tool} models download ${DEFAULT_TEXT_MODEL}`],
+    }))
+        .description("download and verify one speech or embedding model")
+        .argument("<model>", "a model id from models list")
+        .option("--accept-terms", "accept the model's licence terms, for a model that has its own")
+        .action(async function (id, options) {
+        if (orderedModels().some((model) => model.id === id))
+            return downloadAudioModel(this, messenger, id);
+        if (TEXT_MODELS.some((model) => model.id === id))
+            return downloadEmbeddingModel(this, messenger, id, options);
+        throw new CliError("validation_error", "unknown model; choose an id from models list");
+    });
     return models;
 };
 /** `images models`: registered with picture search, the only thing these models serve. */

package/dist/cli/messenger/private-people-command.js

@@ -13,22 +13,22 @@ import { readAll } from "./stdin.js";
 const NOTES_QUERY = unfilteredQuery("contact_note", contactNote);
 const everyNote = (command, items) => listOf(command, { items, limit: Math.max(1, items.length), has_more: false });
 export const privatePeopleCommands = (messenger) => {
-    const alias = new Command("alias").description("a private local display name in the selected account");
+    const alias = new Command("aliases").description("a private local display name in the selected account");
     annotate(alias.command("set"), { effects: LOCAL_WRITE, output: { entity: "contact_alias" } })
         .description("your own name for a person in this account; kept on this machine, never sent")
         .argument("<person>", "the person's id, reference or known name")
         .argument("<alias>", "the private name to use for this person")
         .action(async function (person, value) {
         const context = messengerContext(this, messenger);
-        refuseLocalWrite(context, messenger.app.command, "contacts.alias.set");
+        refuseLocalWrite(context, messenger.app.command, "contacts.aliases.set");
         renderAnswer(this, context, itemOf(snakeKeys(await context.withServices((services) => services.privatePeople.alias(person, value)))));
     });
-    annotate(alias.command("rm"), { effects: LOCAL_WRITE, output: { entity: "contact_alias" } })
+    annotate(alias.command("remove"), { effects: LOCAL_WRITE, output: { entity: "contact_alias" } })
         .description("drop your local name for a person; their own name shows again")
         .argument("<person>", "the person's id, reference or known name")
         .action(async function (person) {
         const context = messengerContext(this, messenger);
-        refuseLocalWrite(context, messenger.app.command, "contacts.alias.rm");
+        refuseLocalWrite(context, messenger.app.command, "contacts.aliases.remove");
         renderAnswer(this, context, itemOf(snakeKeys(await context.withServices((services) => services.privatePeople.alias(person, null)))));
     });
     const notes = new Command("notes").description("your private notes on a stored contact, the same in every account that sees them");
@@ -57,8 +57,7 @@ export const privatePeopleCommands = (messenger) => {
             ? "add a private note on a person from stdin or --text-file; never sent"
             : "replace a note's text; --revision must match the one you read")
             .argument("<person>", "the person's id, reference or known name")
-            .addOption(ownerOnlyOption("--text-file <path>", "read note text from a file; omitted or - reads stdin").conflicts("file"))
-            .addOption(ownerOnlyOption("--file <path>", "compatibility alias for --text-file").hideHelp().conflicts("textFile"));
+            .addOption(ownerOnlyOption("--text-file <path>", "read note text from a file; omitted or - reads stdin"));
         if (name === "edit")
             command
                 .argument("<id>", "the note id from contacts notes list")

package/dist/cli/messenger/replies-edit-command.js

@@ -65,7 +65,6 @@ export const addReplyEditors = (replies, messenger) => {
             option.conflicts("model");
         edit.addOption(option);
     }
-    edit.addOption(new Option("--model <mode>", "compatibility alias for --template-mode").hideHelp().conflicts("templateMode"));
     // Commander gives negated-only flags a true default; omission must preserve the saved field.
     edit.action(function (id) {
         const options = this.opts();

package/dist/cli/messenger/review.js

@@ -1,9 +1,8 @@
 import { CliError } from "@wirecat/cli-base";
 import { annotate } from "@wirecat/cli-base/commands";
-import { Command, Option } from "commander";
+import { Command } from "commander";
 import { parseDuration } from "../../domain/duration.js";
 import { renderMessages } from "../../render/messages.js";
-import { CHAT_KINDS } from "../../services/chats.js";
 import { kindsOf, REVIEW_DAYS, reviewStart, UNANSWERED_HOURS } from "../../services/inbox.js";
 import { modelWith } from "../../speech/hearing.js";
 import { REMOTE_READ } from "../effects.js";
@@ -34,7 +33,6 @@ export const reviewCommand = (messenger) => annotate(new Command("review"), {
     .description("every message, yours too, in chats that changed since a point — for reviewing who owes what")
     .addHelpText("after", queryHelp(REVIEW_QUERY))
     .argument("[query...]", `where the last review ended and which chat: date>2h, chat:"Book club"; ${REVIEW_DAYS} days ago if no date`)
-    .addOption(new Option("--kind <kinds>", `compatibility spelling for kind:; ${CHAT_KINDS.join(", ")}`).hideHelp())
     .option("--unanswered [duration]", `only questions to you or a group's admins that nobody answered, asked at least this long ago — 4h, 1d; ${UNANSWERED_HOURS}h if not given`)
     .option("--all", "muted and archived chats too — left out unless they mention you or reply to you")
     .option(...TRANSCRIBE_OPTION)

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

@@ -81,6 +81,7 @@ export declare const serveRelay: (command: Command, messenger: Messenger) => {
         joinRequestsAll?: boolean;
         joinRequestsByLink?: boolean;
         channelComments?: boolean;
+        readsComments?: boolean;
         addsWithHistory?: boolean;
         adminRights?: readonly import("../../domain/models.js").AdminRight[];
         pickAdminRights?: boolean;

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

@@ -93,7 +93,7 @@ export const statsCommand = (messenger, loadRenderer = chartRenderer) => {
         "contacts evidence": '101 --selection "$selection" --component messages',
         "contacts responses": 'chat:"Project room"',
         "contacts top": 'chat:"Book club" --limit 10',
-        "messages counters refresh": '--chat "Book club" --dry-run',
+        "messages counters sync": '--chat "Book club" --dry-run',
         "messages counters show": '--chat "Book club" --limit 10',
         "messages discussion": 'chat:"Book club"',
         "messages evidence": '"$message" --selection "$selection" --component reactions',

package/dist/cli/messenger/store-maintenance-command.d.ts

@@ -22,7 +22,7 @@ export declare const storeSummary: (env: NodeJS.ProcessEnv) => Promise<{
 export declare const storeMaintenanceCommands: (messenger: Messenger) => Command[];
 /**
  * Stems what is left, after rebuilding stems made by other stemmer choices than the store's setting —
- * only here and in `store reindex`, never in a search's quick fill.
+ * only here and in `store rebuild`, never in a search's quick fill.
  */
 export declare const buildStems: (database: CacheDatabase, note: (text: string) => void, { force }?: {
     force?: boolean | undefined;

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

@@ -237,7 +237,7 @@ const checkCommand = (messenger) => annotate(new Command("check"), { output: { e
         renderer.note(`${orphans} pointers name a row that is gone or a type the store does not know — see orphan_pointers`);
     const older = answer.conversations.filter((chat) => chat.provider === messenger.provider && !chat.current).length;
     if (older > 0) {
-        renderer.note(`${older} chats' conversations were built by older rules — \`${command} conversations build --chat <chat>\``);
+        renderer.note(`${older} chats' conversations were built by older rules — \`${command} conversations links rebuild --chat <chat>\``);
     }
 });
 const inspect = (path) => reading(path, (database) => {
@@ -407,7 +407,7 @@ const buildWordIndex = (database, note) => {
 };
 /**
  * Stems what is left, after rebuilding stems made by other stemmer choices than the store's setting —
- * only here and in `store reindex`, never in a search's quick fill.
+ * only here and in `store rebuild`, never in a search's quick fill.
  */
 export const buildStems = (database, note, { force = false } = {}) => {
     const before = stemsState(database);
@@ -422,7 +422,7 @@ export const buildStems = (database, note, { force = false } = {}) => {
     const { stemmed, drained } = fillStems(database, { onBatch: (step, done) => note(`${done} ${step}`) });
     return { stemmed: stemmed + drained };
 };
-/** Indexes the notes written since — all of them after `store reindex` queued them again. */
+/** Indexes the notes written since — all of them after `store rebuild` queued them again. */
 const buildNoteIndex = (database, note, { reset = false } = {}) => {
     if (reset)
         resetNoteIndex(database);
@@ -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"), { output: { entity: "store_reindex" }, effects: LOCAL_WRITE }))
+const reindexCommand = (messenger) => destroysNothing(annotate(new Command("rebuild"), { 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 () {

package/dist/cli/messenger/stored.js

@@ -534,6 +534,11 @@ const fill = async (store, account, batch) => {
         of(chatId).stars.push({ messageId, starred });
     for (const [chatId, { messages, votes, reactions, stars }] of byChat)
         await store.messages.saveMessages(account, chatId, messages, { via: "history", votes, reactions, stars });
+    const deletions = new Map();
+    for (const { chatId, messageId } of batch.deletions ?? [])
+        deletions.set(chatId, [...(deletions.get(chatId) ?? []), messageId]);
+    for (const [chatId, ids] of deletions)
+        await store.messages.markDeleted(account, ids, { chatId });
     const changes = new Map();
     for (const { chatId, change } of batch.events ?? [])
         changes.set(chatId, [...(changes.get(chatId) ?? []), change]);

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

@@ -32,10 +32,10 @@ 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"), {
+    changesStore(annotate(tags.command("rebuild"), {
         output: { entity: "automatic_tags" },
         effects: FETCH,
-        examples: [`${tool} tags auto --chat "Book club" --dry-run`],
+        examples: [`${tool} tags rebuild --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], [])
@@ -46,7 +46,7 @@ export const tagsCommand = (messenger) => {
         const context = messengerContext(this, messenger);
         const { chat, limit, syncFirst, dryRun } = this.opts();
         if (!dryRun)
-            refuseLocalWrite(context, messenger.app.command, "tags.auto");
+            refuseLocalWrite(context, messenger.app.command, "tags.rebuild");
         const done = await context.withServices((services) => services.metadata.auto({ chats: chat, limit: Number(limit), refresh: syncFirst, dryRun }));
         renderAnswer(this, context, itemOf(snakeKeys(done)));
     });
@@ -68,13 +68,7 @@ export const tagsCommand = (messenger) => {
         effects: LOCAL_WRITE,
         examples: [`${tool} tags remove reading --chat "Book club"`],
     }).description("take tags off one chat, person, message or task"), messenger, "untag")
-        .addOption(new Option("--claim <claim>", "remove only this ownership claim: manual or auto")
-        .argParser(sourceOf)
-        .conflicts("source"))
-        .addOption(new Option("--source <manual|auto>", "compatibility alias for --claim")
-        .argParser(sourceOf)
-        .hideHelp()
-        .conflicts("claim"))
+        .addOption(new Option("--claim <claim>", "remove only this ownership claim: manual or auto").argParser(sourceOf))
         .action(async function (given) {
         const context = messengerContext(this, messenger);
         refuseLocalWrite(context, messenger.app.command, "tags.remove");

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

@@ -185,17 +185,17 @@ export const tasksCommand = (messenger) => {
         else if (followUpOf && context.format === "pretty")
             context.renderer.note(`${task.key ?? task.id} follows up ${followUpOf.key} (${followUpOf.status}), which stays closed: linked follow-up-of`);
     });
-    planOptions(destroysNothing(annotate(tasks.command("plan"), {
+    planOptions(destroysNothing(annotate(tasks.command("update"), {
         output: { entity: "task_card" },
         effects: LOCAL_WRITE,
-        examples: [`${tool} personal tasks plan DOC-12 --title "Review draft"`],
+        examples: [`${tool} personal tasks update DOC-12 --title "Review draft"`],
     }))
         .summary("set a task's title, description, due date, next check, category and assignee")
         .description("set a task's title, description, due date, next check, category and assignee; nothing reaches the messenger")
         .argument("<task>", "the task's id or key, as tasks list shows it")
         .option("--category <name>", `${categoryHelp}; a change is kept in the task's history`), "send Alex the API token").action(async function (id) {
         const context = messengerContext(this, messenger);
-        refuseLocalWrite(context, messenger.app.command, "tasks.plan");
+        refuseLocalWrite(context, messenger.app.command, "tasks.update");
         const plan = planFrom(this.opts());
         if (Object.keys(plan).length === 0)
             throw new CliError("validation_error", "give at least one of --title, --description, --due, --remind-time, --category");