@unbrained/pm-cli 2026.7.5 → 2026.7.6

package/dist/cli-bundle/chunks/chunk-YMABYTNG.js

@@ -1,1573 +0,0 @@
-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-MTTXDAK4.js";
-import {
-  applyTagRemovals,
-  assertNoUnknownCsvKeys,
-  createStdinTokenResolver,
-  looksLikeGenericKeyValueEntry,
-  mergeAdditiveTags,
-  parseCsvKv,
-  parseOptionalNumber,
-  parseTags
-} from "./chunk-T3ABIMGW.js";
-import {
-  runClose
-} from "./chunk-FGQKEDE4.js";
-import {
-  describeAllowedTransitions,
-  evaluateTransition,
-  resolveTypeWorkflows
-} from "./chunk-CZVISY5A.js";
-import {
-  applyRegisteredItemFieldDefaultsAndValidation,
-  buildItemNotFoundError,
-  collectRegisteredItemFieldNames,
-  locateItem,
-  mutateItem,
-  parseRegisteredItemFieldAssignments,
-  readLocatedItem,
-  toItemRecord
-} from "./chunk-3U3VEWK6.js";
-import {
-  assertParentReferenceIsNotSelf,
-  normalizeParentReferenceValue,
-  validateMissingParentReference,
-  validateSprintOrReleaseValue
-} from "./chunk-OWTIRHX4.js";
-import {
-  collectRuntimeUpdateFieldValues,
-  normalizeItemId,
-  normalizeStatusInput
-} from "./chunk-EZFKWSC7.js";
-import {
-  resolveIsoOrRelative
-} from "./chunk-DRBV5UC2.js";
-import {
-  PmCliError,
-  getActiveExtensionRegistrations,
-  readSettings,
-  stableValueEquals
-} from "./chunk-P5YORJRH.js";
-import {
-  buildInvalidTypeError
-} from "./chunk-T35XLYZF.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-5VVUKE3U.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-YMABYTNG.js.map