@unbrained/pm-cli 2026.5.29 → 2026.5.31

package/dist/cli-bundle/chunks/chunk-3M73P3G6.js

@@ -0,0 +1,1636 @@
+import {
+  applyRegisteredItemFieldDefaultsAndValidation,
+  assertNoLegacyNoneToken,
+  assertNoLegacyNoneTokens,
+  ensureEnumValue,
+  isLegacyNoneToken,
+  normalizeRiskInput,
+  normalizeSeverityInput,
+  parseConfidenceInput,
+  parseDocs,
+  parseEventBoolean,
+  parseFiles,
+  parseLogSeed,
+  parseRecurrenceRule,
+  parseRegressionInput,
+  parseTests,
+  resolveEventEndAt,
+  resolvePriority
+} from "./chunk-JTWRXG4B.js";
+import {
+  buildInvalidTypeError
+} from "./chunk-7Y53ZJIQ.js";
+import {
+  applyTagRemovals,
+  createStdinTokenResolver,
+  mergeAdditiveTags,
+  parseCsvKv,
+  parseOptionalNumber,
+  parseTags
+} from "./chunk-NGN7UV5K.js";
+import {
+  runClose
+} from "./chunk-G57E5D7T.js";
+import {
+  normalizeParentReferenceValue,
+  validateMissingParentReference,
+  validateSprintOrReleaseValue
+} from "./chunk-AKOOMO3T.js";
+import {
+  buildItemNotFoundError,
+  locateItem,
+  mutateItem,
+  readLocatedItem,
+  toItemRecord
+} from "./chunk-BUPWJ3IJ.js";
+import {
+  normalizeItemId
+} from "./chunk-CEFIVZPG.js";
+import {
+  collectRuntimeUpdateFieldValues,
+  normalizeStatusInput
+} from "./chunk-MD7K4JYF.js";
+import {
+  canonicalizeCommandOptionKey,
+  commandOptionFlagLabel,
+  resolveCommandOptionPolicyState,
+  resolveItemTypeRegistry,
+  resolveTypeDefinition,
+  resolveTypeName,
+  validateTypeOptions
+} from "./chunk-WDPXDQFG.js";
+import {
+  resolveIsoOrRelative
+} from "./chunk-PVNQLCIS.js";
+import {
+  DEPENDENCY_KIND_VALUES,
+  EXIT_CODE,
+  ISSUE_SEVERITY_VALUES,
+  PmCliError,
+  RISK_VALUES,
+  getActiveExtensionRegistrations,
+  getSettingsPath,
+  pathExists,
+  readSettings,
+  resolvePmRoot,
+  resolveRuntimeFieldRegistry,
+  resolveRuntimeStatusRegistry
+} from "./chunk-LSXGH6NE.js";
+
+// dist/cli/commands/update.js
+!(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] = "3722af32-cd81-5b1e-bc17-bdb1f3335754");
+  } catch (e2) {
+  }
+})();
+var UPDATE_UNSET_FIELD_DEFINITIONS = [
+  { canonical: "tags", aliases: ["tags"], optionKey: "tags", frontMatterKey: "tags" },
+  { canonical: "close-reason", aliases: ["close_reason", "close-reason"], optionKey: "closeReason", frontMatterKey: "close_reason" },
+  { canonical: "deadline", aliases: ["deadline"], optionKey: "deadline", frontMatterKey: "deadline" },
+  {
+    canonical: "estimate",
+    aliases: ["estimate", "estimated_minutes", "estimated-minutes"],
+    optionKey: "estimatedMinutes",
+    frontMatterKey: "estimated_minutes"
+  },
+  {
+    canonical: "acceptance-criteria",
+    aliases: ["acceptance_criteria", "acceptance-criteria", "ac"],
+    optionKey: "acceptanceCriteria",
+    frontMatterKey: "acceptance_criteria"
+  },
+  {
+    canonical: "definition-of-ready",
+    aliases: ["definition_of_ready", "definition-of-ready"],
+    optionKey: "definitionOfReady",
+    frontMatterKey: "definition_of_ready"
+  },
+  { canonical: "order", aliases: ["order", "rank"], optionKey: "order", frontMatterKey: "order" },
+  { canonical: "goal", aliases: ["goal"], optionKey: "goal", frontMatterKey: "goal" },
+  { canonical: "objective", aliases: ["objective"], optionKey: "objective", frontMatterKey: "objective" },
+  { canonical: "value", aliases: ["value"], optionKey: "value", frontMatterKey: "value" },
+  { canonical: "impact", aliases: ["impact"], optionKey: "impact", frontMatterKey: "impact" },
+  { canonical: "outcome", aliases: ["outcome"], optionKey: "outcome", frontMatterKey: "outcome" },
+  { canonical: "why-now", aliases: ["why_now", "why-now"], optionKey: "whyNow", frontMatterKey: "why_now" },
+  { canonical: "assignee", aliases: ["assignee"], optionKey: "assignee", frontMatterKey: "assignee" },
+  { canonical: "parent", aliases: ["parent"], optionKey: "parent", frontMatterKey: "parent" },
+  { canonical: "reviewer", aliases: ["reviewer"], optionKey: "reviewer", frontMatterKey: "reviewer" },
+  { canonical: "risk", aliases: ["risk"], optionKey: "risk", frontMatterKey: "risk" },
+  { canonical: "confidence", aliases: ["confidence"], optionKey: "confidence", frontMatterKey: "confidence" },
+  { canonical: "sprint", aliases: ["sprint"], optionKey: "sprint", frontMatterKey: "sprint" },
+  { canonical: "release", aliases: ["release"], optionKey: "release", frontMatterKey: "release" },
+  {
+    canonical: "blocked-by",
+    aliases: ["blocked_by", "blocked-by"],
+    optionKey: "blockedBy",
+    frontMatterKey: "blocked_by"
+  },
+  {
+    canonical: "blocked-reason",
+    aliases: ["blocked_reason", "blocked-reason"],
+    optionKey: "blockedReason",
+    frontMatterKey: "blocked_reason"
+  },
+  {
+    canonical: "unblock-note",
+    aliases: ["unblock_note", "unblock-note"],
+    optionKey: "unblockNote",
+    frontMatterKey: "unblock_note"
+  },
+  { canonical: "reporter", aliases: ["reporter"], optionKey: "reporter", frontMatterKey: "reporter" },
+  { canonical: "severity", aliases: ["severity"], optionKey: "severity", frontMatterKey: "severity" },
+  {
+    canonical: "environment",
+    aliases: ["environment"],
+    optionKey: "environment",
+    frontMatterKey: "environment"
+  },
+  {
+    canonical: "repro-steps",
+    aliases: ["repro_steps", "repro-steps"],
+    optionKey: "reproSteps",
+    frontMatterKey: "repro_steps"
+  },
+  {
+    canonical: "resolution",
+    aliases: ["resolution"],
+    optionKey: "resolution",
+    frontMatterKey: "resolution"
+  },
+  {
+    canonical: "expected-result",
+    aliases: ["expected_result", "expected-result"],
+    optionKey: "expectedResult",
+    frontMatterKey: "expected_result"
+  },
+  {
+    canonical: "actual-result",
+    aliases: ["actual_result", "actual-result"],
+    optionKey: "actualResult",
+    frontMatterKey: "actual_result"
+  },
+  {
+    canonical: "affected-version",
+    aliases: ["affected_version", "affected-version"],
+    optionKey: "affectedVersion",
+    frontMatterKey: "affected_version"
+  },
+  {
+    canonical: "fixed-version",
+    aliases: ["fixed_version", "fixed-version"],
+    optionKey: "fixedVersion",
+    frontMatterKey: "fixed_version"
+  },
+  { canonical: "component", aliases: ["component"], optionKey: "component", frontMatterKey: "component" },
+  { canonical: "regression", aliases: ["regression"], optionKey: "regression", frontMatterKey: "regression" },
+  {
+    canonical: "customer-impact",
+    aliases: ["customer_impact", "customer-impact"],
+    optionKey: "customerImpact",
+    frontMatterKey: "customer_impact"
+  }
+];
+var UPDATE_UNSET_ALIAS_MAP = (() => {
+  const map = /* @__PURE__ */ new Map();
+  for (const definition of UPDATE_UNSET_FIELD_DEFINITIONS) {
+    for (const alias of definition.aliases) {
+      map.set(alias, {
+        optionKey: definition.optionKey,
+        frontMatterKey: definition.frontMatterKey
+      });
+    }
+  }
+  return map;
+})();
+var UPDATE_OPTION_KEY_TO_UNSET_CANONICAL = new Map(UPDATE_UNSET_FIELD_DEFINITIONS.map((definition) => [definition.optionKey, definition.canonical]));
+var UPDATE_UNSET_SUPPORTED_CANONICAL_FIELDS = UPDATE_UNSET_FIELD_DEFINITIONS.map((definition) => definition.canonical).sort((left, right) => left.localeCompare(right)).join(", ");
+var AUDIT_UPDATE_DISALLOWED_UNSET_FRONT_MATTER_KEYS = /* @__PURE__ */ new Set([
+  "close_reason",
+  "assignee",
+  "parent",
+  "blocked_by",
+  "blocked_reason",
+  "unblock_note",
+  "dependencies",
+  "comments",
+  "notes",
+  "learnings",
+  "files",
+  "tests",
+  "docs",
+  "reminders",
+  "events"
+]);
+function toAuthor(candidate, defaultAuthor) {
+  const resolved = candidate ?? process.env.PM_AUTHOR ?? defaultAuthor;
+  const trimmed = resolved.trim();
+  return trimmed || "unknown";
+}
+var UPDATE_LEGACY_NONE_COLLECTION_NORMALIZERS = [
+  { optionKey: "dep", clearFlagKey: "clearDeps", valueFlag: "--dep", clearFlag: "--clear-deps", disableReplaceFlagKey: "replaceDeps" },
+  { optionKey: "comment", clearFlagKey: "clearComments", valueFlag: "--comment", clearFlag: "--clear-comments" },
+  { optionKey: "note", clearFlagKey: "clearNotes", valueFlag: "--note", clearFlag: "--clear-notes" },
+  { optionKey: "learning", clearFlagKey: "clearLearnings", valueFlag: "--learning", clearFlag: "--clear-learnings" },
+  { optionKey: "file", clearFlagKey: "clearFiles", valueFlag: "--file", clearFlag: "--clear-files" },
+  { optionKey: "test", clearFlagKey: "clearTests", valueFlag: "--test", clearFlag: "--clear-tests", disableReplaceFlagKey: "replaceTests" },
+  { optionKey: "doc", clearFlagKey: "clearDocs", valueFlag: "--doc", clearFlag: "--clear-docs" },
+  { optionKey: "reminder", clearFlagKey: "clearReminders", valueFlag: "--reminder", clearFlag: "--clear-reminders" },
+  { optionKey: "event", clearFlagKey: "clearEvents", valueFlag: "--event", clearFlag: "--clear-events" },
+  { optionKey: "typeOption", clearFlagKey: "clearTypeOptions", valueFlag: "--type-option", clearFlag: "--clear-type-options" }
+];
+function normalizeLegacyNoneUpdateOptions(options) {
+  const normalized = {
+    ...options,
+    unset: options.unset ? [...options.unset] : void 0
+  };
+  const appendUnsetTarget = (value) => {
+    const current = normalized.unset ? [...normalized.unset] : [];
+    if (!current.includes(value)) {
+      current.push(value);
+    }
+    normalized.unset = current;
+  };
+  const scalarOptionKeys = /* @__PURE__ */ new Set([...UPDATE_OPTION_KEY_TO_UNSET_CANONICAL.keys(), "rank"]);
+  for (const optionKey of scalarOptionKeys) {
+    const candidate = normalized[optionKey];
+    if (typeof candidate !== "string" || !isLegacyNoneToken(candidate)) {
+      continue;
+    }
+    const canonicalUnset = optionKey === "rank" ? "order" : UPDATE_OPTION_KEY_TO_UNSET_CANONICAL.get(optionKey) ?? optionKey;
+    appendUnsetTarget(canonicalUnset);
+    normalized[optionKey] = void 0;
+  }
+  for (const definition of UPDATE_LEGACY_NONE_COLLECTION_NORMALIZERS) {
+    const entries = normalized[definition.optionKey];
+    if (!Array.isArray(entries) || entries.length === 0) {
+      continue;
+    }
+    const hasLegacy = entries.some((entry) => isLegacyNoneToken(entry));
+    if (!hasLegacy) {
+      continue;
+    }
+    const concreteEntries = entries.filter((entry) => !isLegacyNoneToken(entry));
+    if (concreteEntries.length > 0) {
+      throw new PmCliError(`Cannot mix legacy clear token "none"/"null" with concrete ${definition.valueFlag} entries. Use ${definition.clearFlag} to clear or provide explicit entries.`, EXIT_CODE.USAGE);
+    }
+    normalized[definition.optionKey] = void 0;
+    normalized[definition.clearFlagKey] = true;
+    if (definition.disableReplaceFlagKey) {
+      normalized[definition.disableReplaceFlagKey] = false;
+    }
+  }
+  return normalized;
+}
+function resolveRuntimeUnsetDefinition(token, runtimeFieldRegistry) {
+  if (!runtimeFieldRegistry) {
+    return void 0;
+  }
+  for (const definition of runtimeFieldRegistry.definitions) {
+    if (definition.allow_unset === false) {
+      continue;
+    }
+    const candidates = /* @__PURE__ */ new Set([
+      definition.key,
+      definition.metadata_key,
+      definition.cli_flag.replaceAll("-", "_"),
+      definition.cli_flag,
+      ...definition.cli_aliases.map((alias) => alias.replaceAll("-", "_")),
+      ...definition.cli_aliases
+    ]);
+    if (!candidates.has(token)) {
+      continue;
+    }
+    return {
+      optionKey: definition.key,
+      frontMatterKey: definition.metadata_key
+    };
+  }
+  return void 0;
+}
+function parseUpdateUnsetTargets(raw, runtimeFieldRegistry) {
+  const frontMatterKeys = /* @__PURE__ */ new Set();
+  const optionKeys = /* @__PURE__ */ new Set();
+  if (!raw || raw.length === 0) {
+    return { frontMatterKeys, optionKeys };
+  }
+  for (const entry of raw) {
+    const trimmed = entry.trim().toLowerCase();
+    if (!trimmed) {
+      throw new PmCliError("--unset values must not be empty", EXIT_CODE.USAGE);
+    }
+    if (isLegacyNoneToken(trimmed)) {
+      throw new PmCliError('--unset no longer accepts "none" or "null". Specify concrete field names such as --unset deadline', EXIT_CODE.USAGE);
+    }
+    const definition = UPDATE_UNSET_ALIAS_MAP.get(trimmed) ?? resolveRuntimeUnsetDefinition(trimmed, runtimeFieldRegistry);
+    if (!definition) {
+      throw new PmCliError(`Unsupported --unset field "${entry}". Supported fields: ${UPDATE_UNSET_SUPPORTED_CANONICAL_FIELDS}`, EXIT_CODE.USAGE);
+    }
+    frontMatterKeys.add(definition.frontMatterKey);
+    optionKeys.add(definition.optionKey);
+  }
+  return { frontMatterKeys, optionKeys };
+}
+function enforceAllowAuditUpdateScope(options, clearFrontMatterKeys) {
+  const allowAuditUpdate = options.allowAuditUpdate === true;
+  const allowAuditDepUpdate = options.allowAuditDepUpdate === true;
+  if (!allowAuditUpdate && !allowAuditDepUpdate) {
+    return;
+  }
+  if (allowAuditUpdate && allowAuditDepUpdate) {
+    throw new PmCliError("Choose either --allow-audit-update or --allow-audit-dep-update; these override modes are mutually exclusive.", EXIT_CODE.USAGE);
+  }
+  const pushIf = (condition, flag, list) => {
+    if (condition) {
+      list.push(flag);
+    }
+  };
+  if (allowAuditDepUpdate) {
+    const disallowedFlags2 = [];
+    pushIf(options.title !== void 0, "--title", disallowedFlags2);
+    pushIf(options.description !== void 0, "--description", disallowedFlags2);
+    pushIf(options.body !== void 0, "--body", disallowedFlags2);
+    pushIf(options.status !== void 0, "--status", disallowedFlags2);
+    pushIf(options.closeReason !== void 0, "--close-reason", disallowedFlags2);
+    pushIf(options.priority !== void 0, "--priority", disallowedFlags2);
+    pushIf(options.type !== void 0, "--type", disallowedFlags2);
+    pushIf(options.tags !== void 0, "--tags", disallowedFlags2);
+    pushIf(Array.isArray(options.addTags) && options.addTags.length > 0, "--add-tags", disallowedFlags2);
+    pushIf(Array.isArray(options.removeTags) && options.removeTags.length > 0, "--remove-tags", disallowedFlags2);
+    pushIf(options.deadline !== void 0, "--deadline", disallowedFlags2);
+    pushIf(options.estimatedMinutes !== void 0, "--estimate", disallowedFlags2);
+    pushIf(options.acceptanceCriteria !== void 0, "--acceptance-criteria", disallowedFlags2);
+    pushIf(options.definitionOfReady !== void 0, "--definition-of-ready", disallowedFlags2);
+    pushIf(options.order !== void 0 || options.rank !== void 0, "--order/--rank", disallowedFlags2);
+    pushIf(options.goal !== void 0, "--goal", disallowedFlags2);
+    pushIf(options.objective !== void 0, "--objective", disallowedFlags2);
+    pushIf(options.value !== void 0, "--value", disallowedFlags2);
+    pushIf(options.impact !== void 0, "--impact", disallowedFlags2);
+    pushIf(options.outcome !== void 0, "--outcome", disallowedFlags2);
+    pushIf(options.whyNow !== void 0, "--why-now", disallowedFlags2);
+    pushIf(options.assignee !== void 0, "--assignee", disallowedFlags2);
+    pushIf(options.parent !== void 0, "--parent", disallowedFlags2);
+    pushIf(options.reviewer !== void 0, "--reviewer", disallowedFlags2);
+    pushIf(options.risk !== void 0, "--risk", disallowedFlags2);
+    pushIf(options.confidence !== void 0, "--confidence", disallowedFlags2);
+    pushIf(options.sprint !== void 0, "--sprint", disallowedFlags2);
+    pushIf(options.release !== void 0, "--release", disallowedFlags2);
+    pushIf(options.blockedBy !== void 0, "--blocked-by", disallowedFlags2);
+    pushIf(options.blockedReason !== void 0, "--blocked-reason", disallowedFlags2);
+    pushIf(options.unblockNote !== void 0, "--unblock-note", disallowedFlags2);
+    pushIf(options.reporter !== void 0, "--reporter", disallowedFlags2);
+    pushIf(options.severity !== void 0, "--severity", disallowedFlags2);
+    pushIf(options.environment !== void 0, "--environment", disallowedFlags2);
+    pushIf(options.reproSteps !== void 0, "--repro-steps", disallowedFlags2);
+    pushIf(options.resolution !== void 0, "--resolution", disallowedFlags2);
+    pushIf(options.expectedResult !== void 0, "--expected-result", disallowedFlags2);
+    pushIf(options.actualResult !== void 0, "--actual-result", disallowedFlags2);
+    pushIf(options.affectedVersion !== void 0, "--affected-version", disallowedFlags2);
+    pushIf(options.fixedVersion !== void 0, "--fixed-version", disallowedFlags2);
+    pushIf(options.component !== void 0, "--component", disallowedFlags2);
+    pushIf(options.regression !== void 0, "--regression", disallowedFlags2);
+    pushIf(options.customerImpact !== void 0, "--customer-impact", disallowedFlags2);
+    pushIf(options.depRemove !== void 0, "--dep-remove", disallowedFlags2);
+    pushIf(options.replaceDeps === true, "--replace-deps", disallowedFlags2);
+    pushIf(options.replaceTests === true, "--replace-tests", disallowedFlags2);
+    pushIf(options.comment !== void 0, "--comment", disallowedFlags2);
+    pushIf(options.note !== void 0, "--note", disallowedFlags2);
+    pushIf(options.learning !== void 0, "--learning", disallowedFlags2);
+    pushIf(options.file !== void 0, "--file", disallowedFlags2);
+    pushIf(options.test !== void 0, "--test", disallowedFlags2);
+    pushIf(options.doc !== void 0, "--doc", disallowedFlags2);
+    pushIf(options.reminder !== void 0, "--reminder", disallowedFlags2);
+    pushIf(options.event !== void 0, "--event", disallowedFlags2);
+    pushIf(options.typeOption !== void 0, "--type-option", disallowedFlags2);
+    pushIf(options.clearDeps === true, "--clear-deps", disallowedFlags2);
+    pushIf(options.clearComments === true, "--clear-comments", disallowedFlags2);
+    pushIf(options.clearNotes === true, "--clear-notes", disallowedFlags2);
+    pushIf(options.clearLearnings === true, "--clear-learnings", disallowedFlags2);
+    pushIf(options.clearFiles === true, "--clear-files", disallowedFlags2);
+    pushIf(options.clearTests === true, "--clear-tests", disallowedFlags2);
+    pushIf(options.clearDocs === true, "--clear-docs", disallowedFlags2);
+    pushIf(options.clearReminders === true, "--clear-reminders", disallowedFlags2);
+    pushIf(options.clearEvents === true, "--clear-events", disallowedFlags2);
+    pushIf(options.clearTypeOptions === true, "--clear-type-options", disallowedFlags2);
+    pushIf(options.force === true, "--force", disallowedFlags2);
+    pushIf(clearFrontMatterKeys.size > 0, "--unset", disallowedFlags2);
+    if (options.dep === void 0 || options.dep.length === 0) {
+      throw new PmCliError("--allow-audit-dep-update requires at least one --dep value", EXIT_CODE.USAGE);
+    }
+    if (disallowedFlags2.length > 0) {
+      throw new PmCliError(`--allow-audit-dep-update supports append-only dependency additions via --dep. Remove restricted options: ${disallowedFlags2.join(", ")}`, EXIT_CODE.USAGE);
+    }
+    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.comment !== void 0) {
+    disallowedFlags.push("--comment");
+  }
+  if (options.note !== void 0) {
+    disallowedFlags.push("--note");
+  }
+  if (options.learning !== void 0) {
+    disallowedFlags.push("--learning");
+  }
+  if (options.file !== void 0) {
+    disallowedFlags.push("--file");
+  }
+  if (options.test !== void 0) {
+    disallowedFlags.push("--test");
+  }
+  if (options.doc !== void 0) {
+    disallowedFlags.push("--doc");
+  }
+  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");
+  }
+  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) {
+    throw new PmCliError(`--allow-audit-update only supports non-lifecycle metadata fields. Remove restricted options: ${disallowedFlags.join(", ")}`, EXIT_CODE.USAGE);
+  }
+}
+function parseStatus(value, statusRegistry) {
+  const normalized = normalizeStatusInput(value, statusRegistry);
+  if (!normalized) {
+    const allowedStatuses = statusRegistry.definitions.map((definition) => definition.id);
+    throw new PmCliError(`Invalid --status value "${value}". Allowed: ${allowedStatuses.join(", ")}`, EXIT_CODE.USAGE);
+  }
+  return normalized;
+}
+function parseReminderEntries(raw, nowValue) {
+  return raw.map((entry) => {
+    const kv = parseCsvKv(entry, "--reminder");
+    const atRaw = (kv.at ?? kv.date)?.trim();
+    const textRaw = (kv.text ?? kv.title)?.trim();
+    if (!atRaw || !textRaw) {
+      throw new PmCliError("--reminder requires at=<iso|relative> or date=<iso|relative>, plus text=<value> or title=<value>", EXIT_CODE.USAGE);
+    }
+    return {
+      at: resolveIsoOrRelative(atRaw, nowValue, "reminder.at"),
+      text: textRaw
+    };
+  });
+}
+function parseEventEntries(raw, nowValue) {
+  return raw.map((entry) => {
+    const kv = parseCsvKv(entry, "--event");
+    const startRaw = (kv.start ?? kv.date)?.trim();
+    if (!startRaw) {
+      throw new PmCliError("--event requires start=<iso|relative> or date=<iso|relative>", EXIT_CODE.USAGE);
+    }
+    const startAt = resolveIsoOrRelative(startRaw, nowValue, "event.start");
+    const endRaw = kv.end?.trim();
+    const durationRaw = kv.duration?.trim();
+    const endAt = resolveEventEndAt(startAt, endRaw, durationRaw, nowValue);
+    const titleRaw = kv.title;
+    const descriptionRaw = kv.description;
+    const locationRaw = kv.location;
+    const timezoneRaw = kv.timezone;
+    const title = titleRaw?.trim();
+    const description = descriptionRaw?.trim();
+    const location = locationRaw?.trim();
+    const timezone = timezoneRaw?.trim();
+    if (titleRaw !== void 0 && !title) {
+      throw new PmCliError("--event title must not be empty", EXIT_CODE.USAGE);
+    }
+    if (descriptionRaw !== void 0 && !description) {
+      throw new PmCliError("--event description must not be empty", EXIT_CODE.USAGE);
+    }
+    if (locationRaw !== void 0 && !location) {
+      throw new PmCliError("--event location must not be empty", EXIT_CODE.USAGE);
+    }
+    if (timezoneRaw !== void 0 && !timezone) {
+      throw new PmCliError("--event timezone must not be empty", EXIT_CODE.USAGE);
+    }
+    const allDayRaw = kv.all_day?.trim();
+    const recurrence = parseRecurrenceRule(kv, startAt, nowValue, "truthy");
+    return {
+      start_at: startAt,
+      end_at: endAt,
+      title,
+      description,
+      location,
+      all_day: allDayRaw ? parseEventBoolean(allDayRaw, "--event all_day") : void 0,
+      timezone,
+      recurrence
+    };
+  });
+}
+function parseTypeOptionEntries(raw) {
+  const values = {};
+  for (const entry of raw) {
+    const trimmedEntry = entry.trim();
+    if (trimmedEntry.length === 0) {
+      throw new PmCliError("--type-option values must not be empty", EXIT_CODE.USAGE);
+    }
+    let key;
+    let value;
+    const prefersStructuredKv = trimmedEntry.includes(",") || trimmedEntry.includes("\n") || trimmedEntry.startsWith("```") || /^(?:[-*+]\s+)?(?:key|value)\s*[:=]/i.test(trimmedEntry);
+    if (prefersStructuredKv) {
+      const kv = parseCsvKv(trimmedEntry, "--type-option");
+      key = kv.key?.trim();
+      value = kv.value?.trim();
+    } else {
+      const equalsIndex = trimmedEntry.indexOf("=");
+      const colonIndex = trimmedEntry.indexOf(":");
+      let separatorIndex = equalsIndex;
+      if (equalsIndex <= 0 && colonIndex > 0) {
+        separatorIndex = colonIndex;
+      }
+      if (separatorIndex <= 0 || separatorIndex === trimmedEntry.length - 1) {
+        throw new PmCliError("--type-option requires key=value or key=<name>,value=<value> entries", EXIT_CODE.USAGE);
+      }
+      key = trimmedEntry.slice(0, separatorIndex).trim();
+      value = trimmedEntry.slice(separatorIndex + 1).trim();
+    }
+    if (!key || !value) {
+      throw new PmCliError("--type-option requires key and value", EXIT_CODE.USAGE);
+    }
+    values[key] = value;
+  }
+  return Object.fromEntries(Object.entries(values).sort((left, right) => left[0].localeCompare(right[0])));
+}
+function parseDependencyCreatedAt(value, currentIso) {
+  if (!value || value.trim() === "" || value.trim().toLowerCase() === "now") {
+    return currentIso;
+  }
+  const parsed = Date.parse(value);
+  if (!Number.isFinite(parsed)) {
+    throw new PmCliError(`Invalid dependency created_at timestamp "${value}"`, EXIT_CODE.USAGE);
+  }
+  return new Date(parsed).toISOString();
+}
+function parseOptionalDependencyString(value) {
+  if (value === void 0)
+    return void 0;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function looksLikeStructuredDependencyEntry(raw) {
+  if (raw.startsWith("```") || raw.includes("\n")) {
+    return true;
+  }
+  return /^(?:[-*+]\s+)?(?:id|kind|author|created_at|source_kind)\s*[:=]/i.test(raw);
+}
+var DEPENDENCY_KIND_INPUT_ALIASES = {
+  depends_on: "blocked_by",
+  "depends-on": "blocked_by"
+};
+function normalizeDependencyKindInput(raw) {
+  if (typeof raw !== "string") {
+    return raw;
+  }
+  const trimmed = raw.trim();
+  const alias = DEPENDENCY_KIND_INPUT_ALIASES[trimmed.toLowerCase()];
+  return alias ?? trimmed;
+}
+function parseDependencyAdditions(raw, prefix, nowIso) {
+  if (!raw) {
+    return { additions: [] };
+  }
+  assertNoLegacyNoneTokens(raw, "--dep", "Use --clear-deps to clear dependencies.");
+  const additions = raw.map((entry) => {
+    const trimmedEntry = entry.trim();
+    const kv = looksLikeStructuredDependencyEntry(trimmedEntry) ? parseCsvKv(entry, "--dep") : { id: trimmedEntry, kind: "related" };
+    const id = kv.id?.trim();
+    const kind = normalizeDependencyKindInput(kv.kind?.trim());
+    if (!id || !kind) {
+      throw new PmCliError("--dep requires id and kind, or a bare item id to add a related dependency", EXIT_CODE.USAGE);
+    }
+    if (id.toLowerCase() === "undefined") {
+      throw new PmCliError(`--dep id must not use placeholder token "${id}". Use --clear-deps to clear dependencies.`, EXIT_CODE.USAGE);
+    }
+    const sourceKind = parseOptionalDependencyString(kv.source_kind);
+    return {
+      id: normalizeItemId(id, prefix),
+      kind: ensureEnumValue(kind, DEPENDENCY_KIND_VALUES, "dependency kind"),
+      created_at: parseDependencyCreatedAt(kv.created_at, nowIso),
+      author: parseOptionalDependencyString(kv.author),
+      source_kind: sourceKind
+    };
+  });
+  return { additions };
+}
+function parseDependencyRemovals(raw, prefix) {
+  if (!raw) {
+    return [];
+  }
+  assertNoLegacyNoneTokens(raw, "--dep-remove");
+  return raw.map((entry) => {
+    const trimmed = entry.trim();
+    if (!trimmed) {
+      throw new PmCliError("--dep-remove requires id or key/value selectors", EXIT_CODE.USAGE);
+    }
+    if (trimmed.includes("=") || /^(?:[-*+]\s+)?(?:id|kind|source_kind)\s*[:=]/i.test(trimmed) || trimmed.startsWith("```")) {
+      const kv = parseCsvKv(trimmed, "--dep-remove");
+      const idRaw = kv.id?.trim();
+      if (!idRaw) {
+        throw new PmCliError("--dep-remove key/value form requires id=<value>", EXIT_CODE.USAGE);
+      }
+      if (idRaw.toLowerCase() === "undefined") {
+        throw new PmCliError(`--dep-remove id must not use placeholder token "${idRaw}"`, EXIT_CODE.USAGE);
+      }
+      const kindRaw = normalizeDependencyKindInput(parseOptionalDependencyString(kv.kind));
+      const sourceKind = parseOptionalDependencyString(kv.source_kind);
+      return {
+        id: normalizeItemId(idRaw, prefix),
+        kind: kindRaw ? ensureEnumValue(kindRaw, DEPENDENCY_KIND_VALUES, "dependency kind") : void 0,
+        source_kind: sourceKind
+      };
+    }
+    if (trimmed.toLowerCase() === "undefined") {
+      throw new PmCliError(`--dep-remove id must not use placeholder token "${trimmed}"`, EXIT_CODE.USAGE);
+    }
+    return {
+      id: normalizeItemId(trimmed, prefix)
+    };
+  });
+}
+function dependencyKey(value) {
+  return `${value.id}::${value.kind}::${value.source_kind ?? ""}`;
+}
+function reconcileBlockedByDependency(current, nextBlockedById, nowIsoValue, author) {
+  let next = [...current ?? []];
+  let changed = false;
+  const filtered = next.filter((dep) => dep.kind !== "blocked_by" || dep.id === nextBlockedById);
+  if (filtered.length !== next.length) {
+    next = filtered;
+    changed = true;
+  }
+  if (nextBlockedById && !next.some((dep) => dep.kind === "blocked_by" && dep.id === nextBlockedById)) {
+    next.push({ id: nextBlockedById, kind: "blocked_by", created_at: nowIsoValue, author });
+    changed = true;
+  }
+  if (!changed) {
+    return { dependencies: current, changed: false };
+  }
+  return { dependencies: next.length > 0 ? next : void 0, changed: true };
+}
+async function resolveBlockedByDependencyTarget(blockedByOption, blockedByCleared, pmRoot, idPrefix, itemFormat, typeToFolder) {
+  if (blockedByOption === void 0 || blockedByCleared) {
+    return {};
+  }
+  const blockedByValue = blockedByOption.trim();
+  if (blockedByValue.length === 0) {
+    return {};
+  }
+  const located = await locateItem(pmRoot, normalizeItemId(blockedByValue, idPrefix), idPrefix, itemFormat, typeToFolder);
+  return located ? { id: located.id } : { unresolved: blockedByValue };
+}
+function applyBlockedByDependencyEdge(metadata, resolvedBlockedById, nowIsoValue, author, changedFields) {
+  const reconciled = reconcileBlockedByDependency(metadata.dependencies, resolvedBlockedById, nowIsoValue, author);
+  if (!reconciled.changed) {
+    return;
+  }
+  if (reconciled.dependencies === void 0) {
+    delete metadata.dependencies;
+  } else {
+    metadata.dependencies = reconciled.dependencies;
+  }
+  if (!changedFields.includes("dependencies")) {
+    changedFields.push("dependencies");
+  }
+}
+function fileKey(value) {
+  return `${value.path}::${value.scope}`;
+}
+function docKey(value) {
+  return `${value.path}::${value.scope}`;
+}
+function testKey(value) {
+  return `${value.command}::${value.path ?? ""}::${value.scope}::${value.pm_context_mode ?? ""}`;
+}
+function matchesDependencySelector(value, selector) {
+  if (value.id !== selector.id) {
+    return false;
+  }
+  if (selector.kind && value.kind !== selector.kind) {
+    return false;
+  }
+  if (selector.source_kind !== void 0 && (value.source_kind ?? void 0) !== selector.source_kind) {
+    return false;
+  }
+  return true;
+}
+function ensurePriority(raw) {
+  return resolvePriority(raw);
+}
+function normalizeUpdatePolicyOptionKey(raw, typeName) {
+  const canonical = canonicalizeCommandOptionKey("update", raw);
+  if (!canonical) {
+    throw new PmCliError(`Unsupported command_option_policies option "${raw}" for update command on type "${typeName}"`, EXIT_CODE.CONFLICT);
+  }
+  return canonical;
+}
+function collectProvidedUpdatePolicyOptions(options) {
+  const provided = /* @__PURE__ */ new Set();
+  const mark = (optionKey, isProvided) => {
+    if (isProvided) {
+      provided.add(optionKey);
+    }
+  };
+  mark("title", options.title !== void 0);
+  mark("description", options.description !== void 0);
+  mark("body", options.body !== void 0);
+  mark("status", options.status !== void 0);
+  mark("closeReason", options.closeReason !== void 0);
+  mark("priority", options.priority !== void 0);
+  mark("type", options.type !== void 0);
+  mark("tags", options.tags !== void 0 || Array.isArray(options.addTags) && options.addTags.length > 0 || Array.isArray(options.removeTags) && options.removeTags.length > 0);
+  mark("deadline", options.deadline !== void 0);
+  mark("estimatedMinutes", options.estimatedMinutes !== void 0);
+  mark("acceptanceCriteria", options.acceptanceCriteria !== void 0);
+  mark("definitionOfReady", options.definitionOfReady !== void 0);
+  mark("order", options.order !== void 0 || options.rank !== void 0);
+  mark("goal", options.goal !== void 0);
+  mark("objective", options.objective !== void 0);
+  mark("value", options.value !== void 0);
+  mark("impact", options.impact !== void 0);
+  mark("outcome", options.outcome !== void 0);
+  mark("whyNow", options.whyNow !== void 0);
+  mark("author", options.author !== void 0);
+  mark("message", options.message !== void 0);
+  mark("assignee", options.assignee !== void 0);
+  mark("parent", options.parent !== void 0);
+  mark("reviewer", options.reviewer !== void 0);
+  mark("risk", options.risk !== void 0);
+  mark("confidence", options.confidence !== void 0);
+  mark("sprint", options.sprint !== void 0);
+  mark("release", options.release !== void 0);
+  mark("blockedBy", options.blockedBy !== void 0);
+  mark("blockedReason", options.blockedReason !== void 0);
+  mark("unblockNote", options.unblockNote !== void 0);
+  mark("reporter", options.reporter !== void 0);
+  mark("severity", options.severity !== void 0);
+  mark("environment", options.environment !== void 0);
+  mark("reproSteps", options.reproSteps !== void 0);
+  mark("resolution", options.resolution !== void 0);
+  mark("expectedResult", options.expectedResult !== void 0);
+  mark("actualResult", options.actualResult !== void 0);
+  mark("affectedVersion", options.affectedVersion !== void 0);
+  mark("fixedVersion", options.fixedVersion !== void 0);
+  mark("component", options.component !== void 0);
+  mark("regression", options.regression !== void 0);
+  mark("customerImpact", options.customerImpact !== void 0);
+  mark("dep", options.dep !== void 0);
+  mark("depRemove", options.depRemove !== void 0);
+  mark("dep", options.replaceDeps === true);
+  mark("comment", options.comment !== void 0);
+  mark("note", options.note !== void 0);
+  mark("learning", options.learning !== void 0);
+  mark("file", options.file !== void 0);
+  mark("test", options.test !== void 0);
+  mark("test", options.replaceTests === true);
+  mark("doc", options.doc !== void 0);
+  mark("reminder", options.reminder !== void 0);
+  mark("event", options.event !== void 0);
+  mark("typeOption", options.typeOption !== void 0);
+  mark("force", options.force === true);
+  mark("allowAuditUpdate", options.allowAuditUpdate === true);
+  mark("dep", options.clearDeps === true);
+  mark("comment", options.clearComments === true);
+  mark("note", options.clearNotes === true);
+  mark("learning", options.clearLearnings === true);
+  mark("file", options.clearFiles === true);
+  mark("test", options.clearTests === true);
+  mark("doc", options.clearDocs === true);
+  mark("reminder", options.clearReminders === true);
+  mark("event", options.clearEvents === true);
+  mark("typeOption", options.clearTypeOptions === true);
+  if (options.unset && options.unset.length > 0) {
+    const unsetTargets = parseUpdateUnsetTargets(options.unset);
+    for (const optionKey of unsetTargets.optionKeys) {
+      mark(optionKey, true);
+    }
+  }
+  return provided;
+}
+function enforceUpdateOptionsByType(typeName, options, typeRegistry) {
+  const typeDefinition = resolveTypeDefinition(typeName, typeRegistry);
+  if (!typeDefinition) {
+    throw new PmCliError(`Invalid type value "${typeName}"`, EXIT_CODE.USAGE);
+  }
+  const policyState = resolveCommandOptionPolicyState(typeDefinition, "update", []);
+  if (policyState.errors.length > 0) {
+    throw new PmCliError(policyState.errors.join("; "), EXIT_CODE.CONFLICT);
+  }
+  const provided = collectProvidedUpdatePolicyOptions(options);
+  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);
+    }
+  }
+  for (const required of policyState.required) {
+    if (!provided.has(normalizeUpdatePolicyOptionKey(required, typeName))) {
+      throw new PmCliError(`Missing required option ${commandOptionFlagLabel("update", required)} for type "${typeName}"`, EXIT_CODE.USAGE);
+    }
+  }
+}
+async function runUpdate(id, options, global2) {
+  const stdinResolver = createStdinTokenResolver();
+  options = normalizeLegacyNoneUpdateOptions({
+    ...options,
+    body: await stdinResolver.resolveValue(options.body, "--body"),
+    dep: await stdinResolver.resolveList(options.dep, "--dep"),
+    depRemove: await stdinResolver.resolveList(options.depRemove, "--dep-remove"),
+    comment: await stdinResolver.resolveList(options.comment, "--comment"),
+    note: await stdinResolver.resolveList(options.note, "--note"),
+    learning: await stdinResolver.resolveList(options.learning, "--learning"),
+    file: await stdinResolver.resolveList(options.file, "--file"),
+    test: await stdinResolver.resolveList(options.test, "--test"),
+    doc: await stdinResolver.resolveList(options.doc, "--doc"),
+    reminder: await stdinResolver.resolveList(options.reminder, "--reminder"),
+    event: await stdinResolver.resolveList(options.event, "--event"),
+    typeOption: await stdinResolver.resolveList(options.typeOption, "--type-option")
+  });
+  const pmRoot = resolvePmRoot(process.cwd(), global2.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 typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
+  const parentReferencePolicy = settings.validation.parent_reference;
+  const sprintReleasePolicy = settings.validation.sprint_release_format;
+  const unsetTargets = parseUpdateUnsetTargets(options.unset, runtimeFieldRegistry);
+  const clearOptionKeys = new Set(unsetTargets.optionKeys);
+  const clearFrontMatterKeys = new Set(unsetTargets.frontMatterKeys);
+  const clearCollectionDefinitions = [
+    {
+      enabled: options.clearDeps || options.replaceDeps,
+      optionKey: "dep",
+      clearFlag: "--clear-deps",
+      valueFlag: "--dep",
+      values: options.dep,
+      frontMatterKey: "dependencies"
+    },
+    {
+      enabled: options.clearComments,
+      optionKey: "comment",
+      clearFlag: "--clear-comments",
+      valueFlag: "--comment",
+      values: options.comment,
+      frontMatterKey: "comments"
+    },
+    {
+      enabled: options.clearNotes,
+      optionKey: "note",
+      clearFlag: "--clear-notes",
+      valueFlag: "--note",
+      values: options.note,
+      frontMatterKey: "notes"
+    },
+    {
+      enabled: options.clearLearnings,
+      optionKey: "learning",
+      clearFlag: "--clear-learnings",
+      valueFlag: "--learning",
+      values: options.learning,
+      frontMatterKey: "learnings"
+    },
+    {
+      enabled: options.clearFiles,
+      optionKey: "file",
+      clearFlag: "--clear-files",
+      valueFlag: "--file",
+      values: options.file,
+      frontMatterKey: "files"
+    },
+    {
+      enabled: options.clearTests || options.replaceTests,
+      optionKey: "test",
+      clearFlag: "--clear-tests",
+      valueFlag: "--test",
+      values: options.test,
+      frontMatterKey: "tests"
+    },
+    {
+      enabled: options.clearDocs,
+      optionKey: "doc",
+      clearFlag: "--clear-docs",
+      valueFlag: "--doc",
+      values: options.doc,
+      frontMatterKey: "docs"
+    },
+    {
+      enabled: options.clearReminders,
+      optionKey: "reminder",
+      clearFlag: "--clear-reminders",
+      valueFlag: "--reminder",
+      values: options.reminder,
+      frontMatterKey: "reminders"
+    },
+    {
+      enabled: options.clearEvents,
+      optionKey: "event",
+      clearFlag: "--clear-events",
+      valueFlag: "--event",
+      values: options.event,
+      frontMatterKey: "events"
+    },
+    {
+      enabled: options.clearTypeOptions,
+      optionKey: "typeOption",
+      clearFlag: "--clear-type-options",
+      valueFlag: "--type-option",
+      values: options.typeOption,
+      frontMatterKey: "type_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);
+  }
+  if (options.replaceDeps === true && options.depRemove !== void 0 && options.depRemove.length > 0) {
+    throw new PmCliError("--replace-deps cannot be combined with --dep-remove", EXIT_CODE.USAGE);
+  }
+  if (options.replaceTests === true && (options.test === void 0 || options.test.length === 0)) {
+    throw new PmCliError("--replace-tests requires at least one --test entry", EXIT_CODE.USAGE);
+  }
+  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) {
+    if (!definition.enabled) {
+      continue;
+    }
+    if (definition.values && definition.values.length > 0 && !(definition.optionKey === "dep" && options.replaceDeps === true || definition.optionKey === "test" && options.replaceTests === true)) {
+      throw new PmCliError(`Cannot combine ${definition.clearFlag} with ${definition.valueFlag}`, EXIT_CODE.USAGE);
+    }
+    clearOptionKeys.add(definition.optionKey);
+    clearFrontMatterKeys.add(definition.frontMatterKey);
+  }
+  enforceAllowAuditUpdateScope(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
+  };
+  for (const [optionKey, hasValue] of Object.entries(scalarOptionPresence)) {
+    if (!hasValue || !unsetTargets.optionKeys.has(optionKey)) {
+      continue;
+    }
+    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);
+    }
+  }
+  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");
+  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.");
+  const author = toAuthor(options.author, settings.author_default);
+  const nowValue = /* @__PURE__ */ new Date();
+  const nowIso = nowValue.toISOString();
+  const dependencyUpdates = parseDependencyAdditions(options.dep, settings.id_prefix, nowIso);
+  const dependencyRemovals = parseDependencyRemovals(options.depRemove, settings.id_prefix);
+  const commentUpdates = parseLogSeed("--comment", options.comment, nowIso, author);
+  const noteUpdates = parseLogSeed("--note", options.note, nowIso, author);
+  const learningUpdates = parseLogSeed("--learning", options.learning, nowIso, author);
+  const fileUpdates = parseFiles(options.file);
+  const testUpdates = parseTests(options.test);
+  const docUpdates = parseDocs(options.doc);
+  const parentReferenceWarnings = [];
+  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 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 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,
+    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
+  };
+  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 (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 }, global2);
+        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
+      }, global2);
+      const warnings = [...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);
+  }
+  const result = await mutateItem({
+    pmRoot,
+    settings,
+    typeToFolder: typeRegistry.type_to_folder,
+    id,
+    op: options.allowAuditUpdate === true || options.allowAuditDepUpdate === true ? "update_audit" : "update",
+    author,
+    message: options.message,
+    force: options.force,
+    bypassAssigneeConflict: options.allowAuditUpdate === true || options.allowAuditDepUpdate === true,
+    mutate(document) {
+      const changedFields = [];
+      const warnings = [];
+      let activeTypeName = resolveTypeName(document.metadata.type, typeRegistry) ?? document.metadata.type;
+      const metadataRecord = toItemRecord(document.metadata);
+      const setOrClearScalar = (optionValue, metadataKey, transform) => {
+        if (optionValue === void 0 && !clearFrontMatterKeys.has(metadataKey)) {
+          return;
+        }
+        if (clearFrontMatterKeys.has(metadataKey)) {
+          delete metadataRecord[metadataKey];
+        } else {
+          metadataRecord[metadataKey] = transform(optionValue);
+        }
+        changedFields.push(metadataKey);
+      };
+      const setOrClearTrimScalar = (optionValue, metadataKey) => {
+        setOrClearScalar(optionValue, metadataKey, (value) => value.trim());
+      };
+      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), EXIT_CODE.USAGE);
+        }
+        document.metadata.type = resolvedTypeName;
+        activeTypeName = resolvedTypeName;
+        changedFields.push("type");
+      }
+      enforceUpdateOptionsByType(activeTypeName, options, typeRegistry);
+      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");
+      }
+      setOrClearScalar(options.deadline, "deadline", (value) => resolveIsoOrRelative(value, nowValue, "deadline"));
+      setOrClearScalar(options.estimatedMinutes, "estimated_minutes", (value) => parseOptionalNumber(value, "estimated-minutes"));
+      setOrClearScalar(options.acceptanceCriteria, "acceptance_criteria", (value) => value);
+      setOrClearTrimScalar(options.definitionOfReady, "definition_of_ready");
+      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");
+      }
+      setOrClearTrimScalar(options.goal, "goal");
+      setOrClearTrimScalar(options.objective, "objective");
+      setOrClearTrimScalar(options.value, "value");
+      setOrClearTrimScalar(options.impact, "impact");
+      setOrClearTrimScalar(options.outcome, "outcome");
+      setOrClearTrimScalar(options.whyNow, "why_now");
+      if (options.assignee !== void 0 || clearFrontMatterKeys.has("assignee")) {
+        if (clearFrontMatterKeys.has("assignee")) {
+          delete document.metadata.assignee;
+        } else {
+          if (options.assignee.trim() === "") {
+            throw new PmCliError("--assignee must not be empty. Use --unset assignee to clear it.", EXIT_CODE.USAGE);
+          }
+          document.metadata.assignee = options.assignee.trim();
+        }
+        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");
+      }
+      setOrClearTrimScalar(options.reviewer, "reviewer");
+      setOrClearScalar(options.risk, "risk", (value) => ensureEnumValue(normalizeRiskInput(value), RISK_VALUES, "risk"));
+      setOrClearScalar(options.confidence, "confidence", (value) => parseConfidenceInput(value));
+      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);
+      }
+      setOrClearTrimScalar(options.blockedReason, "blocked_reason");
+      setOrClearTrimScalar(options.unblockNote, "unblock_note");
+      setOrClearTrimScalar(options.reporter, "reporter");
+      setOrClearScalar(options.severity, "severity", (value) => ensureEnumValue(normalizeSeverityInput(value), ISSUE_SEVERITY_VALUES, "severity"));
+      setOrClearTrimScalar(options.environment, "environment");
+      setOrClearTrimScalar(options.reproSteps, "repro_steps");
+      setOrClearTrimScalar(options.resolution, "resolution");
+      setOrClearTrimScalar(options.expectedResult, "expected_result");
+      setOrClearTrimScalar(options.actualResult, "actual_result");
+      setOrClearTrimScalar(options.affectedVersion, "affected_version");
+      setOrClearTrimScalar(options.fixedVersion, "fixed_version");
+      setOrClearTrimScalar(options.component, "component");
+      setOrClearScalar(options.regression, "regression", (value) => parseRegressionInput(value));
+      setOrClearTrimScalar(options.customerImpact, "customer_impact");
+      if (options.reminder !== void 0 || clearFrontMatterKeys.has("reminders")) {
+        if (clearFrontMatterKeys.has("reminders")) {
+          delete document.metadata.reminders;
+        } else {
+          document.metadata.reminders = parseReminderEntries(options.reminder, nowValue);
+        }
+        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);
+        }
+        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);
+      }
+      const runtimeFieldUpdates = collectRuntimeUpdateFieldValues(options, runtimeFieldRegistry);
+      for (const [fieldKey, fieldValue] of Object.entries(runtimeFieldUpdates)) {
+        if (clearFrontMatterKeys.has(fieldKey)) {
+          continue;
+        }
+        if (JSON.stringify(metadataRecord[fieldKey]) === JSON.stringify(fieldValue)) {
+          continue;
+        }
+        metadataRecord[fieldKey] = fieldValue;
+        changedFields.push(fieldKey);
+      }
+      try {
+        applyRegisteredItemFieldDefaultsAndValidation(metadataRecord, getActiveExtensionRegistrations());
+      } catch (error) {
+        throw new PmCliError(error instanceof Error ? error.message : "Invalid extension item field values", EXIT_CODE.USAGE);
+      }
+      return { changedFields, warnings };
+    }
+  });
+  return {
+    item: toItemRecord(result.item),
+    changed_fields: result.changedFields,
+    warnings: [...parentReferenceWarnings, ...result.warnings],
+    ...options.allowAuditUpdate === true || options.allowAuditDepUpdate === true ? { audit_update: true } : {}
+  };
+}
+
+export {
+  runUpdate
+};
+//# sourceMappingURL=chunk-3M73P3G6.js.map