@unbrained/pm-cli 2026.5.31 → 2026.6.6

package/dist/cli-bundle/chunks/{chunk-JTWRXG4B.js → chunk-IJGCZSIQ.js}

@@ -10,44 +10,45 @@ import {
   parseLinkedTestMinLines,
   parseLinkedTestRegexList,
   parseLinkedTestStringList
-} from "./chunk-WJ2NAC37.js";
-import {
-  buildInvalidTypeError
-} from "./chunk-7Y53ZJIQ.js";
+} from "./chunk-N7ACFE26.js";
 import {
   createStdinTokenResolver,
   mergeAdditiveTags,
   parseCsvKv,
   parseOptionalNumber,
   parseTags
-} from "./chunk-NGN7UV5K.js";
+} from "./chunk-XLTD2HN3.js";
 import {
   normalizeParentReferenceValue,
   validateMissingParentReference,
   validateSprintOrReleaseValue
-} from "./chunk-AKOOMO3T.js";
+} from "./chunk-KAG77BY3.js";
+import {
+  buildInvalidTypeError
+} from "./chunk-OVQCEJPG.js";
 import {
   printError
-} from "./chunk-5HSEP75M.js";
+} from "./chunk-LCM63IXU.js";
 import {
+  acquireLock,
   appendHistoryEntry,
+  applyRegisteredItemFieldDefaultsAndValidation,
+  collectRegisteredItemFieldNames,
   createHistoryEntry,
-  locateItem
-} from "./chunk-BUPWJ3IJ.js";
-import {
-  acquireLock
-} from "./chunk-4AEZR5EJ.js";
+  locateItem,
+  parseRegisteredItemFieldAssignments
+} from "./chunk-XTGLRY2Y.js";
 import {
   generateItemId,
   normalizeItemId
-} from "./chunk-CEFIVZPG.js";
+} from "./chunk-T3LC5LKB.js";
 import {
   canonicalDocument,
   collectRuntimeCreateFieldValues,
   normalizeFrontMatter,
   normalizeStatusInput,
   serializeItemDocument
-} from "./chunk-MD7K4JYF.js";
+} from "./chunk-AO442XLN.js";
 import {
   canonicalizeCommandOptionKey,
   commandOptionFlagLabel,
@@ -56,11 +57,11 @@ import {
   resolveTypeDefinition,
   resolveTypeName,
   validateTypeOptions
-} from "./chunk-WDPXDQFG.js";
+} from "./chunk-KJE2FOS4.js";
 import {
   nowIso,
   resolveIsoOrRelative
-} from "./chunk-PVNQLCIS.js";
+} from "./chunk-QO7EBBOM.js";
 import {
   CONFIDENCE_TEXT_VALUES,
   DEPENDENCY_KIND_VALUES,
@@ -77,7 +78,9 @@ import {
   getItemPath,
   getSettingsPath,
   pathExists,
+  projectAfterCommandItemSnapshot,
   readSettings,
+  recordAfterCommandAffectedItem,
   removeFileIfExists,
   resolvePmRoot,
   resolveRuntimeFieldRegistry,
@@ -86,7 +89,7 @@ import {
   runActiveOnWriteHooks,
   weekdayOrderIndex,
   writeFileAtomic
-} from "./chunk-LSXGH6NE.js";
+} from "./chunk-U5SXYXSY.js";
 
 // dist/core/item/priority.js
 !(function() {
@@ -161,88 +164,6 @@ function resolveTypeSynonym(rawType) {
   return TYPE_SYNONYMS[rawType.trim().toLowerCase()];
 }
 
-// dist/core/extensions/item-fields.js
-!(function() {
-  try {
-    var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
-    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "ded4c408-642b-51bb-8f35-b66db506ce14");
-  } catch (e2) {
-  }
-})();
-function normalizeFieldName(value) {
-  if (typeof value !== "string") {
-    return null;
-  }
-  const normalized = value.trim();
-  return normalized.length > 0 ? normalized : null;
-}
-function normalizeFieldType(value) {
-  if (typeof value !== "string") {
-    return null;
-  }
-  const normalized = value.trim().toLowerCase();
-  if (normalized === "string" || normalized === "number" || normalized === "boolean" || normalized === "array" || normalized === "object") {
-    return normalized;
-  }
-  return null;
-}
-function cloneFieldValue(value) {
-  try {
-    return structuredClone(value);
-  } catch {
-    return value;
-  }
-}
-function isValidFieldType(value, expectedType) {
-  if (expectedType === "string") {
-    return typeof value === "string";
-  }
-  if (expectedType === "number") {
-    return typeof value === "number" && Number.isFinite(value);
-  }
-  if (expectedType === "boolean") {
-    return typeof value === "boolean";
-  }
-  if (expectedType === "array") {
-    return Array.isArray(value);
-  }
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isAllowedFieldValue(value, allowed) {
-  if (!allowed || allowed.length === 0) {
-    return true;
-  }
-  return allowed.some((candidate) => Object.is(candidate, value));
-}
-function applyRegisteredItemFieldDefaultsAndValidation(frontMatter, registrations) {
-  if (!registrations) {
-    return;
-  }
-  for (const registration of registrations.item_fields) {
-    for (const definition of registration.fields) {
-      const fieldName = normalizeFieldName(definition.name);
-      if (!fieldName) {
-        continue;
-      }
-      if (!(fieldName in frontMatter) && Object.prototype.hasOwnProperty.call(definition, "default")) {
-        frontMatter[fieldName] = cloneFieldValue(definition.default);
-      }
-      const currentValue = frontMatter[fieldName];
-      if (currentValue === void 0) {
-        continue;
-      }
-      const expectedType = normalizeFieldType(definition.type);
-      if (expectedType && !isValidFieldType(currentValue, expectedType)) {
-        throw new TypeError(`Item field "${fieldName}" must be of type ${expectedType}`);
-      }
-      const allowedValues = Array.isArray(definition.values) ? definition.values : void 0;
-      if (!isAllowedFieldValue(currentValue, allowedValues)) {
-        throw new TypeError(`Item field "${fieldName}" must match one of the configured allowed values`);
-      }
-    }
-  }
-}
-
 // dist/cli/commands/metadata-normalizers.js
 !(function() {
   try {
@@ -284,44 +205,6 @@ function parseRegressionInput(value) {
   throw new PmCliError("Regression must be one of true|false|1|0", EXIT_CODE.USAGE);
 }
 
-// dist/cli/commands/event-validation-messages.js
-!(function() {
-  try {
-    var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
-    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "d61c5566-4a50-5cd2-aafa-b52e99aa266a");
-  } catch (e2) {
-  }
-})();
-var EVENT_END_AFTER_START_MESSAGE = "--event end must be strictly after start. Equal start/end timestamps are treated as an instant event (end is dropped); an end earlier than start is rejected. Omit end for an instant event or set end later than start.";
-var EVENT_END_DURATION_MUTUALLY_EXCLUSIVE_MESSAGE = "--event end and duration are mutually exclusive; provide only one (use duration=<relative> like duration=2h, or set an explicit end).";
-function resolveEventEndAt(startAt, endRaw, durationRaw, referenceDate) {
-  if (endRaw && durationRaw) {
-    throw new PmCliError(EVENT_END_DURATION_MUTUALLY_EXCLUSIVE_MESSAGE, EXIT_CODE.USAGE);
-  }
-  if (durationRaw) {
-    const normalizedDuration = durationRaw.startsWith("+") ? durationRaw : `+${durationRaw}`;
-    const endAt2 = resolveIsoOrRelative(normalizedDuration, new Date(startAt), "event.duration");
-    if (endAt2 < startAt) {
-      throw new PmCliError(EVENT_END_AFTER_START_MESSAGE, EXIT_CODE.USAGE);
-    }
-    if (endAt2 === startAt) {
-      return void 0;
-    }
-    return endAt2;
-  }
-  if (!endRaw) {
-    return void 0;
-  }
-  const endAt = resolveIsoOrRelative(endRaw, referenceDate, "event.end");
-  if (endAt < startAt) {
-    throw new PmCliError(EVENT_END_AFTER_START_MESSAGE, EXIT_CODE.USAGE);
-  }
-  if (endAt === startAt) {
-    return void 0;
-  }
-  return endAt;
-}
-
 // dist/cli/commands/legacy-none-tokens.js
 !(function() {
   try {
@@ -435,11 +318,162 @@ function parseRecurrenceRule(kv, startAt, nowValue, emptyNumericGuard) {
   };
 }
 
+// dist/cli/commands/event-validation-messages.js
+!(function() {
+  try {
+    var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "d61c5566-4a50-5cd2-aafa-b52e99aa266a");
+  } catch (e2) {
+  }
+})();
+var EVENT_END_AFTER_START_MESSAGE = "--event end must be strictly after start. Equal start/end timestamps are treated as an instant event (end is dropped); an end earlier than start is rejected. Omit end for an instant event or set end later than start.";
+var EVENT_END_DURATION_MUTUALLY_EXCLUSIVE_MESSAGE = "--event end and duration are mutually exclusive; provide only one (use duration=<relative> like duration=2h, or set an explicit end).";
+function resolveEventEndAt(startAt, endRaw, durationRaw, referenceDate) {
+  if (endRaw && durationRaw) {
+    throw new PmCliError(EVENT_END_DURATION_MUTUALLY_EXCLUSIVE_MESSAGE, EXIT_CODE.USAGE);
+  }
+  if (durationRaw) {
+    const normalizedDuration = durationRaw.startsWith("+") ? durationRaw : `+${durationRaw}`;
+    const endAt2 = resolveIsoOrRelative(normalizedDuration, new Date(startAt), "event.duration");
+    if (endAt2 < startAt) {
+      throw new PmCliError(EVENT_END_AFTER_START_MESSAGE, EXIT_CODE.USAGE);
+    }
+    if (endAt2 === startAt) {
+      return void 0;
+    }
+    return endAt2;
+  }
+  if (!endRaw) {
+    return void 0;
+  }
+  const endAt = resolveIsoOrRelative(endRaw, referenceDate, "event.end");
+  if (endAt < startAt) {
+    throw new PmCliError(EVENT_END_AFTER_START_MESSAGE, EXIT_CODE.USAGE);
+  }
+  if (endAt === startAt) {
+    return void 0;
+  }
+  return endAt;
+}
+
+// dist/cli/commands/repeatable-metadata-parsers.js
+!(function() {
+  try {
+    var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "1f8d48a8-041d-5a4c-9dd2-a175d9be03ea");
+  } catch (e2) {
+  }
+})();
+function optionalString(value, mode) {
+  return mode === "trimmed" ? value?.trim() : value;
+}
+function isProvided(value, guard) {
+  return guard === "defined" ? value !== void 0 : Boolean(value);
+}
+function parseReminderEntries(raw, nowValue, options) {
+  return raw.map((entry) => {
+    const kv = parseCsvKv(entry, "--reminder");
+    const atRaw = optionalString(kv.at ?? kv.date, options.valueMode);
+    const textRaw = optionalString(kv.text ?? kv.title, options.valueMode);
+    if (!atRaw || !textRaw) {
+      throw new PmCliError("--reminder requires at=<iso|relative> or date=<iso|relative>, plus text=<value> or title=<value>", EXIT_CODE.USAGE);
+    }
+    const text = textRaw.trim();
+    if (!text) {
+      throw new PmCliError("--reminder text must not be empty", EXIT_CODE.USAGE);
+    }
+    return {
+      at: resolveIsoOrRelative(atRaw, nowValue, "reminder.at"),
+      text
+    };
+  });
+}
+function parseEventEntries(raw, nowValue, options) {
+  return raw.map((entry) => {
+    const kv = parseCsvKv(entry, "--event");
+    const startRaw = (kv.start ?? kv.date)?.trim();
+    if (!startRaw) {
+      throw new PmCliError("--event requires start=<iso|relative> or date=<iso|relative>", EXIT_CODE.USAGE);
+    }
+    const startAt = resolveIsoOrRelative(startRaw, nowValue, "event.start");
+    const endRaw = kv.end?.trim();
+    const durationRaw = kv.duration?.trim();
+    const endAt = resolveEventEndAt(startAt, endRaw, durationRaw, nowValue);
+    const titleRaw = kv.title;
+    const descriptionRaw = kv.description;
+    const locationRaw = kv.location;
+    const timezoneRaw = kv.timezone;
+    const title = titleRaw?.trim();
+    const description = descriptionRaw?.trim();
+    const location = locationRaw?.trim();
+    const timezone = timezoneRaw?.trim();
+    if (titleRaw !== void 0 && !title) {
+      throw new PmCliError("--event title must not be empty", EXIT_CODE.USAGE);
+    }
+    if (descriptionRaw !== void 0 && !description) {
+      throw new PmCliError("--event description must not be empty", EXIT_CODE.USAGE);
+    }
+    if (locationRaw !== void 0 && !location) {
+      throw new PmCliError("--event location must not be empty", EXIT_CODE.USAGE);
+    }
+    if (timezoneRaw !== void 0 && !timezone) {
+      throw new PmCliError("--event timezone must not be empty", EXIT_CODE.USAGE);
+    }
+    const allDayRaw = kv.all_day?.trim();
+    const recurrence = parseRecurrenceRule(kv, startAt, nowValue, options.recurrenceEmptyNumericGuard);
+    const allDay = isProvided(allDayRaw, options.allDayEmptyGuard) ? parseEventBoolean(allDayRaw, "--event all_day") : void 0;
+    return {
+      start_at: startAt,
+      end_at: endAt,
+      title,
+      description,
+      location,
+      all_day: allDay,
+      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])));
+}
+
 // dist/cli/commands/create.js
 !(function() {
   try {
     var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
-    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "34bfa540-3464-5b83-87d4-fe09e97d916d");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "6d06ae5b-933c-54ca-90c4-998090c1fcb3");
   } catch (e2) {
   }
 })();
@@ -711,9 +745,9 @@ function parseDependencies(raw, nowValue, prefix) {
   assertNoLegacyNoneTokens(raw, "--dep", "Use --clear-deps to clear dependencies.");
   const values = raw.map((entry) => {
     const trimmedEntry = entry.trim();
-    const kv = looksLikeStructuredEntry(trimmedEntry, ["id", "kind", "author", "created_at"]) ? parseCsvKv(entry, "--dep") : { id: trimmedEntry, kind: "related" };
+    const kv = looksLikeStructuredEntry(trimmedEntry, ["id", "kind", "type", "author", "created_at"]) ? parseCsvKv(entry, "--dep") : { id: trimmedEntry, kind: "related" };
     const id = parseOptionalString(kv.id);
-    const kind = parseOptionalString(kv.kind);
+    const kind = normalizeDependencyKindInput(parseOptionalString(kv.kind ?? kv.type));
     if (!id || !kind) {
       throw new PmCliError("--dep requires id and kind, or a bare item id to create a related dependency", EXIT_CODE.USAGE);
     }
@@ -729,6 +763,18 @@ function parseDependencies(raw, nowValue, prefix) {
   });
   return { values, explicitEmpty: false };
 }
+var DEPENDENCY_KIND_INPUT_ALIASES = {
+  "blocked-by": "blocked_by",
+  depends_on: "blocked_by",
+  "depends-on": "blocked_by"
+};
+function normalizeDependencyKindInput(raw) {
+  if (typeof raw !== "string") {
+    return raw;
+  }
+  const alias = DEPENDENCY_KIND_INPUT_ALIASES[raw.toLowerCase()];
+  return alias ?? raw;
+}
 function looksLikeStructuredEntry(raw, keys) {
   if (raw.startsWith("```") || raw.includes("\n")) {
     return true;
@@ -861,77 +907,27 @@ function parseReminders(raw, nowValue) {
   if (!raw || raw.length === 0)
     return { values: void 0, explicitEmpty: false };
   assertNoLegacyNoneTokens(raw, "--reminder", "Use --clear-reminders to clear reminders.");
-  const values = raw.map((entry) => {
-    const kv = parseCsvKv(entry, "--reminder");
-    const atRaw = parseOptionalString(kv.at ?? kv.date);
-    const textRaw = parseOptionalString(kv.text ?? kv.title);
-    if (!atRaw || !textRaw) {
-      throw new PmCliError("--reminder requires at=<iso|relative> or date=<iso|relative>, plus text=<value> or title=<value>", EXIT_CODE.USAGE);
-    }
-    const text = textRaw.trim();
-    if (!text) {
-      throw new PmCliError("--reminder text must not be empty", EXIT_CODE.USAGE);
-    }
-    return {
-      at: resolveIsoOrRelative(atRaw, new Date(nowValue), "reminder.at"),
-      text
-    };
-  });
-  return { values, explicitEmpty: false };
+  return {
+    values: parseReminderEntries(raw, new Date(nowValue), { valueMode: "raw" }),
+    explicitEmpty: false
+  };
 }
 function parseEvents(raw, nowValue) {
   if (!raw || raw.length === 0)
     return { values: void 0, explicitEmpty: false };
   assertNoLegacyNoneTokens(raw, "--event", "Use --clear-events to clear linked events.");
-  const referenceDate = new Date(nowValue);
-  const values = raw.map((entry) => {
-    const kv = parseCsvKv(entry, "--event");
-    const startRaw = parseOptionalString(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, referenceDate, "event.start");
-    const endRaw = parseOptionalString(kv.end)?.trim();
-    const durationRaw = parseOptionalString(kv.duration)?.trim();
-    const endAt = resolveEventEndAt(startAt, endRaw, durationRaw, referenceDate);
-    const titleRaw = parseOptionalString(kv.title);
-    const descriptionRaw = parseOptionalString(kv.description);
-    const locationRaw = parseOptionalString(kv.location);
-    const timezoneRaw = parseOptionalString(kv.timezone);
-    const title = titleRaw?.trim();
-    const description = descriptionRaw?.trim();
-    const location = locationRaw?.trim();
-    const timezone = timezoneRaw?.trim();
-    if (titleRaw !== void 0 && !title) {
-      throw new PmCliError("--event title must not be empty", EXIT_CODE.USAGE);
-    }
-    if (descriptionRaw !== void 0 && !description) {
-      throw new PmCliError("--event description must not be empty", EXIT_CODE.USAGE);
-    }
-    if (locationRaw !== void 0 && !location) {
-      throw new PmCliError("--event location must not be empty", EXIT_CODE.USAGE);
-    }
-    if (timezoneRaw !== void 0 && !timezone) {
-      throw new PmCliError("--event timezone must not be empty", EXIT_CODE.USAGE);
-    }
-    const allDayRaw = parseOptionalString(kv.all_day)?.trim();
-    const recurrence = parseRecurrenceRule(kv, startAt, referenceDate, "defined");
-    return {
-      start_at: startAt,
-      end_at: endAt,
-      title,
-      description,
-      location,
-      all_day: allDayRaw !== void 0 ? parseEventBoolean(allDayRaw, "--event all_day") : void 0,
-      timezone,
-      recurrence
-    };
-  });
-  return { values, explicitEmpty: false };
+  return {
+    values: parseEventEntries(raw, new Date(nowValue), {
+      allDayEmptyGuard: "defined",
+      recurrenceEmptyNumericGuard: "defined"
+    }),
+    explicitEmpty: false
+  };
 }
-function buildChangedFields(frontMatter, body, explicitUnsets) {
+function buildChangedFields(frontMatter, body, explicitUnsets, additionalFrontMatterKeys = []) {
   const changed = [
     ...FRONT_MATTER_KEY_ORDER.filter((key) => frontMatter[key] !== void 0),
+    ...additionalFrontMatterKeys.filter((key) => frontMatter[key] !== void 0),
     ...body.length > 0 ? ["body"] : [],
     ...explicitUnsets.map((key) => `unset:${key}`)
   ];
@@ -957,40 +953,8 @@ function parseTypeOptions(raw) {
     return { values: void 0, explicitEmpty: false };
   }
   assertNoLegacyNoneTokens(raw, "--type-option", "Use --clear-type-options to clear existing type options.");
-  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 = parseOptionalString(kv.key)?.trim();
-      value = parseOptionalString(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;
-  }
-  const sortedEntries = Object.entries(values).sort((left, right) => left[0].localeCompare(right[0]));
   return {
-    values: Object.fromEntries(sortedEntries),
+    values: parseTypeOptionEntries(raw),
     explicitEmpty: false
   };
 }
@@ -1008,7 +972,8 @@ async function resolveCreateStdinInputs(options) {
     doc: await stdinResolver.resolveList(options.doc, "--doc"),
     reminder: await stdinResolver.resolveList(options.reminder, "--reminder"),
     event: await stdinResolver.resolveList(options.event, "--event"),
-    typeOption: await stdinResolver.resolveList(options.typeOption, "--type-option")
+    typeOption: await stdinResolver.resolveList(options.typeOption, "--type-option"),
+    field: await stdinResolver.resolveList(options.field, "--field")
   };
 }
 function resolveCreateMode(createMode, defaultMode) {
@@ -1104,7 +1069,8 @@ function requireCreateOptionByType(typeDefinition, options, createMode, clearOpt
     doc: options.doc,
     reminder: options.reminder,
     event: options.event,
-    typeOption: options.typeOption
+    typeOption: options.typeOption,
+    field: options.field
   };
   const hasOptionValue = (optionKey) => {
     if (optionKey === "tags") {
@@ -1565,8 +1531,17 @@ async function runCreate(options, global2) {
   const events = parseEvents(resolvedOptions.event, nowValue);
   const typeOptions = parseTypeOptions(resolvedOptions.typeOption);
   const validatedTypeOptions = validateTypeOptions(type, typeOptions.values, typeRegistry);
+  const extensionRegistrations = getActiveExtensionRegistrations();
+  const extensionFieldNames = collectRegisteredItemFieldNames(extensionRegistrations);
+  const registeredItemFieldValues = parseRegisteredItemFieldAssignments(resolvedOptions.field, extensionRegistrations);
+  for (const fieldKey of Object.keys(registeredItemFieldValues)) {
+    if (!unsetTargets.frontMatterKeys.has(fieldKey)) {
+      continue;
+    }
+    throw new PmCliError(`Cannot combine --unset ${fieldKey.replaceAll("_", "-")} with --field ${fieldKey}=...`, EXIT_CODE.USAGE);
+  }
   const runtimeCreateFieldValues = collectRuntimeCreateFieldValues(resolvedOptions, runtimeFieldRegistry, type);
-  for (const fieldKey of Object.keys(runtimeCreateFieldValues.values)) {
+  for (const fieldKey of Object.keys(runtimeCreateFieldValues.values ?? {})) {
     if (!unsetTargets.frontMatterKeys.has(fieldKey)) {
       continue;
     }
@@ -1774,17 +1749,18 @@ async function runCreate(options, global2) {
     docs: docs.values,
     reminders: reminders.values,
     events: events.values,
-    ...runtimeCreateFieldValues.values
+    ...registeredItemFieldValues,
+    ...runtimeCreateFieldValues.values ?? {}
   });
   try {
-    applyRegisteredItemFieldDefaultsAndValidation(frontMatter, getActiveExtensionRegistrations());
+    applyRegisteredItemFieldDefaultsAndValidation(frontMatter, extensionRegistrations);
   } catch (error) {
     throw new PmCliError(error instanceof Error ? error.message : "Invalid extension item field values", EXIT_CODE.USAGE);
   }
   const afterDocument = canonicalDocument({
     metadata: frontMatter,
     body
-  }, { schema: settings.schema });
+  }, { schema: settings.schema, extensionFieldNames });
   const beforeDocument = {
     metadata: {},
     body: ""
@@ -1794,9 +1770,17 @@ async function runCreate(options, global2) {
   const lockRelease = await acquireLock(pmRoot, id, settings.locks.ttl_seconds, author, false, settings.governance.force_required_for_stale_lock);
   const explicitUnsetKeys = [...explicitUnsets].sort((left, right) => left.localeCompare(right));
   const historyMessage = buildHistoryMessage(resolvedOptions.message, explicitUnsetKeys);
+  const changedFields = buildChangedFields(frontMatter, body, explicitUnsetKeys, [
+    ...Object.keys(registeredItemFieldValues),
+    ...Object.keys(runtimeCreateFieldValues.values ?? {})
+  ]);
   let hookWarnings = [];
   try {
-    await writeFileAtomic(itemPath, serializeItemDocument(afterDocument, { format: settings.item_format, schema: settings.schema }));
+    await writeFileAtomic(itemPath, serializeItemDocument(afterDocument, {
+      format: settings.item_format,
+      schema: settings.schema,
+      extensionFieldNames
+    }));
     try {
       const entry = createHistoryEntry({
         nowIso: nowValue,
@@ -1815,18 +1799,35 @@ async function runCreate(options, global2) {
       ...await runActiveOnWriteHooks({
         path: itemPath,
         scope: "project",
-        op: "create"
+        op: "create",
+        item_id: afterDocument.metadata.id,
+        item_type: afterDocument.metadata.type,
+        before: beforeDocument,
+        after: afterDocument,
+        changed_fields: changedFields
       }),
       ...await runActiveOnWriteHooks({
         path: historyPath,
         scope: "project",
-        op: "create:history"
+        op: "create:history",
+        item_id: afterDocument.metadata.id,
+        item_type: afterDocument.metadata.type,
+        before: beforeDocument,
+        after: afterDocument,
+        changed_fields: changedFields
       })
     ];
+    recordAfterCommandAffectedItem({
+      id: afterDocument.metadata.id,
+      op: "create",
+      item_type: afterDocument.metadata.type,
+      status: afterDocument.metadata.status,
+      current: projectAfterCommandItemSnapshot(afterDocument.metadata, changedFields),
+      changed_fields: changedFields
+    });
   } finally {
     await lockRelease();
   }
-  const changedFields = buildChangedFields(frontMatter, body, explicitUnsetKeys);
   const outputItem = structuredClone(frontMatter);
   if (calendarRelevantTypes.has(type.toLowerCase()) && !hasDeadline && !hasReminders && !hasEvents) {
     printError(`[pm] warning: ${type} '${id}' has no deadline/reminder/event \u2014 it will not appear on the calendar. Add one via 'pm update ${id} --deadline <ISO>' or 'pm update ${id} --event "start=<ISO>,end=<ISO>"'.`);
@@ -1840,22 +1841,21 @@ async function runCreate(options, global2) {
 
 export {
   resolvePriority,
-  applyRegisteredItemFieldDefaultsAndValidation,
   normalizeRiskInput,
   normalizeSeverityInput,
   parseConfidenceInput,
   parseRegressionInput,
-  resolveEventEndAt,
   isLegacyNoneToken,
   assertNoLegacyNoneToken,
   assertNoLegacyNoneTokens,
-  parseEventBoolean,
   ensureEnumValue,
-  parseRecurrenceRule,
+  parseReminderEntries,
+  parseEventEntries,
+  parseTypeOptionEntries,
   parseLogSeed,
   parseFiles,
   parseTests,
   parseDocs,
   runCreate
 };
-//# sourceMappingURL=chunk-JTWRXG4B.js.map
+//# sourceMappingURL=chunk-IJGCZSIQ.js.map