@unbrained/pm-cli 2026.7.7 → 2026.7.9

package/dist/sdk/runtime.js

@@ -4,7 +4,7 @@
  * Defines public SDK APIs and package-author helpers for Runtime.
  */
 
-!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]="89db1e15-b152-57e2-910d-64ed77eb540b")}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]="a1d2566f-bb81-5e21-aaab-f501f90657ed")}catch(e){}}();
 import path from "node:path";
 import { createEmptyExtensionCommandRegistry, createEmptyExtensionHookRegistry, createEmptyExtensionParserRegistry, createEmptyExtensionPreflightRegistry, createEmptyExtensionRegistrationRegistry, createEmptyExtensionRendererRegistry, createEmptyExtensionServiceRegistry, } from "../core/extensions/extension-registries.js";
 import { activateExtensions, deactivateExtensions, loadExtensions, runActiveCommandHandler, setActiveExtensionCommands, setActiveExtensionHooks, setActiveExtensionParsers, setActiveExtensionPreflight, setActiveExtensionRegistrations, setActiveExtensionRenderers, setActiveExtensionServices, } from "../core/extensions/index.js";
@@ -63,13 +63,8 @@ export { runReindex } from "../cli/commands/reindex.js";
 export { loadCreateTemplateOptions, runTemplatesList, runTemplatesSave, runTemplatesShow, } from "../cli/commands/templates.js";
 export { runTestRunsList, runTestRunsLogs, runTestRunsResume, runTestRunsStatus, runTestRunsStop, } from "../cli/commands/test-runs.js";
 export { CONFIDENCE_TEXT_VALUES, DEPENDENCY_KIND_VALUES, BUILTIN_ITEM_TYPE_VALUES, ISSUE_SEVERITY_VALUES, ITEM_TYPE_VALUES, RISK_VALUES, STATUS_VALUES, } from "../types/index.js";
-function splitClientMutationOptions(options) {
-    const { fullChangedFields, idOnly, ...runnerOptions } = options;
-    return {
-        ...(fullChangedFields === undefined ? {} : { fullChangedFields }),
-        ...(idOnly === undefined ? {} : { idOnly }),
-        options: runnerOptions,
-    };
+function splitFullClientMutationOptions(options) {
+    return { fullChangedFields: true, options };
 }
 /**
  * Programmatic pm client for custom tools, CI jobs, bots, and embedded runtimes.
@@ -146,83 +141,378 @@ export class PmClient {
     stats(options = {}) {
         return this.runTyped("stats", { options });
     }
+    /**
+     * List, add, edit, or delete item comments.
+     */
+    comments(id, options = {}) {
+        return this.runTyped("comments", { id, options });
+    }
+    /**
+     * List or append private item notes.
+     */
+    notes(id, options = {}) {
+        return this.runTyped("notes", { id, options });
+    }
+    /**
+     * List or append durable item learnings.
+     */
+    learnings(id, options = {}) {
+        return this.runTyped("learnings", { id, options });
+    }
+    /**
+     * Add, remove, clear, or list linked project files for an item.
+     */
+    files(id, options = {}) {
+        return this.runTyped("files", { id, options });
+    }
+    /**
+     * Discover and optionally attach changed files for an item.
+     */
+    filesDiscover(id, options = {}) {
+        return this.runTyped("files-discover", { id, options });
+    }
+    /**
+     * Add, remove, clear, or list linked documentation for an item.
+     */
+    docs(id, options = {}) {
+        return this.runTyped("docs", { id, options });
+    }
+    /**
+     * Inspect item dependency relationships.
+     */
+    deps(id, options = {}) {
+        return this.runTyped("deps", { id, options });
+    }
+    /**
+     * Append markdown/body text to an item through the mutation pipeline.
+     */
+    append(id, body, options = {}) {
+        return this.runTyped("append", { id, ...splitFullClientMutationOptions({ ...options, body }) });
+    }
+    /**
+     * Initialize a workspace with the same semantics as `pm init`.
+     */
+    init(prefix, options = {}) {
+        return this.runTyped("init", { ...(prefix === undefined ? {} : { prefix }), options });
+    }
+    /**
+     * Read or update project/global configuration.
+     */
+    config(scope, configAction, key, value, options = {}) {
+        return this.runTyped("config", {
+            scope,
+            configAction,
+            ...(key === undefined ? {} : { key }),
+            ...(value === undefined ? {} : { value }),
+            options,
+        });
+    }
+    /**
+     * Run the schema customization surface.
+     */
+    schema(subcommand, options = {}) {
+        return this.runTyped("schema", { options: { ...options, subcommand } });
+    }
+    /**
+     * List built-in, custom, and extension-provided schema types/statuses.
+     */
+    schemaList() {
+        return this.runTyped("schema", { options: { subcommand: "list" } });
+    }
+    /**
+     * Show a schema item type definition.
+     */
+    schemaShow(name) {
+        return this.runTyped("schema", { name, options: { subcommand: "show" } });
+    }
+    /**
+     * Register or replace a custom item type.
+     */
+    schemaAddType(name, options = {}) {
+        return this.runTyped("schema", { name, options: { ...options, subcommand: "add-type" } });
+    }
+    /**
+     * Remove a custom item type.
+     */
+    schemaRemoveType(name, options = {}) {
+        return this.runTyped("schema", { name, options: { ...options, subcommand: "remove-type" } });
+    }
+    /**
+     * Register or replace a custom status.
+     */
+    schemaAddStatus(name, options = {}) {
+        return this.runTyped("schema", { name, options: { ...options, subcommand: "add-status" } });
+    }
+    /**
+     * Remove a custom status.
+     */
+    schemaRemoveStatus(name, options = {}) {
+        return this.runTyped("schema", { name, options: { ...options, subcommand: "remove-status" } });
+    }
+    /**
+     * Register or replace a runtime custom field.
+     */
+    schemaAddField(name, options = {}) {
+        return this.runTyped("schema", { name, options: { ...options, subcommand: "add-field" } });
+    }
+    /**
+     * Remove a runtime custom field.
+     */
+    schemaRemoveField(name, options = {}) {
+        return this.runTyped("schema", { name, options: { ...options, subcommand: "remove-field" } });
+    }
+    /**
+     * List runtime custom fields.
+     */
+    schemaListFields() {
+        return this.runTyped("schema", { options: { subcommand: "list-fields" } });
+    }
+    /**
+     * Show one runtime custom field definition.
+     */
+    schemaShowField(name) {
+        return this.runTyped("schema", { name, options: { subcommand: "show-field" } });
+    }
+    /**
+     * Apply a built-in type preset to the workspace schema.
+     */
+    schemaApplyPreset(typePreset, options = {}) {
+        return this.runTyped("schema", { typePreset, options: { ...options, subcommand: "apply-preset" } });
+    }
+    /**
+     * Infer item types from the current tracker and optionally apply them.
+     */
+    schemaInferTypes(options = {}) {
+        return this.runTyped("schema", { options: { ...options, subcommand: "add-type", infer: true } });
+    }
+    /**
+     * Show one runtime status definition.
+     */
+    schemaShowStatus(name) {
+        return this.runTyped("schema", { name, options: { subcommand: "show-status" } });
+    }
+    /**
+     * Run the profile customization surface.
+     */
+    profile(subcommand, options = {}) {
+        return this.runTyped("profile", { options: { ...options, subcommand } });
+    }
+    /**
+     * List available project profiles.
+     */
+    profileList() {
+        return this.runTyped("profile", { options: { subcommand: "list" } });
+    }
+    /**
+     * Show a project profile.
+     */
+    profileShow(name) {
+        return this.runTyped("profile", { name, options: { subcommand: "show" } });
+    }
+    /**
+     * Apply a project profile.
+     */
+    profileApply(name, options = {}) {
+        return this.runTyped("profile", { name, options: { ...options, subcommand: "apply" } });
+    }
+    /**
+     * Lint a project profile.
+     */
+    profileLint(name) {
+        return this.runTyped("profile", { name, options: { subcommand: "lint" } });
+    }
+    /**
+     * Run project validation checks.
+     */
+    validate(options = {}) {
+        return this.runTyped("validate", { options });
+    }
+    /**
+     * Run project health checks.
+     */
+    health(options = {}) {
+        return this.runTyped("health", { options });
+    }
+    /**
+     * Run tracker cache/runtime garbage collection.
+     */
+    gc(options = {}) {
+        return this.runTyped("gc", { options });
+    }
     /**
      * Create an item using the same mutation path as `pm create`.
      */
     create(options = {}) {
-        return this.run("create", splitClientMutationOptions(options));
+        return this.runTyped("create", splitFullClientMutationOptions(options));
     }
     /**
      * Update an item using the same mutation path as `pm update`.
      */
     update(id, options = {}) {
-        return this.run("update", { id, ...splitClientMutationOptions(options) });
+        return this.runTyped("update", { id, ...splitFullClientMutationOptions(options) });
     }
     /**
      * Close an item using the same mutation path as `pm close`.
      */
     close(id, reason, options = {}) {
-        return this.run("close", { id, reason, ...splitClientMutationOptions(options) });
+        return this.runTyped("close", { id, reason, ...splitFullClientMutationOptions(options) });
     }
     /**
      * Claim an item using the same mutation path as `pm claim`.
      */
     claim(id, options = {}) {
-        return this.run("claim", { id, ...splitClientMutationOptions(options) });
+        return this.runTyped("claim", { id, ...splitFullClientMutationOptions(options) });
     }
     /**
      * Release an item's active claim using the same mutation path as `pm release`.
      */
     release(id, options = {}) {
-        return this.run("release", { id, ...splitClientMutationOptions(options) });
+        return this.runTyped("release", { id, ...splitFullClientMutationOptions(options) });
     }
     /**
      * Copy an item using the same mutation path as `pm copy`.
      */
     copy(id, options = {}) {
-        return this.run("copy", { id, ...splitClientMutationOptions(options) });
+        return this.runTyped("copy", { id, ...splitFullClientMutationOptions(options) });
     }
     /**
      * Delete an item using the same mutation path as `pm delete`.
      */
     delete(id, options = {}) {
-        return this.run("delete", { id, ...splitClientMutationOptions(options) });
+        return this.runTyped("delete", { id, ...splitFullClientMutationOptions(options) });
     }
     /**
      * Restore an item to a history version or timestamp using `pm restore`.
      */
     restore(id, target, options = {}) {
-        const { fullChangedFields, idOnly, ...runnerOptions } = options;
-        return this.run("restore", {
-            ...(fullChangedFields === undefined ? {} : { fullChangedFields }),
-            ...(idOnly === undefined ? {} : { idOnly }),
+        return this.runTyped("restore", {
+            fullChangedFields: true,
             id,
-            options: { ...runnerOptions, target },
+            options: { ...options, target },
         });
     }
     /**
      * Set, clear, or read workspace focus using the same path as `pm focus`.
      */
     focus(id, options = {}) {
-        return this.run("focus", { ...(id === undefined ? {} : { id }), ...splitClientMutationOptions(options) });
+        return this.runTyped("focus", { ...(id === undefined ? {} : { id }), ...splitFullClientMutationOptions(options) });
     }
     /**
      * Claim an item and transition it to the workspace in-progress status.
      */
     startTask(id, options = {}) {
-        return this.run("start-task", { id, ...splitClientMutationOptions(options) });
+        return this.runTyped("start-task", { id, ...splitFullClientMutationOptions(options) });
     }
     /**
      * Move an item back to the workspace open status and release the claim.
      */
     pauseTask(id, options = {}) {
-        return this.run("pause-task", { id, ...splitClientMutationOptions(options) });
+        return this.runTyped("pause-task", { id, ...splitFullClientMutationOptions(options) });
     }
     /**
      * Close an item and release its active assignment.
      */
     closeTask(id, reason, options = {}) {
-        return this.run("close-task", { id, reason, ...splitClientMutationOptions(options) });
+        return this.runTyped("close-task", { id, reason, ...splitFullClientMutationOptions(options) });
+    }
+    /**
+     * Run the extension lifecycle surface with the same result shape as `pm extension`.
+     */
+    extension(target, options = {}) {
+        return this.runTyped("extension", { ...(target === undefined ? {} : { target }), options });
+    }
+    /**
+     * List project or global extensions without constructing command-line argv.
+     */
+    extensionList(options = {}) {
+        return this.extension("list", options);
+    }
+    /**
+     * Enable an installed extension using the same action as `pm extension activate`.
+     */
+    extensionActivate(target, options = {}) {
+        return this.runTyped("extension-activate", { target, options });
+    }
+    /**
+     * Disable an installed extension using the same action as `pm extension deactivate`.
+     */
+    extensionDeactivate(target, options = {}) {
+        return this.runTyped("extension-deactivate", { target, options });
+    }
+    /**
+     * Run the package lifecycle surface with package vocabulary preserved.
+     */
+    package(target, options = {}) {
+        return this.runTyped("package", {
+            ...(target === undefined ? {} : { target }),
+            options: { ...options, vocabulary: "package" },
+        });
+    }
+    /**
+     * List project or global packages through the package lifecycle primitive.
+     */
+    packageList(options = {}) {
+        return this.package("list", options);
+    }
+    /**
+     * Install a package or extension source using the same action as `pm package install`.
+     */
+    packageInstall(target, options = {}) {
+        return this.runTyped("package-install", { target, options });
+    }
+    /**
+     * Uninstall a package or extension using the same action as `pm package uninstall`.
+     */
+    packageUninstall(target, options = {}) {
+        return this.runTyped("package-uninstall", { target, options });
+    }
+    /**
+     * Read package lifecycle diagnostics using the same action as `pm package doctor`.
+     */
+    packageDoctor(options = {}) {
+        return this.runTyped("package-doctor", { options });
+    }
+    /**
+     * Inspect managed package state using the same action as `pm package manage`.
+     */
+    packageManage(target, options = {}) {
+        return this.runTyped("package-manage", { ...(target === undefined ? {} : { target }), options });
+    }
+    /**
+     * Describe installed package surfaces using the same action as `pm package describe`.
+     */
+    packageDescribe(target, options = {}) {
+        return this.runTyped("package-describe", { ...(target === undefined ? {} : { target }), options });
+    }
+    /**
+     * Reload installed package extensions using the same action as `pm package reload`.
+     */
+    packageReload(options = {}) {
+        return this.runTyped("package-reload", { options });
+    }
+    /**
+     * Read bundled package catalog metadata using the same action as `pm package catalog`.
+     */
+    packageCatalog(options = {}) {
+        return this.runTyped("package-catalog", { options });
+    }
+    /**
+     * Enable an installed package using the same action as `pm package activate`.
+     */
+    packageActivate(target, options = {}) {
+        return this.runTyped("package-activate", { target, options });
+    }
+    /**
+     * Disable an installed package using the same action as `pm package deactivate`.
+     */
+    packageDeactivate(target, options = {}) {
+        return this.runTyped("package-deactivate", { target, options });
+    }
+    /**
+     * Upgrade the pm CLI and/or managed packages through the public SDK dispatcher.
+     */
+    upgrade(target, options = {}) {
+        return this.runTyped("upgrade", { ...(target === undefined ? {} : { target }), options });
     }
 }
 /**
@@ -273,6 +563,198 @@ export function aggregate(options = {}, clientOptions = {}) {
 export function stats(options = {}, clientOptions = {}) {
     return new PmClient(clientOptions).stats(options);
 }
+/**
+ * List, add, edit, or delete item comments without constructing a reusable client.
+ */
+export function comments(id, options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).comments(id, options);
+}
+/**
+ * List or append private item notes without constructing a reusable client.
+ */
+export function notes(id, options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).notes(id, options);
+}
+/**
+ * List or append durable item learnings without constructing a reusable client.
+ */
+export function learnings(id, options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).learnings(id, options);
+}
+/**
+ * Manage linked item files without constructing a reusable client.
+ */
+export function files(id, options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).files(id, options);
+}
+/**
+ * Discover linked item files without constructing a reusable client.
+ */
+export function filesDiscover(id, options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).filesDiscover(id, options);
+}
+/**
+ * Manage linked item docs without constructing a reusable client.
+ */
+export function docs(id, options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).docs(id, options);
+}
+/**
+ * Inspect item dependency relationships without constructing a reusable client.
+ */
+export function deps(id, options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).deps(id, options);
+}
+/**
+ * Append markdown/body text to an item without constructing a reusable client.
+ */
+export function append(id, body, options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).append(id, body, options);
+}
+/**
+ * Initialize a workspace without constructing a reusable client.
+ */
+export function init(prefix, options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).init(prefix, options);
+}
+/**
+ * Read or update configuration without constructing a reusable client.
+ */
+export function config(scope, configAction, key, value, options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).config(scope, configAction, key, value, options);
+}
+/**
+ * Run the schema customization surface without constructing a reusable client.
+ */
+export function schema(subcommand, options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).schema(subcommand, options);
+}
+/**
+ * List schema definitions without constructing a reusable client.
+ */
+export function schemaList(clientOptions = {}) {
+    return new PmClient(clientOptions).schemaList();
+}
+/**
+ * Show a schema item type without constructing a reusable client.
+ */
+export function schemaShow(name, clientOptions = {}) {
+    return new PmClient(clientOptions).schemaShow(name);
+}
+/**
+ * Register a custom item type without constructing a reusable client.
+ */
+export function schemaAddType(name, options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).schemaAddType(name, options);
+}
+/**
+ * Remove a custom item type without constructing a reusable client.
+ */
+export function schemaRemoveType(name, options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).schemaRemoveType(name, options);
+}
+/**
+ * Register a custom status without constructing a reusable client.
+ */
+export function schemaAddStatus(name, options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).schemaAddStatus(name, options);
+}
+/**
+ * Remove a custom status without constructing a reusable client.
+ */
+export function schemaRemoveStatus(name, options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).schemaRemoveStatus(name, options);
+}
+/**
+ * Register a custom field without constructing a reusable client.
+ */
+export function schemaAddField(name, options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).schemaAddField(name, options);
+}
+/**
+ * Remove a custom field without constructing a reusable client.
+ */
+export function schemaRemoveField(name, options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).schemaRemoveField(name, options);
+}
+/**
+ * List custom fields without constructing a reusable client.
+ */
+export function schemaListFields(clientOptions = {}) {
+    return new PmClient(clientOptions).schemaListFields();
+}
+/**
+ * Show a custom field without constructing a reusable client.
+ */
+export function schemaShowField(name, clientOptions = {}) {
+    return new PmClient(clientOptions).schemaShowField(name);
+}
+/**
+ * Apply a schema preset without constructing a reusable client.
+ */
+export function schemaApplyPreset(typePreset, options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).schemaApplyPreset(typePreset, options);
+}
+/**
+ * Infer schema types without constructing a reusable client.
+ */
+export function schemaInferTypes(options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).schemaInferTypes(options);
+}
+/**
+ * Show a custom status without constructing a reusable client.
+ */
+export function schemaShowStatus(name, clientOptions = {}) {
+    return new PmClient(clientOptions).schemaShowStatus(name);
+}
+/**
+ * Run the profile customization surface without constructing a reusable client.
+ */
+export function profile(subcommand, options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).profile(subcommand, options);
+}
+/**
+ * List profiles without constructing a reusable client.
+ */
+export function profileList(clientOptions = {}) {
+    return new PmClient(clientOptions).profileList();
+}
+/**
+ * Show a profile without constructing a reusable client.
+ */
+export function profileShow(name, clientOptions = {}) {
+    return new PmClient(clientOptions).profileShow(name);
+}
+/**
+ * Apply a profile without constructing a reusable client.
+ */
+export function profileApply(name, options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).profileApply(name, options);
+}
+/**
+ * Lint a profile without constructing a reusable client.
+ */
+export function profileLint(name, clientOptions = {}) {
+    return new PmClient(clientOptions).profileLint(name);
+}
+/**
+ * Validate a tracker without constructing a reusable client.
+ */
+export function validate(options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).validate(options);
+}
+/**
+ * Run health checks without constructing a reusable client.
+ */
+export function health(options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).health(options);
+}
+/**
+ * Run cache/runtime garbage collection without constructing a reusable client.
+ */
+export function gc(options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).gc(options);
+}
 /**
  * Create an item without constructing a reusable client.
  */
@@ -345,6 +827,102 @@ export function pauseTask(id, options = {}, clientOptions = {}) {
 export function closeTask(id, reason, options = {}, clientOptions = {}) {
     return new PmClient(clientOptions).closeTask(id, reason, options);
 }
+/**
+ * Run the extension lifecycle surface without constructing a reusable client.
+ */
+export function extension(target, options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).extension(target, options);
+}
+/**
+ * List extensions without constructing a reusable client.
+ */
+export function extensionList(options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).extensionList(options);
+}
+/**
+ * Enable an extension without constructing a reusable client.
+ */
+export function extensionActivate(target, options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).extensionActivate(target, options);
+}
+/**
+ * Disable an extension without constructing a reusable client.
+ */
+export function extensionDeactivate(target, options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).extensionDeactivate(target, options);
+}
+/**
+ * Run the package lifecycle surface without constructing a reusable client.
+ */
+export function packageLifecycle(target, options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).package(target, options);
+}
+/**
+ * List packages without constructing a reusable client.
+ */
+export function packageList(options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).packageList(options);
+}
+/**
+ * Install a package or extension source without constructing a reusable client.
+ */
+export function packageInstall(target, options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).packageInstall(target, options);
+}
+/**
+ * Uninstall a package or extension without constructing a reusable client.
+ */
+export function packageUninstall(target, options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).packageUninstall(target, options);
+}
+/**
+ * Read package lifecycle diagnostics without constructing a reusable client.
+ */
+export function packageDoctor(options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).packageDoctor(options);
+}
+/**
+ * Inspect managed package state without constructing a reusable client.
+ */
+export function packageManage(target, options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).packageManage(target, options);
+}
+/**
+ * Describe package surfaces without constructing a reusable client.
+ */
+export function packageDescribe(target, options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).packageDescribe(target, options);
+}
+/**
+ * Reload package extensions without constructing a reusable client.
+ */
+export function packageReload(options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).packageReload(options);
+}
+/**
+ * Read bundled package catalog metadata without constructing a reusable client.
+ */
+export function packageCatalog(options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).packageCatalog(options);
+}
+/**
+ * Enable a package without constructing a reusable client.
+ */
+export function packageActivate(target, options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).packageActivate(target, options);
+}
+/**
+ * Disable a package without constructing a reusable client.
+ */
+export function packageDeactivate(target, options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).packageDeactivate(target, options);
+}
+/**
+ * Upgrade the pm CLI and/or managed packages without constructing a reusable client.
+ */
+export function upgrade(target, options = {}, clientOptions = {}) {
+    return new PmClient(clientOptions).upgrade(target, options);
+}
 /**
  * Process-lifetime memo of activated extension registrations, keyed by resolved
  * pm root + cwd + extension settings. `getWorkspaceContracts` is frequently
@@ -488,11 +1066,16 @@ const LIFECYCLE_AUTHOR_ALIAS_ACTIONS = new Set([
 function normalizeMcpOptionsArrays(options, action) {
     const result = {};
     const promoteAddRemove = action !== undefined && ARRAY_ADD_REMOVE_ACTIONS.has(action);
+    const preserveStandaloneNote = action === "files" || action === "files-discover" || action === "docs";
     for (const [key, value] of Object.entries(options)) {
         if (Array.isArray(value) && ARRAY_TO_CSV_FIELDS.has(key)) {
             result[key] = value.join(",");
             continue;
         }
+        if (key === "note" && preserveStandaloneNote) {
+            result[key] = value;
+            continue;
+        }
         if (typeof value === "string" && SCALAR_TO_ARRAY_FIELDS.has(key)) {
             result[key] = [value];
             continue;
@@ -993,6 +1576,9 @@ function resolveSdkActionInput(args) {
     if (alias?.options !== undefined) {
         resolvedArgs.options = { ...alias.options, ...asRecordClone(args.options) };
     }
+    if (action === "package") {
+        resolvedArgs.options = { ...asRecordClone(resolvedArgs.options), vocabulary: "package" };
+    }
     return { action, args: resolvedArgs };
 }
 function shouldInvalidateWorkspaceContractsCacheAfterAction(action) {
@@ -1500,4 +2086,4 @@ async function loadWorkspaceExtensionRegistrations(pmRoot, settings, cwd) {
     }
 }
 //# sourceMappingURL=runtime.js.map
-//# debugId=89db1e15-b152-57e2-910d-64ed77eb540b
+//# debugId=a1d2566f-bb81-5e21-aaab-f501f90657ed