@unbrained/pm-cli 2026.6.30 → 2026.7.2

package/dist/cli-bundle/chunks/{chunk-VD3LKZFX.js → chunk-7W4H4K26.js}

@@ -1,10 +1,13 @@
 
-!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]="2e4b7619-5881-5abc-8c6d-a33b06c74f8d")}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]="636bc41a-f03b-528f-84cb-5ab89ae42c00")}catch(e){}}();
 import {
   describeAllowedTransitions,
   evaluateTransition,
   resolveTypeWorkflows
 } from "./chunk-YJIEJRZB.js";
+import {
+  runClose
+} from "./chunk-XTHQWXVC.js";
 import {
   COMMON_UNSET_FIELD_DEFINITIONS_AFTER_AUTHOR,
   COMMON_UNSET_FIELD_DEFINITIONS_AFTER_CLOSE_REASON_BEFORE_AUTHOR,
@@ -27,7 +30,7 @@ import {
   parseTypeOptionEntries,
   resolvePriority,
   resolveRuntimeUnsetFieldDefinition
-} from "./chunk-UB3V5WUI.js";
+} from "./chunk-RM37OPYK.js";
 import {
   applyTagRemovals,
   assertNoUnknownCsvKeys,
@@ -37,18 +40,15 @@ import {
   parseCsvKv,
   parseOptionalNumber,
   parseTags
-} from "./chunk-D6USKAMA.js";
-import {
-  runClose
-} from "./chunk-BOWQWXLI.js";
+} from "./chunk-KLXF7NCC.js";
 import {
   normalizeParentReferenceValue,
   validateMissingParentReference,
   validateSprintOrReleaseValue
-} from "./chunk-7RIJGN4R.js";
+} from "./chunk-QH3FSKRJ.js";
 import {
   buildInvalidTypeError
-} from "./chunk-YEDFE4DC.js";
+} from "./chunk-ZNT7KEWE.js";
 import {
   applyRegisteredItemFieldDefaultsAndValidation,
   buildItemNotFoundError,
@@ -59,14 +59,14 @@ import {
   parseRegisteredItemFieldAssignments,
   readLocatedItem,
   toItemRecord
-} from "./chunk-KGQ3W65B.js";
+} from "./chunk-NRZS637N.js";
 import {
   collectRuntimeUpdateFieldValues,
   normalizeStatusInput
-} from "./chunk-V3KLX7U7.js";
+} from "./chunk-KN3URLKS.js";
 import {
   resolveIsoOrRelative
-} from "./chunk-KRASIL6M.js";
+} from "./chunk-K2VYLVX4.js";
 import {
   DEPENDENCY_KIND_VALUES,
   EXIT_CODE,
@@ -89,7 +89,7 @@ import {
   resolveTypeName,
   stableValueEquals,
   validateTypeOptions
-} from "./chunk-CY5IJMUM.js";
+} from "./chunk-I66WE2HE.js";
 
 // dist/cli/commands/update.js
 var UPDATE_UNSET_FIELD_DEFINITIONS = [
@@ -321,81 +321,31 @@ function enforceAllowAuditUpdateScope(id, options, clearFrontMatterKeys) {
     return;
   }
   const disallowedFlags = [];
-  if (options.status !== void 0) {
-    disallowedFlags.push("--status");
-  }
-  if (options.closeReason !== void 0) {
-    disallowedFlags.push("--close-reason");
-  }
-  if (options.assignee !== void 0) {
-    disallowedFlags.push("--assignee");
-  }
-  if (options.parent !== void 0) {
-    disallowedFlags.push("--parent");
-  }
-  if (options.blockedBy !== void 0) {
-    disallowedFlags.push("--blocked-by");
-  }
-  if (options.blockedReason !== void 0) {
-    disallowedFlags.push("--blocked-reason");
-  }
-  if (options.unblockNote !== void 0) {
-    disallowedFlags.push("--unblock-note");
-  }
-  if (options.dep !== void 0) {
-    disallowedFlags.push("--dep");
-  }
-  if (options.depRemove !== void 0) {
-    disallowedFlags.push("--dep-remove");
-  }
-  if (options.replaceDeps === true) {
-    disallowedFlags.push("--replace-deps");
-  }
-  if (options.replaceTests === true) {
-    disallowedFlags.push("--replace-tests");
-  }
-  if (options.note !== void 0) {
-    disallowedFlags.push("--note");
-  }
-  if (options.learning !== void 0) {
-    disallowedFlags.push("--learning");
-  }
-  if (options.test !== void 0) {
-    disallowedFlags.push("--test");
-  }
-  if (options.reminder !== void 0) {
-    disallowedFlags.push("--reminder");
-  }
-  if (options.event !== void 0) {
-    disallowedFlags.push("--event");
-  }
-  if (options.clearDeps === true) {
-    disallowedFlags.push("--clear-deps");
-  }
-  if (options.clearComments === true) {
-    disallowedFlags.push("--clear-comments");
-  }
-  if (options.clearNotes === true) {
-    disallowedFlags.push("--clear-notes");
-  }
-  if (options.clearLearnings === true) {
-    disallowedFlags.push("--clear-learnings");
-  }
-  if (options.clearFiles === true) {
-    disallowedFlags.push("--clear-files");
-  }
-  if (options.clearTests === true) {
-    disallowedFlags.push("--clear-tests");
-  }
-  if (options.clearDocs === true) {
-    disallowedFlags.push("--clear-docs");
-  }
-  if (options.clearReminders === true) {
-    disallowedFlags.push("--clear-reminders");
-  }
-  if (options.clearEvents === true) {
-    disallowedFlags.push("--clear-events");
-  }
+  pushIf(options.status !== void 0, "--status", disallowedFlags);
+  pushIf(options.closeReason !== void 0, "--close-reason", disallowedFlags);
+  pushIf(options.assignee !== void 0, "--assignee", disallowedFlags);
+  pushIf(options.parent !== void 0, "--parent", disallowedFlags);
+  pushIf(options.blockedBy !== void 0, "--blocked-by", disallowedFlags);
+  pushIf(options.blockedReason !== void 0, "--blocked-reason", disallowedFlags);
+  pushIf(options.unblockNote !== void 0, "--unblock-note", disallowedFlags);
+  pushIf(options.dep !== void 0, "--dep", disallowedFlags);
+  pushIf(options.depRemove !== void 0, "--dep-remove", disallowedFlags);
+  pushIf(options.replaceDeps === true, "--replace-deps", disallowedFlags);
+  pushIf(options.replaceTests === true, "--replace-tests", disallowedFlags);
+  pushIf(options.note !== void 0, "--note", disallowedFlags);
+  pushIf(options.learning !== void 0, "--learning", disallowedFlags);
+  pushIf(options.test !== void 0, "--test", disallowedFlags);
+  pushIf(options.reminder !== void 0, "--reminder", disallowedFlags);
+  pushIf(options.event !== void 0, "--event", disallowedFlags);
+  pushIf(options.clearDeps === true, "--clear-deps", disallowedFlags);
+  pushIf(options.clearComments === true, "--clear-comments", disallowedFlags);
+  pushIf(options.clearNotes === true, "--clear-notes", disallowedFlags);
+  pushIf(options.clearLearnings === true, "--clear-learnings", disallowedFlags);
+  pushIf(options.clearFiles === true, "--clear-files", disallowedFlags);
+  pushIf(options.clearTests === true, "--clear-tests", disallowedFlags);
+  pushIf(options.clearDocs === true, "--clear-docs", disallowedFlags);
+  pushIf(options.clearReminders === true, "--clear-reminders", disallowedFlags);
+  pushIf(options.clearEvents === true, "--clear-events", disallowedFlags);
   const disallowedUnset = [...clearFrontMatterKeys].filter((field) => AUDIT_UPDATE_DISALLOWED_UNSET_FRONT_MATTER_KEYS.has(field)).sort((left, right) => left.localeCompare(right)).map((field) => `--unset ${field.replaceAll("_", "-")}`);
   disallowedFlags.push(...disallowedUnset);
   if (disallowedFlags.length > 0) {
@@ -622,7 +572,7 @@ function normalizeUpdatePolicyOptionKey(raw, typeName) {
   }
   return canonical;
 }
-function collectProvidedUpdatePolicyOptions(options, extensionFieldNames) {
+function collectProvidedUpdatePolicyOptions(options, runtimeFieldRegistry, extensionFieldNames) {
   const provided = /* @__PURE__ */ new Set();
   const mark = (optionKey, isProvided) => {
     if (isProvided) {
@@ -699,14 +649,14 @@ function collectProvidedUpdatePolicyOptions(options, extensionFieldNames) {
   mark("event", options.clearEvents === true);
   mark("typeOption", options.clearTypeOptions === true);
   if (options.unset && options.unset.length > 0) {
-    const unsetTargets = parseUpdateUnsetTargets(options.unset, void 0, extensionFieldNames);
+    const unsetTargets = parseUpdateUnsetTargets(options.unset, runtimeFieldRegistry, extensionFieldNames);
     for (const optionKey of unsetTargets.optionKeys) {
       mark(optionKey, true);
     }
   }
   return provided;
 }
-function enforceUpdateOptionsByType(typeName, options, typeRegistry, extensionFieldNames) {
+function enforceUpdateOptionsByType(typeName, options, typeRegistry, runtimeFieldRegistry, extensionFieldNames) {
   const typeDefinition = resolveTypeDefinition(typeName, typeRegistry);
   if (!typeDefinition) {
     throw new PmCliError(`Invalid type value "${typeName}"`, EXIT_CODE.USAGE);
@@ -715,7 +665,7 @@ function enforceUpdateOptionsByType(typeName, options, typeRegistry, extensionFi
   if (policyState.errors.length > 0) {
     throw new PmCliError(policyState.errors.join("; "), EXIT_CODE.CONFLICT);
   }
-  const provided = collectProvidedUpdatePolicyOptions(options, extensionFieldNames);
+  const provided = collectProvidedUpdatePolicyOptions(options, runtimeFieldRegistry, extensionFieldNames);
   for (const disabled of policyState.disabled) {
     if (provided.has(normalizeUpdatePolicyOptionKey(disabled, typeName))) {
       throw new PmCliError(`Option ${commandOptionFlagLabel("update", disabled)} is disabled for type "${typeName}" by command_option_policies`, EXIT_CODE.USAGE);
@@ -727,6 +677,95 @@ function enforceUpdateOptionsByType(typeName, options, typeRegistry, extensionFi
     }
   }
 }
+var UPDATE_LEGACY_SCALAR_OPTION_KEYS = [
+  "tags",
+  "closeReason",
+  "deadline",
+  "estimatedMinutes",
+  "acceptanceCriteria",
+  "definitionOfReady",
+  "goal",
+  "objective",
+  "value",
+  "impact",
+  "outcome",
+  "whyNow",
+  "assignee",
+  "parent",
+  "reviewer",
+  "risk",
+  "confidence",
+  "sprint",
+  "release",
+  "blockedBy",
+  "blockedReason",
+  "unblockNote",
+  "reporter",
+  "severity",
+  "environment",
+  "reproSteps",
+  "resolution",
+  "expectedResult",
+  "actualResult",
+  "affectedVersion",
+  "fixedVersion",
+  "component",
+  "regression",
+  "customerImpact"
+];
+var UPDATE_SIMPLE_FIELD_FLAG_KEYS = [
+  "title",
+  "description",
+  "body",
+  "status",
+  "closeReason",
+  "priority",
+  "type",
+  "deadline",
+  "estimatedMinutes",
+  "acceptanceCriteria",
+  "definitionOfReady",
+  "goal",
+  "objective",
+  "value",
+  "impact",
+  "outcome",
+  "whyNow",
+  "assignee",
+  "parent",
+  "reviewer",
+  "risk",
+  "confidence",
+  "sprint",
+  "release",
+  "blockedBy",
+  "blockedReason",
+  "unblockNote",
+  "reporter",
+  "severity",
+  "environment",
+  "reproSteps",
+  "resolution",
+  "expectedResult",
+  "actualResult",
+  "affectedVersion",
+  "fixedVersion",
+  "component",
+  "regression",
+  "customerImpact",
+  "dep",
+  "depRemove",
+  "comment",
+  "note",
+  "learning",
+  "file",
+  "test",
+  "doc",
+  "reminder",
+  "event",
+  "typeOption",
+  "field"
+];
 var UPDATE_POST_TAG_SCALAR_MUTATIONS = [
   {
     optionKey: "deadline",
@@ -791,9 +830,9 @@ function applyUpdateScalarMutations(definitions, options, context) {
     context.changedFields.push(definition.metadataKey);
   }
 }
-async function runUpdate(id, options, global) {
+async function resolveStdinUpdateOptions(options) {
   const stdinResolver = createStdinTokenResolver();
-  options = normalizeLegacyNoneUpdateOptions({
+  return normalizeLegacyNoneUpdateOptions({
     ...options,
     body: await stdinResolver.resolveValue(options.body, "--body"),
     dep: await stdinResolver.resolveList(options.dep, "--dep"),
@@ -809,24 +848,9 @@ async function runUpdate(id, options, global) {
     typeOption: await stdinResolver.resolveList(options.typeOption, "--type-option"),
     field: await stdinResolver.resolveList(options.field, "--field")
   });
-  const pmRoot = resolvePmRoot(process.cwd(), global.path);
-  if (!await pathExists(getSettingsPath(pmRoot))) {
-    throw new PmCliError(`Tracker is not initialized at ${pmRoot}. Run pm init first.`, EXIT_CODE.NOT_FOUND);
-  }
-  const settings = await readSettings(pmRoot);
-  const statusRegistry = resolveRuntimeStatusRegistry(settings.schema);
-  const runtimeFieldRegistry = resolveRuntimeFieldRegistry(settings.schema);
-  const extensionRegistrations = getActiveExtensionRegistrations();
-  const extensionFieldNames = collectRegisteredItemFieldNames(extensionRegistrations);
-  const typeRegistry = resolveItemTypeRegistry(settings, extensionRegistrations);
-  const workflowEnforcement = settings.governance.workflow_enforcement ?? "off";
-  const typeWorkflows = workflowEnforcement === "off" ? [] : resolveTypeWorkflows(settings.schema);
-  const parentReferencePolicy = settings.validation.parent_reference;
-  const sprintReleasePolicy = settings.validation.sprint_release_format;
-  const unsetTargets = parseUpdateUnsetTargets(options.unset, runtimeFieldRegistry, extensionFieldNames);
-  const clearOptionKeys = new Set(unsetTargets.optionKeys);
-  const clearFrontMatterKeys = new Set(unsetTargets.frontMatterKeys);
-  const clearCollectionDefinitions = [
+}
+function buildClearCollectionDefinitions(options) {
+  return [
     {
       enabled: options.clearDeps || options.replaceDeps,
       optionKey: "dep",
@@ -908,6 +932,8 @@ async function runUpdate(id, options, global) {
       frontMatterKey: "type_options"
     }
   ];
+}
+function validateReplaceOptions(options) {
   if (options.replaceDeps === true && (options.dep === void 0 || options.dep.length === 0)) {
     throw new PmCliError("--replace-deps requires at least one --dep entry", EXIT_CODE.USAGE);
   }
@@ -920,54 +946,30 @@ async function runUpdate(id, options, global) {
   if (options.replaceTests === true && options.clearTests === true) {
     throw new PmCliError("--replace-tests cannot be combined with --clear-tests", EXIT_CODE.USAGE);
   }
-  for (const definition of clearCollectionDefinitions) {
+}
+function applyClearCollectionDefinitions(params) {
+  for (const definition of params.definitions) {
     if (!definition.enabled) {
       continue;
     }
-    if (definition.values && definition.values.length > 0 && !(definition.optionKey === "dep" && options.replaceDeps === true || definition.optionKey === "test" && options.replaceTests === true)) {
+    const isReplacement = definition.optionKey === "dep" && params.options.replaceDeps === true || definition.optionKey === "test" && params.options.replaceTests === true;
+    if (definition.values && definition.values.length > 0 && !isReplacement) {
       throw new PmCliError(`Cannot combine ${definition.clearFlag} with ${definition.valueFlag}`, EXIT_CODE.USAGE);
     }
-    clearOptionKeys.add(definition.optionKey);
-    clearFrontMatterKeys.add(definition.frontMatterKey);
+    params.clearOptionKeys.add(definition.optionKey);
+    params.clearFrontMatterKeys.add(definition.frontMatterKey);
   }
-  enforceAllowAuditUpdateScope(id, options, clearFrontMatterKeys);
-  const scalarOptionPresence = {
-    tags: options.tags !== void 0,
-    closeReason: options.closeReason !== void 0,
-    deadline: options.deadline !== void 0,
-    estimatedMinutes: options.estimatedMinutes !== void 0,
-    acceptanceCriteria: options.acceptanceCriteria !== void 0,
-    definitionOfReady: options.definitionOfReady !== void 0,
-    order: options.order !== void 0 || options.rank !== void 0,
-    goal: options.goal !== void 0,
-    objective: options.objective !== void 0,
-    value: options.value !== void 0,
-    impact: options.impact !== void 0,
-    outcome: options.outcome !== void 0,
-    whyNow: options.whyNow !== void 0,
-    assignee: options.assignee !== void 0,
-    parent: options.parent !== void 0,
-    reviewer: options.reviewer !== void 0,
-    risk: options.risk !== void 0,
-    confidence: options.confidence !== void 0,
-    sprint: options.sprint !== void 0,
-    release: options.release !== void 0,
-    blockedBy: options.blockedBy !== void 0,
-    blockedReason: options.blockedReason !== void 0,
-    unblockNote: options.unblockNote !== void 0,
-    reporter: options.reporter !== void 0,
-    severity: options.severity !== void 0,
-    environment: options.environment !== void 0,
-    reproSteps: options.reproSteps !== void 0,
-    resolution: options.resolution !== void 0,
-    expectedResult: options.expectedResult !== void 0,
-    actualResult: options.actualResult !== void 0,
-    affectedVersion: options.affectedVersion !== void 0,
-    fixedVersion: options.fixedVersion !== void 0,
-    component: options.component !== void 0,
-    regression: options.regression !== void 0,
-    customerImpact: options.customerImpact !== void 0
-  };
+}
+function buildScalarOptionPresence(options) {
+  const presence = {};
+  for (const key of UPDATE_LEGACY_SCALAR_OPTION_KEYS) {
+    presence[String(key)] = options[key] !== void 0;
+  }
+  presence.order = options.order !== void 0 || options.rank !== void 0;
+  return presence;
+}
+function rejectUnsetScalarConflicts(options, unsetTargets) {
+  const scalarOptionPresence = buildScalarOptionPresence(options);
   for (const [optionKey, hasValue] of Object.entries(scalarOptionPresence)) {
     if (!hasValue || !unsetTargets.optionKeys.has(optionKey)) {
       continue;
@@ -975,56 +977,539 @@ async function runUpdate(id, options, global) {
     const unsetField = UPDATE_OPTION_KEY_TO_UNSET_CANONICAL.get(optionKey) ?? optionKey;
     throw new PmCliError(`Cannot combine --unset ${unsetField} with ${commandOptionFlagLabel("update", optionKey)}`, EXIT_CODE.USAGE);
   }
-  if (clearFrontMatterKeys.has("tags")) {
-    if (Array.isArray(options.addTags) && options.addTags.length > 0) {
-      throw new PmCliError("Cannot combine --unset tags with --add-tags", EXIT_CODE.USAGE);
-    }
-    if (Array.isArray(options.removeTags) && options.removeTags.length > 0) {
-      throw new PmCliError("Cannot combine --unset tags with --remove-tags", EXIT_CODE.USAGE);
-    }
+  if (!unsetTargets.frontMatterKeys.has("tags")) {
+    return;
   }
+  if (Array.isArray(options.addTags) && options.addTags.length > 0) {
+    throw new PmCliError("Cannot combine --unset tags with --add-tags", EXIT_CODE.USAGE);
+  }
+  if (Array.isArray(options.removeTags) && options.removeTags.length > 0) {
+    throw new PmCliError("Cannot combine --unset tags with --remove-tags", EXIT_CODE.USAGE);
+  }
+}
+function rejectLegacyScalarTokens(options) {
   const assertNoLegacyScalarToken = (value, optionKey) => {
     const unsetField = UPDATE_OPTION_KEY_TO_UNSET_CANONICAL.get(optionKey);
     const hint = unsetField ? `Use --unset ${unsetField} to clear this field.` : void 0;
     assertNoLegacyNoneToken(value, commandOptionFlagLabel("update", optionKey), hint);
   };
-  assertNoLegacyScalarToken(options.tags, "tags");
-  assertNoLegacyScalarToken(options.closeReason, "closeReason");
-  assertNoLegacyScalarToken(options.deadline, "deadline");
-  assertNoLegacyScalarToken(options.estimatedMinutes, "estimatedMinutes");
-  assertNoLegacyScalarToken(options.acceptanceCriteria, "acceptanceCriteria");
-  assertNoLegacyScalarToken(options.definitionOfReady, "definitionOfReady");
+  for (const key of UPDATE_LEGACY_SCALAR_OPTION_KEYS) {
+    assertNoLegacyScalarToken(options[key], String(key));
+  }
   assertNoLegacyScalarToken(options.order ?? options.rank, "order");
-  assertNoLegacyScalarToken(options.goal, "goal");
-  assertNoLegacyScalarToken(options.objective, "objective");
-  assertNoLegacyScalarToken(options.value, "value");
-  assertNoLegacyScalarToken(options.impact, "impact");
-  assertNoLegacyScalarToken(options.outcome, "outcome");
-  assertNoLegacyScalarToken(options.whyNow, "whyNow");
-  assertNoLegacyScalarToken(options.assignee, "assignee");
-  assertNoLegacyScalarToken(options.parent, "parent");
-  assertNoLegacyScalarToken(options.reviewer, "reviewer");
-  assertNoLegacyScalarToken(options.risk, "risk");
-  assertNoLegacyScalarToken(options.confidence, "confidence");
-  assertNoLegacyScalarToken(options.sprint, "sprint");
-  assertNoLegacyScalarToken(options.release, "release");
-  assertNoLegacyScalarToken(options.blockedBy, "blockedBy");
-  assertNoLegacyScalarToken(options.blockedReason, "blockedReason");
-  assertNoLegacyScalarToken(options.unblockNote, "unblockNote");
-  assertNoLegacyScalarToken(options.reporter, "reporter");
-  assertNoLegacyScalarToken(options.severity, "severity");
-  assertNoLegacyScalarToken(options.environment, "environment");
-  assertNoLegacyScalarToken(options.reproSteps, "reproSteps");
-  assertNoLegacyScalarToken(options.resolution, "resolution");
-  assertNoLegacyScalarToken(options.expectedResult, "expectedResult");
-  assertNoLegacyScalarToken(options.actualResult, "actualResult");
-  assertNoLegacyScalarToken(options.affectedVersion, "affectedVersion");
-  assertNoLegacyScalarToken(options.fixedVersion, "fixedVersion");
-  assertNoLegacyScalarToken(options.component, "component");
-  assertNoLegacyScalarToken(options.regression, "regression");
-  assertNoLegacyScalarToken(options.customerImpact, "customerImpact");
   assertNoLegacyNoneTokens(options.reminder, "--reminder", "Use --clear-reminders to clear reminders.");
   assertNoLegacyNoneTokens(options.event, "--event", "Use --clear-events to clear linked events.");
+}
+function buildUpdateFieldFlags(options, runtimeFieldUpdates) {
+  const flags = {};
+  for (const key of UPDATE_SIMPLE_FIELD_FLAG_KEYS) {
+    flags[String(key)] = options[key] !== void 0;
+  }
+  flags.tags = options.tags !== void 0;
+  flags.addTags = Array.isArray(options.addTags) && options.addTags.length > 0;
+  flags.removeTags = Array.isArray(options.removeTags) && options.removeTags.length > 0;
+  flags.order = options.order !== void 0;
+  flags.rank = options.rank !== void 0;
+  flags.replaceDeps = options.replaceDeps === true;
+  flags.replaceTests = options.replaceTests === true;
+  flags.unset = options.unset !== void 0 && options.unset.length > 0;
+  flags.clearDeps = options.clearDeps === true;
+  flags.clearComments = options.clearComments === true;
+  flags.clearNotes = options.clearNotes === true;
+  flags.clearLearnings = options.clearLearnings === true;
+  flags.clearFiles = options.clearFiles === true;
+  flags.clearTests = options.clearTests === true;
+  flags.clearDocs = options.clearDocs === true;
+  flags.clearReminders = options.clearReminders === true;
+  flags.clearEvents = options.clearEvents === true;
+  flags.clearTypeOptions = options.clearTypeOptions === true;
+  flags.runtimeFields = Object.keys(runtimeFieldUpdates).length > 0;
+  return flags;
+}
+async function buildNoopUpdateResult(params) {
+  const located = await locateItem(params.pmRoot, params.id, params.settings.id_prefix, params.settings.item_format, params.typeRegistry.type_to_folder);
+  if (!located) {
+    throw await buildItemNotFoundError(params.pmRoot, params.id, params.settings.id_prefix, params.typeRegistry.type_to_folder);
+  }
+  const { document } = await readLocatedItem(located, { schema: params.settings.schema });
+  return {
+    item: toItemRecord(document.metadata),
+    changed_fields: [],
+    warnings: ["noop_no_update_fields"]
+  };
+}
+async function assertUpdateTrackerInitialized(pmRoot) {
+  if (!await pathExists(getSettingsPath(pmRoot))) {
+    throw new PmCliError(`Tracker is not initialized at ${pmRoot}. Run pm init first.`, EXIT_CODE.NOT_FOUND);
+  }
+}
+function assertMatchingOrderRank(options) {
+  if (options.order !== void 0 && options.rank !== void 0 && options.order !== options.rank) {
+    throw new PmCliError("--order and --rank must match when both are provided", EXIT_CODE.USAGE);
+  }
+}
+async function resolveParentReferenceForUpdate(params) {
+  if (params.options.parent === void 0 || params.unsetTargets.frontMatterKeys.has("parent")) {
+    return { resolvedParentValue: void 0, warnings: [] };
+  }
+  const resolvedParentValue = normalizeParentReferenceValue(params.options.parent);
+  const parentLocated = await locateItem(params.pmRoot, resolvedParentValue, params.settings.id_prefix, params.settings.item_format, params.typeRegistry.type_to_folder);
+  if (parentLocated) {
+    return { resolvedParentValue, warnings: [] };
+  }
+  const normalizedParentId = normalizeItemId(resolvedParentValue, params.settings.id_prefix);
+  return {
+    resolvedParentValue,
+    warnings: validateMissingParentReference(normalizedParentId, params.parentReferencePolicy).warnings
+  };
+}
+function blockedByResolutionWarnings(resolution) {
+  return resolution.unresolved === void 0 ? [] : [`blocked_by_unresolved:${resolution.unresolved}`];
+}
+async function collectWorkflowTransitionWarnings(params) {
+  if (params.workflowEnforcement === "off" || params.typeWorkflows.length === 0 || !params.fieldFlags.status || params.options.status === void 0) {
+    return [];
+  }
+  const located = await locateItem(params.pmRoot, params.id, params.settings.id_prefix, params.settings.item_format, params.typeRegistry.type_to_folder);
+  if (!located) {
+    throw await buildItemNotFoundError(params.pmRoot, params.id, params.settings.id_prefix, params.typeRegistry.type_to_folder);
+  }
+  const { document } = await readLocatedItem(located, { schema: params.settings.schema });
+  const effectiveType = params.options.type !== void 0 ? resolveTypeName(params.options.type, params.typeRegistry) ?? params.options.type : document.metadata?.type ?? "";
+  const warning = enforceTypeWorkflowTransition({
+    enforcement: params.workflowEnforcement,
+    typeWorkflows: params.typeWorkflows,
+    statusRegistry: params.statusRegistry,
+    typeName: effectiveType,
+    fromStatus: document.metadata?.status ?? "",
+    toStatus: params.options.status
+  });
+  return warning ? [warning] : [];
+}
+async function routeCloseStatusUpdate(context) {
+  if (!context.fieldFlags.status) {
+    return void 0;
+  }
+  const targetStatus = normalizeStatusInput(context.options.status, context.statusRegistry);
+  if (targetStatus !== context.statusRegistry.close_status) {
+    return void 0;
+  }
+  const otherFieldKeys = Object.entries(context.fieldFlags).filter(([key, value]) => value && key !== "status" && key !== "closeReason").map(([key]) => key);
+  const routeWarnings = [];
+  let preChangedFields = [];
+  if (otherFieldKeys.length > 0) {
+    const preUpdate = await runUpdate(context.id, { ...context.options, status: void 0, closeReason: void 0, message: void 0 }, context.global);
+    preChangedFields = preUpdate.changed_fields;
+    routeWarnings.push(...preUpdate.warnings);
+  }
+  const explicitReason = typeof context.options.closeReason === "string" ? context.options.closeReason.trim() : "";
+  const fallbackMessage = typeof context.options.message === "string" ? context.options.message.trim() : "";
+  const closeReason = explicitReason || fallbackMessage || "Closed via pm update";
+  const closeResult = await runClose(context.id, closeReason, {
+    author: context.options.author,
+    message: context.options.message,
+    force: context.options.force
+  }, context.global);
+  const warnings = [
+    ...context.workflowTransitionWarnings,
+    ...routeWarnings,
+    ...closeResult.warnings,
+    "auto_routed_from_update_to_close"
+  ];
+  if (explicitReason.length === 0 && fallbackMessage.length === 0) {
+    warnings.push("close_reason_defaulted");
+  }
+  return {
+    item: closeResult.item,
+    changed_fields: [...preChangedFields, ...closeResult.changed_fields],
+    warnings
+  };
+}
+function applySimpleItemMutations(document, options, statusRegistry, changedFields) {
+  if (options.title !== void 0) {
+    document.metadata.title = options.title;
+    changedFields.push("title");
+  }
+  if (options.description !== void 0) {
+    document.metadata.description = options.description;
+    changedFields.push("description");
+  }
+  if (options.body !== void 0) {
+    document.body = options.body;
+    changedFields.push("body");
+  }
+  return normalizeStatusInput(document.metadata.status, statusRegistry) ?? document.metadata.status;
+}
+function applyStatusAndCloseReasonMutations(document, context, previousStatusNormalized, changedFields) {
+  if (context.options.status !== void 0) {
+    const status = parseStatus(context.options.status, context.statusRegistry);
+    document.metadata.status = status;
+    changedFields.push("status");
+  }
+  if (context.options.closeReason !== void 0 || context.clearFrontMatterKeys.has("close_reason")) {
+    if (context.clearFrontMatterKeys.has("close_reason")) {
+      delete document.metadata.close_reason;
+    } else {
+      const closeReason = context.options.closeReason?.trim() ?? "";
+      if (closeReason.length === 0) {
+        throw new PmCliError("--close-reason must not be empty", EXIT_CODE.USAGE);
+      }
+      document.metadata.close_reason = closeReason;
+    }
+    changedFields.push("close_reason");
+    return;
+  }
+  if (context.options.status !== void 0 && previousStatusNormalized === context.statusRegistry.close_status && document.metadata.status !== context.statusRegistry.canceled_status && document.metadata.close_reason !== void 0) {
+    delete document.metadata.close_reason;
+    changedFields.push("close_reason");
+  }
+}
+function applyPriorityTypeAndOptions(document, context, changedFields) {
+  let activeTypeName = resolveTypeName(document.metadata.type, context.typeRegistry) ?? document.metadata.type;
+  if (context.options.priority !== void 0) {
+    document.metadata.priority = ensurePriority(context.options.priority);
+    changedFields.push("priority");
+  }
+  if (context.options.type !== void 0) {
+    const resolvedTypeName = resolveTypeName(context.options.type, context.typeRegistry);
+    if (!resolvedTypeName) {
+      throw new PmCliError(buildInvalidTypeError(context.options.type, context.typeRegistry.types, resolveItemTypesFilePath(context.pmRoot, context.settings.schema)), EXIT_CODE.USAGE);
+    }
+    document.metadata.type = resolvedTypeName;
+    activeTypeName = resolvedTypeName;
+    changedFields.push("type");
+  }
+  enforceUpdateOptionsByType(activeTypeName, context.options, context.typeRegistry, context.runtimeFieldRegistry, context.extensionFieldNames);
+  applyTypeOptionMutation(document, context, activeTypeName, changedFields);
+  return activeTypeName;
+}
+function applyTypeOptionMutation(document, context, activeTypeName, changedFields) {
+  if (context.options.typeOption !== void 0 || context.clearFrontMatterKeys.has("type_options")) {
+    if (context.clearFrontMatterKeys.has("type_options")) {
+      delete document.metadata.type_options;
+    } else {
+      const parsedTypeOptions = parseTypeOptionEntries(context.options.typeOption ?? []);
+      const validation2 = validateTypeOptions(activeTypeName, parsedTypeOptions, context.typeRegistry);
+      if (validation2.errors.length > 0) {
+        throw new PmCliError(validation2.errors.join("; "), EXIT_CODE.USAGE);
+      }
+      document.metadata.type_options = validation2.normalized;
+    }
+    changedFields.push("type_options");
+    return;
+  }
+  if (context.options.type === void 0 || document.metadata.type_options === void 0) {
+    return;
+  }
+  const validation = validateTypeOptions(activeTypeName, document.metadata.type_options, context.typeRegistry);
+  if (validation.errors.length > 0) {
+    throw new PmCliError(`Current type options are incompatible with type "${activeTypeName}". ${validation.errors.join("; ")}. Use --clear-type-options to clear them.`, EXIT_CODE.USAGE);
+  }
+  document.metadata.type_options = validation.normalized;
+}
+function applyDependencyMutations(document, context, changedFields) {
+  if (context.options.dep === void 0 && context.options.depRemove === void 0 && !context.clearFrontMatterKeys.has("dependencies")) {
+    return;
+  }
+  let nextDependencies = context.clearFrontMatterKeys.has("dependencies") ? [] : [...document.metadata.dependencies ?? []];
+  if (context.dependencyUpdates.additions.length > 0) {
+    const seen = new Set(nextDependencies.map((entry) => dependencyKey(entry)));
+    for (const addition of context.dependencyUpdates.additions) {
+      const key = dependencyKey(addition);
+      if (!seen.has(key)) {
+        nextDependencies.push(addition);
+        seen.add(key);
+      }
+    }
+  }
+  if (context.dependencyRemovals.length > 0) {
+    nextDependencies = nextDependencies.filter((entry) => !context.dependencyRemovals.some((selector) => matchesDependencySelector(entry, selector)));
+  }
+  if (nextDependencies.length === 0) {
+    delete document.metadata.dependencies;
+  } else {
+    document.metadata.dependencies = nextDependencies;
+  }
+  changedFields.push("dependencies");
+}
+function applyLogCollectionMutations(document, context, changedFields) {
+  applyLogCollectionMutation(document, "comments", context.options.comment, context.commentUpdates.values, context.clearFrontMatterKeys, changedFields);
+  applyLogCollectionMutation(document, "notes", context.options.note, context.noteUpdates.values, context.clearFrontMatterKeys, changedFields);
+  applyLogCollectionMutation(document, "learnings", context.options.learning, context.learningUpdates.values, context.clearFrontMatterKeys, changedFields);
+}
+function applyLogCollectionMutation(document, key, optionValue, values, clearFrontMatterKeys, changedFields) {
+  if (optionValue === void 0 && !clearFrontMatterKeys.has(key)) {
+    return;
+  }
+  if (clearFrontMatterKeys.has(key) || !values || values.length === 0) {
+    delete document.metadata[key];
+  } else {
+    document.metadata[key] = [...document.metadata[key] ?? [], ...values];
+  }
+  changedFields.push(key);
+}
+function applyEvidenceCollectionMutations(document, context, changedFields) {
+  applyUniqueLinkedCollectionMutation(document, "files", context.options.file, context.fileUpdates.values, fileKey, context.clearFrontMatterKeys, changedFields);
+  applyTestCollectionMutation(document, context, changedFields);
+  applyUniqueLinkedCollectionMutation(document, "docs", context.options.doc, context.docUpdates.values, docKey, context.clearFrontMatterKeys, changedFields);
+}
+function applyUniqueLinkedCollectionMutation(document, key, optionValue, values, keyOf, clearFrontMatterKeys, changedFields) {
+  if (optionValue === void 0 && !clearFrontMatterKeys.has(key)) {
+    return;
+  }
+  if (clearFrontMatterKeys.has(key) || !values || values.length === 0) {
+    delete document.metadata[key];
+  } else {
+    const next = [...document.metadata[key] ?? []];
+    const seen = new Set(next.map((entry) => keyOf(entry)));
+    for (const entry of values) {
+      const keyValue = keyOf(entry);
+      if (!seen.has(keyValue)) {
+        next.push(entry);
+        seen.add(keyValue);
+      }
+    }
+    document.metadata[key] = next;
+  }
+  changedFields.push(key);
+}
+function applyTestCollectionMutation(document, context, changedFields) {
+  if (context.options.test === void 0 && !context.clearFrontMatterKeys.has("tests")) {
+    return;
+  }
+  if (context.clearFrontMatterKeys.has("tests") && context.options.replaceTests === true) {
+    document.metadata.tests = dedupeLinkedTests(context.testUpdates.values) ?? [];
+  } else if (context.clearFrontMatterKeys.has("tests") || !context.testUpdates.values || context.testUpdates.values.length === 0) {
+    delete document.metadata.tests;
+  } else {
+    document.metadata.tests = dedupeLinkedTests([...document.metadata.tests ?? [], ...context.testUpdates.values]);
+  }
+  if (document.metadata.tests !== void 0 && document.metadata.tests.length === 0) {
+    delete document.metadata.tests;
+  }
+  changedFields.push("tests");
+}
+function dedupeLinkedTests(values) {
+  if (!values || values.length === 0) {
+    return void 0;
+  }
+  const next = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of values) {
+    const key = testKey(entry);
+    if (!seen.has(key)) {
+      next.push(entry);
+      seen.add(key);
+    }
+  }
+  return next;
+}
+function applyTagsAndPlanningMutations(document, context, scalarMutationContext) {
+  const addTagsValues = context.options.addTags;
+  const removeTagsValues = context.options.removeTags;
+  const hasAdditiveTagMutation = Array.isArray(addTagsValues) && addTagsValues.length > 0 || Array.isArray(removeTagsValues) && removeTagsValues.length > 0;
+  if (context.options.tags !== void 0 || context.clearFrontMatterKeys.has("tags") || hasAdditiveTagMutation) {
+    const baseTags = context.clearFrontMatterKeys.has("tags") ? [] : context.options.tags !== void 0 ? parseTags(context.options.tags) : Array.isArray(document.metadata.tags) ? [...document.metadata.tags] : [];
+    document.metadata.tags = applyTagRemovals(mergeAdditiveTags(baseTags, addTagsValues), removeTagsValues);
+    scalarMutationContext.changedFields.push("tags");
+  }
+  applyUpdateScalarMutations(UPDATE_POST_TAG_SCALAR_MUTATIONS, context.options, scalarMutationContext);
+  applyOrderMutation(document, context, scalarMutationContext.changedFields);
+}
+function applyOrderMutation(document, context, changedFields) {
+  const orderRaw = context.options.order ?? context.options.rank;
+  if (orderRaw === void 0 && !context.clearFrontMatterKeys.has("order")) {
+    return;
+  }
+  if (context.clearFrontMatterKeys.has("order")) {
+    delete document.metadata.order;
+  } else {
+    const parsedOrder = parseOptionalNumber(orderRaw ?? "", "order");
+    if (!Number.isInteger(parsedOrder)) {
+      throw new PmCliError("Order must be an integer", EXIT_CODE.USAGE);
+    }
+    document.metadata.order = parsedOrder;
+  }
+  changedFields.push("order");
+}
+function applyOwnershipAndIssueMutations(document, context, scalarMutationContext, warnings) {
+  applyAssigneeMutation(document, context, scalarMutationContext.changedFields);
+  applyParentMutation(document, context, scalarMutationContext.changedFields);
+  applyUpdateScalarMutations(UPDATE_STAKEHOLDER_SCALAR_MUTATIONS, context.options, scalarMutationContext);
+  applySprintReleaseMutation(document, context, "sprint", warnings, scalarMutationContext.changedFields);
+  applySprintReleaseMutation(document, context, "release", warnings, scalarMutationContext.changedFields);
+  applyBlockedByMutation(document, context, scalarMutationContext.changedFields);
+  applyUpdateScalarMutations(UPDATE_ISSUE_SCALAR_MUTATIONS, context.options, scalarMutationContext);
+}
+function applyAssigneeMutation(document, context, changedFields) {
+  if (context.options.assignee === void 0 && !context.clearFrontMatterKeys.has("assignee")) {
+    return;
+  }
+  if (context.clearFrontMatterKeys.has("assignee")) {
+    delete document.metadata.assignee;
+  } else {
+    const assignee = context.options.assignee?.trim() ?? "";
+    if (assignee === "") {
+      throw new PmCliError("--assignee must not be empty. Use --unset assignee to clear it.", EXIT_CODE.USAGE);
+    }
+    document.metadata.assignee = assignee;
+  }
+  changedFields.push("assignee");
+}
+function applyParentMutation(document, context, changedFields) {
+  if (context.options.parent === void 0 && !context.clearFrontMatterKeys.has("parent")) {
+    return;
+  }
+  if (context.clearFrontMatterKeys.has("parent")) {
+    delete document.metadata.parent;
+  } else {
+    document.metadata.parent = context.resolvedParentValue ?? "";
+  }
+  changedFields.push("parent");
+}
+function applySprintReleaseMutation(document, context, key, warnings, changedFields) {
+  if (context.options[key] === void 0 && !context.clearFrontMatterKeys.has(key)) {
+    return;
+  }
+  if (context.clearFrontMatterKeys.has(key)) {
+    delete document.metadata[key];
+  } else {
+    const validation = validateSprintOrReleaseValue(key, context.options[key] ?? "", context.settings.validation.sprint_release_format);
+    document.metadata[key] = validation.value;
+    warnings.push(...validation.warnings);
+  }
+  changedFields.push(key);
+}
+function applyBlockedByMutation(document, context, changedFields) {
+  if (context.options.blockedBy === void 0 && !context.clearFrontMatterKeys.has("blocked_by")) {
+    return;
+  }
+  if (context.clearFrontMatterKeys.has("blocked_by")) {
+    delete document.metadata.blocked_by;
+  } else {
+    document.metadata.blocked_by = context.options.blockedBy?.trim() ?? "";
+  }
+  changedFields.push("blocked_by");
+  applyBlockedByDependencyEdge(document.metadata, context.resolvedBlockedByDependencyId, context.nowIso, context.author, changedFields);
+}
+function applyScheduleMutations(document, context, changedFields) {
+  if (context.options.reminder !== void 0 || context.clearFrontMatterKeys.has("reminders")) {
+    if (context.clearFrontMatterKeys.has("reminders")) {
+      delete document.metadata.reminders;
+    } else {
+      document.metadata.reminders = parseReminderEntries(context.options.reminder ?? [], context.nowValue, { valueMode: "trimmed" });
+    }
+    changedFields.push("reminders");
+  }
+  if (context.options.event !== void 0 || context.clearFrontMatterKeys.has("events")) {
+    if (context.clearFrontMatterKeys.has("events")) {
+      delete document.metadata.events;
+    } else {
+      document.metadata.events = parseEventEntries(context.options.event ?? [], context.nowValue, {
+        allDayEmptyGuard: "truthy",
+        recurrenceEmptyNumericGuard: "truthy"
+      });
+    }
+    changedFields.push("events");
+  }
+}
+function applyRuntimeAndRegisteredFieldMutations(metadataRecord, context, changedFields) {
+  clearDynamicFields(metadataRecord, context.runtimeFieldRegistry.definitions.map((definition) => definition.metadata_key), context.clearFrontMatterKeys, changedFields);
+  clearDynamicFields(metadataRecord, context.extensionFieldNames, context.clearFrontMatterKeys, changedFields);
+  for (const [fieldKey, fieldValue] of Object.entries(context.runtimeFieldUpdates)) {
+    if (context.clearFrontMatterKeys.has(fieldKey)) {
+      const fieldFlag = fieldKey.replaceAll("_", "-");
+      const definition = context.runtimeFieldRegistry.definitions.find((candidate) => candidate.metadata_key === fieldKey);
+      const updateFlag = definition?.cli_flag ?? fieldFlag;
+      throw new PmCliError(`Cannot combine --unset ${fieldFlag} with --${updateFlag}`, EXIT_CODE.USAGE);
+    }
+    if (stableValueEquals(metadataRecord[fieldKey], fieldValue)) {
+      continue;
+    }
+    metadataRecord[fieldKey] = fieldValue;
+    changedFields.push(fieldKey);
+  }
+  const registeredItemFieldUpdates = parseRegisteredItemFieldAssignments(context.options.field, context.extensionRegistrations);
+  for (const fieldKey of Object.keys(registeredItemFieldUpdates)) {
+    if (context.clearFrontMatterKeys.has(fieldKey)) {
+      throw new PmCliError(`Cannot combine --unset ${fieldKey.replaceAll("_", "-")} with --field ${fieldKey}=...`, EXIT_CODE.USAGE);
+    }
+  }
+  for (const [fieldKey, fieldValue] of Object.entries(registeredItemFieldUpdates)) {
+    if (!stableValueEquals(metadataRecord[fieldKey], fieldValue)) {
+      metadataRecord[fieldKey] = fieldValue;
+      changedFields.push(fieldKey);
+    }
+  }
+}
+function clearDynamicFields(metadataRecord, fieldKeys, clearFrontMatterKeys, changedFields) {
+  for (const fieldKey of fieldKeys) {
+    if (!clearFrontMatterKeys.has(fieldKey) || metadataRecord[fieldKey] === void 0) {
+      continue;
+    }
+    delete metadataRecord[fieldKey];
+    changedFields.push(fieldKey);
+  }
+}
+function mutateUpdateDocument(document, context) {
+  const changedFields = [];
+  const warnings = [];
+  const previousStatusNormalized = applySimpleItemMutations(document, context.options, context.statusRegistry, changedFields);
+  const metadataRecord = toItemRecord(document.metadata);
+  const scalarMutationContext = {
+    metadataRecord,
+    clearFrontMatterKeys: context.clearFrontMatterKeys,
+    changedFields,
+    nowValue: context.nowValue
+  };
+  applyStatusAndCloseReasonMutations(document, context, previousStatusNormalized, changedFields);
+  applyPriorityTypeAndOptions(document, context, changedFields);
+  applyDependencyMutations(document, context, changedFields);
+  applyLogCollectionMutations(document, context, changedFields);
+  applyEvidenceCollectionMutations(document, context, changedFields);
+  applyTagsAndPlanningMutations(document, context, scalarMutationContext);
+  applyOwnershipAndIssueMutations(document, context, scalarMutationContext, warnings);
+  if (normalizeStatusInput(document.metadata.status, context.statusRegistry) === context.statusRegistry.canceled_status && document.metadata.assignee !== void 0) {
+    delete document.metadata.assignee;
+    if (!changedFields.includes("assignee")) {
+      changedFields.push("assignee");
+    }
+  }
+  applyScheduleMutations(document, context, changedFields);
+  applyRuntimeAndRegisteredFieldMutations(metadataRecord, context, changedFields);
+  try {
+    applyRegisteredItemFieldDefaultsAndValidation(metadataRecord, context.extensionRegistrations, { skipDefaultFields: context.clearFrontMatterKeys });
+  } catch (error) {
+    throw new PmCliError(error instanceof Error ? error.message : "Invalid extension item field values", EXIT_CODE.USAGE);
+  }
+  return { changedFields, warnings };
+}
+async function runUpdate(id, options, global) {
+  options = await resolveStdinUpdateOptions(options);
+  const pmRoot = resolvePmRoot(process.cwd(), global.path);
+  await assertUpdateTrackerInitialized(pmRoot);
+  const settings = await readSettings(pmRoot);
+  const statusRegistry = resolveRuntimeStatusRegistry(settings.schema);
+  const runtimeFieldRegistry = resolveRuntimeFieldRegistry(settings.schema);
+  const extensionRegistrations = getActiveExtensionRegistrations();
+  const extensionFieldNames = collectRegisteredItemFieldNames(extensionRegistrations);
+  const typeRegistry = resolveItemTypeRegistry(settings, extensionRegistrations);
+  const workflowEnforcement = settings.governance.workflow_enforcement ?? "off";
+  const typeWorkflows = workflowEnforcement === "off" ? [] : resolveTypeWorkflows(settings.schema);
+  const parentReferencePolicy = settings.validation.parent_reference;
+  const unsetTargets = parseUpdateUnsetTargets(options.unset, runtimeFieldRegistry, extensionFieldNames);
+  const clearOptionKeys = new Set(unsetTargets.optionKeys);
+  const clearFrontMatterKeys = new Set(unsetTargets.frontMatterKeys);
+  validateReplaceOptions(options);
+  applyClearCollectionDefinitions({
+    definitions: buildClearCollectionDefinitions(options),
+    options,
+    clearOptionKeys,
+    clearFrontMatterKeys
+  });
+  enforceAllowAuditUpdateScope(id, options, clearFrontMatterKeys);
+  rejectUnsetScalarConflicts(options, unsetTargets);
+  rejectLegacyScalarTokens(options);
   const author = toAuthor(options.author, settings.author_default);
   const nowValue = /* @__PURE__ */ new Date();
   const nowIso = nowValue.toISOString();
@@ -1040,166 +1525,47 @@ async function runUpdate(id, options, global) {
   const fileUpdates = parseFiles(options.file);
   const testUpdates = parseTests(options.test);
   const docUpdates = parseDocs(options.doc);
-  const parentReferenceWarnings = [];
   const workflowTransitionWarnings = [];
-  let resolvedParentValue;
-  if (options.parent !== void 0 && !unsetTargets.frontMatterKeys.has("parent")) {
-    resolvedParentValue = normalizeParentReferenceValue(options.parent);
-    const parentLocated = await locateItem(pmRoot, resolvedParentValue, settings.id_prefix, settings.item_format, typeRegistry.type_to_folder);
-    if (!parentLocated) {
-      const normalizedParentId = normalizeItemId(resolvedParentValue, settings.id_prefix);
-      parentReferenceWarnings.push(...validateMissingParentReference(normalizedParentId, parentReferencePolicy).warnings);
-    }
-  }
+  const parentReference = await resolveParentReferenceForUpdate({
+    options,
+    unsetTargets,
+    pmRoot,
+    settings,
+    typeRegistry,
+    parentReferencePolicy
+  });
   const blockedByResolution = await resolveBlockedByDependencyTarget(options.blockedBy, clearFrontMatterKeys.has("blocked_by"), pmRoot, settings.id_prefix, settings.item_format, typeRegistry.type_to_folder);
   const resolvedBlockedByDependencyId = blockedByResolution.id;
-  if (blockedByResolution.unresolved !== void 0) {
-    parentReferenceWarnings.push(`blocked_by_unresolved:${blockedByResolution.unresolved}`);
-  }
+  const parentReferenceWarnings = [...parentReference.warnings, ...blockedByResolutionWarnings(blockedByResolution)];
   const runtimeFieldUpdates = collectRuntimeUpdateFieldValues(options, runtimeFieldRegistry, options.runtimeFieldCommands);
-  const fieldFlags = {
-    title: options.title !== void 0,
-    description: options.description !== void 0,
-    body: options.body !== void 0,
-    status: options.status !== void 0,
-    closeReason: options.closeReason !== void 0,
-    priority: options.priority !== void 0,
-    type: options.type !== void 0,
-    tags: options.tags !== void 0,
-    addTags: Array.isArray(options.addTags) && options.addTags.length > 0,
-    removeTags: Array.isArray(options.removeTags) && options.removeTags.length > 0,
-    deadline: options.deadline !== void 0,
-    estimatedMinutes: options.estimatedMinutes !== void 0,
-    acceptanceCriteria: options.acceptanceCriteria !== void 0,
-    definitionOfReady: options.definitionOfReady !== void 0,
-    order: options.order !== void 0,
-    rank: options.rank !== void 0,
-    goal: options.goal !== void 0,
-    objective: options.objective !== void 0,
-    value: options.value !== void 0,
-    impact: options.impact !== void 0,
-    outcome: options.outcome !== void 0,
-    whyNow: options.whyNow !== void 0,
-    assignee: options.assignee !== void 0,
-    parent: options.parent !== void 0,
-    reviewer: options.reviewer !== void 0,
-    risk: options.risk !== void 0,
-    confidence: options.confidence !== void 0,
-    sprint: options.sprint !== void 0,
-    release: options.release !== void 0,
-    blockedBy: options.blockedBy !== void 0,
-    blockedReason: options.blockedReason !== void 0,
-    unblockNote: options.unblockNote !== void 0,
-    reporter: options.reporter !== void 0,
-    severity: options.severity !== void 0,
-    environment: options.environment !== void 0,
-    reproSteps: options.reproSteps !== void 0,
-    resolution: options.resolution !== void 0,
-    expectedResult: options.expectedResult !== void 0,
-    actualResult: options.actualResult !== void 0,
-    affectedVersion: options.affectedVersion !== void 0,
-    fixedVersion: options.fixedVersion !== void 0,
-    component: options.component !== void 0,
-    regression: options.regression !== void 0,
-    customerImpact: options.customerImpact !== void 0,
-    dep: options.dep !== void 0,
-    depRemove: options.depRemove !== void 0,
-    replaceDeps: options.replaceDeps === true,
-    comment: options.comment !== void 0,
-    note: options.note !== void 0,
-    learning: options.learning !== void 0,
-    file: options.file !== void 0,
-    test: options.test !== void 0,
-    replaceTests: options.replaceTests === true,
-    doc: options.doc !== void 0,
-    reminder: options.reminder !== void 0,
-    event: options.event !== void 0,
-    typeOption: options.typeOption !== void 0,
-    field: options.field !== void 0,
-    unset: options.unset !== void 0 && options.unset.length > 0,
-    clearDeps: options.clearDeps === true,
-    clearComments: options.clearComments === true,
-    clearNotes: options.clearNotes === true,
-    clearLearnings: options.clearLearnings === true,
-    clearFiles: options.clearFiles === true,
-    clearTests: options.clearTests === true,
-    clearDocs: options.clearDocs === true,
-    clearReminders: options.clearReminders === true,
-    clearEvents: options.clearEvents === true,
-    clearTypeOptions: options.clearTypeOptions === true,
-    runtimeFields: Object.keys(runtimeFieldUpdates).length > 0
-  };
+  const fieldFlags = buildUpdateFieldFlags(options, runtimeFieldUpdates);
   const changedFlags = Object.values(fieldFlags).some(Boolean);
   if (!changedFlags) {
-    const located = await locateItem(pmRoot, id, settings.id_prefix, settings.item_format, typeRegistry.type_to_folder);
-    if (!located) {
-      throw await buildItemNotFoundError(pmRoot, id, settings.id_prefix, typeRegistry.type_to_folder);
-    }
-    const { document } = await readLocatedItem(located, { schema: settings.schema });
-    return {
-      item: toItemRecord(document.metadata),
-      changed_fields: [],
-      warnings: ["noop_no_update_fields"]
-    };
-  }
-  if (workflowEnforcement !== "off" && typeWorkflows.length > 0 && fieldFlags.status && options.status !== void 0) {
-    const located = await locateItem(pmRoot, id, settings.id_prefix, settings.item_format, typeRegistry.type_to_folder);
-    if (!located) {
-      throw await buildItemNotFoundError(pmRoot, id, settings.id_prefix, typeRegistry.type_to_folder);
-    }
-    const { document } = await readLocatedItem(located, { schema: settings.schema });
-    const effectiveType = options.type !== void 0 ? resolveTypeName(options.type, typeRegistry) ?? options.type : document.metadata?.type ?? "";
-    const warning = enforceTypeWorkflowTransition({
-      enforcement: workflowEnforcement,
-      typeWorkflows,
-      statusRegistry,
-      typeName: effectiveType,
-      fromStatus: document.metadata?.status ?? "",
-      toStatus: options.status ?? ""
-    });
-    if (warning) {
-      workflowTransitionWarnings.push(warning);
-    }
-  }
-  if (fieldFlags.status) {
-    const targetStatus = normalizeStatusInput(options.status, statusRegistry);
-    if (targetStatus === statusRegistry.close_status) {
-      const otherFieldKeys = Object.entries(fieldFlags).filter(([key, value]) => value && key !== "status" && key !== "closeReason").map(([key]) => key);
-      const routeWarnings = [];
-      let preChangedFields = [];
-      if (otherFieldKeys.length > 0) {
-        const preUpdate = await runUpdate(id, { ...options, status: void 0, closeReason: void 0, message: void 0 }, global);
-        preChangedFields = preUpdate.changed_fields;
-        routeWarnings.push(...preUpdate.warnings);
-      }
-      const explicitReason = typeof options.closeReason === "string" ? options.closeReason.trim() : "";
-      const fallbackMessage = typeof options.message === "string" ? options.message.trim() : "";
-      const closeReason = explicitReason || fallbackMessage || "Closed via pm update";
-      const reasonDefaulted = explicitReason.length === 0 && fallbackMessage.length === 0;
-      const closeResult = await runClose(id, closeReason, {
-        author: options.author,
-        message: options.message,
-        force: options.force
-      }, global);
-      const warnings = [
-        ...workflowTransitionWarnings,
-        ...routeWarnings,
-        ...closeResult.warnings,
-        "auto_routed_from_update_to_close"
-      ];
-      if (reasonDefaulted) {
-        warnings.push("close_reason_defaulted");
-      }
-      return {
-        item: closeResult.item,
-        changed_fields: [...preChangedFields, ...closeResult.changed_fields],
-        warnings
-      };
-    }
-  }
-  if (options.order !== void 0 && options.rank !== void 0 && options.order !== options.rank) {
-    throw new PmCliError("--order and --rank must match when both are provided", EXIT_CODE.USAGE);
+    return buildNoopUpdateResult({ pmRoot, id, settings, typeRegistry });
+  }
+  workflowTransitionWarnings.push(...await collectWorkflowTransitionWarnings({
+    options,
+    fieldFlags,
+    workflowEnforcement,
+    typeWorkflows,
+    statusRegistry,
+    typeRegistry,
+    pmRoot,
+    id,
+    settings
+  }));
+  const routedClose = await routeCloseStatusUpdate({
+    options,
+    fieldFlags,
+    statusRegistry,
+    workflowTransitionWarnings,
+    global,
+    id
+  });
+  if (routedClose) {
+    return routedClose;
   }
+  assertMatchingOrderRank(options);
   const result = await mutateItem({
     pmRoot,
     settings,
@@ -1212,347 +1578,31 @@ async function runUpdate(id, options, global) {
     bypassAssigneeConflict: options.allowAuditUpdate === true || options.allowAuditDepUpdate === true,
     extensionFieldNames,
     mutate(document) {
-      const changedFields = [];
-      const warnings = [];
-      let activeTypeName = resolveTypeName(document.metadata.type, typeRegistry) ?? document.metadata.type;
-      const metadataRecord = toItemRecord(document.metadata);
-      const scalarMutationContext = {
-        metadataRecord,
+      return mutateUpdateDocument(document, {
+        options,
+        settings,
+        typeRegistry,
+        statusRegistry,
+        runtimeFieldRegistry,
+        extensionRegistrations,
+        extensionFieldNames,
         clearFrontMatterKeys,
-        changedFields,
-        nowValue
-      };
-      if (options.title !== void 0) {
-        document.metadata.title = options.title;
-        changedFields.push("title");
-      }
-      if (options.description !== void 0) {
-        document.metadata.description = options.description;
-        changedFields.push("description");
-      }
-      if (options.body !== void 0) {
-        document.body = options.body;
-        changedFields.push("body");
-      }
-      const previousStatus = document.metadata.status;
-      const previousStatusNormalized = normalizeStatusInput(previousStatus, statusRegistry) ?? previousStatus;
-      if (options.status !== void 0) {
-        const status = parseStatus(options.status, statusRegistry);
-        document.metadata.status = status;
-        if (status === statusRegistry.canceled_status) {
-          delete document.metadata.assignee;
-        }
-        changedFields.push("status");
-      }
-      if (options.closeReason !== void 0 || clearFrontMatterKeys.has("close_reason")) {
-        if (clearFrontMatterKeys.has("close_reason")) {
-          delete document.metadata.close_reason;
-        } else {
-          const closeReason = options.closeReason?.trim() ?? "";
-          if (closeReason.length === 0) {
-            throw new PmCliError("--close-reason must not be empty", EXIT_CODE.USAGE);
-          }
-          document.metadata.close_reason = closeReason;
-        }
-        changedFields.push("close_reason");
-      } else if (options.status !== void 0 && previousStatusNormalized === statusRegistry.close_status && document.metadata.status !== statusRegistry.canceled_status && document.metadata.close_reason !== void 0) {
-        delete document.metadata.close_reason;
-        changedFields.push("close_reason");
-      }
-      if (options.priority !== void 0) {
-        document.metadata.priority = ensurePriority(options.priority);
-        changedFields.push("priority");
-      }
-      if (options.type !== void 0) {
-        const resolvedTypeName = resolveTypeName(options.type, typeRegistry);
-        if (!resolvedTypeName) {
-          throw new PmCliError(buildInvalidTypeError(options.type, typeRegistry.types, resolveItemTypesFilePath(pmRoot, settings.schema)), EXIT_CODE.USAGE);
-        }
-        document.metadata.type = resolvedTypeName;
-        activeTypeName = resolvedTypeName;
-        changedFields.push("type");
-      }
-      enforceUpdateOptionsByType(activeTypeName, options, typeRegistry, extensionFieldNames);
-      if (options.typeOption !== void 0 || clearFrontMatterKeys.has("type_options")) {
-        if (clearFrontMatterKeys.has("type_options")) {
-          delete document.metadata.type_options;
-        } else {
-          const parsedTypeOptions = parseTypeOptionEntries(options.typeOption ?? []);
-          const validation = validateTypeOptions(activeTypeName, parsedTypeOptions, typeRegistry);
-          if (validation.errors.length > 0) {
-            throw new PmCliError(validation.errors.join("; "), EXIT_CODE.USAGE);
-          }
-          document.metadata.type_options = validation.normalized;
-        }
-        changedFields.push("type_options");
-      } else if (options.type !== void 0 && document.metadata.type_options !== void 0) {
-        const validation = validateTypeOptions(activeTypeName, document.metadata.type_options, typeRegistry);
-        if (validation.errors.length > 0) {
-          throw new PmCliError(`Current type options are incompatible with type "${activeTypeName}". ${validation.errors.join("; ")}. Use --clear-type-options to clear them.`, EXIT_CODE.USAGE);
-        }
-        document.metadata.type_options = validation.normalized;
-      }
-      if (options.dep !== void 0 || options.depRemove !== void 0 || clearFrontMatterKeys.has("dependencies")) {
-        let nextDependencies = clearFrontMatterKeys.has("dependencies") ? [] : [...document.metadata.dependencies ?? []];
-        if (dependencyUpdates.additions.length > 0) {
-          const seen = new Set(nextDependencies.map((entry) => dependencyKey(entry)));
-          for (const addition of dependencyUpdates.additions) {
-            const key = dependencyKey(addition);
-            if (seen.has(key)) {
-              continue;
-            }
-            nextDependencies.push(addition);
-            seen.add(key);
-          }
-        }
-        if (dependencyRemovals.length > 0) {
-          nextDependencies = nextDependencies.filter((entry) => !dependencyRemovals.some((selector) => matchesDependencySelector(entry, selector)));
-        }
-        if (nextDependencies.length === 0) {
-          delete document.metadata.dependencies;
-        } else {
-          document.metadata.dependencies = nextDependencies;
-        }
-        changedFields.push("dependencies");
-      }
-      if (options.comment !== void 0 || clearFrontMatterKeys.has("comments")) {
-        if (clearFrontMatterKeys.has("comments") || !commentUpdates.values || commentUpdates.values.length === 0) {
-          delete document.metadata.comments;
-        } else {
-          document.metadata.comments = [...document.metadata.comments ?? [], ...commentUpdates.values];
-        }
-        changedFields.push("comments");
-      }
-      if (options.note !== void 0 || clearFrontMatterKeys.has("notes")) {
-        if (clearFrontMatterKeys.has("notes") || !noteUpdates.values || noteUpdates.values.length === 0) {
-          delete document.metadata.notes;
-        } else {
-          document.metadata.notes = [...document.metadata.notes ?? [], ...noteUpdates.values];
-        }
-        changedFields.push("notes");
-      }
-      if (options.learning !== void 0 || clearFrontMatterKeys.has("learnings")) {
-        if (clearFrontMatterKeys.has("learnings") || !learningUpdates.values || learningUpdates.values.length === 0) {
-          delete document.metadata.learnings;
-        } else {
-          document.metadata.learnings = [...document.metadata.learnings ?? [], ...learningUpdates.values];
-        }
-        changedFields.push("learnings");
-      }
-      if (options.file !== void 0 || clearFrontMatterKeys.has("files")) {
-        if (clearFrontMatterKeys.has("files") || !fileUpdates.values || fileUpdates.values.length === 0) {
-          delete document.metadata.files;
-        } else {
-          const nextFiles = [...document.metadata.files ?? []];
-          const seen = new Set(nextFiles.map((entry) => fileKey(entry)));
-          for (const entry of fileUpdates.values) {
-            const key = fileKey(entry);
-            if (seen.has(key)) {
-              continue;
-            }
-            nextFiles.push(entry);
-            seen.add(key);
-          }
-          document.metadata.files = nextFiles;
-        }
-        changedFields.push("files");
-      }
-      if (options.test !== void 0 || clearFrontMatterKeys.has("tests")) {
-        if (clearFrontMatterKeys.has("tests") && options.replaceTests === true) {
-          if (!testUpdates.values || testUpdates.values.length === 0) {
-            delete document.metadata.tests;
-          } else {
-            const replacementTests = [];
-            const seen = /* @__PURE__ */ new Set();
-            for (const entry of testUpdates.values) {
-              const key = testKey(entry);
-              if (seen.has(key)) {
-                continue;
-              }
-              replacementTests.push(entry);
-              seen.add(key);
-            }
-            document.metadata.tests = replacementTests;
-          }
-        } else if (clearFrontMatterKeys.has("tests") || !testUpdates.values || testUpdates.values.length === 0) {
-          delete document.metadata.tests;
-        } else {
-          const nextTests = [...document.metadata.tests ?? []];
-          const seen = new Set(nextTests.map((entry) => testKey(entry)));
-          for (const entry of testUpdates.values) {
-            const key = testKey(entry);
-            if (seen.has(key)) {
-              continue;
-            }
-            nextTests.push(entry);
-            seen.add(key);
-          }
-          document.metadata.tests = nextTests;
-        }
-        changedFields.push("tests");
-      }
-      if (options.doc !== void 0 || clearFrontMatterKeys.has("docs")) {
-        if (clearFrontMatterKeys.has("docs") || !docUpdates.values || docUpdates.values.length === 0) {
-          delete document.metadata.docs;
-        } else {
-          const nextDocs = [...document.metadata.docs ?? []];
-          const seen = new Set(nextDocs.map((entry) => docKey(entry)));
-          for (const entry of docUpdates.values) {
-            const key = docKey(entry);
-            if (seen.has(key)) {
-              continue;
-            }
-            nextDocs.push(entry);
-            seen.add(key);
-          }
-          document.metadata.docs = nextDocs;
-        }
-        changedFields.push("docs");
-      }
-      const addTagsValues = options.addTags;
-      const removeTagsValues = options.removeTags;
-      const hasAdditiveTagMutation = Array.isArray(addTagsValues) && addTagsValues.length > 0 || Array.isArray(removeTagsValues) && removeTagsValues.length > 0;
-      if (options.tags !== void 0 || clearFrontMatterKeys.has("tags") || hasAdditiveTagMutation) {
-        const baseTags = clearFrontMatterKeys.has("tags") ? [] : options.tags !== void 0 ? parseTags(options.tags) : Array.isArray(document.metadata.tags) ? [...document.metadata.tags] : [];
-        const withAdditions = mergeAdditiveTags(baseTags, addTagsValues);
-        const finalTags = applyTagRemovals(withAdditions, removeTagsValues);
-        document.metadata.tags = finalTags;
-        changedFields.push("tags");
-      }
-      applyUpdateScalarMutations(UPDATE_POST_TAG_SCALAR_MUTATIONS, options, scalarMutationContext);
-      const orderRaw = options.order ?? options.rank;
-      if (orderRaw !== void 0 || clearFrontMatterKeys.has("order")) {
-        if (clearFrontMatterKeys.has("order")) {
-          delete document.metadata.order;
-        } else {
-          const parsedOrder = parseOptionalNumber(orderRaw ?? "", "order");
-          if (!Number.isInteger(parsedOrder)) {
-            throw new PmCliError("Order must be an integer", EXIT_CODE.USAGE);
-          }
-          document.metadata.order = parsedOrder;
-        }
-        changedFields.push("order");
-      }
-      if (options.assignee !== void 0 || clearFrontMatterKeys.has("assignee")) {
-        if (clearFrontMatterKeys.has("assignee")) {
-          delete document.metadata.assignee;
-        } else {
-          const assignee = options.assignee?.trim() ?? "";
-          if (assignee === "") {
-            throw new PmCliError("--assignee must not be empty. Use --unset assignee to clear it.", EXIT_CODE.USAGE);
-          }
-          document.metadata.assignee = assignee;
-        }
-        changedFields.push("assignee");
-      }
-      if (options.parent !== void 0 || clearFrontMatterKeys.has("parent")) {
-        if (clearFrontMatterKeys.has("parent")) {
-          delete document.metadata.parent;
-        } else {
-          document.metadata.parent = resolvedParentValue ?? "";
-        }
-        changedFields.push("parent");
-      }
-      applyUpdateScalarMutations(UPDATE_STAKEHOLDER_SCALAR_MUTATIONS, options, scalarMutationContext);
-      if (options.sprint !== void 0 || clearFrontMatterKeys.has("sprint")) {
-        if (clearFrontMatterKeys.has("sprint")) {
-          delete document.metadata.sprint;
-        } else {
-          const sprintValidation = validateSprintOrReleaseValue("sprint", options.sprint ?? "", sprintReleasePolicy);
-          document.metadata.sprint = sprintValidation.value;
-          warnings.push(...sprintValidation.warnings);
-        }
-        changedFields.push("sprint");
-      }
-      if (options.release !== void 0 || clearFrontMatterKeys.has("release")) {
-        if (clearFrontMatterKeys.has("release")) {
-          delete document.metadata.release;
-        } else {
-          const releaseValidation = validateSprintOrReleaseValue("release", options.release ?? "", sprintReleasePolicy);
-          document.metadata.release = releaseValidation.value;
-          warnings.push(...releaseValidation.warnings);
-        }
-        changedFields.push("release");
-      }
-      if (options.blockedBy !== void 0 || clearFrontMatterKeys.has("blocked_by")) {
-        if (clearFrontMatterKeys.has("blocked_by")) {
-          delete document.metadata.blocked_by;
-        } else {
-          document.metadata.blocked_by = options.blockedBy?.trim() ?? "";
-        }
-        changedFields.push("blocked_by");
-        applyBlockedByDependencyEdge(document.metadata, resolvedBlockedByDependencyId, nowIso, author, changedFields);
-      }
-      applyUpdateScalarMutations(UPDATE_ISSUE_SCALAR_MUTATIONS, options, scalarMutationContext);
-      if (options.reminder !== void 0 || clearFrontMatterKeys.has("reminders")) {
-        if (clearFrontMatterKeys.has("reminders")) {
-          delete document.metadata.reminders;
-        } else {
-          document.metadata.reminders = parseReminderEntries(options.reminder ?? [], nowValue, { valueMode: "trimmed" });
-        }
-        changedFields.push("reminders");
-      }
-      if (options.event !== void 0 || clearFrontMatterKeys.has("events")) {
-        if (clearFrontMatterKeys.has("events")) {
-          delete document.metadata.events;
-        } else {
-          document.metadata.events = parseEventEntries(options.event ?? [], nowValue, {
-            allDayEmptyGuard: "truthy",
-            recurrenceEmptyNumericGuard: "truthy"
-          });
-        }
-        changedFields.push("events");
-      }
-      for (const definition of runtimeFieldRegistry.definitions) {
-        if (!clearFrontMatterKeys.has(definition.metadata_key)) {
-          continue;
-        }
-        if (metadataRecord[definition.metadata_key] === void 0) {
-          continue;
-        }
-        delete metadataRecord[definition.metadata_key];
-        changedFields.push(definition.metadata_key);
-      }
-      for (const fieldKey of extensionFieldNames) {
-        if (!clearFrontMatterKeys.has(fieldKey)) {
-          continue;
-        }
-        if (metadataRecord[fieldKey] === void 0) {
-          continue;
-        }
-        delete metadataRecord[fieldKey];
-        changedFields.push(fieldKey);
-      }
-      for (const [fieldKey, fieldValue] of Object.entries(runtimeFieldUpdates)) {
-        if (clearFrontMatterKeys.has(fieldKey)) {
-          continue;
-        }
-        if (stableValueEquals(metadataRecord[fieldKey], fieldValue)) {
-          continue;
-        }
-        metadataRecord[fieldKey] = fieldValue;
-        changedFields.push(fieldKey);
-      }
-      const registeredItemFieldUpdates = parseRegisteredItemFieldAssignments(options.field, extensionRegistrations);
-      for (const fieldKey of Object.keys(registeredItemFieldUpdates)) {
-        if (!clearFrontMatterKeys.has(fieldKey)) {
-          continue;
-        }
-        throw new PmCliError(`Cannot combine --unset ${fieldKey.replaceAll("_", "-")} with --field ${fieldKey}=...`, EXIT_CODE.USAGE);
-      }
-      for (const [fieldKey, fieldValue] of Object.entries(registeredItemFieldUpdates)) {
-        if (stableValueEquals(metadataRecord[fieldKey], fieldValue)) {
-          continue;
-        }
-        metadataRecord[fieldKey] = fieldValue;
-        changedFields.push(fieldKey);
-      }
-      try {
-        applyRegisteredItemFieldDefaultsAndValidation(metadataRecord, extensionRegistrations, { skipDefaultFields: clearFrontMatterKeys });
-      } catch (error) {
-        throw new PmCliError(error instanceof Error ? error.message : "Invalid extension item field values", EXIT_CODE.USAGE);
-      }
-      return { changedFields, warnings };
+        dependencyUpdates,
+        dependencyRemovals,
+        commentUpdates,
+        noteUpdates,
+        learningUpdates,
+        fileUpdates,
+        testUpdates,
+        docUpdates,
+        resolvedParentValue: parentReference.resolvedParentValue,
+        resolvedBlockedByDependencyId,
+        runtimeFieldUpdates,
+        nowValue,
+        nowIso,
+        author,
+        pmRoot
+      });
     }
   });
   return {
@@ -1581,6 +1631,6 @@ export {
   runUpdate,
   _testOnlyUpdateCommand
 };
-//# sourceMappingURL=chunk-VD3LKZFX.js.map
+//# sourceMappingURL=chunk-7W4H4K26.js.map
 
-//# debugId=2e4b7619-5881-5abc-8c6d-a33b06c74f8d
+//# debugId=636bc41a-f03b-528f-84cb-5ab89ae42c00