@unbrained/pm-cli 2026.7.5 → 2026.7.7

package/dist/cli-bundle/chunks/{chunk-T5Y3QSNF.js → chunk-MHNMCDWR.js}

@@ -1,31 +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]="c6d1c49f-01ed-5fa4-b05d-e515ef54f671")}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]="8e64eac6-c632-5921-b8ce-74dd117c9670")}catch(e){}}();
 import {
-  runContracts
-} from "./chunk-MNZ7DRNC.js";
+  runFiles,
+  runFilesDiscover
+} from "./chunk-GPIDUMMN.js";
 import {
-  runUpdate
-} from "./chunk-TSPKZRRW.js";
+  runDocs
+} from "./chunk-V5ZWKJNY.js";
 import {
-  jaccardSimilarity,
-  normalizeLowercaseWhitespace,
-  tokenizeAlphaNumeric
-} from "./chunk-ZJB3UV5U.js";
+  runDeps
+} from "./chunk-XS2TMNXR.js";
 import {
-  parseTags
-} from "./chunk-7WYXBPYQ.js";
+  assertHistoryRepairTarget,
+  runHistoryRepair,
+  runHistoryRepairAll
+} from "./chunk-42LXP4VO.js";
+import {
+  resolveStartTaskInProgressStatus,
+  runClaim,
+  runContracts,
+  runGc,
+  runHealth,
+  runRelease,
+  runStats,
+  runTelemetry,
+  runTest,
+  runTestAll,
+  runValidate
+} from "./chunk-J2VGADNG.js";
+import {
+  runComments
+} from "./chunk-II7R6KD4.js";
+import {
+  runCopy
+} from "./chunk-5FIQ4EX3.js";
+import {
+  runFocus
+} from "./chunk-RB3KLPAH.js";
+import {
+  runDelete
+} from "./chunk-NWWL22C7.js";
+import {
+  runAppend
+} from "./chunk-Q64AYQYW.js";
+import {
+  runProfileApply,
+  runProfileLint,
+  runProfileList,
+  runProfileShow
+} from "./chunk-YH5NBDFA.js";
+import {
+  runNotes
+} from "./chunk-VGO73OCK.js";
+import {
+  runLearnings
+} from "./chunk-SIM5JDON.js";
+import {
+  runCloseMany
+} from "./chunk-4IQKDKGE.js";
+import {
+  runUpdateMany
+} from "./chunk-QDABF2RB.js";
+import {
+  runRestore
+} from "./chunk-EMXPI36L.js";
+import {
+  runUpdate
+} from "./chunk-7PNQA24K.js";
 import {
   runClose
-} from "./chunk-K3AGVXSF.js";
+} from "./chunk-6LCJRGPD.js";
+import {
+  runPlan
+} from "./chunk-XXIYUTLK.js";
+import {
+  runHistoryCompact
+} from "./chunk-XHCVAZGM.js";
 import {
-  buildListQueryFilters
-} from "./chunk-VY3VQ22F.js";
+  runHistoryRedact
+} from "./chunk-52NS7JDP.js";
 import {
+  runConfig,
+  runUpgrade
+} from "./chunk-6G6O3OPQ.js";
+import {
+  SCAFFOLD_CAPABILITIES,
+  runExtension,
+  runInit
+} from "./chunk-Y5IKRUEM.js";
+import {
+  runSchemaAddField,
+  runSchemaAddStatus,
+  runSchemaAddType,
+  runSchemaApplyPreset,
+  runSchemaInferTypes,
+  runSchemaList,
+  runSchemaListFields,
+  runSchemaRemoveField,
+  runSchemaRemoveStatus,
+  runSchemaRemoveType,
+  runSchemaShow,
+  runSchemaShowField,
+  runSchemaShowStatus
+} from "./chunk-CJQM7O7R.js";
+import {
+  jaccardSimilarity,
+  normalizeLowercaseWhitespace,
+  runActivity,
+  runAggregate,
+  runContext,
+  runGet,
+  runNext,
+  runSearch,
+  tokenizeAlphaNumeric
+} from "./chunk-7ML7JONU.js";
+import {
+  buildListQueryFilters,
   runList
-} from "./chunk-YSAH5FY5.js";
+} from "./chunk-RY7PTTUB.js";
+import {
+  runHistory
+} from "./chunk-565WYS5W.js";
 import {
   parseIntegerLimit
-} from "./chunk-YFIE7YK6.js";
+} from "./chunk-AJUON7E6.js";
+import {
+  resolveRegisteredSearchProvider,
+  resolveRegisteredVectorStoreAdapter
+} from "./chunk-KGHH652T.js";
 import {
   REINDEX_LOCK_ID,
   buildSearchCorpus,
@@ -39,6 +141,8 @@ import {
   hasVectorizationEmbeddingIdentityChanged,
   hasVectorizationVectorDimensionChanged,
   inferConsistentVectorDimension,
+  normalizeListOptions,
+  normalizeUpdateOptions,
   readVectorizationStatusLedger,
   resolveEmbeddingProviders,
   resolveSearchCorpusFields,
@@ -46,17 +150,7 @@ import {
   resolveSettingsWithSemanticRuntimeDefaults,
   resolveVectorStores,
   writeVectorizationStatusLedger
-} from "./chunk-7QH7DHUB.js";
-import {
-  resolveRegisteredSearchProvider,
-  resolveRegisteredVectorStoreAdapter
-} from "./chunk-KGHH652T.js";
-import {
-  SCAFFOLD_CAPABILITIES
-} from "./chunk-53BTLLAF.js";
-import {
-  splitCommaList
-} from "./chunk-P4SESZGT.js";
+} from "./chunk-XZWL7VNE.js";
 import {
   ACTIVITY_FLAG_CONTRACTS,
   AGGREGATE_FLAG_CONTRACTS,
@@ -85,42 +179,66 @@ import {
   PM_CORE_COMMAND_NAMES,
   REMIND_FLAG_CONTRACTS,
   SEARCH_FLAG_CONTRACTS,
+  UPDATE_COMMANDER_STRING_OPTION_CONTRACTS,
   UPDATE_FLAG_CONTRACTS,
   UPDATE_MANY_FLAG_CONTRACTS,
   toCompletionFlagString
-} from "./chunk-PPE4YUQM.js";
+} from "./chunk-2APXX4TZ.js";
 import {
+  runCreate
+} from "./chunk-QFBSP3NI.js";
+import {
+  parseTags
+} from "./chunk-DR2V5OIV.js";
+import {
+  splitCommaList
+} from "./chunk-P4SESZGT.js";
+import {
+  projectMutationResult
+} from "./chunk-EOUVR7JN.js";
+import {
+  PmCliError,
   acquireLock,
   appendHistoryEntry,
   collectRegisteredItemFieldNames,
+  compareTimestampStrings,
   createHistoryEntry,
+  getActiveExtensionRegistrations,
+  isTerminalStatus,
   listAllDocumentCandidatesCached,
   locateItem,
-  readLocatedItem,
-  toItemRecord
-} from "./chunk-57C2RLW5.js";
-import {
-  isTerminalStatus,
   normalizeStatusInput,
+  nowIso,
   parseItemDocument,
-  serializeItemDocument
-} from "./chunk-HK72NWAD.js";
-import {
-  compareTimestampStrings,
-  nowIso
-} from "./chunk-FJRKQREY.js";
-import {
-  PmCliError,
-  getActiveExtensionRegistrations,
+  readLocatedItem,
   readSettings,
+  runActiveCommandHandler,
   runActiveOnIndexHooks,
-  runActiveOnWriteHooks
-} from "./chunk-US3T3W5J.js";
+  runActiveOnWriteHooks,
+  serializeItemDocument,
+  setActiveExtensionCommands,
+  setActiveExtensionHooks,
+  setActiveExtensionParsers,
+  setActiveExtensionPreflight,
+  setActiveExtensionRegistrations,
+  setActiveExtensionRenderers,
+  setActiveExtensionServices,
+  toItemRecord
+} from "./chunk-GH73UOSJ.js";
 import {
   BUILTIN_ITEM_TYPE_VALUES,
   EXIT_CODE,
   STATUS_VALUES,
   activateExtensions,
+  asRecordClone,
+  createEmptyExtensionCommandRegistry,
+  createEmptyExtensionHookRegistry,
+  createEmptyExtensionParserRegistry,
+  createEmptyExtensionPreflightRegistry,
+  createEmptyExtensionRegistrationRegistry,
+  createEmptyExtensionRendererRegistry,
+  createEmptyExtensionServiceRegistry,
+  deactivateExtensions,
   getHistoryPath,
   getSettingsPath,
   loadExtensions,
@@ -133,11 +251,97 @@ import {
   toErrorMessage,
   toNonEmptyStringOrUndefined,
   writeFileAtomic
-} from "./chunk-YD5FML7K.js";
+} from "./chunk-UO7XAZK6.js";
 
 // dist/sdk/runtime.js
 import path3 from "node:path";
 
+// dist/core/output/query-summary.js
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function resolveQueryProjectionLabel(options) {
+  if (options.brief === true) {
+    return "brief";
+  }
+  if (typeof options.fields === "string" && options.fields.trim().length > 0) {
+    return "fields";
+  }
+  if (Array.isArray(options.fields) && options.fields.length > 0) {
+    return "fields";
+  }
+  if (options.compact === true) {
+    return "compact";
+  }
+  return "full";
+}
+function withQuerySummary(result, options) {
+  const requestedLabel = resolveQueryProjectionLabel(options);
+  const projection = requestedLabel === "brief" ? requestedLabel : isRecord(result.projection) && typeof result.projection.mode === "string" ? result.projection.mode : requestedLabel;
+  return {
+    ...result,
+    query_summary: {
+      filters: isRecord(result.filters) ? result.filters : {},
+      projection
+    }
+  };
+}
+
+// dist/core/shared/serial-queue.js
+function createSerialQueue() {
+  let tail = Promise.resolve();
+  let pending = 0;
+  const idleWaiters = [];
+  const notifyIdle = () => {
+    if (pending !== 0) {
+      return;
+    }
+    const waiters = idleWaiters.splice(0);
+    for (const resolve of waiters) {
+      resolve();
+    }
+  };
+  return {
+    enqueue(task) {
+      pending++;
+      const run = tail.then(() => task());
+      tail = run.then(() => void 0, () => void 0).finally(() => {
+        pending--;
+        notifyIdle();
+      });
+      return run;
+    },
+    idle() {
+      return pending === 0 ? Promise.resolve() : new Promise((resolve) => idleWaiters.push(resolve));
+    }
+  };
+}
+
+// dist/sdk/workspace-contracts-cache.js
+var WORKSPACE_CONTRACTS_CACHE_LIMIT = 50;
+var workspaceExtensionRegistrationsCache = /* @__PURE__ */ new Map();
+function clearWorkspaceContractsCache() {
+  workspaceExtensionRegistrationsCache.clear();
+}
+function memoizeWorkspaceExtensionRegistrations(cacheKey, loadRegistrations) {
+  const cached = workspaceExtensionRegistrationsCache.get(cacheKey);
+  if (cached !== void 0) {
+    return cached;
+  }
+  if (workspaceExtensionRegistrationsCache.size >= WORKSPACE_CONTRACTS_CACHE_LIMIT) {
+    const oldestKey = workspaceExtensionRegistrationsCache.keys().next().value;
+    workspaceExtensionRegistrationsCache.delete(oldestKey);
+  }
+  const registrations = loadRegistrations().catch((error) => {
+    if (workspaceExtensionRegistrationsCache.get(cacheKey) === registrations) {
+      workspaceExtensionRegistrationsCache.delete(cacheKey);
+    }
+    throw error;
+  });
+  workspaceExtensionRegistrationsCache.set(cacheKey, registrations);
+  return registrations;
+}
+
 // dist/sdk/package-runtime-options.js
 var BOOLEAN_TRUE_VALUES = /* @__PURE__ */ new Set(["true", "1", "yes", "on"]);
 var BOOLEAN_FALSE_VALUES = /* @__PURE__ */ new Set(["false", "0", "no", "off"]);
@@ -3689,16 +3893,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
     };
@@ -4204,17 +4408,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, {
@@ -4222,12 +4426,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);
@@ -4274,14 +4478,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);
@@ -4714,9 +4918,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;
 }
@@ -4885,7 +5089,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);
   }
@@ -5156,6 +5360,7 @@ async function runReindex(options, global) {
     const extensionVectorAdapter = resolveExtensionVectorAdapter(settings);
     const semanticRuntime = assertSemanticRuntimeAvailable({
       requestedMode,
+      pmRoot,
       settings,
       extensionEmbedding,
       extensionVectorAdapter
@@ -5245,8 +5450,214 @@ async function runReindex(options, global) {
 }
 
 // dist/sdk/runtime.js
-var WORKSPACE_CONTRACTS_CACHE_LIMIT = 50;
-var workspaceExtensionRegistrationsCache = /* @__PURE__ */ new Map();
+function splitClientMutationOptions(options) {
+  const { fullChangedFields, idOnly, ...runnerOptions } = options;
+  return {
+    ...fullChangedFields === void 0 ? {} : { fullChangedFields },
+    ...idOnly === void 0 ? {} : { idOnly },
+    options: runnerOptions
+  };
+}
+var PmClient = class {
+  defaults;
+  /**
+   * Create a client with workspace, author, and extension-loading defaults.
+   */
+  constructor(options = {}) {
+    this.defaults = {
+      ...options.pmRoot === void 0 ? {} : { path: options.pmRoot },
+      ...options.cwd === void 0 ? {} : { cwd: options.cwd },
+      ...options.author === void 0 ? {} : { author: options.author },
+      ...options.noExtensions === void 0 ? {} : { noExtensions: options.noExtensions }
+    };
+  }
+  /**
+   * Run any native or extension-contributed action through the SDK dispatcher.
+   */
+  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.runTyped("context", { options });
+  }
+  /**
+   * List items with the MCP/agent compact defaults.
+   */
+  list(options = {}) {
+    return this.runTyped("list", { options });
+  }
+  /**
+   * Search items with the MCP/agent compact defaults.
+   */
+  search(query, options = {}) {
+    return this.runTyped("search", { query, options });
+  }
+  /**
+   * Read one item by id.
+   */
+  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 = {}) {
+    return this.run("create", splitClientMutationOptions(options));
+  }
+  /**
+   * Update an item using the same mutation path as `pm update`.
+   */
+  update(id, options = {}) {
+    return this.run("update", { id, ...splitClientMutationOptions(options) });
+  }
+  /**
+   * Close an item using the same mutation path as `pm close`.
+   */
+  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) });
+  }
+};
+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 buildWorkspaceExtensionRegistrationsCacheKey(pmRoot, settings, cwd) {
   return JSON.stringify([
     path3.resolve(pmRoot),
@@ -5256,22 +5667,9 @@ function buildWorkspaceExtensionRegistrationsCacheKey(pmRoot, settings, cwd) {
     settings.extensions.policy
   ]);
 }
-function clearWorkspaceContractsCache() {
-  workspaceExtensionRegistrationsCache.clear();
-}
 async function resolveWorkspaceExtensionRegistrations(pmRoot, settings, cwd) {
   const cacheKey = buildWorkspaceExtensionRegistrationsCacheKey(pmRoot, settings, cwd);
-  const cached = workspaceExtensionRegistrationsCache.get(cacheKey);
-  if (cached !== void 0) {
-    return cached;
-  }
-  if (workspaceExtensionRegistrationsCache.size >= WORKSPACE_CONTRACTS_CACHE_LIMIT) {
-    const oldestKey = workspaceExtensionRegistrationsCache.keys().next().value;
-    workspaceExtensionRegistrationsCache.delete(oldestKey);
-  }
-  const registrations = loadWorkspaceExtensionRegistrations(pmRoot, settings, cwd);
-  workspaceExtensionRegistrationsCache.set(cacheKey, registrations);
-  return registrations;
+  return memoizeWorkspaceExtensionRegistrations(cacheKey, () => loadWorkspaceExtensionRegistrations(pmRoot, settings, cwd));
 }
 async function getWorkspaceContracts(pmRoot, options = {}) {
   const settings = await readSettings(pmRoot);
@@ -5298,6 +5696,940 @@ async function getContracts(pmRootOrOptions, options = {}) {
   };
   return runContracts(resolvedOptions, global);
 }
+function readString(args, key) {
+  const value = args[key];
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function readScalarString(args, key) {
+  const value = args[key];
+  if (typeof value === "string") {
+    return value.trim().length > 0 ? value : void 0;
+  }
+  return typeof value === "number" && Number.isFinite(value) ? String(value) : void 0;
+}
+function readScalarStringAllowBlank(args, key) {
+  const value = args[key];
+  if (typeof value === "string") {
+    return value;
+  }
+  return typeof value === "number" && Number.isFinite(value) ? String(value) : void 0;
+}
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function readRequiredString(args, key) {
+  const value = readString(args, key);
+  if (!value) {
+    throw new PmCliError(`Missing required argument: ${key}`, 64);
+  }
+  return value;
+}
+function globalOptions(args) {
+  return {
+    json: true,
+    quiet: true,
+    path: readString(args, "path"),
+    noExtensions: args.noExtensions === true || args.no_extensions === true,
+    noPager: true
+  };
+}
+var ARRAY_TO_CSV_FIELDS = /* @__PURE__ */ new Set(["tags", "blockedBy", "blocked_by", "skills", "fields"]);
+var SCALAR_TO_ARRAY_FIELDS = /* @__PURE__ */ new Set([
+  "comment",
+  "note",
+  "learning",
+  "reminder",
+  "event",
+  "dep",
+  "depRemove",
+  "dep_remove",
+  "file",
+  "doc",
+  "test",
+  "unset",
+  "addGlob",
+  "add_glob",
+  "migrate",
+  "envSet",
+  "env_set",
+  "envClear",
+  "env_clear"
+]);
+var ARRAY_ADD_REMOVE_ACTIONS = /* @__PURE__ */ new Set([
+  "files",
+  "files-discover",
+  "docs",
+  "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);
+  for (const [key, value] of Object.entries(options)) {
+    if (Array.isArray(value) && ARRAY_TO_CSV_FIELDS.has(key)) {
+      result[key] = value.join(",");
+      continue;
+    }
+    if (typeof value === "string" && SCALAR_TO_ARRAY_FIELDS.has(key)) {
+      result[key] = [value];
+      continue;
+    }
+    if (typeof value === "string" && promoteAddRemove && (key === "add" || key === "remove")) {
+      result[key] = [value];
+      continue;
+    }
+    result[key] = value;
+  }
+  return result;
+}
+function optionsWithAuthor(args, action) {
+  const baseOptions = asRecordClone(args.options);
+  const hoistedTopLevel = {};
+  const hoistKey = (key) => {
+    if (baseOptions[key] !== void 0 || args[key] === void 0) {
+      return;
+    }
+    hoistedTopLevel[key] = args[key];
+  };
+  if (action === "list") {
+    hoistKey("status");
+    hoistKey("type");
+    hoistKey("tag");
+    hoistKey("priority");
+    hoistKey("limit");
+    hoistKey("offset");
+  } else if (action === "search") {
+    hoistKey("mode");
+    hoistKey("status");
+    hoistKey("type");
+    hoistKey("tag");
+    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");
+  } else if (action === "append") {
+    hoistKey("body");
+  }
+  const options = normalizeMcpOptionsArrays({ ...hoistedTopLevel, ...baseOptions }, action);
+  const author = readString(args, "author");
+  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 next2 = { ...options };
+  if (next2.note === void 0 && typeof next2.addNote === "string") {
+    next2.note = next2.addNote;
+  }
+  delete next2.addNote;
+  return next2;
+}
+function withFilesDiscoveryOptions(options) {
+  const next2 = { ...options };
+  if (next2.discoveryNote !== void 0 && next2.note === void 0 && typeof next2.discoveryNote === "string") {
+    next2.note = next2.discoveryNote;
+  }
+  delete next2.discover;
+  delete next2.discoveryNote;
+  return next2;
+}
+function normalizeActionName(value) {
+  const chunks = [];
+  let lastWasSeparator = true;
+  for (const character of value.trim().toLowerCase()) {
+    const isAlphaNumeric = character >= "a" && character <= "z" || character >= "0" && character <= "9";
+    if (isAlphaNumeric) {
+      chunks.push(character);
+      lastWasSeparator = false;
+      continue;
+    }
+    if (!lastWasSeparator) {
+      chunks.push("-");
+      lastWasSeparator = true;
+    }
+  }
+  if (chunks.at(-1) === "-") {
+    chunks.pop();
+  }
+  return chunks.join("");
+}
+function normalizeCommandPath(value) {
+  return value.trim().toLowerCase().split(/\s+/).filter(Boolean).join(" ");
+}
+function readStringArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((entry) => String(entry)).filter((entry) => entry.length > 0);
+}
+function extensionOptionsFromArgs(args, options) {
+  const reserved = /* @__PURE__ */ new Set([
+    "action",
+    "args",
+    "author",
+    "cwd",
+    "fullChangedFields",
+    "id",
+    "options",
+    "path",
+    "query",
+    "reason",
+    "target"
+  ]);
+  const passthrough = {};
+  for (const [key, value] of Object.entries(args)) {
+    if (!reserved.has(key)) {
+      passthrough[key] = value;
+    }
+  }
+  const normalizedOptions = { ...passthrough, ...options };
+  delete normalizedOptions.args;
+  return normalizedOptions;
+}
+var extensionActivationQueue = createSerialQueue();
+function resetActiveExtensionRegistries() {
+  setActiveExtensionHooks(createEmptyExtensionHookRegistry());
+  setActiveExtensionCommands(createEmptyExtensionCommandRegistry());
+  setActiveExtensionParsers(createEmptyExtensionParserRegistry());
+  setActiveExtensionPreflight(createEmptyExtensionPreflightRegistry());
+  setActiveExtensionServices(createEmptyExtensionServiceRegistry());
+  setActiveExtensionRenderers(createEmptyExtensionRendererRegistry());
+  setActiveExtensionRegistrations(createEmptyExtensionRegistrationRegistry());
+}
+async function withActiveExtensions(global, explicitCwd, resolutionCwd, run) {
+  return extensionActivationQueue.enqueue(async () => explicitCwd === void 0 ? await withActiveExtensionsExclusively(global, resolutionCwd, run) : await withCwd(explicitCwd, () => withActiveExtensionsExclusively(global, resolutionCwd, run)));
+}
+async function withActiveExtensionsExclusively(global, cwd, run) {
+  if (global.noExtensions) {
+    resetActiveExtensionRegistries();
+    return run(null);
+  }
+  const pmRoot = resolvePmRoot(cwd, global.path);
+  if (!await pathExists(getSettingsPath(pmRoot))) {
+    resetActiveExtensionRegistries();
+    return run(null);
+  }
+  let active = null;
+  let activated;
+  try {
+    const settings = await readSettings(pmRoot);
+    const loadResult = await loadExtensions({ pmRoot, settings, cwd, noExtensions: false });
+    const activationResult = await activateExtensions({ ...loadResult, loaded: loadResult.loaded });
+    activated = { loadResult, activationResult };
+    setActiveExtensionHooks(activationResult.hooks);
+    setActiveExtensionCommands(activationResult.commands);
+    setActiveExtensionParsers(activationResult.parsers);
+    setActiveExtensionPreflight(activationResult.preflight);
+    setActiveExtensionServices(activationResult.services);
+    setActiveExtensionRenderers(activationResult.renderers);
+    setActiveExtensionRegistrations(activationResult.registrations);
+    active = { registrations: activationResult.registrations, commands: activationResult.commands, pmRoot };
+  } catch (error) {
+    resetActiveExtensionRegistries();
+    console.error("[pm-sdk] extension activation failed; continuing without active extensions:", error);
+  }
+  try {
+    return await run(active);
+  } finally {
+    resetActiveExtensionRegistries();
+    if (activated) {
+      await deactivateExtensions(activated.loadResult, activated.activationResult).catch(() => void 0);
+    }
+  }
+}
+async function dispatchActiveExtensionAction(action, args, options, global, active) {
+  if (!active) {
+    throw new PmCliError(`Unsupported native pm action: ${action}`, 64);
+  }
+  const normalizedAction = normalizeActionName(action);
+  const definition = active.registrations.commands.find((entry) => normalizeActionName(entry.action) === normalizedAction);
+  const command = definition?.command ?? active.commands.handlers.find((entry) => normalizeActionName(entry.command) === normalizedAction)?.command;
+  if (!command) {
+    throw new PmCliError(`Unsupported native pm action: ${action}`, 64);
+  }
+  const handlerResult = await runActiveCommandHandler({
+    command: normalizeCommandPath(command),
+    args: readStringArray(options.args ?? args.args),
+    options: extensionOptionsFromArgs(args, options),
+    global,
+    pm_root: active.pmRoot
+  });
+  if (!handlerResult.handled) {
+    const suffix = handlerResult.warnings.length > 0 ? ` (${handlerResult.warnings.join(", ")})` : "";
+    throw new PmCliError(`Unsupported native pm action: ${action}${suffix}`, 64);
+  }
+  return handlerResult.result;
+}
+async function withCwd(cwd, run) {
+  const previous = process.cwd();
+  process.chdir(cwd);
+  try {
+    return await run();
+  } finally {
+    process.chdir(previous);
+  }
+}
+function withMutationCompaction(args, options) {
+  return { changedFields: args.fullChangedFields === true ? "full" : "compact", idOnly: args.idOnly === true, runnerOptions: { ...options } };
+}
+function mutationListOptions(options) {
+  return {
+    type: readScalarString(options, "filterType"),
+    tag: readScalarString(options, "filterTag"),
+    priority: readScalarString(options, "filterPriority"),
+    deadlineBefore: readScalarString(options, "filterDeadlineBefore"),
+    deadlineAfter: readScalarString(options, "filterDeadlineAfter"),
+    updatedAfter: readScalarString(options, "filterUpdatedAfter"),
+    updatedBefore: readScalarString(options, "filterUpdatedBefore"),
+    createdAfter: readScalarString(options, "filterCreatedAfter"),
+    createdBefore: readScalarString(options, "filterCreatedBefore"),
+    ids: readScalarStringAllowBlank(options, "ids"),
+    assignee: readScalarString(options, "filterAssignee"),
+    assigneeFilter: readScalarString(options, "filterAssigneeFilter") ?? readScalarString(options, "filterAssignee_filter"),
+    parent: readScalarString(options, "filterParent"),
+    sprint: readScalarString(options, "filterSprint"),
+    release: readScalarString(options, "filterRelease"),
+    limit: readScalarString(options, "limit"),
+    offset: readScalarString(options, "offset")
+  };
+}
+function closeManyOptionsFromFlat(options) {
+  return {
+    status: readString(options, "filterStatus"),
+    list: isRecord2(options.list) ? normalizeListOptions(options.list) : mutationListOptions(options),
+    reason: readString(options, "reason"),
+    resolution: readString(options, "resolution"),
+    expectedResult: readString(options, "expectedResult") ?? readString(options, "expected_result") ?? readString(options, "expected"),
+    actualResult: readString(options, "actualResult") ?? readString(options, "actual_result") ?? readString(options, "actual"),
+    validateClose: readString(options, "validateClose") ?? readString(options, "validate_close"),
+    author: readString(options, "author"),
+    message: readString(options, "message"),
+    force: options.force === true ? true : void 0,
+    dryRun: options.dryRun === true || options.dry_run === true ? true : void 0,
+    rollback: readString(options, "rollback"),
+    checkpoint: options.checkpoint === false || options.noCheckpoint === true || options.no_checkpoint === true ? false : void 0
+  };
+}
+var UPDATE_MANY_FLAT_CONTROL_KEYS = /* @__PURE__ */ new Set([
+  "filterStatus",
+  "filterType",
+  "filterTag",
+  "filterPriority",
+  "filterDeadlineBefore",
+  "filterDeadlineAfter",
+  "filterUpdatedAfter",
+  "filterUpdatedBefore",
+  "filterCreatedAfter",
+  "filterCreatedBefore",
+  "filterAssignee",
+  "filterAssigneeFilter",
+  "filterAssignee_filter",
+  "filterParent",
+  "filterSprint",
+  "filterRelease",
+  "ids",
+  "list",
+  "update",
+  "limit",
+  "offset",
+  "dryRun",
+  "dry_run",
+  "rollback",
+  "checkpoint",
+  "noCheckpoint",
+  "no_checkpoint"
+]);
+function updateManyUpdateOptionsFromFlat(options) {
+  const update2 = {};
+  for (const [key, value] of Object.entries(options)) {
+    if (UPDATE_MANY_FLAT_CONTROL_KEYS.has(key)) {
+      continue;
+    }
+    update2[key] = value;
+  }
+  return normalizeMcpUpdateOptions(update2);
+}
+function normalizeMcpUpdateOptions(options) {
+  const normalizedInput = normalizeMcpOptionsArrays(options, "update-many");
+  for (const contract of UPDATE_COMMANDER_STRING_OPTION_CONTRACTS) {
+    for (const key of contract.keys) {
+      const value = normalizedInput[key];
+      if (typeof value === "number" && Number.isFinite(value)) {
+        normalizedInput[key] = String(value);
+      }
+    }
+  }
+  return normalizeUpdateOptions(normalizedInput);
+}
+function updateManyOptionsFromFlat(options) {
+  if (isRecord2(options.list) || isRecord2(options.update)) {
+    const updateSource = isRecord2(options.update) ? options.update : updateManyUpdateOptionsFromFlat(options);
+    return {
+      status: readScalarString(options, "filterStatus"),
+      list: isRecord2(options.list) ? normalizeListOptions(options.list) : mutationListOptions(options),
+      update: normalizeMcpUpdateOptions(updateSource),
+      dryRun: options.dryRun === true || options.dry_run === true ? true : void 0,
+      rollback: readString(options, "rollback"),
+      checkpoint: options.checkpoint === false || options.noCheckpoint === true || options.no_checkpoint === true ? false : void 0
+    };
+  }
+  return {
+    status: readScalarString(options, "filterStatus"),
+    list: mutationListOptions(options),
+    update: updateManyUpdateOptionsFromFlat(options),
+    dryRun: options.dryRun === true || options.dry_run === true ? true : void 0,
+    rollback: readString(options, "rollback"),
+    checkpoint: options.checkpoint === false || options.noCheckpoint === true || options.no_checkpoint === true ? false : void 0
+  };
+}
+var WORKSPACE_CONTRACTS_CACHE_PRESERVING_ACTIONS = /* @__PURE__ */ new Set([
+  "activity",
+  "aggregate",
+  "context",
+  "contracts",
+  "deps",
+  "files-discover",
+  "get",
+  "health",
+  "history",
+  "list",
+  "next",
+  "search",
+  "stats",
+  "telemetry",
+  "validate"
+]);
+var LIST_ACTION_ALIASES = {
+  "list-all": { action: "list", options: { excludeTerminal: false } },
+  "list-draft": { action: "list", options: { status: "draft", excludeTerminal: false } },
+  "list-open": { action: "list", options: { status: "open", excludeTerminal: false } },
+  "list-in-progress": { action: "list", options: { status: "in_progress", excludeTerminal: false } },
+  "list-blocked": { action: "list", options: { status: "blocked", excludeTerminal: false } },
+  "list-closed": { action: "list", options: { status: "closed", excludeTerminal: false } },
+  "list-canceled": { action: "list", options: { status: "canceled", excludeTerminal: false } }
+};
+var EXTENSION_ACTION_ALIASES = {
+  "extension-init": { action: "extension", options: { init: true } },
+  "extension-install": { action: "extension", options: { install: true } },
+  "extension-uninstall": { action: "extension", options: { uninstall: true } },
+  "extension-explore": { action: "extension", options: { explore: true } },
+  "extension-manage": { action: "extension", options: { manage: true } },
+  "extension-describe": { action: "extension", options: { describe: true } },
+  "extension-reload": { action: "extension", options: { reload: true } },
+  "extension-doctor": { action: "extension", options: { doctor: true } },
+  "extension-catalog": { action: "extension", options: { catalog: true } },
+  "extension-adopt": { action: "extension", options: { adopt: true } },
+  "extension-adopt-all": { action: "extension", options: { adoptAll: true } },
+  "extension-activate": { action: "extension", options: { activate: true } },
+  "extension-deactivate": { action: "extension", options: { deactivate: true } }
+};
+var PACKAGE_ACTION_ALIASES = {
+  "package-init": { action: "package", options: { init: true, vocabulary: "package" } },
+  "package-install": { action: "package", options: { install: true, vocabulary: "package" } },
+  "package-uninstall": { action: "package", options: { uninstall: true, vocabulary: "package" } },
+  "package-explore": { action: "package", options: { explore: true, vocabulary: "package" } },
+  "package-manage": { action: "package", options: { manage: true, vocabulary: "package" } },
+  "package-describe": { action: "package", options: { describe: true, vocabulary: "package" } },
+  "package-reload": { action: "package", options: { reload: true, vocabulary: "package" } },
+  "package-doctor": { action: "package", options: { doctor: true, vocabulary: "package" } },
+  "package-catalog": { action: "package", options: { catalog: true, vocabulary: "package" } },
+  "package-adopt": { action: "package", options: { adopt: true, vocabulary: "package" } },
+  "package-adopt-all": { action: "package", options: { adoptAll: true, vocabulary: "package" } },
+  "package-activate": { action: "package", options: { activate: true, vocabulary: "package" } },
+  "package-deactivate": { action: "package", options: { deactivate: true, vocabulary: "package" } }
+};
+var SDK_ACTION_ALIASES = {
+  ctx: { action: "context" },
+  ...LIST_ACTION_ALIASES,
+  ...EXTENSION_ACTION_ALIASES,
+  ...PACKAGE_ACTION_ALIASES
+};
+function resolveSdkActionInput(args) {
+  const rawAction = readRequiredString(args, "action");
+  const normalizedAction = normalizeActionName(rawAction);
+  const alias = getOwnHandler(SDK_ACTION_ALIASES, normalizedAction);
+  const action = alias?.action ?? normalizedAction;
+  const resolvedArgs = { ...args, action };
+  if (alias?.options !== void 0) {
+    resolvedArgs.options = { ...alias.options, ...asRecordClone(args.options) };
+  }
+  return { action, args: resolvedArgs };
+}
+function shouldInvalidateWorkspaceContractsCacheAfterAction(action) {
+  return !WORKSPACE_CONTRACTS_CACHE_PRESERVING_ACTIONS.has(normalizeActionName(action));
+}
+async function runAction(args) {
+  const resolved = resolveSdkActionInput(args);
+  const global = globalOptions(resolved.args);
+  const invalidateWorkspaceContractsCache = shouldInvalidateWorkspaceContractsCacheAfterAction(resolved.action);
+  const explicitCwd = readString(resolved.args, "cwd");
+  const resolutionCwd = explicitCwd ?? process.cwd();
+  try {
+    return await withActiveExtensions(global, explicitCwd, resolutionCwd, (activeExtensions) => dispatchAction(resolved.action, resolved.args, global, activeExtensions));
+  } finally {
+    if (invalidateWorkspaceContractsCache) {
+      clearWorkspaceContractsCache();
+    }
+  }
+}
+function getOwnHandler(handlers, key) {
+  return Object.prototype.hasOwnProperty.call(handlers, key) ? handlers[key] : void 0;
+}
+function readMcpTarget(ctx) {
+  return readString(ctx.args, "target") ?? readString(ctx.options, "target");
+}
+function requireMcpItemId(ctx, source = ctx.options) {
+  return ctx.id ?? readRequiredString(source, "id");
+}
+async function runMcpListAction(ctx) {
+  const listOptions = { ...ctx.options };
+  if (listOptions.compact === void 0 && listOptions.brief === void 0 && listOptions.fields === void 0 && listOptions.includeBody === void 0) {
+    listOptions.compact = true;
+  }
+  return withQuerySummary(await runList(readString(ctx.args, "status") ?? readString(listOptions, "status"), listOptions, ctx.global), listOptions);
+}
+async function runMcpSearchAction(ctx) {
+  const searchOptions = { ...ctx.options };
+  if (searchOptions.compact === void 0 && searchOptions.full === void 0 && searchOptions.fields === void 0) {
+    searchOptions.compact = true;
+  }
+  return withQuerySummary(await runSearch(readRequiredString(ctx.args, "query"), searchOptions, ctx.global), searchOptions);
+}
+async function runMcpCreateAction(ctx) {
+  const { changedFields, idOnly, runnerOptions } = withMutationCompaction(ctx.args, ctx.options);
+  return projectMutationResult(await runCreate(runnerOptions, ctx.global), { changedFields, idOnly });
+}
+async function runMcpCopyAction(ctx) {
+  const { changedFields, idOnly, runnerOptions } = withMutationCompaction(ctx.args, ctx.options);
+  const copyOptions = {
+    ...runnerOptions,
+    ...runnerOptions.title === void 0 && typeof ctx.args.title === "string" ? { title: ctx.args.title } : {},
+    ...runnerOptions.message === void 0 && typeof ctx.args.message === "string" ? { message: ctx.args.message } : {}
+  };
+  return projectMutationResult(await runCopy(requireMcpItemId(ctx, copyOptions), copyOptions, ctx.global), {
+    changedFields,
+    idOnly
+  });
+}
+async function runMcpUpdateAction(ctx) {
+  const { changedFields, idOnly, runnerOptions } = withMutationCompaction(ctx.args, ctx.options);
+  return projectMutationResult(await runUpdate(requireMcpItemId(ctx, runnerOptions), runnerOptions, ctx.global), {
+    changedFields,
+    idOnly
+  });
+}
+async function runMcpCloseAction(ctx) {
+  const { changedFields, idOnly, runnerOptions } = withMutationCompaction(ctx.args, ctx.options);
+  const closeReason = readString(ctx.args, "reason") ?? readString(ctx.args, "text") ?? readString(runnerOptions, "reason") ?? readString(runnerOptions, "text");
+  return projectMutationResult(await runClose(requireMcpItemId(ctx, runnerOptions), closeReason, runnerOptions, ctx.global), { changedFields, idOnly });
+}
+function runMcpCommentsAction(ctx) {
+  const commentOptions = { ...ctx.options };
+  const isListing = commentOptions.add === void 0 && commentOptions.stdin === void 0 && commentOptions.file === void 0 && commentOptions.edit === void 0 && commentOptions.delete === void 0;
+  if (isListing) {
+    commentOptions.includeMeta = true;
+    if (commentOptions.limit === void 0 && commentOptions.full !== true) {
+      commentOptions.limit = "20";
+    }
+  }
+  delete commentOptions.full;
+  return runComments(requireMcpItemId(ctx), commentOptions, ctx.global);
+}
+function runMcpFilesAction(ctx) {
+  const fileId = requireMcpItemId(ctx);
+  return ctx.options.discover === true ? runFilesDiscover(fileId, withFilesDiscoveryOptions(ctx.options), ctx.global) : runFiles(fileId, withAddNoteOption(ctx.options), ctx.global);
+}
+function runMcpTelemetryAction(ctx) {
+  return runTelemetry({
+    subcommand: readString(ctx.args, "subcommand") ?? readString(ctx.options, "subcommand"),
+    limit: resolveMcpTelemetryLimit(ctx.args, ctx.options)
+  }, ctx.global);
+}
+function resolveMcpTelemetryLimit(args, options) {
+  if (typeof args.limit === "number" && Number.isFinite(args.limit)) {
+    return args.limit;
+  }
+  if (typeof options.limit === "number" && Number.isFinite(options.limit)) {
+    return options.limit;
+  }
+  return readString(args, "limit") ?? readString(options, "limit");
+}
+function runMcpHealthAction(ctx) {
+  const healthOptions = { ...ctx.options };
+  if (healthOptions.brief === void 0 && healthOptions.summary === void 0 && healthOptions.full === void 0) {
+    healthOptions.summary = true;
+  }
+  return runHealth(ctx.global, healthOptions);
+}
+function runMcpConfigAction(ctx) {
+  const configAction = readString(ctx.args, "configAction") ?? readString(ctx.options, "configAction") ?? readString(ctx.options, "action");
+  if (configAction === void 0) {
+    throw new PmCliError("Missing required argument: configAction", 64);
+  }
+  return runConfig(readString(ctx.args, "scope") ?? readString(ctx.options, "scope") ?? "project", configAction, readString(ctx.args, "key") ?? readString(ctx.options, "key"), ctx.options, ctx.global, readString(ctx.args, "value") ?? readString(ctx.options, "value"));
+}
+function runMcpActivityAction(ctx) {
+  const activityOptions = { ...ctx.options };
+  if (activityOptions.compact === void 0) {
+    activityOptions.compact = activityOptions.full === true ? false : true;
+  }
+  delete activityOptions.full;
+  return runActivity(activityOptions, ctx.global);
+}
+function runMcpHistoryRepairAction(ctx) {
+  const repairAll = ctx.options.all === true;
+  const repairId = ctx.id ?? readString(ctx.options, "id");
+  assertHistoryRepairTarget(repairId, repairAll);
+  return repairAll ? runHistoryRepairAll(ctx.options, ctx.global) : runHistoryRepair(repairId, ctx.options, ctx.global);
+}
+function parseMcpInteger(value, label) {
+  if (typeof value === "number") {
+    if (!Number.isInteger(value)) {
+      throw new PmCliError(`${label} must be a finite integer.`, 64);
+    }
+    return value;
+  }
+  if (typeof value === "string" && value.trim().length > 0) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed)) {
+      throw new PmCliError(`${label} must be a finite integer.`, 64);
+    }
+    return parsed;
+  }
+  return void 0;
+}
+function parseMcpIntegerPrefix(value, label) {
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || !Number.isInteger(value)) {
+      throw new PmCliError(`${label} must be a finite integer.`, 64);
+    }
+    return value;
+  }
+  if (typeof value === "string" && value.trim().length > 0) {
+    const trimmed = value.trim();
+    if (!/^[+-]?\d+(?:st|nd|rd|th)?$/i.test(trimmed)) {
+      throw new PmCliError(`${label} must be a finite integer.`, 64);
+    }
+    const parsed = Number.parseInt(trimmed, 10);
+    if (!Number.isInteger(parsed)) {
+      throw new PmCliError(`${label} must be a finite integer.`, 64);
+    }
+    return parsed;
+  }
+  return void 0;
+}
+function runMcpPlanAction(ctx) {
+  const subcommand = readString(ctx.args, "subcommand") ?? readRequiredString(ctx.options, "subcommand");
+  const planRecord = ctx.options;
+  return runPlan({
+    subcommand,
+    id: typeof ctx.id === "string" ? ctx.id : typeof planRecord.id === "string" ? planRecord.id : void 0,
+    stepRef: readMcpPlanStepRef(ctx),
+    reorderTo: parseMcpIntegerPrefix(planRecord.reorderTo ?? ctx.args.reorderTo, "plan reorderTo"),
+    options: ctx.options,
+    global: ctx.global
+  });
+}
+function readMcpPlanStepRef(ctx) {
+  return typeof ctx.options.stepRef === "string" ? ctx.options.stepRef : typeof ctx.args.stepRef === "string" ? ctx.args.stepRef : void 0;
+}
+function createMcpSchemaContext(ctx) {
+  const subcommand = readString(ctx.args, "subcommand") ?? readRequiredString(ctx.options, "subcommand");
+  const aliasSource = ctx.args.alias ?? ctx.options.alias;
+  return {
+    ctx,
+    subcommand: subcommand.trim().toLowerCase(),
+    name: readString(ctx.args, "name") ?? readString(ctx.options, "name"),
+    author: readString(ctx.args, "author") ?? readString(ctx.options, "author"),
+    force: ctx.args.force === true || ctx.options.force === true,
+    aliases: aliasSource === void 0 ? void 0 : readStringArray(aliasSource)
+  };
+}
+function runMcpSchemaReadOrRemoveAction(schema) {
+  const { ctx, subcommand, name, author, force } = schema;
+  const simpleHandlers = {
+    list: () => runSchemaList(ctx.global),
+    show: () => runSchemaShow(name, ctx.global),
+    "show-status": () => runSchemaShowStatus(name, ctx.global),
+    "list-fields": () => runSchemaListFields(ctx.global),
+    "show-field": () => runSchemaShowField(name, ctx.global),
+    "remove-type": () => runSchemaRemoveType(name, { author, force }, ctx.global),
+    "remove-field": () => runSchemaRemoveField(name, { author, force }, ctx.global),
+    "remove-status": () => runSchemaRemoveStatus(name, { author, force }, ctx.global),
+    "apply-preset": () => runSchemaApplyPreset(readString(ctx.args, "typePreset") ?? readString(ctx.options, "typePreset"), { author, force }, ctx.global)
+  };
+  const handler = getOwnHandler(simpleHandlers, subcommand);
+  return handler ? handler() : null;
+}
+function runMcpSchemaAddFieldAction(schema) {
+  const { ctx, name, author, force, aliases } = schema;
+  const commandsSource = ctx.args.commands ?? ctx.options.commands;
+  const requiredTypesSource = ctx.args.requiredTypes ?? ctx.options.requiredTypes;
+  return runSchemaAddField(name, {
+    type: readString(ctx.args, "fieldType") ?? readString(ctx.options, "fieldType"),
+    commands: commandsSource === void 0 ? void 0 : readStringArray(commandsSource),
+    description: readString(ctx.args, "description") ?? readString(ctx.options, "description"),
+    cliFlag: readString(ctx.args, "cliFlag") ?? readString(ctx.options, "cliFlag"),
+    alias: aliases,
+    required: ctx.args.required === true || ctx.options.required === true,
+    requiredOnCreate: ctx.args.requiredOnCreate === true || ctx.options.requiredOnCreate === true,
+    allowUnset: !(ctx.args.allowUnset === false || ctx.options.allowUnset === false),
+    requiredTypes: requiredTypesSource === void 0 ? void 0 : readStringArray(requiredTypesSource),
+    author,
+    force
+  }, ctx.global);
+}
+function runMcpSchemaAddStatusAction(schema) {
+  const { ctx, name, author, force, aliases } = schema;
+  const roleSource = ctx.args.role ?? ctx.options.role;
+  return runSchemaAddStatus(name, {
+    role: roleSource === void 0 ? void 0 : readStringArray(roleSource),
+    alias: aliases,
+    description: readString(ctx.args, "description") ?? readString(ctx.options, "description"),
+    order: parseMcpInteger(ctx.args.order ?? ctx.options.order, "schema add-status order"),
+    author,
+    force
+  }, ctx.global);
+}
+function runMcpSchemaAddTypeAction(schema) {
+  const { ctx, name, author, force, aliases } = schema;
+  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"),
+    folder: readString(ctx.args, "folder") ?? readString(ctx.options, "folder"),
+    alias: aliases,
+    author,
+    force
+  }, ctx.global);
+}
+function runMcpSchemaAction(ctx) {
+  const schema = createMcpSchemaContext(ctx);
+  const simpleResult = runMcpSchemaReadOrRemoveAction(schema);
+  if (simpleResult !== null) {
+    return simpleResult;
+  }
+  if (schema.subcommand === "add-field") {
+    return runMcpSchemaAddFieldAction(schema);
+  }
+  if (schema.subcommand === "add-status") {
+    return runMcpSchemaAddStatusAction(schema);
+  }
+  if (schema.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
+      }, ctx.global);
+    }
+    return runMcpSchemaAddTypeAction(schema);
+  }
+  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);
+}
+function runMcpProfileAction(ctx) {
+  const subcommand = readString(ctx.args, "subcommand") ?? readRequiredString(ctx.options, "subcommand");
+  const normalizedSubcommand = subcommand.trim().toLowerCase();
+  const profileName = readString(ctx.args, "name") ?? readString(ctx.options, "name");
+  const handlers = {
+    list: () => runProfileList(),
+    show: () => runProfileShow(profileName),
+    lint: () => runProfileLint(profileName),
+    apply: () => runProfileApply(profileName, {
+      dryRun: ctx.args.dryRun === true || ctx.options.dryRun === true,
+      author: readString(ctx.args, "author") ?? readString(ctx.options, "author"),
+      force: ctx.args.force === true || ctx.options.force === true
+    }, ctx.global)
+  };
+  const handler = getOwnHandler(handlers, normalizedSubcommand);
+  if (!handler) {
+    throw new PmCliError(`Unknown pm profile subcommand "${subcommand}". Allowed: list, show, apply, lint`, 64);
+  }
+  return handler();
+}
+function runMcpStatsAction(ctx) {
+  return runStats(ctx.global, {
+    storage: ctx.options.storage === true,
+    metadataCoverage: ctx.options.metadataCoverage === true,
+    fieldUtilization: ctx.options.fieldUtilization === true,
+    byAssignee: ctx.options.byAssignee === true,
+    byTag: ctx.options.byTag === true,
+    byPriority: ctx.options.byPriority === true,
+    tagPrefix: typeof ctx.options.tagPrefix === "string" ? ctx.options.tagPrefix : void 0
+  });
+}
+async function runMcpAppendAction(ctx) {
+  const { changedFields, runnerOptions } = withMutationCompaction(ctx.args, ctx.options);
+  return projectMutationResult(await runAppend(requireMcpItemId(ctx, runnerOptions), runnerOptions, ctx.global), {
+    changedFields
+  });
+}
+async function runMcpUpdateManyAction(ctx) {
+  const { changedFields, runnerOptions } = withMutationCompaction(ctx.args, ctx.options);
+  return projectMutationResult(await runUpdateMany(updateManyOptionsFromFlat(runnerOptions), ctx.global), { changedFields });
+}
+async function runMcpCloseManyAction(ctx) {
+  const { changedFields, runnerOptions } = withMutationCompaction(ctx.args, ctx.options);
+  const topLevelReason = readString(ctx.args, "reason");
+  const closeManyRunnerOptions = topLevelReason !== void 0 && runnerOptions.reason === void 0 ? { ...runnerOptions, reason: topLevelReason } : { ...runnerOptions };
+  if (ctx.force && closeManyRunnerOptions.force === void 0) {
+    closeManyRunnerOptions.force = true;
+  }
+  return projectMutationResult(await runCloseMany(closeManyOptionsFromFlat(closeManyRunnerOptions), ctx.global), { changedFields });
+}
+async function runMcpRestoreAction(ctx) {
+  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);
+  const settings = await readSettings(pmRoot);
+  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, { ...withoutLifecycleAssigneeAlias(ctx.options), status: inProgressStatus, force: ctx.force }, ctx.global);
+  return { id, action: "start_task", claim: claimResult, update: updateResult };
+}
+async function runMcpPauseTaskAction(ctx) {
+  const pmRoot = resolvePmRoot(process.cwd(), ctx.global.path);
+  const settings = await readSettings(pmRoot);
+  const id = requireMcpItemId(ctx);
+  const openStatus = resolveRuntimeStatusRegistry(settings.schema).open_status;
+  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 };
+}
+async function runMcpCloseTaskAction(ctx) {
+  const id = requireMcpItemId(ctx);
+  const closeReason = readString(ctx.args, "reason") ?? readString(ctx.args, "text") ?? readString(ctx.options, "reason") ?? readString(ctx.options, "text");
+  const closeResult = await runClose(id, closeReason, { ...ctx.options, force: ctx.force }, ctx.global);
+  const releaseResult = await runRelease(id, ctx.force, ctx.global, ctx.options);
+  return { id, action: "close_task", close: closeResult, release: releaseResult };
+}
+var SDK_ACTION_HANDLERS = {
+  init: (ctx) => runInit(readString(ctx.args, "prefix"), ctx.global, ctx.options),
+  context: (ctx) => runContext(ctx.options, ctx.global),
+  next: (ctx) => runNext(ctx.options, ctx.global),
+  list: runMcpListAction,
+  get: (ctx) => runGet(requireMcpItemId(ctx), ctx.global, ctx.options),
+  search: runMcpSearchAction,
+  create: runMcpCreateAction,
+  copy: runMcpCopyAction,
+  focus: (ctx) => runFocus(ctx.id, { clear: ctx.options.clear === true || ctx.args.clear === true }, ctx.global),
+  update: runMcpUpdateAction,
+  restore: runMcpRestoreAction,
+  claim: (ctx) => runClaim(requireMcpItemId(ctx), ctx.force, ctx.global, ctx.options),
+  release: (ctx) => runRelease(requireMcpItemId(ctx), ctx.force, ctx.global, ctx.options),
+  "start-task": runMcpStartTaskAction,
+  "pause-task": runMcpPauseTaskAction,
+  "close-task": runMcpCloseTaskAction,
+  close: runMcpCloseAction,
+  comments: runMcpCommentsAction,
+  notes: (ctx) => runNotes(requireMcpItemId(ctx), ctx.options, ctx.global),
+  learnings: (ctx) => runLearnings(requireMcpItemId(ctx), ctx.options, ctx.global),
+  files: runMcpFilesAction,
+  docs: (ctx) => runDocs(requireMcpItemId(ctx), withAddNoteOption(ctx.options), ctx.global),
+  test: (ctx) => runTest(requireMcpItemId(ctx), ctx.options, ctx.global),
+  "test-all": (ctx) => runTestAll(ctx.options, ctx.global),
+  telemetry: runMcpTelemetryAction,
+  validate: (ctx) => runValidate(ctx.options, ctx.global),
+  health: runMcpHealthAction,
+  contracts: (ctx) => runContracts(ctx.options, ctx.global),
+  config: runMcpConfigAction,
+  activity: runMcpActivityAction,
+  aggregate: (ctx) => runAggregate(ctx.options, ctx.global),
+  extension: (ctx) => runExtension(readMcpTarget(ctx), ctx.options, ctx.global),
+  package: (ctx) => runExtension(readMcpTarget(ctx), ctx.options, ctx.global),
+  install: (ctx) => runExtension(readMcpTarget(ctx), { ...ctx.options, install: true }, ctx.global),
+  upgrade: (ctx) => runUpgrade(readMcpTarget(ctx), ctx.options, ctx.global),
+  delete: (ctx) => runDelete(requireMcpItemId(ctx), ctx.options, ctx.global),
+  deps: (ctx) => runDeps(requireMcpItemId(ctx), ctx.options, ctx.global),
+  "files-discover": (ctx) => runFilesDiscover(requireMcpItemId(ctx), ctx.options, ctx.global),
+  history: (ctx) => runHistory(requireMcpItemId(ctx), ctx.options, ctx.global),
+  "history-redact": (ctx) => runHistoryRedact(requireMcpItemId(ctx), ctx.options, ctx.global),
+  "history-repair": runMcpHistoryRepairAction,
+  "history-compact": (ctx) => runHistoryCompact(requireMcpItemId(ctx), ctx.options, ctx.global),
+  plan: runMcpPlanAction,
+  schema: runMcpSchemaAction,
+  profile: runMcpProfileAction,
+  stats: runMcpStatsAction,
+  append: runMcpAppendAction,
+  "update-many": runMcpUpdateManyAction,
+  "close-many": runMcpCloseManyAction,
+  gc: (ctx) => runGc(ctx.global, ctx.options)
+};
+async function dispatchAction(action, args, global, activeExtensions) {
+  const options = optionsWithAuthor(args, action);
+  const ctx = {
+    action,
+    args,
+    options,
+    id: readString(args, "id"),
+    force: args.force === true || options.force === true,
+    global,
+    activeExtensions
+  };
+  const handler = getOwnHandler(SDK_ACTION_HANDLERS, action);
+  return handler ? handler(ctx) : dispatchActiveExtensionAction(action, args, options, global, activeExtensions);
+}
+var actionRunnerTestHooks = {
+  closeManyOptionsFromFlat,
+  extensionOptionsFromArgs,
+  globalOptions,
+  mutationListOptions,
+  normalizeActionName,
+  normalizeCommandPath,
+  normalizeMcpUpdateOptions,
+  normalizeMcpOptionsArrays,
+  optionsWithAuthor,
+  readRequiredString,
+  readScalarString,
+  readScalarStringAllowBlank,
+  readStringArray,
+  updateManyOptionsFromFlat,
+  withAddNoteOption,
+  withFilesDiscoveryOptions,
+  withMutationCompaction
+};
+if (process.env.NODE_ENV === "test" || process.env.VITEST !== void 0 || process.env.VITEST_WORKER_ID !== void 0) {
+  globalThis.__pmCliActionRunnerTestHooks = actionRunnerTestHooks;
+}
 async function loadWorkspaceExtensionRegistrations(pmRoot, settings, cwd) {
   const loadResult = await loadExtensions({
     pmRoot,
@@ -5306,10 +6638,18 @@ async function loadWorkspaceExtensionRegistrations(pmRoot, settings, cwd) {
     noExtensions: false
   });
   const activationResult = await activateExtensions(loadResult);
-  return activationResult.registrations;
+  try {
+    return activationResult.registrations;
+  } finally {
+    try {
+      await deactivateExtensions(loadResult, activationResult);
+    } catch {
+    }
+  }
 }
 
 export {
+  clearWorkspaceContractsCache,
   readStringOption,
   readBooleanOption,
   readCsvListOption,
@@ -5345,10 +6685,31 @@ export {
   runDedupeMerge,
   runNormalize,
   runReindex,
-  clearWorkspaceContractsCache,
+  PmClient,
+  context,
+  list,
+  search,
+  get,
+  next,
+  aggregate,
+  stats,
+  create,
+  update,
+  close,
+  claim,
+  release,
+  copy,
+  deleteItem,
+  restore,
+  focus,
+  startTask,
+  pauseTask,
+  closeTask,
   getWorkspaceContracts,
-  getContracts
+  getContracts,
+  readRequiredString,
+  runAction
 };
-//# sourceMappingURL=chunk-T5Y3QSNF.js.map
+//# sourceMappingURL=chunk-MHNMCDWR.js.map
 
-//# debugId=c6d1c49f-01ed-5fa4-b05d-e515ef54f671
+//# debugId=8e64eac6-c632-5921-b8ce-74dd117c9670