@unbrained/pm-cli 2026.7.6 → 2026.7.8

package/dist/cli-bundle/chunks/{chunk-TKD5VCTD.js → chunk-2RADY7IB.js}

@@ -1,148 +1,133 @@
 
-!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]="2c7e86dd-91a7-512d-9ef1-93d67aff97c1")}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]="172e4594-e82f-5ac4-add6-4f96b3b2890f")}catch(e){}}();
 import {
-  runValidate
-} from "./chunk-FOUYJE4A.js";
-import {
-  runGc
-} from "./chunk-WSBLYDWV.js";
-import {
-  runContracts
-} from "./chunk-DEWEK6AN.js";
+  runFiles,
+  runFilesDiscover
+} from "./chunk-JYVPLGOW.js";
 import {
-  runClaim,
-  runRelease
-} from "./chunk-LP3HSFZ2.js";
+  runDocs
+} from "./chunk-UFNFHCAC.js";
 import {
-  resolveStartTaskInProgressStatus
-} from "./chunk-5BMM6XQY.js";
+  runDeps
+} from "./chunk-LD2NBQ5T.js";
 import {
   assertHistoryRepairTarget,
   runHistoryRepair,
   runHistoryRepairAll
-} from "./chunk-B6XS3R3O.js";
+} from "./chunk-SIQGG335.js";
 import {
-  runTestAll
-} from "./chunk-B7FRNMYN.js";
-import {
-  runTest
-} from "./chunk-64YKRTSV.js";
+  resolveStartTaskInProgressStatus,
+  runClaim,
+  runContracts,
+  runGc,
+  runHealth,
+  runRelease,
+  runStats,
+  runTelemetry,
+  runTest,
+  runTestAll,
+  runValidate
+} from "./chunk-KMXVZ2P7.js";
 import {
-  runTelemetry
-} from "./chunk-XC5BURG2.js";
+  runComments
+} from "./chunk-LG4N6YOK.js";
 import {
-  runStats
-} from "./chunk-GEYZ4G4O.js";
+  runCopy
+} from "./chunk-SCJPFQQT.js";
 import {
-  runHealth
-} from "./chunk-MAWDPCJW.js";
+  runFocus
+} from "./chunk-NRMDT4OV.js";
 import {
   runDelete
-} from "./chunk-ZWBEPGD7.js";
+} from "./chunk-6ZKDMEVT.js";
 import {
   runAppend
-} from "./chunk-SGMFPXKR.js";
+} from "./chunk-RL24NAUX.js";
 import {
   runProfileApply,
   runProfileLint,
   runProfileList,
   runProfileShow
-} from "./chunk-CFNGIXZP.js";
+} from "./chunk-GQOKFX2G.js";
 import {
   runNotes
-} from "./chunk-I36Y7PCE.js";
+} from "./chunk-HZZ3AC27.js";
 import {
   runLearnings
-} from "./chunk-45FYNUFJ.js";
-import {
-  runFiles,
-  runFilesDiscover
-} from "./chunk-HOVCGJSD.js";
-import {
-  runDocs
-} from "./chunk-JVH7QBVV.js";
+} from "./chunk-F5DDGY6R.js";
 import {
-  runDeps
-} from "./chunk-4CJFCTLM.js";
+  runCloseMany
+} from "./chunk-IYRG5AEC.js";
 import {
   runUpdateMany
-} from "./chunk-EBRZZ54H.js";
+} from "./chunk-YR5R4FMQ.js";
+import {
+  runRestore
+} from "./chunk-PAWPLIWW.js";
 import {
   runUpdate
-} from "./chunk-ZZD4J5XY.js";
+} from "./chunk-UCRYCT5M.js";
+import {
+  runClose
+} from "./chunk-UVFJSKTF.js";
 import {
   runPlan
-} from "./chunk-HFDADVJZ.js";
+} from "./chunk-YUCKM3MD.js";
 import {
   runHistoryCompact
-} from "./chunk-CRVYGJUI.js";
+} from "./chunk-4OCWJ2AP.js";
 import {
   runHistoryRedact
-} from "./chunk-D2XRLB55.js";
+} from "./chunk-JH5XDDYS.js";
 import {
-  runComments
-} from "./chunk-6QBJLYBP.js";
+  runConfig,
+  runUpgrade
+} from "./chunk-D63PEJTB.js";
 import {
-  runCopy
-} from "./chunk-UH7T2DAX.js";
+  SCAFFOLD_CAPABILITIES,
+  runExtension,
+  runInit
+} from "./chunk-GE44TQMC.js";
 import {
-  runFocus
-} from "./chunk-GDDAGPWJ.js";
+  runSchemaAddField,
+  runSchemaAddStatus,
+  runSchemaAddType,
+  runSchemaApplyPreset,
+  runSchemaInferTypes,
+  runSchemaList,
+  runSchemaListFields,
+  runSchemaRemoveField,
+  runSchemaRemoveStatus,
+  runSchemaRemoveType,
+  runSchemaShow,
+  runSchemaShowField,
+  runSchemaShowStatus
+} from "./chunk-FOJEBRDD.js";
 import {
   jaccardSimilarity,
   normalizeLowercaseWhitespace,
+  runActivity,
+  runAggregate,
+  runContext,
+  runGet,
+  runNext,
   runSearch,
   tokenizeAlphaNumeric
-} from "./chunk-TZXRBVAM.js";
-import {
-  runGet
-} from "./chunk-4MZVRJOE.js";
-import {
-  runCreate
-} from "./chunk-TULGS6X6.js";
-import {
-  parseTags
-} from "./chunk-IWVU4C2F.js";
-import {
-  runCloseMany
-} from "./chunk-4LELACOL.js";
-import {
-  runClose
-} from "./chunk-G64OCSKU.js";
-import {
-  runRestore
-} from "./chunk-YN7Y6DQZ.js";
-import {
-  runUpgrade
-} from "./chunk-S3JS6YVZ.js";
-import {
-  runAggregate
-} from "./chunk-VQRSPVME.js";
-import {
-  buildListQueryFilters
-} from "./chunk-VY3VQ22F.js";
-import {
-  runNext
-} from "./chunk-ML5X7DP2.js";
-import {
-  runContext
-} from "./chunk-MXYA5SAJ.js";
+} from "./chunk-HI27UADG.js";
 import {
+  buildListQueryFilters,
   runList
-} from "./chunk-3VHSI5FL.js";
-import {
-  runActivity
-} from "./chunk-WRTENIX3.js";
+} from "./chunk-XN5BEN2B.js";
 import {
   runHistory
-} from "./chunk-IX5BXEMX.js";
+} from "./chunk-6WCXSC5V.js";
 import {
   parseIntegerLimit
-} from "./chunk-22KBU3MW.js";
+} from "./chunk-6RR4XM5H.js";
 import {
-  normalizeListOptions,
-  normalizeUpdateOptions
-} from "./chunk-4IWYTWGF.js";
+  resolveRegisteredSearchProvider,
+  resolveRegisteredVectorStoreAdapter
+} from "./chunk-KGHH652T.js";
 import {
   REINDEX_LOCK_ID,
   buildSearchCorpus,
@@ -156,6 +141,8 @@ import {
   hasVectorizationEmbeddingIdentityChanged,
   hasVectorizationVectorDimensionChanged,
   inferConsistentVectorDimension,
+  normalizeListOptions,
+  normalizeUpdateOptions,
   readVectorizationStatusLedger,
   resolveEmbeddingProviders,
   resolveSearchCorpusFields,
@@ -163,26 +150,7 @@ import {
   resolveSettingsWithSemanticRuntimeDefaults,
   resolveVectorStores,
   writeVectorizationStatusLedger
-} from "./chunk-EOKXK3R3.js";
-import {
-  projectMutationResult
-} from "./chunk-MLIYFOE7.js";
-import {
-  resolveRegisteredSearchProvider,
-  resolveRegisteredVectorStoreAdapter
-} from "./chunk-KGHH652T.js";
-import {
-  runInit
-} from "./chunk-MFSCBT5Q.js";
-import {
-  runExtension
-} from "./chunk-WG34ZNQQ.js";
-import {
-  SCAFFOLD_CAPABILITIES
-} from "./chunk-WLSM645P.js";
-import {
-  splitCommaList
-} from "./chunk-P4SESZGT.js";
+} from "./chunk-G4FKP4ID.js";
 import {
   ACTIVITY_FLAG_CONTRACTS,
   AGGREGATE_FLAG_CONTRACTS,
@@ -215,60 +183,48 @@ import {
   UPDATE_FLAG_CONTRACTS,
   UPDATE_MANY_FLAG_CONTRACTS,
   toCompletionFlagString
-} from "./chunk-EGAP5OWD.js";
+} from "./chunk-ML27MHNM.js";
 import {
-  runSchemaAddField,
-  runSchemaAddStatus,
-  runSchemaAddType,
-  runSchemaApplyPreset,
-  runSchemaInferTypes,
-  runSchemaList,
-  runSchemaListFields,
-  runSchemaRemoveField,
-  runSchemaRemoveStatus,
-  runSchemaRemoveType,
-  runSchemaShow,
-  runSchemaShowField,
-  runSchemaShowStatus
-} from "./chunk-LPSSSDJR.js";
+  runCreate
+} from "./chunk-TUDAYIO7.js";
+import {
+  parseTags
+} from "./chunk-3SHDAKMF.js";
 import {
+  splitCommaList
+} from "./chunk-P4SESZGT.js";
+import {
+  projectMutationResult
+} from "./chunk-U72GF3I2.js";
+import {
+  PmCliError,
   acquireLock,
   appendHistoryEntry,
   collectRegisteredItemFieldNames,
+  compareTimestampStrings,
   createHistoryEntry,
+  getActiveExtensionRegistrations,
+  isTerminalStatus,
   listAllDocumentCandidatesCached,
   locateItem,
-  readLocatedItem,
-  toItemRecord
-} from "./chunk-ENGQOEUY.js";
-import {
-  runConfig
-} from "./chunk-DMRNBQOI.js";
-import {
-  isTerminalStatus,
   normalizeStatusInput,
+  nowIso,
   parseItemDocument,
-  serializeItemDocument
-} from "./chunk-G24G7ZAV.js";
-import {
-  compareTimestampStrings,
-  nowIso
-} from "./chunk-3GCS5SKL.js";
-import {
-  PmCliError,
-  getActiveExtensionRegistrations,
+  readLocatedItem,
   readSettings,
   runActiveCommandHandler,
   runActiveOnIndexHooks,
   runActiveOnWriteHooks,
+  serializeItemDocument,
   setActiveExtensionCommands,
   setActiveExtensionHooks,
   setActiveExtensionParsers,
   setActiveExtensionPreflight,
   setActiveExtensionRegistrations,
   setActiveExtensionRenderers,
-  setActiveExtensionServices
-} from "./chunk-E3SZTQ4K.js";
+  setActiveExtensionServices,
+  toItemRecord
+} from "./chunk-NTOOEVJ4.js";
 import {
   BUILTIN_ITEM_TYPE_VALUES,
   EXIT_CODE,
@@ -295,7 +251,7 @@ import {
   toErrorMessage,
   toNonEmptyStringOrUndefined,
   writeFileAtomic
-} from "./chunk-57NWPFF2.js";
+} from "./chunk-MFLLULHU.js";
 
 // dist/sdk/runtime.js
 import path3 from "node:path";
@@ -2851,6 +2807,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]' \\
@@ -2889,6 +2847,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]' \\
@@ -3787,6 +3747,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)'
 
@@ -3822,6 +3784,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`;
@@ -3937,16 +3901,16 @@ function buildCommentsAuditSummary(items) {
     entry.comments_exported += item.comments.length;
     byTypeAccumulator.set(item.type, entry);
   }
-  const byType = [...byTypeAccumulator.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([type, stats]) => {
-    const zeroCount = stats.items_scanned - stats.items_with_comments;
-    const coverage = ratioPercent(stats.items_with_comments, stats.items_scanned);
+  const byType = [...byTypeAccumulator.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([type, stats2]) => {
+    const zeroCount = stats2.items_scanned - stats2.items_with_comments;
+    const coverage = ratioPercent(stats2.items_with_comments, stats2.items_scanned);
     return {
       type,
-      items_scanned: stats.items_scanned,
-      items_with_comments: stats.items_with_comments,
+      items_scanned: stats2.items_scanned,
+      items_with_comments: stats2.items_with_comments,
       zero_comment_items: zeroCount,
-      comments_total: stats.comments_total,
-      comments_exported: stats.comments_exported,
+      comments_total: stats2.comments_total,
+      comments_exported: stats2.comments_exported,
       items_with_comments_ratio: coverage.ratio,
       items_with_comments_percent: coverage.percent
     };
@@ -4452,17 +4416,17 @@ async function applyDedupeMergeReparents(params) {
 }
 async function applyDedupeMergeClose(params) {
   const reason = `Duplicate of ${params.keep}`;
-  const close = { duplicate_of: params.keep, reason, applied: false };
+  const close2 = { duplicate_of: params.keep, reason, applied: false };
   if (isTerminalStatus(params.duplicate.metadata.status, params.statusRegistry)) {
-    close.skipped_reason = "already_terminal";
+    close2.skipped_reason = "already_terminal";
     if (params.duplicate.metadata.duplicate_of?.trim() !== params.keep) {
       params.warnings.push(`close_skipped_terminal:${params.duplicate.id}:already_closed`);
     }
-    return close;
+    return close2;
   }
   if (!params.apply) {
-    close.skipped_reason = "dry_run";
-    return close;
+    close2.skipped_reason = "dry_run";
+    return close2;
   }
   try {
     await runClose(params.duplicate.id, void 0, {
@@ -4470,12 +4434,12 @@ async function applyDedupeMergeClose(params) {
       author: params.options.author,
       message: params.options.message ?? `dedupe-merge: close ${params.duplicate.id} as duplicate of ${params.keep}`
     }, params.global);
-    close.applied = true;
+    close2.applied = true;
   } catch (error) {
-    close.skipped_reason = "failed";
+    close2.skipped_reason = "failed";
     params.warnings.push(`close_failed:${params.duplicate.id}:${error instanceof Error ? error.message : String(error)}`);
   }
-  return close;
+  return close2;
 }
 async function runDedupeMerge(options, global) {
   const pmRoot = resolvePmRoot(process.cwd(), global.path);
@@ -4522,14 +4486,14 @@ async function runDedupeMerge(options, global) {
       global,
       warnings
     });
-    const close = await applyDedupeMergeClose({ duplicate, keep, apply, options, global, statusRegistry, warnings });
+    const close2 = await applyDedupeMergeClose({ duplicate, keep, apply, options, global, statusRegistry, warnings });
     outcomes.push({
       duplicate_id: duplicate.id,
       duplicate_title: duplicate.title,
       canonical_id: keep,
       reparented_children: reparented,
       skipped_children: skippedChildren,
-      close
+      close: close2
     });
   }
   const childrenReparented = outcomes.reduce((total, outcome) => total + outcome.reparented_children.filter((child) => child.applied).length, 0);
@@ -4962,9 +4926,9 @@ function resolveExtensionVectorAdapter(settings) {
     ...typeof deleteHandler === "function" ? { delete: deleteHandler } : {}
   };
 }
-function assertVector(value, context) {
+function assertVector(value, context2) {
   if (!Array.isArray(value) || value.some((entry) => typeof entry !== "number" || !Number.isFinite(entry))) {
-    throw new PmCliError(`Invalid vector returned by ${context}`, EXIT_CODE.GENERIC_FAILURE);
+    throw new PmCliError(`Invalid vector returned by ${context2}`, EXIT_CODE.GENERIC_FAILURE);
   }
   return value;
 }
@@ -5133,7 +5097,7 @@ function assertSemanticRuntimeAvailable(params) {
   if (!providerResolution.active && !params.extensionEmbedding) {
     throw new PmCliError(`Reindex mode '${params.requestedMode}' requires a configured embedding provider in settings.providers.openai/settings.providers.ollama or an extension provider selected by settings.search.provider`, EXIT_CODE.USAGE);
   }
-  const vectorResolution = resolveVectorStores(params.settings);
+  const vectorResolution = resolveVectorStores(params.settings, params.pmRoot);
   if (!vectorResolution.active && !params.extensionVectorAdapter) {
     throw new PmCliError(`Reindex mode '${params.requestedMode}' requires a configured vector store in settings.vector_store.qdrant/settings.vector_store.lancedb or an extension adapter selected by settings.vector_store.adapter`, EXIT_CODE.USAGE);
   }
@@ -5404,6 +5368,7 @@ async function runReindex(options, global) {
     const extensionVectorAdapter = resolveExtensionVectorAdapter(settings);
     const semanticRuntime = assertSemanticRuntimeAvailable({
       requestedMode,
+      pmRoot,
       settings,
       extensionEmbedding,
       extensionVectorAdapter
@@ -5520,40 +5485,61 @@ var PmClient = class {
   run(action, args = {}) {
     return runAction({ ...this.defaults, ...args, action });
   }
+  runTyped(action, args = {}) {
+    return this.run(action, args);
+  }
   /**
    * Return the same context snapshot produced by `pm context`.
    */
   context(options = {}) {
-    return this.run("context", { options });
+    return this.runTyped("context", { options });
   }
   /**
    * List items with the MCP/agent compact defaults.
    */
   list(options = {}) {
-    return this.run("list", { options });
+    return this.runTyped("list", { options });
   }
   /**
    * Search items with the MCP/agent compact defaults.
    */
   search(query, options = {}) {
-    return this.run("search", { query, options });
+    return this.runTyped("search", { query, options });
   }
   /**
    * Read one item by id.
    */
   get(id, options = {}) {
-    return this.run("get", { id, options });
+    return this.runTyped("get", { id, options });
+  }
+  /**
+   * Return the ranked next-work recommendation produced by `pm next`.
+   */
+  next(options = {}) {
+    return this.runTyped("next", { options });
+  }
+  /**
+   * Group matching items with the same semantics as `pm aggregate`.
+   */
+  aggregate(options = {}) {
+    return this.runTyped("aggregate", { options });
+  }
+  /**
+   * Return project tracker statistics with the same sections as `pm stats`.
+   */
+  stats(options = {}) {
+    return this.runTyped("stats", { options });
   }
   /**
    * Create an item using the same mutation path as `pm create`.
    */
-  create(options) {
+  create(options = {}) {
     return this.run("create", splitClientMutationOptions(options));
   }
   /**
    * Update an item using the same mutation path as `pm update`.
    */
-  update(id, options) {
+  update(id, options = {}) {
     return this.run("update", { id, ...splitClientMutationOptions(options) });
   }
   /**
@@ -5562,7 +5548,271 @@ var PmClient = class {
   close(id, reason, options = {}) {
     return this.run("close", { id, reason, ...splitClientMutationOptions(options) });
   }
+  /**
+   * Claim an item using the same mutation path as `pm claim`.
+   */
+  claim(id, options = {}) {
+    return this.run("claim", { id, ...splitClientMutationOptions(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) });
+  }
+  /**
+   * Copy an item using the same mutation path as `pm copy`.
+   */
+  copy(id, options = {}) {
+    return this.run("copy", { id, ...splitClientMutationOptions(options) });
+  }
+  /**
+   * Delete an item using the same mutation path as `pm delete`.
+   */
+  delete(id, options = {}) {
+    return this.run("delete", { id, ...splitClientMutationOptions(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 },
+      id,
+      options: { ...runnerOptions, 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) });
+  }
+  /**
+   * Claim an item and transition it to the workspace in-progress status.
+   */
+  startTask(id, options = {}) {
+    return this.run("start-task", { id, ...splitClientMutationOptions(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) });
+  }
+  /**
+   * Close an item and release its active assignment.
+   */
+  closeTask(id, reason, options = {}) {
+    return this.run("close-task", { id, reason, ...splitClientMutationOptions(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 = {}) {
+  return new PmClient(clientOptions).context(options);
+}
+function list(options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).list(options);
+}
+function search(query, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).search(query, options);
+}
+function get(id, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).get(id, options);
+}
+function next(options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).next(options);
+}
+function aggregate(options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).aggregate(options);
+}
+function stats(options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).stats(options);
+}
+function create(options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).create(options);
+}
+function update(id, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).update(id, options);
+}
+function close(id, reason, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).close(id, reason, options);
+}
+function claim(id, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).claim(id, options);
+}
+function release(id, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).release(id, options);
+}
+function copy(id, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).copy(id, options);
+}
+function deleteItem(id, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).delete(id, options);
+}
+function restore(id, target, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).restore(id, target, options);
+}
+function focus(id, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).focus(id, options);
+}
+function startTask(id, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).startTask(id, options);
+}
+function pauseTask(id, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).pauseTask(id, options);
+}
+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),
@@ -5667,6 +5917,13 @@ var ARRAY_ADD_REMOVE_ACTIONS = /* @__PURE__ */ new Set([
   "test",
   "test-all"
 ]);
+var LIFECYCLE_AUTHOR_ALIAS_ACTIONS = /* @__PURE__ */ new Set([
+  "claim",
+  "release",
+  "start-task",
+  "pause-task",
+  "close-task"
+]);
 function normalizeMcpOptionsArrays(options, action) {
   const result = {};
   const promoteAddRemove = action !== void 0 && ARRAY_ADD_REMOVE_ACTIONS.has(action);
@@ -5711,6 +5968,16 @@ function optionsWithAuthor(args, action) {
     hoistKey("priority");
     hoistKey("limit");
   } else if (action === "create") {
+    hoistKey("title");
+    hoistKey("type");
+    hoistKey("status");
+    hoistKey("description");
+    hoistKey("body");
+    hoistKey("priority");
+    hoistKey("tags");
+    hoistKey("parent");
+    hoistKey("createMode");
+    hoistKey("create_mode");
     hoistKey("allowMissingParent");
   } else if (action === "close") {
     hoistKey("duplicateOf");
@@ -5719,27 +5986,34 @@ function optionsWithAuthor(args, action) {
   }
   const options = normalizeMcpOptionsArrays({ ...hoistedTopLevel, ...baseOptions }, action);
   const author = readString(args, "author");
-  return author && options.author === void 0 ? { ...options, author } : options;
+  const authorFromAssignee = action !== void 0 && LIFECYCLE_AUTHOR_ALIAS_ACTIONS.has(action) ? readString(args, "assignee") ?? readString(options, "assignee") : void 0;
+  if (author && options.author === void 0) {
+    return { ...options, author };
+  }
+  if (authorFromAssignee && options.author === void 0) {
+    return { ...options, author: authorFromAssignee };
+  }
+  return options;
 }
 function withAddNoteOption(options) {
   if (options.addNote === void 0) {
     return options;
   }
-  const next = { ...options };
-  if (next.note === void 0 && typeof next.addNote === "string") {
-    next.note = next.addNote;
+  const next2 = { ...options };
+  if (next2.note === void 0 && typeof next2.addNote === "string") {
+    next2.note = next2.addNote;
   }
-  delete next.addNote;
-  return next;
+  delete next2.addNote;
+  return next2;
 }
 function withFilesDiscoveryOptions(options) {
-  const next = { ...options };
-  if (next.discoveryNote !== void 0 && next.note === void 0 && typeof next.discoveryNote === "string") {
-    next.note = next.discoveryNote;
+  const next2 = { ...options };
+  if (next2.discoveryNote !== void 0 && next2.note === void 0 && typeof next2.discoveryNote === "string") {
+    next2.note = next2.discoveryNote;
   }
-  delete next.discover;
-  delete next.discoveryNote;
-  return next;
+  delete next2.discover;
+  delete next2.discoveryNote;
+  return next2;
 }
 function normalizeActionName(value) {
   const chunks = [];
@@ -5948,14 +6222,14 @@ var UPDATE_MANY_FLAT_CONTROL_KEYS = /* @__PURE__ */ new Set([
   "no_checkpoint"
 ]);
 function updateManyUpdateOptionsFromFlat(options) {
-  const update = {};
+  const update2 = {};
   for (const [key, value] of Object.entries(options)) {
     if (UPDATE_MANY_FLAT_CONTROL_KEYS.has(key)) {
       continue;
     }
-    update[key] = value;
+    update2[key] = value;
   }
-  return normalizeMcpUpdateOptions(update);
+  return normalizeMcpUpdateOptions(update2);
 }
 function normalizeMcpUpdateOptions(options) {
   const normalizedInput = normalizeMcpOptionsArrays(options, "update-many");
@@ -6061,6 +6335,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) {
@@ -6386,7 +6663,17 @@ async function runMcpCloseManyAction(ctx) {
   return projectMutationResult(await runCloseMany(closeManyOptionsFromFlat(closeManyRunnerOptions), ctx.global), { changedFields });
 }
 async function runMcpRestoreAction(ctx) {
-  return runRestore(requireMcpItemId(ctx), readRequiredString(ctx.options, "target"), ctx.options, ctx.global);
+  const { changedFields, idOnly, runnerOptions } = withMutationCompaction(ctx.args, ctx.options);
+  const target = readString(runnerOptions, "target") ?? readRequiredString(ctx.args, "target");
+  return projectMutationResult(await runRestore(requireMcpItemId(ctx, runnerOptions), target, runnerOptions, ctx.global), {
+    changedFields,
+    idOnly
+  });
+}
+function withoutLifecycleAssigneeAlias(options) {
+  const updateOptions = { ...options };
+  delete updateOptions.assignee;
+  return updateOptions;
 }
 async function runMcpStartTaskAction(ctx) {
   const pmRoot = resolvePmRoot(process.cwd(), ctx.global.path);
@@ -6394,7 +6681,7 @@ async function runMcpStartTaskAction(ctx) {
   const inProgressStatus = resolveStartTaskInProgressStatus(resolveRuntimeStatusRegistry(settings.schema));
   const id = requireMcpItemId(ctx);
   const claimResult = await runClaim(id, ctx.force, ctx.global, ctx.options);
-  const updateResult = await runUpdate(id, { ...ctx.options, status: inProgressStatus, force: ctx.force }, ctx.global);
+  const updateResult = await runUpdate(id, { ...withoutLifecycleAssigneeAlias(ctx.options), status: inProgressStatus, force: ctx.force }, ctx.global);
   return { id, action: "start_task", claim: claimResult, update: updateResult };
 }
 async function runMcpPauseTaskAction(ctx) {
@@ -6402,7 +6689,7 @@ async function runMcpPauseTaskAction(ctx) {
   const settings = await readSettings(pmRoot);
   const id = requireMcpItemId(ctx);
   const openStatus = resolveRuntimeStatusRegistry(settings.schema).open_status;
-  const updateResult = await runUpdate(id, { ...ctx.options, status: openStatus, force: ctx.force }, ctx.global);
+  const updateResult = await runUpdate(id, { ...withoutLifecycleAssigneeAlias(ctx.options), status: openStatus, force: ctx.force }, ctx.global);
   const releaseResult = await runRelease(id, ctx.force, ctx.global, ctx.options);
   return { id, action: "pause_task", update: updateResult, release: releaseResult };
 }
@@ -6557,11 +6844,46 @@ export {
   runNormalize,
   runReindex,
   PmClient,
+  context,
+  list,
+  search,
+  get,
+  next,
+  aggregate,
+  stats,
+  create,
+  update,
+  close,
+  claim,
+  release,
+  copy,
+  deleteItem,
+  restore,
+  focus,
+  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-TKD5VCTD.js.map
+//# sourceMappingURL=chunk-2RADY7IB.js.map
 
-//# debugId=2c7e86dd-91a7-512d-9ef1-93d67aff97c1
+//# debugId=172e4594-e82f-5ac4-add6-4f96b3b2890f