@wirecat/cli-core 0.405.0 → 0.406.0

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

@@ -3,9 +3,9 @@ import type { CacheDatabase } from "../../store/driver.js";
 import type { Messenger } from "./context.js";
 /** `doctor`'s short summary of the store. Must answer for a broken file, so an error is a field. */
 export declare const storeSummary: (env: NodeJS.ProcessEnv) => Promise<{
+    error?: undefined;
     path: string;
     exists: boolean;
-    error?: undefined;
 } | {
     path: string;
     exists: boolean;
@@ -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");

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

@@ -18,7 +18,7 @@ export const transcribeSubcommand = (messages, messenger) => annotate(messages.c
     .argument("<chat>", messenger.chatArgument)
     .argument("<message>", "the id of a voice message")
     .option("--local", "use the model on this machine, never the messenger")
-    .option("--model <model>", "which downloaded model; implies --local (`models audio list`)")
+    .option("--model <model>", "which downloaded model; implies --local (`models list`)")
     .action(async function (chat, messageId) {
     const context = messengerContext(this, messenger);
     const choice = {

package/dist/cli/moved.d.ts

@@ -7,6 +7,8 @@ export declare const MOVED_TO_MEMO: Readonly<Record<string, {
     what: string;
     memo: string;
 }>>;
+/** Retired spellings are guidance only; none is mounted as a command alias. */
+export declare const RENAMED_COMMANDS: Readonly<Record<string, string>>;
 export declare const movedPointer: (path: string) => string | undefined;
 /** The longest moved path the words start with, unless the program still has it. */
 export declare const movedPath: (words: readonly string[], has: (path: string) => boolean) => string | undefined;

package/dist/cli/moved.js

@@ -6,12 +6,50 @@
 export const MOVED_TO_MEMO = {
     "search mail": { what: "mail is searched by the separate memo CLI", memo: "memo search mail …" },
 };
+/** Retired spellings are guidance only; none is mounted as a command alias. */
+export const RENAMED_COMMANDS = {
+    "contacts alias rm": "contacts aliases remove",
+    "contacts alias": "contacts aliases",
+    "contacts profile": "contacts info",
+    "contacts timeline": "contacts events",
+    "chats link revoke": "chats links remove",
+    "chats link": "chats links",
+    "chats members audit": "chats members check",
+    "chats requests accept": "chats requests confirm",
+    "chats requests decline": "chats requests reject",
+    "metadata get": "metadata show",
+    "metadata refresh": "metadata sync",
+    "tasks plan": "tasks update",
+    "tags auto": "tags rebuild",
+    "attachments text set": "attachments update",
+    "conversations build": "conversations links rebuild",
+    "conversations embed status": "conversations embeddings status",
+    "conversations embed clear": "conversations embeddings clear",
+    "conversations batches next": "conversations batches show",
+    "conversations consents revoke": "conversations consents remove",
+    "doctor report create": "doctor reports create",
+    "doctor report": "doctor reports show",
+    "mcp setup": "mcp add",
+    "mcp doctor": "mcp check",
+    "commands schema": "commands info",
+    "store gaps plan": "store gaps show",
+    "store reindex": "store rebuild",
+    "stats messages counters refresh": "stats messages counters sync",
+    "models text key": "models keys",
+    "models audio list": "models list kind:audio",
+    "models text list": "models list kind:text",
+    "models audio download": "models download",
+    "models text download": "models download",
+};
 export const movedPointer = (path) => {
+    const renamed = RENAMED_COMMANDS[path];
+    if (renamed)
+        return `use \`${renamed}\``;
     const moved = MOVED_TO_MEMO[path];
     return moved && `${moved.what}: install @wirecat/cli-memo, then \`${moved.memo}\``;
 };
 /** The longest moved path the words start with, unless the program still has it. */
-export const movedPath = (words, has) => Object.keys(MOVED_TO_MEMO)
+export const movedPath = (words, has) => [...Object.keys(MOVED_TO_MEMO), ...Object.keys(RENAMED_COMMANDS)]
     .filter((path) => path.split(" ").every((word, at) => words[at] === word))
     .sort((a, b) => b.length - a.length)
     .find((path) => !has(path));

package/dist/cli/permission-keys.js

@@ -1,3 +1,4 @@
+import { canonicalPermissionKey } from "../sends/permission-aliases.js";
 import { CEILING_KEY, keyForCommand, WRITE_KEYS } from "../sends/permissions.js";
 const pathOf = (command) => {
     const words = [];
@@ -19,6 +20,7 @@ const everyCommand = (command) => [command, ...command.commands.flatMap(everyCom
 export const knownPermissionKeys = (command, keyOf = (one) => keyForCommand(pathOf(one)), extra = []) => {
     const known = new Set();
     const add = (key) => {
+        key = canonicalPermissionKey(key);
         for (let parts = key.split("."); parts.length > 0; parts = parts.slice(0, -1))
             known.add(parts.join("."));
     };

package/dist/cli/settings.js

@@ -60,7 +60,7 @@ const SHARED_PROFILE_ENTRIES = {
     sends_per_hour: v.optional(count),
     requests_per_minute: v.optional(countOrZero),
     transcribe_with: v.optional(v.picklist(["auto", "messenger", "local"], plain("has to be auto, messenger or local"))),
-    speech_model: v.optional(v.string(plain("has to be a model id from `models audio list`, in quotes"))),
+    speech_model: v.optional(v.string(plain("has to be a model id from `models list`, in quotes"))),
     search_catch_up: v.optional(flag),
     picture_search: v.optional(flag),
     ...AI_ENTRIES,

package/dist/cli/steps.js

@@ -83,7 +83,7 @@ export const STEPS = defineSteps([
     },
     {
         id: "models.download",
-        command: "models text download",
+        command: "models download",
         args: [{ name: "model", required: true }],
         why: "{model} is not downloaded, so nothing is searched by meaning",
     },
@@ -116,7 +116,7 @@ export const STEPS = defineSteps([
     },
     {
         id: "store.reindex",
-        command: "store reindex",
+        command: "store rebuild",
         args: [],
         why: "the stems were built by another stemmer; this builds them again",
     },
@@ -134,7 +134,7 @@ export const STEPS = defineSteps([
     },
     {
         id: "conversations.build",
-        command: "conversations build",
+        command: "conversations links rebuild",
         args: [{ name: "chat", required: false }],
         why: "conversations are missing or older than the messages; this builds them",
     },
@@ -175,7 +175,7 @@ export const STEPS = defineSteps([
     },
     {
         id: "doctor.report-create",
-        command: "doctor report create",
+        command: "doctor reports create",
         args: [{ name: "run", required: false }],
         why: "writes the report to a file to read and send; it holds no message text",
     },

package/dist/cli/store-settings.js

@@ -132,7 +132,7 @@ const changeCategory = async (app, env, setting, value) => {
         return {
             result: { store: storePath(env), file, scope: "shared", setting, value: set ? taskCategoryValue(set) : null },
             note: [
-                `saved in ${file} — rules, tasks add and tasks plan in tg, MAX and memo take categories from it; ` +
+                `saved in ${file} — rules, tasks add and tasks update in tg, MAX and memo take categories from it; ` +
                     "tasks keep the category they have",
                 ...unlisted,
             ].join("\n"),

package/dist/cli/upgrade-command.js

@@ -32,7 +32,6 @@ export const restartServers = (app, script, env, spawn) => {
 };
 export const upgradeCommand = (app, packageName, contextFor) => grantsAuthority(annotate(new Command("upgrade"), {
     effects: LOCAL_WRITE,
-    mcp: false,
     offline: false,
     examples: [`${app.command} upgrade --check`, `${app.command} upgrade`],
 }), { unless: "check" })