@unbrained/pm-cli 2026.5.11 → 2026.5.14

package/dist/cli/register-setup.js

@@ -1,6 +1,13 @@
-import { runConfig, runExtension, runInit, runTemplatesList, runTemplatesSave, runTemplatesShow, } from "./commands/index.js";
-import { collect, getGlobalOptions, normalizeCreateOptions, printError, printResult, } from "./registration-helpers.js";
-function normalizeExtensionOptions(options, forcedAction) {
+import fs from "node:fs/promises";
+import { EXIT_CODE } from "../core/shared/constants.js";
+import { PmCliError } from "../core/shared/errors.js";
+import { collect, getGlobalOptions, printError, printResult, } from "./registration-helpers.js";
+let setupCommandsModulePromise = null;
+async function loadSetupCommandsModule() {
+    setupCommandsModulePromise ??= import("./commands/index.js");
+    return setupCommandsModulePromise;
+}
+function normalizeExtensionOptions(options, forcedAction, vocabulary = "extension") {
     const isForcedAction = (action) => forcedAction === action;
     const readBoolean = (...keys) => keys.some((key) => options[key] === true);
     const readString = (...keys) => {
@@ -20,6 +27,7 @@ function normalizeExtensionOptions(options, forcedAction) {
         manage: isForcedAction("manage") || readBoolean("manage"),
         reload: isForcedAction("reload") || readBoolean("reload"),
         doctor: isForcedAction("doctor") || readBoolean("doctor"),
+        catalog: isForcedAction("catalog") || readBoolean("catalog"),
         adopt: isForcedAction("adopt") || readBoolean("adopt"),
         adoptAll: isForcedAction("adopt-all") || readBoolean("adoptAll", "adopt_all", "adopt-all"),
         activate: isForcedAction("activate") || readBoolean("activate"),
@@ -37,13 +45,37 @@ function normalizeExtensionOptions(options, forcedAction) {
         fixManagedState: readBoolean("fixManagedState", "fix_managed_state", "fix-managed-state"),
         strictExit: readBoolean("strictExit", "strict_exit", "strict-exit"),
         failOnWarn: readBoolean("failOnWarn", "fail_on_warn", "fail-on-warn"),
+        vocabulary,
     };
 }
-import { EXIT_CODE } from "../core/shared/constants.js";
-async function executeExtensionCommand(target, options, command, forcedAction) {
+async function looksLikeShellExpandedWildcard(targets) {
+    if (targets.length <= 1) {
+        return false;
+    }
+    const visibleEntries = (await fs.readdir(process.cwd()))
+        .filter((entry) => !entry.startsWith("."))
+        .sort((left, right) => left.localeCompare(right));
+    const normalizedTargets = [...targets].sort((left, right) => left.localeCompare(right));
+    return (visibleEntries.length === normalizedTargets.length &&
+        visibleEntries.every((entry, index) => entry === normalizedTargets[index]));
+}
+async function normalizeInstallTargets(targets) {
+    const normalizedTargets = (Array.isArray(targets) ? targets : typeof targets === "string" ? [targets] : [])
+        .map((target) => target.trim())
+        .filter((target) => target.length > 0);
+    if (normalizedTargets.length <= 1) {
+        return normalizedTargets[0];
+    }
+    if (await looksLikeShellExpandedWildcard(normalizedTargets)) {
+        return "*";
+    }
+    throw new PmCliError(`Install accepts one package source at a time. To install bundled first-party packages, quote the wildcard: pm install '*'`, EXIT_CODE.USAGE);
+}
+async function executeExtensionCommand(target, options, command, forcedAction, vocabulary = "extension") {
     const globalOptions = getGlobalOptions(command);
     const startedAt = Date.now();
-    const normalizedOptions = normalizeExtensionOptions(options, forcedAction);
+    const normalizedOptions = normalizeExtensionOptions(options, forcedAction, vocabulary);
+    const { runExtension } = await loadSetupCommandsModule();
     const result = await runExtension(target, normalizedOptions, globalOptions);
     printResult(result, globalOptions);
     const strictExit = Boolean(normalizedOptions.strictExit) || Boolean(normalizedOptions.failOnWarn);
@@ -66,6 +98,125 @@ function addExtensionScopeOptions(command) {
         .option("--local", "Alias for --project")
         .option("--global", "Use global extension scope");
 }
+function addPackageScopeOptions(command) {
+    return command
+        .option("--project", "Use project package scope (default)")
+        .option("--local", "Alias for --project")
+        .option("--global", "Use global package scope");
+}
+function addLifecycleScopeOptions(command, vocabulary) {
+    return vocabulary === "package" ? addPackageScopeOptions(command) : addExtensionScopeOptions(command);
+}
+function registerLifecycleCommand(program, vocabulary) {
+    const noun = vocabulary === "package" ? "package" : "extension";
+    const plural = vocabulary === "package" ? "packages" : "extensions";
+    const commandName = vocabulary;
+    const lifecycleCommand = program
+        .command(commandName)
+        .argument("[target]", `${noun[0].toUpperCase()}${noun.slice(1)} source/name or scaffold target path (for --init/--scaffold)`)
+        .option("--init", `Generate a starter ${noun} scaffold at target path`)
+        .option("--scaffold", "Alias for --init")
+        .option("--install", `Install ${noun} from local path or GitHub source`)
+        .option("--uninstall", `Uninstall an installed ${noun}`)
+        .option("--explore", `List discovered ${plural} in selected scope`)
+        .option("--manage", `List managed ${plural} with update-check metadata`)
+        .option("--reload", `Reload ${plural} with cache-busted module imports`)
+        .option("--watch", "Use watch mode with --reload")
+        .option("--doctor", `Run consolidated ${noun} diagnostics (summary/deep modes)`)
+        .option("--catalog", `List bundled first-party ${noun} catalog metadata`)
+        .option("--adopt", `Adopt an existing unmanaged ${noun} into managed metadata`)
+        .option("--adopt-all", `Adopt all unmanaged ${plural} into managed metadata`)
+        .option("--activate", `Activate a ${noun} in selected scope settings`)
+        .option("--deactivate", `Deactivate a ${noun} in selected scope settings`)
+        .option("--project", `Use project ${noun} scope (default)`)
+        .option("--local", "Alias for --project")
+        .option("--global", `Use global ${noun} scope`)
+        .option("--gh <owner/repo[/path]>", "Install from GitHub shorthand source")
+        .option("--github <owner/repo[/path]>", "Alias for --gh")
+        .option("--ref <ref>", "Git ref/branch/tag for GitHub install sources")
+        .option("--detail <mode>", `${noun[0].toUpperCase()}${noun.slice(1)} diagnostics detail mode (summary|deep)`)
+        .option("--trace", "Include actionable registration traces in doctor deep diagnostics")
+        .option("--runtime-probe", "Opt-in runtime activation probe for manage output parity")
+        .option("--fix-managed-state", `Adopt unmanaged ${plural} before diagnostics/update checks`)
+        .option("--strict-exit", "Return non-zero exit when doctor warnings are present (ok=false)")
+        .option("--fail-on-warn", "Alias for --strict-exit (doctor)")
+        .description(vocabulary === "package"
+        ? "Manage package lifecycle operations for project or global scope. Backward-compatible with extension packages."
+        : "Manage extension lifecycle operations for project or global scope.")
+        .action(async (target, _options, command) => {
+        await executeExtensionCommand(target, command.opts(), command, undefined, vocabulary);
+    });
+    if (vocabulary === "package") {
+        lifecycleCommand.alias("packages");
+    }
+    addLifecycleScopeOptions(lifecycleCommand
+        .command("init")
+        .alias("scaffold")
+        .argument("<target>", `Scaffold target directory path`)
+        .description(`Generate a starter ${noun} scaffold with manifest and entrypoint.`), vocabulary).action(async (target, _options, command) => {
+        await executeExtensionCommand(target, command.opts(), command, "init", vocabulary);
+    });
+    addLifecycleScopeOptions(lifecycleCommand
+        .command("install")
+        .argument("[targets...]", `${noun[0].toUpperCase()}${noun.slice(1)} source (local path, bundled alias, wildcard, or GitHub source)`)
+        .option("--gh <owner/repo[/path]>", "Install from GitHub shorthand source")
+        .option("--github <owner/repo[/path]>", "Alias for --gh")
+        .option("--ref <ref>", "Git ref/branch/tag for GitHub install sources")
+        .description(`Install ${noun} from local path or GitHub source.`), vocabulary).action(async (targets, _options, command) => {
+        const target = await normalizeInstallTargets(targets);
+        await executeExtensionCommand(target, command.opts(), command, "install", vocabulary);
+    });
+    addLifecycleScopeOptions(lifecycleCommand.command("uninstall").argument("<target>", `${noun[0].toUpperCase()}${noun.slice(1)} name`).description(`Uninstall an installed ${noun}.`), vocabulary).action(async (target, _options, command) => {
+        await executeExtensionCommand(target, command.opts(), command, "uninstall", vocabulary);
+    });
+    addLifecycleScopeOptions(lifecycleCommand.command("explore").description(`List discovered ${plural} in selected scope.`), vocabulary).action(async (_options, command) => {
+        await executeExtensionCommand(undefined, command.opts(), command, "explore", vocabulary);
+    });
+    addLifecycleScopeOptions(lifecycleCommand
+        .command("manage")
+        .option("--runtime-probe", "Opt-in runtime activation probe for manage output parity")
+        .option("--fix-managed-state", `Adopt unmanaged ${plural} before diagnostics/update checks`)
+        .description(`List managed ${plural} with update-check metadata.`), vocabulary).action(async (_options, command) => {
+        await executeExtensionCommand(undefined, command.opts(), command, "manage", vocabulary);
+    });
+    addLifecycleScopeOptions(lifecycleCommand
+        .command("reload")
+        .option("--watch", "Use watch mode for repeated reload checks")
+        .description(`Reload ${plural} with cache-busted module imports.`), vocabulary).action(async (_options, command) => {
+        await executeExtensionCommand(undefined, command.opts(), command, "reload", vocabulary);
+    });
+    addLifecycleScopeOptions(lifecycleCommand
+        .command("doctor")
+        .option("--detail <mode>", `Detail mode for ${noun} diagnostics (summary|deep)`)
+        .option("--trace", "Include actionable registration traces in doctor deep diagnostics")
+        .option("--fix-managed-state", `Adopt unmanaged ${plural} before diagnostics/update checks`)
+        .option("--strict-exit", "Return non-zero exit when doctor warnings are present (ok=false)")
+        .option("--fail-on-warn", "Alias for --strict-exit (doctor)")
+        .description(`Run consolidated ${noun} diagnostics (summary/deep modes).`), vocabulary).action(async (_options, command) => {
+        await executeExtensionCommand(undefined, command.opts(), command, "doctor", vocabulary);
+    });
+    addLifecycleScopeOptions(lifecycleCommand.command("catalog").alias("list").description(`List bundled first-party ${noun} catalog metadata.`), vocabulary).action(async (_options, command) => {
+        await executeExtensionCommand(undefined, command.opts(), command, "catalog", vocabulary);
+    });
+    addLifecycleScopeOptions(lifecycleCommand
+        .command("adopt")
+        .argument("<target>", `${noun[0].toUpperCase()}${noun.slice(1)} name`)
+        .option("--gh <owner/repo[/path]>", `GitHub provenance shorthand for adopted ${noun}`)
+        .option("--github <owner/repo[/path]>", "Alias for --gh")
+        .option("--ref <ref>", "Git ref/branch/tag for GitHub shorthand source")
+        .description(`Adopt an existing unmanaged ${noun} into managed metadata.`), vocabulary).action(async (target, _options, command) => {
+        await executeExtensionCommand(target, command.opts(), command, "adopt", vocabulary);
+    });
+    addLifecycleScopeOptions(lifecycleCommand.command("adopt-all").description(`Adopt all unmanaged ${plural} into managed metadata.`), vocabulary).action(async (_options, command) => {
+        await executeExtensionCommand(undefined, command.opts(), command, "adopt-all", vocabulary);
+    });
+    addLifecycleScopeOptions(lifecycleCommand.command("activate").argument("<target>", `${noun[0].toUpperCase()}${noun.slice(1)} name`).description(`Activate a ${noun} in selected scope settings.`), vocabulary).action(async (target, _options, command) => {
+        await executeExtensionCommand(target, command.opts(), command, "activate", vocabulary);
+    });
+    addLifecycleScopeOptions(lifecycleCommand.command("deactivate").argument("<target>", `${noun[0].toUpperCase()}${noun.slice(1)} name`).description(`Deactivate a ${noun} in selected scope settings.`), vocabulary).action(async (target, _options, command) => {
+        await executeExtensionCommand(target, command.opts(), command, "deactivate", vocabulary);
+    });
+}
 export function registerSetupCommands(program) {
     program
         .command("init")
@@ -77,6 +228,7 @@ export function registerSetupCommands(program) {
         .action(async (prefix, options, command) => {
         const globalOptions = getGlobalOptions(command);
         const startedAt = Date.now();
+        const { runInit } = await loadSetupCommandsModule();
         const result = await runInit(prefix, globalOptions, {
             preset: typeof options.preset === "string" ? options.preset : undefined,
             defaults: options.defaults === true,
@@ -112,6 +264,7 @@ export function registerSetupCommands(program) {
         const globalOptions = getGlobalOptions(command);
         const startedAt = Date.now();
         const criteria = Array.isArray(options.criterion) ? options.criterion : [];
+        const { runConfig } = await loadSetupCommandsModule();
         const result = await runConfig(scope, action, key, {
             criterion: criteria,
             format: typeof options.format === "string" ? options.format : undefined,
@@ -134,214 +287,38 @@ export function registerSetupCommands(program) {
             printError(`profile:command=config took_ms=${Date.now() - startedAt}`);
         }
     });
-    const extensionCommand = program
-        .command("extension")
-        .argument("[target]", "Extension source/name or scaffold target path (for --init/--scaffold)")
-        .option("--init", "Generate a starter extension scaffold at target path")
-        .option("--scaffold", "Alias for --init")
-        .option("--install", "Install extension from local path or GitHub source")
-        .option("--uninstall", "Uninstall an installed extension")
-        .option("--explore", "List discovered extensions in selected scope")
-        .option("--manage", "List managed extensions with update-check metadata")
-        .option("--reload", "Reload extensions with cache-busted module imports")
-        .option("--watch", "Use watch mode with --reload")
-        .option("--doctor", "Run consolidated extension diagnostics (summary/deep modes)")
-        .option("--adopt", "Adopt an existing unmanaged extension into managed metadata")
-        .option("--adopt-all", "Adopt all unmanaged extensions into managed metadata")
-        .option("--activate", "Activate an extension in selected scope settings")
-        .option("--deactivate", "Deactivate an extension in selected scope settings")
-        .option("--project", "Use project extension scope (default)")
-        .option("--local", "Alias for --project")
-        .option("--global", "Use global extension scope")
-        .option("--gh <owner/repo[/path]>", "Install from GitHub shorthand source")
-        .option("--github <owner/repo[/path]>", "Alias for --gh")
-        .option("--ref <ref>", "Git ref/branch/tag for GitHub install sources")
-        .option("--detail <mode>", "Detail mode for extension diagnostics (summary|deep)")
-        .option("--trace", "Include actionable registration traces in doctor deep diagnostics")
-        .option("--runtime-probe", "Opt-in runtime activation probe for manage output parity")
-        .option("--fix-managed-state", "Adopt unmanaged extensions before diagnostics/update checks")
-        .option("--strict-exit", "Return non-zero exit when doctor warnings are present (ok=false)")
-        .option("--fail-on-warn", "Alias for --strict-exit (doctor)")
-        .description("Manage extension lifecycle operations for project or global scope.")
-        .action(async (target, _options, command) => {
-        await executeExtensionCommand(target, command.opts(), command);
-    });
-    addExtensionScopeOptions(extensionCommand
-        .command("init")
-        .alias("scaffold")
-        .argument("<target>", "Scaffold target directory path")
-        .description("Generate a starter extension scaffold with manifest and entrypoint.")).action(async (target, _options, command) => {
-        await executeExtensionCommand(target, command.opts(), command, "init");
-    });
-    addExtensionScopeOptions(extensionCommand
+    registerLifecycleCommand(program, "extension");
+    registerLifecycleCommand(program, "package");
+    addPackageScopeOptions(program
         .command("install")
-        .argument("[target]", "Extension source (local path or GitHub source)")
+        .argument("[targets...]", "Package source (local path, bundled alias, wildcard, or GitHub source)")
         .option("--gh <owner/repo[/path]>", "Install from GitHub shorthand source")
         .option("--github <owner/repo[/path]>", "Alias for --gh")
         .option("--ref <ref>", "Git ref/branch/tag for GitHub install sources")
-        .description("Install extension from local path or GitHub source.")).action(async (target, _options, command) => {
-        await executeExtensionCommand(target, command.opts(), command, "install");
-    });
-    addExtensionScopeOptions(extensionCommand.command("uninstall").argument("<target>", "Extension name").description("Uninstall an installed extension.")).action(async (target, _options, command) => {
-        await executeExtensionCommand(target, command.opts(), command, "uninstall");
-    });
-    addExtensionScopeOptions(extensionCommand.command("explore").description("List discovered extensions in selected scope.")).action(async (_options, command) => {
-        await executeExtensionCommand(undefined, command.opts(), command, "explore");
-    });
-    addExtensionScopeOptions(extensionCommand
-        .command("manage")
-        .option("--runtime-probe", "Opt-in runtime activation probe for manage output parity")
-        .option("--fix-managed-state", "Adopt unmanaged extensions before diagnostics/update checks")
-        .description("List managed extensions with update-check metadata.")).action(async (_options, command) => {
-        await executeExtensionCommand(undefined, command.opts(), command, "manage");
-    });
-    addExtensionScopeOptions(extensionCommand
-        .command("reload")
-        .option("--watch", "Use watch mode for repeated reload checks")
-        .description("Reload extensions with cache-busted module imports.")).action(async (_options, command) => {
-        await executeExtensionCommand(undefined, command.opts(), command, "reload");
+        .description("Install a pm package into the project package scope by default.")).action(async (targets, _options, command) => {
+        const target = await normalizeInstallTargets(targets);
+        await executeExtensionCommand(target, command.opts(), command, "install", "package");
     });
-    addExtensionScopeOptions(extensionCommand
-        .command("doctor")
-        .option("--detail <mode>", "Detail mode for extension diagnostics (summary|deep)")
-        .option("--trace", "Include actionable registration traces in doctor deep diagnostics")
-        .option("--fix-managed-state", "Adopt unmanaged extensions before diagnostics/update checks")
-        .option("--strict-exit", "Return non-zero exit when doctor warnings are present (ok=false)")
-        .option("--fail-on-warn", "Alias for --strict-exit (doctor)")
-        .description("Run consolidated extension diagnostics (summary/deep modes).")).action(async (_options, command) => {
-        await executeExtensionCommand(undefined, command.opts(), command, "doctor");
-    });
-    addExtensionScopeOptions(extensionCommand
-        .command("adopt")
-        .argument("<target>", "Extension name")
-        .option("--gh <owner/repo[/path]>", "GitHub provenance shorthand for adopted extension")
-        .option("--github <owner/repo[/path]>", "Alias for --gh")
-        .option("--ref <ref>", "Git ref/branch/tag for GitHub shorthand source")
-        .description("Adopt an existing unmanaged extension into managed metadata.")).action(async (target, _options, command) => {
-        await executeExtensionCommand(target, command.opts(), command, "adopt");
-    });
-    addExtensionScopeOptions(extensionCommand.command("adopt-all").description("Adopt all unmanaged extensions into managed metadata.")).action(async (_options, command) => {
-        await executeExtensionCommand(undefined, command.opts(), command, "adopt-all");
-    });
-    addExtensionScopeOptions(extensionCommand.command("activate").argument("<target>", "Extension name").description("Activate an extension in selected scope settings.")).action(async (target, _options, command) => {
-        await executeExtensionCommand(target, command.opts(), command, "activate");
-    });
-    addExtensionScopeOptions(extensionCommand.command("deactivate").argument("<target>", "Extension name").description("Deactivate an extension in selected scope settings.")).action(async (target, _options, command) => {
-        await executeExtensionCommand(target, command.opts(), command, "deactivate");
-    });
-    const templatesCommand = program
-        .command("templates")
-        .description("Manage reusable create templates.")
-        .action(async () => {
-        const globalOptions = program.opts();
-        const result = await runTemplatesList(globalOptions);
-        printResult(result, globalOptions);
-    });
-    templatesCommand
-        .command("save")
-        .argument("<name>", "Template name")
-        .option("--title, -t <value>", "Template default item title")
-        .option("--description, -d <value>", "Template default item description")
-        .option("--type <value>", "Template default item type")
-        .option("--status, -s <value>", "Template default item status")
-        .option("--priority, -p <value>", "Template default priority 0..4")
-        .option("--tags <value>", "Template default comma-separated tags")
-        .option("--body, -b <value>", "Template default item markdown body")
-        .option("--deadline <value>", "Template default deadline")
-        .option("--estimate, --estimated-minutes <value>", "Template default estimated minutes")
-        .option("--estimated_minutes <value>", "Alias for --estimated-minutes")
-        .option("--acceptance-criteria <value>", "Template default acceptance criteria")
-        .option("--acceptance_criteria <value>", "Alias for --acceptance-criteria")
-        .option("--ac <value>", "Alias for --acceptance-criteria")
-        .option("--definition-of-ready <value>", "Template default definition of ready")
-        .option("--definition_of_ready <value>", "Alias for --definition-of-ready")
-        .option("--order <value>", "Template default planning order/rank integer")
-        .option("--rank <value>", "Alias for --order")
-        .option("--goal <value>", "Template default goal identifier")
-        .option("--objective <value>", "Template default objective identifier")
-        .option("--value <value>", "Template default business value summary")
-        .option("--impact <value>", "Template default business impact summary")
-        .option("--outcome <value>", "Template default expected outcome summary")
-        .option("--why-now <value>", "Template default why-now rationale")
-        .option("--why_now <value>", "Alias for --why-now")
-        .option("--author <value>", "Template default mutation author")
-        .option("--message <value>", "Template default history message")
-        .option("--assignee <value>", "Template default assignee")
-        .option("--parent <value>", "Template default parent item ID")
-        .option("--reviewer <value>", "Template default reviewer")
-        .option("--risk <value>", "Template default risk level")
-        .option("--confidence <value>", "Template default confidence")
-        .option("--sprint <value>", "Template default sprint identifier")
-        .option("--release <value>", "Template default release identifier")
-        .option("--blocked-by <value>", "Template default blocked-by item ID or reason")
-        .option("--blocked_by <value>", "Alias for --blocked-by")
-        .option("--blocked-reason <value>", "Template default blocked reason")
-        .option("--blocked_reason <value>", "Alias for --blocked-reason")
-        .option("--unblock-note <value>", "Template default unblock rationale note")
-        .option("--unblock_note <value>", "Alias for --unblock-note")
-        .option("--reporter <value>", "Template default issue reporter")
-        .option("--severity <value>", "Template default issue severity")
-        .option("--environment <value>", "Template default issue environment context")
-        .option("--repro-steps <value>", "Template default issue reproduction steps")
-        .option("--repro_steps <value>", "Alias for --repro-steps")
-        .option("--resolution <value>", "Template default issue resolution summary")
-        .option("--expected-result <value>", "Template default issue expected behavior")
-        .option("--expected_result <value>", "Alias for --expected-result")
-        .option("--actual-result <value>", "Template default issue observed behavior")
-        .option("--actual_result <value>", "Alias for --actual-result")
-        .option("--affected-version <value>", "Template default affected version identifier")
-        .option("--affected_version <value>", "Alias for --affected-version")
-        .option("--fixed-version <value>", "Template default fixed version identifier")
-        .option("--fixed_version <value>", "Alias for --fixed-version")
-        .option("--component <value>", "Template default issue component ownership")
-        .option("--regression <value>", "Template default regression marker")
-        .option("--customer-impact <value>", "Template default customer impact summary")
-        .option("--customer_impact <value>", "Alias for --customer-impact")
-        .option("--dep <value>", "Template default dependency entry (repeatable; CSV/markdown pairs or - for stdin)", collect)
-        .option("--type-option <value>", "Template default type option entry (repeatable; key=value or markdown pairs; use - for stdin)", collect)
-        .option("--type_option <value>", "Alias for --type-option", collect)
-        .option("--reminder <value>", "Template default reminder entry (repeatable; at=<iso|relative>,text=<text>)", collect)
-        .option("--event <value>", "Template default event entry (repeatable; start/end/title/recur_* fields)", collect)
-        .option("--comment <value>", "Template default comment seed entry (repeatable; text=<value> CSV/markdown pairs or - for stdin)", collect)
-        .option("--note <value>", "Template default note seed entry (repeatable; text=<value> CSV/markdown pairs or - for stdin)", collect)
-        .option("--learning <value>", "Template default learning seed entry (repeatable; text=<value> CSV/markdown pairs or - for stdin)", collect)
-        .option("--file <value>", "Template default linked file entry (repeatable; CSV/markdown pairs or - for stdin)", collect)
-        .option("--test <value>", "Template default linked test entry (repeatable; CSV/markdown pairs or - for stdin)", collect)
-        .option("--doc <value>", "Template default linked doc entry (repeatable; CSV/markdown pairs or - for stdin)", collect)
-        .description("Save or update a named create template.")
-        .action(async (name, options, command) => {
-        const globalOptions = getGlobalOptions(command);
-        const startedAt = Date.now();
-        const normalized = normalizeCreateOptions(options, { requireType: false });
-        const result = await runTemplatesSave(name, normalized, globalOptions);
-        printResult(result, globalOptions);
-        if (globalOptions.profile) {
-            printError(`profile:command=templates save took_ms=${Date.now() - startedAt}`);
-        }
-    });
-    templatesCommand
-        .command("list")
-        .description("List saved create templates.")
-        .action(async (_options, command) => {
+    addPackageScopeOptions(program
+        .command("upgrade")
+        .argument("[target]", "Optional managed package name/source to upgrade; omit to upgrade pm CLI and all managed packages")
+        .option("--dry-run", "Plan CLI/package upgrades without running npm or reinstalling packages")
+        .option("--cli-only", "Upgrade only the pm CLI/SDK npm package")
+        .option("--packages-only", "Upgrade only managed pm packages")
+        .option("--repair", "Force npm global reinstall when upgrading the pm CLI/SDK")
+        .option("--tag <value>", "npm dist-tag/version for CLI and registry package upgrades")
+        .option("--package-name <value>", "Override the CLI package name for self-upgrade testing")
+        .description("Upgrade the pm CLI/SDK and refresh managed installable pm packages.")).action(async (target, _options, command) => {
         const globalOptions = getGlobalOptions(command);
         const startedAt = Date.now();
-        const result = await runTemplatesList(globalOptions);
+        const { runUpgrade } = await loadSetupCommandsModule();
+        const result = await runUpgrade(target, command.opts(), globalOptions);
         printResult(result, globalOptions);
-        if (globalOptions.profile) {
-            printError(`profile:command=templates list took_ms=${Date.now() - startedAt}`);
+        if (!result.ok) {
+            process.exitCode = EXIT_CODE.GENERIC_FAILURE;
         }
-    });
-    templatesCommand
-        .command("show")
-        .argument("<name>", "Template name")
-        .description("Show saved create template details.")
-        .action(async (name, _options, command) => {
-        const globalOptions = getGlobalOptions(command);
-        const startedAt = Date.now();
-        const result = await runTemplatesShow(name, globalOptions);
-        printResult(result, globalOptions);
         if (globalOptions.profile) {
-            printError(`profile:command=templates show took_ms=${Date.now() - startedAt}`);
+            printError(`profile:command=upgrade took_ms=${Date.now() - startedAt}`);
         }
     });
 }