@wirecat/cli-core 0.423.0 → 0.425.0

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

@@ -11,7 +11,7 @@ import { MIGRATIONS, migrate } from "../../store/migrations.js";
 import { openCache } from "../../store/open.js";
 import { storePath } from "../../store/path.js";
 import { deleteCopy, repairStore } from "../../store/repair.js";
-import { drainNoteIndex, fillSearchIndex, fillStems, involvementStoreOver, noteIndexState, openStore, orphanPointers, pendingNormalization, resetAttachmentWords, resetNoteIndex, resetSearchIndex, resetStems, searchIndexState, stemmerCache, stemsState, } from "../../store/store.js";
+import { drainNoteIndex, fillSearchIndex, fillStems, involvementStoreOver, noteIndexState, openSqlite, openStore, orphanPointers, pendingNormalization, resetAttachmentWords, resetNoteIndex, resetSearchIndex, resetStems, rowCounts, searchIndexState, stemmerCache, stemsState, storeContents, } from "../../store/store.js";
 import { environmentOf, outputFor } from "../context.js";
 import { destroysNothing, LOCAL_READ, LOCAL_WRITE } from "../effects.js";
 import { itemOf, renderAnswer, snakeKeys } from "../envelope.js";
@@ -49,6 +49,16 @@ const reading = async (path, read) => {
         database.close();
     }
 };
+/** For a command that only reads: the connection refuses writes, and opening sets no journal mode. */
+const readingOnly = async (path, read) => {
+    const { database } = await openSqlite(path, { readOnly: true });
+    try {
+        return read(database);
+    }
+    finally {
+        database.close();
+    }
+};
 /** `doctor`'s short summary of the store. Must answer for a broken file, so an error is a field. */
 export const storeSummary = async (env) => {
     const path = storePath(env);
@@ -154,25 +164,25 @@ const copiesCommand = () => new Command("copies").description("the tables `store
 }));
 const infoCommand = () => annotate(new Command("info"), { output: { entity: "store_info" }, effects: LOCAL_READ })
     .summary("the local archive's format, size and contents")
-    .description("the store file: where it is, its size, its schema and how many rows it holds; changes nothing")
+    .description("the store file: where it is, its size, its schema and how many rows it holds, by provider, chat kind, account, year (UTC) and attachment kind, over every account; changes nothing")
     .action(async function () {
     const path = storePath(environmentOf(this).env ?? process.env);
     if (!existsSync(path)) {
         result(this, { path, exists: false });
         return;
     }
-    const read = reading(path, (database) => {
+    const read = readingOnly(path, (database) => {
         const { version, minCompatible, writable } = schemaOf(database);
-        const tables = ["accounts", "chats", "messages", "attachments", "identities"];
         return {
             path,
             exists: true,
             bytes: { file: bytesOf(path), wal: bytesOf(`${path}-wal`) },
             schema: { version, minCompatible, speaks: SPEAKS, writable },
-            rows: version > 0 ? Object.fromEntries(tables.map((table) => [table, count(database, table)])) : {},
+            rows: version > 0 ? rowCounts(database) : {},
             pendingNormalization: pendingIfKnown(database),
             wordIndex: searchIndexState(database) ?? null,
             stemIndex: stemsState(database) ?? null,
+            ...(version > 0 ? storeContents(database) : {}),
         };
     });
     result(this, await read.catch((error) => ({ path, exists: true, opens: false, error: messageOf(error) })));

package/dist/cli/preview.d.ts

@@ -3,13 +3,51 @@ import { type PermissionKey } from "../sends/permissions.js";
 import type { Settings } from "./settings.js";
 export declare class PreviewComplete extends Error {
 }
-export declare const preview: (command: Command, settings: Pick<Settings, "permissions" | "permissionSources" | "configPath" | "savedPermissions" | "profile">, tool: string, keyOf?: (path: readonly string[]) => PermissionKey | null | undefined) => {
+export declare const preview: (command: Command, settings: Pick<Settings, "permissions" | "permissionSources" | "configPath" | "savedPermissions" | "profile">, tool: string, keyOf?: (path: readonly string[]) => PermissionKey | null | undefined, messenger?: boolean) => {
     preview: boolean;
     path: string[];
-    permission: {
-        key: string | null;
-        level: "allow" | "ask" | "readonly";
+    permission?: {
+        key: PermissionKey | null;
+        level: string;
+    } | undefined;
+    validation: {
+        arguments: string;
+        permissions: string;
+        targets: string;
+        businessRules: string;
+    };
+    effects: {
+        actionInvoked: boolean;
+        writeReserved: boolean;
+        messengerContacted?: boolean | undefined;
+        serviceContacted: boolean;
+        configurationRead: boolean;
     };
+    arguments: ({
+        name: string;
+        reference: string;
+    } | {
+        name: string;
+        supplied: boolean;
+        bytes: number | undefined;
+    })[];
+    options: string[];
+    trust: string;
+};
+/**
+ * `messenger_contacted` stays for the messengers, whose callers may read it; `service_contacted` says the same
+ * for every tool. Without `permission` nothing was checked: a host that is not `run` has no settings to check.
+ */
+export declare const previewBody: (command: Command, permission: {
+    key: PermissionKey | null;
+    level: string;
+} | undefined, messenger: boolean) => {
+    preview: boolean;
+    path: string[];
+    permission?: {
+        key: PermissionKey | null;
+        level: string;
+    } | undefined;
     validation: {
         arguments: string;
         permissions: string;
@@ -19,7 +57,8 @@ export declare const preview: (command: Command, settings: Pick<Settings, "permi
     effects: {
         actionInvoked: boolean;
         writeReserved: boolean;
-        messengerContacted: boolean;
+        messengerContacted?: boolean | undefined;
+        serviceContacted: boolean;
         configurationRead: boolean;
     };
     arguments: ({

package/dist/cli/preview.js

@@ -6,11 +6,11 @@ import { commandPathOf } from "./command-contract.js";
 import { refuseUnknownPermissionKeys } from "./permission-keys.js";
 export class PreviewComplete extends Error {
 }
-export const preview = (command, settings, tool, keyOf) => {
+export const preview = (command, settings, tool, keyOf, messenger = true) => {
     const path = commandPathOf(command);
     const { permissions } = settings;
     refuseUnknownPermissionKeys(command, settings, tool, keyOf && ((one) => keyOf(commandPathOf(one))));
-    const key = keyForCommand(path);
+    const key = keyOf?.(path) ?? keyForCommand(path);
     const level = key ? levelFor(permissions, key).level : "allow";
     for (const source of readKeysForCommand(path)) {
         if (levelFor(permissions, source).level === "deny")
@@ -21,18 +21,36 @@ export const preview = (command, settings, tool, keyOf) => {
         (key !== null && key !== undefined && WRITE_KEYS.includes(key));
     if (level === "deny" || (writes && level === "readonly"))
         throw new CliError("permission_error", `this profile does not permit ${path.join(" ")}`, { permission: key });
-    const targets = new Set(["chat", "message", "person", "profile"]);
+    return previewBody(command, { key: key ?? null, level }, messenger);
+};
+const TARGETS = new Set(["chat", "message", "person", "profile"]);
+/**
+ * `messenger_contacted` stays for the messengers, whose callers may read it; `service_contacted` says the same
+ * for every tool. Without `permission` nothing was checked: a host that is not `run` has no settings to check.
+ */
+export const previewBody = (command, permission, messenger) => {
     return {
         preview: true,
-        path,
-        permission: { key: key ?? null, level },
-        validation: { arguments: "parsed", permissions: "checked", targets: "unresolved", businessRules: "not-executed" },
-        effects: { actionInvoked: false, writeReserved: false, messengerContacted: false, configurationRead: true },
+        path: commandPathOf(command),
+        ...(permission ? { permission } : {}),
+        validation: {
+            arguments: "parsed",
+            permissions: permission ? "checked" : "not-checked",
+            targets: "unresolved",
+            businessRules: "not-executed",
+        },
+        effects: {
+            actionInvoked: false,
+            writeReserved: false,
+            ...(messenger ? { messengerContacted: false } : {}),
+            serviceContacted: false,
+            configurationRead: permission !== undefined,
+        },
         arguments: command.registeredArguments.map((argument, at) => {
             const value = command.processedArgs[at];
             return {
                 name: argument.name(),
-                ...(targets.has(argument.name()) && typeof value === "string"
+                ...(TARGETS.has(argument.name()) && typeof value === "string"
                     ? { reference: value }
                     : { supplied: value !== undefined, bytes: typeof value === "string" ? Buffer.byteLength(value) : undefined }),
             };

package/dist/cli/program.d.ts

@@ -10,7 +10,7 @@ export interface ProgramDefinition {
     /** The CLI's own settings, for keeping a failure that happened before its command could; plain ones without. */
     configuration?: {
         permissionKey?: (path: readonly string[]) => string | null | undefined;
-        resolveSettings: (flags?: GlobalFlags, options?: ResolveOptions) => Pick<Settings, "profile" | "keepFailedRuns" | "keepRunsForDays" | "skillHint"> & Partial<Pick<Settings, "permissions" | "permissionSources" | "configPath" | "savedPermissions">>;
+        resolveSettings: (flags?: GlobalFlags, options?: ResolveOptions) => Pick<Settings, "profile" | "keepFailedRuns" | "keepRunsForDays" | "skillHint"> & Partial<Pick<Settings, "permissions" | "permissionSources" | "configPath" | "savedPermissions" | "sources">>;
     };
     configure?: (program: Command) => void;
     /** The tool's pitch and "what you can do" lines on `--help` and a bare run. */

package/dist/cli/program.js

@@ -10,6 +10,7 @@ import { isCliFailure, isCommanderFailure } from "../errors/failures.js";
 import { failureContext } from "../errors/reasons.js";
 import { envName, readOnlyLockOf, readOnlyRefusal } from "../ports/app.js";
 import { recorded, wasSettled } from "../runs/recording.js";
+import { runContextOf } from "../runs/run-context.js";
 import { processRun, useAsProcessRun } from "../runs/scope.js";
 import { AUTHORITY_KEY, BOT_API_KEY, isBotApi, keyForCommand } from "../sends/permissions.js";
 import { logParsedArgv, logVersion } from "./argv-log.js";
@@ -28,7 +29,7 @@ import { checkJson, liftJson } from "./json-fields.js";
 import { PreviewComplete, preview } from "./preview.js";
 import { commandWords, liftProfile, PROFILE_FREE, sampleCommand, valuedOptions } from "./profile.js";
 import { absolutePaths, relayTarget } from "./relay-route.js";
-import { settingsFor } from "./settings.js";
+import { NoProfileHere, namedProfile, settingsFor, } from "./settings.js";
 import { assertSharedContracts } from "./shared-contracts.js";
 import { commandAt, lineOf, withLines } from "./steps.js";
 /**
@@ -191,6 +192,7 @@ const runOnce = async (argv, definition, options) => {
     const exit = {};
     const environment = {
         ...options,
+        argv,
         streams: control.streams,
         signal: options.signal ? AbortSignal.any([control.signal, options.signal]) : control.signal,
         commandSignal: control.signal,
@@ -267,16 +269,18 @@ const runOnce = async (argv, definition, options) => {
         const path = commandPathOf(action);
         const lock = readOnlyLockOf(definition.app, commandEnv);
         const input = options.stdin ?? process.stdin;
-        await setupAtStart({
-            command,
-            env: commandEnv,
-            contentLanguages: definition.app.contentLanguages,
-            path,
-            headless,
-            readOnlyLock: lock,
-            input,
-            terminal: !options.streams && input.isTTY === true && process.stderr.isTTY === true,
-        });
+        // The first-run questions write the shared config; a dry run writes nothing.
+        if (!flags.dryRun)
+            await setupAtStart({
+                command,
+                env: commandEnv,
+                contentLanguages: definition.app.contentLanguages,
+                path,
+                headless,
+                readOnlyLock: lock,
+                input,
+                terminal: !options.streams && input.isTTY === true && process.stderr.isTTY === true,
+            });
         if (lock && isLogin(action) && !flags.dryRun)
             throw readOnlyRefusal(lock, "log in or out");
         if (lock && isStoreChange(action) && !flags.dryRun)
@@ -385,7 +389,7 @@ const runOnce = async (argv, definition, options) => {
                 configPath: resolved.configPath ?? "",
                 profile: resolved.profile,
                 ...(resolved.savedPermissions ? { savedPermissions: resolved.savedPermissions } : {}),
-            }, command, definition.configuration?.permissionKey);
+            }, command, definition.configuration?.permissionKey, definition.app.messenger !== false);
             renderAnswer(action, outputFor(action), itemOf(snakeKeys(previewed)));
             throw new PreviewComplete();
         }
@@ -412,7 +416,7 @@ const runOnce = async (argv, definition, options) => {
             refuseJoinedPath(program, words.filter((word) => !word.startsWith("-")), profile !== undefined && !/\s/.test(profile) ? [profile] : []);
     }
     catch (failure) {
-        const settled = await settleFailure(failure, { definition, program, rest: lifted, profile, options });
+        const settled = await settleFailure(failure, { definition, program, rest: lifted, argv, profile, options });
         return report(streams, reporting, failed(definition, program, lifted, failure, settled, debug));
     }
     if (profile !== undefined)
@@ -427,7 +431,7 @@ const runOnce = async (argv, definition, options) => {
         const message = `"${profile}" is not a command, so it was read as a profile name — and no command followed it. ` +
             `Run \`${command} --help\` for the commands, or \`${command} ${profile} account show\` if "${profile}" is your profile.`;
         const failure = new CliError("validation_error", message, { param: "profile" });
-        const settled = await settleFailure(failure, { definition, program, rest, profile, options });
+        const settled = await settleFailure(failure, { definition, program, rest, argv, profile, options });
         return report(streams, reporting, failed(definition, program, rest, failure, settled, debug));
     }
     try {
@@ -472,10 +476,10 @@ const runOnce = async (argv, definition, options) => {
                 message += ` — "${profile}" is not a command, so it was read as a profile name — which left "${rest[0]}" to be one.`;
             }
             const failure = new CliError("validation_error", message);
-            const settled = await settleFailure(failure, { definition, program, rest, profile, options });
+            const settled = await settleFailure(failure, { definition, program, rest, argv, profile, options });
             return report(streams, reporting, failed(definition, program, rest, failure, settled, debug));
         }
-        const settled = await settleFailure(error, { definition, program, rest, profile, options });
+        const settled = await settleFailure(error, { definition, program, rest, argv, profile, options });
         const exit = report(streams, reporting, failed(definition, program, rest, error, settled, debug));
         return signalExit ?? exit;
     }
@@ -562,9 +566,9 @@ const settleFailure = async (failure, state) => {
 /**
  * **Every failure is kept as a run** — a usage error, a configuration that will not load, a command
  * that never opens a run — unless recording was turned off. One its own run already kept is skipped.
- * Only the command's words are named, never its arguments: those can be a message.
+ * Its arguments are kept masked (`maskArgv`): a value that can be a message never is.
  */
-const keepFailure = async (failure, { definition, program, rest, profile, options }) => {
+const keepFailure = async (failure, { definition, program, rest, argv, profile, options }) => {
     if (wasSettled(failure))
         return;
     const env = options.env ?? process.env;
@@ -577,10 +581,18 @@ const keepFailure = async (failure, { definition, program, rest, profile, option
     catch {
         // A configuration that will not load is a failure worth keeping too; the flags are all there is to go on.
     }
+    const command = `${options.agent ? "mcp " : ""}${path || definition.app.command}`;
     await recorded({
         app: definition.app,
-        command: `${options.agent ? "mcp " : ""}${path || definition.app.command}`,
-        profile: settings?.profile ?? profile ?? "default",
+        command,
+        context: runContextOf({
+            bin: definition.app.command,
+            command: path ? command : options.agent ? "mcp" : "",
+            program,
+            argv,
+            env,
+        }),
+        profile: settings ? namedProfile(settings) : profile,
         record: false,
         keepFailed: settings?.keepFailedRuns ?? !rest.includes("--no-record"),
         trace: false,
@@ -609,10 +621,11 @@ const commandPath = (program, rest) => {
     return words.join(" ");
 };
 const failed = ({ app }, program, rest, error, settled, debug) => {
-    const failure = settled.settlementFailed && isCliFailure(error)
-        ? new CliError(error.code, error.message, { ...error.details, settlement_failed: true })
-        : error;
     const path = commandPath(program, program.args.length > 0 ? program.args : rest);
+    const told = error instanceof NoProfileHere && !commandAt(program, "setup") ? error.withoutSetup(path) : error;
+    const failure = settled.settlementFailed && isCliFailure(told)
+        ? new CliError(told.code, told.message, { ...told.details, settlement_failed: true })
+        : told;
     const effects = judgedEffects(path ? metaOf(commandAt(program, path) ?? program).effects : undefined);
     const object = errorObjectOf(failure, {
         ...failureContext(app.errors),

package/dist/cli/runs/search.d.ts

@@ -14,7 +14,7 @@ export declare const searchRuns: (dir: string, { query, terms, status, errorCode
     items: {
         runId: string;
         command: string;
-        profile: string;
+        profile: string | undefined;
         status: "running" | import("../../runs/run.js").RunStatus;
         startedAt: string;
         completedAt: string | undefined;

package/dist/cli/runs/search.js

@@ -8,6 +8,8 @@ const FIELDS = [
     "opcode",
     "seq",
     "status",
+    "method",
+    "endpoint_template",
     "bytes",
     "ids",
     "counts",

package/dist/cli/settings.d.ts

@@ -1,3 +1,4 @@
+import { CliError } from "@wirecat/cli-base";
 import * as v from "valibot";
 import { type AISettings } from "../analysis/settings.js";
 import { type AppIdentity } from "../ports/app.js";
@@ -161,6 +162,18 @@ export interface ResolveOptions {
 }
 /** Where `profile` came from when none was named and the command needs none. */
 export declare const NONE_NAMED = "none named";
+/** The profile a run is for: none when nothing named one, even though `Settings.profile` holds a placeholder. */
+export declare const namedProfile: (settings: Pick<Settings, "profile"> & Partial<Pick<Settings, "sources">>) => string | undefined;
+/**
+ * No profile named and none on this computer. The settings cannot see the program, so the program swaps the
+ * `setup` this suggests for `withoutSetup` when it has no such command.
+ */
+export declare class NoProfileHere extends CliError {
+    private readonly app;
+    constructor(app: AppIdentity);
+    /** `words`: the command that was typed, without its arguments, so the suggestion runs as written. */
+    withoutSetup(words: string): CliError;
+}
 /** The first candidate that is set, and which layer it came from. */
 export declare const first: <T>(candidates: [Source, T | undefined][], fallback: T) => {
     value: T;

package/dist/cli/settings.js

@@ -7,7 +7,7 @@ import { envName, readOnlyLockOf } from "../ports/app.js";
 import { assertOverridesTighten, CEILING_KEY, LEVELS, layerPermissions, permissionOverrides, RESOURCES, } from "../sends/permissions.js";
 import { storePath } from "../store/path.js";
 import { sharedConfigPath } from "../store/shared-config.js";
-import { issueMessage, parseConfigText, publicIssue, savedPermissionKeys, schemaIssues, withoutIssues, } from "./config-issues.js";
+import { checkConfigText, issueMessage, parseConfigText, publicIssue, savedPermissionKeys, schemaIssues, } from "./config-issues.js";
 import { DEFAULT_CONFIG, ensureDefaultConfig } from "./default-config.js";
 import { profilesHere } from "./messenger/accounts.js";
 import { usableProfileName } from "./profile.js";
@@ -81,6 +81,26 @@ const SHARED_DEFAULTS_ONLY = {
 export const NONE_NAMED = "none named";
 /** A name for a command that speaks for no account; never chosen for one that does. */
 const NO_PROFILE = "default";
+/** The profile a run is for: none when nothing named one, even though `Settings.profile` holds a placeholder. */
+export const namedProfile = (settings) => settings.sources?.profile === NONE_NAMED ? undefined : settings.profile;
+/**
+ * No profile named and none on this computer. The settings cannot see the program, so the program swaps the
+ * `setup` this suggests for `withoutSetup` when it has no such command.
+ */
+export class NoProfileHere extends CliError {
+    app;
+    constructor(app) {
+        super("validation_error", `name a profile: there is none on this computer yet — create one with \`${app.command} personal setup\` ` +
+            "(any name in place of personal)", { profiles: [] });
+        this.app = app;
+    }
+    /** `words`: the command that was typed, without its arguments, so the suggestion runs as written. */
+    withoutSetup(words) {
+        const command = words ? `${this.app.command} personal ${words}` : `${this.app.command} personal …`;
+        return new CliError("validation_error", `name a profile: there is none on this computer yet — any name works, such as \`${command}\` ` +
+            `(or set ${envName(this.app, "PROFILE")})`, { profiles: [] });
+    }
+}
 /** The first candidate that is set, and which layer it came from. */
 export const first = (candidates, fallback) => {
     for (const [from, value] of candidates)
@@ -137,14 +157,15 @@ export const settingsFor = (app, extension = {}) => {
     };
     /** The file with every problem found; what loads is the file without the settings they name. */
     const loadConfig = (path) => {
-        const read = readRaw(path);
-        if ("issue" in read)
-            return { config: { profiles: {} }, issues: [read.issue], raw: undefined };
-        if (read.raw === undefined)
-            return { config: { profiles: {} }, issues: [], raw: undefined };
-        const issues = schemaIssues(read.raw, readSchema, context(path));
-        const parsed = v.safeParse(readSchema, withoutIssues(read.raw, issues));
-        return { config: (parsed.success ? parsed.output : { profiles: {} }), issues, raw: read.raw };
+        let text;
+        try {
+            text = readFileSync(path, "utf8");
+        }
+        catch {
+            return { config: { profiles: {} }, issues: [] };
+        }
+        const { config, issues } = checkConfigText(text, { file: path, tool: app.command, schema: readSchema });
+        return { config: (config ?? { profiles: {} }), issues };
     };
     /**
      * A lock pins a process to one profile: the owner sets it where an agent runs, and a first word
@@ -170,10 +191,9 @@ export const settingsFor = (app, extension = {}) => {
         if (!needed)
             return { value: NO_PROFILE, from: NONE_NAMED };
         const here = profilesOf(config, env);
-        throw new CliError("validation_error", here.length === 0
-            ? `name a profile: there is none on this computer yet — create one with \`${app.command} personal setup\` ` +
-                "(any name in place of personal)"
-            : `name a profile: \`${app.command} <profile> …\` — profiles here: ${here.join(", ")} (or set ${PROFILE})`, { profiles: here });
+        if (here.length === 0)
+            throw new NoProfileHere(app);
+        throw new CliError("validation_error", `name a profile: \`${app.command} <profile> …\` — profiles here: ${here.join(", ")} (or set ${PROFILE})`, { profiles: here });
     };
     const profilesOf = (config, env) => profilesHere(app, [...namedProfiles(config), ...(extension.profiles?.(env) ?? [])], env);
     const resolveSettings = (flags = {}, options = {}) => {
@@ -188,7 +208,7 @@ export const settingsFor = (app, extension = {}) => {
         }
         const loaded = loadConfig(configPath);
         if (loaded.issues.length > 0 && !options.withIssues)
-            throw new CliError("configuration_error", issueMessage(loaded.issues.map(publicIssue)));
+            throw new CliError("configuration_error", issueMessage(loaded.issues));
         const { config } = loaded;
         const lock = given(env[PROFILE_LOCK]);
         const named = first([
@@ -311,7 +331,7 @@ export const settingsFor = (app, extension = {}) => {
             },
             configured,
             shared,
-            configIssues: loaded.issues.map(publicIssue),
+            configIssues: loaded.issues,
             savedPermissions: savedPermissionKeys(config),
         };
         // The file was checked by the schema; a flag was not, and `--limit abc` is `NaN` by the time it
@@ -332,7 +352,7 @@ export const settingsFor = (app, extension = {}) => {
     const configuredProfiles = (options = {}) => {
         const { config, issues } = loadConfig(configPathFor(options));
         if (issues.length > 0 && !options.withIssues)
-            throw new CliError("configuration_error", issueMessage(issues.map(publicIssue)));
+            throw new CliError("configuration_error", issueMessage(issues));
         return namedProfiles(config);
     };
     /**

package/dist/cli/shared-command-exports.js

@@ -5,6 +5,7 @@ import { botMcpCommand as botMcpCommandDefinition } from "./bot/mcp.js";
 import { botMessagesCommand as botMessagesCommandDefinition } from "./bot/messages.js";
 import { commandsCommand as commandsCommandDefinition } from "./commands-command.js";
 import { configCommand as configCommandDefinition } from "./config-command.js";
+import { honoursDryRun } from "./dry-run-guard.js";
 import { guideCommand as guideCommandDefinition } from "./guide.js";
 import { addMeetingBatchCommand as addMeetingBatchCommandDefinition } from "./meeting-batch.js";
 import { addMeetingPreparationCommand as addMeetingPreparationCommandDefinition } from "./meeting-preparation-command.js";
@@ -48,9 +49,10 @@ import { tasksCommand as tasksCommandDefinition, tasksStatsCommand as tasksStats
 import { topicsCommand as topicsCommandDefinition } from "./messenger/topics-command.js";
 import { watchCommand as watchCommandDefinition } from "./messenger/watch-command.js";
 import { runsCommand as runsCommandDefinition } from "./runs/command.js";
-import { sharedCommand } from "./shared-contracts.js";
+import { sharedCommand as protectedCommand } from "./shared-contracts.js";
 import { skillCommand as skillCommandDefinition } from "./skill-command.js";
 import { upgradeCommand as upgradeCommandDefinition } from "./upgrade-command.js";
+const sharedCommand = (factory) => honoursDryRun(protectedCommand(factory));
 export const botAdminsCommand = sharedCommand(botAdminsCommandDefinition);
 export const botMembersCommand = sharedCommand(botMembersCommandDefinition);
 export const generatedApiCommand = sharedCommand(generatedApiCommandDefinition);