@unbrained/pm-cli 2026.5.31 → 2026.6.5

package/dist/cli-bundle/chunks/{chunk-3M73P3G6.js → chunk-D5X7N6FI.js}

@@ -1,5 +1,4 @@
 import {
-  applyRegisteredItemFieldDefaultsAndValidation,
   assertNoLegacyNoneToken,
   assertNoLegacyNoneTokens,
   ensureEnumValue,
@@ -8,18 +7,15 @@ import {
   normalizeSeverityInput,
   parseConfidenceInput,
   parseDocs,
-  parseEventBoolean,
+  parseEventEntries,
   parseFiles,
   parseLogSeed,
-  parseRecurrenceRule,
   parseRegressionInput,
+  parseReminderEntries,
   parseTests,
-  resolveEventEndAt,
+  parseTypeOptionEntries,
   resolvePriority
-} from "./chunk-JTWRXG4B.js";
-import {
-  buildInvalidTypeError
-} from "./chunk-7Y53ZJIQ.js";
+} from "./chunk-OUF3ARDX.js";
 import {
   applyTagRemovals,
   createStdinTokenResolver,
@@ -27,29 +23,35 @@ import {
   parseCsvKv,
   parseOptionalNumber,
   parseTags
-} from "./chunk-NGN7UV5K.js";
+} from "./chunk-CJDQB2ED.js";
 import {
   runClose
-} from "./chunk-G57E5D7T.js";
+} from "./chunk-ATBVS6WW.js";
 import {
   normalizeParentReferenceValue,
   validateMissingParentReference,
   validateSprintOrReleaseValue
-} from "./chunk-AKOOMO3T.js";
+} from "./chunk-XX5LRINW.js";
+import {
+  buildInvalidTypeError
+} from "./chunk-KK6YPGH3.js";
 import {
+  applyRegisteredItemFieldDefaultsAndValidation,
   buildItemNotFoundError,
+  collectRegisteredItemFieldNames,
   locateItem,
   mutateItem,
+  parseRegisteredItemFieldAssignments,
   readLocatedItem,
   toItemRecord
-} from "./chunk-BUPWJ3IJ.js";
+} from "./chunk-XG7RJYHV.js";
 import {
   normalizeItemId
-} from "./chunk-CEFIVZPG.js";
+} from "./chunk-KA24HME7.js";
 import {
   collectRuntimeUpdateFieldValues,
   normalizeStatusInput
-} from "./chunk-MD7K4JYF.js";
+} from "./chunk-HPH6X4ZZ.js";
 import {
   canonicalizeCommandOptionKey,
   commandOptionFlagLabel,
@@ -58,10 +60,10 @@ import {
   resolveTypeDefinition,
   resolveTypeName,
   validateTypeOptions
-} from "./chunk-WDPXDQFG.js";
+} from "./chunk-4PJQSECJ.js";
 import {
   resolveIsoOrRelative
-} from "./chunk-PVNQLCIS.js";
+} from "./chunk-RANZIID5.js";
 import {
   DEPENDENCY_KIND_VALUES,
   EXIT_CODE,
@@ -74,14 +76,95 @@ import {
   readSettings,
   resolvePmRoot,
   resolveRuntimeFieldRegistry,
-  resolveRuntimeStatusRegistry
-} from "./chunk-LSXGH6NE.js";
+  resolveRuntimeStatusRegistry,
+  stableValueEquals
+} from "./chunk-SRVKTWPR.js";
+
+// dist/core/schema/type-workflows.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] = "70ab7197-566b-52de-8a82-e432b324ad8d");
+  } catch (e2) {
+  }
+})();
+function normalizeStatusToken(value) {
+  return typeof value === "string" ? value.trim().toLowerCase().replaceAll(/[\s-]+/g, "_") : "";
+}
+function normalizeTypeName(value) {
+  return typeof value === "string" ? value.trim().toLowerCase() : "";
+}
+function resolveStatusId(value, statusRegistry) {
+  const token = normalizeStatusToken(value);
+  if (token.length === 0) {
+    return "";
+  }
+  return statusRegistry?.alias_to_id?.get(token) ?? token;
+}
+function resolveTypeWorkflows(schema) {
+  const rawWorkflows = Array.isArray(schema?.type_workflows) ? schema.type_workflows : [];
+  const byType = /* @__PURE__ */ new Map();
+  for (const entry of rawWorkflows) {
+    const type = normalizeTypeName(entry?.type);
+    if (type.length === 0) {
+      continue;
+    }
+    if (!Array.isArray(entry?.allowed_transitions)) {
+      continue;
+    }
+    const pairs = entry.allowed_transitions;
+    const record = byType.get(type) ?? { pairs: [], denyAll: false };
+    if (pairs.length === 0) {
+      record.denyAll = true;
+    }
+    for (const pair of pairs) {
+      if (!Array.isArray(pair) || pair.length !== 2) {
+        continue;
+      }
+      const from = normalizeStatusToken(pair[0]);
+      const to = normalizeStatusToken(pair[1]);
+      if (from.length === 0 || to.length === 0) {
+        continue;
+      }
+      if (record.pairs.some((candidate) => candidate[0] === from && candidate[1] === to)) {
+        continue;
+      }
+      record.pairs.push([from, to]);
+    }
+    byType.set(type, record);
+  }
+  return [...byType.entries()].filter(([, record]) => record.pairs.length > 0 || record.denyAll).map(([type, record]) => ({ type, allowed_transitions: record.pairs })).sort((left, right) => left.type.localeCompare(right.type));
+}
+function evaluateTransition(input) {
+  const typeName = normalizeTypeName(input.typeName);
+  const matched = input.typeWorkflows.find((workflow) => workflow.type === typeName);
+  if (!matched) {
+    return { allowed: true, hasRule: false, allowedTransitions: [] };
+  }
+  const from = resolveStatusId(input.fromStatus, input.statusRegistry);
+  const to = resolveStatusId(input.toStatus, input.statusRegistry);
+  if (from.length > 0 && from === to) {
+    return { allowed: true, hasRule: true, allowedTransitions: matched.allowed_transitions };
+  }
+  const allowed = matched.allowed_transitions.some((pair) => {
+    const ruleFrom = resolveStatusId(pair[0], input.statusRegistry);
+    const ruleTo = resolveStatusId(pair[1], input.statusRegistry);
+    return ruleFrom === from && ruleTo === to;
+  });
+  return { allowed, hasRule: true, allowedTransitions: matched.allowed_transitions };
+}
+function describeAllowedTransitions(allowedTransitions) {
+  if (allowedTransitions.length === 0) {
+    return "(no transitions allowed)";
+  }
+  return allowedTransitions.map((pair) => `${pair[0]} -> ${pair[1]}`).join(", ");
+}
 
 // dist/cli/commands/update.js
 !(function() {
   try {
     var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
-    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "3722af32-cd81-5b1e-bc17-bdb1f3335754");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "74fefeac-195a-595c-aa23-d38e5b855b84");
   } catch (e2) {
   }
 })();
@@ -309,7 +392,7 @@ function resolveRuntimeUnsetDefinition(token, runtimeFieldRegistry) {
   }
   return void 0;
 }
-function parseUpdateUnsetTargets(raw, runtimeFieldRegistry) {
+function parseUpdateUnsetTargets(raw, runtimeFieldRegistry, extensionFieldNames = []) {
   const frontMatterKeys = /* @__PURE__ */ new Set();
   const optionKeys = /* @__PURE__ */ new Set();
   if (!raw || raw.length === 0) {
@@ -323,7 +406,11 @@ function parseUpdateUnsetTargets(raw, runtimeFieldRegistry) {
     if (isLegacyNoneToken(trimmed)) {
       throw new PmCliError('--unset no longer accepts "none" or "null". Specify concrete field names such as --unset deadline', EXIT_CODE.USAGE);
     }
-    const definition = UPDATE_UNSET_ALIAS_MAP.get(trimmed) ?? resolveRuntimeUnsetDefinition(trimmed, runtimeFieldRegistry);
+    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) ?? resolveRuntimeUnsetDefinition(trimmed, runtimeFieldRegistry) ?? (extensionFieldName ? { optionKey: "field", frontMatterKey: extensionFieldName } : void 0);
     if (!definition) {
       throw new PmCliError(`Unsupported --unset field "${entry}". Supported fields: ${UPDATE_UNSET_SUPPORTED_CANONICAL_FIELDS}`, EXIT_CODE.USAGE);
     }
@@ -522,98 +609,27 @@ function parseStatus(value, statusRegistry) {
   }
   return normalized;
 }
-function parseReminderEntries(raw, nowValue) {
-  return raw.map((entry) => {
-    const kv = parseCsvKv(entry, "--reminder");
-    const atRaw = (kv.at ?? kv.date)?.trim();
-    const textRaw = (kv.text ?? kv.title)?.trim();
-    if (!atRaw || !textRaw) {
-      throw new PmCliError("--reminder requires at=<iso|relative> or date=<iso|relative>, plus text=<value> or title=<value>", EXIT_CODE.USAGE);
-    }
-    return {
-      at: resolveIsoOrRelative(atRaw, nowValue, "reminder.at"),
-      text: textRaw
-    };
-  });
-}
-function parseEventEntries(raw, nowValue) {
-  return raw.map((entry) => {
-    const kv = parseCsvKv(entry, "--event");
-    const startRaw = (kv.start ?? kv.date)?.trim();
-    if (!startRaw) {
-      throw new PmCliError("--event requires start=<iso|relative> or date=<iso|relative>", EXIT_CODE.USAGE);
-    }
-    const startAt = resolveIsoOrRelative(startRaw, nowValue, "event.start");
-    const endRaw = kv.end?.trim();
-    const durationRaw = kv.duration?.trim();
-    const endAt = resolveEventEndAt(startAt, endRaw, durationRaw, nowValue);
-    const titleRaw = kv.title;
-    const descriptionRaw = kv.description;
-    const locationRaw = kv.location;
-    const timezoneRaw = kv.timezone;
-    const title = titleRaw?.trim();
-    const description = descriptionRaw?.trim();
-    const location = locationRaw?.trim();
-    const timezone = timezoneRaw?.trim();
-    if (titleRaw !== void 0 && !title) {
-      throw new PmCliError("--event title must not be empty", EXIT_CODE.USAGE);
-    }
-    if (descriptionRaw !== void 0 && !description) {
-      throw new PmCliError("--event description must not be empty", EXIT_CODE.USAGE);
-    }
-    if (locationRaw !== void 0 && !location) {
-      throw new PmCliError("--event location must not be empty", EXIT_CODE.USAGE);
-    }
-    if (timezoneRaw !== void 0 && !timezone) {
-      throw new PmCliError("--event timezone must not be empty", EXIT_CODE.USAGE);
-    }
-    const allDayRaw = kv.all_day?.trim();
-    const recurrence = parseRecurrenceRule(kv, startAt, nowValue, "truthy");
-    return {
-      start_at: startAt,
-      end_at: endAt,
-      title,
-      description,
-      location,
-      all_day: allDayRaw ? parseEventBoolean(allDayRaw, "--event all_day") : void 0,
-      timezone,
-      recurrence
-    };
+function 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
   });
-}
-function parseTypeOptionEntries(raw) {
-  const values = {};
-  for (const entry of raw) {
-    const trimmedEntry = entry.trim();
-    if (trimmedEntry.length === 0) {
-      throw new PmCliError("--type-option values must not be empty", EXIT_CODE.USAGE);
-    }
-    let key;
-    let value;
-    const prefersStructuredKv = trimmedEntry.includes(",") || trimmedEntry.includes("\n") || trimmedEntry.startsWith("```") || /^(?:[-*+]\s+)?(?:key|value)\s*[:=]/i.test(trimmedEntry);
-    if (prefersStructuredKv) {
-      const kv = parseCsvKv(trimmedEntry, "--type-option");
-      key = kv.key?.trim();
-      value = kv.value?.trim();
-    } else {
-      const equalsIndex = trimmedEntry.indexOf("=");
-      const colonIndex = trimmedEntry.indexOf(":");
-      let separatorIndex = equalsIndex;
-      if (equalsIndex <= 0 && colonIndex > 0) {
-        separatorIndex = colonIndex;
-      }
-      if (separatorIndex <= 0 || separatorIndex === trimmedEntry.length - 1) {
-        throw new PmCliError("--type-option requires key=value or key=<name>,value=<value> entries", EXIT_CODE.USAGE);
-      }
-      key = trimmedEntry.slice(0, separatorIndex).trim();
-      value = trimmedEntry.slice(separatorIndex + 1).trim();
-    }
-    if (!key || !value) {
-      throw new PmCliError("--type-option requires key and value", EXIT_CODE.USAGE);
-    }
-    values[key] = value;
+  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 Object.fromEntries(Object.entries(values).sort((left, right) => left[0].localeCompare(right[0])));
+  return `workflow_transition_not_allowed: ${message}`;
 }
 function parseDependencyCreatedAt(value, currentIso) {
   if (!value || value.trim() === "" || value.trim().toLowerCase() === "now") {
@@ -635,9 +651,10 @@ function looksLikeStructuredDependencyEntry(raw) {
   if (raw.startsWith("```") || raw.includes("\n")) {
     return true;
   }
-  return /^(?:[-*+]\s+)?(?:id|kind|author|created_at|source_kind)\s*[:=]/i.test(raw);
+  return /^(?:[-*+]\s+)?(?:id|kind|type|author|created_at|source_kind)\s*[:=]/i.test(raw);
 }
 var DEPENDENCY_KIND_INPUT_ALIASES = {
+  "blocked-by": "blocked_by",
   depends_on: "blocked_by",
   "depends-on": "blocked_by"
 };
@@ -658,7 +675,7 @@ function parseDependencyAdditions(raw, prefix, nowIso) {
     const trimmedEntry = entry.trim();
     const kv = looksLikeStructuredDependencyEntry(trimmedEntry) ? parseCsvKv(entry, "--dep") : { id: trimmedEntry, kind: "related" };
     const id = kv.id?.trim();
-    const kind = normalizeDependencyKindInput(kv.kind?.trim());
+    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);
     }
@@ -686,7 +703,7 @@ function parseDependencyRemovals(raw, prefix) {
     if (!trimmed) {
       throw new PmCliError("--dep-remove requires id or key/value selectors", EXIT_CODE.USAGE);
     }
-    if (trimmed.includes("=") || /^(?:[-*+]\s+)?(?:id|kind|source_kind)\s*[:=]/i.test(trimmed) || trimmed.startsWith("```")) {
+    if (trimmed.includes("=") || /^(?:[-*+]\s+)?(?:id|kind|type|source_kind)\s*[:=]/i.test(trimmed) || trimmed.startsWith("```")) {
       const kv = parseCsvKv(trimmed, "--dep-remove");
       const idRaw = kv.id?.trim();
       if (!idRaw) {
@@ -695,7 +712,7 @@ function parseDependencyRemovals(raw, prefix) {
       if (idRaw.toLowerCase() === "undefined") {
         throw new PmCliError(`--dep-remove id must not use placeholder token "${idRaw}"`, EXIT_CODE.USAGE);
       }
-      const kindRaw = normalizeDependencyKindInput(parseOptionalDependencyString(kv.kind));
+      const kindRaw = normalizeDependencyKindInput(parseOptionalDependencyString(kv.kind ?? kv.type));
       const sourceKind = parseOptionalDependencyString(kv.source_kind);
       return {
         id: normalizeItemId(idRaw, prefix),
@@ -787,7 +804,7 @@ function normalizeUpdatePolicyOptionKey(raw, typeName) {
   }
   return canonical;
 }
-function collectProvidedUpdatePolicyOptions(options) {
+function collectProvidedUpdatePolicyOptions(options, extensionFieldNames) {
   const provided = /* @__PURE__ */ new Set();
   const mark = (optionKey, isProvided) => {
     if (isProvided) {
@@ -850,6 +867,7 @@ function collectProvidedUpdatePolicyOptions(options) {
   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);
@@ -863,14 +881,14 @@ function collectProvidedUpdatePolicyOptions(options) {
   mark("event", options.clearEvents === true);
   mark("typeOption", options.clearTypeOptions === true);
   if (options.unset && options.unset.length > 0) {
-    const unsetTargets = parseUpdateUnsetTargets(options.unset);
+    const unsetTargets = parseUpdateUnsetTargets(options.unset, void 0, extensionFieldNames);
     for (const optionKey of unsetTargets.optionKeys) {
       mark(optionKey, true);
     }
   }
   return provided;
 }
-function enforceUpdateOptionsByType(typeName, options, typeRegistry) {
+function enforceUpdateOptionsByType(typeName, options, typeRegistry, extensionFieldNames) {
   const typeDefinition = resolveTypeDefinition(typeName, typeRegistry);
   if (!typeDefinition) {
     throw new PmCliError(`Invalid type value "${typeName}"`, EXIT_CODE.USAGE);
@@ -879,7 +897,7 @@ function enforceUpdateOptionsByType(typeName, options, typeRegistry) {
   if (policyState.errors.length > 0) {
     throw new PmCliError(policyState.errors.join("; "), EXIT_CODE.CONFLICT);
   }
-  const provided = collectProvidedUpdatePolicyOptions(options);
+  const provided = collectProvidedUpdatePolicyOptions(options, 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);
@@ -906,7 +924,8 @@ async function runUpdate(id, options, global2) {
     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")
+    typeOption: await stdinResolver.resolveList(options.typeOption, "--type-option"),
+    field: await stdinResolver.resolveList(options.field, "--field")
   });
   const pmRoot = resolvePmRoot(process.cwd(), global2.path);
   if (!await pathExists(getSettingsPath(pmRoot))) {
@@ -915,10 +934,14 @@ async function runUpdate(id, options, global2) {
   const settings = await readSettings(pmRoot);
   const statusRegistry = resolveRuntimeStatusRegistry(settings.schema);
   const runtimeFieldRegistry = resolveRuntimeFieldRegistry(settings.schema);
-  const typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
+  const extensionRegistrations = getActiveExtensionRegistrations();
+  const extensionFieldNames = collectRegisteredItemFieldNames(extensionRegistrations);
+  const typeRegistry = resolveItemTypeRegistry(settings, extensionRegistrations);
+  const workflowEnforcement = settings.governance.workflow_enforcement ?? "off";
+  const typeWorkflows = workflowEnforcement === "off" ? [] : resolveTypeWorkflows(settings.schema);
   const parentReferencePolicy = settings.validation.parent_reference;
   const sprintReleasePolicy = settings.validation.sprint_release_format;
-  const unsetTargets = parseUpdateUnsetTargets(options.unset, runtimeFieldRegistry);
+  const unsetTargets = parseUpdateUnsetTargets(options.unset, runtimeFieldRegistry, extensionFieldNames);
   const clearOptionKeys = new Set(unsetTargets.optionKeys);
   const clearFrontMatterKeys = new Set(unsetTargets.frontMatterKeys);
   const clearCollectionDefinitions = [
@@ -1132,6 +1155,7 @@ async function runUpdate(id, options, global2) {
   const testUpdates = parseTests(options.test);
   const docUpdates = parseDocs(options.doc);
   const parentReferenceWarnings = [];
+  const workflowTransitionWarnings = [];
   let resolvedParentValue;
   if (options.parent !== void 0 && !unsetTargets.frontMatterKeys.has("parent")) {
     resolvedParentValue = normalizeParentReferenceValue(options.parent);
@@ -1146,6 +1170,7 @@ async function runUpdate(id, options, global2) {
   if (blockedByResolution.unresolved !== void 0) {
     parentReferenceWarnings.push(`blocked_by_unresolved:${blockedByResolution.unresolved}`);
   }
+  const runtimeFieldUpdates = collectRuntimeUpdateFieldValues(options, runtimeFieldRegistry, options.runtimeFieldCommands);
   const fieldFlags = {
     title: options.title !== void 0,
     description: options.description !== void 0,
@@ -1204,6 +1229,7 @@ async function runUpdate(id, options, global2) {
     reminder: options.reminder !== void 0,
     event: options.event !== void 0,
     typeOption: options.typeOption !== void 0,
+    field: options.field !== void 0,
     unset: options.unset !== void 0 && options.unset.length > 0,
     clearDeps: options.clearDeps === true,
     clearComments: options.clearComments === true,
@@ -1214,7 +1240,8 @@ async function runUpdate(id, options, global2) {
     clearDocs: options.clearDocs === true,
     clearReminders: options.clearReminders === true,
     clearEvents: options.clearEvents === true,
-    clearTypeOptions: options.clearTypeOptions === true
+    clearTypeOptions: options.clearTypeOptions === true,
+    runtimeFields: Object.keys(runtimeFieldUpdates).length > 0
   };
   const changedFlags = Object.values(fieldFlags).some(Boolean);
   if (!changedFlags) {
@@ -1229,6 +1256,25 @@ async function runUpdate(id, options, global2) {
       warnings: ["noop_no_update_fields"]
     };
   }
+  if (workflowEnforcement !== "off" && typeWorkflows.length > 0 && fieldFlags.status && options.status !== void 0) {
+    const located = await locateItem(pmRoot, id, settings.id_prefix, settings.item_format, typeRegistry.type_to_folder);
+    if (!located) {
+      throw await buildItemNotFoundError(pmRoot, id, settings.id_prefix, typeRegistry.type_to_folder);
+    }
+    const { document } = await readLocatedItem(located, { schema: settings.schema });
+    const effectiveType = options.type !== void 0 ? resolveTypeName(options.type, typeRegistry) ?? options.type : document.metadata?.type ?? "";
+    const warning = enforceTypeWorkflowTransition({
+      enforcement: workflowEnforcement,
+      typeWorkflows,
+      statusRegistry,
+      typeName: effectiveType,
+      fromStatus: document.metadata?.status ?? "",
+      toStatus: options.status ?? ""
+    });
+    if (warning) {
+      workflowTransitionWarnings.push(warning);
+    }
+  }
   if (fieldFlags.status) {
     const targetStatus = normalizeStatusInput(options.status, statusRegistry);
     if (targetStatus === statusRegistry.close_status) {
@@ -1249,7 +1295,12 @@ async function runUpdate(id, options, global2) {
         message: options.message,
         force: options.force
       }, global2);
-      const warnings = [...routeWarnings, ...closeResult.warnings, "auto_routed_from_update_to_close"];
+      const warnings = [
+        ...workflowTransitionWarnings,
+        ...routeWarnings,
+        ...closeResult.warnings,
+        "auto_routed_from_update_to_close"
+      ];
       if (reasonDefaulted) {
         warnings.push("close_reason_defaulted");
       }
@@ -1273,6 +1324,7 @@ async function runUpdate(id, options, global2) {
     message: options.message,
     force: options.force,
     bypassAssigneeConflict: options.allowAuditUpdate === true || options.allowAuditDepUpdate === true,
+    extensionFieldNames,
     mutate(document) {
       const changedFields = [];
       const warnings = [];
@@ -1342,7 +1394,7 @@ async function runUpdate(id, options, global2) {
         activeTypeName = resolvedTypeName;
         changedFields.push("type");
       }
-      enforceUpdateOptionsByType(activeTypeName, options, typeRegistry);
+      enforceUpdateOptionsByType(activeTypeName, options, typeRegistry, extensionFieldNames);
       if (options.typeOption !== void 0 || clearFrontMatterKeys.has("type_options")) {
         if (clearFrontMatterKeys.has("type_options")) {
           delete document.metadata.type_options;
@@ -1581,7 +1633,7 @@ async function runUpdate(id, options, global2) {
         if (clearFrontMatterKeys.has("reminders")) {
           delete document.metadata.reminders;
         } else {
-          document.metadata.reminders = parseReminderEntries(options.reminder, nowValue);
+          document.metadata.reminders = parseReminderEntries(options.reminder, nowValue, { valueMode: "trimmed" });
         }
         changedFields.push("reminders");
       }
@@ -1589,7 +1641,10 @@ async function runUpdate(id, options, global2) {
         if (clearFrontMatterKeys.has("events")) {
           delete document.metadata.events;
         } else {
-          document.metadata.events = parseEventEntries(options.event, nowValue);
+          document.metadata.events = parseEventEntries(options.event, nowValue, {
+            allDayEmptyGuard: "truthy",
+            recurrenceEmptyNumericGuard: "truthy"
+          });
         }
         changedFields.push("events");
       }
@@ -1603,19 +1658,42 @@ async function runUpdate(id, options, global2) {
         delete metadataRecord[definition.metadata_key];
         changedFields.push(definition.metadata_key);
       }
-      const runtimeFieldUpdates = collectRuntimeUpdateFieldValues(options, runtimeFieldRegistry);
+      for (const fieldKey of extensionFieldNames) {
+        if (!clearFrontMatterKeys.has(fieldKey)) {
+          continue;
+        }
+        if (metadataRecord[fieldKey] === void 0) {
+          continue;
+        }
+        delete metadataRecord[fieldKey];
+        changedFields.push(fieldKey);
+      }
       for (const [fieldKey, fieldValue] of Object.entries(runtimeFieldUpdates)) {
         if (clearFrontMatterKeys.has(fieldKey)) {
           continue;
         }
-        if (JSON.stringify(metadataRecord[fieldKey]) === JSON.stringify(fieldValue)) {
+        if (stableValueEquals(metadataRecord[fieldKey], fieldValue)) {
+          continue;
+        }
+        metadataRecord[fieldKey] = fieldValue;
+        changedFields.push(fieldKey);
+      }
+      const registeredItemFieldUpdates = parseRegisteredItemFieldAssignments(options.field, extensionRegistrations);
+      for (const fieldKey of Object.keys(registeredItemFieldUpdates)) {
+        if (!clearFrontMatterKeys.has(fieldKey)) {
+          continue;
+        }
+        throw new PmCliError(`Cannot combine --unset ${fieldKey.replaceAll("_", "-")} with --field ${fieldKey}=...`, EXIT_CODE.USAGE);
+      }
+      for (const [fieldKey, fieldValue] of Object.entries(registeredItemFieldUpdates)) {
+        if (stableValueEquals(metadataRecord[fieldKey], fieldValue)) {
           continue;
         }
         metadataRecord[fieldKey] = fieldValue;
         changedFields.push(fieldKey);
       }
       try {
-        applyRegisteredItemFieldDefaultsAndValidation(metadataRecord, getActiveExtensionRegistrations());
+        applyRegisteredItemFieldDefaultsAndValidation(metadataRecord, extensionRegistrations, { skipDefaultFields: clearFrontMatterKeys });
       } catch (error) {
         throw new PmCliError(error instanceof Error ? error.message : "Invalid extension item field values", EXIT_CODE.USAGE);
       }
@@ -1625,7 +1703,7 @@ async function runUpdate(id, options, global2) {
   return {
     item: toItemRecord(result.item),
     changed_fields: result.changedFields,
-    warnings: [...parentReferenceWarnings, ...result.warnings],
+    warnings: [...workflowTransitionWarnings, ...parentReferenceWarnings, ...result.warnings],
     ...options.allowAuditUpdate === true || options.allowAuditDepUpdate === true ? { audit_update: true } : {}
   };
 }
@@ -1633,4 +1711,4 @@ async function runUpdate(id, options, global2) {
 export {
   runUpdate
 };
-//# sourceMappingURL=chunk-3M73P3G6.js.map
+//# sourceMappingURL=chunk-D5X7N6FI.js.map