@unbrained/pm-cli 2026.7.7 → 2026.7.9

package/dist/cli-bundle/chunks/{chunk-S547WBYG.js → chunk-CEX2DQXZ.js}

@@ -1,18 +1,18 @@
 import {
   runFiles,
   runFilesDiscover
-} from "./chunk-W5HXHC7C.js";
+} from "./chunk-D6J5673C.js";
 import {
   runDocs
-} from "./chunk-2LEJGRQ7.js";
+} from "./chunk-KFL3XHMA.js";
 import {
   runDeps
-} from "./chunk-F6MT7KKE.js";
+} from "./chunk-MCH6IKK7.js";
 import {
   assertHistoryRepairTarget,
   runHistoryRepair,
   runHistoryRepairAll
-} from "./chunk-43UQN754.js";
+} from "./chunk-FJR2S7S4.js";
 import {
   resolveStartTaskInProgressStatus,
   runClaim,
@@ -25,67 +25,67 @@ import {
   runTest,
   runTestAll,
   runValidate
-} from "./chunk-TZLYO4PP.js";
+} from "./chunk-NRYZ4QLH.js";
 import {
   runComments
-} from "./chunk-YPD7SQ5P.js";
+} from "./chunk-EEJKHF7M.js";
 import {
   runCopy
-} from "./chunk-I74FMIWA.js";
+} from "./chunk-FFB3WITE.js";
 import {
   runFocus
-} from "./chunk-S6VC2A2K.js";
+} from "./chunk-7TBUV7XS.js";
 import {
   runDelete
-} from "./chunk-XBX5CBRQ.js";
+} from "./chunk-UH6VFRV6.js";
 import {
   runAppend
-} from "./chunk-DDDWVPID.js";
+} from "./chunk-GSQVQINP.js";
 import {
   runProfileApply,
   runProfileLint,
   runProfileList,
   runProfileShow
-} from "./chunk-IDIBF4E2.js";
+} from "./chunk-KAJNWMBE.js";
 import {
   runNotes
-} from "./chunk-4BKDAEDF.js";
+} from "./chunk-QJZM5WO5.js";
 import {
   runLearnings
-} from "./chunk-DG6BSXZ7.js";
+} from "./chunk-WVEMZZCR.js";
 import {
   runCloseMany
-} from "./chunk-ARKHKYYS.js";
+} from "./chunk-DQLP22K2.js";
 import {
   runUpdateMany
-} from "./chunk-S5BNGFN5.js";
+} from "./chunk-VCGHRLJU.js";
 import {
   runRestore
-} from "./chunk-Y7KYVCZM.js";
+} from "./chunk-NGBWEYNY.js";
 import {
   runUpdate
-} from "./chunk-LZQU6XJG.js";
+} from "./chunk-CHSXGTWF.js";
 import {
   runClose
-} from "./chunk-F6YC2A6X.js";
+} from "./chunk-NSPSJWGL.js";
 import {
   runPlan
-} from "./chunk-TNC6MZUD.js";
+} from "./chunk-XXN2B2MJ.js";
 import {
   runHistoryCompact
-} from "./chunk-GTM5HQL4.js";
+} from "./chunk-UIHDZS6X.js";
 import {
   runHistoryRedact
-} from "./chunk-EIUBK2LT.js";
+} from "./chunk-K52C6YPA.js";
 import {
   runConfig,
   runUpgrade
-} from "./chunk-ZNEG2UDO.js";
+} from "./chunk-WDNPNW22.js";
 import {
   SCAFFOLD_CAPABILITIES,
   runExtension,
   runInit
-} from "./chunk-X47MKQXU.js";
+} from "./chunk-YHKXNGLA.js";
 import {
   runSchemaAddField,
   runSchemaAddStatus,
@@ -100,7 +100,7 @@ import {
   runSchemaShow,
   runSchemaShowField,
   runSchemaShowStatus
-} from "./chunk-TGUK6XN6.js";
+} from "./chunk-UURYLDDC.js";
 import {
   jaccardSimilarity,
   normalizeLowercaseWhitespace,
@@ -111,17 +111,17 @@ import {
   runNext,
   runSearch,
   tokenizeAlphaNumeric
-} from "./chunk-FILL6BB2.js";
+} from "./chunk-N4S7BV43.js";
 import {
   buildListQueryFilters,
   runList
-} from "./chunk-C5ACVMOI.js";
+} from "./chunk-5RJ4LFD3.js";
 import {
   runHistory
-} from "./chunk-M62RO3XK.js";
+} from "./chunk-LHDHS4Z6.js";
 import {
   parseIntegerLimit
-} from "./chunk-ZO7CLOY2.js";
+} from "./chunk-BFNFTHWQ.js";
 import {
   resolveRegisteredSearchProvider,
   resolveRegisteredVectorStoreAdapter
@@ -148,7 +148,7 @@ import {
   resolveSettingsWithSemanticRuntimeDefaults,
   resolveVectorStores,
   writeVectorizationStatusLedger
-} from "./chunk-6XTSYPPO.js";
+} from "./chunk-ONADVBMD.js";
 import {
   ACTIVITY_FLAG_CONTRACTS,
   AGGREGATE_FLAG_CONTRACTS,
@@ -181,19 +181,19 @@ import {
   UPDATE_FLAG_CONTRACTS,
   UPDATE_MANY_FLAG_CONTRACTS,
   toCompletionFlagString
-} from "./chunk-YCVWWIKY.js";
+} from "./chunk-K4NMHZR3.js";
 import {
   runCreate
-} from "./chunk-XC3X7BQR.js";
+} from "./chunk-K2OKKYSO.js";
 import {
   parseTags
-} from "./chunk-2TILG6F2.js";
+} from "./chunk-CGDUIPJL.js";
 import {
   splitCommaList
 } from "./chunk-5HIZDR5A.js";
 import {
   projectMutationResult
-} from "./chunk-SY75LYXR.js";
+} from "./chunk-C6XSTACC.js";
 import {
   PmCliError,
   acquireLock,
@@ -222,7 +222,7 @@ import {
   setActiveExtensionRenderers,
   setActiveExtensionServices,
   toItemRecord
-} from "./chunk-YNCFP5AR.js";
+} from "./chunk-BPJ5NYSJ.js";
 import {
   BUILTIN_ITEM_TYPE_VALUES,
   EXIT_CODE,
@@ -249,7 +249,7 @@ import {
   toErrorMessage,
   toNonEmptyStringOrUndefined,
   writeFileAtomic
-} from "./chunk-LCFJ7XAM.js";
+} from "./chunk-2BVD4ZD2.js";
 
 // dist/sdk/runtime.js
 import path3 from "node:path";
@@ -1186,11 +1186,11 @@ function toExcerpt(content, maxLines, maxCharacters) {
 async function renderGuideDocs(topic, depth, packageRoot) {
   const includeContent = depth !== "brief";
   const contentMode = includeContent ? depth === "deep" ? "full" : "excerpt" : "none";
-  const docs = [];
+  const docs2 = [];
   for (const doc of topic.docs) {
     const absolutePath = path.resolve(packageRoot, doc.path);
     if (!includeContent) {
-      docs.push({
+      docs2.push({
         path: doc.path,
         purpose: doc.purpose,
         optional: doc.optional === true,
@@ -1206,7 +1206,7 @@ async function renderGuideDocs(topic, depth, packageRoot) {
       const rawContent = await readFile(absolutePath, "utf8");
       if (depth === "deep") {
         const normalized = normalizeLineEndings(rawContent).trimEnd();
-        docs.push({
+        docs2.push({
           path: doc.path,
           purpose: doc.purpose,
           optional: doc.optional === true,
@@ -1218,7 +1218,7 @@ async function renderGuideDocs(topic, depth, packageRoot) {
         });
       } else {
         const excerpt = toExcerpt(rawContent, 120, 12e3);
-        docs.push({
+        docs2.push({
           path: doc.path,
           purpose: doc.purpose,
           optional: doc.optional === true,
@@ -1232,7 +1232,7 @@ async function renderGuideDocs(topic, depth, packageRoot) {
     } catch (error) {
       const code = error?.code;
       const missing = code === "ENOENT";
-      docs.push({
+      docs2.push({
         path: doc.path,
         purpose: doc.purpose,
         optional: doc.optional === true,
@@ -1247,7 +1247,7 @@ async function renderGuideDocs(topic, depth, packageRoot) {
       }
     }
   }
-  return docs;
+  return docs2;
 }
 function buildGuideIndex(depth) {
   const topics = listGuideTopics().map((topic) => ({
@@ -1290,15 +1290,15 @@ async function runGuide(options, global2) {
   }
   const topic = ensureGuideTopic(topicRaw);
   const packageRoot = resolvePackageRoot();
-  const docs = await renderGuideDocs(topic, depth, packageRoot);
-  const warnings = docs.filter((doc) => !doc.exists && !doc.optional).map((doc) => `Missing required guide document: ${doc.path}`);
+  const docs2 = await renderGuideDocs(topic, depth, packageRoot);
+  const warnings = docs2.filter((doc) => !doc.exists && !doc.optional).map((doc) => `Missing required guide document: ${doc.path}`);
   return {
     output_default: "toon",
     mode: "topic",
     depth,
     requested_topic: topicRaw,
     topic,
-    docs,
+    docs: docs2,
     warnings
   };
 }
@@ -1378,7 +1378,7 @@ function renderGuideMarkdown(result) {
 !(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] = "c5c33ca2-acd6-55cc-8bf9-de815086e990");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "470e1fde-dbda-54fe-b821-9175c37b1cd3");
   } catch (e2) {
   }
 })();
@@ -2064,6 +2064,8 @@ _pm() {
             '--priority[Filter by priority]:(0 1 2 3 4)' \\
             '--deadline-before[Filter by deadline upper bound (ISO/date string or relative)]:date' \\
             '--deadline-after[Filter by deadline lower bound (ISO/date string or relative)]:date' \\
+            '--today[Filter to items updated since local midnight today]' \\
+            '--recent[Filter to items updated in the last 7 days]' \\
             '--updated-after[Filter by updated_at lower bound (ISO/relative)]:timestamp' \\
             '--updated-before[Filter by updated_at upper bound (ISO/relative)]:timestamp' \\
             '--created-after[Filter by created_at lower bound (ISO/relative)]:timestamp' \\
@@ -2566,6 +2568,7 @@ ${zshSearchRuntimeFieldFlags}            '--json[Output JSON]' \\
           _arguments \\
             '--action[Filter schema by tool action]:action' \\
             '--command[Scope output to one command (narrow-by-default)]:command' \\
+            '--summary[Return compact command intent summary]' \\
             '--schema-only[Return schema-only payload]' \\
             '--flags-only[Return command flag contracts only]' \\
             '--availability-only[Return action availability only]' \\
@@ -2877,6 +2880,8 @@ ${zshSearchRuntimeFieldFlags}            '--json[Output JSON]' \\
             '--trace[Include registration traces in doctor deep diagnostics]' \\
             '--runtime-probe[Opt-in runtime activation probe for manage output]' \\
             '--fix-managed-state[Adopt unmanaged extensions before diagnostics/update checks]' \\
+            '--isolated[Run doctor against project-scope extensions only]' \\
+            '--ignore-global[Alias for --isolated]' \\
             '--strict-exit[Return non-zero exit when doctor warnings are present]' \\
             '--fail-on-warn[Alias for --strict-exit (doctor)]' \\
             '--json[Output JSON]' \\
@@ -2915,6 +2920,8 @@ ${zshSearchRuntimeFieldFlags}            '--json[Output JSON]' \\
             '--trace[Include registration traces in doctor deep diagnostics]' \\
             '--runtime-probe[Opt-in runtime activation probe for manage output]' \\
             '--fix-managed-state[Adopt unmanaged packages before diagnostics/update checks]' \\
+            '--isolated[Run doctor against project-scope packages only]' \\
+            '--ignore-global[Alias for --isolated]' \\
             '--strict-exit[Return non-zero exit when doctor warnings are present]' \\
             '--fail-on-warn[Alias for --strict-exit (doctor)]' \\
             '--json[Output JSON]' \\
@@ -3037,6 +3044,8 @@ for list_cmd in ${listCmds}
   complete -c pm -n "__fish_seen_subcommand_from $list_cmd" -l stream -d 'Emit line-delimited JSON rows (requires --json)'
   complete -c pm -n "__fish_seen_subcommand_from $list_cmd" -l deadline-before -d 'Filter by deadline upper bound (ISO/date string or relative)' -r
   complete -c pm -n "__fish_seen_subcommand_from $list_cmd" -l deadline-after  -d 'Filter by deadline lower bound (ISO/date string or relative)' -r
+  complete -c pm -n "__fish_seen_subcommand_from $list_cmd" -l today -d 'Filter to items updated since local midnight today'
+  complete -c pm -n "__fish_seen_subcommand_from $list_cmd" -l recent -d 'Filter to items updated in the last 7 days'
   complete -c pm -n "__fish_seen_subcommand_from $list_cmd" -l updated-after  -d 'Filter by updated_at lower bound (ISO/relative)' -r
   complete -c pm -n "__fish_seen_subcommand_from $list_cmd" -l updated-before -d 'Filter by updated_at upper bound (ISO/relative)' -r
   complete -c pm -n "__fish_seen_subcommand_from $list_cmd" -l created-after  -d 'Filter by created_at lower bound (ISO/relative)' -r
@@ -3531,6 +3540,7 @@ complete -c pm -n '__fish_seen_subcommand_from activity' -l full -d 'Show full a
 complete -c pm -n '__fish_seen_subcommand_from activity' -l stream -d 'Emit line-delimited JSON rows'
 complete -c pm -n '__fish_seen_subcommand_from contracts' -l action -d 'Filter schema by tool action' -r
 complete -c pm -n '__fish_seen_subcommand_from contracts' -l command -d 'Scope output to one command (narrow-by-default)' -r
+complete -c pm -n '__fish_seen_subcommand_from contracts' -l summary -d 'Return compact command intent summary'
 complete -c pm -n '__fish_seen_subcommand_from contracts' -l schema-only -d 'Return schema-only payload'
 complete -c pm -n '__fish_seen_subcommand_from contracts' -l flags-only -d 'Return command flag contracts only'
 complete -c pm -n '__fish_seen_subcommand_from contracts' -l availability-only -d 'Return action availability only'
@@ -3813,6 +3823,8 @@ complete -c pm -n '__fish_seen_subcommand_from extension' -l detail -d 'Detail m
 complete -c pm -n '__fish_seen_subcommand_from extension' -l trace -d 'Include registration traces in doctor deep diagnostics'
 complete -c pm -n '__fish_seen_subcommand_from extension' -l runtime-probe -d 'Opt-in runtime activation probe for manage output'
 complete -c pm -n '__fish_seen_subcommand_from extension' -l fix-managed-state -d 'Adopt unmanaged extensions before diagnostics/update checks'
+complete -c pm -n '__fish_seen_subcommand_from extension' -l isolated -d 'Run doctor against project-scope extensions only'
+complete -c pm -n '__fish_seen_subcommand_from extension' -l ignore-global -d 'Alias for --isolated'
 complete -c pm -n '__fish_seen_subcommand_from extension' -l strict-exit -d 'Return non-zero exit when doctor warnings are present'
 complete -c pm -n '__fish_seen_subcommand_from extension' -l fail-on-warn -d 'Alias for --strict-exit (doctor)'
 
@@ -3848,6 +3860,8 @@ for package_cmd in package packages
   complete -c pm -n "__fish_seen_subcommand_from $package_cmd" -l trace -d 'Include registration traces in doctor deep diagnostics'
   complete -c pm -n "__fish_seen_subcommand_from $package_cmd" -l runtime-probe -d 'Opt-in runtime activation probe for manage output'
   complete -c pm -n "__fish_seen_subcommand_from $package_cmd" -l fix-managed-state -d 'Adopt unmanaged packages before diagnostics/update checks'
+  complete -c pm -n "__fish_seen_subcommand_from $package_cmd" -l isolated -d 'Run doctor against project-scope packages only'
+  complete -c pm -n "__fish_seen_subcommand_from $package_cmd" -l ignore-global -d 'Alias for --isolated'
   complete -c pm -n "__fish_seen_subcommand_from $package_cmd" -l strict-exit -d 'Return non-zero exit when doctor warnings are present'
   complete -c pm -n "__fish_seen_subcommand_from $package_cmd" -l fail-on-warn -d 'Alias for --strict-exit (doctor)'
 end`;
@@ -4017,7 +4031,7 @@ function resolveCommentsAuditLimits(options) {
   };
 }
 function toCommentsAuditEntry(item, latest) {
-  const comments = item.comments ?? [];
+  const comments2 = item.comments ?? [];
   return {
     id: item.id,
     title: item.title,
@@ -4025,8 +4039,8 @@ function toCommentsAuditEntry(item, latest) {
     status: item.status,
     assignee: item.assignee ?? null,
     updated_at: item.updated_at,
-    comment_count: comments.length,
-    comments: latest === void 0 ? comments : limitComments(comments, latest)
+    comment_count: comments2.length,
+    comments: latest === void 0 ? comments2 : limitComments(comments2, latest)
   };
 }
 function buildCommentsAuditFilters(options, status, limitItems, latest, fullHistory) {
@@ -4917,15 +4931,15 @@ function parseMode2(raw) {
   }
   throw new PmCliError("Reindex mode must be one of keyword|semantic|hybrid", EXIT_CODE.USAGE);
 }
-async function loadDocumentCandidates(pmRoot, itemFormat, typeToFolder, schema) {
+async function loadDocumentCandidates(pmRoot, itemFormat, typeToFolder, schema2) {
   const warnings = [];
-  const candidates = await listAllDocumentCandidatesCached(pmRoot, itemFormat, typeToFolder, warnings, schema);
+  const candidates = await listAllDocumentCandidatesCached(pmRoot, itemFormat, typeToFolder, warnings, schema2);
   return {
     candidates,
     warnings
   };
 }
-async function hydrateDocuments(pmRoot, candidates, schema, warnings, itemIds) {
+async function hydrateDocuments(pmRoot, candidates, schema2, warnings, itemIds) {
   const extensionFieldNames = collectRegisteredItemFieldNames(getActiveExtensionRegistrations());
   const hydrated = [];
   for (const candidate of candidates) {
@@ -4943,7 +4957,7 @@ async function hydrateDocuments(pmRoot, candidates, schema, warnings, itemIds) {
       const raw = await fs.readFile(candidate.item_path, "utf8");
       const parsed = parseItemDocument(raw, {
         format: candidate.item_format,
-        schema,
+        schema: schema2,
         extensionFieldNames,
         onWarning: (warning) => warnings.push(warning)
       });
@@ -5558,17 +5572,12 @@ async function runReindex(options, global2) {
 !(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");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "a1d2566f-bb81-5e21-aaab-f501f90657ed");
   } catch (e2) {
   }
 })();
-function splitClientMutationOptions(options) {
-  const { fullChangedFields, idOnly, ...runnerOptions } = options;
-  return {
-    ...fullChangedFields === void 0 ? {} : { fullChangedFields },
-    ...idOnly === void 0 ? {} : { idOnly },
-    options: runnerOptions
-  };
+function splitFullClientMutationOptions(options) {
+  return { fullChangedFields: true, options };
 }
 var PmClient = class {
   defaults;
@@ -5634,83 +5643,378 @@ var PmClient = class {
   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 === void 0 ? {} : { prefix }, options });
+  }
+  /**
+   * Read or update project/global configuration.
+   */
+  config(scope, configAction, key, value, options = {}) {
+    return this.runTyped("config", {
+      scope,
+      configAction,
+      ...key === void 0 ? {} : { key },
+      ...value === void 0 ? {} : { 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 === void 0 ? {} : { fullChangedFields },
-      ...idOnly === void 0 ? {} : { 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 === void 0 ? {} : { id }, ...splitClientMutationOptions(options) });
+    return this.runTyped("focus", { ...id === void 0 ? {} : { 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 === void 0 ? {} : { 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 === void 0 ? {} : { 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 === void 0 ? {} : { target }, options });
+  }
+  /**
+   * Describe installed package surfaces using the same action as `pm package describe`.
+   */
+  packageDescribe(target, options = {}) {
+    return this.runTyped("package-describe", { ...target === void 0 ? {} : { 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 === void 0 ? {} : { target }, options });
   }
 };
 function context(options = {}, clientOptions = {}) {
@@ -5734,6 +6038,102 @@ function aggregate(options = {}, clientOptions = {}) {
 function stats(options = {}, clientOptions = {}) {
   return new PmClient(clientOptions).stats(options);
 }
+function comments(id, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).comments(id, options);
+}
+function notes(id, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).notes(id, options);
+}
+function learnings(id, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).learnings(id, options);
+}
+function files(id, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).files(id, options);
+}
+function filesDiscover(id, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).filesDiscover(id, options);
+}
+function docs(id, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).docs(id, options);
+}
+function deps(id, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).deps(id, options);
+}
+function append(id, body, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).append(id, body, options);
+}
+function init(prefix, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).init(prefix, options);
+}
+function config(scope, configAction, key, value, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).config(scope, configAction, key, value, options);
+}
+function schema(subcommand, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).schema(subcommand, options);
+}
+function schemaList(clientOptions = {}) {
+  return new PmClient(clientOptions).schemaList();
+}
+function schemaShow(name, clientOptions = {}) {
+  return new PmClient(clientOptions).schemaShow(name);
+}
+function schemaAddType(name, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).schemaAddType(name, options);
+}
+function schemaRemoveType(name, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).schemaRemoveType(name, options);
+}
+function schemaAddStatus(name, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).schemaAddStatus(name, options);
+}
+function schemaRemoveStatus(name, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).schemaRemoveStatus(name, options);
+}
+function schemaAddField(name, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).schemaAddField(name, options);
+}
+function schemaRemoveField(name, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).schemaRemoveField(name, options);
+}
+function schemaListFields(clientOptions = {}) {
+  return new PmClient(clientOptions).schemaListFields();
+}
+function schemaShowField(name, clientOptions = {}) {
+  return new PmClient(clientOptions).schemaShowField(name);
+}
+function schemaApplyPreset(typePreset, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).schemaApplyPreset(typePreset, options);
+}
+function schemaInferTypes(options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).schemaInferTypes(options);
+}
+function schemaShowStatus(name, clientOptions = {}) {
+  return new PmClient(clientOptions).schemaShowStatus(name);
+}
+function profile(subcommand, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).profile(subcommand, options);
+}
+function profileList(clientOptions = {}) {
+  return new PmClient(clientOptions).profileList();
+}
+function profileShow(name, clientOptions = {}) {
+  return new PmClient(clientOptions).profileShow(name);
+}
+function profileApply(name, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).profileApply(name, options);
+}
+function profileLint(name, clientOptions = {}) {
+  return new PmClient(clientOptions).profileLint(name);
+}
+function validate(options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).validate(options);
+}
+function health(options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).health(options);
+}
+function gc(options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).gc(options);
+}
 function create(options = {}, clientOptions = {}) {
   return new PmClient(clientOptions).create(options);
 }
@@ -5770,6 +6170,54 @@ function pauseTask(id, options = {}, clientOptions = {}) {
 function closeTask(id, reason, options = {}, clientOptions = {}) {
   return new PmClient(clientOptions).closeTask(id, reason, options);
 }
+function extension(target, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).extension(target, options);
+}
+function extensionList(options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).extensionList(options);
+}
+function extensionActivate(target, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).extensionActivate(target, options);
+}
+function extensionDeactivate(target, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).extensionDeactivate(target, options);
+}
+function packageLifecycle(target, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).package(target, options);
+}
+function packageList(options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).packageList(options);
+}
+function packageInstall(target, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).packageInstall(target, options);
+}
+function packageUninstall(target, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).packageUninstall(target, options);
+}
+function packageDoctor(options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).packageDoctor(options);
+}
+function packageManage(target, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).packageManage(target, options);
+}
+function packageDescribe(target, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).packageDescribe(target, options);
+}
+function packageReload(options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).packageReload(options);
+}
+function packageCatalog(options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).packageCatalog(options);
+}
+function packageActivate(target, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).packageActivate(target, options);
+}
+function packageDeactivate(target, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).packageDeactivate(target, options);
+}
+function upgrade(target, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).upgrade(target, options);
+}
 function buildWorkspaceExtensionRegistrationsCacheKey(pmRoot, settings, cwd) {
   return JSON.stringify([
     path3.resolve(pmRoot),
@@ -5884,11 +6332,16 @@ var LIFECYCLE_AUTHOR_ALIAS_ACTIONS = /* @__PURE__ */ new Set([
 function normalizeMcpOptionsArrays(options, action) {
   const result = {};
   const promoteAddRemove = action !== void 0 && 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;
@@ -6292,6 +6745,9 @@ function resolveSdkActionInput(args) {
   if (alias?.options !== void 0) {
     resolvedArgs.options = { ...alias.options, ...asRecordClone(args.options) };
   }
+  if (action === "package") {
+    resolvedArgs.options = { ...asRecordClone(resolvedArgs.options), vocabulary: "package" };
+  }
   return { action, args: resolvedArgs };
 }
 function shouldInvalidateWorkspaceContractsCacheAfterAction(action) {
@@ -6484,8 +6940,8 @@ function createMcpSchemaContext(ctx) {
     aliases: aliasSource === void 0 ? void 0 : readStringArray(aliasSource)
   };
 }
-function runMcpSchemaReadOrRemoveAction(schema) {
-  const { ctx, subcommand, name, author, force } = schema;
+function runMcpSchemaReadOrRemoveAction(schema2) {
+  const { ctx, subcommand, name, author, force } = schema2;
   const simpleHandlers = {
     list: () => runSchemaList(ctx.global),
     show: () => runSchemaShow(name, ctx.global),
@@ -6500,8 +6956,8 @@ function runMcpSchemaReadOrRemoveAction(schema) {
   const handler = getOwnHandler(simpleHandlers, subcommand);
   return handler ? handler() : null;
 }
-function runMcpSchemaAddFieldAction(schema) {
-  const { ctx, name, author, force, aliases } = schema;
+function runMcpSchemaAddFieldAction(schema2) {
+  const { ctx, name, author, force, aliases } = schema2;
   const commandsSource = ctx.args.commands ?? ctx.options.commands;
   const requiredTypesSource = ctx.args.requiredTypes ?? ctx.options.requiredTypes;
   return runSchemaAddField(name, {
@@ -6518,8 +6974,8 @@ function runMcpSchemaAddFieldAction(schema) {
     force
   }, ctx.global);
 }
-function runMcpSchemaAddStatusAction(schema) {
-  const { ctx, name, author, force, aliases } = schema;
+function runMcpSchemaAddStatusAction(schema2) {
+  const { ctx, name, author, force, aliases } = schema2;
   const roleSource = ctx.args.role ?? ctx.options.role;
   return runSchemaAddStatus(name, {
     role: roleSource === void 0 ? void 0 : readStringArray(roleSource),
@@ -6530,8 +6986,8 @@ function runMcpSchemaAddStatusAction(schema) {
     force
   }, ctx.global);
 }
-function runMcpSchemaAddTypeAction(schema) {
-  const { ctx, name, author, force, aliases } = schema;
+function runMcpSchemaAddTypeAction(schema2) {
+  const { ctx, name, author, force, aliases } = schema2;
   return runSchemaAddType(name, {
     description: readString(ctx.args, "description") ?? readString(ctx.options, "description"),
     defaultStatus: readString(ctx.args, "defaultStatus") ?? readString(ctx.args, "default_status") ?? readString(ctx.options, "defaultStatus") ?? readString(ctx.options, "default_status"),
@@ -6542,29 +6998,29 @@ function runMcpSchemaAddTypeAction(schema) {
   }, ctx.global);
 }
 function runMcpSchemaAction(ctx) {
-  const schema = createMcpSchemaContext(ctx);
-  const simpleResult = runMcpSchemaReadOrRemoveAction(schema);
+  const schema2 = createMcpSchemaContext(ctx);
+  const simpleResult = runMcpSchemaReadOrRemoveAction(schema2);
   if (simpleResult !== null) {
     return simpleResult;
   }
-  if (schema.subcommand === "add-field") {
-    return runMcpSchemaAddFieldAction(schema);
+  if (schema2.subcommand === "add-field") {
+    return runMcpSchemaAddFieldAction(schema2);
   }
-  if (schema.subcommand === "add-status") {
-    return runMcpSchemaAddStatusAction(schema);
+  if (schema2.subcommand === "add-status") {
+    return runMcpSchemaAddStatusAction(schema2);
   }
-  if (schema.subcommand === "add-type") {
+  if (schema2.subcommand === "add-type") {
     if (ctx.args.infer === true || ctx.options.infer === true) {
       return runSchemaInferTypes({
         minCount: parseMcpInteger(ctx.args.minCount ?? ctx.options.minCount, "schema infer minCount"),
         apply: ctx.args.apply === true || ctx.options.apply === true,
-        author: schema.author,
-        force: schema.force
+        author: schema2.author,
+        force: schema2.force
       }, ctx.global);
     }
-    return runMcpSchemaAddTypeAction(schema);
+    return runMcpSchemaAddTypeAction(schema2);
   }
-  throw new PmCliError(`Unknown pm schema subcommand "${schema.subcommand}". Allowed: add-type, remove-type, add-status, remove-status, add-field, remove-field, list-fields, show-field, apply-preset, list, show, show-status`, 64);
+  throw new PmCliError(`Unknown pm schema subcommand "${schema2.subcommand}". Allowed: add-type, remove-type, add-status, remove-status, add-field, remove-field, list-fields, show-field, apply-preset, list, show, show-status`, 64);
 }
 function runMcpProfileAction(ctx) {
   const subcommand = readString(ctx.args, "subcommand") ?? readRequiredString(ctx.options, "subcommand");
@@ -6805,6 +7261,38 @@ export {
   next,
   aggregate,
   stats,
+  comments,
+  notes,
+  learnings,
+  files,
+  filesDiscover,
+  docs,
+  deps,
+  append,
+  init,
+  config,
+  schema,
+  schemaList,
+  schemaShow,
+  schemaAddType,
+  schemaRemoveType,
+  schemaAddStatus,
+  schemaRemoveStatus,
+  schemaAddField,
+  schemaRemoveField,
+  schemaListFields,
+  schemaShowField,
+  schemaApplyPreset,
+  schemaInferTypes,
+  schemaShowStatus,
+  profile,
+  profileList,
+  profileShow,
+  profileApply,
+  profileLint,
+  validate,
+  health,
+  gc,
   create,
   update,
   close,
@@ -6817,9 +7305,25 @@ export {
   startTask,
   pauseTask,
   closeTask,
+  extension,
+  extensionList,
+  extensionActivate,
+  extensionDeactivate,
+  packageLifecycle,
+  packageList,
+  packageInstall,
+  packageUninstall,
+  packageDoctor,
+  packageManage,
+  packageDescribe,
+  packageReload,
+  packageCatalog,
+  packageActivate,
+  packageDeactivate,
+  upgrade,
   getWorkspaceContracts,
   getContracts,
   readRequiredString,
   runAction
 };
-//# sourceMappingURL=chunk-S547WBYG.js.map
+//# sourceMappingURL=chunk-CEX2DQXZ.js.map