@wirecat/cli-core 0.409.0 → 0.411.0

package/CHANGELOG.md

@@ -5,6 +5,53 @@ Notable changes to `@wirecat/cli-core` (`@wirecat/cli-messaging` up to 0.261.0,
 minor version may break callers, and says how under "Changed — may break callers". `pnpm docs:check` checks the
 shape of this file.
 
+
+## 0.411.0 — 24.10.2026
+
+### Added
+
+- **Stored events accept native queries on id, origin and timestamps.** SQLite applies filters before returning rows; stores without query support refuse a filtered request.
+- **Shared task updates include project priority and parent.** Project tasks can be updated without choosing a messenger account.
+
+- **`commands info --json` exports schemas, declared error reasons and explicit contract overrides.** Providers with
+  their own program shell use `addContractInfo`; field-only declarations are labelled separately from typed schemas.
+- **Provider model catalogues share `modelCatalogueCommand`.** Providers choose supported kinds and bind output,
+  environment and offline policy; native query filtering, model receipts and verified downloads stay in core.
+
+
+### Changed — may break callers
+
+- **Contact activity and diagnostic run times filter through native queries.** Use `contacts events <person> scope:work 'at:[2026-10-01 TO 2026-10-31]'` and `search runs 'started_at>=7d'` instead of their time/scope flags. Time bounds reach the native readers before pagination, and continuations preserve the query.
+- **Webhook setup adds another address with `--append`.** `--add <chat>` keeps its folder-edit meaning. Webhook answers omit an unrestricted or unknown type list instead of emitting `types: null`.
+
+- **Unknown chat rosters are omitted instead of returned as `members: null`.** An empty array means a known empty roster. Send-attempt output exposes only `operation_id`; legacy journal entries remain readable.
+- **Stored meeting topic labels use `--topic-name`.** `--topic` remains the messenger forum-topic id. Update meeting-search invocations and continuations to the unambiguous name.
+
+- **Core-owned command contracts reject silent edits after construction.** Use `overrideSharedContract` with a
+  specific reason and a callback before modifying an inherited definition. Exact before/after values remain visible
+  in contract discovery. Independent shell replacements pin static, reviewed declarations, so new Core defaults cannot be silently omitted. Provider-only commands may extend groups; inherited leaves retain their contracts.
+
+## 0.410.0 — 24.10.2026
+
+### Added
+
+- `buildDoctorReport`, `doctorReportFileName` and their report types are public through `/cli`.
+  Consumers can reuse run selection, identifier labelling and home-path redaction while retaining
+  typed diagnostic payloads and optional technical context. Existing reports keep their shape
+  when context is omitted. `eventFields: "recorded"` retains allowlisted recorded technical
+  fields for consumers that already include them; the default report projection is unchanged.
+
+### Fixed
+
+- **Meeting search continuation arguments match the generated MCP schema.** Stored numeric selector IDs are
+  serialized as strings in replay arguments, so an agent can pass the returned next step to the shared read tool
+  without converting IDs. Validated search requests still use numeric store IDs.
+
+- Media archives skip call events alongside service events and keyboards. A message containing
+  both a file and a call event now archives the file and verifies its checksum; call-only
+  messages make no download request. Unknown attachment kinds still fail rather than being
+  silently dropped.
+
 ## 0.409.0 — 24.10.2026
 
 ### Added

package/dist/cli/bot/command.js

@@ -105,6 +105,7 @@ const authCommand = (bot, tokenVariable) => {
     return auth;
 };
 const meCommand = (bot) => annotate(new Command("me"), { effects: REMOTE_READ, examples: botExamples(bot, "me") })
+    .summary("the bot this profile's token belongs to")
     .description("the bot this profile's token belongs to: id, name and username")
     .action(async function () {
     const context = online(botContext(this, bot), this);

package/dist/cli/bot/port.d.ts

@@ -267,7 +267,7 @@ export interface BotMessenger {
     name?: string;
     /** The admin rights `--can` offers; every shared one when unset. */
     adminRights?: readonly AdminRight[];
-    /** Whether `bot webhooks set --add` keeps the other addresses; a messenger with one address has no `--add`. */
+    /** Whether `bot webhooks set --append` keeps the other addresses; a messenger with one address has no `--add`. */
     manyWebhooks?: boolean;
     /** Secrets beside the token, each set with `bot auth set --secret <name>`; none when unset. */
     secrets?: readonly BotSecret[];

package/dist/cli/bot/setup.js

@@ -121,7 +121,10 @@ export const botWebhooksCommand = (bot) => {
         const context = online(botContext(this, bot), this);
         await context.run(async (events) => {
             const adapter = await context.authenticated({ events });
-            renderAnswer(this, context, wholeList("bot webhooks list", (await botCan(adapter, "webhooks", bot, "list its webhooks")()).map(snakeKeys)));
+            renderAnswer(this, context, wholeList("bot webhooks list", (await botCan(adapter, "webhooks", bot, "list its webhooks")()).map(({ url, types }) => ({
+                url,
+                ...(types == null ? {} : { types }),
+            }))));
         });
     });
     const set = annotate(command.command("set"), {
@@ -133,7 +136,7 @@ export const botWebhooksCommand = (bot) => {
         .option("--types <types>", "only these update types, comma-separated, in the messenger's words")
         .option("--secret-stdin", "a secret the messenger sends back with each update — asked for, or read from a pipe");
     if (bot.manyWebhooks)
-        set.option("--add", "keep the webhooks already set and add this one beside them");
+        set.option("--append", "keep the webhooks already set and add this one beside them");
     set.action(async function (url) {
         const context = online(botContext(this, bot), this);
         const options = this.opts();
@@ -141,10 +144,10 @@ export const botWebhooksCommand = (bot) => {
             const adapter = await context.authenticated({ events });
             const list = botCan(adapter, "webhooks", bot, "list its webhooks");
             const others = (await list()).filter((one) => one.url !== url);
-            if (others.length > 0 && !options.add) {
+            if (others.length > 0 && !options.append) {
                 throw new CliError("confirmation_required", `this bot already sends its updates to ${others.map((one) => one.url).join(", ")} — ` +
                     `remove it first with \`${context.words} webhooks delete <url>\`` +
-                    (bot.manyWebhooks ? ", or give --add to get every update at both" : ""));
+                    (bot.manyWebhooks ? ", or give --append to get every update at both" : ""));
             }
             const types = typesOf(options.types);
             const setWebhook = botCan(adapter, "setWebhook", bot, "set a webhook");
@@ -170,7 +173,10 @@ export const botWebhooksCommand = (bot) => {
             const adapter = await context.authenticated({ events });
             const remove = botCan(adapter, "deleteWebhook", bot, "delete a webhook");
             await botWrite(context, "bot.webhooks.delete", () => remove(url));
-            renderAnswer(this, context, wholeList("bot webhooks list", (await botCan(adapter, "webhooks", bot, "list its webhooks")()).map(snakeKeys)));
+            renderAnswer(this, context, wholeList("bot webhooks list", (await botCan(adapter, "webhooks", bot, "list its webhooks")()).map(({ url, types }) => ({
+                url,
+                ...(types == null ? {} : { types }),
+            }))));
         });
     });
     return command;

package/dist/cli/commands-command.js

@@ -4,6 +4,8 @@ import { CRASH_CODE } from "@wirecat/cli-base/standards";
 import { Command } from "commander";
 import { commandContract, commandPathOf, findCommand } from "./command-contract.js";
 import { environmentOf, outputFor } from "./context.js";
+import { contractEvidence } from "./contract-evidence.js";
+import { DISCOVERY_DESCRIPTIONS } from "./discovery-descriptions.js";
 import { NO_EFFECTS } from "./effects.js";
 import { renderDocument } from "./envelope.js";
 import { commandsText } from "./help/commands-text.js";
@@ -19,7 +21,7 @@ export const CONTRACT = 3;
  */
 export const commandsCommand = (app) => {
     const command = annotate(new Command("commands"), { effects: NO_EFFECTS })
-        .description("every command by section, one line each; --json: the contract, one path per call")
+        .description(DISCOVERY_DESCRIPTIONS.commands)
         .hook("preAction", (_command, action) => {
         if (action.optsWithGlobals().jsonl)
             throw new CliError("validation_error", "command discovery is one JSON object — use --json", {
@@ -59,22 +61,26 @@ export const commandsCommand = (app) => {
         effects: NO_EFFECTS,
         examples: [`${app.command} commands info messages list`],
     })
-        .description("one command's argv and result schemas, effects, permissions and retry guidance")
-        .argument("<path...>", "one command path, for example: stats messages show")
+        .description(DISCOVERY_DESCRIPTIONS.info)
+        .argument("[path...]", "one command path; without one, export schemas, error reasons and explicit overrides")
         .action(function (path) {
         renderDocument(outputFor(this), {
             cli: app.command,
             version: app.version,
             contract: CONTRACT,
-            ...commandContract(findCommand(rootOf(this), path)),
-            ...(() => {
-                const found = findCommand(rootOf(this), path);
-                const availability = environmentOf(this).discoveryAvailability?.({
-                    ...metaOf(found),
-                    path: commandPathOf(found),
-                });
-                return availability ? { availability } : {};
-            })(),
+            ...(path.length
+                ? {
+                    ...commandContract(findCommand(rootOf(this), path)),
+                    ...(() => {
+                        const found = findCommand(rootOf(this), path);
+                        const availability = environmentOf(this).discoveryAvailability?.({
+                            ...metaOf(found),
+                            path: commandPathOf(found),
+                        });
+                        return availability ? { availability } : {};
+                    })(),
+                }
+                : contractEvidence(rootOf(this), app.errors ? { errors: app.errors } : {})),
         });
     }));
     return command;

package/dist/cli/contract-evidence.d.ts

@@ -0,0 +1,26 @@
+import type { Command } from "commander";
+import { type AppErrors } from "../errors/reasons.js";
+import type { JsonFieldsResolver } from "./json-fields.js";
+export interface ContractEvidenceOptions {
+    fields?: JsonFieldsResolver;
+    errors?: AppErrors;
+}
+export declare const contractEvidence: (root: Command, { fields, errors }?: ContractEvidenceOptions) => {
+    schemas: {
+        [k: string]: {
+            $schema: string;
+        };
+    };
+    contracts: Record<string, unknown>;
+    field_only: string[];
+    reasons: readonly {
+        reason: string;
+        code: "authentication_error" | "cancelled" | "configuration_error" | "confirmation_required" | "internal_error" | "invalid_response" | "network_error" | "not_found" | "outcome_unknown" | "permission_error" | "provider_error" | "provider_unavailable" | "rate_limited" | "timeout" | "validation_error";
+        message: string;
+        details: string[];
+        step?: string | undefined;
+    }[] | undefined;
+    overrides: import("@wirecat/cli-base/commands").SharedContractOverride[];
+};
+/** Same discovery endpoint for the shared runner and providers with their own output/context adapters. */
+export declare const addContractInfo: (root: Command, output: (value: unknown) => void, options?: ContractEvidenceOptions) => Command;

package/dist/cli/contract-evidence.js

@@ -0,0 +1,58 @@
+import { CliError } from "@wirecat/cli-base";
+import { annotate, describeProgram, flatten } from "@wirecat/cli-base/commands";
+import { jsonSchemaOf } from "@wirecat/cli-base/standards";
+import { entityDefinitions } from "../entities/index.js";
+import { failureContext } from "../errors/reasons.js";
+import { answerEntitySchema } from "./answer-entity.js";
+import { commandContract, findCommand, SCHEMA_DIALECT } from "./command-contract.js";
+import { DISCOVERY_DESCRIPTIONS } from "./discovery-descriptions.js";
+import { NO_EFFECTS } from "./effects.js";
+import { sharedContractOverrides, sharedContracts } from "./shared-contracts.js";
+export const contractEvidence = (root, { fields, errors } = {}) => {
+    const schemas = { ...entityDefinitions() };
+    const fieldOnly = [];
+    for (const info of flatten(describeProgram(root))) {
+        if (!info.output)
+            continue;
+        const name = info.output.view ? `${info.output.entity}.${info.output.view}` : info.output.entity;
+        const command = findCommand(root, info.path);
+        const schema = answerEntitySchema(command);
+        if (schema)
+            schemas[name] = jsonSchemaOf(schema);
+        else if (schemas[name] === undefined) {
+            const names = fields?.(command);
+            if (names) {
+                schemas[name] = {
+                    type: "object",
+                    properties: Object.fromEntries(names.map((name) => [name, {}])),
+                    additionalProperties: false,
+                };
+                fieldOnly.push(name);
+            }
+        }
+    }
+    return {
+        schemas: Object.fromEntries(Object.entries(schemas).map(([name, schema]) => [name, { $schema: SCHEMA_DIALECT, ...schema }])),
+        contracts: sharedContracts(root),
+        field_only: [...new Set(fieldOnly)].sort(),
+        reasons: failureContext(errors).reasons,
+        overrides: sharedContractOverrides(root),
+    };
+};
+/** Same discovery endpoint for the shared runner and providers with their own output/context adapters. */
+export const addContractInfo = (root, output, options = {}) => {
+    const commands = root.commands.find((command) => command.name() === "commands");
+    if (!commands)
+        throw new CliError("configuration_error", "contract discovery needs the commands group");
+    const info = commands.commands.find((command) => command.name() === "info") ?? commands.command("info");
+    annotate(info, { effects: NO_EFFECTS, examples: [`${root.name()} commands info --json`] });
+    if (info.registeredArguments.length === 0)
+        info.argument("[path...]", "one command path; without one, schemas, error reasons and explicit overrides");
+    if (!info.options.some((option) => option.long === "--json") &&
+        !root.options.some((option) => option.long === "--json"))
+        info.option("--json", "print JSON");
+    info
+        .description(DISCOVERY_DESCRIPTIONS.info)
+        .action((path) => output(path.length ? commandContract(findCommand(root, path)) : contractEvidence(root, options)));
+    return info;
+};

package/dist/cli/contract-templates.d.ts

@@ -0,0 +1,4 @@
+import { Command } from "commander";
+import type { AppIdentity } from "../ports/app.js";
+/** Construction-only defaults for a CLI that explicitly binds an independent source or transport. */
+export declare const sharedCommandTemplate: (app: AppIdentity, name: "commands" | "doctor" | "mcp" | "search" | "notes" | "session" | "setup" | "meetings") => Command;

package/dist/cli/contract-templates.js

@@ -0,0 +1,83 @@
+import { CliError } from "@wirecat/cli-base";
+import { annotate, sharedCommand } from "@wirecat/cli-base/commands";
+import { Command } from "commander";
+import { note } from "../entities/note.js";
+import { addMeetingCommands } from "../meetings/cli/index.js";
+import { commandsCommand } from "./commands-command.js";
+import { LOCAL_READ, LOCAL_WRITE, NO_EFFECTS, REMOTE_WRITE } from "./effects.js";
+import { unfilteredQuery, withQuery } from "./list-query.js";
+import { doctorCommand } from "./messenger/doctor-command.js";
+import { mcpCommand } from "./messenger/mcp-command.js";
+import { searchCommand } from "./messenger/search-command.js";
+import { settingsFor } from "./settings.js";
+/** Construction-only defaults for a CLI that explicitly binds an independent source or transport. */
+export const sharedCommandTemplate = (app, name) => {
+    const unavailable = () => {
+        throw new CliError("configuration_error", "a command contract template cannot execute");
+    };
+    const messenger = {
+        app,
+        provider: app.command,
+        chatArgument: "a stored chat id or name",
+        topics: false,
+        history: "store",
+        resolveSettings: settingsFor(app).resolveSettings,
+        connect: async () => unavailable(),
+    };
+    const command = sharedCommand(() => {
+        if (name === "commands")
+            return commandsCommand(app);
+        if (name === "doctor")
+            return doctorCommand(messenger);
+        if (name === "mcp")
+            return mcpCommand(messenger);
+        if (name === "search")
+            return searchCommand(messenger);
+        if (name === "meetings") {
+            const root = new Command(app.command);
+            addMeetingCommands(root, {
+                get store() {
+                    return unavailable();
+                },
+                accountId: 0,
+                write: unavailable,
+            });
+            const meetings = root.commands.find((command) => command.name() === "meetings");
+            if (!meetings)
+                return unavailable();
+            return meetings;
+        }
+        if (name === "setup")
+            return annotate(new Command("setup"), { effects: REMOTE_WRITE, lifetime: "interactive", mcp: false })
+                .description("set up the account and connect an agent")
+                .option("--agent <agent>", "install instructions for this agent")
+                .option("--method <method>", "login method");
+        if (name === "session") {
+            const session = annotate(new Command("session"), { effects: NO_EFFECTS, mcp: false }).description("link this account, or end its login");
+            annotate(session.command("start"), { effects: REMOTE_WRITE, lifetime: "interactive" })
+                .description("link this account")
+                .argument("[method]", "login method");
+            annotate(session.command("end"), { effects: REMOTE_WRITE }).description("end this account's login");
+            return session;
+        }
+        const notes = annotate(new Command("notes"), { effects: NO_EFFECTS }).description("notes kept in the shared store");
+        withQuery(annotate(notes.command("list"), { effects: LOCAL_READ, output: { entity: "note" } }).description("list stored notes"), unfilteredQuery("note", note));
+        annotate(notes.command("show"), { effects: LOCAL_READ, output: { entity: "note" } })
+            .description("show one note")
+            .argument("<note>", "stored note reference");
+        annotate(notes.command("add"), { effects: LOCAL_WRITE, output: { entity: "note" } })
+            .description("write a note")
+            .argument("<text>", "note text")
+            .option("--subject <ref>", "stored resource the note describes");
+        annotate(notes.command("edit"), { effects: LOCAL_WRITE, output: { entity: "note" } })
+            .description("change a note")
+            .argument("<note>", "stored note reference")
+            .argument("<text>", "replacement text");
+        annotate(notes.command("remove"), { effects: LOCAL_WRITE })
+            .description("remove a note")
+            .argument("<note>", "stored note reference");
+        return notes;
+    })();
+    command.hook("preAction", unavailable);
+    return command;
+};

package/dist/cli/discovery-descriptions.d.ts

@@ -0,0 +1,4 @@
+export declare const DISCOVERY_DESCRIPTIONS: Readonly<{
+    commands: "every command by section; --json prints its contract, one path per call";
+    info: "one command contract, or all schemas, error reasons and explicit overrides";
+}>;

package/dist/cli/discovery-descriptions.js

@@ -0,0 +1,4 @@
+export const DISCOVERY_DESCRIPTIONS = Object.freeze({
+    commands: "every command by section; --json prints its contract, one path per call",
+    info: "one command contract, or all schemas, error reasons and explicit overrides",
+});

package/dist/cli/index.d.ts

@@ -37,107 +37,74 @@ export { openRequestTask } from "../services/task-rules.js";
 export { TASK_PAIR_QUERY, TASK_QUERY } from "../services/tasks.js";
 export { type AgentPolicy, type AgentTask, type EvaluationResult, evaluateAgent, type Observation, } from "./agent-evaluation.js";
 export { answerEntity } from "./answer-entity.js";
-export { botAdminsCommand, botMembersCommand } from "./bot/admins.js";
-export { type ApiCommandInput, type ApiCommands, generatedApiCommand } from "./bot/api.js";
+export type { ApiCommandInput, ApiCommands } from "./bot/api.js";
 export { apiFlagOf, apiJson, apiOptionKey, apiPlainJson, checkApiBody, checkApiParameter, parseApiJson, readApiBody, } from "./bot/api-input.js";
 export { prepareRpcApiBody, type RpcApiBody } from "./bot/api-rpc.js";
-export { botCommand } from "./bot/command.js";
 export { type BotContext, botContext, botWords } from "./bot/context.js";
 export { type BotCopy, botCopy } from "./bot/copy.js";
-export { botMcpCommand } from "./bot/mcp.js";
-export { botCan, botIdOf, botMessagesCommand } from "./bot/messages.js";
+export { botCan, botIdOf } from "./bot/messages.js";
 export { BOT_ACTIONS, type BotAction, type BotAdapter, type BotCallbacks, type BotChatAdmin, type BotChatAdmins, type BotChatMembers, type BotChatRef, type BotChatTools, type BotConnectOptions, type BotEvent, type BotHistory, type BotMcp, type BotMenu, type BotMenuEntry, type BotMessaging, type BotMessenger, type BotNativeApi, type BotNotice, type BotPeople, type BotPress, type BotSecret, type BotSendOptions, type BotUpdates, type BotUpdatesPage, type BotWebhook, type BotWebhookAnswer, type BotWebhookIntake, type BotWebhookRequest, type BotWebhooks, } from "./bot/port.js";
 export { botFiles, botsDirectory, ChatRegistry, registryProfiles, type SeenChat } from "./bot/registry.js";
 export { BotTokenStore, type BotTokenStoreOptions } from "./bot/token.js";
 export { PressLog, UpdatesCursor } from "./bot/updates.js";
 export type { CommandAvailability, DiscoveredCommand } from "./command-availability.js";
 export { commandContract, type JsonSchema, SCHEMA_DIALECT } from "./command-contract.js";
-export { CONTRACT, commandsCommand } from "./commands-command.js";
-export { configCommand, refuseUnknownKey } from "./config-command.js";
+export { CONTRACT } from "./commands-command.js";
+export { refuseUnknownKey } from "./config-command.js";
 export { loadSnakeCaseConfig } from "./config-keys.js";
 export { type AgentRun, type BaseContext, type BaseEnvironment, baseContext, environmentOf, outputFor, provide, secretInputOf, } from "./context.js";
+export { addContractInfo, type ContractEvidenceOptions, contractEvidence } from "./contract-evidence.js";
+export { sharedCommandTemplate } from "./contract-templates.js";
 export { type Closeable, withDeadline } from "./deadline.js";
 export { DEFAULT_CONFIG, ensureDefaultConfig } from "./default-config.js";
+export { DISCOVERY_DESCRIPTIONS } from "./discovery-descriptions.js";
 export { changesAuthority, changesAuthorityAt, changesAuthorityNow, destroysNothing, FETCH, grantsAuthority, isLogin, isOtherServiceCall, isStoreChange, judgedEffects, judgedTargets, LOCAL_READ, LOCAL_WRITE, logsInOrOut, NO_EFFECTS, ownerOnlyOption, REMOTE_READ, REMOTE_WRITE, reachesOtherService, refuseUnderReadOnly, } from "./effects.js";
 export { type AnswerOutput, answerSchema, type Body, type ItemBody, isBody, itemAnswer, itemOf, jsonlRecords, judgedAnswer, type ListBody, type ListInput, listOf, metaNow, printItem, renderAnswer, sealed, snakeKeys, snakeKeysKeeping, } from "./envelope.js";
 export { withAbort } from "./execution.js";
 export { askSetupQuestions, asksAtStart, type FirstRun, type FirstRunIo, LANGUAGES, setupAtStart, systemLanguage, } from "./first-run.js";
-export { checkGuide, checkStep, type GuideOptions, type GuideReference, type GuideStep, guideCommand, loadScenarios, MEMO_SCENARIOS, type Scenario, shellProblems, } from "./guide.js";
+export { checkGuide, checkStep, type GuideOptions, type GuideReference, type GuideStep, loadScenarios, MEMO_SCENARIOS, type Scenario, shellProblems, } from "./guide.js";
 export { type CommandHelp, commandHelp, commandHelpMarkdown, commandHelpText, exampleReport, type NextChoice, nextUsually, } from "./help/command-help.js";
 export { commandsText } from "./help/commands-text.js";
-export { type FirstScreen, type FirstScreenLine, firstScreen, installHelp, WIRECAT_TOOLS, } from "./help/first-screen.js";
+export { type FirstScreen, type FirstScreenLine, firstScreen, installHelp, WIRECAT_TOOLS } from "./help/first-screen.js";
 export { type HelpSection, inSection, SECTIONS } from "./help/sections.js";
 export { bufferedInput, type InputPolicy, inputPolicy, MAX_BUFFERED_INPUT, MAX_SECRET_INPUT, provideInputPolicy, } from "./input-policy.js";
 export { answerFields, checkJson, type EntityFields, entityFields, type JsonFieldsResolver, type JsonRequest, liftJson, } from "./json-fields.js";
 export { commandPath, LIST_QUERY_GUIDE, listQuery, nativeField, nativeTerms, pagedList, pageOf, type QueryWords, queryArgument, queryHelp, queryTerms, searchText, termField, timeBounds, typedQuery, unfilteredQuery, withQuery, } from "./list-query.js";
-export { addMeetingBatchCommand, formatMeetingBatch, prepareMeetingBatch } from "./meeting-batch.js";
+export { formatMeetingBatch, prepareMeetingBatch } from "./meeting-batch.js";
 export { meetingEvidenceItem, meetingPersonContextItem } from "./meeting-evidence-answer.js";
 export { parseEvidenceFindingsJson, parseMeetingFindingsJson } from "./meeting-findings-input.js";
 export { meetingPreparationAnswer } from "./meeting-preparation-answer.js";
-export { addMeetingPreparationCommand } from "./meeting-preparation-command.js";
 export { type MeetingPreparationReader, meetingPreparationInput, readMeetingPreparation, } from "./meeting-preparation-read.js";
-export { addMeetingProjectCandidatesCommand } from "./meeting-project-candidates-command.js";
 export { readMeetingProjectCandidates } from "./meeting-project-candidates-read.js";
 export { meetingResultItem } from "./meeting-results.js";
-export { addMeetingSeriesInventoryCommand } from "./meeting-series-inventory-command.js";
 export { type MeetingSeriesInventoryReader, readMeetingSeriesInventory } from "./meeting-series-inventory-read.js";
-export { accountCommand } from "./messenger/account-command.js";
 export { accountFileFor, profilesHere, rememberAccount } from "./messenger/accounts.js";
-export { storeCommand } from "./messenger/archive-commands.js";
-export { attachmentsCommand } from "./messenger/attachments-command.js";
-export { chatsCommand } from "./messenger/chats-command.js";
-export { markReadCommand } from "./messenger/chats-read-command.js";
-export { type CompletionOptions, completeCommand } from "./messenger/complete-command.js";
-export { contactsCommand } from "./messenger/contacts-command.js";
+export type { CompletionOptions } from "./messenger/complete-command.js";
 export { type ConnectOptions, connectFor, type Messenger, type MessengerContext, messengerContext, type ReadConnection, type StoredMessages, } from "./messenger/context.js";
-export { conversationsCommand } from "./messenger/conversations-command.js";
-export { doctorCommand } from "./messenger/doctor-command.js";
-export { floodCommand } from "./messenger/flood-command.js";
-export { recipientsCommand, sendsCommand } from "./messenger/guard-commands.js";
-export { imagesCommand } from "./messenger/images-command.js";
-export { inboxCommand } from "./messenger/inbox.js";
 export { COMMAND_NEEDS } from "./messenger/lacks.js";
-export { httpTokenFile, type McpEnvironment, mcpCommand, serverEntry } from "./messenger/mcp-command.js";
-export { mentionsCommand } from "./messenger/mentions-command.js";
+export { httpTokenFile, type McpEnvironment, serverEntry } from "./messenger/mcp-command.js";
 export { type MessageItem, messageItem, type ReadMessage } from "./messenger/message-items.js";
-export { messagesCommand, sendCommand } from "./messenger/messages-command.js";
-export { deleteCommand } from "./messenger/messages-delete-command.js";
-export { editCommand } from "./messenger/messages-edit-command.js";
-export { forwardCommand } from "./messenger/messages-forward-command.js";
-export { pinCommand, starCommands, unpinCommand } from "./messenger/messages-pin-command.js";
-export { metadataCommand } from "./messenger/metadata-command.js";
-export { modelsCommand } from "./messenger/models-command.js";
-export { pollsCommand } from "./messenger/polls-command.js";
 export { type ModeProblem, type PrivateFiles, privateFiles, withSqliteSidecars } from "./messenger/private-files.js";
-export { reactionsCommand } from "./messenger/reactions-command.js";
-export { callsCommand, stickersCommand } from "./messenger/records-command.js";
-export { repliesCommand } from "./messenger/replies-command.js";
-export { reviewCommand } from "./messenger/review.js";
-export { scheduleCommand } from "./messenger/schedule-command.js";
+export { buildReport as buildDoctorReport, type Report as DoctorReport, type ReportContext as DoctorReportContext, reportFileName as doctorReportFileName, } from "./messenger/report.js";
 export { allAnswer, allHitItem, type HitItem, type MessageHitItem, messageHitItem, type NoteHitItem, noteHitItem, } from "./messenger/search-answers.js";
-export { searchCommand } from "./messenger/search-command.js";
-export { SEARCHES_QUERY, searchesCommand } from "./messenger/searches-command.js";
-export { serveCommand, servingProfiles } from "./messenger/serve-command.js";
+export { SEARCHES_QUERY } from "./messenger/searches-command.js";
+export { servingProfiles } from "./messenger/serve-command.js";
 export { DAY_MS, FIRST_FETCH_MS, type MemberFetches, memberFetches } from "./messenger/serve-members.js";
 export { STEMS_EVERY_MS, STEMS_SLICE_MS, type StemFills, stemFills } from "./messenger/serve-stems.js";
-export { type Running, type ServerOptions, type ServerProcess, type ServerSystem, serverCommand, } from "./messenger/server-command.js";
-export { statsCommand } from "./messenger/stats-command.js";
+export type { Running, ServerOptions, ServerProcess, ServerSystem } from "./messenger/server-command.js";
 export { storeSummary } from "./messenger/store-maintenance-command.js";
 export { type Saving, stored } from "./messenger/stored.js";
-export { tagsCommand } from "./messenger/tags-command.js";
-export { tasksCommand, tasksStatsCommand } from "./messenger/tasks-command.js";
-export { topicsCommand } from "./messenger/topics-command.js";
-export { watchCommand } from "./messenger/watch-command.js";
+export { MODEL_CATALOGUE_QUERY, type ModelCatalogueOptions } from "./model-catalogue-command.js";
 export { window, withPaging } from "./paging.js";
-export { knownBeside, knownPermissionKeys, type PermissionKeyOf, unknownPermissionKeys, } from "./permission-keys.js";
-export { asFirstWord, commandWords, liftProfile, refuseCommandName, rootOf, usableProfileName, } from "./profile.js";
+export { knownBeside, knownPermissionKeys, type PermissionKeyOf, unknownPermissionKeys } from "./permission-keys.js";
+export { asFirstWord, commandWords, liftProfile, refuseCommandName, rootOf, usableProfileName } from "./profile.js";
 export { createProgram, type ProgramDefinition, type ProgramOptions, type RunOptions, run } from "./program.js";
 export { fieldsOf, projectFields } from "./result-fields.js";
-export { runsCommand } from "./runs/command.js";
 export { type Config, type Configuration, count, first, flag, fromFile, type GlobalFlags, NONE_NAMED, type ProfileKind, plain, type ResolveOptions, type Settings, type SettingsExtension, type SettingsExtensionContext, type Source, settingsFor, } from "./settings.js";
 export { type PermissionAnswer, readSetupAnswers, type SetupAnswers, setupPermissionCeiling } from "./setup-answers.js";
 export { AGENTS, type Agent, agentFor, screenFor } from "./setup-screen.js";
-export { skillCommand } from "./skill-command.js";
+export { accountCommand, addMeetingBatchCommand, addMeetingPreparationCommand, addMeetingProjectCandidatesCommand, addMeetingSeriesInventoryCommand, attachmentsCommand, botAdminsCommand, botCommand, botMcpCommand, botMembersCommand, botMessagesCommand, callsCommand, chatsCommand, commandsCommand, completeCommand, configCommand, contactsCommand, conversationsCommand, deleteCommand, doctorCommand, editCommand, floodCommand, forwardCommand, generatedApiCommand, guideCommand, imagesCommand, inboxCommand, markReadCommand, mcpCommand, mentionsCommand, messagesCommand, metadataCommand, modelCatalogueCommand, modelsCommand, pinCommand, pollsCommand, reactionsCommand, recipientsCommand, repliesCommand, reviewCommand, runsCommand, scheduleCommand, searchCommand, searchesCommand, sendCommand, sendsCommand, serveCommand, serverCommand, skillCommand, starCommands, statsCommand, stickersCommand, storeCommand, tagsCommand, tasksCommand, tasksStatsCommand, topicsCommand, unpinCommand, upgradeCommand, watchCommand, } from "./shared-command-exports.js";
+export { assertSharedContracts, customizeSharedCommand, hasSharedContract, overrideSharedContract, type SharedContractOverride, sharedContractOverrides, sharedContracts, } from "./shared-contracts.js";
 export { runnable, withSafety } from "./steps.js";
 export { changeStoreSetting, isStoreSetting, STORE_SETTINGS, storeSettings } from "./store-settings.js";
-export { restartServers, type UpgradeContext, upgradeCommand } from "./upgrade-command.js";
+export { restartServers, type UpgradeContext } from "./upgrade-command.js";