@wirecat/cli-core 0.405.0 → 0.407.0

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

@@ -121,22 +121,22 @@ export const chatsCommand = (messenger) => {
         inspect: "https://example.com/invite/book-club",
         join: "https://example.com/invite/book-club",
         leave: '"Book club"',
-        "link create": '"Book club"',
-        "link list": '"Book club"',
-        "link reset": '"Book club"',
-        "link revoke": '"Book club" https://example.com/invite/book-club',
-        "link show": '"Book club"',
+        "links create": '"Book club"',
+        "links list": '"Book club"',
+        "links reset": '"Book club"',
+        "links remove": '"Book club" https://example.com/invite/book-club',
+        "links show": '"Book club"',
         list: "--limit 10",
         "mark-read": '"Book club" --until-id 101',
         "members add": '"Book club" "Alex Example"',
-        "members audit": '"Book club"',
+        "members check": '"Book club"',
         "members fetch": '"Book club"',
         "members history": '"Book club"',
         "members list": '"Book club"',
         "members remove": '"Book club" "Alex Example"',
         moderate: '"Book club" --dry-run',
-        "requests accept": '"Book club" "Alex Example"',
-        "requests decline": '"Book club" "Alex Example"',
+        "requests confirm": '"Book club" "Alex Example"',
+        "requests reject": '"Book club" "Alex Example"',
         "requests list": '"Book club"',
         "rules set": '"Book club" links report',
         "rules show": '"Book club"',

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

@@ -23,7 +23,7 @@ export const membersCommand = (messenger) => {
         const body = await context.withServices((services) => membersList(services, chat, context.settings));
         renderAnswer(this, context, body, lines(({ id, name, username, role }) => [id, name ?? "", username ? `@${username}` : "", role ?? ""].join("  ")));
     }));
-    members.addCommand(withQuery(annotate(annotate(new Command("audit"), { effects: REMOTE_READ, offline: false })
+    members.addCommand(withQuery(annotate(annotate(new Command("check"), { effects: REMOTE_READ, offline: false })
         .summary("members that look like bots, with reasons")
         .description("members that look like bots, each with its reasons — read from the member list and the local store; " +
         "never one request per person, and it removes nobody")

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

@@ -69,7 +69,7 @@ export const contactsCommand = (messenger) => {
         }));
         renderAnswer(this, context, itemOf(contactAnswer(account, card)));
     }));
-    annotate(contacts.command("profile"), { effects: REMOTE_READ, output: { entity: "contact_profile" } })
+    annotate(contacts.command("info"), { effects: REMOTE_READ, output: { entity: "contact_profile" } })
         .summary("a person's profile from the messenger")
         .description("everything the messenger says about one person — handles, flags, last seen, when they registered — and " +
         "how many of their messages the store holds in each chat you share, the first and the last, and the " +
@@ -173,7 +173,10 @@ export const contactsCommand = (messenger) => {
             meta: { ...window.meta, ...(hasMore ? { truncated: true } : {}) },
         }));
     });
-    annotate(contacts.command("timeline"), { effects: REMOTE_READ, output: { entity: "contact_activity" } })
+    annotate(contacts.command("events"), {
+        effects: REMOTE_READ,
+        output: { entity: "contact_activity" },
+    })
         .summary("one person's activity across their linked identities")
         .description("everything one person took part in, in every messenger linked to them — messages they wrote or were " +
         "mentioned in, chats, mail, meetings, tasks — newest first, from the store; never connects")
@@ -200,7 +203,7 @@ export const contactsCommand = (messenger) => {
             ...(cursor === undefined ? {} : { cursor }),
         }));
         const { items, hasMore, limits, pending } = found;
-        renderAnswer(this, context, listOf("contacts timeline", {
+        renderAnswer(this, context, listOf("contacts events", {
             items: items.map(snakeKeys),
             limit: limits.items,
             has_more: hasMore,
@@ -292,8 +295,8 @@ export const contactsCommand = (messenger) => {
         contacts.addCommand(command);
     const examples = {
         add: '"Alex Example"',
-        "alias rm": '"Alex Example"',
-        "alias set": '"Alex Example" "Reading partner"',
+        "aliases remove": '"Alex Example"',
+        "aliases set": '"Alex Example" "Reading partner"',
         block: '"Alex Example"',
         check: '"Alex Example"',
         context: '"Alex Example" --limit 10',
@@ -306,12 +309,12 @@ export const contactsCommand = (messenger) => {
         "notes list": '"Alex Example"',
         "notes remove": '"Alex Example" 1',
         "notes show": '"Alex Example" 1',
-        profile: '"Alex Example"',
+        info: '"Alex Example"',
         remove: '"Alex Example"',
         rename: '"Alex Example" Alex Example',
         show: '"Alex Example"',
         sync: "",
-        timeline: '"Alex Example" --limit 10',
+        events: '"Alex Example" --limit 10',
         unblock: '"Alex Example"',
         unlink: '"Alex Example"',
     };

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

@@ -1,5 +1,5 @@
 import type { Command } from "commander";
-import type { AdminRight, GroupSettingKey, Id, Message, PollVote, PrivacyKey, Provider } from "../../domain/models.js";
+import type { AdminRight, GroupSettingKey, Id, Message, Page, PollVote, PrivacyKey, Provider } from "../../domain/models.js";
 import type { MessengerAdapter } from "../../ports/messenger.js";
 import type { EventSink, Warn } from "../../runs/events.js";
 import { type Asker, type SendGuard } from "../../sends/guard.js";
@@ -18,6 +18,11 @@ import type { GlobalFlags, ResolveOptions, Settings } from "../settings.js";
  */
 export interface StoredMessages {
     message(chatId: Id, messageId: Id): Promise<Message | undefined>;
+    /** Stored messages in one provider thread, oldest first within the newest page. No remote fetch. */
+    threadMessages?(chatId: Id, threadId: Id, window: {
+        limit: number;
+        before?: Id;
+    }): Promise<Page<Message>>;
     /** The newest message from someone else in the chat, older than `before` when it is given. */
     newestIncoming(chatId: Id, before?: Id): Promise<Message | undefined>;
     /** The newest message in the chat sent at `at` or earlier; without `at`, the oldest one held. */
@@ -148,20 +153,22 @@ export interface Messenger extends ServiceMessenger {
     stickerFileBytes?: number;
     /** Whether shared folders can be joined; yes when unset. */
     folderJoin?: boolean;
-    /** Whether another invite link can be made — `chats link create`; yes when unset. */
+    /** Whether another invite link can be made — `chats links create`; yes when unset. */
     inviteLinkCreate?: boolean;
     /** Whether invite links can be listed; yes when unset. */
     inviteLinkList?: boolean;
     /** Whether one invite link can be revoked; yes when unset. */
     inviteLinkRevoke?: boolean;
-    /** Whether one invite link can be changed — `chats link update`; no when unset. */
+    /** Whether one invite link can be changed — `chats links update`; no when unset. */
     inviteLinkUpdate?: boolean;
-    /** Whether every pending join request is answered at once — `chats requests accept --all`; yes when unset. */
+    /** Whether every pending join request is answered at once — `chats requests confirm --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 comments can be read independently of sending; inherits channelComments when unset. */
+    readsComments?: boolean;
     /** Whether people added can be shown the messages from before they came — `members add --history`; yes when unset. */
     addsWithHistory?: boolean;
     /** The admin rights this messenger has, as `admins add --can` offers them; every one when unset. */

package/dist/cli/messenger/context.js

@@ -40,6 +40,12 @@ export const storedMessages = (provider, store, account) => {
             const at = key();
             return at && (await store()).messages.message(at, messageId, { chatId });
         },
+        threadMessages: async (chatId, threadId, window) => {
+            const owner = key();
+            return owner
+                ? (await store()).messages.messages(owner, chatId, { ...window, threadId })
+                : { items: [], hasMore: false };
+        },
         newestIncoming: async (chatId, before) => {
             const at = key();
             if (!at)

package/dist/cli/messenger/conversation-examples.js

@@ -2,13 +2,14 @@ import { annotate } from "@wirecat/cli-base/commands";
 import { commandAt } from "../steps.js";
 export const conversationExamples = (root, tool) => {
     const examples = {
-        "batches next": '--chat "Book club"',
+        "batches show": '--chat "Book club"',
         "batches status": '--chat "Book club"',
-        build: '--chat "Book club"',
+        "links rebuild": '--chat "Book club"',
         "consents list": "",
-        "consents revoke": '--chat "Book club"',
-        "embed clear": '--chat "Book club"',
-        "embed status": '--chat "Book club"',
+        "consents remove": '--chat "Book club"',
+        embed: '--chat "Book club"',
+        "embeddings clear": '--chat "Book club"',
+        "embeddings status": '--chat "Book club"',
         "links add": '--batch "$batch"',
         "links clear": '--chat "Book club"',
         list: '"Book club"',
@@ -21,5 +22,5 @@ export const conversationExamples = (root, tool) => {
         if (command)
             annotate(command, { examples: [`${tool} personal conversations ${path} ${args}`.trimEnd()] });
     }
-    commandAt(root, "links add")?.addHelpText("after", "\nSet batch to the id from conversations batches next; supply the JSON answer to that batch on stdin.\n");
+    commandAt(root, "links add")?.addHelpText("after", "\nSet batch to the id from conversations batches show; supply the JSON answer to that batch on stdin.\n");
 };

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

@@ -1,9 +1,5 @@
 import { Command } from "commander";
 import { type Messenger } from "./context.js";
-/**
- * `conversations`: the threads inside a group chat, found by rules over the stored messages — replies,
- * mentions, one sender's messages in a row. From the store alone; nothing is built until asked (phase 3).
- */
 export declare const conversationsCommand: (messenger: Messenger) => Command;
 /** `messages links`: why a message sits where it does in its conversation. */
 export declare const linksCommand: (messenger: Messenger) => Command;

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

@@ -30,94 +30,121 @@ import { readAll } from "./stdin.js";
  * `conversations`: the threads inside a group chat, found by rules over the stored messages — replies,
  * mentions, one sender's messages in a row. From the store alone; nothing is built until asked (phase 3).
  */
+const conversationBuildCommand = (messenger) => boundOptions(reachesOtherService(annotate(new Command("rebuild"), { output: { entity: "conversation_build" }, effects: REMOTE_WRITE }))
+    .summary("build conversation links from stored messages")
+    .description("find a chat's conversations in what the store holds, replacing the last build; without --chat, every " +
+    "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")
+    .addOption(new Option("--analysis-provider <provider>", "analysis: agent, openai or anthropic"))
+    .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"))
+    .option("--max-tokens <n>", "analysis input/output reservation cap per run; default 100000", positiveCount("--max-tokens")), { chunks: false }).action(async function () {
+    const options = this.optsWithGlobals();
+    const { chat, maxChats } = options;
+    const context = messengerContext(this, messenger);
+    if (options.analyze) {
+        if (!chat)
+            throw new CliError("validation_error", "--analyze requires --chat");
+        refuseLocalWrite(context, messenger.app.command, LINKS_KEY);
+        refuseLocalWrite(context, messenger.app.command, "conversations.links.rebuild");
+        const target = analysisChoice(options, messenger.app, context.settings, context.env, context.keyring);
+        if (!isLocal(target.baseUrl))
+            refuseUnderReadOnly(this, `send chat text to ${new URL(target.baseUrl).host}`);
+        const controller = new AbortController();
+        context.track({ close: async () => controller.abort() });
+        const maxTokens = options.maxTokens ?? 100_000;
+        const size = options.size ?? BATCH_SIZE.default;
+        const result = await context.withStore(async (store, account) => {
+            const services = servicesFor({
+                ...storedDeps(messenger, store, account, context.guard),
+                env: context.env,
+                profile: context.profile,
+            });
+            const status = await services.conversations.batchStatus(chat, size);
+            const consents = analysisConsents(store, account);
+            const identity = providerIdentity(target);
+            if (status.messages && !(await consents.has(status.chat, identity))) {
+                const what = `${status.messages} messages, ${status.characters} characters (about ${status.tokensEstimate} message tokens, plus prompt and batch context), go to ${target.model} at ${target.baseUrl}; this run reserves at most ${maxTokens} input/output tokens. Consent is remembered for this chat and provider until revoked`;
+                if (!options.yes) {
+                    const answer = await askOwner(this, `${what}. Allow analysis? [y/N] `);
+                    if (answer === null)
+                        throw new CliError("confirmation_required", `${what} — add --yes`);
+                    if (!/^y(es)?$/i.test(answer.trim()))
+                        throw new CliError("cancelled", "cancelled — nothing was sent");
+                }
+                await consents.remember(status.chat, identity);
+            }
+            await services.conversations.build(chat);
+            const request = openAnalysis(target, controller.signal);
+            return runAnalysis(services.conversations, chat, async (...args) => {
+                if (!(await consents.has(status.chat, identity)))
+                    throw new CliError("permission_error", "analysis consent was revoked; no further batch was sent");
+                return request(...args);
+            }, {
+                model: target.model,
+                command: messenger.app.command,
+                size,
+                maxTokens,
+            });
+        });
+        renderAnswer(this, context, itemOf(snakeKeys(result)));
+        return;
+    }
+    if (options.analysisProvider !== undefined ||
+        options.provider !== undefined ||
+        options.model !== undefined ||
+        options.baseUrl !== undefined ||
+        options.size !== undefined ||
+        options.maxTokens !== undefined)
+        throw new CliError("validation_error", "analysis options require --analyze");
+    if (chat === undefined) {
+        const refreshed = await context.withServices((services) => services.embeddings.refresh({
+            embed: false,
+            ...(maxChats ? { maxChats } : {}),
+            progress: (note) => context.renderer.note(note),
+        }));
+        renderRefreshed(this, context, refreshed);
+        return;
+    }
+    const built = await context.withServices((services) => services.conversations.build(chat));
+    renderAnswer(this, context, itemOf(snakeKeys(built)), () => `${built.messages} messages → ${built.conversations} conversations, ${built.links} links (rules v${built.rulesVersion})\n`);
+});
+const embeddingStatusCommand = (messenger) => withModelOptions(annotate(new Command("status"), { output: { entity: "conversation_embedding_status" }, effects: LOCAL_READ })
+    .summary("which conversation vectors are ready or stale")
+    .description("how many chunks of a chat have a vector of the model, how many are left, and what is left costs")
+    .option("--chat <chat>", messenger.chatArgument)).action(async function () {
+    const options = this.optsWithGlobals();
+    const chat = chatOf(options);
+    const context = messengerContext(this, messenger);
+    const model = choiceOf(options, messenger, context, { needKey: false });
+    const status = await context.withServices((services) => services.embeddings.status(chat, model));
+    renderAnswer(this, context, itemOf(snakeKeys(status)), () => `${status.embedded} of ${status.chunks} chunks embedded with ${status.model}; ${status.left} left` +
+        (status.estimateSeconds === null ? "" : `, ${minutes(status.estimateSeconds)}`) +
+        (status.priceAtMost ? `, at most ${dollars(status.priceAtMost.usd)}` : "") +
+        "\n");
+});
+const embeddingClearCommand = (messenger) => withModelOptions(destroysNothing(annotate(new Command("clear"), { output: { entity: "conversation_change" }, effects: LOCAL_WRITE }))
+    .summary("remove stored conversation vectors")
+    .description("drop a chat's vectors, or only one model's; messages and conversations are never touched")
+    .option("--chat <chat>", messenger.chatArgument)).action(async function () {
+    const options = this.optsWithGlobals();
+    const chat = chatOf(options);
+    const context = messengerContext(this, messenger);
+    refuseLocalWrite(context, messenger.app.command, EMBED_KEY);
+    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`);
+});
 export const conversationsCommand = (messenger) => {
     const conversations = new Command("conversations")
         .summary("group stored messages into conversations")
         .description("the conversations inside a chat, found in the stored messages by replies, mentions and who wrote next");
-    boundOptions(reachesOtherService(annotate(conversations.command("build"), { output: { entity: "conversation_build" }, effects: REMOTE_WRITE }))
-        .summary("build conversation links from stored messages")
-        .description("find a chat's conversations in what the store holds, replacing the last build; without --chat, every " +
-        "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")
-        .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"))
-        .option("--max-tokens <n>", "analysis input/output reservation cap per run; default 100000", positiveCount("--max-tokens")), { chunks: false }).action(async function () {
-        const options = this.optsWithGlobals();
-        const { chat, maxChats } = options;
-        const context = messengerContext(this, messenger);
-        if (options.analyze) {
-            if (!chat)
-                throw new CliError("validation_error", "--analyze requires --chat");
-            refuseLocalWrite(context, messenger.app.command, LINKS_KEY);
-            refuseLocalWrite(context, messenger.app.command, "conversations.build");
-            const target = analysisChoice(options, messenger.app, context.settings, context.env, context.keyring);
-            if (!isLocal(target.baseUrl))
-                refuseUnderReadOnly(this, `send chat text to ${new URL(target.baseUrl).host}`);
-            const controller = new AbortController();
-            context.track({ close: async () => controller.abort() });
-            const maxTokens = options.maxTokens ?? 100_000;
-            const size = options.size ?? BATCH_SIZE.default;
-            const result = await context.withStore(async (store, account) => {
-                const services = servicesFor({
-                    ...storedDeps(messenger, store, account, context.guard),
-                    env: context.env,
-                    profile: context.profile,
-                });
-                const status = await services.conversations.batchStatus(chat, size);
-                const consents = analysisConsents(store, account);
-                const identity = providerIdentity(target);
-                if (status.messages && !(await consents.has(status.chat, identity))) {
-                    const what = `${status.messages} messages, ${status.characters} characters (about ${status.tokensEstimate} message tokens, plus prompt and batch context), go to ${target.model} at ${target.baseUrl}; this run reserves at most ${maxTokens} input/output tokens. Consent is remembered for this chat and provider until revoked`;
-                    if (!options.yes) {
-                        const answer = await askOwner(this, `${what}. Allow analysis? [y/N] `);
-                        if (answer === null)
-                            throw new CliError("confirmation_required", `${what} — add --yes`);
-                        if (!/^y(es)?$/i.test(answer.trim()))
-                            throw new CliError("cancelled", "cancelled — nothing was sent");
-                    }
-                    await consents.remember(status.chat, identity);
-                }
-                await services.conversations.build(chat);
-                const request = openAnalysis(target, controller.signal);
-                return runAnalysis(services.conversations, chat, async (...args) => {
-                    if (!(await consents.has(status.chat, identity)))
-                        throw new CliError("permission_error", "analysis consent was revoked; no further batch was sent");
-                    return request(...args);
-                }, {
-                    model: target.model,
-                    command: messenger.app.command,
-                    size,
-                    maxTokens,
-                });
-            });
-            renderAnswer(this, context, itemOf(snakeKeys(result)));
-            return;
-        }
-        if (options.analysisProvider !== undefined ||
-            options.provider !== undefined ||
-            options.model !== undefined ||
-            options.baseUrl !== undefined ||
-            options.size !== undefined ||
-            options.maxTokens !== undefined)
-            throw new CliError("validation_error", "analysis options require --analyze");
-        if (chat === undefined) {
-            const refreshed = await context.withServices((services) => services.embeddings.refresh({
-                embed: false,
-                ...(maxChats ? { maxChats } : {}),
-                progress: (note) => context.renderer.note(note),
-            }));
-            renderRefreshed(this, context, refreshed);
-            return;
-        }
-        const built = await context.withServices((services) => services.conversations.build(chat));
-        renderAnswer(this, context, itemOf(snakeKeys(built)), () => `${built.messages} messages → ${built.conversations} conversations, ${built.links} links (rules v${built.rulesVersion})\n`);
-    });
     withQuery(annotate(conversations.command("list"), { effects: LOCAL_READ })
         .summary("stored conversations in one chat")
         .description("a chat's conversations, the newest first: when, how many messages, how many people")
@@ -187,7 +214,7 @@ export const conversationsCommand = (messenger) => {
         const { model: id, chats, unbuiltGroups, } = await context.withServices((services) => services.embeddings.readiness({ ...(options.chat === undefined ? {} : { chat: options.chat }), model }));
         renderAnswer(this, context, readinessList({ model: id, chats, ...(unbuiltGroups === undefined ? {} : { unbuiltGroups }) }), () => chats.map((one) => `${readinessLine(one, id)}\n`).join(""));
         if (chats.length === 0 && !unbuiltGroups && context.format === "pretty")
-            context.renderer.note("no chat has conversations yet — `conversations build --chat <chat>`");
+            context.renderer.note("no chat has conversations yet — `conversations links rebuild --chat <chat>`");
     });
     const batches = conversations
         .command("batches")
@@ -204,7 +231,7 @@ export const conversationsCommand = (messenger) => {
         renderAnswer(this, context, itemOf(snakeKeys(status)), () => `${status.messages} messages to answer, about ${status.batches} batches, ` +
             `${status.characters} characters (about ${status.tokensEstimate} tokens)\n`);
     });
-    sizeOption(annotate(batches.command("next"), { output: { entity: "conversation_batch" }, effects: LOCAL_READ })
+    sizeOption(annotate(batches.command("show"), { output: { entity: "conversation_batch" }, effects: LOCAL_READ })
         .summary("get the next batch of messages to link")
         .description("the next window to answer, with the messages before it; message text goes to stdout only")
         .requiredOption("--chat <chat>", messenger.chatArgument)).action(async function () {
@@ -228,9 +255,8 @@ export const conversationsCommand = (messenger) => {
             .join("")}`);
         context.renderer.note(`${batch.remaining.messages} messages left after this batch`);
     });
-    const links = conversations
-        .command("links")
-        .description("your agent's answers: which earlier message each message of a batch answers");
+    const links = conversations.command("links").description("message links and the conversations derived from them");
+    links.addCommand(conversationBuildCommand(messenger));
     readsStdin(annotate(links.command("add"), { output: { entity: "conversation_change" }, effects: LOCAL_WRITE }), {
         name: "answer",
         description: '{ "model", "skill"?, "answers": [{ "message", "parent", "confidence" }] }',
@@ -239,7 +265,7 @@ export const conversationsCommand = (messenger) => {
         .summary("save an agent's conversation-link answers")
         .description('store your agent\'s answer to a batch, read as JSON from stdin: { "model", "answers": [{ "message", ' +
         '"parent", "confidence" }] }; all or nothing')
-        .requiredOption("--batch <id>", "the batch id `conversations batches next` printed")
+        .requiredOption("--batch <id>", "the batch id `conversations batches show` printed")
         .action(async function () {
         const { batch } = this.opts();
         const context = messengerContext(this, messenger);
@@ -252,8 +278,7 @@ 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)
-        .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"))
+        .addOption(new Option("--answer-model <model>", "only the stored answers this model gave"))
         .action(async function () {
         const { chat, model, answerModel } = this.opts();
         const context = messengerContext(this, messenger);
@@ -308,36 +333,9 @@ export const conversationsCommand = (messenger) => {
             next: done.skipped ? [nextStep("conversations.build", { args: { chat } })] : [],
         }), () => `${done.embedded} chunks embedded with ${done.model}${done.skipped ? `, ${done.skipped} changed since the build` : ""}\n`);
     });
-    withModelOptions(annotate(embed.command("status"), { output: { entity: "conversation_embedding_status" }, effects: LOCAL_READ })
-        .summary("which conversation vectors are ready or stale")
-        .description("how many chunks of a chat have a vector of the model, how many are left, and what is left costs")
-        .option("--chat <chat>", messenger.chatArgument)).action(async function () {
-        const options = this.optsWithGlobals();
-        const chat = chatOf(options);
-        const context = messengerContext(this, messenger);
-        const model = choiceOf(options, messenger, context, { needKey: false });
-        const status = await context.withServices((services) => services.embeddings.status(chat, model));
-        renderAnswer(this, context, itemOf(snakeKeys(status)), () => `${status.embedded} of ${status.chunks} chunks embedded with ${status.model}; ${status.left} left` +
-            (status.estimateSeconds === null ? "" : `, ${minutes(status.estimateSeconds)}`) +
-            (status.priceAtMost ? `, at most ${dollars(status.priceAtMost.usd)}` : "") +
-            "\n");
-    });
-    withModelOptions(destroysNothing(annotate(embed.command("clear"), { output: { entity: "conversation_change" }, effects: LOCAL_WRITE }))
-        .summary("remove stored conversation vectors")
-        .description("drop a chat's vectors, or only one model's; messages and conversations are never touched")
-        .option("--chat <chat>", messenger.chatArgument)).action(async function () {
-        const options = this.optsWithGlobals();
-        const chat = chatOf(options);
-        const context = messengerContext(this, messenger);
-        refuseLocalWrite(context, messenger.app.command, EMBED_KEY);
-        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`);
-    });
+    const embeddings = new Command("embeddings").description("stored conversation vectors");
+    embeddings.addCommand(embeddingStatusCommand(messenger)).addCommand(embeddingClearCommand(messenger));
+    conversations.addCommand(embeddings);
     boundOptions(destroysNothing(annotate(conversations.command("rebuild"), {
         output: { entity: "conversation_preparation" },
         effects: LOCAL_WRITE,
@@ -373,13 +371,13 @@ export const conversationsCommand = (messenger) => {
             has_more: false,
         }));
     });
-    annotate(consents.command("revoke"), { effects: LOCAL_WRITE, output: { entity: "analysis_consent_revocation" } })
+    annotate(consents.command("remove"), {
+        effects: LOCAL_WRITE,
+        output: { entity: "analysis_consent_revocation" },
+    })
         .description("forget analysis permissions so the next analysis asks again")
         .option("--chat <chat>", "revoke only this chat's consents; defaults to every chat")
-        .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"))
+        .addOption(new Option("--consent-provider <identity>", "exact provider identity from consents list; defaults to every provider"))
         .action(async function () {
         const { chat, provider, consentProvider } = this.opts();
         const context = messengerContext(this, messenger);
@@ -406,11 +404,8 @@ const chatOf = ({ chat }) => {
     return chat;
 };
 const withModelOptions = (command) => command
-    .option("--model <model>", "local: a model id from `models text list` (default: e5-small); remote: the provider's model")
-    .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("--model <model>", "local: a model id from `models list` (default: e5-small); remote: the provider's model")
+    .addOption(new Option("--embedding-provider <provider>", "embedding provider: local or openai; flags override profile settings"))
     .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. */
@@ -488,7 +483,7 @@ const consent = async (command, status, baseUrl, { yes, maxTokens }) => {
         throw new CliError("cancelled", "cancelled — nothing was sent");
 };
 const LINKS_KEY = "conversations.links";
-const EMBED_KEY = "conversations.embed";
+const EMBED_KEY = "conversations.embeddings";
 const dollars = (usd) => (usd < 0.0001 ? "under $0.0001" : `$${usd.toFixed(4)}`);
 const minutes = (seconds) => (seconds < 90 ? `about ${seconds} s` : `about ${Math.round(seconds / 60)} min`);
 /** The agent's JSON, shaped enough for the store to check the rest against the batch. */
@@ -524,7 +519,7 @@ export const linksCommand = (messenger) => annotate(new Command("links"), {
         return;
     }
     if (found.links.length === 0) {
-        context.renderer.note("no links: it starts a conversation, or the chat is not built — `conversations build`");
+        context.renderer.note("no links: it starts a conversation, or the chat is not built — `conversations links rebuild`");
     }
     context.streams.data(found.links
         .map((link) => `${link.chosen ? "→" : " "} ${link.parentId ?? "(starts)"}  ${link.source} ${link.kind} ` +
@@ -538,7 +533,7 @@ const itemLine = (one) => `${one.id}  ${one.started_at.slice(0, 16).replace("T",
 const hitLine = ({ summary, chunk, score, stale, locator }) => `${score === null ? "  —  " : score.toFixed(3)}  ${line(summary)}  ` +
     `(messages ${chunk.firstMessageId}–${chunk.lastMessageId})${locator ? `  ${locator}` : ""}${stale ? "  stale" : ""}`;
 const readinessLine = ({ chat, state, graph, pending, vectors }, model) => graph === null
-    ? `${chat}  ${state} — \`conversations build --chat ${chat}\``
+    ? `${chat}  ${state} — \`conversations links rebuild --chat ${chat}\``
     : `${chat}  ${state}  built ${graph.builtAt.slice(0, 16).replace("T", " ")}, rules v${graph.rulesVersion}` +
         `${graph.outdatedRules ? " (outdated)" : ""} · not in the build: ${pending.new} new, ${pending.edited} edited, ` +
         `${pending.deleted} deleted · ${model}: ${vectors.current} current, ${vectors.stale} stale, ` +

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

@@ -9,7 +9,7 @@ import { countersAnswer, refreshAnswer, refuseJsonl } from "./stats-answers.js";
 export const countersCommand = (messenger) => {
     const parent = new Command("counters").description("per-counter observations and bounded remote refresh");
     for (const operation of ["show", "refresh"]) {
-        const command = new Command(operation)
+        const command = new Command(operation === "refresh" ? "sync" : operation)
             .summary("refresh message counters from the messenger")
             .description(operation === "show"
             ? "show saved counter values and their observation freshness"
@@ -22,6 +22,8 @@ export const countersCommand = (messenger) => {
             .option("--selection <json>", "pinned counter-targets selection from counters show; conflicts with query and scope")
             .option("--counters <names>", "distinct views,reactions,comments fields; all three by default")
             .option("--limit <n>", "messages, 1–100; 20 by default", positiveCount("--limit"));
+        if (operation === "refresh")
+            command;
         if (operation === "show")
             command.option("--max-age <duration>", "maximum fresh observation age; 24h by default");
         annotate(command, operation === "refresh"
@@ -36,7 +38,7 @@ export const countersCommand = (messenger) => {
             const context = messengerContext(this, messenger), options = this.opts();
             refuseJsonl(context.format);
             if (operation === "refresh" && !options.dryRun)
-                refuseLocalWrite(context, messenger.app.command, "stats.messages.counters.refresh");
+                refuseLocalWrite(context, messenger.app.command, "stats.messages.counters.sync");
             const query = {
                 ...options,
                 limit: options.limit ?? 20,

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

@@ -9,7 +9,7 @@ import { FloodMemory, floodPathFor } from "../../sends/flood.js";
 import { SendJournal, sendsPathFor } from "../../sends/journal.js";
 import { storePath } from "../../store/path.js";
 import { baseContext, environmentOf, outputFor } from "../context.js";
-import { destroysNothing, LOCAL_WRITE, REMOTE_READ } from "../effects.js";
+import { destroysNothing, LOCAL_WRITE, NO_EFFECTS, REMOTE_READ } from "../effects.js";
 import { itemOf, renderAnswer, snakeKeys } from "../envelope.js";
 import { lineOf, nextStep } from "../steps.js";
 import { recalledAccount } from "./accounts.js";
@@ -57,11 +57,15 @@ const INCLUDES = [
 const EXCLUDES = ["message text", "chat titles", "names", "phone numbers", "the session", "the app credentials"];
 const reportCommand = (messenger) => {
     const { app } = messenger;
-    const report = annotate(new Command("report"), { effects: REMOTE_READ })
+    const report = new Command("reports").description("problem reports");
+    annotate(report.command("show"), {
+        effects: NO_EFFECTS,
+        examples: [`${app.command} doctor reports show`],
+    })
         .description("what a problem report holds; writes nothing")
         .action(function () {
         const output = outputFor(this);
-        const create = lineOf(this, "doctor report create");
+        const create = lineOf(this, "doctor reports create");
         renderAnswer(this, output, itemOf({ includes: INCLUDES, excludes: EXCLUDES, ...(app.issues ? { send_to: app.issues } : {}) }, { next: [nextStep("doctor.report-create", { args: {} })] }), () => [
             `A problem report is one file for the author of ${app.command}.`,
             "",
@@ -76,7 +80,7 @@ const reportCommand = (messenger) => {
     });
     destroysNothing(annotate(report.command("create"), {
         effects: LOCAL_WRITE,
-        examples: [`${app.command} personal doctor report create --output ./problem-report.json`],
+        examples: [`${app.command} personal doctor reports create --output ./problem-report.json`],
     }))
         .description("write a problem report to a file, and say where to send it")
         .option("--run <id>", "the run the report is about; the newest failed one if not given")