@wirecat/cli-core 0.347.0 → 0.348.0

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

@@ -15,7 +15,7 @@ import { drainNoteIndex, fillSearchIndex, fillStems, involvementStoreOver, noteI
 import { environmentOf, outputFor } from "../context.js";
 import { destroysNothing, LOCAL_READ, LOCAL_WRITE } from "../effects.js";
 import { itemOf, renderAnswer, snakeKeys } from "../envelope.js";
-import { nextStep } from "../steps.js";
+import { lineOf, nextStep } from "../steps.js";
 import { answerOf } from "./ask.js";
 import { ENCRYPT_OPTION, passwordOf } from "./password.js";
 import { servingProfiles } from "./serve-command.js";
@@ -443,7 +443,7 @@ const reindexCommand = (messenger) => destroysNothing(annotate(new Command("rein
                 `${schema.minCompatible}; this one speaks ${SPEAKS}) — upgrade this tool`);
         }
         if (schema.version < SPEAKS) {
-            throw new CliError("validation_error", `the store is behind this build — \`${messenger.app.command} store migrate\` first`);
+            throw new CliError("validation_error", `the store is behind this build — \`${lineOf(this, "store migrate")}\` first`);
         }
         resetSearchIndex(database);
         const fileTexts = resetAttachmentWords(database);
@@ -591,7 +591,7 @@ const restoreFrom = async (command, messenger, backup, given) => {
     // One that has not touched the store yet holds nothing open, and was not seen.
     renderer.note("restart every serve and mcp of either CLI that was running, so they read the restored store");
     if (schema.version < SPEAKS) {
-        renderer.note(`the backup is behind this build; the next command migrates it — \`${messenger.app.command} store migrate\` now`);
+        renderer.note(`the backup is behind this build; the next command migrates it — \`${lineOf(command, "store migrate")}\` now`);
     }
 };
 const backupSchema = async (backup) => {

package/dist/cli/messenger/stored.js

@@ -49,6 +49,36 @@ export const stored = (messenger, { account, store, warn, events, pending, delet
             return undefined;
         }
     };
+    const saveBatches = (operation, onBatch) => {
+        // In order: a batch's messages may belong to chats only an earlier batch named.
+        let previous = Promise.resolve();
+        return (batch) => {
+            if (namesFromStore) {
+                for (const { from, to } of batch.rekeys ?? []) {
+                    const title = titles.get(from);
+                    titles.delete(from);
+                    if (title && !titles.has(to))
+                        titles.set(to, title);
+                }
+                for (const chat of batch.chats ?? [])
+                    if (chat.title)
+                        titles.set(chat.id, chat.title);
+            }
+            // Each re-key apart: one refused leaves the chat split, never the batch's history unsaved.
+            const saving = previous.then(async () => {
+                for (const { from, to } of batch.rekeys ?? [])
+                    await attempt("history.rekey", async (opened) => {
+                        await opened.chats.rekeyChat(account, from, to);
+                        await rekeyed?.(from, to);
+                    });
+                await attempt(operation, (opened) => fill(opened, account, batch));
+            });
+            previous = saving;
+            pending?.add(saving);
+            void saving.finally(() => pending?.delete(saving));
+            onBatch(batch);
+        };
+    };
     // A method not listed here saves nothing and passes through; a lane that should save adds its line.
     return throughWrapper(messenger, {
         ...(messenger.forumState
@@ -213,36 +243,12 @@ export const stored = (messenger, { account, store, warn, events, pending, delet
             : {}),
         ...(messenger.feed
             ? {
-                feed: (onBatch, signal) => {
-                    // In order: a batch's messages may belong to chats only an earlier batch named.
-                    let previous = Promise.resolve();
-                    return (messenger.feed?.((batch) => {
-                        if (namesFromStore) {
-                            for (const { from, to } of batch.rekeys ?? []) {
-                                const title = titles.get(from);
-                                titles.delete(from);
-                                if (title && !titles.has(to))
-                                    titles.set(to, title);
-                            }
-                            for (const chat of batch.chats ?? [])
-                                if (chat.title)
-                                    titles.set(chat.id, chat.title);
-                        }
-                        // Each re-key apart: one refused leaves the chat split, never the batch's history unsaved.
-                        const saving = previous.then(async () => {
-                            for (const { from, to } of batch.rekeys ?? [])
-                                await attempt("history.rekey", async (opened) => {
-                                    await opened.chats.rekeyChat(account, from, to);
-                                    await rekeyed?.(from, to);
-                                });
-                            await attempt("history.feed", (opened) => fill(opened, account, batch));
-                        });
-                        previous = saving;
-                        pending?.add(saving);
-                        void saving.finally(() => pending?.delete(saving));
-                        onBatch(batch);
-                    }, signal) ?? Promise.resolve());
-                },
+                feed: (onBatch, signal) => messenger.feed?.(saveBatches("history.feed", onBatch), signal) ?? Promise.resolve(),
+            }
+            : {}),
+        ...(messenger.listenHistory
+            ? {
+                listenHistory: (onBatch, signal) => messenger.listenHistory?.(saveBatches("history.listen", onBatch), signal) ?? Promise.resolve(),
             }
             : {}),
         ...(messenger.edit

package/dist/cli/program.js

@@ -19,7 +19,6 @@ import { changesAuthorityNow, isLogin, isStoreChange, judgedEffects, judgedTarge
 import { itemOf, renderAnswer, snakeKeys } from "./envelope.js";
 import { byteCount, DEFAULT_COMMAND_MS, DEFAULT_OUTPUT_BYTES, execution } from "./execution.js";
 import { installHelp } from "./help/first-screen.js";
-import { sectionCoreGroups } from "./help/sections.js";
 import { MAX_BUFFERED_INPUT, provideInputPolicy } from "./input-policy.js";
 import { checkJson, liftJson } from "./json-fields.js";
 import { movedPath, movedPointer } from "./moved.js";
@@ -27,7 +26,7 @@ import { PreviewComplete, preview } from "./preview.js";
 import { commandWords, liftProfile, PROFILE_FREE, valuedOptions } from "./profile.js";
 import { absolutePaths, relayTarget } from "./relay-route.js";
 import { settingsFor } from "./settings.js";
-import { commandAt } from "./steps.js";
+import { commandAt, lineOf, withLines } from "./steps.js";
 /**
  * The command tree, built fresh on each call. Commander is global state by default —
  * `exitOverride` and the write hooks turn it into a value a test can drive.
@@ -63,13 +62,13 @@ export const createProgram = ({ app, commands, configure, firstScreen }, { out,
     for (const command of commands())
         program.addCommand(command);
     configure?.(program);
-    sectionCoreGroups(program);
     installHelp(program, { pitch: app.description, ...firstScreen });
     // Commander builds a usage line from the command tree, where the profile is not a word.
     for (const top of program.commands) {
         if (PROFILE_FREE.has(top.name()))
             continue;
         forEachCommand(top, (command) => command.configureHelp({
+            ...command.configureHelp(),
             commandUsage: (shown) => `${app.command} <profile>${new Help().commandUsage(shown).slice(app.command.length)}`,
         }));
     }
@@ -327,7 +326,7 @@ export const run = async (argv, definition, options = {}) => {
         }
         // Not inside the scheduled run itself: its own failure is already on its way to last.json.
         if (!flags.quiet && commandEnv[envName(definition.app, "SCHEDULED")] === undefined && path[0] !== "schedule") {
-            const notice = failingNoticeFor(definition.app, commandEnv);
+            const notice = failingNoticeFor(definition.app, commandEnv, program);
             if (notice)
                 streams.diagnostic(notice);
         }
@@ -450,10 +449,10 @@ const quietBrokenPipes = () => {
                 throw error;
         });
 };
-const failingNoticeFor = (app, env) => {
+const failingNoticeFor = (app, env, program) => {
     try {
         const state = resolvePaths({ appName: app.appName, prefix: app.envPrefix, env }).state;
-        return failingNotice(app.command, scheduledRuns(state), `${app.command} schedule list`);
+        return failingNotice(app.command, scheduledRuns(state), lineOf(program, "schedule list"));
     }
     catch {
         return undefined;
@@ -572,6 +571,7 @@ const failed = ({ app }, program, rest, error, settled, debug) => {
     return {
         object,
         cli: app.command,
+        program,
         ...(debug
             ? { record: errorRecordOf(failure, object, { command, service: app.command, version: app.version }) }
             : {}),
@@ -581,12 +581,13 @@ const failed = ({ app }, program, rest, error, settled, debug) => {
  * **A failure never reaches stdout.** It goes to stderr — as JSON when nobody is watching, because
  * an exit code says which kind of thing went wrong and nothing about which chat or how long to wait.
  */
-const report = (streams, options, { object, record, cli }) => {
+const report = (streams, options, { object, record, cli, program }) => {
     if (options.agent) {
         options.agent.failure(object);
         return exitCodeOfError(object);
     }
     const interactive = options.tty ?? process.stdout.isTTY === true;
-    streams.diagnostic(renderError(object, { cli, interactive, ...(record ? { record } : {}) }));
-    return exitCodeOfError(object);
+    const lined = object.error.next ? { error: { ...object.error, next: withLines(program, object.error.next) } } : object;
+    streams.diagnostic(renderError(lined, { cli, interactive, ...(record ? { record } : {}) }));
+    return exitCodeOfError(lined);
 };

package/dist/cli/runs/command.js

@@ -6,6 +6,7 @@ import { environmentOf, outputFor } from "../context.js";
 import { LOCAL_READ, NO_EFFECTS } from "../effects.js";
 import { itemOf, listOf, renderAnswer, snakeKeys } from "../envelope.js";
 import { positiveCount } from "../paging.js";
+import { lineOf } from "../steps.js";
 import { runsFound, searchRuns } from "./search.js";
 /** Reading the log is not itself worth recording, so **nothing here starts a run**. */
 export const runsCommand = (app) => {
@@ -14,7 +15,7 @@ export const runsCommand = (app) => {
     const runOrRefuse = (from, id) => {
         const found = findRun(dir(from), id);
         if (!found)
-            throw new CliError("not_found", `no recorded run "${id}" — \`${app.command} runs list\` shows them`);
+            throw new CliError("not_found", `no recorded run "${id}" — \`${lineOf(from, "runs list")}\` shows them`);
         return found;
     };
     annotate(command.command("list"), { effects: LOCAL_READ, mcp: false })
@@ -50,7 +51,7 @@ export const runsCommand = (app) => {
             events: shown,
         }));
         if (shown.length < events.length)
-            renderer.note(`${events.length - shown.length} other events — \`${app.command} runs show ${id}\` shows them all`);
+            renderer.note(`${events.length - shown.length} other events — \`${lineOf(this, `runs show ${id}`)}\` shows them all`);
     });
     annotate(command.command("search"), { effects: LOCAL_READ })
         .description("search recorded diagnostic metadata and events; no message contents")

package/dist/cli/steps.d.ts

@@ -20,6 +20,8 @@ export declare const STEPS: ({
 })[];
 /** A step from its registered definition; an argument left undefined is left out, as the command line would. */
 export declare const nextStep: (id: string, input: StepInput) => NextStep;
+/** `typedCommand` with the profile this command line named, else the run's. */
+export declare const lineOf: (command: Command, words: string) => string;
 export declare const rootOf: (command: Command) => Command;
 /** The command a path names in this program, or nothing when this CLI does not have it. */
 export declare const commandAt: (root: Command, path: string) => Command | undefined;
@@ -35,6 +37,8 @@ type Targets = NonNullable<StepInput["targets"]>;
 export declare const runnable: (root: Command, steps: readonly NextStep[] | undefined) => NextStep[];
 /** Each command step judged by its command's effects: safe to run unasked only when it writes nothing remotely. */
 export declare const withSafety: (steps: readonly NextStep[], targets: Targets) => NextStep[];
+/** Each command step with `line`, the whole command to type — only the CLI knows the profile, so MCP gets none. */
+export declare const withLines: (root: Command, steps: readonly NextStep[]) => NextStep[];
 /**
  * The step as a person types it: the profile the command ran with, positional arguments in their place, then the
  * options. A CLI that assumes no profile refuses the line without it.

package/dist/cli/steps.js

@@ -1,4 +1,5 @@
 import { STEPS as BASE_STEPS, defineSteps, MAX_NEXT_STEPS, stepOf, writes, } from "@wirecat/cli-base/standards";
+import { typedCommand } from "../runs/scope.js";
 import { judgedTargets } from "./effects.js";
 /**
  * Every step an answer or an error may name. A step's command must exist in tg and max alike, and its
@@ -211,6 +212,12 @@ export const nextStep = (id, input) => {
     const args = Object.fromEntries(Object.entries(input.args ?? {}).filter(([, value]) => value !== undefined));
     return stepOf(definition, { ...input, args });
 };
+/** `typedCommand` with the profile this command line named, else the run's. */
+export const lineOf = (command, words) => {
+    const root = rootOf(command);
+    const profile = root.getOptionValue("profile");
+    return typedCommand(root.name(), words, typeof profile === "string" && profile !== "" ? profile : undefined);
+};
 export const rootOf = (command) => {
     let root = command;
     while (root.parent)
@@ -239,6 +246,8 @@ export const withSafety = (steps, targets) => steps.map((step) => {
     const effects = targets(step.command)?.effects;
     return { ...step, safe_to_auto_execute: effects !== undefined && !writes(effects) };
 });
+/** Each command step with `line`, the whole command to type — only the CLI knows the profile, so MCP gets none. */
+export const withLines = (root, steps) => steps.map((step) => (step.kind === "command" ? { ...step, line: stepLine(root, step) } : step));
 const kebab = (name) => name.replaceAll("_", "-");
 const quoted = (value) => {
     const text = String(value);

package/dist/cli/store-settings.js

@@ -2,6 +2,7 @@ import { existsSync } from "node:fs";
 import { CliError } from "@wirecat/cli-base";
 import { DEFAULT_PHONE_COUNTRIES, parsePhoneCountries } from "../domain/phones.js";
 import { DEFAULT_TASK_CATEGORIES, taskCategoryValue, unlistedNote, withTaskCategory, } from "../domain/task-categories.js";
+import { typedCommand } from "../runs/scope.js";
 import { ACCOUNT_GROUPS_SETTING, groupMembers, groupName } from "../search/account-list.js";
 import { DEFAULT_STEMMERS, parseStemmers } from "../search/stem.js";
 import { openCache } from "../store/open.js";
@@ -82,7 +83,7 @@ const changePhoneCountries = async (app, env, value) => {
             value: (countries ?? DEFAULT_PHONE_COUNTRIES).join(","),
         },
         note: "store-wide — a number written without + is read in these countries, the first that fits; numbers already " +
-            `found keep their old reading until \`${app.command} mentions rebuild phone\``,
+            `found keep their old reading until \`${typedCommand(app.command, "mentions rebuild phone")}\``,
         rebuild: true,
     };
 };
@@ -150,7 +151,7 @@ const changeFirstPass = async (app, env, value) => {
         return {
             result: { store: storePath(env), scope: "store", setting: FIRST_PASS, value: now },
             note: `store-wide — an account's first sync opens at most ${now} task(s) per chat from history; later syncs read ` +
-                `only new messages. \`${app.command} tasks scan <chat>\` builds tasks from a chat's history when asked`,
+                `only new messages. \`${typedCommand(app.command, "tasks scan <chat>")}\` builds tasks from a chat's history when asked`,
         };
     }
     finally {
@@ -199,7 +200,7 @@ const changeGroup = async (app, env, setting, value) => {
         return {
             result: { store: storePath(env), scope: "store", setting, value: members ?? null },
             note: `store-wide — \`--source group:${name}\` searches these accounts from every app; ` +
-                `a profile is found once its app has saved something (\`${app.command} config show\`)`,
+                `a profile is found once its app has saved something (\`${typedCommand(app.command, "config show")}\`)`,
         };
     }
     finally {

package/dist/domain/models.d.ts

@@ -25,7 +25,10 @@ export interface Chat {
     id: Id;
     title: string | null;
     kind: ChatKind;
-    /** `null` means the provider did not say, which is not the same as zero. */
+    /**
+     * `null` means the provider did not say, which is not the same as zero. A save that does not know it leaves it
+     * out.
+     */
     unreadCount: number | null;
     /** ISO 8601, or `null` when the chat has never had a message. */
     lastMessageAt: string | null;
@@ -43,6 +46,13 @@ export interface Chat {
      */
     providerMetadata?: ProviderMetadata;
 }
+/**
+ * A chat as an adapter saves it. A `title`, `unreadCount`, `lastMessageAt` or `participantsCount` left out keeps the
+ * stored value; `null` stores none. So a push that knows only some of them, such as a notice that a group left its
+ * community, leaves the rest out.
+ */
+export type ChatUpdate = Omit<Chat, KeptFields> & Partial<Pick<Chat, KeptFields>>;
+type KeptFields = "title" | "unreadCount" | "lastMessageAt" | "participantsCount";
 /** A group's switches; `null` where the messenger does not say, or has no such switch. */
 export interface GroupSettings {
     allCanPin: boolean | null;

package/dist/kit/contract.d.ts

@@ -16,13 +16,13 @@ export interface ContractOptions {
     ids?: IdMaker;
     /** As the messenger's `fetching.orderBy`: whether `history`'s `before` is a message id or an ISO time. */
     orderBy?: "id" | "time";
-    /** How long `watch` may take to say it listens, and `watch`, `listen` and `feed` to end once aborted. */
+    /** How long `watch` may take to say it listens, and `watch`, `listen`, `listenHistory` and `feed` to end on abort. */
     waitMs?: number;
     /** As the messenger's `history`: a `"server"` messenger's adapter must have every `ServerReads` method. */
     history?: "server" | "store";
 }
 /** Every method of the optional groups, which `capability` hands over or refuses. */
-export declare const OPTIONAL_METHODS: readonly ["fetchCounters", "chats", "history", "around", "contact", "historyAfter", "historyBefore", "topics", "inspect", "edit", "forward", "delete", "pin", "unpin", "star", "react", "markRead", "markTopicRead", "poll", "vote", "closePoll", "createPoll", "watch", "listen", "feed", "download", "transcribe", "scheduled", "members", "admins", "chatEvents", "sessions", "lookup", "addressBook", "people", "createGroup", "join", "leave", "group", "updateGroup", "resetInviteLink", "addMembers", "removeMembers", "addAdmin", "removeAdmin", "folders", "createFolder", "updateFolder", "deleteFolder", "addContact", "removeContact", "block", "unblock", "renameContact", "importContacts", "updateProfile", "endOtherSessions"];
+export declare const OPTIONAL_METHODS: readonly ["fetchCounters", "chats", "history", "around", "contact", "historyAfter", "historyBefore", "topics", "inspect", "edit", "forward", "delete", "pin", "unpin", "star", "react", "markRead", "markTopicRead", "poll", "vote", "closePoll", "createPoll", "watch", "listen", "listenHistory", "feed", "download", "transcribe", "scheduled", "members", "admins", "chatEvents", "sessions", "lookup", "addressBook", "people", "createGroup", "join", "leave", "group", "updateGroup", "resetInviteLink", "addMembers", "removeMembers", "addAdmin", "removeAdmin", "folders", "createFolder", "updateFolder", "deleteFolder", "addContact", "removeContact", "block", "unblock", "renameContact", "importContacts", "updateProfile", "endOtherSessions"];
 /**
  * The port's promises as cases any test runner can run: each connects through `connect`, checks
  * with `node:assert/strict` and closes the adapter. None needs a live service.

package/dist/kit/contract.js

@@ -29,6 +29,7 @@ export const OPTIONAL_METHODS = [
     "createPoll",
     "watch",
     "listen",
+    "listenHistory",
     "feed",
     "download",
     "transcribe",
@@ -430,6 +431,30 @@ export const contractCases = ({ connect, ids = wordIds, orderBy = "id", waitMs =
                     await within(listening, "listen did not end when the signal aborted", waitMs);
                 },
             ],
+            [
+                "listenHistory on a signal already aborted resolves at once and does not reject",
+                async (adapter) => {
+                    const skipped = lacking(adapter, "listenHistory");
+                    if (skipped)
+                        return skipped;
+                    const controller = new AbortController();
+                    controller.abort();
+                    await within(Promise.resolve(adapter.listenHistory?.(() => { }, controller.signal)), "listenHistory did not resolve on a signal already aborted", waitMs);
+                },
+            ],
+            [
+                "listenHistory keeps listening until the signal aborts, then resolves",
+                async (adapter) => {
+                    const skipped = lacking(adapter, "listenHistory");
+                    if (skipped)
+                        return skipped;
+                    const controller = new AbortController();
+                    const listening = Promise.resolve(adapter.listenHistory?.(() => { }, controller.signal));
+                    assert.equal(await settledSoon(listening), false, "listenHistory ended before the signal aborted");
+                    controller.abort();
+                    await within(listening, "listenHistory did not end when the signal aborted", waitMs);
+                },
+            ],
             [
                 "feed pushes only the seed's chats and messages, with ids as strings, and ends when the signal aborts",
                 async (adapter, seed) => {

package/dist/kit/fake.d.ts

@@ -5,4 +5,5 @@ export type FakeAdapter = MessengerCore & ServerReads & ChatReading & MessageEdi
 export declare const fakeAdapter: (seed?: Seed, options?: {
     feed?: boolean;
     listen?: boolean;
+    listenHistory?: boolean;
 }) => FakeAdapter;

package/dist/kit/fake.js

@@ -28,7 +28,8 @@ const missing = (what) => new CliError("not_found", `the fake adapter has no ${w
  *
  * With `{ feed: true }` it also pushes its history, as a messenger with `history: "store"` does:
  * the chats and people in one batch, then each chat's messages in a batch of their own.
- * With `{ listen: true }` it also has `listen`, which hands on what `watch` does.
+ * With `{ listen: true }` it also has `listen`, which hands on what `watch` does, and with `{ listenHistory: true }`
+ * `listenHistory`, which hands on what `feed` does.
  */
 const withRules = (folder, { emoji, include, skip, exclude, pin }) => {
     if (emoji !== undefined)
@@ -57,6 +58,17 @@ export const fakeAdapter = (seed = contractSeed(), options = {}) => {
     const folders = [];
     const listeners = new Set();
     let counter = 0;
+    const pushHistory = async (onBatch, signal) => {
+        if (signal.aborted)
+            return;
+        onBatch({ chats: structuredClone(state.chats), people: state.people.map(asMember) });
+        for (const chat of state.chats) {
+            const messages = messagesOf(chat.id);
+            if (messages.length > 0)
+                onBatch({ messages: structuredClone(messages) });
+        }
+        await new Promise((resolve) => signal.addEventListener("abort", () => resolve(), { once: true }));
+    };
     const ownId = () => {
         if (!account)
             throw new CliError("authentication_error", "the fake adapter is not logged in");
@@ -323,21 +335,8 @@ export const fakeAdapter = (seed = contractSeed(), options = {}) => {
                 },
             }
             : {}),
-        ...(options.feed
-            ? {
-                feed: async (onBatch, signal) => {
-                    if (signal.aborted)
-                        return;
-                    onBatch({ chats: structuredClone(state.chats), people: state.people.map(asMember) });
-                    for (const chat of state.chats) {
-                        const messages = messagesOf(chat.id);
-                        if (messages.length > 0)
-                            onBatch({ messages: structuredClone(messages) });
-                    }
-                    await new Promise((resolve) => signal.addEventListener("abort", () => resolve(), { once: true }));
-                },
-            }
-            : {}),
+        ...(options.feed ? { feed: pushHistory } : {}),
+        ...(options.listenHistory ? { listenHistory: pushHistory } : {}),
         download: async (reference, messageId) => {
             const message = messageOf(chatOf(reference).id, messageId);
             return {

package/dist/mcp/meeting-preparation.d.ts

@@ -42,6 +42,7 @@ export declare const callMeetingPreparationTool: (read: MeetingPreparationReader
                 args: {
                     [x: string]: unknown;
                 };
+                line?: string | undefined;
                 why: string;
                 safe_to_auto_execute: boolean;
             } | {

package/dist/mcp/meeting-project-candidates.d.ts

@@ -37,6 +37,7 @@ export declare const callMeetingProjectCandidatesTool: (read: StoredMeetingProje
                 args: {
                     [x: string]: unknown;
                 };
+                line?: string | undefined;
                 why: string;
                 safe_to_auto_execute: boolean;
             } | {

package/dist/mcp/meeting-series-inventory.d.ts

@@ -37,6 +37,7 @@ export declare const callMeetingSeriesInventoryTool: (read: MeetingSeriesInvento
                 args: {
                     [x: string]: unknown;
                 };
+                line?: string | undefined;
                 why: string;
                 safe_to_auto_execute: boolean;
             } | {

package/dist/mcp/tool.js

@@ -116,10 +116,12 @@ export const entryRunner = (registration) => {
                 ...(traceId === undefined ? {} : { traceId }),
             })
             : undefined;
+        const profile = registration.defaults.settings.profile;
         const scope = {
             runId: recording?.runId ?? newRunId(new Date(startedAt), command),
             command,
             startedAt,
+            ...(profile === undefined ? {} : { profile }),
             ...(traceId === undefined ? {} : { traceId }),
         };
         const result = await inRun(scope, () => {

package/dist/mcp/tools/messages-photo.js

@@ -3,6 +3,7 @@ import * as v from "valibot";
 import { itemOf } from "../../cli/envelope.js";
 import { keepRefreshedRefs } from "../../cli/messenger/refreshed-refs.js";
 import { capability } from "../../ports/messenger.js";
+import { typedCommand } from "../../runs/scope.js";
 import { chatOf, message, Picture, READ, tool } from "../tool.js";
 /** Larger than this and a client may refuse the answer, or spend the model's context on one picture. */
 export const PHOTO_LIMIT = 512 * 1024;
@@ -26,7 +27,7 @@ export const messagesPhotoTools = (messenger) => ({
         annotations: READ,
         online: async (adapter, args, defaults) => {
             const { id: chatId } = await adapter.resolve(args.chat);
-            const saveIt = `the owner can save it with \`${messenger.app.command} messages download ${chatId} ${args.message}\``;
+            const saveIt = `the owner can save it with \`${typedCommand(messenger.app.command, `messages download ${chatId} ${args.message}`)}\``;
             const { files } = await capability(adapter, "download", "download attachments")(chatId, args.message);
             const photo = args.index === undefined ? files.find((file) => file.kind === "photo") : files[args.index];
             if (!photo) {

package/dist/meetings/mcp/passage.d.ts

@@ -71,6 +71,7 @@ export declare const callMeetingPassageTool: (read: MeetingPassageReader, input:
                 args: {
                     [x: string]: unknown;
                 };
+                line?: string | undefined;
                 why: string;
                 safe_to_auto_execute: boolean;
             } | {

package/dist/meetings/mcp/project-evidence.d.ts

@@ -65,6 +65,7 @@ export declare const callMeetingProjectEvidenceTool: (read: MeetingProjectDiscov
                 args: {
                     [x: string]: unknown;
                 };
+                line?: string | undefined;
                 why: string;
                 safe_to_auto_execute: boolean;
             } | {

package/dist/meetings/mcp/search.d.ts

@@ -107,6 +107,7 @@ export declare const callMeetingSearchTool: (search: MeetingHitSearch, input: un
                 args: {
                     [x: string]: unknown;
                 };
+                line?: string | undefined;
                 why: string;
                 safe_to_auto_execute: boolean;
             } | {

package/dist/meetings/reads.d.ts

@@ -51,6 +51,7 @@ export declare const meetingPeople: (store: MeetingStore & Partial<MeetingPartic
         args: {
             [x: string]: unknown;
         };
+        line?: string | undefined;
         why: string;
         safe_to_auto_execute: boolean;
     } | {

package/dist/ports/messenger.d.ts

@@ -3,7 +3,7 @@ import type { CounterField, CounterObservations } from "../domain/counters.js";
 import type { HtmlFormatting, MarkdownFormatting, TextSpan } from "../domain/formatting.js";
 import type { Markup } from "../domain/markdown.js";
 import type { MessagePermalink } from "../domain/message-link.js";
-import type { Account, AccountSession, AdminRight, Button, CallRecord, Chat, ChatCard, ChatEvent, ChatEvents, Discussion, Folder, FolderChange, FolderRules, GroupCard, GroupChange, GroupMember, Id, InviteLink, InviteLinkChange, JoinRequest, LinkTarget, MediaKind, Member, Message, MessageEvent, MessageHit, OfficialChatStats, Page, PersonCard, PhoneBookEntry, Poll, PollVote, PrivacySettings, ProfileFacts, ProviderMetadata, SenderIdentity, Sticker, StickerSet, Topic, TopicChange, WindowedMessage } from "../domain/models.js";
+import type { Account, AccountSession, AdminRight, Button, CallRecord, Chat, ChatCard, ChatEvent, ChatEvents, ChatUpdate, Discussion, Folder, FolderChange, FolderRules, GroupCard, GroupChange, GroupMember, Id, InviteLink, InviteLinkChange, JoinRequest, LinkTarget, MediaKind, Member, Message, MessageEvent, MessageHit, OfficialChatStats, Page, PersonCard, PhoneBookEntry, Poll, PollVote, PrivacySettings, ProfileFacts, ProviderMetadata, SenderIdentity, Sticker, StickerSet, Topic, TopicChange, WindowedMessage } from "../domain/models.js";
 /** One attachment's bytes, fetched over the adapter's connection when `bytes` is read — so read it before the command closes. */
 export interface RemoteFile {
     kind: string;
@@ -316,6 +316,14 @@ export interface PassiveUpdates {
      * be handed on.
      */
     listen(onEvent: (event: MessageEvent) => void, signal: AbortSignal): Promise<void>;
+    /**
+     * What the open connection is pushed of the messenger's history, as `feed` hands it, until `signal` aborts — on
+     * the same connections as `listen`, under the same rules: it never connects or waits for the connection, and
+     * resolves once nothing more will be handed on. A messenger that pushes history once (`history: "store"`) then
+     * has it saved by a command that never feeds. Optional within the group, so an adapter typed as having
+     * `PassiveUpdates` before it existed still is one.
+     */
+    listenHistory?(onBatch: (batch: HistoryBatch) => void, signal: AbortSignal): Promise<void>;
 }
 /** One voter's vote in the poll message `messageId` of `chatId` carries, as `PollVoteEvent` has it. */
 export interface HistoryVote {
@@ -346,7 +354,7 @@ export interface HistoryBatch {
         from: Id;
         to: Id;
     }[];
-    chats?: Chat[];
+    chats?: ChatUpdate[];
     people?: Member[];
     messages?: Message[];
     votes?: HistoryVote[];

package/dist/runs/recording.js

@@ -19,6 +19,7 @@ export const recorded = async (options, body) => {
             runId: recording.runId,
             command: options.command,
             startedAt: Date.now(),
+            profile: options.profile,
             ...(recording.traceId ? { traceId: recording.traceId } : {}),
         }, () => body(recording.events));
         await recording.succeed(answer);

package/dist/runs/scope.d.ts

@@ -5,6 +5,8 @@ export interface RunScope {
     startedAt?: number;
     /** The caller's trace — an MCP client's `_meta.traceparent`, or `TRACEPARENT` from whatever started this process. */
     traceId?: string;
+    /** The profile the run is for, so a hint deep in a service can name the command with it. */
+    profile?: string;
 }
 /**
  * The run a log line written now belongs to, for a writer that is not handed one — the send journal,
@@ -12,6 +14,11 @@ export interface RunScope {
  */
 export declare const currentRun: () => RunScope;
 export declare const inRun: <T>(scope: RunScope, body: () => T) => T;
+/**
+ * A command as a person types it: `max personal store migrate`. A hint without the profile fails when copied,
+ * since no profile is assumed; outside a run with a profile it stays `max store migrate`.
+ */
+export declare const typedCommand: (tool: string, words: string, profile?: string | undefined) => string;
 /**
  * For a one-shot command whose action runs outside `inRun` — max's `max bot`, recorded from commander's hooks, which
  * cannot wrap the action — so its answers' `meta.run_id` names the run `runs show` finds. Never in a server.

package/dist/runs/scope.js

@@ -21,6 +21,11 @@ export const currentRun = () => {
     return processScope;
 };
 export const inRun = (scope, body) => scopes.run(scope, body);
+/**
+ * A command as a person types it: `max personal store migrate`. A hint without the profile fails when copied,
+ * since no profile is assumed; outside a run with a profile it stays `max store migrate`.
+ */
+export const typedCommand = (tool, words, profile = currentRun().profile) => [tool, profile, words].filter((part) => part !== undefined && part !== "").join(" ");
 /**
  * For a one-shot command whose action runs outside `inRun` — max's `max bot`, recorded from commander's hooks, which
  * cannot wrap the action — so its answers' `meta.run_id` names the run `runs show` finds. Never in a server.

package/dist/services/archive.js

@@ -1,6 +1,7 @@
 import { setTimeout as sleep } from "node:timers/promises";
 import { CliError } from "@wirecat/cli-base";
 import { capability } from "../ports/messenger.js";
+import { typedCommand } from "../runs/scope.js";
 import { fetchedKey, historyStartKey, } from "../store/store.js";
 import { estimateBackfill } from "./backfill-estimate.js";
 import { actionable, batchProgress } from "./batch.js";
@@ -11,7 +12,7 @@ import { catchUpSearch, validateCatchUp } from "./search-catchup.js";
 const pushed = (deps, what) => {
     if (deps.reads === "store") {
         throw new CliError("validation_error", `${what} asks for older history, and this messenger pushes its history instead — keep ` +
-            `\`${deps.messenger.app.command} serve\` running`);
+            `\`${typedCommand(deps.messenger.app.command, "serve")}\` running`);
     }
 };
 /** The most messages a provider hands out per history request — Telegram's cap. */