@unbrained/pm-cli 2026.7.5 → 2026.7.6

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

@@ -0,0 +1,1573 @@
+import {
+  COMMON_UNSET_FIELD_DEFINITIONS_AFTER_AUTHOR,
+  COMMON_UNSET_FIELD_DEFINITIONS_AFTER_CLOSE_REASON_BEFORE_AUTHOR,
+  COMMON_UNSET_FIELD_DEFINITIONS_BEFORE_CLOSE_REASON,
+  applyLegacyNoneCollectionNormalizers,
+  assertNoLegacyNoneToken,
+  assertNoLegacyNoneTokens,
+  ensureEnumValue,
+  isLegacyNoneToken,
+  normalizeRiskInput,
+  normalizeSeverityInput,
+  parseCommandUnsetTargets,
+  parseConfidenceInput,
+  parseDocs,
+  parseEventEntries,
+  parseFiles,
+  parseLogSeed,
+  parseRegressionInput,
+  parseReminderEntries,
+  parseTests,
+  parseTypeOptionEntries,
+  resolvePriority,
+  resolveRuntimeUnsetFieldDefinition
+} from "./chunk-SCUR7K7N.js";
+import {
+  applyTagRemovals,
+  assertNoUnknownCsvKeys,
+  createStdinTokenResolver,
+  looksLikeGenericKeyValueEntry,
+  mergeAdditiveTags,
+  parseCsvKv,
+  parseOptionalNumber,
+  parseTags
+} from "./chunk-AZYGZGGI.js";
+import {
+  runClose
+} from "./chunk-W3DSJQIO.js";
+import {
+  describeAllowedTransitions,
+  evaluateTransition,
+  resolveTypeWorkflows
+} from "./chunk-CZVISY5A.js";
+import {
+  applyRegisteredItemFieldDefaultsAndValidation,
+  buildItemNotFoundError,
+  collectRegisteredItemFieldNames,
+  locateItem,
+  mutateItem,
+  parseRegisteredItemFieldAssignments,
+  readLocatedItem,
+  toItemRecord
+} from "./chunk-5VAA4YHR.js";
+import {
+  assertParentReferenceIsNotSelf,
+  normalizeParentReferenceValue,
+  validateMissingParentReference,
+  validateSprintOrReleaseValue
+} from "./chunk-ALFPSEWO.js";
+import {
+  collectRuntimeUpdateFieldValues,
+  normalizeItemId,
+  normalizeStatusInput
+} from "./chunk-NMP5I3I5.js";
+import {
+  resolveIsoOrRelative
+} from "./chunk-FLZSGSQR.js";
+import {
+  PmCliError,
+  getActiveExtensionRegistrations,
+  readSettings,
+  stableValueEquals
+} from "./chunk-SHQY2IDC.js";
+import {
+  buildInvalidTypeError
+} from "./chunk-NGXQ3PFT.js";
+import {
+  COMMON_MUTATION_COMMAND_OPTION_KEYS,
+  DEPENDENCY_KIND_VALUES,
+  EXIT_CODE,
+  ISSUE_SEVERITY_VALUES,
+  RISK_VALUES,
+  canonicalizeCommandOptionKey,
+  commandOptionFlagLabel,
+  getSettingsPath,
+  pathExists,
+  resolveCommandOptionPolicyState,
+  resolveItemTypeRegistry,
+  resolveItemTypesFilePath,
+  resolvePmRoot,
+  resolveRuntimeFieldRegistry,
+  resolveRuntimeStatusRegistry,
+  resolveTypeDefinition,
+  resolveTypeName,
+  validateTypeOptions
+} from "./chunk-LK6XLOGP.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] = "74de80a0-4291-5c52-b619-620900850237");
+  } catch (e2) {
+  }
+})();
+var UPDATE_UNSET_FIELD_DEFINITIONS = [
+  ...COMMON_UNSET_FIELD_DEFINITIONS_BEFORE_CLOSE_REASON,
+  { canonical: "close-reason", aliases: ["close_reason", "close-reason"], optionKey: "closeReason", frontMatterKey: "close_reason" },
+  ...COMMON_UNSET_FIELD_DEFINITIONS_AFTER_CLOSE_REASON_BEFORE_AUTHOR,
+  ...COMMON_UNSET_FIELD_DEFINITIONS_AFTER_AUTHOR
+];
+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", disableFlagKey: "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", disableFlagKey: "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;
+  }
+  return applyLegacyNoneCollectionNormalizers(normalized, UPDATE_LEGACY_NONE_COLLECTION_NORMALIZERS);
+}
+function parseUpdateUnsetTargets(raw, runtimeFieldRegistry, extensionFieldNames = []) {
+  return parseCommandUnsetTargets({
+    raw,
+    supportedFields: UPDATE_UNSET_SUPPORTED_CANONICAL_FIELDS,
+    resolveDefinition: (trimmed) => {
+      const extensionFieldName = extensionFieldNames.find((fieldName) => {
+        const normalizedFieldName = fieldName.toLowerCase();
+        return normalizedFieldName === trimmed || normalizedFieldName.replaceAll("_", "-") === trimmed || normalizedFieldName.replaceAll("-", "_") === trimmed;
+      });
+      const definition = UPDATE_UNSET_ALIAS_MAP.get(trimmed) ?? resolveRuntimeUnsetFieldDefinition(trimmed, "update", runtimeFieldRegistry) ?? (extensionFieldName ? { optionKey: "field", frontMatterKey: extensionFieldName } : void 0);
+      return definition;
+    }
+  });
+}
+var AUDIT_RESTRICTED_FLAG_REPLACEMENTS = /* @__PURE__ */ new Map([
+  ["--comment", (id) => `pm comments ${id} --add "<text>" --allow-audit-comment`],
+  ["--file", (id) => `pm files ${id} --add "path=<path>,scope=<scope>,note=<note>" --force`],
+  ["--doc", (id) => `pm docs ${id} --add "path=<path>,scope=<scope>,note=<note>" --force`]
+]);
+function buildAuditScopeRestrictedOptionsError(params) {
+  const replacementCommands = params.disallowedFlags.flatMap((flag) => {
+    const replacement = AUDIT_RESTRICTED_FLAG_REPLACEMENTS.get(flag);
+    return replacement ? [replacement(params.id)] : [];
+  });
+  const replacementSteps = params.disallowedFlags.flatMap((flag) => {
+    const replacement = AUDIT_RESTRICTED_FLAG_REPLACEMENTS.get(flag);
+    return replacement ? [`Replace ${flag} with: ${replacement(params.id)}`] : [];
+  });
+  return new PmCliError(params.message, EXIT_CODE.USAGE, {
+    code: params.code,
+    required: params.required,
+    why: params.why,
+    ...replacementCommands.length > 0 ? { examples: replacementCommands } : {},
+    nextSteps: [
+      `Re-run without: ${params.disallowedFlags.join(", ")}`,
+      ...replacementSteps
+    ]
+  });
+}
+function enforceAllowAuditUpdateScope(id, 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 buildAuditScopeRestrictedOptionsError({
+        id,
+        code: "audit_dep_update_restricted_options",
+        message: `--allow-audit-dep-update supports append-only dependency additions via --dep. Remove restricted options: ${disallowedFlags2.join(", ")}`,
+        required: "Pass only --dep additions (plus --message/--author) when using --allow-audit-dep-update.",
+        why: "--allow-audit-dep-update is a narrow non-owner override scoped to append-only dependency additions; every other mutation keeps its normal ownership rules.",
+        disallowedFlags: disallowedFlags2
+      });
+    }
+    return;
+  }
+  const disallowedFlags = [];
+  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) {
+    throw buildAuditScopeRestrictedOptionsError({
+      id,
+      code: "audit_update_restricted_options",
+      message: `--allow-audit-update only supports non-lifecycle metadata fields and evidence appends. Remove restricted options: ${disallowedFlags.join(", ")}`,
+      required: "Limit --allow-audit-update to non-lifecycle metadata fields plus append-only --comment/--file/--doc evidence; route restricted appends and lifecycle changes through their dedicated commands.",
+      why: "--allow-audit-update is a non-owner override scoped to metadata audits and append-only evidence; lifecycle, ownership, dependency mutations, restricted append fields, and clear/replace operations keep their normal ownership rules.",
+      disallowedFlags
+    });
+  }
+}
+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 enforceTypeWorkflowTransition(params) {
+  if (params.enforcement === "off" || params.typeWorkflows.length === 0) {
+    return void 0;
+  }
+  const result = evaluateTransition({
+    typeName: params.typeName,
+    fromStatus: params.fromStatus,
+    toStatus: params.toStatus,
+    typeWorkflows: params.typeWorkflows,
+    statusRegistry: params.statusRegistry
+  });
+  if (!result.hasRule || result.allowed) {
+    return void 0;
+  }
+  const normalizedFrom = normalizeStatusInput(params.fromStatus, params.statusRegistry) ?? params.fromStatus;
+  const normalizedTo = normalizeStatusInput(params.toStatus, params.statusRegistry) ?? params.toStatus;
+  const message = `Disallowed transition for type "${params.typeName}": ${normalizedFrom} -> ${normalizedTo}. Allowed transitions: ${describeAllowedTransitions(result.allowedTransitions)}.`;
+  if (params.enforcement === "strict") {
+    throw new PmCliError(message, EXIT_CODE.USAGE);
+  }
+  return `workflow_transition_not_allowed: ${message}`;
+}
+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;
+}
+var DEP_ADDITION_KEYS = ["id", "kind", "type", "author", "created_at", "source_kind"];
+var DEP_REMOVE_KEYS = ["id", "kind", "type", "source_kind"];
+function looksLikeStructuredDependencyEntry(raw) {
+  if (raw.startsWith("```") || raw.includes("\n")) {
+    return true;
+  }
+  if (/^(?:[-*+]\s+)?(?:id|kind|type|author|created_at|source_kind)\s*[:=]/i.test(raw)) {
+    return true;
+  }
+  return looksLikeGenericKeyValueEntry(raw);
+}
+var DEPENDENCY_KIND_INPUT_ALIASES = {
+  "blocked-by": "blocked_by",
+  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 isStructured = looksLikeStructuredDependencyEntry(trimmedEntry);
+    const kv = isStructured ? parseCsvKv(entry, "--dep") : { id: trimmedEntry, kind: "related" };
+    if (isStructured) {
+      assertNoUnknownCsvKeys(kv, "--dep", DEP_ADDITION_KEYS);
+    }
+    const id = kv.id?.trim();
+    const kind = normalizeDependencyKindInput((kv.kind ?? kv.type)?.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|type|source_kind)\s*[:=]/i.test(trimmed) || trimmed.startsWith("```")) {
+      const kv = parseCsvKv(trimmed, "--dep-remove");
+      assertNoUnknownCsvKeys(kv, "--dep-remove", DEP_REMOVE_KEYS);
+      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 ?? kv.type));
+      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, runtimeFieldRegistry, extensionFieldNames) {
+  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("field", options.field !== 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, runtimeFieldRegistry, extensionFieldNames);
+    for (const optionKey of unsetTargets.optionKeys) {
+      mark(optionKey, true);
+    }
+  }
+  return provided;
+}
+function enforceUpdateOptionsByType(typeName, options, typeRegistry, runtimeFieldRegistry, extensionFieldNames) {
+  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, 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);
+    }
+  }
+  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);
+    }
+  }
+}
+var UPDATE_LEGACY_COMMON_SCALAR_OPTION_EXCLUSIONS = /* @__PURE__ */ new Set(["order", "rank"]);
+var UPDATE_LEGACY_COMMON_SCALAR_OPTION_KEYS = COMMON_MUTATION_COMMAND_OPTION_KEYS.filter((key) => !UPDATE_LEGACY_COMMON_SCALAR_OPTION_EXCLUSIONS.has(key));
+var UPDATE_LEGACY_SCALAR_OPTION_KEYS = [
+  "tags",
+  "closeReason",
+  ...UPDATE_LEGACY_COMMON_SCALAR_OPTION_KEYS
+];
+var UPDATE_SIMPLE_FIELD_FLAG_KEYS = [
+  "title",
+  "description",
+  "body",
+  "status",
+  "closeReason",
+  "priority",
+  "type",
+  ...COMMON_MUTATION_COMMAND_OPTION_KEYS,
+  "dep",
+  "depRemove",
+  "comment",
+  "note",
+  "learning",
+  "file",
+  "test",
+  "doc",
+  "reminder",
+  "event",
+  "typeOption",
+  "field"
+];
+var UPDATE_POST_TAG_SCALAR_MUTATIONS = [
+  {
+    optionKey: "deadline",
+    metadataKey: "deadline",
+    transform: (value, context) => resolveIsoOrRelative(value, context.nowValue, "deadline")
+  },
+  {
+    optionKey: "estimatedMinutes",
+    metadataKey: "estimated_minutes",
+    transform: (value) => parseOptionalNumber(value, "estimated-minutes")
+  },
+  { optionKey: "acceptanceCriteria", metadataKey: "acceptance_criteria", transform: (value) => value },
+  { optionKey: "definitionOfReady", metadataKey: "definition_of_ready" },
+  { optionKey: "goal", metadataKey: "goal" },
+  { optionKey: "objective", metadataKey: "objective" },
+  { optionKey: "value", metadataKey: "value" },
+  { optionKey: "impact", metadataKey: "impact" },
+  { optionKey: "outcome", metadataKey: "outcome" },
+  { optionKey: "whyNow", metadataKey: "why_now" }
+];
+var UPDATE_STAKEHOLDER_SCALAR_MUTATIONS = [
+  { optionKey: "reviewer", metadataKey: "reviewer" },
+  { optionKey: "risk", metadataKey: "risk", transform: (value) => ensureEnumValue(normalizeRiskInput(value), RISK_VALUES, "risk") },
+  { optionKey: "confidence", metadataKey: "confidence", transform: (value) => parseConfidenceInput(value) }
+];
+var UPDATE_ISSUE_SCALAR_MUTATIONS = [
+  { optionKey: "blockedReason", metadataKey: "blocked_reason" },
+  { optionKey: "unblockNote", metadataKey: "unblock_note" },
+  { optionKey: "reporter", metadataKey: "reporter" },
+  {
+    optionKey: "severity",
+    metadataKey: "severity",
+    transform: (value) => ensureEnumValue(normalizeSeverityInput(value), ISSUE_SEVERITY_VALUES, "severity")
+  },
+  { optionKey: "environment", metadataKey: "environment" },
+  { optionKey: "reproSteps", metadataKey: "repro_steps" },
+  { optionKey: "resolution", metadataKey: "resolution" },
+  { optionKey: "expectedResult", metadataKey: "expected_result" },
+  { optionKey: "actualResult", metadataKey: "actual_result" },
+  { optionKey: "affectedVersion", metadataKey: "affected_version" },
+  { optionKey: "fixedVersion", metadataKey: "fixed_version" },
+  { optionKey: "component", metadataKey: "component" },
+  { optionKey: "regression", metadataKey: "regression", transform: (value) => parseRegressionInput(value) },
+  { optionKey: "customerImpact", metadataKey: "customer_impact" }
+];
+function applyUpdateScalarMutations(definitions, options, context) {
+  for (const definition of definitions) {
+    const optionValue = options[definition.optionKey];
+    const shouldClear = context.clearFrontMatterKeys.has(definition.metadataKey);
+    if (optionValue === void 0 && !shouldClear) {
+      continue;
+    }
+    if (shouldClear) {
+      delete context.metadataRecord[definition.metadataKey];
+      context.changedFields.push(definition.metadataKey);
+      continue;
+    }
+    if (typeof optionValue !== "string") {
+      throw new PmCliError(`${commandOptionFlagLabel("update", String(definition.optionKey))} must be a string value`, EXIT_CODE.USAGE);
+    }
+    context.metadataRecord[definition.metadataKey] = definition.transform ? definition.transform(optionValue, context) : optionValue.trim();
+    context.changedFields.push(definition.metadataKey);
+  }
+}
+async function resolveStdinUpdateOptions(options) {
+  const stdinResolver = createStdinTokenResolver();
+  return 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"),
+    field: await stdinResolver.resolveList(options.field, "--field")
+  });
+}
+function buildClearCollectionDefinitions(options) {
+  return [
+    {
+      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"
+    }
+  ];
+}
+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);
+  }
+  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);
+  }
+}
+function applyClearCollectionDefinitions(params) {
+  for (const definition of params.definitions) {
+    if (!definition.enabled) {
+      continue;
+    }
+    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);
+    }
+    params.clearOptionKeys.add(definition.optionKey);
+    params.clearFrontMatterKeys.add(definition.frontMatterKey);
+  }
+}
+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;
+    }
+    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 (!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);
+  };
+  for (const key of UPDATE_LEGACY_SCALAR_OPTION_KEYS) {
+    assertNoLegacyScalarToken(options[key], String(key));
+  }
+  assertNoLegacyScalarToken(options.order ?? options.rank, "order");
+  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);
+  assertParentReferenceIsNotSelf(params.id, resolvedParentValue, params.settings.id_prefix);
+  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, global2) {
+  options = await resolveStdinUpdateOptions(options);
+  const pmRoot = resolvePmRoot(process.cwd(), global2.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();
+  const dependencyUpdates = parseDependencyAdditions(options.dep, settings.id_prefix, nowIso);
+  const dependencyRemovals = parseDependencyRemovals(options.depRemove, settings.id_prefix);
+  const parsedCommentUpdates = parseLogSeed("--comment", options.comment, nowIso, author);
+  const commentUpdates = options.allowAuditUpdate === true && parsedCommentUpdates.values ? {
+    ...parsedCommentUpdates,
+    values: parsedCommentUpdates.values.map((entry) => ({ ...entry, author }))
+  } : parsedCommentUpdates;
+  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 workflowTransitionWarnings = [];
+  const parentReference = await resolveParentReferenceForUpdate({
+    id,
+    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;
+  const parentReferenceWarnings = [...parentReference.warnings, ...blockedByResolutionWarnings(blockedByResolution)];
+  const runtimeFieldUpdates = collectRuntimeUpdateFieldValues(options, runtimeFieldRegistry, options.runtimeFieldCommands);
+  const fieldFlags = buildUpdateFieldFlags(options, runtimeFieldUpdates);
+  const changedFlags = Object.values(fieldFlags).some(Boolean);
+  if (!changedFlags) {
+    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: global2,
+    id
+  });
+  if (routedClose) {
+    return routedClose;
+  }
+  assertMatchingOrderRank(options);
+  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,
+    extensionFieldNames,
+    mutate(document) {
+      return mutateUpdateDocument(document, {
+        options,
+        settings,
+        typeRegistry,
+        statusRegistry,
+        runtimeFieldRegistry,
+        extensionRegistrations,
+        extensionFieldNames,
+        clearFrontMatterKeys,
+        dependencyUpdates,
+        dependencyRemovals,
+        commentUpdates,
+        noteUpdates,
+        learningUpdates,
+        fileUpdates,
+        testUpdates,
+        docUpdates,
+        resolvedParentValue: parentReference.resolvedParentValue,
+        resolvedBlockedByDependencyId,
+        runtimeFieldUpdates,
+        nowValue,
+        nowIso,
+        author,
+        pmRoot
+      });
+    }
+  });
+  return {
+    item: toItemRecord(result.item),
+    changed_fields: result.changedFields,
+    warnings: [...workflowTransitionWarnings, ...parentReferenceWarnings, ...result.warnings],
+    ...options.allowAuditUpdate === true || options.allowAuditDepUpdate === true ? { audit_update: true } : {}
+  };
+}
+var _testOnlyUpdateCommand = {
+  collectProvidedUpdatePolicyOptions,
+  buildAuditScopeRestrictedOptionsError,
+  enforceAllowAuditUpdateScope,
+  enforceTypeWorkflowTransition,
+  matchesDependencySelector,
+  normalizeLegacyNoneUpdateOptions,
+  normalizeUpdatePolicyOptionKey,
+  parseDependencyAdditions,
+  parseDependencyRemovals,
+  parseUpdateUnsetTargets,
+  reconcileBlockedByDependency,
+  resolveRuntimeUnsetDefinition: (token, registry) => resolveRuntimeUnsetFieldDefinition(token, "update", registry)
+};
+
+export {
+  runUpdate,
+  _testOnlyUpdateCommand
+};
+//# sourceMappingURL=chunk-3UJRFJ5R.js.map