@unbrained/pm-cli 2026.5.30 → 2026.6.5

package/dist/cli/register-mutation.js

@@ -1,5 +1,5 @@
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="1c5454e2-e849-5b5f-b7a1-2681e8a90eac")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="512c19d2-da36-590c-a1ca-cd11e57c7529")}catch(e){}}();
 import { Option } from "commander";
 import { EXIT_CODE } from "../core/shared/constants.js";
 import { PmCliError } from "../core/shared/errors.js";
@@ -12,8 +12,6 @@ import { BUILTIN_ITEM_TYPE_VALUES } from "../types/index.js";
 // instead of silently creating a Task titled with the type name.
 const BUILTIN_TYPE_NAME_LOOKUP = new Set(BUILTIN_ITEM_TYPE_VALUES.map((value) => value.toLowerCase()));
 import { collect, extractUpdateManyMutationOptionSource, formatHookWarnings, getGlobalOptions, invalidateSearchCachesForMutation, normalizeCreateOptions, normalizeUpdateOptions, printError, printResult, writeStdout, } from "./registration-helpers.js";
-import { createLazyModule } from "../core/shared/lazy-module.js";
-const loadMutationCommandsModule = createLazyModule(() => import("./commands/index.js"));
 /**
  * Register a flag and hide it from `--help` text while keeping it fully
  * functional as a parse-time alias. The option still appears in
@@ -28,6 +26,34 @@ function addHiddenOption(command, flags, description, repeatable) {
     }
     command.addOption(option);
 }
+/**
+ * Parse the `--order` value for `pm schema add-status`. Accepts a value that is
+ * already a number or a numeric string; throws a usage error when the flag was
+ * supplied but does not parse to a finite integer (rather than silently dropping
+ * it). Returns `undefined` only when the flag was genuinely not provided.
+ */
+function parseSchemaOrderOption(raw) {
+    if (raw === undefined || raw === null) {
+        return undefined;
+    }
+    if (typeof raw === "number") {
+        if (!Number.isInteger(raw)) {
+            throw new PmCliError("--order must be a finite integer.", EXIT_CODE.USAGE);
+        }
+        return raw;
+    }
+    if (typeof raw === "string") {
+        if (raw.trim().length === 0) {
+            return undefined;
+        }
+        const parsed = Number(raw);
+        if (!Number.isInteger(parsed)) {
+            throw new PmCliError("--order must be a finite integer.", EXIT_CODE.USAGE);
+        }
+        return parsed;
+    }
+    throw new PmCliError("--order must be a finite integer.", EXIT_CODE.USAGE);
+}
 function registerCommanderOptionContracts(command, contracts) {
     for (const contract of contracts) {
         if (contract.required) {
@@ -120,7 +146,7 @@ export function registerMutationCommands(program) {
             options.title = positionalTitle;
         }
         const normalized = normalizeCreateOptions(options, { requireType: false });
-        const { runCreate } = await loadMutationCommandsModule();
+        const { runCreate } = await import("./commands/create.js");
         const result = await runCreate(normalized, globalOptions);
         await invalidateSearchCachesForMutation(globalOptions, result);
         printResult(result, globalOptions);
@@ -155,7 +181,7 @@ export function registerMutationCommands(program) {
         .action(async (id, options, command) => {
         const globalOptions = getGlobalOptions(command);
         const startedAt = Date.now();
-        const { runUpdate } = await loadMutationCommandsModule();
+        const { runUpdate } = await import("./commands/update.js");
         const result = await runUpdate(id, normalizeUpdateOptions(options), globalOptions);
         await invalidateSearchCachesForMutation(globalOptions, result);
         printResult(result, globalOptions);
@@ -172,11 +198,16 @@ export function registerMutationCommands(program) {
         .option("--filter-priority <value>", "Filter by priority before applying updates")
         .option("--filter-deadline-before <value>", "Filter by deadline upper bound before applying updates")
         .option("--filter-deadline-after <value>", "Filter by deadline lower bound before applying updates")
+        .option("--filter-updated-after <value>", "Filter by updated_at lower bound before applying updates (ISO/relative)")
+        .option("--filter-updated-before <value>", "Filter by updated_at upper bound before applying updates (ISO/relative)")
+        .option("--filter-created-after <value>", "Filter by created_at lower bound before applying updates (ISO/relative)")
+        .option("--filter-created-before <value>", "Filter by created_at upper bound before applying updates (ISO/relative)")
         .option("--filter-assignee <value>", "Filter by assignee before applying updates")
         .option("--filter-assignee-filter <value>", "Filter assignee presence: assigned|unassigned before applying updates")
         .option("--filter-parent <value>", "Filter by parent item ID before applying updates")
         .option("--filter-sprint <value>", "Filter by sprint before applying updates")
         .option("--filter-release <value>", "Filter by release before applying updates")
+        .option("--ids <value>", "Restrict to an explicit comma-separated ID allowlist (intersected with other filters)")
         .option("--limit <n>", "Limit matched item count before apply/preview")
         .option("--offset <n>", "Skip first n matched rows before apply/preview")
         .option("--dry-run", "Preview per-item diffs and checkpoint intent without mutating")
@@ -291,7 +322,7 @@ export function registerMutationCommands(program) {
         .action(async (options, command) => {
         const globalOptions = getGlobalOptions(command);
         const startedAt = Date.now();
-        const { runUpdateMany } = await loadMutationCommandsModule();
+        const { runUpdateMany } = await import("./commands/update-many.js");
         const result = await runUpdateMany({
             status: typeof options.filterStatus === "string" ? options.filterStatus : undefined,
             list: {
@@ -300,6 +331,11 @@ export function registerMutationCommands(program) {
                 priority: typeof options.filterPriority === "string" ? options.filterPriority : undefined,
                 deadlineBefore: typeof options.filterDeadlineBefore === "string" ? options.filterDeadlineBefore : undefined,
                 deadlineAfter: typeof options.filterDeadlineAfter === "string" ? options.filterDeadlineAfter : undefined,
+                updatedAfter: typeof options.filterUpdatedAfter === "string" ? options.filterUpdatedAfter : undefined,
+                updatedBefore: typeof options.filterUpdatedBefore === "string" ? options.filterUpdatedBefore : undefined,
+                createdAfter: typeof options.filterCreatedAfter === "string" ? options.filterCreatedAfter : undefined,
+                createdBefore: typeof options.filterCreatedBefore === "string" ? options.filterCreatedBefore : undefined,
+                ids: typeof options.ids === "string" ? options.ids : undefined,
                 assignee: typeof options.filterAssignee === "string" ? options.filterAssignee : undefined,
                 assigneeFilter: typeof options.filterAssigneeFilter === "string"
                     ? options.filterAssigneeFilter
@@ -349,7 +385,7 @@ export function registerMutationCommands(program) {
         .action(async (id, text, options, command) => {
         const globalOptions = getGlobalOptions(command);
         const startedAt = Date.now();
-        const { runClose } = await loadMutationCommandsModule();
+        const { runClose } = await import("./commands/close.js");
         const reasonFromOption = (typeof options.reason === "string" && options.reason.trim().length > 0 && options.reason) ||
             (typeof options.closeReason === "string" && options.closeReason.trim().length > 0 && options.closeReason) ||
             undefined;
@@ -394,6 +430,98 @@ export function registerMutationCommands(program) {
             printError(`profile:command=close took_ms=${Date.now() - startedAt}`);
         }
     });
+    const closeManyCommand = program
+        .command("close-many")
+        .description("Bulk-close matched items with a shared reason and full runClose semantics (dry-run + rollback checkpoint).")
+        .option("--filter-status <value>", "Filter by status before closing")
+        .option("--filter-type <value>", "Filter by item type before closing")
+        .option("--filter-tag <value>", "Filter by tag before closing")
+        .option("--filter-priority <value>", "Filter by priority before closing")
+        .option("--filter-deadline-before <value>", "Filter by deadline upper bound before closing")
+        .option("--filter-deadline-after <value>", "Filter by deadline lower bound before closing")
+        .option("--filter-updated-after <value>", "Filter by updated_at lower bound before closing (ISO/relative)")
+        .option("--filter-updated-before <value>", "Filter by updated_at upper bound before closing (ISO/relative)")
+        .option("--filter-created-after <value>", "Filter by created_at lower bound before closing (ISO/relative)")
+        .option("--filter-created-before <value>", "Filter by created_at upper bound before closing (ISO/relative)")
+        .option("--filter-assignee <value>", "Filter by assignee before closing")
+        .option("--filter-assignee-filter <value>", "Filter assignee presence: assigned|unassigned before closing")
+        .option("--filter-parent <value>", "Filter by parent item ID before closing")
+        .option("--filter-sprint <value>", "Filter by sprint before closing")
+        .option("--filter-release <value>", "Filter by release before closing")
+        .option("--ids <value>", "Restrict to an explicit comma-separated ID allowlist (intersected with other filters)")
+        .option("--limit <n>", "Limit matched item count before apply/preview")
+        .option("--offset <n>", "Skip first n matched rows before apply/preview")
+        .option("--reason <value>", "Shared close reason applied to every matched item (required for dry-run/apply)")
+        .option("--resolution <value>", "Shared closure resolution applied to every matched item (closure-validation field)")
+        .option("--expected-result <value>", "Shared expected-result note (closure-validation field)")
+        .option("--expected <value>", "Short alias for --expected-result")
+        .option("--actual-result <value>", "Shared actual-result note (closure-validation field)")
+        .option("--actual <value>", "Short alias for --actual-result")
+        .option("--validate-close [mode]", 'Validate closure metadata per item: "off", "warn", or "strict" (default: settings governance preset)')
+        .option("--author <value>", "Mutation author")
+        .option("--message <value>", "History message")
+        .option("--force", "Re-close already-terminal matches and override ownership")
+        .option("--dry-run", "Preview matched items + per-item skip/active-child plan without mutating")
+        .option("--rollback <value>", "Rollback a prior close-many checkpoint ID")
+        .option("--no-checkpoint", "Disable checkpoint creation during apply mode");
+    addHiddenOption(closeManyCommand, "--filter-assignee_filter <value>", "Alias for --filter-assignee-filter", false);
+    addHiddenOption(closeManyCommand, "--expected_result <value>", "Alias for --expected-result", false);
+    addHiddenOption(closeManyCommand, "--actual_result <value>", "Alias for --actual-result", false);
+    closeManyCommand.action(async (options, command) => {
+        const globalOptions = getGlobalOptions(command);
+        const startedAt = Date.now();
+        const pickString = (...candidates) => {
+            for (const candidate of candidates) {
+                if (typeof candidate === "string") {
+                    return candidate;
+                }
+            }
+            return undefined;
+        };
+        const { runCloseMany } = await import("./commands/close-many.js");
+        const result = await runCloseMany({
+            status: typeof options.filterStatus === "string" ? options.filterStatus : undefined,
+            list: {
+                type: typeof options.filterType === "string" ? options.filterType : undefined,
+                tag: typeof options.filterTag === "string" ? options.filterTag : undefined,
+                priority: typeof options.filterPriority === "string" ? options.filterPriority : undefined,
+                deadlineBefore: typeof options.filterDeadlineBefore === "string" ? options.filterDeadlineBefore : undefined,
+                deadlineAfter: typeof options.filterDeadlineAfter === "string" ? options.filterDeadlineAfter : undefined,
+                updatedAfter: typeof options.filterUpdatedAfter === "string" ? options.filterUpdatedAfter : undefined,
+                updatedBefore: typeof options.filterUpdatedBefore === "string" ? options.filterUpdatedBefore : undefined,
+                createdAfter: typeof options.filterCreatedAfter === "string" ? options.filterCreatedAfter : undefined,
+                createdBefore: typeof options.filterCreatedBefore === "string" ? options.filterCreatedBefore : undefined,
+                ids: typeof options.ids === "string" ? options.ids : undefined,
+                assignee: typeof options.filterAssignee === "string" ? options.filterAssignee : undefined,
+                assigneeFilter: pickString(options.filterAssigneeFilter, options.filterAssignee_filter),
+                parent: typeof options.filterParent === "string" ? options.filterParent : undefined,
+                sprint: typeof options.filterSprint === "string" ? options.filterSprint : undefined,
+                release: typeof options.filterRelease === "string" ? options.filterRelease : undefined,
+                limit: typeof options.limit === "string" ? options.limit : undefined,
+                offset: typeof options.offset === "string" ? options.offset : undefined,
+            },
+            reason: typeof options.reason === "string" ? options.reason : undefined,
+            resolution: typeof options.resolution === "string" ? options.resolution : undefined,
+            expectedResult: pickString(options.expectedResult, options.expected_result, options.expected),
+            actualResult: pickString(options.actualResult, options.actual_result, options.actual),
+            validateClose: options.validateClose === true
+                ? "warn"
+                : typeof options.validateClose === "string"
+                    ? options.validateClose
+                    : undefined,
+            author: typeof options.author === "string" ? options.author : undefined,
+            message: typeof options.message === "string" ? options.message : undefined,
+            force: Boolean(options.force),
+            dryRun: options.dryRun === true ? true : undefined,
+            rollback: typeof options.rollback === "string" ? options.rollback : undefined,
+            checkpoint: options.checkpoint === false ? false : undefined,
+        }, globalOptions);
+        await invalidateSearchCachesForMutation(globalOptions, result);
+        printResult(result, globalOptions);
+        if (globalOptions.profile) {
+            printError(`profile:command=close-many took_ms=${Date.now() - startedAt}`);
+        }
+    });
     program
         .command("delete")
         .argument("<id>", "Item id")
@@ -405,7 +533,7 @@ export function registerMutationCommands(program) {
         .action(async (id, options, command) => {
         const globalOptions = getGlobalOptions(command);
         const startedAt = Date.now();
-        const { runDelete } = await loadMutationCommandsModule();
+        const { runDelete } = await import("./commands/delete.js");
         const result = await runDelete(id, {
             author: typeof options.author === "string" ? options.author : undefined,
             message: typeof options.message === "string" ? options.message : undefined,
@@ -444,7 +572,7 @@ export function registerMutationCommands(program) {
         if (resolvedBody === undefined) {
             throw new PmCliError("Missing append text. Provide it as positional [text], --body <value>, or --text <value> (use - for stdin).", EXIT_CODE.USAGE);
         }
-        const { runAppend } = await loadMutationCommandsModule();
+        const { runAppend } = await import("./commands/append.js");
         const result = await runAppend(id, {
             body: resolvedBody,
             author: typeof options.author === "string" ? options.author : undefined,
@@ -468,7 +596,7 @@ export function registerMutationCommands(program) {
         .action(async (id, target, options, command) => {
         const globalOptions = getGlobalOptions(command);
         const startedAt = Date.now();
-        const { runRestore } = await loadMutationCommandsModule();
+        const { runRestore } = await import("./commands/restore.js");
         const result = await runRestore(id, target, {
             author: typeof options.author === "string" ? options.author : undefined,
             message: typeof options.message === "string" ? options.message : undefined,
@@ -577,7 +705,7 @@ export function registerMutationCommands(program) {
         .action(async (subcommand, id, stepRef, reorderToken, options, command) => {
         const globalOptions = getGlobalOptions(command);
         const startedAt = Date.now();
-        const { runPlan, PLAN_SUBCOMMANDS } = await loadMutationCommandsModule();
+        const { runPlan, PLAN_SUBCOMMANDS } = await import("./commands/plan.js");
         const normalizedSubcommand = (subcommand ?? "").trim().toLowerCase();
         if (!normalizedSubcommand) {
             throw new PmCliError(`pm plan requires a subcommand. Allowed: ${PLAN_SUBCOMMANDS.join(", ")}`, EXIT_CODE.USAGE, {
@@ -674,7 +802,7 @@ export function registerMutationCommands(program) {
         .action(async (id, options, command) => {
         const globalOptions = getGlobalOptions(command);
         const startedAt = Date.now();
-        const { runHistoryRedact } = await loadMutationCommandsModule();
+        const { runHistoryRedact } = await import("./commands/history-redact.js");
         const literal = Array.isArray(options.literal) ? options.literal : undefined;
         const regex = Array.isArray(options.regex) ? options.regex : undefined;
         const result = await runHistoryRedact(id, {
@@ -705,7 +833,7 @@ export function registerMutationCommands(program) {
         .action(async (id, options, command) => {
         const globalOptions = getGlobalOptions(command);
         const startedAt = Date.now();
-        const { runHistoryRepair } = await loadMutationCommandsModule();
+        const { runHistoryRepair } = await import("./commands/history-repair.js");
         const result = await runHistoryRepair(id, {
             dryRun: options.dryRun === true,
             author: typeof options.author === "string" ? options.author : undefined,
@@ -721,30 +849,36 @@ export function registerMutationCommands(program) {
     });
     const schemaCommand = program
         .command("schema")
-        .argument("[subcommand]", "Schema subcommand: add-type, or a custom item type name shorthand")
-        .argument("[name]", "Custom item type name (for add-type)")
-        .option("--description <text>", "Human description for the custom item type")
+        .argument("[subcommand]", "Schema subcommand: list, show, add-type, remove-type, add-status, remove-status, or a custom item type name shorthand")
+        .argument("[name]", "Item type name (add-type/remove-type/show) or status id (add-status/remove-status)")
+        .option("--description <text>", "Human description for the custom item type or status")
         .option("--default-status <status>", "Default status hint recorded for the custom item type")
         .option("--folder <dir>", "Storage folder for items of this custom type")
-        .option("--alias <name>", "Alias for the custom type (repeatable, csv-friendly)", collect)
+        .option("--alias <name>", "Alias for the custom type or status (repeatable, csv-friendly)", collect)
+        .option("--role <value>", "Lifecycle role for a custom status (repeatable): draft, active, blocked, terminal, terminal_done, terminal_canceled, default_open, default_close, default_cancel", collect)
+        .option("--order <n>", "Display/sort order for a custom status")
         .option("--author <value>", "Mutation author")
         .option("--force", "Force ownership/lock override")
-        .description("Manage config-driven runtime schema: register custom item types into .agents/pm/schema/types.json.");
+        .description("Inspect and manage config-driven runtime schema.");
     // Hidden pure snake_case underscore-duplicate alias.
     addHiddenOption(schemaCommand, "--default_status <status>", "Alias for --default-status", false);
     schemaCommand
         .action(async (subcommand, name, options, command) => {
         const globalOptions = getGlobalOptions(command);
         const startedAt = Date.now();
-        const { runSchemaAddType, formatSchemaAddTypeHuman, SCHEMA_SUBCOMMANDS } = await loadMutationCommandsModule();
+        const { runSchemaAddType, runSchemaRemoveType, runSchemaAddStatus, runSchemaRemoveStatus, runSchemaList, runSchemaShow, formatSchemaAddTypeHuman, formatSchemaRemoveTypeHuman, formatSchemaAddStatusHuman, formatSchemaRemoveStatusHuman, formatSchemaListHuman, formatSchemaShowHuman, SCHEMA_SUBCOMMANDS, } = await import("./commands/schema.js");
         let normalizedSubcommand = (subcommand ?? "").trim().toLowerCase();
         let typeName = name;
         if (!normalizedSubcommand) {
             throw new PmCliError(`pm schema requires a subcommand. Allowed: ${SCHEMA_SUBCOMMANDS.join(", ")}`, EXIT_CODE.USAGE, {
                 code: "missing_required_argument",
                 examples: [
+                    "pm schema list",
+                    "pm schema show Task",
                     'pm schema add-type Spike --description "Time-boxed investigation" --default-status open',
-                    'pm schema add-type Spike --alias spike --alias research',
+                    "pm schema remove-type Spike",
+                    "pm schema add-status review --role active --alias in_review",
+                    "pm schema remove-status review",
                 ],
             });
         }
@@ -753,42 +887,78 @@ export function registerMutationCommands(program) {
             : Array.isArray(options.alias)
                 ? options.alias
                 : undefined;
+        const roles = typeof options.role === "string"
+            ? [options.role]
+            : Array.isArray(options.role)
+                ? options.role
+                : undefined;
         const defaultStatus = typeof options.defaultStatus === "string"
             ? options.defaultStatus
             : typeof options.default_status === "string"
                 ? options.default_status
                 : undefined;
-        const usedAddTypeOption = typeof options.description === "string" ||
-            typeof defaultStatus === "string" ||
-            typeof options.folder === "string" ||
-            (aliases?.length ?? 0) > 0;
-        if (!SCHEMA_SUBCOMMANDS.includes(normalizedSubcommand) &&
-            typeName === undefined &&
-            usedAddTypeOption) {
+        const order = parseSchemaOrderOption(options.order);
+        if (!SCHEMA_SUBCOMMANDS.includes(normalizedSubcommand) && typeName === undefined) {
             typeName = subcommand;
             normalizedSubcommand = "add-type";
         }
         if (!SCHEMA_SUBCOMMANDS.includes(normalizedSubcommand)) {
             throw new PmCliError(`Unknown pm schema subcommand "${subcommand}". Allowed: ${SCHEMA_SUBCOMMANDS.join(", ")}`, EXIT_CODE.USAGE, { code: "unknown_subcommand" });
         }
-        const result = await runSchemaAddType(typeName, {
-            description: typeof options.description === "string" ? options.description : undefined,
-            defaultStatus,
-            folder: typeof options.folder === "string" ? options.folder : undefined,
-            alias: aliases,
-            author: typeof options.author === "string" ? options.author : undefined,
-            force: Boolean(options.force),
-        }, globalOptions);
-        // Registering a type does not touch item content, so search caches stay valid.
+        const author = typeof options.author === "string" ? options.author : undefined;
+        const force = Boolean(options.force);
+        const result = normalizedSubcommand === "list"
+            ? await runSchemaList(globalOptions)
+            : normalizedSubcommand === "show"
+                ? await runSchemaShow(typeName, globalOptions)
+                : normalizedSubcommand === "remove-type"
+                    ? await runSchemaRemoveType(typeName, { author, force }, globalOptions)
+                    : normalizedSubcommand === "add-status"
+                        ? await runSchemaAddStatus(typeName, {
+                            role: roles,
+                            alias: aliases,
+                            description: typeof options.description === "string" ? options.description : undefined,
+                            order,
+                            author,
+                            force,
+                        }, globalOptions)
+                        : normalizedSubcommand === "remove-status"
+                            ? await runSchemaRemoveStatus(typeName, { author, force }, globalOptions)
+                            : await runSchemaAddType(typeName, {
+                                description: typeof options.description === "string" ? options.description : undefined,
+                                defaultStatus,
+                                folder: typeof options.folder === "string" ? options.folder : undefined,
+                                alias: aliases,
+                                author,
+                                force,
+                            }, globalOptions);
+        // Schema inspection and type registration do not touch item content, so search caches stay valid.
         if (globalOptions.json === true || globalOptions.defaultOutputFormat === "json") {
             printResult(result, globalOptions);
         }
         else if (!globalOptions.quiet) {
-            writeStdout(`${formatSchemaAddTypeHuman(result)}\n`);
+            if (result.action === "list") {
+                writeStdout(`${formatSchemaListHuman(result)}\n`);
+            }
+            else if (result.action === "show") {
+                writeStdout(`${formatSchemaShowHuman(result)}\n`);
+            }
+            else if (result.action === "remove-type") {
+                writeStdout(`${formatSchemaRemoveTypeHuman(result)}\n`);
+            }
+            else if (result.action === "add-status") {
+                writeStdout(`${formatSchemaAddStatusHuman(result)}\n`);
+            }
+            else if (result.action === "remove-status") {
+                writeStdout(`${formatSchemaRemoveStatusHuman(result)}\n`);
+            }
+            else {
+                writeStdout(`${formatSchemaAddTypeHuman(result)}\n`);
+            }
             // Surface extension on-write hook diagnostics so policy/enforcement
             // warnings are visible without forcing --json.
-            if (result.warnings.length > 0) {
-                printError(`schema add-type warnings: ${formatHookWarnings(result.warnings)}`);
+            if (result.action !== "list" && result.action !== "show" && result.warnings.length > 0) {
+                printError(`schema ${result.action} warnings: ${formatHookWarnings(result.warnings)}`);
             }
         }
         if (globalOptions.profile) {
@@ -826,7 +996,7 @@ export function registerMutationCommands(program) {
             throw new PmCliError("Specify comment text with exactly one source: positional [text], --add, --stdin, or --file", EXIT_CODE.USAGE);
         }
         const add = addFromOption ?? addFromPositional;
-        const { runComments } = await loadMutationCommandsModule();
+        const { runComments } = await import("./commands/comments.js");
         const result = await runComments(id, {
             add,
             stdin: readFromStdin,
@@ -866,7 +1036,7 @@ export function registerMutationCommands(program) {
             throw new PmCliError("Specify note text either as positional [text] or with --add, not both", EXIT_CODE.USAGE);
         }
         const add = addFromOption ?? addFromPositional;
-        const { runNotes } = await loadMutationCommandsModule();
+        const { runNotes } = await import("./commands/notes.js");
         const result = await runNotes(id, {
             add,
             limit: typeof options.limit === "string" ? options.limit : undefined,
@@ -904,7 +1074,7 @@ export function registerMutationCommands(program) {
             throw new PmCliError("Specify learning text either as positional [text] or with --add, not both", EXIT_CODE.USAGE);
         }
         const add = addFromOption ?? addFromPositional;
-        const { runLearnings } = await loadMutationCommandsModule();
+        const { runLearnings } = await import("./commands/learnings.js");
         const result = await runLearnings(id, {
             add,
             limit: typeof options.limit === "string" ? options.limit : undefined,
@@ -944,7 +1114,7 @@ export function registerMutationCommands(program) {
         const addGlobValues = Array.isArray(options.addGlob) ? options.addGlob : [];
         const removeValues = Array.isArray(options.remove) ? options.remove : [];
         const migrateValues = Array.isArray(options.migrate) ? options.migrate : [];
-        const { runFiles } = await loadMutationCommandsModule();
+        const { runFiles } = await import("./commands/files.js");
         const result = await runFiles(id, {
             add: addValues,
             addGlob: addGlobValues,
@@ -979,7 +1149,7 @@ export function registerMutationCommands(program) {
         .action(async (id, options, command) => {
         const globalOptions = getGlobalOptions(command);
         const startedAt = Date.now();
-        const { runFilesDiscover } = await loadMutationCommandsModule();
+        const { runFilesDiscover } = await import("./commands/files.js");
         const result = await runFilesDiscover(id, {
             apply: Boolean(options.apply),
             note: typeof options.note === "string" ? options.note : undefined,
@@ -1017,7 +1187,7 @@ export function registerMutationCommands(program) {
         const addGlobValues = Array.isArray(options.addGlob) ? options.addGlob : [];
         const removeValues = Array.isArray(options.remove) ? options.remove : [];
         const migrateValues = Array.isArray(options.migrate) ? options.migrate : [];
-        const { runDocs } = await loadMutationCommandsModule();
+        const { runDocs } = await import("./commands/docs.js");
         const result = await runDocs(id, {
             add: addValues,
             addGlob: addGlobValues,
@@ -1049,7 +1219,7 @@ export function registerMutationCommands(program) {
         .action(async (id, options, command) => {
         const globalOptions = getGlobalOptions(command);
         const startedAt = Date.now();
-        const { runDeps } = await loadMutationCommandsModule();
+        const { runDeps } = await import("./commands/deps.js");
         const result = await runDeps(id, {
             format: typeof options.format === "string" ? options.format : undefined,
             maxDepth: typeof options.maxDepth === "string" ? options.maxDepth : undefined,
@@ -1063,4 +1233,4 @@ export function registerMutationCommands(program) {
     });
 }
 //# sourceMappingURL=register-mutation.js.map
-//# debugId=1c5454e2-e849-5b5f-b7a1-2681e8a90eac
+//# debugId=512c19d2-da36-590c-a1ca-cd11e57c7529