@wirecat/cli-core 0.398.0 → 0.399.0

package/dist/cli/embedding-choice.js

@@ -6,7 +6,10 @@ import { isLocal, remoteModel } from "../embeddings/remote.js";
 import { readOnlyLockOf, readOnlyRefusal } from "../ports/app.js";
 import { typedCommand } from "../runs/scope.js";
 /** A local model id, or a remote model with its key from `models text key set`. */
-export const embeddingChoice = ({ model, provider, baseUrl, dims, concurrency }, app, settings, env, { needKey = true, keyring } = {}) => {
+export const embeddingChoice = ({ model, provider, embeddingProvider, baseUrl, dims, concurrency }, app, settings, env, { needKey = true, keyring } = {}) => {
+    if (embeddingProvider !== undefined && provider !== undefined)
+        throw new CliError("validation_error", "give --embedding-provider or its legacy --provider spelling, not both");
+    provider = embeddingProvider ?? provider;
     const flagsChooseProvider = (provider !== undefined && provider !== (settings.embeddingProvider ?? "local")) ||
         (baseUrl !== undefined && baseUrl.replace(/\/+$/, "") !== settings.embeddingBaseUrl?.replace(/\/+$/, ""));
     provider ??= flagsChooseProvider ? "openai" : (settings.embeddingProvider ?? "local");

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

@@ -1,6 +1,6 @@
 import { CliError } from "@wirecat/cli-base";
 import { annotate } from "@wirecat/cli-base/commands";
-import { Command } from "commander";
+import { Command, Option } from "commander";
 import { parseDuration } from "../../domain/duration.js";
 import { ADMIN_RIGHTS, GROUP_SETTINGS, } from "../../domain/models.js";
 import { readUpload, typesText } from "../../sends/upload.js";
@@ -22,19 +22,19 @@ const SETTING_FLAGS = {
     onlyAdminsSend: ["only-admins-send <on|off>", "only admins may send messages"],
     onlyAdminsEditInfo: ["only-admins-edit-info <on|off>", "only admins may change the name, photo and description"],
     disappearingSeconds: [
-        "disappear-time <duration|off>",
+        "disappear-after <duration|off>",
         "new messages disappear this long after sending: 24h, 7d, 90d; off keeps them",
     ],
 };
 const flagOf = (key) => `--${SETTING_FLAGS[key][0].split(" ")[0]}`;
-/** Where commander puts the flag's value: `--disappear-time` is `disappearTime`, not the setting's own name. */
+/** Where commander puts the flag's value: `--disappear-after` is `disappearAfter`, not the setting's own name. */
 const optionKey = (key) => flagOf(key)
     .slice(2)
     .replace(/-(\w)/g, (_, letter) => letter.toUpperCase());
 const settingsOf = (keys, options) => {
     const changes = {};
     for (const key of keys) {
-        const value = options[optionKey(key)];
+        const value = options[optionKey(key)] ?? (key === "disappearingSeconds" ? options.disappearTime : undefined);
         if (value === undefined)
             continue;
         if (key === "disappearingSeconds") {
@@ -67,8 +67,16 @@ const updateCommand = (messenger) => {
         update.option("--photo <file>", `a new photo for it — ${photoHelp(messenger)}`);
     if (messenger.groupPhotoRemoval === true)
         update.option("--remove-photo", "take its photo away; not with --photo");
-    for (const key of keys)
-        update.option(`--${SETTING_FLAGS[key][0]}`, SETTING_FLAGS[key][1]);
+    for (const key of keys) {
+        const option = new Option(`--${SETTING_FLAGS[key][0]}`, SETTING_FLAGS[key][1]);
+        if (key === "disappearingSeconds")
+            option.conflicts("disappearTime");
+        update.addOption(option);
+    }
+    if (keys.includes("disappearingSeconds"))
+        update.addOption(new Option("--disappear-time <duration|off>", "compatibility alias for --disappear-after")
+            .hideHelp()
+            .conflicts("disappearAfter"));
     return update.action(async function (chat) {
         const context = messengerContext(this, messenger);
         const { title, description, photo, removePhoto, ...rest } = this.opts();
@@ -210,6 +218,7 @@ const requestsCommand = (messenger) => {
         renderAnswer(this, context, body, lines(({ person_id, name, username, requested_at }) => [person_id, name ?? "", username ? `@${username}` : "", requested_at ?? ""].join("  ")));
     }));
     const everyone = messenger.joinRequestsAll !== false;
+    const byLink = everyone && messenger.joinRequestsByLink !== false;
     for (const [verb, accept, help] of [
         ["accept", true, "let them in; the group sees them join"],
         ["decline", false, "turn the request away"],
@@ -219,9 +228,9 @@ const requestsCommand = (messenger) => {
             .argument("<chat>", messenger.chatArgument)
             .argument(everyone ? "[person]" : "<person>", "who asked: an id from `chats requests list`");
         if (everyone)
-            answer
-                .option("--all", "every pending request, counted against the hourly limit first")
-                .option("--link <link>", "with --all: only the requests made by this invite link");
+            answer.option("--all", "every pending request, counted against the hourly limit first");
+        if (byLink)
+            answer.option("--link <link>", "with --all: only the requests made by this invite link");
         requests.addCommand(answer.action(async function (chat, person) {
             const context = messengerContext(this, messenger);
             const { all, link } = this.opts();

package/dist/cli/messenger/catch-up-answers.d.ts

@@ -1,5 +1,5 @@
 import type { Meta } from "@wirecat/cli-base/standards";
-import type { Inbox, Review } from "../../domain/models.js";
+import type { ChatKind, Inbox, Review } from "../../domain/models.js";
 import { type Hearing } from "../../speech/hearing.js";
 import type { AccountKey } from "../../store/store.js";
 import { type QueryWords } from "../list-query.js";
@@ -11,6 +11,7 @@ export declare const REVIEW_QUERY: import("@wirecat/cli-base/query").QueryRegist
 export declare const catchUpQuery: (words: QueryWords, registry: typeof INBOX_QUERY, command: string) => {
     since?: number;
     chat?: string;
+    kinds?: ChatKind[];
     meta?: Partial<Meta>;
 };
 export declare const inboxAnswer: (inbox: Inbox, hearing: Hearing | undefined, reader: AccountKey, transcribe: boolean, meta?: Partial<Meta>) => import("../envelope.js").ListBody<{

package/dist/cli/messenger/catch-up-answers.js

@@ -1,17 +1,19 @@
 import { defineQuery, queryError } from "@wirecat/cli-base/query";
+import { kindsOf } from "../../services/inbox.js";
 import { heard, hearingMissing } from "../../speech/hearing.js";
 import { listOf } from "../envelope.js";
 import { listQuery, nativeField, nativeTerms, timeBounds, typedQuery } from "../list-query.js";
 import { nextStep } from "../steps.js";
 import { messageItem } from "./message-items.js";
 const date = nativeField({ name: "date", type: "time", operators: ["range"], example: "date>2h" });
+const kind = nativeField({ name: "kind", type: "kw", operators: ["term", "phrase"], example: "kind:group,channel" });
 /** Where `inbox` starts reading: everything after a time. */
-export const INBOX_QUERY = defineQuery({ entity: "message", backend: "native", fields: [date] });
+export const INBOX_QUERY = defineQuery({ entity: "message", backend: "native", fields: [date, kind] });
 /** Where `review` starts, and the one chat it reads. */
 export const REVIEW_QUERY = defineQuery({
     entity: "message",
     backend: "native",
-    fields: [date, nativeField({ name: "chat", type: "kw", operators: ["term", "phrase"], example: "chat:7" })],
+    fields: [date, kind, nativeField({ name: "chat", type: "kw", operators: ["term", "phrase"], example: "chat:7" })],
 });
 /** The query's start and chat. A catch-up reads forward from one point, so an end is refused. */
 export const catchUpQuery = (words, registry, command) => {
@@ -23,9 +25,11 @@ export const catchUpQuery = (words, registry, command) => {
             command,
         });
     const chat = terms.get("chat")?.value;
+    const kinds = terms.get("kind")?.value;
     return {
         ...(since === undefined ? {} : { since }),
         ...(chat === undefined ? {} : { chat }),
+        ...(kinds === undefined ? {} : { kinds: kindsOf(kinds, "kind:") }),
         ...(meta === undefined ? {} : { meta }),
     };
 };

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

@@ -14,7 +14,7 @@ export const statsCommand = (messenger) => annotate(new Command("show"), { effec
     `joins and leaves — counted from the local store; ${messenger.history === "store" ? "joins and leaves too" : "joins and leaves are asked of the messenger"}`)
     .argument("<chat>", messenger.chatArgument)
     .option("--since-time <time>", `ISO 8601, or 2h / 1d ago; ${EVENTS_DAYS} days ago if not given`)
-    .option("--by <day|week>", "also one row per calendar day or week (weeks start on Monday)", periodOf)
+    .option("--by <group>", "also one row per calendar day or week (weeks start on Monday)", periodOf)
     .option("--timezone <zone>", "the IANA timezone for calendar days")
     .action(async function (chat) {
     const context = messengerContext(this, messenger);

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

@@ -297,8 +297,8 @@ export const contactsCommand = (messenger) => {
         link: '"Alex Example" zoom:101',
         list: "--limit 10",
         lookup: "",
-        "notes add": '"Alex Example" --file ./note.txt',
-        "notes edit": '"Alex Example" 1 --revision 1 --file ./note.txt',
+        "notes add": '"Alex Example" --text-file ./note.txt',
+        "notes edit": '"Alex Example" 1 --revision 1 --text-file ./note.txt',
         "notes list": '"Alex Example"',
         "notes remove": '"Alex Example" 1',
         "notes show": '"Alex Example" 1',

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

@@ -158,6 +158,8 @@ export interface Messenger extends ServiceMessenger {
     inviteLinkUpdate?: boolean;
     /** Whether every pending join request is answered at once — `chats requests accept --all`; yes when unset. */
     joinRequestsAll?: boolean;
+    /** Whether `--all` can take only the requests made by one invite link — `--link`; yes when unset. */
+    joinRequestsByLink?: boolean;
     /** Whether a channel post can be commented on — `messages send --comment-to`; yes when unset. */
     channelComments?: boolean;
     /** Whether people added can be shown the messages from before they came — `members add --history`; yes when unset. */

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

@@ -1,6 +1,6 @@
 import { CliError } from "@wirecat/cli-base";
 import { annotate } from "@wirecat/cli-base/commands";
-import { Command } from "commander";
+import { Command, Option } from "commander";
 import { analysisConsents } from "../../analysis/consents.js";
 import { openAnalysis, providerIdentity } from "../../analysis/provider.js";
 import { runAnalysis } from "../../analysis/runner.js";
@@ -39,7 +39,10 @@ export const conversationsCommand = (messenger) => {
         "chat that changed since its build and every group never built; never asks the messenger")
         .option("--chat <chat>", messenger.chatArgument)
         .option("--analyze", "link batches using the configured analysis provider; requires --chat and remembers consent for this chat/provider")
-        .option("--provider <provider>", "analysis: agent, openai or anthropic")
+        .addOption(new Option("--analysis-provider <provider>", "analysis: agent, openai or anthropic").conflicts("provider"))
+        .addOption(new Option("--provider <provider>", "compatibility alias for --analysis-provider")
+        .hideHelp()
+        .conflicts("analysisProvider"))
         .option("--model <model>", "analysis model; overrides analysis_model")
         .option("--base-url <url>", "analysis API endpoint; overrides analysis_base_url")
         .option("--size <n>", "analysis answer messages per batch, 10–200; default 50", positiveCount("--size"))
@@ -95,7 +98,8 @@ export const conversationsCommand = (messenger) => {
             renderAnswer(this, context, itemOf(snakeKeys(result)));
             return;
         }
-        if (options.provider !== undefined ||
+        if (options.analysisProvider !== undefined ||
+            options.provider !== undefined ||
             options.model !== undefined ||
             options.baseUrl !== undefined ||
             options.size !== undefined ||
@@ -247,18 +251,19 @@ export const conversationsCommand = (messenger) => {
         .summary("remove an agent's saved conversation-link answers")
         .description("drop your agent's answers for a chat, or only one model's; messages are never touched")
         .requiredOption("--chat <chat>", messenger.chatArgument)
-        .option("--model <model>", "only the answers this model gave")
+        .addOption(new Option("--answer-model <model>", "only the stored answers this model gave").conflicts("model"))
+        .addOption(new Option("--model <model>", "compatibility alias for --answer-model").hideHelp().conflicts("answerModel"))
         .action(async function () {
-        const { chat, model } = this.opts();
+        const { chat, model, answerModel } = this.opts();
         const context = messengerContext(this, messenger);
         refuseLocalWrite(context, messenger.app.command, LINKS_KEY);
-        const cleared = await context.withServices((services) => services.conversations.clearAnswers(chat, model));
+        const cleared = await context.withServices((services) => services.conversations.clearAnswers(chat, answerModel ?? model));
         renderAnswer(this, context, itemOf(cleared), () => `${cleared.cleared} answers dropped\n`);
     });
     const embed = withModelOptions(reachesOtherService(annotate(new Command("embed"), { effects: REMOTE_WRITE }))
         .summary("prepare conversation vectors for meaning search")
         .description("compute a vector for each chunk of a chat's conversations for search by meaning — on this machine, or " +
-        "with --provider through a service and your key; resumes where it stopped; without --chat, every " +
+        "with --embedding-provider through a service and your key; resumes where it stopped; without --chat, every " +
         "built chat with chunks left, on this machine only")
         .option("--chat <chat>", messenger.chatArgument))
         .option("--threads <n>", "local: threads in all (default: min(8, cores))", positiveCount("--threads"))
@@ -324,7 +329,10 @@ export const conversationsCommand = (messenger) => {
         const chat = chatOf(options);
         const context = messengerContext(this, messenger);
         refuseLocalWrite(context, messenger.app.command, EMBED_KEY);
-        const given = options.model !== undefined || options.provider !== undefined || options.baseUrl !== undefined;
+        const given = options.model !== undefined ||
+            options.embeddingProvider !== undefined ||
+            options.provider !== undefined ||
+            options.baseUrl !== undefined;
         const model = given ? choiceOf(options, messenger, context, { needKey: false }) : undefined;
         const cleared = await context.withServices((services) => services.embeddings.clear(chat, model));
         renderAnswer(this, context, itemOf(cleared), () => `${cleared.cleared} vectors dropped\n`);
@@ -365,16 +373,19 @@ export const conversationsCommand = (messenger) => {
     annotate(consents.command("revoke"), { effects: LOCAL_WRITE })
         .description("forget analysis permissions so the next analysis asks again")
         .option("--chat <chat>", "revoke only this chat's consents; defaults to every chat")
-        .option("--provider <identity>", "exact provider identity from consents list; defaults to every provider")
+        .addOption(new Option("--consent-provider <identity>", "exact provider identity from consents list; defaults to every provider").conflicts("provider"))
+        .addOption(new Option("--provider <identity>", "compatibility alias for --consent-provider")
+        .hideHelp()
+        .conflicts("consentProvider"))
         .action(async function () {
-        const { chat, provider } = this.opts();
+        const { chat, provider, consentProvider } = this.opts();
         const context = messengerContext(this, messenger);
         refuseLocalWrite(context, messenger.app.command, LINKS_KEY);
         await context.withStore(async (store, account) => {
             const chatId = chat === undefined
                 ? undefined
                 : (await servicesFor(storedDeps(messenger, store, account, context.guard)).conversations.batchStatus(chat, BATCH_SIZE.default)).chat;
-            await analysisConsents(store, account).revoke(chatId, provider);
+            await analysisConsents(store, account).revoke(chatId, consentProvider ?? provider);
         });
         renderAnswer(this, context, itemOf({ revoked: true }));
     });
@@ -393,7 +404,10 @@ const chatOf = ({ chat }) => {
 };
 const withModelOptions = (command) => command
     .option("--model <model>", "local: a model id from `models text list` (default: e5-small); remote: the provider's model")
-    .option("--provider <provider>", "embedding provider: local or openai; flags override profile settings")
+    .addOption(new Option("--embedding-provider <provider>", "embedding provider: local or openai; flags override profile settings").conflicts("provider"))
+    .addOption(new Option("--provider <provider>", "compatibility alias for --embedding-provider")
+    .hideHelp()
+    .conflicts("embeddingProvider"))
     .option("--base-url <url>", "a server with OpenAI's /v1/embeddings: Gemini, Jina, or Ollama and LM Studio on this machine")
     .option("--dims <n>", "remote: the vector size — needed with --base-url; shortens an OpenAI model's", positiveCount("--dims"));
 /** How much one run over many chats may do: the owner's machine, not a background job, pays for it. */
@@ -412,7 +426,7 @@ const bounds = ({ maxChats, maxChunks }) => ({
 /** Work nobody named chat by chat never sends chat text off the machine. */
 const localOnly = (model, what) => {
     if (typeof model !== "string") {
-        throw new CliError("validation_error", `${what} uses the model on this machine only — drop --provider and --base-url, or embed one chat with --chat`);
+        throw new CliError("validation_error", `${what} uses the model on this machine only — drop --embedding-provider and --base-url, or embed one chat with --chat`);
     }
 };
 const renderRefreshed = (command, context, refreshed) => {

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 <id>", "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 audio 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

@@ -5,7 +5,7 @@ export const TRANSCRIBE_OPTION = [
     "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 const MODEL_OPTION = [
-    "--model <id>",
+    "--model <model>",
     "which downloaded speech model hears them, with --transcribe; `models audio list` shows them",
 ];
 /**

package/dist/cli/messenger/inbox.js

@@ -1,6 +1,6 @@
 import { CliError } from "@wirecat/cli-base";
 import { annotate } from "@wirecat/cli-base/commands";
-import { Command } from "commander";
+import { Command, Option } from "commander";
 import { renderMessages } from "../../render/messages.js";
 import { CHAT_KINDS } from "../../services/chats.js";
 import { kindsOf } from "../../services/inbox.js";
@@ -41,7 +41,7 @@ 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")
-    .option("--kind <kinds>", `only chats of these kinds, comma-separated: ${CHAT_KINDS.join(", ")}`)
+    .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.")
@@ -51,8 +51,10 @@ export const inboxCommand = (messenger) => annotate(new Command("inbox"), {
     const context = messengerContext(this, messenger);
     const { app } = messenger;
     const { settings, renderer, format, env } = context;
-    const kinds = kind === undefined ? undefined : kindsOf(kind);
-    const { since, meta } = catchUpQuery(query, INBOX_QUERY, "inbox");
+    const { since, meta, kinds: queriedKinds } = catchUpQuery(query, INBOX_QUERY, "inbox");
+    if (kind !== undefined && queriedKinds !== undefined)
+        throw new CliError("validation_error", "give kind: or its legacy --kind spelling, not both");
+    const kinds = queriedKinds ?? (kind === undefined ? undefined : kindsOf(kind));
     if (fresh && since !== undefined)
         throw new CliError("validation_error", "--new keeps its own point — not with a date in the query");
     const saved = fresh && since === undefined

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

@@ -12,7 +12,7 @@ export const messagesStatsCommand = (messenger) => syncOptions(annotate(new Comm
     .summary("count stored messages by chat, sender, day or hour")
     .description(`how many stored messages match, by chat, sender, day or hour — the local store only${syncsFirst(messenger) ? "; optionally fetches new messages with --sync-first" : ""}`)
     .argument("[query...]", "a strict Lucene query, as for search messages; none counts every stored message; with --saved, more words AND-ed to it")
-    .option("--by <chat|sender|day|hour>", "what to count by (default: chat)", groupingOf)
+    .option("--by <group>", "count by chat, sender, day or hour (default: chat)", groupingOf)
     .option("--chat <chat>", `only this chat — the same as chat: in the query; ${messenger.chatArgument}`)
     .option("--source <accounts>", "every account of this messenger held in the store; personal, bots or all — the same as in: in the query")
     .option("--limit <n>", "how many rows", positiveCount("--limit"))

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

@@ -23,7 +23,7 @@ export const metadataCommand = (messenger) => {
         .description("fetch group and channel descriptions again and cache them")
         .option("--chat <chat>", "stored group/channel; repeat for several", (value, previous) => [...previous, value], [])
         .option("--only-missing", "only chats with no metadata yet; without --chat, every stored group/channel")
-        .option("--limit <number>", "process at most 1–500 chats", positiveCount("--limit"), 50)
+        .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");

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

@@ -54,10 +54,11 @@ export const privatePeopleCommands = (messenger) => {
             output: { entity: "contact_note" },
         }), { name: "text", description: "the note's text" })
             .description(name === "add"
-            ? "add a private note on a person from stdin or --file; never sent"
+            ? "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("--file <path>", "read note text from a file; omitted or - reads stdin"));
+            .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"));
         if (name === "edit")
             command
                 .argument("<id>", "the note id from contacts notes list")
@@ -65,7 +66,8 @@ export const privatePeopleCommands = (messenger) => {
         command.action(async function (person, id) {
             const context = messengerContext(this, messenger);
             refuseLocalWrite(context, messenger.app.command, `contacts.notes.${name}`);
-            const { file, revision } = this.opts();
+            const { textFile, file: legacyFile, revision, } = this.opts();
+            const file = textFile ?? legacyFile;
             const text = file === undefined || file === "-" ? await readAll(context.stdin) : await readFile(file, "utf8");
             const version = Number(revision);
             if (name === "edit" && (!Number.isSafeInteger(version) || version < 1))

package/dist/cli/messenger/replies-edit-command.d.ts

@@ -1,5 +1,5 @@
 import { Command } from "commander";
 import { type Messenger } from "./context.js";
-export declare const REPLY_EDIT_OPTIONS: readonly [readonly ["--do <actions>", "actions: reply, task, or both, comma-separated"], readonly ["--kinds <kinds>", "chat kinds: dialog, group; comma-separated, empty for any"], readonly ["--allow-chats <ids>", "only these chat ids, comma-separated; empty for any"], readonly ["--deny-chats <ids>", "leave these chat ids out, comma-separated; empty clears"], readonly ["--words <words>", "match any of these whole words, comma-separated; empty clears"], readonly ["--question", "match only questions"], readonly ["--no-question", "do not require a question"], readonly ["--mentions-me", "require a mention of you or a reply to you"], readonly ["--no-mentions-me", "do not require a mention of you or a reply to you"], readonly ["--allow-people <ids>", "only these sender ids, comma-separated; empty for any"], readonly ["--deny-people <ids>", "leave these sender ids out, comma-separated; empty clears"], readonly ["--contacts-only", "match only contacts"], readonly ["--no-contacts-only", "do not require a contact"], readonly ["--template <text>", "the reply template"], readonly ["--model <mode>", "legacy template mode: fill-only or may-reword; use ai blocks instead"], readonly ["--as-reply", "send as a reply to the matched message"], readonly ["--no-as-reply", "send without linking to the matched message"], readonly ["--per-chat <limit>", "at most this many per chat, such as 1/12h"], readonly ["--per-person <limit>", "at most this many per person, such as 1/1d"], readonly ["--outside <hours>", "answer outside this 24-hour window, such as 09:00-19:00"], readonly ["--days <days>", "days of the working window, such as mon-fri or sat,sun"], readonly ["--timezone <zone>", "the IANA timezone for the working window"], readonly ["--no-hours", "clear the working window"]];
+export declare const REPLY_EDIT_OPTIONS: readonly [readonly ["--do <actions>", "actions: reply, task, or both, comma-separated"], readonly ["--kinds <kinds>", "chat kinds: dialog, group; comma-separated, empty for any"], readonly ["--allow-chats <ids>", "only these chat ids, comma-separated; empty for any"], readonly ["--deny-chats <ids>", "leave these chat ids out, comma-separated; empty clears"], readonly ["--words <words>", "match any of these whole words, comma-separated; empty clears"], readonly ["--question", "match only questions"], readonly ["--no-question", "do not require a question"], readonly ["--mentions-me", "require a mention of you or a reply to you"], readonly ["--no-mentions-me", "do not require a mention of you or a reply to you"], readonly ["--allow-people <ids>", "only these sender ids, comma-separated; empty for any"], readonly ["--deny-people <ids>", "leave these sender ids out, comma-separated; empty clears"], readonly ["--contacts-only", "match only contacts"], readonly ["--no-contacts-only", "do not require a contact"], readonly ["--template <text>", "the reply template"], readonly ["--template-mode <mode>", "legacy template mode: fill-only or may-reword; use ai blocks instead"], readonly ["--as-reply", "send as a reply to the matched message"], readonly ["--no-as-reply", "send without linking to the matched message"], readonly ["--per-chat <limit>", "at most this many per chat, such as 1/12h"], readonly ["--per-person <limit>", "at most this many per person, such as 1/1d"], readonly ["--outside <hours>", "answer outside this 24-hour window, such as 09:00-19:00"], readonly ["--days <days>", "days of the working window, such as mon-fri or sat,sun"], readonly ["--timezone <zone>", "the IANA timezone for the working window"], readonly ["--no-hours", "clear the working window"]];
 export declare const REPLY_AUDIENCE_OPTIONS: readonly [readonly ["--reply <mode>", "answer all or only listed senders and chats: all, listed"], readonly ["--allow-people <ids>", "replace allowed sender ids, comma-separated; empty clears"], readonly ["--allow-chats <ids>", "replace allowed chat ids, comma-separated; empty clears"], readonly ["--deny-people <ids>", "replace denied sender ids, comma-separated; empty clears; deny wins"], readonly ["--deny-chats <ids>", "replace denied chat ids, comma-separated; empty clears; deny wins"]];
 export declare const addReplyEditors: (replies: Command, messenger: Messenger) => void;

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

@@ -1,5 +1,5 @@
 import { annotate } from "@wirecat/cli-base/commands";
-import { Command } from "commander";
+import { Command, Option } from "commander";
 import { addRule, editAudience, editRule, switchRule } from "../../replies/edit.js";
 import { audienceWarnings, repliesPathFor } from "../../replies/rules.js";
 import { grantsAuthority, LOCAL_WRITE } from "../effects.js";
@@ -20,7 +20,7 @@ export const REPLY_EDIT_OPTIONS = [
     ["--contacts-only", "match only contacts"],
     ["--no-contacts-only", "do not require a contact"],
     ["--template <text>", "the reply template"],
-    ["--model <mode>", "legacy template mode: fill-only or may-reword; use ai blocks instead"],
+    ["--template-mode <mode>", "legacy template mode: fill-only or may-reword; use ai blocks instead"],
     ["--as-reply", "send as a reply to the matched message"],
     ["--no-as-reply", "send without linking to the matched message"],
     ["--per-chat <limit>", "at most this many per chat, such as 1/12h"],
@@ -59,8 +59,13 @@ export const addReplyEditors = (replies, messenger) => {
     const edit = grantsAuthority(annotate(new Command("edit"), { effects: LOCAL_WRITE }))
         .description("change only the named fields of a reply rule; lists replace the whole list")
         .argument("<id>", "the rule's id");
-    for (const [flag, help] of REPLY_EDIT_OPTIONS)
-        edit.option(flag, help);
+    for (const [flag, help] of REPLY_EDIT_OPTIONS) {
+        const option = new Option(flag, help);
+        if (flag === "--template-mode <mode>")
+            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();
@@ -68,7 +73,10 @@ export const addReplyEditors = (replies, messenger) => {
             delete options.hours;
         const context = messengerContext(this, messenger);
         const { settings, env } = context;
-        renderItem(this, context, editRule(repliesPathFor(messenger.app, settings.profile, env), messenger.provider, id, options));
+        renderItem(this, context, editRule(repliesPathFor(messenger.app, settings.profile, env), messenger.provider, id, {
+            ...options,
+            model: options.templateMode ?? options.model,
+        }));
     });
     replies.addCommand(edit);
     const audience = grantsAuthority(annotate(new Command("audience"), { effects: LOCAL_WRITE })).description("show the reply audience, who the rules may answer, or replace its named fields; a new file answers everyone a rule matches");

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

@@ -13,7 +13,7 @@ export const retentionCommand = (messenger) => annotate(new Command("retention")
     .option("--until-time <time>", "joining period ends at this time; now by default")
     .option("--checkpoints <durations>", "up to 10 increasing joining ages, comma separated; 1d,7d,30d by default")
     .option("--within <duration>", "activity and early departure window after joining; 7d by default")
-    .addOption(new Option("--by <day|week>", "group joining dates by calendar day or Monday week").choices(["day", "week"]))
+    .addOption(new Option("--by <group>", "group joining dates by calendar day or Monday week").choices(["day", "week"]))
     .option("--timezone <zone>", "IANA timezone for joining cohorts")
     .option("--limit <n>", "cohorts and member evidence, 1–100", positiveCount("--limit"))
     .action(async function (chat) {

package/dist/cli/messenger/review.js

@@ -1,6 +1,6 @@
 import { CliError } from "@wirecat/cli-base";
 import { annotate } from "@wirecat/cli-base/commands";
-import { Command } from "commander";
+import { Command, Option } from "commander";
 import { parseDuration } from "../../domain/duration.js";
 import { renderMessages } from "../../render/messages.js";
 import { CHAT_KINDS } from "../../services/chats.js";
@@ -34,7 +34,7 @@ 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`)
-    .option("--kind <kinds>", `only chats of these kinds, comma-separated: ${CHAT_KINDS.join(", ")}`)
+    .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)
@@ -47,7 +47,9 @@ export const reviewCommand = (messenger) => annotate(new Command("review"), {
     const hearWith = modelWith(options.transcribe, options.model);
     const context = messengerContext(this, messenger);
     const { settings, renderer, format, env } = context;
-    const { since: from, chat, meta } = catchUpQuery(query, REVIEW_QUERY, "review");
+    const { since: from, chat, meta, kinds: queriedKinds } = catchUpQuery(query, REVIEW_QUERY, "review");
+    if (options.kind !== undefined && queriedKinds !== undefined)
+        throw new CliError("validation_error", "give kind: or its legacy --kind spelling, not both");
     if (options.new && (from !== undefined || options.unanswered !== undefined)) {
         // An open question stays open: moving past it would drop it from the next review.
         throw new CliError("validation_error", "--new keeps its own point — not with a date or --unanswered");
@@ -62,7 +64,7 @@ export const reviewCommand = (messenger) => annotate(new Command("review"), {
         : undefined;
     const since = from ?? saved?.first ?? reviewStart();
     const hours = options.unanswered === undefined ? undefined : unansweredHours(options.unanswered);
-    const kinds = options.kind === undefined ? undefined : kindsOf(options.kind);
+    const kinds = queriedKinds ?? (options.kind === undefined ? undefined : kindsOf(options.kind));
     let hearing;
     const transcribe = options.transcribe === true;
     const { found, reader } = await context.withServices(async (services, connect) => {

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

@@ -45,7 +45,7 @@ export const searchesCommand = (messenger) => {
         .option("--exact", "bare words and quotes match their exact form only, as exact:word does; text: still matches every form")
         .option("--context <n>", "messages before and after each hit", wholeCount)
         .option("--timezone <zone>", "the IANA timezone for calendar date boundaries")
-        .option("--by <chat|sender|day|hour>", "what stats messages show --saved counts by", groupingOf)
+        .option("--by <group>", "count by chat, sender, day or hour for stats messages show --saved", groupingOf)
         .option("--selection <json>", "save the resolved parent ranking query and options from a drilldown")
         .option("--replace", "overwrite a saved search of the same name")
         .action(async function (name, words) {

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

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

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

@@ -49,7 +49,7 @@ export const statsCommand = (messenger, loadRenderer = chartRenderer) => {
         .description("a chart's data from a chat's statistics, and optionally a dark SVG or PNG image")
         .argument("<chat>", messenger.chatArgument)
         .option("--chart-kind <messages|active|membership>", "what to draw: messages, active authors, or joins and leaves", chartKindOf, "messages")
-        .option("--by <day|week>", "one point per calendar day or week (weeks start on Monday)", chartPeriodOf, "day")
+        .option("--by <group>", "one point per calendar day or week (weeks start on Monday)", chartPeriodOf, "day")
         .option("--since-time <time>", `ISO 8601, or 2h / 1d ago; ${EVENTS_DAYS} days ago if not given`)
         .option("--timezone <zone>", "the IANA timezone for calendar days")
         .option("--output <file>", "write a dark image to a new .svg or .png file")

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

@@ -1,6 +1,6 @@
 import { CliError } from "@wirecat/cli-base";
 import { annotate } from "@wirecat/cli-base/commands";
-import { Command } from "commander";
+import { Command, Option } from "commander";
 import { TAGGING_QUERY } from "../../services/tags.js";
 import { changesStore, FETCH, LOCAL_READ, LOCAL_WRITE } from "../effects.js";
 import { itemOf, renderAnswer, snakeKeys } from "../envelope.js";
@@ -23,7 +23,7 @@ const describe = ({ type, chatId, personId, messageId, taskId }) => type === "ch
 const line = (one) => `${one.tag}  ${one.type}  ${one.name ?? ""} (${one.target})`;
 const sourceOf = (value) => {
     if (value !== "manual" && value !== "auto")
-        throw new CliError("validation_error", "--source takes manual or auto");
+        throw new CliError("validation_error", "--claim takes manual or auto");
     return value;
 };
 /** The owner's labels, in the local store only: `tag:` in a search finds what they label. */
@@ -35,7 +35,7 @@ export const tagsCommand = (messenger) => {
     changesStore(annotate(tags.command("auto"), { 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 <number>", "process at most 1–500 chats", positiveCount("--limit"), 50)
+        .option("--limit <n>", "process at most 1–500 chats", positiveCount("--limit"), 50)
         .option("--sync-first", "read current descriptions from the messenger before classifying")
         .option("--dry-run", "preview cached classification without changing the store")
         .action(async function () {
@@ -62,12 +62,18 @@ 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")
-        .option("--source <manual|auto>", "remove only this ownership claim", sourceOf)
+        .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"))
         .action(async function (given) {
         const context = messengerContext(this, messenger);
         refuseLocalWrite(context, messenger.app.command, "tags.remove");
         const target = this.opts();
-        const done = await context.withServices((services) => services.tags.remove(target, given, this.opts().source));
+        const done = await context.withServices((services) => services.tags.remove(target, given, this.opts().claim ?? this.opts().source));
         renderAnswer(this, context, itemOf(snakeKeys(done)), () => done.removed.length ? `${describe(done.target)}: ${done.removed.join(", ")} removed\n` : "");
         if (done.unchanged.length && context.format === "pretty")
             context.renderer.note(`not there: ${done.unchanged.join(", ")}`);

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

@@ -17,7 +17,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 <id>", "which downloaded model; implies --local (`models audio list`)")
+    .option("--model <model>", "which downloaded model; implies --local (`models audio list`)")
     .action(async function (chat, messageId) {
     const context = messengerContext(this, messenger);
     const choice = {

package/dist/mcp/prompts.js

@@ -42,9 +42,15 @@ export const registerPrompts = (server, { command, name }) => {
             ?.split(",")
             .map((one) => one.trim())
             .filter((one) => one.length > 0);
+        const query = [
+            kinds?.length ? `kind:${JSON.stringify(kinds.join(","))}` : "",
+            mode === undefined || mode === "unread" || mode === "new" ? "" : after(mode),
+        ]
+            .filter(Boolean)
+            .join(" ");
         const args = {
-            ...(kinds?.length ? { kind: kinds.join(",") } : {}),
-            ...(mode === undefined || mode === "unread" ? {} : mode === "new" ? { new: true } : { query: after(mode) }),
+            ...(query ? { query } : {}),
+            ...(mode === "new" ? { new: true } : {}),
         };
         return asked([
             `Catch me up on ${name}. Call ${call(`${command}_read`, "inbox", args)} once.`,