@unbrained/pm-cli 2026.7.8 → 2026.7.10

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

@@ -1,20 +1,20 @@
 
-!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){}}();
+!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]="fba5a2fc-abf5-5621-9076-1b97983ccc95")}catch(e){}}();
 import {
   runFiles,
   runFilesDiscover
-} from "./chunk-JYVPLGOW.js";
+} from "./chunk-FWL5XVYI.js";
 import {
   runDocs
-} from "./chunk-UFNFHCAC.js";
+} from "./chunk-SWQMU4AD.js";
 import {
   runDeps
-} from "./chunk-LD2NBQ5T.js";
+} from "./chunk-BST7GFIX.js";
 import {
   assertHistoryRepairTarget,
   runHistoryRepair,
   runHistoryRepairAll
-} from "./chunk-SIQGG335.js";
+} from "./chunk-GMNCW27N.js";
 import {
   resolveStartTaskInProgressStatus,
   runClaim,
@@ -27,67 +27,67 @@ import {
   runTest,
   runTestAll,
   runValidate
-} from "./chunk-KMXVZ2P7.js";
+} from "./chunk-FYMHD6VX.js";
 import {
   runComments
-} from "./chunk-LG4N6YOK.js";
+} from "./chunk-ESXG6VFX.js";
 import {
   runCopy
-} from "./chunk-SCJPFQQT.js";
+} from "./chunk-DN67YDFH.js";
 import {
   runFocus
-} from "./chunk-NRMDT4OV.js";
+} from "./chunk-3THCOPYI.js";
 import {
   runDelete
-} from "./chunk-6ZKDMEVT.js";
+} from "./chunk-ECXJ7OHI.js";
 import {
   runAppend
-} from "./chunk-RL24NAUX.js";
+} from "./chunk-B7FCPO65.js";
 import {
   runProfileApply,
   runProfileLint,
   runProfileList,
   runProfileShow
-} from "./chunk-GQOKFX2G.js";
+} from "./chunk-6WIP52LQ.js";
 import {
   runNotes
-} from "./chunk-HZZ3AC27.js";
+} from "./chunk-PFRGQZG2.js";
 import {
   runLearnings
-} from "./chunk-F5DDGY6R.js";
+} from "./chunk-XWS3Z57Q.js";
 import {
   runCloseMany
-} from "./chunk-IYRG5AEC.js";
+} from "./chunk-N7N3PUUP.js";
 import {
   runUpdateMany
-} from "./chunk-YR5R4FMQ.js";
+} from "./chunk-RYA7QE7B.js";
 import {
   runRestore
-} from "./chunk-PAWPLIWW.js";
+} from "./chunk-7THLDY3D.js";
 import {
   runUpdate
-} from "./chunk-UCRYCT5M.js";
+} from "./chunk-5BFBDJ4R.js";
 import {
   runClose
-} from "./chunk-UVFJSKTF.js";
+} from "./chunk-M7DWRMNY.js";
 import {
   runPlan
-} from "./chunk-YUCKM3MD.js";
+} from "./chunk-JQ5NB6O2.js";
 import {
   runHistoryCompact
-} from "./chunk-4OCWJ2AP.js";
+} from "./chunk-BC7QBM2A.js";
 import {
   runHistoryRedact
-} from "./chunk-JH5XDDYS.js";
+} from "./chunk-TM5E2IED.js";
 import {
   runConfig,
   runUpgrade
-} from "./chunk-D63PEJTB.js";
+} from "./chunk-4P2GYOM5.js";
 import {
   SCAFFOLD_CAPABILITIES,
   runExtension,
   runInit
-} from "./chunk-GE44TQMC.js";
+} from "./chunk-CUBPPDDF.js";
 import {
   runSchemaAddField,
   runSchemaAddStatus,
@@ -102,7 +102,7 @@ import {
   runSchemaShow,
   runSchemaShowField,
   runSchemaShowStatus
-} from "./chunk-FOJEBRDD.js";
+} from "./chunk-P7PDLLCE.js";
 import {
   jaccardSimilarity,
   normalizeLowercaseWhitespace,
@@ -113,17 +113,17 @@ import {
   runNext,
   runSearch,
   tokenizeAlphaNumeric
-} from "./chunk-HI27UADG.js";
+} from "./chunk-JDEXIVKQ.js";
 import {
   buildListQueryFilters,
   runList
-} from "./chunk-XN5BEN2B.js";
+} from "./chunk-6PBZBIS6.js";
 import {
   runHistory
-} from "./chunk-6WCXSC5V.js";
+} from "./chunk-ZGDJA6WI.js";
 import {
   parseIntegerLimit
-} from "./chunk-6RR4XM5H.js";
+} from "./chunk-UYK26VRP.js";
 import {
   resolveRegisteredSearchProvider,
   resolveRegisteredVectorStoreAdapter
@@ -150,7 +150,7 @@ import {
   resolveSettingsWithSemanticRuntimeDefaults,
   resolveVectorStores,
   writeVectorizationStatusLedger
-} from "./chunk-G4FKP4ID.js";
+} from "./chunk-DWGHHSDC.js";
 import {
   ACTIVITY_FLAG_CONTRACTS,
   AGGREGATE_FLAG_CONTRACTS,
@@ -183,19 +183,19 @@ import {
   UPDATE_FLAG_CONTRACTS,
   UPDATE_MANY_FLAG_CONTRACTS,
   toCompletionFlagString
-} from "./chunk-ML27MHNM.js";
+} from "./chunk-2RW5DWHQ.js";
 import {
   runCreate
-} from "./chunk-TUDAYIO7.js";
+} from "./chunk-NQTIOKHL.js";
 import {
   parseTags
-} from "./chunk-3SHDAKMF.js";
+} from "./chunk-GPPWUJMR.js";
 import {
   splitCommaList
 } from "./chunk-P4SESZGT.js";
 import {
   projectMutationResult
-} from "./chunk-U72GF3I2.js";
+} from "./chunk-INAZHXOI.js";
 import {
   PmCliError,
   acquireLock,
@@ -203,6 +203,7 @@ import {
   collectRegisteredItemFieldNames,
   compareTimestampStrings,
   createHistoryEntry,
+  createSerialQueue,
   getActiveExtensionRegistrations,
   isTerminalStatus,
   listAllDocumentCandidatesCached,
@@ -224,7 +225,7 @@ import {
   setActiveExtensionRenderers,
   setActiveExtensionServices,
   toItemRecord
-} from "./chunk-NTOOEVJ4.js";
+} from "./chunk-Y5Q4FEE4.js";
 import {
   BUILTIN_ITEM_TYPE_VALUES,
   EXIT_CODE,
@@ -251,7 +252,7 @@ import {
   toErrorMessage,
   toNonEmptyStringOrUndefined,
   writeFileAtomic
-} from "./chunk-MFLLULHU.js";
+} from "./chunk-TB2CZJAQ.js";
 
 // dist/sdk/runtime.js
 import path3 from "node:path";
@@ -287,36 +288,6 @@ function withQuerySummary(result, options) {
   };
 }
 
-// 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();
@@ -1123,11 +1094,11 @@ function toExcerpt(content, maxLines, maxCharacters) {
 async function renderGuideDocs(topic, depth, packageRoot) {
   const includeContent = depth !== "brief";
   const contentMode = includeContent ? depth === "deep" ? "full" : "excerpt" : "none";
-  const docs = [];
+  const docs2 = [];
   for (const doc of topic.docs) {
     const absolutePath = path.resolve(packageRoot, doc.path);
     if (!includeContent) {
-      docs.push({
+      docs2.push({
         path: doc.path,
         purpose: doc.purpose,
         optional: doc.optional === true,
@@ -1143,7 +1114,7 @@ async function renderGuideDocs(topic, depth, packageRoot) {
       const rawContent = await readFile(absolutePath, "utf8");
       if (depth === "deep") {
         const normalized = normalizeLineEndings(rawContent).trimEnd();
-        docs.push({
+        docs2.push({
           path: doc.path,
           purpose: doc.purpose,
           optional: doc.optional === true,
@@ -1155,7 +1126,7 @@ async function renderGuideDocs(topic, depth, packageRoot) {
         });
       } else {
         const excerpt = toExcerpt(rawContent, 120, 12e3);
-        docs.push({
+        docs2.push({
           path: doc.path,
           purpose: doc.purpose,
           optional: doc.optional === true,
@@ -1169,7 +1140,7 @@ async function renderGuideDocs(topic, depth, packageRoot) {
     } catch (error) {
       const code = error?.code;
       const missing = code === "ENOENT";
-      docs.push({
+      docs2.push({
         path: doc.path,
         purpose: doc.purpose,
         optional: doc.optional === true,
@@ -1184,7 +1155,7 @@ async function renderGuideDocs(topic, depth, packageRoot) {
       }
     }
   }
-  return docs;
+  return docs2;
 }
 function buildGuideIndex(depth) {
   const topics = listGuideTopics().map((topic) => ({
@@ -1227,15 +1198,15 @@ async function runGuide(options, global) {
   }
   const topic = ensureGuideTopic(topicRaw);
   const packageRoot = resolvePackageRoot();
-  const docs = await renderGuideDocs(topic, depth, packageRoot);
-  const warnings = docs.filter((doc) => !doc.exists && !doc.optional).map((doc) => `Missing required guide document: ${doc.path}`);
+  const docs2 = await renderGuideDocs(topic, depth, packageRoot);
+  const warnings = docs2.filter((doc) => !doc.exists && !doc.optional).map((doc) => `Missing required guide document: ${doc.path}`);
   return {
     output_default: "toon",
     mode: "topic",
     depth,
     requested_topic: topicRaw,
     topic,
-    docs,
+    docs: docs2,
     warnings
   };
 }
@@ -1994,6 +1965,8 @@ _pm() {
             '--priority[Filter by priority]:(0 1 2 3 4)' \\
             '--deadline-before[Filter by deadline upper bound (ISO/date string or relative)]:date' \\
             '--deadline-after[Filter by deadline lower bound (ISO/date string or relative)]:date' \\
+            '--today[Filter to items updated since local midnight today]' \\
+            '--recent[Filter to items updated in the last 7 days]' \\
             '--updated-after[Filter by updated_at lower bound (ISO/relative)]:timestamp' \\
             '--updated-before[Filter by updated_at upper bound (ISO/relative)]:timestamp' \\
             '--created-after[Filter by created_at lower bound (ISO/relative)]:timestamp' \\
@@ -2496,6 +2469,7 @@ ${zshSearchRuntimeFieldFlags}            '--json[Output JSON]' \\
           _arguments \\
             '--action[Filter schema by tool action]:action' \\
             '--command[Scope output to one command (narrow-by-default)]:command' \\
+            '--summary[Return compact command intent summary]' \\
             '--schema-only[Return schema-only payload]' \\
             '--flags-only[Return command flag contracts only]' \\
             '--availability-only[Return action availability only]' \\
@@ -2971,6 +2945,8 @@ for list_cmd in ${listCmds}
   complete -c pm -n "__fish_seen_subcommand_from $list_cmd" -l stream -d 'Emit line-delimited JSON rows (requires --json)'
   complete -c pm -n "__fish_seen_subcommand_from $list_cmd" -l deadline-before -d 'Filter by deadline upper bound (ISO/date string or relative)' -r
   complete -c pm -n "__fish_seen_subcommand_from $list_cmd" -l deadline-after  -d 'Filter by deadline lower bound (ISO/date string or relative)' -r
+  complete -c pm -n "__fish_seen_subcommand_from $list_cmd" -l today -d 'Filter to items updated since local midnight today'
+  complete -c pm -n "__fish_seen_subcommand_from $list_cmd" -l recent -d 'Filter to items updated in the last 7 days'
   complete -c pm -n "__fish_seen_subcommand_from $list_cmd" -l updated-after  -d 'Filter by updated_at lower bound (ISO/relative)' -r
   complete -c pm -n "__fish_seen_subcommand_from $list_cmd" -l updated-before -d 'Filter by updated_at upper bound (ISO/relative)' -r
   complete -c pm -n "__fish_seen_subcommand_from $list_cmd" -l created-after  -d 'Filter by created_at lower bound (ISO/relative)' -r
@@ -3465,6 +3441,7 @@ complete -c pm -n '__fish_seen_subcommand_from activity' -l full -d 'Show full a
 complete -c pm -n '__fish_seen_subcommand_from activity' -l stream -d 'Emit line-delimited JSON rows'
 complete -c pm -n '__fish_seen_subcommand_from contracts' -l action -d 'Filter schema by tool action' -r
 complete -c pm -n '__fish_seen_subcommand_from contracts' -l command -d 'Scope output to one command (narrow-by-default)' -r
+complete -c pm -n '__fish_seen_subcommand_from contracts' -l summary -d 'Return compact command intent summary'
 complete -c pm -n '__fish_seen_subcommand_from contracts' -l schema-only -d 'Return schema-only payload'
 complete -c pm -n '__fish_seen_subcommand_from contracts' -l flags-only -d 'Return command flag contracts only'
 complete -c pm -n '__fish_seen_subcommand_from contracts' -l availability-only -d 'Return action availability only'
@@ -3948,7 +3925,7 @@ function resolveCommentsAuditLimits(options) {
   };
 }
 function toCommentsAuditEntry(item, latest) {
-  const comments = item.comments ?? [];
+  const comments2 = item.comments ?? [];
   return {
     id: item.id,
     title: item.title,
@@ -3956,8 +3933,8 @@ function toCommentsAuditEntry(item, latest) {
     status: item.status,
     assignee: item.assignee ?? null,
     updated_at: item.updated_at,
-    comment_count: comments.length,
-    comments: latest === void 0 ? comments : limitComments(comments, latest)
+    comment_count: comments2.length,
+    comments: latest === void 0 ? comments2 : limitComments(comments2, latest)
   };
 }
 function buildCommentsAuditFilters(options, status, limitItems, latest, fullHistory) {
@@ -4820,15 +4797,15 @@ function parseMode2(raw) {
   }
   throw new PmCliError("Reindex mode must be one of keyword|semantic|hybrid", EXIT_CODE.USAGE);
 }
-async function loadDocumentCandidates(pmRoot, itemFormat, typeToFolder, schema) {
+async function loadDocumentCandidates(pmRoot, itemFormat, typeToFolder, schema2) {
   const warnings = [];
-  const candidates = await listAllDocumentCandidatesCached(pmRoot, itemFormat, typeToFolder, warnings, schema);
+  const candidates = await listAllDocumentCandidatesCached(pmRoot, itemFormat, typeToFolder, warnings, schema2);
   return {
     candidates,
     warnings
   };
 }
-async function hydrateDocuments(pmRoot, candidates, schema, warnings, itemIds) {
+async function hydrateDocuments(pmRoot, candidates, schema2, warnings, itemIds) {
   const extensionFieldNames = collectRegisteredItemFieldNames(getActiveExtensionRegistrations());
   const hydrated = [];
   for (const candidate of candidates) {
@@ -4846,7 +4823,7 @@ async function hydrateDocuments(pmRoot, candidates, schema, warnings, itemIds) {
       const raw = await fs.readFile(candidate.item_path, "utf8");
       const parsed = parseItemDocument(raw, {
         format: candidate.item_format,
-        schema,
+        schema: schema2,
         extensionFieldNames,
         onWarning: (warning) => warnings.push(warning)
       });
@@ -5458,13 +5435,8 @@ async function runReindex(options, global) {
 }
 
 // dist/sdk/runtime.js
-function splitClientMutationOptions(options) {
-  const { fullChangedFields, idOnly, ...runnerOptions } = options;
-  return {
-    ...fullChangedFields === void 0 ? {} : { fullChangedFields },
-    ...idOnly === void 0 ? {} : { idOnly },
-    options: runnerOptions
-  };
+function splitFullClientMutationOptions(options) {
+  return { fullChangedFields: true, options };
 }
 var PmClient = class {
   defaults;
@@ -5530,83 +5502,279 @@ var PmClient = class {
   stats(options = {}) {
     return this.runTyped("stats", { options });
   }
+  /**
+   * List, add, edit, or delete item comments.
+   */
+  comments(id, options = {}) {
+    return this.runTyped("comments", { id, options });
+  }
+  /**
+   * List or append private item notes.
+   */
+  notes(id, options = {}) {
+    return this.runTyped("notes", { id, options });
+  }
+  /**
+   * List or append durable item learnings.
+   */
+  learnings(id, options = {}) {
+    return this.runTyped("learnings", { id, options });
+  }
+  /**
+   * Add, remove, clear, or list linked project files for an item.
+   */
+  files(id, options = {}) {
+    return this.runTyped("files", { id, options });
+  }
+  /**
+   * Discover and optionally attach changed files for an item.
+   */
+  filesDiscover(id, options = {}) {
+    return this.runTyped("files-discover", { id, options });
+  }
+  /**
+   * Add, remove, clear, or list linked documentation for an item.
+   */
+  docs(id, options = {}) {
+    return this.runTyped("docs", { id, options });
+  }
+  /**
+   * Inspect item dependency relationships.
+   */
+  deps(id, options = {}) {
+    return this.runTyped("deps", { id, options });
+  }
+  /**
+   * Append markdown/body text to an item through the mutation pipeline.
+   */
+  append(id, body, options = {}) {
+    return this.runTyped("append", { id, ...splitFullClientMutationOptions({ ...options, body }) });
+  }
+  /**
+   * Initialize a workspace with the same semantics as `pm init`.
+   */
+  init(prefix, options = {}) {
+    return this.runTyped("init", { ...prefix === void 0 ? {} : { prefix }, options });
+  }
+  /**
+   * Read or update project/global configuration.
+   */
+  config(scope, configAction, key, value, options = {}) {
+    return this.runTyped("config", {
+      scope,
+      configAction,
+      ...key === void 0 ? {} : { key },
+      ...value === void 0 ? {} : { value },
+      options
+    });
+  }
+  /**
+   * Run the schema customization surface.
+   */
+  schema(subcommand, options = {}) {
+    return this.runTyped("schema", { options: { ...options, subcommand } });
+  }
+  /**
+   * List built-in, custom, and extension-provided schema types/statuses.
+   */
+  schemaList() {
+    return this.runTyped("schema", { options: { subcommand: "list" } });
+  }
+  /**
+   * Show a schema item type definition.
+   */
+  schemaShow(name) {
+    return this.runTyped("schema", { name, options: { subcommand: "show" } });
+  }
+  /**
+   * Register or replace a custom item type.
+   */
+  schemaAddType(name, options = {}) {
+    return this.runTyped("schema", { name, options: { ...options, subcommand: "add-type" } });
+  }
+  /**
+   * Remove a custom item type.
+   */
+  schemaRemoveType(name, options = {}) {
+    return this.runTyped("schema", { name, options: { ...options, subcommand: "remove-type" } });
+  }
+  /**
+   * Register or replace a custom status.
+   */
+  schemaAddStatus(name, options = {}) {
+    return this.runTyped("schema", { name, options: { ...options, subcommand: "add-status" } });
+  }
+  /**
+   * Remove a custom status.
+   */
+  schemaRemoveStatus(name, options = {}) {
+    return this.runTyped("schema", { name, options: { ...options, subcommand: "remove-status" } });
+  }
+  /**
+   * Register or replace a runtime custom field.
+   */
+  schemaAddField(name, options = {}) {
+    return this.runTyped("schema", { name, options: { ...options, subcommand: "add-field" } });
+  }
+  /**
+   * Remove a runtime custom field.
+   */
+  schemaRemoveField(name, options = {}) {
+    return this.runTyped("schema", { name, options: { ...options, subcommand: "remove-field" } });
+  }
+  /**
+   * List runtime custom fields.
+   */
+  schemaListFields() {
+    return this.runTyped("schema", { options: { subcommand: "list-fields" } });
+  }
+  /**
+   * Show one runtime custom field definition.
+   */
+  schemaShowField(name) {
+    return this.runTyped("schema", { name, options: { subcommand: "show-field" } });
+  }
+  /**
+   * Apply a built-in type preset to the workspace schema.
+   */
+  schemaApplyPreset(typePreset, options = {}) {
+    return this.runTyped("schema", { typePreset, options: { ...options, subcommand: "apply-preset" } });
+  }
+  /**
+   * Infer item types from the current tracker and optionally apply them.
+   */
+  schemaInferTypes(options = {}) {
+    return this.runTyped("schema", { options: { ...options, subcommand: "add-type", infer: true } });
+  }
+  /**
+   * Show one runtime status definition.
+   */
+  schemaShowStatus(name) {
+    return this.runTyped("schema", { name, options: { subcommand: "show-status" } });
+  }
+  /**
+   * Run the profile customization surface.
+   */
+  profile(subcommand, options = {}) {
+    return this.runTyped("profile", { options: { ...options, subcommand } });
+  }
+  /**
+   * List available project profiles.
+   */
+  profileList() {
+    return this.runTyped("profile", { options: { subcommand: "list" } });
+  }
+  /**
+   * Show a project profile.
+   */
+  profileShow(name) {
+    return this.runTyped("profile", { name, options: { subcommand: "show" } });
+  }
+  /**
+   * Apply a project profile.
+   */
+  profileApply(name, options = {}) {
+    return this.runTyped("profile", { name, options: { ...options, subcommand: "apply" } });
+  }
+  /**
+   * Lint a project profile.
+   */
+  profileLint(name) {
+    return this.runTyped("profile", { name, options: { subcommand: "lint" } });
+  }
+  /**
+   * Run project validation checks.
+   */
+  validate(options = {}) {
+    return this.runTyped("validate", { options });
+  }
+  /**
+   * Run project health checks.
+   */
+  health(options = {}) {
+    return this.runTyped("health", { options });
+  }
+  /**
+   * Run tracker cache/runtime garbage collection.
+   */
+  gc(options = {}) {
+    return this.runTyped("gc", { options });
+  }
   /**
    * Create an item using the same mutation path as `pm create`.
    */
   create(options = {}) {
-    return this.run("create", splitClientMutationOptions(options));
+    return this.runTyped("create", splitFullClientMutationOptions(options));
   }
   /**
    * Update an item using the same mutation path as `pm update`.
    */
   update(id, options = {}) {
-    return this.run("update", { id, ...splitClientMutationOptions(options) });
+    return this.runTyped("update", { id, ...splitFullClientMutationOptions(options) });
   }
   /**
    * Close an item using the same mutation path as `pm close`.
    */
   close(id, reason, options = {}) {
-    return this.run("close", { id, reason, ...splitClientMutationOptions(options) });
+    return this.runTyped("close", { id, reason, ...splitFullClientMutationOptions(options) });
   }
   /**
    * Claim an item using the same mutation path as `pm claim`.
    */
   claim(id, options = {}) {
-    return this.run("claim", { id, ...splitClientMutationOptions(options) });
+    return this.runTyped("claim", { id, ...splitFullClientMutationOptions(options) });
   }
   /**
    * Release an item's active claim using the same mutation path as `pm release`.
    */
   release(id, options = {}) {
-    return this.run("release", { id, ...splitClientMutationOptions(options) });
+    return this.runTyped("release", { id, ...splitFullClientMutationOptions(options) });
   }
   /**
    * Copy an item using the same mutation path as `pm copy`.
    */
   copy(id, options = {}) {
-    return this.run("copy", { id, ...splitClientMutationOptions(options) });
+    return this.runTyped("copy", { id, ...splitFullClientMutationOptions(options) });
   }
   /**
    * Delete an item using the same mutation path as `pm delete`.
    */
   delete(id, options = {}) {
-    return this.run("delete", { id, ...splitClientMutationOptions(options) });
+    return this.runTyped("delete", { id, ...splitFullClientMutationOptions(options) });
   }
   /**
    * Restore an item to a history version or timestamp using `pm restore`.
    */
   restore(id, target, options = {}) {
-    const { fullChangedFields, idOnly, ...runnerOptions } = options;
-    return this.run("restore", {
-      ...fullChangedFields === void 0 ? {} : { fullChangedFields },
-      ...idOnly === void 0 ? {} : { idOnly },
+    return this.runTyped("restore", {
+      fullChangedFields: true,
       id,
-      options: { ...runnerOptions, target }
+      options: { ...options, target }
     });
   }
   /**
    * Set, clear, or read workspace focus using the same path as `pm focus`.
    */
   focus(id, options = {}) {
-    return this.run("focus", { ...id === void 0 ? {} : { id }, ...splitClientMutationOptions(options) });
+    return this.runTyped("focus", { ...id === void 0 ? {} : { id }, ...splitFullClientMutationOptions(options) });
   }
   /**
    * Claim an item and transition it to the workspace in-progress status.
    */
   startTask(id, options = {}) {
-    return this.run("start-task", { id, ...splitClientMutationOptions(options) });
+    return this.runTyped("start-task", { id, ...splitFullClientMutationOptions(options) });
   }
   /**
    * Move an item back to the workspace open status and release the claim.
    */
   pauseTask(id, options = {}) {
-    return this.run("pause-task", { id, ...splitClientMutationOptions(options) });
+    return this.runTyped("pause-task", { id, ...splitFullClientMutationOptions(options) });
   }
   /**
    * Close an item and release its active assignment.
    */
   closeTask(id, reason, options = {}) {
-    return this.run("close-task", { id, reason, ...splitClientMutationOptions(options) });
+    return this.runTyped("close-task", { id, reason, ...splitFullClientMutationOptions(options) });
   }
   /**
    * Run the extension lifecycle surface with the same result shape as `pm extension`.
@@ -5729,6 +5897,102 @@ function aggregate(options = {}, clientOptions = {}) {
 function stats(options = {}, clientOptions = {}) {
   return new PmClient(clientOptions).stats(options);
 }
+function comments(id, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).comments(id, options);
+}
+function notes(id, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).notes(id, options);
+}
+function learnings(id, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).learnings(id, options);
+}
+function files(id, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).files(id, options);
+}
+function filesDiscover(id, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).filesDiscover(id, options);
+}
+function docs(id, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).docs(id, options);
+}
+function deps(id, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).deps(id, options);
+}
+function append(id, body, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).append(id, body, options);
+}
+function init(prefix, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).init(prefix, options);
+}
+function config(scope, configAction, key, value, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).config(scope, configAction, key, value, options);
+}
+function schema(subcommand, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).schema(subcommand, options);
+}
+function schemaList(clientOptions = {}) {
+  return new PmClient(clientOptions).schemaList();
+}
+function schemaShow(name, clientOptions = {}) {
+  return new PmClient(clientOptions).schemaShow(name);
+}
+function schemaAddType(name, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).schemaAddType(name, options);
+}
+function schemaRemoveType(name, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).schemaRemoveType(name, options);
+}
+function schemaAddStatus(name, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).schemaAddStatus(name, options);
+}
+function schemaRemoveStatus(name, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).schemaRemoveStatus(name, options);
+}
+function schemaAddField(name, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).schemaAddField(name, options);
+}
+function schemaRemoveField(name, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).schemaRemoveField(name, options);
+}
+function schemaListFields(clientOptions = {}) {
+  return new PmClient(clientOptions).schemaListFields();
+}
+function schemaShowField(name, clientOptions = {}) {
+  return new PmClient(clientOptions).schemaShowField(name);
+}
+function schemaApplyPreset(typePreset, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).schemaApplyPreset(typePreset, options);
+}
+function schemaInferTypes(options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).schemaInferTypes(options);
+}
+function schemaShowStatus(name, clientOptions = {}) {
+  return new PmClient(clientOptions).schemaShowStatus(name);
+}
+function profile(subcommand, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).profile(subcommand, options);
+}
+function profileList(clientOptions = {}) {
+  return new PmClient(clientOptions).profileList();
+}
+function profileShow(name, clientOptions = {}) {
+  return new PmClient(clientOptions).profileShow(name);
+}
+function profileApply(name, options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).profileApply(name, options);
+}
+function profileLint(name, clientOptions = {}) {
+  return new PmClient(clientOptions).profileLint(name);
+}
+function validate(options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).validate(options);
+}
+function health(options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).health(options);
+}
+function gc(options = {}, clientOptions = {}) {
+  return new PmClient(clientOptions).gc(options);
+}
 function create(options = {}, clientOptions = {}) {
   return new PmClient(clientOptions).create(options);
 }
@@ -5927,11 +6191,16 @@ var LIFECYCLE_AUTHOR_ALIAS_ACTIONS = /* @__PURE__ */ new Set([
 function normalizeMcpOptionsArrays(options, action) {
   const result = {};
   const promoteAddRemove = action !== void 0 && ARRAY_ADD_REMOVE_ACTIONS.has(action);
+  const preserveStandaloneNote = action === "files" || action === "files-discover" || action === "docs";
   for (const [key, value] of Object.entries(options)) {
     if (Array.isArray(value) && ARRAY_TO_CSV_FIELDS.has(key)) {
       result[key] = value.join(",");
       continue;
     }
+    if (key === "note" && preserveStandaloneNote) {
+      result[key] = value;
+      continue;
+    }
     if (typeof value === "string" && SCALAR_TO_ARRAY_FIELDS.has(key)) {
       result[key] = [value];
       continue;
@@ -6530,8 +6799,8 @@ function createMcpSchemaContext(ctx) {
     aliases: aliasSource === void 0 ? void 0 : readStringArray(aliasSource)
   };
 }
-function runMcpSchemaReadOrRemoveAction(schema) {
-  const { ctx, subcommand, name, author, force } = schema;
+function runMcpSchemaReadOrRemoveAction(schema2) {
+  const { ctx, subcommand, name, author, force } = schema2;
   const simpleHandlers = {
     list: () => runSchemaList(ctx.global),
     show: () => runSchemaShow(name, ctx.global),
@@ -6546,8 +6815,8 @@ function runMcpSchemaReadOrRemoveAction(schema) {
   const handler = getOwnHandler(simpleHandlers, subcommand);
   return handler ? handler() : null;
 }
-function runMcpSchemaAddFieldAction(schema) {
-  const { ctx, name, author, force, aliases } = schema;
+function runMcpSchemaAddFieldAction(schema2) {
+  const { ctx, name, author, force, aliases } = schema2;
   const commandsSource = ctx.args.commands ?? ctx.options.commands;
   const requiredTypesSource = ctx.args.requiredTypes ?? ctx.options.requiredTypes;
   return runSchemaAddField(name, {
@@ -6564,8 +6833,8 @@ function runMcpSchemaAddFieldAction(schema) {
     force
   }, ctx.global);
 }
-function runMcpSchemaAddStatusAction(schema) {
-  const { ctx, name, author, force, aliases } = schema;
+function runMcpSchemaAddStatusAction(schema2) {
+  const { ctx, name, author, force, aliases } = schema2;
   const roleSource = ctx.args.role ?? ctx.options.role;
   return runSchemaAddStatus(name, {
     role: roleSource === void 0 ? void 0 : readStringArray(roleSource),
@@ -6576,8 +6845,8 @@ function runMcpSchemaAddStatusAction(schema) {
     force
   }, ctx.global);
 }
-function runMcpSchemaAddTypeAction(schema) {
-  const { ctx, name, author, force, aliases } = schema;
+function runMcpSchemaAddTypeAction(schema2) {
+  const { ctx, name, author, force, aliases } = schema2;
   return runSchemaAddType(name, {
     description: readString(ctx.args, "description") ?? readString(ctx.options, "description"),
     defaultStatus: readString(ctx.args, "defaultStatus") ?? readString(ctx.args, "default_status") ?? readString(ctx.options, "defaultStatus") ?? readString(ctx.options, "default_status"),
@@ -6588,29 +6857,29 @@ function runMcpSchemaAddTypeAction(schema) {
   }, ctx.global);
 }
 function runMcpSchemaAction(ctx) {
-  const schema = createMcpSchemaContext(ctx);
-  const simpleResult = runMcpSchemaReadOrRemoveAction(schema);
+  const schema2 = createMcpSchemaContext(ctx);
+  const simpleResult = runMcpSchemaReadOrRemoveAction(schema2);
   if (simpleResult !== null) {
     return simpleResult;
   }
-  if (schema.subcommand === "add-field") {
-    return runMcpSchemaAddFieldAction(schema);
+  if (schema2.subcommand === "add-field") {
+    return runMcpSchemaAddFieldAction(schema2);
   }
-  if (schema.subcommand === "add-status") {
-    return runMcpSchemaAddStatusAction(schema);
+  if (schema2.subcommand === "add-status") {
+    return runMcpSchemaAddStatusAction(schema2);
   }
-  if (schema.subcommand === "add-type") {
+  if (schema2.subcommand === "add-type") {
     if (ctx.args.infer === true || ctx.options.infer === true) {
       return runSchemaInferTypes({
         minCount: parseMcpInteger(ctx.args.minCount ?? ctx.options.minCount, "schema infer minCount"),
         apply: ctx.args.apply === true || ctx.options.apply === true,
-        author: schema.author,
-        force: schema.force
+        author: schema2.author,
+        force: schema2.force
       }, ctx.global);
     }
-    return runMcpSchemaAddTypeAction(schema);
+    return runMcpSchemaAddTypeAction(schema2);
   }
-  throw new PmCliError(`Unknown pm schema subcommand "${schema.subcommand}". Allowed: add-type, remove-type, add-status, remove-status, add-field, remove-field, list-fields, show-field, apply-preset, list, show, show-status`, 64);
+  throw new PmCliError(`Unknown pm schema subcommand "${schema2.subcommand}". Allowed: add-type, remove-type, add-status, remove-status, add-field, remove-field, list-fields, show-field, apply-preset, list, show, show-status`, 64);
 }
 function runMcpProfileAction(ctx) {
   const subcommand = readString(ctx.args, "subcommand") ?? readRequiredString(ctx.options, "subcommand");
@@ -6851,6 +7120,38 @@ export {
   next,
   aggregate,
   stats,
+  comments,
+  notes,
+  learnings,
+  files,
+  filesDiscover,
+  docs,
+  deps,
+  append,
+  init,
+  config,
+  schema,
+  schemaList,
+  schemaShow,
+  schemaAddType,
+  schemaRemoveType,
+  schemaAddStatus,
+  schemaRemoveStatus,
+  schemaAddField,
+  schemaRemoveField,
+  schemaListFields,
+  schemaShowField,
+  schemaApplyPreset,
+  schemaInferTypes,
+  schemaShowStatus,
+  profile,
+  profileList,
+  profileShow,
+  profileApply,
+  profileLint,
+  validate,
+  health,
+  gc,
   create,
   update,
   close,
@@ -6884,6 +7185,6 @@ export {
   readRequiredString,
   runAction
 };
-//# sourceMappingURL=chunk-2RADY7IB.js.map
+//# sourceMappingURL=chunk-XES6AVCK.js.map
 
-//# debugId=172e4594-e82f-5ac4-add6-4f96b3b2890f
+//# debugId=fba5a2fc-abf5-5621-9076-1b97983ccc95