@unbrained/pm-cli 2026.3.12 → 2026.5.1-2

package/dist/cli/commands/update.js

@@ -1,23 +1,438 @@
 import { pathExists } from "../../core/fs/fs-utils.js";
-import { parseOptionalNumber, parseTags } from "../../core/item/parse.js";
+import { canonicalizeCommandOptionKey, commandOptionFlagLabel, resolveItemTypeRegistry, resolveCommandOptionPolicyState, resolveTypeDefinition, resolveTypeName, validateTypeOptions, } from "../../core/item/type-registry.js";
+import { normalizeItemId } from "../../core/item/id.js";
+import { normalizeParentReferenceValue, validateMissingParentReference, } from "../../core/item/parent-reference-policy.js";
+import { validateSprintOrReleaseValue } from "../../core/item/sprint-release-format.js";
+import { createStdinTokenResolver, parseCsvKv, parseOptionalNumber, parseTags } from "../../core/item/parse.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 { EXIT_CODE } from "../../core/shared/constants.js";
 import { PmCliError } from "../../core/shared/errors.js";
-import { isNoneToken, resolveIsoOrRelative } from "../../core/shared/time.js";
-import { mutateItem } from "../../core/store/item-store.js";
+import { resolveIsoOrRelative } from "../../core/shared/time.js";
+import { getActiveExtensionRegistrations } from "../../core/extensions/index.js";
+import { applyRegisteredItemFieldDefaultsAndValidation } from "../../core/extensions/item-fields.js";
+import { locateItem, mutateItem } from "../../core/store/item-store.js";
 import { getSettingsPath, resolvePmRoot } from "../../core/store/paths.js";
 import { readSettings } from "../../core/store/settings.js";
-import { CONFIDENCE_TEXT_VALUES, ISSUE_SEVERITY_VALUES, ITEM_TYPE_VALUES, RISK_VALUES, STATUS_VALUES } from "../../types/index.js";
+import { CONFIDENCE_TEXT_VALUES, DEPENDENCY_KIND_VALUES, ISSUE_SEVERITY_VALUES, RECURRENCE_FREQUENCY_VALUES, RECURRENCE_WEEKDAY_VALUES, RISK_VALUES, } from "../../types/index.js";
+import { parseDocs, parseFiles, parseLogSeed, parseTests } from "./create.js";
+const LEGACY_NONE_TOKENS = new Set(["none", "null"]);
+const UPDATE_UNSET_FIELD_DEFINITIONS = [
+    { canonical: "tags", aliases: ["tags"], optionKey: "tags", frontMatterKey: "tags" },
+    { canonical: "close-reason", aliases: ["close_reason", "close-reason"], optionKey: "closeReason", frontMatterKey: "close_reason" },
+    { canonical: "deadline", aliases: ["deadline"], optionKey: "deadline", frontMatterKey: "deadline" },
+    {
+        canonical: "estimate",
+        aliases: ["estimate", "estimated_minutes", "estimated-minutes"],
+        optionKey: "estimatedMinutes",
+        frontMatterKey: "estimated_minutes",
+    },
+    {
+        canonical: "acceptance-criteria",
+        aliases: ["acceptance_criteria", "acceptance-criteria", "ac"],
+        optionKey: "acceptanceCriteria",
+        frontMatterKey: "acceptance_criteria",
+    },
+    {
+        canonical: "definition-of-ready",
+        aliases: ["definition_of_ready", "definition-of-ready"],
+        optionKey: "definitionOfReady",
+        frontMatterKey: "definition_of_ready",
+    },
+    { canonical: "order", aliases: ["order", "rank"], optionKey: "order", frontMatterKey: "order" },
+    { canonical: "goal", aliases: ["goal"], optionKey: "goal", frontMatterKey: "goal" },
+    { canonical: "objective", aliases: ["objective"], optionKey: "objective", frontMatterKey: "objective" },
+    { canonical: "value", aliases: ["value"], optionKey: "value", frontMatterKey: "value" },
+    { canonical: "impact", aliases: ["impact"], optionKey: "impact", frontMatterKey: "impact" },
+    { canonical: "outcome", aliases: ["outcome"], optionKey: "outcome", frontMatterKey: "outcome" },
+    { canonical: "why-now", aliases: ["why_now", "why-now"], optionKey: "whyNow", frontMatterKey: "why_now" },
+    { canonical: "assignee", aliases: ["assignee"], optionKey: "assignee", frontMatterKey: "assignee" },
+    { canonical: "parent", aliases: ["parent"], optionKey: "parent", frontMatterKey: "parent" },
+    { canonical: "reviewer", aliases: ["reviewer"], optionKey: "reviewer", frontMatterKey: "reviewer" },
+    { canonical: "risk", aliases: ["risk"], optionKey: "risk", frontMatterKey: "risk" },
+    { canonical: "confidence", aliases: ["confidence"], optionKey: "confidence", frontMatterKey: "confidence" },
+    { canonical: "sprint", aliases: ["sprint"], optionKey: "sprint", frontMatterKey: "sprint" },
+    { canonical: "release", aliases: ["release"], optionKey: "release", frontMatterKey: "release" },
+    {
+        canonical: "blocked-by",
+        aliases: ["blocked_by", "blocked-by"],
+        optionKey: "blockedBy",
+        frontMatterKey: "blocked_by",
+    },
+    {
+        canonical: "blocked-reason",
+        aliases: ["blocked_reason", "blocked-reason"],
+        optionKey: "blockedReason",
+        frontMatterKey: "blocked_reason",
+    },
+    {
+        canonical: "unblock-note",
+        aliases: ["unblock_note", "unblock-note"],
+        optionKey: "unblockNote",
+        frontMatterKey: "unblock_note",
+    },
+    { canonical: "reporter", aliases: ["reporter"], optionKey: "reporter", frontMatterKey: "reporter" },
+    { canonical: "severity", aliases: ["severity"], optionKey: "severity", frontMatterKey: "severity" },
+    {
+        canonical: "environment",
+        aliases: ["environment"],
+        optionKey: "environment",
+        frontMatterKey: "environment",
+    },
+    {
+        canonical: "repro-steps",
+        aliases: ["repro_steps", "repro-steps"],
+        optionKey: "reproSteps",
+        frontMatterKey: "repro_steps",
+    },
+    {
+        canonical: "resolution",
+        aliases: ["resolution"],
+        optionKey: "resolution",
+        frontMatterKey: "resolution",
+    },
+    {
+        canonical: "expected-result",
+        aliases: ["expected_result", "expected-result"],
+        optionKey: "expectedResult",
+        frontMatterKey: "expected_result",
+    },
+    {
+        canonical: "actual-result",
+        aliases: ["actual_result", "actual-result"],
+        optionKey: "actualResult",
+        frontMatterKey: "actual_result",
+    },
+    {
+        canonical: "affected-version",
+        aliases: ["affected_version", "affected-version"],
+        optionKey: "affectedVersion",
+        frontMatterKey: "affected_version",
+    },
+    {
+        canonical: "fixed-version",
+        aliases: ["fixed_version", "fixed-version"],
+        optionKey: "fixedVersion",
+        frontMatterKey: "fixed_version",
+    },
+    { canonical: "component", aliases: ["component"], optionKey: "component", frontMatterKey: "component" },
+    { canonical: "regression", aliases: ["regression"], optionKey: "regression", frontMatterKey: "regression" },
+    {
+        canonical: "customer-impact",
+        aliases: ["customer_impact", "customer-impact"],
+        optionKey: "customerImpact",
+        frontMatterKey: "customer_impact",
+    },
+];
+const UPDATE_UNSET_ALIAS_MAP = (() => {
+    const map = 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;
+})();
+const UPDATE_OPTION_KEY_TO_UNSET_CANONICAL = new Map(UPDATE_UNSET_FIELD_DEFINITIONS.map((definition) => [definition.optionKey, definition.canonical]));
+const UPDATE_UNSET_SUPPORTED_CANONICAL_FIELDS = UPDATE_UNSET_FIELD_DEFINITIONS.map((definition) => definition.canonical)
+    .sort((left, right) => left.localeCompare(right))
+    .join(", ");
+const AUDIT_UPDATE_DISALLOWED_UNSET_FRONT_MATTER_KEYS = 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";
 }
+function isLegacyNoneToken(value) {
+    if (value === undefined) {
+        return false;
+    }
+    return LEGACY_NONE_TOKENS.has(value.trim().toLowerCase());
+}
+function assertNoLegacyNoneToken(value, flag, replacementHint) {
+    if (!isLegacyNoneToken(value)) {
+        return;
+    }
+    const suffix = replacementHint ? ` ${replacementHint}` : "";
+    throw new PmCliError(`${flag} no longer accepts "none" or "null".${suffix}`.trim(), EXIT_CODE.USAGE);
+}
+function assertNoLegacyNoneTokens(values, flag, replacementHint) {
+    if (!values || values.length === 0) {
+        return;
+    }
+    const hasLegacyToken = values.some((value) => isLegacyNoneToken(value));
+    if (!hasLegacyToken) {
+        return;
+    }
+    const suffix = replacementHint ? ` ${replacementHint}` : "";
+    throw new PmCliError(`${flag} no longer accepts "none" or "null".${suffix}`.trim(), EXIT_CODE.USAGE);
+}
+function resolveRuntimeUnsetDefinition(token, runtimeFieldRegistry) {
+    if (!runtimeFieldRegistry) {
+        return undefined;
+    }
+    for (const definition of runtimeFieldRegistry.definitions) {
+        if (definition.allow_unset === false) {
+            continue;
+        }
+        const candidates = new Set([
+            definition.key,
+            definition.front_matter_key,
+            definition.cli_flag.replaceAll("-", "_"),
+            definition.cli_flag,
+            ...definition.cli_aliases.map((alias) => alias.replaceAll("-", "_")),
+            ...definition.cli_aliases,
+        ]);
+        if (!candidates.has(token)) {
+            continue;
+        }
+        return {
+            optionKey: definition.key,
+            frontMatterKey: definition.front_matter_key,
+        };
+    }
+    return undefined;
+}
+function parseUpdateUnsetTargets(raw, runtimeFieldRegistry) {
+    const frontMatterKeys = new Set();
+    const optionKeys = new Set();
+    if (!raw || raw.length === 0) {
+        return { frontMatterKeys, optionKeys };
+    }
+    for (const entry of raw) {
+        const trimmed = entry.trim().toLowerCase();
+        if (!trimmed) {
+            throw new PmCliError("--unset values must not be empty", EXIT_CODE.USAGE);
+        }
+        if (isLegacyNoneToken(trimmed)) {
+            throw new PmCliError('--unset no longer accepts "none" or "null". Specify concrete field names such as --unset deadline', EXIT_CODE.USAGE);
+        }
+        const definition = UPDATE_UNSET_ALIAS_MAP.get(trimmed) ?? resolveRuntimeUnsetDefinition(trimmed, runtimeFieldRegistry);
+        if (!definition) {
+            throw new PmCliError(`Unsupported --unset field "${entry}". Supported fields: ${UPDATE_UNSET_SUPPORTED_CANONICAL_FIELDS}`, EXIT_CODE.USAGE);
+        }
+        frontMatterKeys.add(definition.frontMatterKey);
+        optionKeys.add(definition.optionKey);
+    }
+    return { frontMatterKeys, optionKeys };
+}
+function enforceAllowAuditUpdateScope(options, clearFrontMatterKeys) {
+    const allowAuditUpdate = options.allowAuditUpdate === true;
+    const allowAuditDepUpdate = options.allowAuditDepUpdate === true;
+    if (!allowAuditUpdate && !allowAuditDepUpdate) {
+        return;
+    }
+    if (allowAuditUpdate && allowAuditDepUpdate) {
+        throw new PmCliError("Choose either --allow-audit-update or --allow-audit-dep-update; these override modes are mutually exclusive.", EXIT_CODE.USAGE);
+    }
+    const pushIf = (condition, flag, list) => {
+        if (condition) {
+            list.push(flag);
+        }
+    };
+    if (allowAuditDepUpdate) {
+        const disallowedFlags = [];
+        pushIf(options.title !== undefined, "--title", disallowedFlags);
+        pushIf(options.description !== undefined, "--description", disallowedFlags);
+        pushIf(options.body !== undefined, "--body", disallowedFlags);
+        pushIf(options.status !== undefined, "--status", disallowedFlags);
+        pushIf(options.closeReason !== undefined, "--close-reason", disallowedFlags);
+        pushIf(options.priority !== undefined, "--priority", disallowedFlags);
+        pushIf(options.type !== undefined, "--type", disallowedFlags);
+        pushIf(options.tags !== undefined, "--tags", disallowedFlags);
+        pushIf(options.deadline !== undefined, "--deadline", disallowedFlags);
+        pushIf(options.estimatedMinutes !== undefined, "--estimate", disallowedFlags);
+        pushIf(options.acceptanceCriteria !== undefined, "--acceptance-criteria", disallowedFlags);
+        pushIf(options.definitionOfReady !== undefined, "--definition-of-ready", disallowedFlags);
+        pushIf(options.order !== undefined || options.rank !== undefined, "--order/--rank", disallowedFlags);
+        pushIf(options.goal !== undefined, "--goal", disallowedFlags);
+        pushIf(options.objective !== undefined, "--objective", disallowedFlags);
+        pushIf(options.value !== undefined, "--value", disallowedFlags);
+        pushIf(options.impact !== undefined, "--impact", disallowedFlags);
+        pushIf(options.outcome !== undefined, "--outcome", disallowedFlags);
+        pushIf(options.whyNow !== undefined, "--why-now", disallowedFlags);
+        pushIf(options.assignee !== undefined, "--assignee", disallowedFlags);
+        pushIf(options.parent !== undefined, "--parent", disallowedFlags);
+        pushIf(options.reviewer !== undefined, "--reviewer", disallowedFlags);
+        pushIf(options.risk !== undefined, "--risk", disallowedFlags);
+        pushIf(options.confidence !== undefined, "--confidence", disallowedFlags);
+        pushIf(options.sprint !== undefined, "--sprint", disallowedFlags);
+        pushIf(options.release !== undefined, "--release", disallowedFlags);
+        pushIf(options.blockedBy !== undefined, "--blocked-by", disallowedFlags);
+        pushIf(options.blockedReason !== undefined, "--blocked-reason", disallowedFlags);
+        pushIf(options.unblockNote !== undefined, "--unblock-note", disallowedFlags);
+        pushIf(options.reporter !== undefined, "--reporter", disallowedFlags);
+        pushIf(options.severity !== undefined, "--severity", disallowedFlags);
+        pushIf(options.environment !== undefined, "--environment", disallowedFlags);
+        pushIf(options.reproSteps !== undefined, "--repro-steps", disallowedFlags);
+        pushIf(options.resolution !== undefined, "--resolution", disallowedFlags);
+        pushIf(options.expectedResult !== undefined, "--expected-result", disallowedFlags);
+        pushIf(options.actualResult !== undefined, "--actual-result", disallowedFlags);
+        pushIf(options.affectedVersion !== undefined, "--affected-version", disallowedFlags);
+        pushIf(options.fixedVersion !== undefined, "--fixed-version", disallowedFlags);
+        pushIf(options.component !== undefined, "--component", disallowedFlags);
+        pushIf(options.regression !== undefined, "--regression", disallowedFlags);
+        pushIf(options.customerImpact !== undefined, "--customer-impact", disallowedFlags);
+        pushIf(options.depRemove !== undefined, "--dep-remove", disallowedFlags);
+        pushIf(options.replaceDeps === true, "--replace-deps", disallowedFlags);
+        pushIf(options.replaceTests === true, "--replace-tests", disallowedFlags);
+        pushIf(options.comment !== undefined, "--comment", disallowedFlags);
+        pushIf(options.note !== undefined, "--note", disallowedFlags);
+        pushIf(options.learning !== undefined, "--learning", disallowedFlags);
+        pushIf(options.file !== undefined, "--file", disallowedFlags);
+        pushIf(options.test !== undefined, "--test", disallowedFlags);
+        pushIf(options.doc !== undefined, "--doc", disallowedFlags);
+        pushIf(options.reminder !== undefined, "--reminder", disallowedFlags);
+        pushIf(options.event !== undefined, "--event", disallowedFlags);
+        pushIf(options.typeOption !== undefined, "--type-option", 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);
+        pushIf(options.clearTypeOptions === true, "--clear-type-options", disallowedFlags);
+        pushIf(options.force === true, "--force", disallowedFlags);
+        pushIf(clearFrontMatterKeys.size > 0, "--unset", disallowedFlags);
+        if (options.dep === undefined || options.dep.length === 0) {
+            throw new PmCliError("--allow-audit-dep-update requires at least one --dep value", EXIT_CODE.USAGE);
+        }
+        if (disallowedFlags.length > 0) {
+            throw new PmCliError(`--allow-audit-dep-update supports append-only dependency additions via --dep. Remove restricted options: ${disallowedFlags.join(", ")}`, EXIT_CODE.USAGE);
+        }
+        return;
+    }
+    const disallowedFlags = [];
+    if (options.status !== undefined) {
+        disallowedFlags.push("--status");
+    }
+    if (options.closeReason !== undefined) {
+        disallowedFlags.push("--close-reason");
+    }
+    if (options.assignee !== undefined) {
+        disallowedFlags.push("--assignee");
+    }
+    if (options.parent !== undefined) {
+        disallowedFlags.push("--parent");
+    }
+    if (options.blockedBy !== undefined) {
+        disallowedFlags.push("--blocked-by");
+    }
+    if (options.blockedReason !== undefined) {
+        disallowedFlags.push("--blocked-reason");
+    }
+    if (options.unblockNote !== undefined) {
+        disallowedFlags.push("--unblock-note");
+    }
+    if (options.dep !== undefined) {
+        disallowedFlags.push("--dep");
+    }
+    if (options.depRemove !== undefined) {
+        disallowedFlags.push("--dep-remove");
+    }
+    if (options.replaceDeps === true) {
+        disallowedFlags.push("--replace-deps");
+    }
+    if (options.replaceTests === true) {
+        disallowedFlags.push("--replace-tests");
+    }
+    if (options.comment !== undefined) {
+        disallowedFlags.push("--comment");
+    }
+    if (options.note !== undefined) {
+        disallowedFlags.push("--note");
+    }
+    if (options.learning !== undefined) {
+        disallowedFlags.push("--learning");
+    }
+    if (options.file !== undefined) {
+        disallowedFlags.push("--file");
+    }
+    if (options.test !== undefined) {
+        disallowedFlags.push("--test");
+    }
+    if (options.doc !== undefined) {
+        disallowedFlags.push("--doc");
+    }
+    if (options.reminder !== undefined) {
+        disallowedFlags.push("--reminder");
+    }
+    if (options.event !== undefined) {
+        disallowedFlags.push("--event");
+    }
+    if (options.clearDeps === true) {
+        disallowedFlags.push("--clear-deps");
+    }
+    if (options.clearComments === true) {
+        disallowedFlags.push("--clear-comments");
+    }
+    if (options.clearNotes === true) {
+        disallowedFlags.push("--clear-notes");
+    }
+    if (options.clearLearnings === true) {
+        disallowedFlags.push("--clear-learnings");
+    }
+    if (options.clearFiles === true) {
+        disallowedFlags.push("--clear-files");
+    }
+    if (options.clearTests === true) {
+        disallowedFlags.push("--clear-tests");
+    }
+    if (options.clearDocs === true) {
+        disallowedFlags.push("--clear-docs");
+    }
+    if (options.clearReminders === true) {
+        disallowedFlags.push("--clear-reminders");
+    }
+    if (options.clearEvents === true) {
+        disallowedFlags.push("--clear-events");
+    }
+    const disallowedUnset = [...clearFrontMatterKeys]
+        .filter((field) => AUDIT_UPDATE_DISALLOWED_UNSET_FRONT_MATTER_KEYS.has(field))
+        .sort((left, right) => left.localeCompare(right))
+        .map((field) => `--unset ${field.replaceAll("_", "-")}`);
+    disallowedFlags.push(...disallowedUnset);
+    if (disallowedFlags.length > 0) {
+        throw new PmCliError(`--allow-audit-update only supports non-lifecycle metadata fields. Remove restricted options: ${disallowedFlags.join(", ")}`, EXIT_CODE.USAGE);
+    }
+}
 function ensureEnum(value, allowed, label) {
     if (!allowed.includes(value)) {
         throw new PmCliError(`Invalid ${label} value "${value}"`, EXIT_CODE.USAGE);
     }
     return value;
 }
+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 normalizeRiskInput(value) {
     const trimmed = value.trim();
     return trimmed.toLowerCase() === "med" ? "medium" : trimmed;
@@ -50,6 +465,278 @@ function parseRegressionInput(value) {
     }
     throw new PmCliError("Regression must be one of true|false|1|0", EXIT_CODE.USAGE);
 }
+function weekdayOrderIndex(value) {
+    return RECURRENCE_WEEKDAY_VALUES.indexOf(value);
+}
+function parseReminderEntries(raw, nowValue) {
+    return raw.map((entry) => {
+        const kv = parseCsvKv(entry, "--reminder");
+        const atRaw = kv.at?.trim();
+        const textRaw = kv.text?.trim();
+        if (!atRaw || !textRaw) {
+            throw new PmCliError("--reminder requires at=<iso|relative> and text=<value>", EXIT_CODE.USAGE);
+        }
+        return {
+            at: resolveIsoOrRelative(atRaw, nowValue, "reminder.at"),
+            text: textRaw,
+        };
+    });
+}
+function parseEventBoolean(value, flag) {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "true" || normalized === "1" || normalized === "yes") {
+        return true;
+    }
+    if (normalized === "false" || normalized === "0" || normalized === "no") {
+        return false;
+    }
+    throw new PmCliError(`${flag} must be one of true|false|1|0|yes|no`, EXIT_CODE.USAGE);
+}
+function parseDelimitedList(raw) {
+    if (!raw) {
+        return [];
+    }
+    return raw
+        .split("|")
+        .map((value) => value.trim())
+        .filter((value) => value.length > 0);
+}
+function parseRecurrenceRule(kv, startAt, nowValue) {
+    const freqRaw = kv.recur_freq?.trim();
+    const intervalRaw = kv.recur_interval?.trim();
+    const countRaw = kv.recur_count?.trim();
+    const untilRaw = kv.recur_until?.trim();
+    const byWeekdayRaw = kv.recur_by_weekday?.trim();
+    const byMonthDayRaw = kv.recur_by_month_day?.trim();
+    const exdatesRaw = kv.recur_exdates?.trim();
+    const recurrenceInputsProvided = [freqRaw, intervalRaw, countRaw, untilRaw, byWeekdayRaw, byMonthDayRaw, exdatesRaw].some((value) => value !== undefined);
+    if (!recurrenceInputsProvided) {
+        return undefined;
+    }
+    if (!freqRaw) {
+        throw new PmCliError("--event recurrence fields require recur_freq=<daily|weekly|monthly|yearly>", EXIT_CODE.USAGE);
+    }
+    const freq = ensureEnum(freqRaw.toLowerCase(), RECURRENCE_FREQUENCY_VALUES, "event recurrence frequency");
+    const interval = intervalRaw ? parseOptionalNumber(intervalRaw, "event recur_interval") : undefined;
+    if (interval !== undefined && (!Number.isInteger(interval) || interval < 1)) {
+        throw new PmCliError("--event recur_interval must be an integer >= 1", EXIT_CODE.USAGE);
+    }
+    const count = countRaw ? parseOptionalNumber(countRaw, "event recur_count") : undefined;
+    if (count !== undefined && (!Number.isInteger(count) || count < 1)) {
+        throw new PmCliError("--event recur_count must be an integer >= 1", EXIT_CODE.USAGE);
+    }
+    const until = untilRaw ? resolveIsoOrRelative(untilRaw, nowValue, "event.recur_until") : undefined;
+    if (until && until < startAt) {
+        throw new PmCliError("--event recur_until must be at or after start", EXIT_CODE.USAGE);
+    }
+    const byWeekday = Array.from(new Set(parseDelimitedList(byWeekdayRaw)
+        .map((value) => ensureEnum(value.toLowerCase(), RECURRENCE_WEEKDAY_VALUES, "event weekday")))).sort((left, right) => weekdayOrderIndex(left) -
+        weekdayOrderIndex(right));
+    const byMonthDay = Array.from(new Set(parseDelimitedList(byMonthDayRaw)
+        .map((value) => {
+        const day = parseOptionalNumber(value, "event recur_by_month_day");
+        if (!Number.isInteger(day) || day < 1 || day > 31) {
+            throw new PmCliError("--event recur_by_month_day values must be integers 1..31", EXIT_CODE.USAGE);
+        }
+        return day;
+    }))).sort((left, right) => left - right);
+    const exdates = Array.from(new Set(parseDelimitedList(exdatesRaw).map((value) => resolveIsoOrRelative(value, nowValue, "event.recur_exdates")))).sort((left, right) => left.localeCompare(right));
+    return {
+        freq,
+        interval,
+        count,
+        until,
+        by_weekday: byWeekday.length > 0 ? byWeekday : undefined,
+        by_month_day: byMonthDay.length > 0 ? byMonthDay : undefined,
+        exdates: exdates.length > 0 ? exdates : undefined,
+    };
+}
+function parseEventEntries(raw, nowValue) {
+    return raw.map((entry) => {
+        const kv = parseCsvKv(entry, "--event");
+        const startRaw = kv.start?.trim();
+        if (!startRaw) {
+            throw new PmCliError("--event requires start=<iso|relative>", EXIT_CODE.USAGE);
+        }
+        const startAt = resolveIsoOrRelative(startRaw, nowValue, "event.start");
+        const endRaw = kv.end?.trim();
+        const endAt = endRaw ? resolveIsoOrRelative(endRaw, nowValue, "event.end") : undefined;
+        if (endAt && endAt <= startAt) {
+            throw new PmCliError("--event end must be after start", EXIT_CODE.USAGE);
+        }
+        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);
+        return {
+            start_at: startAt,
+            end_at: endAt,
+            title,
+            description,
+            location,
+            all_day: allDayRaw ? parseEventBoolean(allDayRaw, "--event all_day") : undefined,
+            timezone,
+            recurrence,
+        };
+    });
+}
+function parseTypeOptionEntries(raw) {
+    const values = {};
+    for (const entry of raw) {
+        const trimmedEntry = entry.trim();
+        if (trimmedEntry.length === 0) {
+            throw new PmCliError("--type-option values must not be empty", EXIT_CODE.USAGE);
+        }
+        let key;
+        let value;
+        const prefersStructuredKv = trimmedEntry.includes(",") ||
+            trimmedEntry.includes("\n") ||
+            trimmedEntry.startsWith("```") ||
+            /^(?:[-*+]\s+)?(?:key|value)\s*[:=]/i.test(trimmedEntry);
+        if (prefersStructuredKv) {
+            const kv = parseCsvKv(trimmedEntry, "--type-option");
+            key = kv.key?.trim();
+            value = kv.value?.trim();
+        }
+        else {
+            const equalsIndex = trimmedEntry.indexOf("=");
+            const colonIndex = trimmedEntry.indexOf(":");
+            let separatorIndex = equalsIndex;
+            if (equalsIndex <= 0 && colonIndex > 0) {
+                separatorIndex = colonIndex;
+            }
+            if (separatorIndex <= 0 || separatorIndex === trimmedEntry.length - 1) {
+                throw new PmCliError("--type-option requires key=value or key=<name>,value=<value> entries", EXIT_CODE.USAGE);
+            }
+            key = trimmedEntry.slice(0, separatorIndex).trim();
+            value = trimmedEntry.slice(separatorIndex + 1).trim();
+        }
+        if (!key || !value) {
+            throw new PmCliError("--type-option requires key and value", EXIT_CODE.USAGE);
+        }
+        values[key] = value;
+    }
+    return Object.fromEntries(Object.entries(values).sort((left, right) => left[0].localeCompare(right[0])));
+}
+function parseDependencyCreatedAt(value, currentIso) {
+    if (!value || value.trim() === "" || value.trim().toLowerCase() === "now") {
+        return currentIso;
+    }
+    const parsed = Date.parse(value);
+    if (!Number.isFinite(parsed)) {
+        throw new PmCliError(`Invalid dependency created_at timestamp "${value}"`, EXIT_CODE.USAGE);
+    }
+    return new Date(parsed).toISOString();
+}
+function parseOptionalDependencyString(value) {
+    if (value === undefined)
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function parseDependencyAdditions(raw, prefix, nowIso) {
+    if (!raw) {
+        return { additions: [] };
+    }
+    assertNoLegacyNoneTokens(raw, "--dep", "Use --clear-deps to clear dependencies.");
+    const additions = raw.map((entry) => {
+        const kv = parseCsvKv(entry, "--dep");
+        const id = kv.id?.trim();
+        const kind = kv.kind?.trim();
+        if (!id || !kind) {
+            throw new PmCliError("--dep requires id and kind", 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: ensureEnum(kind, DEPENDENCY_KIND_VALUES, "dependency kind"),
+            created_at: parseDependencyCreatedAt(kv.created_at, nowIso),
+            author: parseOptionalDependencyString(kv.author),
+            source_kind: sourceKind,
+        };
+    });
+    return { additions };
+}
+function parseDependencyRemovals(raw, prefix) {
+    if (!raw) {
+        return [];
+    }
+    assertNoLegacyNoneTokens(raw, "--dep-remove");
+    return raw.map((entry) => {
+        const trimmed = entry.trim();
+        if (!trimmed) {
+            throw new PmCliError("--dep-remove requires id or key/value selectors", EXIT_CODE.USAGE);
+        }
+        if (trimmed.includes("=") || /^(?:[-*+]\s+)?(?:id|kind|source_kind)\s*[:=]/i.test(trimmed) || trimmed.startsWith("```")) {
+            const kv = parseCsvKv(trimmed, "--dep-remove");
+            const idRaw = kv.id?.trim();
+            if (!idRaw) {
+                throw new PmCliError("--dep-remove key/value form requires id=<value>", EXIT_CODE.USAGE);
+            }
+            if (idRaw.toLowerCase() === "undefined") {
+                throw new PmCliError(`--dep-remove id must not use placeholder token "${idRaw}"`, EXIT_CODE.USAGE);
+            }
+            const kindRaw = parseOptionalDependencyString(kv.kind);
+            const sourceKind = parseOptionalDependencyString(kv.source_kind);
+            return {
+                id: normalizeItemId(idRaw, prefix),
+                kind: kindRaw ? ensureEnum(kindRaw, DEPENDENCY_KIND_VALUES, "dependency kind") : undefined,
+                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 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 !== undefined && (value.source_kind ?? undefined) !== selector.source_kind) {
+        return false;
+    }
+    return true;
+}
 function ensurePriority(raw) {
     const parsed = parseOptionalNumber(raw, "priority");
     if (![0, 1, 2, 3, 4].includes(parsed)) {
@@ -57,17 +744,368 @@ function ensurePriority(raw) {
     }
     return parsed;
 }
+function normalizeUpdatePolicyOptionKey(raw, typeName) {
+    const canonical = canonicalizeCommandOptionKey("update", raw);
+    if (!canonical) {
+        throw new PmCliError(`Unsupported command_option_policies option "${raw}" for update command on type "${typeName}"`, EXIT_CODE.CONFLICT);
+    }
+    return canonical;
+}
+function collectProvidedUpdatePolicyOptions(options) {
+    const provided = new Set();
+    const mark = (optionKey, isProvided) => {
+        if (isProvided) {
+            provided.add(optionKey);
+        }
+    };
+    mark("title", options.title !== undefined);
+    mark("description", options.description !== undefined);
+    mark("body", options.body !== undefined);
+    mark("status", options.status !== undefined);
+    mark("closeReason", options.closeReason !== undefined);
+    mark("priority", options.priority !== undefined);
+    mark("type", options.type !== undefined);
+    mark("tags", options.tags !== undefined);
+    mark("deadline", options.deadline !== undefined);
+    mark("estimatedMinutes", options.estimatedMinutes !== undefined);
+    mark("acceptanceCriteria", options.acceptanceCriteria !== undefined);
+    mark("definitionOfReady", options.definitionOfReady !== undefined);
+    mark("order", options.order !== undefined || options.rank !== undefined);
+    mark("goal", options.goal !== undefined);
+    mark("objective", options.objective !== undefined);
+    mark("value", options.value !== undefined);
+    mark("impact", options.impact !== undefined);
+    mark("outcome", options.outcome !== undefined);
+    mark("whyNow", options.whyNow !== undefined);
+    mark("author", options.author !== undefined);
+    mark("message", options.message !== undefined);
+    mark("assignee", options.assignee !== undefined);
+    mark("parent", options.parent !== undefined);
+    mark("reviewer", options.reviewer !== undefined);
+    mark("risk", options.risk !== undefined);
+    mark("confidence", options.confidence !== undefined);
+    mark("sprint", options.sprint !== undefined);
+    mark("release", options.release !== undefined);
+    mark("blockedBy", options.blockedBy !== undefined);
+    mark("blockedReason", options.blockedReason !== undefined);
+    mark("unblockNote", options.unblockNote !== undefined);
+    mark("reporter", options.reporter !== undefined);
+    mark("severity", options.severity !== undefined);
+    mark("environment", options.environment !== undefined);
+    mark("reproSteps", options.reproSteps !== undefined);
+    mark("resolution", options.resolution !== undefined);
+    mark("expectedResult", options.expectedResult !== undefined);
+    mark("actualResult", options.actualResult !== undefined);
+    mark("affectedVersion", options.affectedVersion !== undefined);
+    mark("fixedVersion", options.fixedVersion !== undefined);
+    mark("component", options.component !== undefined);
+    mark("regression", options.regression !== undefined);
+    mark("customerImpact", options.customerImpact !== undefined);
+    mark("dep", options.dep !== undefined);
+    mark("depRemove", options.depRemove !== undefined);
+    mark("dep", options.replaceDeps === true);
+    mark("comment", options.comment !== undefined);
+    mark("note", options.note !== undefined);
+    mark("learning", options.learning !== undefined);
+    mark("file", options.file !== undefined);
+    mark("test", options.test !== undefined);
+    mark("test", options.replaceTests === true);
+    mark("doc", options.doc !== undefined);
+    mark("reminder", options.reminder !== undefined);
+    mark("event", options.event !== undefined);
+    mark("typeOption", options.typeOption !== undefined);
+    mark("force", options.force === true);
+    mark("allowAuditUpdate", options.allowAuditUpdate === true);
+    mark("dep", options.clearDeps === true);
+    mark("comment", options.clearComments === true);
+    mark("note", options.clearNotes === true);
+    mark("learning", options.clearLearnings === true);
+    mark("file", options.clearFiles === true);
+    mark("test", options.clearTests === true);
+    mark("doc", options.clearDocs === true);
+    mark("reminder", options.clearReminders === true);
+    mark("event", options.clearEvents === true);
+    mark("typeOption", options.clearTypeOptions === true);
+    if (options.unset && options.unset.length > 0) {
+        const unsetTargets = parseUpdateUnsetTargets(options.unset);
+        for (const optionKey of unsetTargets.optionKeys) {
+            mark(optionKey, true);
+        }
+    }
+    return provided;
+}
+function enforceUpdateOptionsByType(typeName, options, typeRegistry) {
+    const typeDefinition = resolveTypeDefinition(typeName, typeRegistry);
+    if (!typeDefinition) {
+        throw new PmCliError(`Invalid type value "${typeName}"`, EXIT_CODE.USAGE);
+    }
+    const policyState = resolveCommandOptionPolicyState(typeDefinition, "update", []);
+    if (policyState.errors.length > 0) {
+        throw new PmCliError(policyState.errors.join("; "), EXIT_CODE.CONFLICT);
+    }
+    const provided = collectProvidedUpdatePolicyOptions(options);
+    for (const disabled of policyState.disabled) {
+        if (provided.has(normalizeUpdatePolicyOptionKey(disabled, typeName))) {
+            throw new PmCliError(`Option ${commandOptionFlagLabel("update", disabled)} is disabled for type "${typeName}" by command_option_policies`, EXIT_CODE.USAGE);
+        }
+    }
+    for (const required of policyState.required) {
+        if (!provided.has(normalizeUpdatePolicyOptionKey(required, typeName))) {
+            throw new PmCliError(`Missing required option ${commandOptionFlagLabel("update", required)} for type "${typeName}"`, EXIT_CODE.USAGE);
+        }
+    }
+}
 export async function runUpdate(id, options, global) {
+    const stdinResolver = createStdinTokenResolver();
+    options = {
+        ...options,
+        body: await stdinResolver.resolveValue(options.body, "--body"),
+        dep: await stdinResolver.resolveList(options.dep, "--dep"),
+        depRemove: await stdinResolver.resolveList(options.depRemove, "--dep-remove"),
+        comment: await stdinResolver.resolveList(options.comment, "--comment"),
+        note: await stdinResolver.resolveList(options.note, "--note"),
+        learning: await stdinResolver.resolveList(options.learning, "--learning"),
+        file: await stdinResolver.resolveList(options.file, "--file"),
+        test: await stdinResolver.resolveList(options.test, "--test"),
+        doc: await stdinResolver.resolveList(options.doc, "--doc"),
+        reminder: await stdinResolver.resolveList(options.reminder, "--reminder"),
+        event: await stdinResolver.resolveList(options.event, "--event"),
+        typeOption: await stdinResolver.resolveList(options.typeOption, "--type-option"),
+    };
     const pmRoot = resolvePmRoot(process.cwd(), global.path);
     if (!(await pathExists(getSettingsPath(pmRoot)))) {
         throw new PmCliError(`Tracker is not initialized at ${pmRoot}. Run pm init first.`, EXIT_CODE.NOT_FOUND);
     }
     const settings = await readSettings(pmRoot);
+    const statusRegistry = resolveRuntimeStatusRegistry(settings.schema);
+    const runtimeFieldRegistry = resolveRuntimeFieldRegistry(settings.schema);
+    const typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
+    const parentReferencePolicy = settings.validation.parent_reference;
+    const sprintReleasePolicy = settings.validation.sprint_release_format;
+    const unsetTargets = parseUpdateUnsetTargets(options.unset, runtimeFieldRegistry);
+    const clearOptionKeys = new Set(unsetTargets.optionKeys);
+    const clearFrontMatterKeys = new Set(unsetTargets.frontMatterKeys);
+    const clearCollectionDefinitions = [
+        {
+            enabled: options.clearDeps || options.replaceDeps,
+            optionKey: "dep",
+            clearFlag: "--clear-deps",
+            valueFlag: "--dep",
+            values: options.dep,
+            frontMatterKey: "dependencies",
+        },
+        {
+            enabled: options.clearComments,
+            optionKey: "comment",
+            clearFlag: "--clear-comments",
+            valueFlag: "--comment",
+            values: options.comment,
+            frontMatterKey: "comments",
+        },
+        {
+            enabled: options.clearNotes,
+            optionKey: "note",
+            clearFlag: "--clear-notes",
+            valueFlag: "--note",
+            values: options.note,
+            frontMatterKey: "notes",
+        },
+        {
+            enabled: options.clearLearnings,
+            optionKey: "learning",
+            clearFlag: "--clear-learnings",
+            valueFlag: "--learning",
+            values: options.learning,
+            frontMatterKey: "learnings",
+        },
+        {
+            enabled: options.clearFiles,
+            optionKey: "file",
+            clearFlag: "--clear-files",
+            valueFlag: "--file",
+            values: options.file,
+            frontMatterKey: "files",
+        },
+        {
+            enabled: options.clearTests || options.replaceTests,
+            optionKey: "test",
+            clearFlag: "--clear-tests",
+            valueFlag: "--test",
+            values: options.test,
+            frontMatterKey: "tests",
+        },
+        {
+            enabled: options.clearDocs,
+            optionKey: "doc",
+            clearFlag: "--clear-docs",
+            valueFlag: "--doc",
+            values: options.doc,
+            frontMatterKey: "docs",
+        },
+        {
+            enabled: options.clearReminders,
+            optionKey: "reminder",
+            clearFlag: "--clear-reminders",
+            valueFlag: "--reminder",
+            values: options.reminder,
+            frontMatterKey: "reminders",
+        },
+        {
+            enabled: options.clearEvents,
+            optionKey: "event",
+            clearFlag: "--clear-events",
+            valueFlag: "--event",
+            values: options.event,
+            frontMatterKey: "events",
+        },
+        {
+            enabled: options.clearTypeOptions,
+            optionKey: "typeOption",
+            clearFlag: "--clear-type-options",
+            valueFlag: "--type-option",
+            values: options.typeOption,
+            frontMatterKey: "type_options",
+        },
+    ];
+    if (options.replaceDeps === true && (options.dep === undefined || options.dep.length === 0)) {
+        throw new PmCliError("--replace-deps requires at least one --dep entry", EXIT_CODE.USAGE);
+    }
+    if (options.replaceDeps === true && options.depRemove !== undefined && options.depRemove.length > 0) {
+        throw new PmCliError("--replace-deps cannot be combined with --dep-remove", EXIT_CODE.USAGE);
+    }
+    if (options.replaceTests === true && (options.test === undefined || options.test.length === 0)) {
+        throw new PmCliError("--replace-tests requires at least one --test entry", EXIT_CODE.USAGE);
+    }
+    if (options.replaceTests === true && options.clearTests === true) {
+        throw new PmCliError("--replace-tests cannot be combined with --clear-tests", EXIT_CODE.USAGE);
+    }
+    for (const definition of clearCollectionDefinitions) {
+        if (!definition.enabled) {
+            continue;
+        }
+        if (definition.values &&
+            definition.values.length > 0 &&
+            !((definition.optionKey === "dep" && options.replaceDeps === true) ||
+                (definition.optionKey === "test" && options.replaceTests === true))) {
+            throw new PmCliError(`Cannot combine ${definition.clearFlag} with ${definition.valueFlag}`, EXIT_CODE.USAGE);
+        }
+        clearOptionKeys.add(definition.optionKey);
+        clearFrontMatterKeys.add(definition.frontMatterKey);
+    }
+    enforceAllowAuditUpdateScope(options, clearFrontMatterKeys);
+    const scalarOptionPresence = {
+        tags: options.tags !== undefined,
+        closeReason: options.closeReason !== undefined,
+        deadline: options.deadline !== undefined,
+        estimatedMinutes: options.estimatedMinutes !== undefined,
+        acceptanceCriteria: options.acceptanceCriteria !== undefined,
+        definitionOfReady: options.definitionOfReady !== undefined,
+        order: options.order !== undefined || options.rank !== undefined,
+        goal: options.goal !== undefined,
+        objective: options.objective !== undefined,
+        value: options.value !== undefined,
+        impact: options.impact !== undefined,
+        outcome: options.outcome !== undefined,
+        whyNow: options.whyNow !== undefined,
+        assignee: options.assignee !== undefined,
+        parent: options.parent !== undefined,
+        reviewer: options.reviewer !== undefined,
+        risk: options.risk !== undefined,
+        confidence: options.confidence !== undefined,
+        sprint: options.sprint !== undefined,
+        release: options.release !== undefined,
+        blockedBy: options.blockedBy !== undefined,
+        blockedReason: options.blockedReason !== undefined,
+        unblockNote: options.unblockNote !== undefined,
+        reporter: options.reporter !== undefined,
+        severity: options.severity !== undefined,
+        environment: options.environment !== undefined,
+        reproSteps: options.reproSteps !== undefined,
+        resolution: options.resolution !== undefined,
+        expectedResult: options.expectedResult !== undefined,
+        actualResult: options.actualResult !== undefined,
+        affectedVersion: options.affectedVersion !== undefined,
+        fixedVersion: options.fixedVersion !== undefined,
+        component: options.component !== undefined,
+        regression: options.regression !== undefined,
+        customerImpact: options.customerImpact !== undefined,
+    };
+    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);
+    }
+    const assertNoLegacyScalarToken = (value, optionKey) => {
+        const unsetField = UPDATE_OPTION_KEY_TO_UNSET_CANONICAL.get(optionKey);
+        const hint = unsetField ? `Use --unset ${unsetField} to clear this field.` : undefined;
+        assertNoLegacyNoneToken(value, commandOptionFlagLabel("update", optionKey), hint);
+    };
+    assertNoLegacyScalarToken(options.tags, "tags");
+    assertNoLegacyScalarToken(options.closeReason, "closeReason");
+    assertNoLegacyScalarToken(options.deadline, "deadline");
+    assertNoLegacyScalarToken(options.estimatedMinutes, "estimatedMinutes");
+    assertNoLegacyScalarToken(options.acceptanceCriteria, "acceptanceCriteria");
+    assertNoLegacyScalarToken(options.definitionOfReady, "definitionOfReady");
+    assertNoLegacyScalarToken(options.order ?? options.rank, "order");
+    assertNoLegacyScalarToken(options.goal, "goal");
+    assertNoLegacyScalarToken(options.objective, "objective");
+    assertNoLegacyScalarToken(options.value, "value");
+    assertNoLegacyScalarToken(options.impact, "impact");
+    assertNoLegacyScalarToken(options.outcome, "outcome");
+    assertNoLegacyScalarToken(options.whyNow, "whyNow");
+    assertNoLegacyScalarToken(options.assignee, "assignee");
+    assertNoLegacyScalarToken(options.parent, "parent");
+    assertNoLegacyScalarToken(options.reviewer, "reviewer");
+    assertNoLegacyScalarToken(options.risk, "risk");
+    assertNoLegacyScalarToken(options.confidence, "confidence");
+    assertNoLegacyScalarToken(options.sprint, "sprint");
+    assertNoLegacyScalarToken(options.release, "release");
+    assertNoLegacyScalarToken(options.blockedBy, "blockedBy");
+    assertNoLegacyScalarToken(options.blockedReason, "blockedReason");
+    assertNoLegacyScalarToken(options.unblockNote, "unblockNote");
+    assertNoLegacyScalarToken(options.reporter, "reporter");
+    assertNoLegacyScalarToken(options.severity, "severity");
+    assertNoLegacyScalarToken(options.environment, "environment");
+    assertNoLegacyScalarToken(options.reproSteps, "reproSteps");
+    assertNoLegacyScalarToken(options.resolution, "resolution");
+    assertNoLegacyScalarToken(options.expectedResult, "expectedResult");
+    assertNoLegacyScalarToken(options.actualResult, "actualResult");
+    assertNoLegacyScalarToken(options.affectedVersion, "affectedVersion");
+    assertNoLegacyScalarToken(options.fixedVersion, "fixedVersion");
+    assertNoLegacyScalarToken(options.component, "component");
+    assertNoLegacyScalarToken(options.regression, "regression");
+    assertNoLegacyScalarToken(options.customerImpact, "customerImpact");
+    assertNoLegacyNoneTokens(options.reminder, "--reminder", "Use --clear-reminders to clear reminders.");
+    assertNoLegacyNoneTokens(options.event, "--event", "Use --clear-events to clear linked events.");
     const author = toAuthor(options.author, settings.author_default);
+    const nowValue = new Date();
+    const nowIso = nowValue.toISOString();
+    const dependencyUpdates = parseDependencyAdditions(options.dep, settings.id_prefix, nowIso);
+    const dependencyRemovals = parseDependencyRemovals(options.depRemove, settings.id_prefix);
+    const commentUpdates = parseLogSeed("--comment", options.comment, nowIso, author);
+    const noteUpdates = parseLogSeed("--note", options.note, nowIso, author);
+    const learningUpdates = parseLogSeed("--learning", options.learning, nowIso, author);
+    const fileUpdates = parseFiles(options.file);
+    const testUpdates = parseTests(options.test);
+    const docUpdates = parseDocs(options.doc);
+    const parentReferenceWarnings = [];
+    let resolvedParentValue;
+    if (options.parent !== undefined && !unsetTargets.frontMatterKeys.has("parent")) {
+        resolvedParentValue = normalizeParentReferenceValue(options.parent);
+        const parentLocated = await locateItem(pmRoot, resolvedParentValue, settings.id_prefix, settings.item_format, typeRegistry.type_to_folder);
+        if (!parentLocated) {
+            const normalizedParentId = normalizeItemId(resolvedParentValue, settings.id_prefix);
+            parentReferenceWarnings.push(...validateMissingParentReference(normalizedParentId, parentReferencePolicy).warnings);
+        }
+    }
     const changedFlags = [
         options.title !== undefined,
         options.description !== undefined,
+        options.body !== undefined,
         options.status !== undefined,
+        options.closeReason !== undefined,
         options.priority !== undefined,
         options.type !== undefined,
         options.tags !== undefined,
@@ -105,6 +1143,30 @@ export async function runUpdate(id, options, global) {
         options.component !== undefined,
         options.regression !== undefined,
         options.customerImpact !== undefined,
+        options.dep !== undefined,
+        options.depRemove !== undefined,
+        options.replaceDeps === true,
+        options.comment !== undefined,
+        options.note !== undefined,
+        options.learning !== undefined,
+        options.file !== undefined,
+        options.test !== undefined,
+        options.replaceTests === true,
+        options.doc !== undefined,
+        options.reminder !== undefined,
+        options.event !== undefined,
+        options.typeOption !== undefined,
+        options.unset !== undefined && options.unset.length > 0,
+        options.clearDeps === true,
+        options.clearComments === true,
+        options.clearNotes === true,
+        options.clearLearnings === true,
+        options.clearFiles === true,
+        options.clearTests === true,
+        options.clearDocs === true,
+        options.clearReminders === true,
+        options.clearEvents === true,
+        options.clearTypeOptions === true,
     ].some(Boolean);
     if (!changedFlags) {
         throw new PmCliError("No update flags provided", EXIT_CODE.USAGE);
@@ -115,13 +1177,17 @@ export async function runUpdate(id, options, global) {
     const result = await mutateItem({
         pmRoot,
         settings,
+        typeToFolder: typeRegistry.type_to_folder,
         id,
-        op: "update",
+        op: options.allowAuditUpdate === true || options.allowAuditDepUpdate === true ? "update_audit" : "update",
         author,
         message: options.message,
         force: options.force,
+        bypassAssigneeConflict: options.allowAuditUpdate === true || options.allowAuditDepUpdate === true,
         mutate(document) {
             const changedFields = [];
+            const warnings = [];
+            let activeTypeName = resolveTypeName(document.front_matter.type, typeRegistry) ?? document.front_matter.type;
             if (options.title !== undefined) {
                 document.front_matter.title = options.title;
                 changedFields.push("title");
@@ -130,40 +1196,230 @@ export async function runUpdate(id, options, global) {
                 document.front_matter.description = options.description;
                 changedFields.push("description");
             }
+            if (options.body !== undefined) {
+                document.body = options.body;
+                changedFields.push("body");
+            }
+            const previousStatus = document.front_matter.status;
+            const previousStatusNormalized = normalizeStatusInput(previousStatus, statusRegistry) ?? previousStatus;
             if (options.status !== undefined) {
-                const status = ensureEnum(options.status, STATUS_VALUES, "status");
-                if (status === "closed") {
-                    throw new PmCliError('Invalid --status value "closed". Use "pm close <ID> <TEXT>" to close an item.', EXIT_CODE.USAGE);
+                const status = parseStatus(options.status, statusRegistry);
+                if (status === statusRegistry.close_status) {
+                    throw new PmCliError(`Invalid --status value "${statusRegistry.close_status}". Use "pm close <ID> <TEXT>" to close an item.`, EXIT_CODE.USAGE, {
+                        code: "close_through_update",
+                        why: "Closing requires a close reason and optional validation checks that pm update cannot enforce. Use pm close for auditable close workflows.",
+                        examples: [
+                            `pm close ${id} "All acceptance criteria met" --author "${author}" --message "Close: verified"`,
+                            `pm close ${id} "Resolved" --validate-close warn --author "${author}"`,
+                        ],
+                        nextSteps: [
+                            'Use "pm close <ID> <reason>" to close with required close reason and optional --validate-close.',
+                            'To cancel instead, use "pm update <ID> --status canceled".',
+                        ],
+                    });
                 }
                 document.front_matter.status = status;
-                if (status === "canceled") {
+                if (status === statusRegistry.canceled_status) {
                     delete document.front_matter.assignee;
                 }
                 changedFields.push("status");
             }
+            if (options.closeReason !== undefined || clearFrontMatterKeys.has("close_reason")) {
+                if (clearFrontMatterKeys.has("close_reason")) {
+                    delete document.front_matter.close_reason;
+                }
+                else {
+                    const closeReason = options.closeReason.trim();
+                    if (closeReason.length === 0) {
+                        throw new PmCliError("--close-reason must not be empty", EXIT_CODE.USAGE);
+                    }
+                    document.front_matter.close_reason = closeReason;
+                }
+                changedFields.push("close_reason");
+            }
+            else if (options.status !== undefined &&
+                previousStatusNormalized === statusRegistry.close_status &&
+                document.front_matter.status !== statusRegistry.canceled_status &&
+                document.front_matter.close_reason !== undefined) {
+                delete document.front_matter.close_reason;
+                changedFields.push("close_reason");
+            }
             if (options.priority !== undefined) {
                 document.front_matter.priority = ensurePriority(options.priority);
                 changedFields.push("priority");
             }
             if (options.type !== undefined) {
-                document.front_matter.type = ensureEnum(options.type, ITEM_TYPE_VALUES, "type");
+                const resolvedTypeName = resolveTypeName(options.type, typeRegistry);
+                if (!resolvedTypeName) {
+                    throw new PmCliError(`Invalid type value "${options.type}". Allowed: ${typeRegistry.types.join(", ")}`, EXIT_CODE.USAGE);
+                }
+                document.front_matter.type = resolvedTypeName;
+                activeTypeName = resolvedTypeName;
                 changedFields.push("type");
             }
-            if (options.tags !== undefined) {
-                document.front_matter.tags = parseTags(options.tags);
+            enforceUpdateOptionsByType(activeTypeName, options, typeRegistry);
+            if (options.typeOption !== undefined || clearFrontMatterKeys.has("type_options")) {
+                if (clearFrontMatterKeys.has("type_options")) {
+                    delete document.front_matter.type_options;
+                }
+                else {
+                    const parsedTypeOptions = parseTypeOptionEntries(options.typeOption);
+                    const validation = validateTypeOptions(activeTypeName, parsedTypeOptions, typeRegistry);
+                    if (validation.errors.length > 0) {
+                        throw new PmCliError(validation.errors.join("; "), EXIT_CODE.USAGE);
+                    }
+                    document.front_matter.type_options = validation.normalized;
+                }
+                changedFields.push("type_options");
+            }
+            else if (options.type !== undefined && document.front_matter.type_options !== undefined) {
+                const validation = validateTypeOptions(activeTypeName, document.front_matter.type_options, typeRegistry);
+                if (validation.errors.length > 0) {
+                    throw new PmCliError(`Current type options are incompatible with type "${activeTypeName}". ${validation.errors.join("; ")}. Use --clear-type-options to clear them.`, EXIT_CODE.USAGE);
+                }
+                document.front_matter.type_options = validation.normalized;
+            }
+            if (options.dep !== undefined || options.depRemove !== undefined || clearFrontMatterKeys.has("dependencies")) {
+                let nextDependencies = clearFrontMatterKeys.has("dependencies") ? [] : [...(document.front_matter.dependencies ?? [])];
+                if (dependencyUpdates.additions.length > 0) {
+                    const seen = new Set(nextDependencies.map((entry) => dependencyKey(entry)));
+                    for (const addition of dependencyUpdates.additions) {
+                        const key = dependencyKey(addition);
+                        if (seen.has(key)) {
+                            continue;
+                        }
+                        nextDependencies.push(addition);
+                        seen.add(key);
+                    }
+                }
+                if (dependencyRemovals.length > 0) {
+                    nextDependencies = nextDependencies.filter((entry) => !dependencyRemovals.some((selector) => matchesDependencySelector(entry, selector)));
+                }
+                if (nextDependencies.length === 0) {
+                    delete document.front_matter.dependencies;
+                }
+                else {
+                    document.front_matter.dependencies = nextDependencies;
+                }
+                changedFields.push("dependencies");
+            }
+            if (options.comment !== undefined || clearFrontMatterKeys.has("comments")) {
+                if (clearFrontMatterKeys.has("comments") || !commentUpdates.values || commentUpdates.values.length === 0) {
+                    delete document.front_matter.comments;
+                }
+                else {
+                    document.front_matter.comments = [...(document.front_matter.comments ?? []), ...commentUpdates.values];
+                }
+                changedFields.push("comments");
+            }
+            if (options.note !== undefined || clearFrontMatterKeys.has("notes")) {
+                if (clearFrontMatterKeys.has("notes") || !noteUpdates.values || noteUpdates.values.length === 0) {
+                    delete document.front_matter.notes;
+                }
+                else {
+                    document.front_matter.notes = [...(document.front_matter.notes ?? []), ...noteUpdates.values];
+                }
+                changedFields.push("notes");
+            }
+            if (options.learning !== undefined || clearFrontMatterKeys.has("learnings")) {
+                if (clearFrontMatterKeys.has("learnings") || !learningUpdates.values || learningUpdates.values.length === 0) {
+                    delete document.front_matter.learnings;
+                }
+                else {
+                    document.front_matter.learnings = [...(document.front_matter.learnings ?? []), ...learningUpdates.values];
+                }
+                changedFields.push("learnings");
+            }
+            if (options.file !== undefined || clearFrontMatterKeys.has("files")) {
+                if (clearFrontMatterKeys.has("files") || !fileUpdates.values || fileUpdates.values.length === 0) {
+                    delete document.front_matter.files;
+                }
+                else {
+                    const nextFiles = [...(document.front_matter.files ?? [])];
+                    const seen = new Set(nextFiles.map((entry) => fileKey(entry)));
+                    for (const entry of fileUpdates.values) {
+                        const key = fileKey(entry);
+                        if (seen.has(key)) {
+                            continue;
+                        }
+                        nextFiles.push(entry);
+                        seen.add(key);
+                    }
+                    document.front_matter.files = nextFiles;
+                }
+                changedFields.push("files");
+            }
+            if (options.test !== undefined || clearFrontMatterKeys.has("tests")) {
+                if (clearFrontMatterKeys.has("tests") && options.replaceTests === true) {
+                    if (!testUpdates.values || testUpdates.values.length === 0) {
+                        delete document.front_matter.tests;
+                    }
+                    else {
+                        const replacementTests = [];
+                        const seen = new Set();
+                        for (const entry of testUpdates.values) {
+                            const key = testKey(entry);
+                            if (seen.has(key)) {
+                                continue;
+                            }
+                            replacementTests.push(entry);
+                            seen.add(key);
+                        }
+                        document.front_matter.tests = replacementTests;
+                    }
+                }
+                else if (clearFrontMatterKeys.has("tests") || !testUpdates.values || testUpdates.values.length === 0) {
+                    delete document.front_matter.tests;
+                }
+                else {
+                    const nextTests = [...(document.front_matter.tests ?? [])];
+                    const seen = new Set(nextTests.map((entry) => testKey(entry)));
+                    for (const entry of testUpdates.values) {
+                        const key = testKey(entry);
+                        if (seen.has(key)) {
+                            continue;
+                        }
+                        nextTests.push(entry);
+                        seen.add(key);
+                    }
+                    document.front_matter.tests = nextTests;
+                }
+                changedFields.push("tests");
+            }
+            if (options.doc !== undefined || clearFrontMatterKeys.has("docs")) {
+                if (clearFrontMatterKeys.has("docs") || !docUpdates.values || docUpdates.values.length === 0) {
+                    delete document.front_matter.docs;
+                }
+                else {
+                    const nextDocs = [...(document.front_matter.docs ?? [])];
+                    const seen = new Set(nextDocs.map((entry) => docKey(entry)));
+                    for (const entry of docUpdates.values) {
+                        const key = docKey(entry);
+                        if (seen.has(key)) {
+                            continue;
+                        }
+                        nextDocs.push(entry);
+                        seen.add(key);
+                    }
+                    document.front_matter.docs = nextDocs;
+                }
+                changedFields.push("docs");
+            }
+            if (options.tags !== undefined || clearFrontMatterKeys.has("tags")) {
+                document.front_matter.tags = clearFrontMatterKeys.has("tags") ? [] : parseTags(options.tags);
                 changedFields.push("tags");
             }
-            if (options.deadline !== undefined) {
-                if (isNoneToken(options.deadline)) {
+            if (options.deadline !== undefined || clearFrontMatterKeys.has("deadline")) {
+                if (clearFrontMatterKeys.has("deadline")) {
                     delete document.front_matter.deadline;
                 }
                 else {
-                    document.front_matter.deadline = resolveIsoOrRelative(options.deadline);
+                    document.front_matter.deadline = resolveIsoOrRelative(options.deadline, new Date(), "deadline");
                 }
                 changedFields.push("deadline");
             }
-            if (options.estimatedMinutes !== undefined) {
-                if (isNoneToken(options.estimatedMinutes)) {
+            if (options.estimatedMinutes !== undefined || clearFrontMatterKeys.has("estimated_minutes")) {
+                if (clearFrontMatterKeys.has("estimated_minutes")) {
                     delete document.front_matter.estimated_minutes;
                 }
                 else {
@@ -171,8 +1427,8 @@ export async function runUpdate(id, options, global) {
                 }
                 changedFields.push("estimated_minutes");
             }
-            if (options.acceptanceCriteria !== undefined) {
-                if (isNoneToken(options.acceptanceCriteria)) {
+            if (options.acceptanceCriteria !== undefined || clearFrontMatterKeys.has("acceptance_criteria")) {
+                if (clearFrontMatterKeys.has("acceptance_criteria")) {
                     delete document.front_matter.acceptance_criteria;
                 }
                 else {
@@ -180,8 +1436,8 @@ export async function runUpdate(id, options, global) {
                 }
                 changedFields.push("acceptance_criteria");
             }
-            if (options.definitionOfReady !== undefined) {
-                if (isNoneToken(options.definitionOfReady)) {
+            if (options.definitionOfReady !== undefined || clearFrontMatterKeys.has("definition_of_ready")) {
+                if (clearFrontMatterKeys.has("definition_of_ready")) {
                     delete document.front_matter.definition_of_ready;
                 }
                 else {
@@ -190,8 +1446,8 @@ export async function runUpdate(id, options, global) {
                 changedFields.push("definition_of_ready");
             }
             const orderRaw = options.order ?? options.rank;
-            if (orderRaw !== undefined) {
-                if (isNoneToken(orderRaw)) {
+            if (orderRaw !== undefined || clearFrontMatterKeys.has("order")) {
+                if (clearFrontMatterKeys.has("order")) {
                     delete document.front_matter.order;
                 }
                 else {
@@ -203,8 +1459,8 @@ export async function runUpdate(id, options, global) {
                 }
                 changedFields.push("order");
             }
-            if (options.goal !== undefined) {
-                if (isNoneToken(options.goal)) {
+            if (options.goal !== undefined || clearFrontMatterKeys.has("goal")) {
+                if (clearFrontMatterKeys.has("goal")) {
                     delete document.front_matter.goal;
                 }
                 else {
@@ -212,8 +1468,8 @@ export async function runUpdate(id, options, global) {
                 }
                 changedFields.push("goal");
             }
-            if (options.objective !== undefined) {
-                if (isNoneToken(options.objective)) {
+            if (options.objective !== undefined || clearFrontMatterKeys.has("objective")) {
+                if (clearFrontMatterKeys.has("objective")) {
                     delete document.front_matter.objective;
                 }
                 else {
@@ -221,8 +1477,8 @@ export async function runUpdate(id, options, global) {
                 }
                 changedFields.push("objective");
             }
-            if (options.value !== undefined) {
-                if (isNoneToken(options.value)) {
+            if (options.value !== undefined || clearFrontMatterKeys.has("value")) {
+                if (clearFrontMatterKeys.has("value")) {
                     delete document.front_matter.value;
                 }
                 else {
@@ -230,8 +1486,8 @@ export async function runUpdate(id, options, global) {
                 }
                 changedFields.push("value");
             }
-            if (options.impact !== undefined) {
-                if (isNoneToken(options.impact)) {
+            if (options.impact !== undefined || clearFrontMatterKeys.has("impact")) {
+                if (clearFrontMatterKeys.has("impact")) {
                     delete document.front_matter.impact;
                 }
                 else {
@@ -239,8 +1495,8 @@ export async function runUpdate(id, options, global) {
                 }
                 changedFields.push("impact");
             }
-            if (options.outcome !== undefined) {
-                if (isNoneToken(options.outcome)) {
+            if (options.outcome !== undefined || clearFrontMatterKeys.has("outcome")) {
+                if (clearFrontMatterKeys.has("outcome")) {
                     delete document.front_matter.outcome;
                 }
                 else {
@@ -248,8 +1504,8 @@ export async function runUpdate(id, options, global) {
                 }
                 changedFields.push("outcome");
             }
-            if (options.whyNow !== undefined) {
-                if (isNoneToken(options.whyNow)) {
+            if (options.whyNow !== undefined || clearFrontMatterKeys.has("why_now")) {
+                if (clearFrontMatterKeys.has("why_now")) {
                     delete document.front_matter.why_now;
                 }
                 else {
@@ -257,26 +1513,29 @@ export async function runUpdate(id, options, global) {
                 }
                 changedFields.push("why_now");
             }
-            if (options.assignee !== undefined) {
-                if (isNoneToken(options.assignee) || options.assignee.trim() === "") {
+            if (options.assignee !== undefined || clearFrontMatterKeys.has("assignee")) {
+                if (clearFrontMatterKeys.has("assignee")) {
                     delete document.front_matter.assignee;
                 }
                 else {
+                    if (options.assignee.trim() === "") {
+                        throw new PmCliError("--assignee must not be empty. Use --unset assignee to clear it.", EXIT_CODE.USAGE);
+                    }
                     document.front_matter.assignee = options.assignee.trim();
                 }
                 changedFields.push("assignee");
             }
-            if (options.parent !== undefined) {
-                if (isNoneToken(options.parent)) {
+            if (options.parent !== undefined || clearFrontMatterKeys.has("parent")) {
+                if (clearFrontMatterKeys.has("parent")) {
                     delete document.front_matter.parent;
                 }
                 else {
-                    document.front_matter.parent = options.parent.trim();
+                    document.front_matter.parent = resolvedParentValue;
                 }
                 changedFields.push("parent");
             }
-            if (options.reviewer !== undefined) {
-                if (isNoneToken(options.reviewer)) {
+            if (options.reviewer !== undefined || clearFrontMatterKeys.has("reviewer")) {
+                if (clearFrontMatterKeys.has("reviewer")) {
                     delete document.front_matter.reviewer;
                 }
                 else {
@@ -284,8 +1543,8 @@ export async function runUpdate(id, options, global) {
                 }
                 changedFields.push("reviewer");
             }
-            if (options.risk !== undefined) {
-                if (isNoneToken(options.risk)) {
+            if (options.risk !== undefined || clearFrontMatterKeys.has("risk")) {
+                if (clearFrontMatterKeys.has("risk")) {
                     delete document.front_matter.risk;
                 }
                 else {
@@ -293,8 +1552,8 @@ export async function runUpdate(id, options, global) {
                 }
                 changedFields.push("risk");
             }
-            if (options.confidence !== undefined) {
-                if (isNoneToken(options.confidence)) {
+            if (options.confidence !== undefined || clearFrontMatterKeys.has("confidence")) {
+                if (clearFrontMatterKeys.has("confidence")) {
                     delete document.front_matter.confidence;
                 }
                 else {
@@ -302,26 +1561,30 @@ export async function runUpdate(id, options, global) {
                 }
                 changedFields.push("confidence");
             }
-            if (options.sprint !== undefined) {
-                if (isNoneToken(options.sprint)) {
+            if (options.sprint !== undefined || clearFrontMatterKeys.has("sprint")) {
+                if (clearFrontMatterKeys.has("sprint")) {
                     delete document.front_matter.sprint;
                 }
                 else {
-                    document.front_matter.sprint = options.sprint.trim();
+                    const sprintValidation = validateSprintOrReleaseValue("sprint", options.sprint, sprintReleasePolicy);
+                    document.front_matter.sprint = sprintValidation.value;
+                    warnings.push(...sprintValidation.warnings);
                 }
                 changedFields.push("sprint");
             }
-            if (options.release !== undefined) {
-                if (isNoneToken(options.release)) {
+            if (options.release !== undefined || clearFrontMatterKeys.has("release")) {
+                if (clearFrontMatterKeys.has("release")) {
                     delete document.front_matter.release;
                 }
                 else {
-                    document.front_matter.release = options.release.trim();
+                    const releaseValidation = validateSprintOrReleaseValue("release", options.release, sprintReleasePolicy);
+                    document.front_matter.release = releaseValidation.value;
+                    warnings.push(...releaseValidation.warnings);
                 }
                 changedFields.push("release");
             }
-            if (options.blockedBy !== undefined) {
-                if (isNoneToken(options.blockedBy)) {
+            if (options.blockedBy !== undefined || clearFrontMatterKeys.has("blocked_by")) {
+                if (clearFrontMatterKeys.has("blocked_by")) {
                     delete document.front_matter.blocked_by;
                 }
                 else {
@@ -329,8 +1592,8 @@ export async function runUpdate(id, options, global) {
                 }
                 changedFields.push("blocked_by");
             }
-            if (options.blockedReason !== undefined) {
-                if (isNoneToken(options.blockedReason)) {
+            if (options.blockedReason !== undefined || clearFrontMatterKeys.has("blocked_reason")) {
+                if (clearFrontMatterKeys.has("blocked_reason")) {
                     delete document.front_matter.blocked_reason;
                 }
                 else {
@@ -338,8 +1601,8 @@ export async function runUpdate(id, options, global) {
                 }
                 changedFields.push("blocked_reason");
             }
-            if (options.unblockNote !== undefined) {
-                if (isNoneToken(options.unblockNote)) {
+            if (options.unblockNote !== undefined || clearFrontMatterKeys.has("unblock_note")) {
+                if (clearFrontMatterKeys.has("unblock_note")) {
                     delete document.front_matter.unblock_note;
                 }
                 else {
@@ -347,8 +1610,8 @@ export async function runUpdate(id, options, global) {
                 }
                 changedFields.push("unblock_note");
             }
-            if (options.reporter !== undefined) {
-                if (isNoneToken(options.reporter)) {
+            if (options.reporter !== undefined || clearFrontMatterKeys.has("reporter")) {
+                if (clearFrontMatterKeys.has("reporter")) {
                     delete document.front_matter.reporter;
                 }
                 else {
@@ -356,8 +1619,8 @@ export async function runUpdate(id, options, global) {
                 }
                 changedFields.push("reporter");
             }
-            if (options.severity !== undefined) {
-                if (isNoneToken(options.severity)) {
+            if (options.severity !== undefined || clearFrontMatterKeys.has("severity")) {
+                if (clearFrontMatterKeys.has("severity")) {
                     delete document.front_matter.severity;
                 }
                 else {
@@ -365,8 +1628,8 @@ export async function runUpdate(id, options, global) {
                 }
                 changedFields.push("severity");
             }
-            if (options.environment !== undefined) {
-                if (isNoneToken(options.environment)) {
+            if (options.environment !== undefined || clearFrontMatterKeys.has("environment")) {
+                if (clearFrontMatterKeys.has("environment")) {
                     delete document.front_matter.environment;
                 }
                 else {
@@ -374,8 +1637,8 @@ export async function runUpdate(id, options, global) {
                 }
                 changedFields.push("environment");
             }
-            if (options.reproSteps !== undefined) {
-                if (isNoneToken(options.reproSteps)) {
+            if (options.reproSteps !== undefined || clearFrontMatterKeys.has("repro_steps")) {
+                if (clearFrontMatterKeys.has("repro_steps")) {
                     delete document.front_matter.repro_steps;
                 }
                 else {
@@ -383,8 +1646,8 @@ export async function runUpdate(id, options, global) {
                 }
                 changedFields.push("repro_steps");
             }
-            if (options.resolution !== undefined) {
-                if (isNoneToken(options.resolution)) {
+            if (options.resolution !== undefined || clearFrontMatterKeys.has("resolution")) {
+                if (clearFrontMatterKeys.has("resolution")) {
                     delete document.front_matter.resolution;
                 }
                 else {
@@ -392,8 +1655,8 @@ export async function runUpdate(id, options, global) {
                 }
                 changedFields.push("resolution");
             }
-            if (options.expectedResult !== undefined) {
-                if (isNoneToken(options.expectedResult)) {
+            if (options.expectedResult !== undefined || clearFrontMatterKeys.has("expected_result")) {
+                if (clearFrontMatterKeys.has("expected_result")) {
                     delete document.front_matter.expected_result;
                 }
                 else {
@@ -401,8 +1664,8 @@ export async function runUpdate(id, options, global) {
                 }
                 changedFields.push("expected_result");
             }
-            if (options.actualResult !== undefined) {
-                if (isNoneToken(options.actualResult)) {
+            if (options.actualResult !== undefined || clearFrontMatterKeys.has("actual_result")) {
+                if (clearFrontMatterKeys.has("actual_result")) {
                     delete document.front_matter.actual_result;
                 }
                 else {
@@ -410,8 +1673,8 @@ export async function runUpdate(id, options, global) {
                 }
                 changedFields.push("actual_result");
             }
-            if (options.affectedVersion !== undefined) {
-                if (isNoneToken(options.affectedVersion)) {
+            if (options.affectedVersion !== undefined || clearFrontMatterKeys.has("affected_version")) {
+                if (clearFrontMatterKeys.has("affected_version")) {
                     delete document.front_matter.affected_version;
                 }
                 else {
@@ -419,8 +1682,8 @@ export async function runUpdate(id, options, global) {
                 }
                 changedFields.push("affected_version");
             }
-            if (options.fixedVersion !== undefined) {
-                if (isNoneToken(options.fixedVersion)) {
+            if (options.fixedVersion !== undefined || clearFrontMatterKeys.has("fixed_version")) {
+                if (clearFrontMatterKeys.has("fixed_version")) {
                     delete document.front_matter.fixed_version;
                 }
                 else {
@@ -428,8 +1691,8 @@ export async function runUpdate(id, options, global) {
                 }
                 changedFields.push("fixed_version");
             }
-            if (options.component !== undefined) {
-                if (isNoneToken(options.component)) {
+            if (options.component !== undefined || clearFrontMatterKeys.has("component")) {
+                if (clearFrontMatterKeys.has("component")) {
                     delete document.front_matter.component;
                 }
                 else {
@@ -437,8 +1700,8 @@ export async function runUpdate(id, options, global) {
                 }
                 changedFields.push("component");
             }
-            if (options.regression !== undefined) {
-                if (isNoneToken(options.regression)) {
+            if (options.regression !== undefined || clearFrontMatterKeys.has("regression")) {
+                if (clearFrontMatterKeys.has("regression")) {
                     delete document.front_matter.regression;
                 }
                 else {
@@ -446,8 +1709,8 @@ export async function runUpdate(id, options, global) {
                 }
                 changedFields.push("regression");
             }
-            if (options.customerImpact !== undefined) {
-                if (isNoneToken(options.customerImpact)) {
+            if (options.customerImpact !== undefined || clearFrontMatterKeys.has("customer_impact")) {
+                if (clearFrontMatterKeys.has("customer_impact")) {
                     delete document.front_matter.customer_impact;
                 }
                 else {
@@ -455,13 +1718,59 @@ export async function runUpdate(id, options, global) {
                 }
                 changedFields.push("customer_impact");
             }
-            return { changedFields };
+            if (options.reminder !== undefined || clearFrontMatterKeys.has("reminders")) {
+                if (clearFrontMatterKeys.has("reminders")) {
+                    delete document.front_matter.reminders;
+                }
+                else {
+                    document.front_matter.reminders = parseReminderEntries(options.reminder, nowValue);
+                }
+                changedFields.push("reminders");
+            }
+            if (options.event !== undefined || clearFrontMatterKeys.has("events")) {
+                if (clearFrontMatterKeys.has("events")) {
+                    delete document.front_matter.events;
+                }
+                else {
+                    document.front_matter.events = parseEventEntries(options.event, nowValue);
+                }
+                changedFields.push("events");
+            }
+            for (const definition of runtimeFieldRegistry.definitions) {
+                if (!clearFrontMatterKeys.has(definition.front_matter_key)) {
+                    continue;
+                }
+                if (document.front_matter[definition.front_matter_key] === undefined) {
+                    continue;
+                }
+                delete document.front_matter[definition.front_matter_key];
+                changedFields.push(definition.front_matter_key);
+            }
+            const runtimeFieldUpdates = collectRuntimeUpdateFieldValues(options, runtimeFieldRegistry);
+            for (const [fieldKey, fieldValue] of Object.entries(runtimeFieldUpdates)) {
+                if (clearFrontMatterKeys.has(fieldKey)) {
+                    continue;
+                }
+                if (JSON.stringify(document.front_matter[fieldKey]) === JSON.stringify(fieldValue)) {
+                    continue;
+                }
+                document.front_matter[fieldKey] = fieldValue;
+                changedFields.push(fieldKey);
+            }
+            try {
+                applyRegisteredItemFieldDefaultsAndValidation(document.front_matter, getActiveExtensionRegistrations());
+            }
+            catch (error) {
+                throw new PmCliError(error instanceof Error ? error.message : "Invalid extension item field values", EXIT_CODE.USAGE);
+            }
+            return { changedFields, warnings };
         },
     });
     return {
         item: result.item,
         changed_fields: result.changedFields,
-        warnings: result.warnings,
+        warnings: [...parentReferenceWarnings, ...result.warnings],
+        ...(options.allowAuditUpdate === true || options.allowAuditDepUpdate === true ? { audit_update: true } : {}),
     };
 }
 //# sourceMappingURL=update.js.map