@unbrained/pm-cli 2026.5.31 → 2026.6.5

package/dist/cli/commands/update.js

@@ -1,5 +1,5 @@
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="3722af32-cd81-5b1e-bc17-bdb1f3335754")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="74fefeac-195a-595c-aa23-d38e5b855b84")}catch(e){}}();
 import { pathExists } from "../../core/fs/fs-utils.js";
 import { canonicalizeCommandOptionKey, commandOptionFlagLabel, resolveItemTypeRegistry, resolveCommandOptionPolicyState, resolveTypeDefinition, resolveTypeName, validateTypeOptions, } from "../../core/item/type-registry.js";
 import { normalizeItemId } from "../../core/item/id.js";
@@ -12,19 +12,21 @@ import { resolvePriority } from "../../core/item/priority.js";
 import { normalizeStatusInput } from "../../core/item/status.js";
 import { collectRuntimeUpdateFieldValues } from "../../core/schema/runtime-field-values.js";
 import { resolveRuntimeFieldRegistry, resolveRuntimeStatusRegistry, } from "../../core/schema/runtime-schema.js";
+import { describeAllowedTransitions, evaluateTransition, resolveTypeWorkflows, } from "../../core/schema/type-workflows.js";
 import { EXIT_CODE } from "../../core/shared/constants.js";
 import { PmCliError } from "../../core/shared/errors.js";
+import { stableValueEquals } from "../../core/shared/serialization.js";
 import { resolveIsoOrRelative } from "../../core/shared/time.js";
 import { getActiveExtensionRegistrations } from "../../core/extensions/index.js";
-import { applyRegisteredItemFieldDefaultsAndValidation } from "../../core/extensions/item-fields.js";
+import { collectRegisteredItemFieldNames, applyRegisteredItemFieldDefaultsAndValidation, parseRegisteredItemFieldAssignments, } from "../../core/extensions/item-fields.js";
 import { buildItemNotFoundError, locateItem, mutateItem, readLocatedItem } from "../../core/store/item-store.js";
 import { getSettingsPath, resolvePmRoot } from "../../core/store/paths.js";
 import { readSettings } from "../../core/store/settings.js";
 import { runClose } from "./close.js";
 import { normalizeRiskInput, normalizeSeverityInput, parseConfidenceInput, parseRegressionInput, } from "./metadata-normalizers.js";
-import { resolveEventEndAt } from "./event-validation-messages.js";
 import { assertNoLegacyNoneToken, assertNoLegacyNoneTokens, isLegacyNoneToken } from "./legacy-none-tokens.js";
-import { ensureEnumValue as ensureEnum, parseEventBoolean, parseRecurrenceRule } from "./recurrence-parsers.js";
+import { ensureEnumValue as ensureEnum } from "./recurrence-parsers.js";
+import { parseEventEntries, parseReminderEntries, parseTypeOptionEntries, } from "./repeatable-metadata-parsers.js";
 import { DEPENDENCY_KIND_VALUES, ISSUE_SEVERITY_VALUES, RISK_VALUES, } from "../../types/index.js";
 import { parseDocs, parseFiles, parseLogSeed, parseTests } from "./create.js";
 const UPDATE_UNSET_FIELD_DEFINITIONS = [
@@ -253,7 +255,7 @@ function resolveRuntimeUnsetDefinition(token, runtimeFieldRegistry) {
     }
     return undefined;
 }
-function parseUpdateUnsetTargets(raw, runtimeFieldRegistry) {
+function parseUpdateUnsetTargets(raw, runtimeFieldRegistry, extensionFieldNames = []) {
     const frontMatterKeys = new Set();
     const optionKeys = new Set();
     if (!raw || raw.length === 0) {
@@ -267,7 +269,15 @@ 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 } : undefined);
         if (!definition) {
             throw new PmCliError(`Unsupported --unset field "${entry}". Supported fields: ${UPDATE_UNSET_SUPPORTED_CANONICAL_FIELDS}`, EXIT_CODE.USAGE);
         }
@@ -469,102 +479,35 @@ 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 !== undefined && !title) {
-            throw new PmCliError("--event title must not be empty", EXIT_CODE.USAGE);
-        }
-        if (descriptionRaw !== undefined && !description) {
-            throw new PmCliError("--event description must not be empty", EXIT_CODE.USAGE);
-        }
-        if (locationRaw !== undefined && !location) {
-            throw new PmCliError("--event location must not be empty", EXIT_CODE.USAGE);
-        }
-        if (timezoneRaw !== undefined && !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") : undefined,
-            timezone,
-            recurrence,
-        };
+/**
+ * Enforce per-type allowed-transition rules (governance.workflow_enforcement).
+ * `off` (default) or an unrestricted type is a no-op. `strict` throws on a
+ * disallowed transition; `warn` returns a warning string surfaced on the
+ * update result. The target status is the raw `--status` value (resolved
+ * case-insensitively through the registry inside evaluateTransition).
+ */
+function enforceTypeWorkflowTransition(params) {
+    if (params.enforcement === "off" || params.typeWorkflows.length === 0) {
+        return undefined;
+    }
+    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 undefined;
+    }
+    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") {
@@ -586,7 +529,7 @@ 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);
 }
 // pm-fl0c #4 (2026-05-28): `pm plan` accepts `depends_on` as a link kind
 // (`PLAN_STEP_LINK_KIND_VALUES`) but `pm update --dep kind=depends_on` rejected
@@ -596,6 +539,7 @@ function looksLikeStructuredDependencyEntry(raw) {
 // — the stored kind stays canonical (`blocked_by`) and downstream consumers
 // (closing logic, dependency graphs, blockers views) keep working unchanged.
 const DEPENDENCY_KIND_INPUT_ALIASES = {
+    "blocked-by": "blocked_by",
     depends_on: "blocked_by",
     "depends-on": "blocked_by",
 };
@@ -616,7 +560,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);
         }
@@ -644,7 +588,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) {
@@ -653,7 +597,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),
@@ -760,7 +704,7 @@ function normalizeUpdatePolicyOptionKey(raw, typeName) {
     }
     return canonical;
 }
-function collectProvidedUpdatePolicyOptions(options) {
+function collectProvidedUpdatePolicyOptions(options, extensionFieldNames) {
     const provided = new Set();
     const mark = (optionKey, isProvided) => {
         if (isProvided) {
@@ -827,6 +771,7 @@ function collectProvidedUpdatePolicyOptions(options) {
     mark("reminder", options.reminder !== undefined);
     mark("event", options.event !== undefined);
     mark("typeOption", options.typeOption !== undefined);
+    mark("field", options.field !== undefined);
     mark("force", options.force === true);
     mark("allowAuditUpdate", options.allowAuditUpdate === true);
     mark("dep", options.clearDeps === true);
@@ -840,14 +785,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, undefined, 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);
@@ -856,7 +801,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);
@@ -884,6 +829,7 @@ export async function runUpdate(id, options, global) {
         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"),
     });
     const pmRoot = resolvePmRoot(process.cwd(), global.path);
     if (!(await pathExists(getSettingsPath(pmRoot)))) {
@@ -892,10 +838,16 @@ export async function runUpdate(id, options, global) {
     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);
+    // Per-type allowed-transition enforcement is read RAW (not preset-derived) so
+    // existing projects are unaffected when unset; defaults to "off".
+    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 = [
@@ -1115,6 +1067,7 @@ export async function runUpdate(id, options, global) {
     const testUpdates = parseTests(options.test);
     const docUpdates = parseDocs(options.doc);
     const parentReferenceWarnings = [];
+    const workflowTransitionWarnings = [];
     let resolvedParentValue;
     if (options.parent !== undefined && !unsetTargets.frontMatterKeys.has("parent")) {
         resolvedParentValue = normalizeParentReferenceValue(options.parent);
@@ -1131,6 +1084,7 @@ export async function runUpdate(id, options, global) {
     if (blockedByResolution.unresolved !== undefined) {
         parentReferenceWarnings.push(`blocked_by_unresolved:${blockedByResolution.unresolved}`);
     }
+    const runtimeFieldUpdates = collectRuntimeUpdateFieldValues(options, runtimeFieldRegistry, options.runtimeFieldCommands);
     const fieldFlags = {
         title: options.title !== undefined,
         description: options.description !== undefined,
@@ -1189,6 +1143,7 @@ export async function runUpdate(id, options, global) {
         reminder: options.reminder !== undefined,
         event: options.event !== undefined,
         typeOption: options.typeOption !== undefined,
+        field: options.field !== undefined,
         unset: options.unset !== undefined && options.unset.length > 0,
         clearDeps: options.clearDeps === true,
         clearComments: options.clearComments === true,
@@ -1200,6 +1155,7 @@ export async function runUpdate(id, options, global) {
         clearReminders: options.clearReminders === true,
         clearEvents: options.clearEvents === true,
         clearTypeOptions: options.clearTypeOptions === true,
+        runtimeFields: Object.keys(runtimeFieldUpdates).length > 0,
     };
     const changedFlags = Object.values(fieldFlags).some(Boolean);
     if (!changedFlags) {
@@ -1214,6 +1170,37 @@ export async function runUpdate(id, options, global) {
             warnings: ["noop_no_update_fields"],
         };
     }
+    // Per-type allowed-transition enforcement runs BEFORE the close-reroute so a
+    // transition toward the close status is gated too. We read the item's current
+    // status + type once (only when enforcement is active and --status is set) so
+    // the default `off` path adds zero extra work. A `strict` violation throws; a
+    // `warn` violation surfaces a warning on the result.
+    if (workflowEnforcement !== "off" && typeWorkflows.length > 0 && fieldFlags.status && options.status !== undefined) {
+        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 });
+        // When this update also changes --type, gate the transition against the
+        // EFFECTIVE (post-update) type, so a combined --type/--status change can't
+        // bypass a target-type rule (or be wrongly blocked by the pre-update type's
+        // rule that will no longer apply). Falls back to the raw value when --type is
+        // unresolved; the later type resolution surfaces an invalid-type error.
+        const effectiveType = options.type !== undefined
+            ? (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);
+        }
+    }
     // `pm update --status <close_status>` always routes to the auditable close
     // workflow so agents are never blocked by close-through-update errors. Any
     // other field updates in the same call are applied first, then the item is
@@ -1242,7 +1229,12 @@ export async function runUpdate(id, options, global) {
                 message: options.message,
                 force: options.force,
             }, global);
-            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");
             }
@@ -1266,6 +1258,7 @@ export async function runUpdate(id, options, global) {
         message: options.message,
         force: options.force,
         bypassAssigneeConflict: options.allowAuditUpdate === true || options.allowAuditDepUpdate === true,
+        extensionFieldNames,
         mutate(document) {
             const changedFields = [];
             const warnings = [];
@@ -1348,7 +1341,7 @@ export async function runUpdate(id, options, global) {
                 activeTypeName = resolvedTypeName;
                 changedFields.push("type");
             }
-            enforceUpdateOptionsByType(activeTypeName, options, typeRegistry);
+            enforceUpdateOptionsByType(activeTypeName, options, typeRegistry, extensionFieldNames);
             if (options.typeOption !== undefined || clearFrontMatterKeys.has("type_options")) {
                 if (clearFrontMatterKeys.has("type_options")) {
                     delete document.metadata.type_options;
@@ -1613,7 +1606,7 @@ export async function runUpdate(id, options, global) {
                     delete document.metadata.reminders;
                 }
                 else {
-                    document.metadata.reminders = parseReminderEntries(options.reminder, nowValue);
+                    document.metadata.reminders = parseReminderEntries(options.reminder, nowValue, { valueMode: "trimmed" });
                 }
                 changedFields.push("reminders");
             }
@@ -1622,7 +1615,10 @@ export async function runUpdate(id, options, global) {
                     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");
             }
@@ -1636,19 +1632,42 @@ export async function runUpdate(id, options, global) {
                 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] === undefined) {
+                    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);
@@ -1659,9 +1678,9 @@ export async function runUpdate(id, options, global) {
     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 } : {}),
     };
 }
 //# sourceMappingURL=update.js.map
-//# debugId=3722af32-cd81-5b1e-bc17-bdb1f3335754
+//# debugId=74fefeac-195a-595c-aa23-d38e5b855b84