@unbrained/pm-cli 2026.6.24 → 2026.7.1

package/dist/cli-bundle/chunks/{chunk-IAP5KYBQ.js → chunk-4XOIEKSD.js}

@@ -1,5 +1,5 @@
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="dd613437-a3c2-555c-9100-92271fb1f1db")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="282e5a28-5e38-537b-8dd7-1c4731851fe2")}catch(e){}}();
 import {
   looksLikeStructuredLinkedTestEntry,
   normalizeStructuredLinkedTestEntry,
@@ -12,7 +12,7 @@ import {
   parseLinkedTestMinLines,
   parseLinkedTestRegexList,
   parseLinkedTestStringList
-} from "./chunk-AYPQUFCX.js";
+} from "./chunk-EJUDVUYZ.js";
 import {
   assertNoUnknownCsvKeys,
   createStdinTokenResolver,
@@ -21,54 +21,43 @@ import {
   parseCsvKv,
   parseOptionalNumber,
   parseTags
-} from "./chunk-KIEAK7YE.js";
+} from "./chunk-ZRP4VG5U.js";
 import {
   getFocusedItem
-} from "./chunk-5S4ZGDB2.js";
+} from "./chunk-N74UMG5H.js";
 import {
   normalizeParentReferenceValue,
   validateMissingParentReference,
   validateSprintOrReleaseValue
-} from "./chunk-2WCYE3IF.js";
+} from "./chunk-HZZEHPRG.js";
 import {
   buildInvalidTypeError
-} from "./chunk-TSI32UEL.js";
+} from "./chunk-MAUKX7JC.js";
 import {
   printError
-} from "./chunk-JPJDP4VU.js";
+} from "./chunk-NWMZWYYB.js";
 import {
   acquireLock,
   appendHistoryEntry,
   applyRegisteredItemFieldDefaultsAndValidation,
   collectRegisteredItemFieldNames,
   createHistoryEntry,
+  generateItemId,
   locateItem,
+  normalizeItemId,
   parseRegisteredItemFieldAssignments
-} from "./chunk-KJZOSF7J.js";
-import {
-  generateItemId,
-  normalizeItemId
-} from "./chunk-FBLT6WGK.js";
+} from "./chunk-JSU5P7VS.js";
 import {
   canonicalDocument,
   collectRuntimeCreateFieldValues,
   normalizeFrontMatter,
   normalizeStatusInput,
   serializeItemDocument
-} from "./chunk-ZLWRPBOW.js";
-import {
-  canonicalizeCommandOptionKey,
-  commandOptionFlagLabel,
-  resolveCommandOptionPolicyState,
-  resolveItemTypeRegistry,
-  resolveTypeDefinition,
-  resolveTypeName,
-  validateTypeOptions
-} from "./chunk-TKPP4GOO.js";
+} from "./chunk-QCWF6IYD.js";
 import {
   nowIso,
   resolveIsoOrRelative
-} from "./chunk-FMWW2JDU.js";
+} from "./chunk-AXIDKKAT.js";
 import {
   CONFIDENCE_TEXT_VALUES,
   CREATE_DIRECT_CLOSE_REASON_DEFAULT,
@@ -81,6 +70,8 @@ import {
   RECURRENCE_WEEKDAY_VALUES,
   RISK_VALUES,
   SCOPE_VALUES,
+  canonicalizeCommandOptionKey,
+  commandOptionFlagLabel,
   getActiveExtensionRegistrations,
   getHistoryPath,
   getItemPath,
@@ -91,15 +82,20 @@ import {
   readSettings,
   recordAfterCommandAffectedItem,
   removeFileIfExists,
+  resolveCommandOptionPolicyState,
+  resolveItemTypeRegistry,
   resolveItemTypesFilePath,
   resolvePmRoot,
   resolveRuntimeFieldRegistry,
   resolveRuntimeStatusRegistry,
+  resolveTypeDefinition,
+  resolveTypeName,
   runActiveCommandHandler,
   runActiveOnWriteHooks,
+  validateTypeOptions,
   weekdayOrderIndex,
   writeFileAtomic
-} from "./chunk-VSAABFGQ.js";
+} from "./chunk-7R4QEMZZ.js";
 
 // dist/core/item/priority.js
 var PRIORITY_NAME_TO_VALUE = {
@@ -220,6 +216,32 @@ function assertNoLegacyNoneTokens(values, flag, replacementHint) {
   const suffix = replacementHint ? ` ${replacementHint}` : "";
   throw new PmCliError(`${flag} no longer accepts "none" or "null".${suffix}`.trim(), EXIT_CODE.USAGE);
 }
+function applyLegacyNoneCollectionNormalizers(normalized, definitions) {
+  for (const definition of definitions) {
+    const candidate = normalized[definition.optionKey];
+    if (!Array.isArray(candidate) || candidate.length === 0) {
+      continue;
+    }
+    if (!candidate.every((entry) => typeof entry === "string")) {
+      throw new PmCliError(`${definition.valueFlag} entries must be strings.`, EXIT_CODE.USAGE);
+    }
+    const entries = candidate;
+    const hasLegacy = entries.some((entry) => isLegacyNoneToken(entry));
+    if (!hasLegacy) {
+      continue;
+    }
+    const concreteEntries = entries.filter((entry) => !isLegacyNoneToken(entry));
+    if (concreteEntries.length > 0) {
+      throw new PmCliError(`Cannot mix legacy clear token "none"/"null" with concrete ${definition.valueFlag} entries. Use ${definition.clearFlag} to clear or provide explicit entries.`, EXIT_CODE.USAGE);
+    }
+    normalized[definition.optionKey] = void 0;
+    normalized[definition.clearFlagKey] = true;
+    if (definition.disableFlagKey) {
+      normalized[definition.disableFlagKey] = false;
+    }
+  }
+  return normalized;
+}
 
 // dist/cli/commands/lifecycle-transitions.js
 var NON_WORKABLE_TYPES = /* @__PURE__ */ new Set([
@@ -244,6 +266,162 @@ function suggestNextLifecycleTransition(id, type, status, statusRegistry) {
   return { command: `pm start-task ${id}`, to_status: inProgress };
 }
 
+// dist/cli/commands/shared-unset-fields.js
+var COMMON_UNSET_FIELD_DEFINITIONS_BEFORE_CLOSE_REASON = [
+  { canonical: "tags", aliases: ["tags"], optionKey: "tags", frontMatterKey: "tags" }
+];
+var COMMON_UNSET_FIELD_DEFINITIONS_AFTER_CLOSE_REASON_BEFORE_AUTHOR = [
+  { 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" }
+];
+var COMMON_UNSET_FIELD_DEFINITIONS_BEFORE_AUTHOR = [
+  ...COMMON_UNSET_FIELD_DEFINITIONS_BEFORE_CLOSE_REASON,
+  ...COMMON_UNSET_FIELD_DEFINITIONS_AFTER_CLOSE_REASON_BEFORE_AUTHOR
+];
+var COMMON_UNSET_FIELD_DEFINITIONS_AFTER_AUTHOR = [
+  { 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"
+  }
+];
+function resolveRuntimeUnsetFieldDefinition(token, command, runtimeFieldRegistry) {
+  const normalizedToken = token.trim().toLowerCase();
+  if (!runtimeFieldRegistry) {
+    return void 0;
+  }
+  const definitions = runtimeFieldRegistry.command_to_fields?.get(command) ?? [];
+  for (const definition of definitions) {
+    if (definition.allow_unset === false) {
+      continue;
+    }
+    const candidates = /* @__PURE__ */ new Set();
+    if (typeof definition.key === "string" && definition.key.length > 0) {
+      candidates.add(definition.key.toLowerCase());
+    }
+    if (typeof definition.metadata_key === "string" && definition.metadata_key.length > 0) {
+      candidates.add(definition.metadata_key.toLowerCase());
+    }
+    if (typeof definition.cli_flag === "string" && definition.cli_flag.length > 0) {
+      candidates.add(definition.cli_flag.replaceAll("-", "_").toLowerCase());
+      candidates.add(definition.cli_flag.toLowerCase());
+    }
+    if (Array.isArray(definition.cli_aliases)) {
+      for (const alias of definition.cli_aliases) {
+        if (typeof alias !== "string" || alias.length === 0) {
+          continue;
+        }
+        candidates.add(alias.replaceAll("-", "_").toLowerCase());
+        candidates.add(alias.toLowerCase());
+      }
+    }
+    if (!candidates.has(normalizedToken)) {
+      continue;
+    }
+    return {
+      optionKey: definition.key,
+      frontMatterKey: definition.metadata_key
+    };
+  }
+  return void 0;
+}
+
 // dist/cli/commands/recurrence-parsers.js
 function parseEventBoolean(value, flag) {
   const normalized = value.trim().toLowerCase();
@@ -452,17 +630,16 @@ function parseEventEntries(raw, nowValue, options) {
     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 optionalTextFields = [
+      ["title", titleRaw, title],
+      ["description", descriptionRaw, description],
+      ["location", locationRaw, location],
+      ["timezone", timezoneRaw, timezone]
+    ];
+    for (const [fieldLabel, rawValue, trimmedValue] of optionalTextFields) {
+      if (rawValue !== void 0 && !trimmedValue) {
+        throw new PmCliError(`--event ${fieldLabel} must not be empty`, EXIT_CODE.USAGE);
+      }
     }
     const allDayRaw = kv.all_day?.trim();
     const recurrence = parseRecurrenceRule(kv, startAt, nowValue, options.recurrenceEmptyNumericGuard);
@@ -521,111 +698,9 @@ var SCHEDULE_CREATE_PRESET_VALUES = ["lightweight"];
 var SCHEDULE_CREATE_PRESET_TYPES = /* @__PURE__ */ new Set(["Reminder", "Meeting", "Event"]);
 var LOG_SEED_ALLOWED_KEYS = /* @__PURE__ */ new Set(["author", "created_at", "text"]);
 var CREATE_UNSET_FIELD_DEFINITIONS = [
-  { canonical: "tags", aliases: ["tags"], optionKey: "tags", frontMatterKey: "tags" },
-  { 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" },
+  ...COMMON_UNSET_FIELD_DEFINITIONS_BEFORE_AUTHOR,
   { canonical: "author", aliases: ["author"], optionKey: "author", frontMatterKey: "author" },
-  { 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"
-  }
+  ...COMMON_UNSET_FIELD_DEFINITIONS_AFTER_AUTHOR
 ];
 var CREATE_UNSET_ALIAS_MAP = (() => {
   const map = /* @__PURE__ */ new Map();
@@ -711,55 +786,13 @@ function normalizeLegacyNoneCreateOptions(options) {
     appendUnsetTarget(canonicalUnset);
     normalized[optionKey] = void 0;
   }
-  for (const definition of CREATE_LEGACY_NONE_COLLECTION_NORMALIZERS) {
-    const entries = normalized[definition.optionKey];
-    if (!Array.isArray(entries) || entries.length === 0) {
-      continue;
-    }
-    const hasLegacy = entries.some((entry) => isLegacyNoneToken(entry));
-    if (!hasLegacy) {
-      continue;
-    }
-    const concreteEntries = entries.filter((entry) => !isLegacyNoneToken(entry));
-    if (concreteEntries.length > 0) {
-      throw new PmCliError(`Cannot mix legacy clear token "none"/"null" with concrete ${definition.valueFlag} entries. Use ${definition.clearFlag} to clear or provide explicit entries.`, EXIT_CODE.USAGE);
-    }
-    normalized[definition.optionKey] = void 0;
-    normalized[definition.clearFlagKey] = true;
-  }
-  return normalized;
+  return applyLegacyNoneCollectionNormalizers(normalized, CREATE_LEGACY_NONE_COLLECTION_NORMALIZERS);
 }
 function parseOptionalString(value) {
   if (value === void 0)
     return void 0;
   return value;
 }
-function resolveRuntimeCreateUnsetDefinition(token, runtimeFieldRegistry) {
-  if (!runtimeFieldRegistry) {
-    return void 0;
-  }
-  for (const definition of runtimeFieldRegistry.definitions) {
-    if (definition.allow_unset === false) {
-      continue;
-    }
-    const candidates = /* @__PURE__ */ new Set([
-      definition.key,
-      definition.metadata_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.metadata_key
-    };
-  }
-  return void 0;
-}
 function parseCreateUnsetTargets(raw, runtimeFieldRegistry) {
   const frontMatterKeys = /* @__PURE__ */ new Set();
   const optionKeys = /* @__PURE__ */ new Set();
@@ -774,7 +807,7 @@ function parseCreateUnsetTargets(raw, runtimeFieldRegistry) {
     if (isLegacyNoneToken(trimmed)) {
       throw new PmCliError('--unset no longer accepts "none" or "null". Specify concrete field names such as --unset deadline', EXIT_CODE.USAGE);
     }
-    const definition = CREATE_UNSET_ALIAS_MAP.get(trimmed) ?? resolveRuntimeCreateUnsetDefinition(trimmed, runtimeFieldRegistry);
+    const definition = CREATE_UNSET_ALIAS_MAP.get(trimmed) ?? resolveRuntimeUnsetFieldDefinition(trimmed, "create", runtimeFieldRegistry);
     if (!definition) {
       throw new PmCliError(`Unsupported --unset field "${entry}". Supported fields: ${CREATE_UNSET_SUPPORTED_CANONICAL_FIELDS}`, EXIT_CODE.USAGE);
     }
@@ -1347,14 +1380,96 @@ function ensureInitHasRun(pmRoot) {
     }
   });
 }
-async function runCreate(options, global) {
-  let resolvedOptions = normalizeLegacyNoneCreateOptions(await resolveCreateStdinInputs(options));
-  const pmRoot = resolvePmRoot(process.cwd(), global.path);
-  await ensureInitHasRun(pmRoot);
-  const settings = await readSettings(pmRoot);
-  const statusRegistry = resolveRuntimeStatusRegistry(settings.schema);
-  const runtimeFieldRegistry = resolveRuntimeFieldRegistry(settings.schema);
-  const typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
+function resolveUnsettableOptionalString(unsetKeys, frontMatterKey, raw) {
+  return unsetKeys.has(frontMatterKey) || raw === void 0 ? void 0 : parseOptionalString(raw);
+}
+function resolveUnsettableTransformed(unsetKeys, frontMatterKey, raw, transform) {
+  return unsetKeys.has(frontMatterKey) || raw === void 0 ? void 0 : transform(raw);
+}
+var CALENDAR_RELEVANT_CREATE_TYPES = /* @__PURE__ */ new Set(["milestone", "meeting", "reminder", "event"]);
+function createItemLacksSchedule(type, deadline, reminders, events) {
+  const hasDeadline = deadline !== void 0;
+  const hasReminders = reminders !== void 0 && reminders.length > 0;
+  const hasEvents = events !== void 0 && events.length > 0;
+  return CALENDAR_RELEVANT_CREATE_TYPES.has(type.toLowerCase()) && !hasDeadline && !hasReminders && !hasEvents;
+}
+function collectCreateScheduleWarnings(type, id, deadline, reminders, events) {
+  const warnings = [];
+  if (type.toLowerCase() === "event" && (events === void 0 || events.length === 0)) {
+    warnings.push(`event_without_schedule:${id}:no_time_set`);
+  }
+  if (createItemLacksSchedule(type, deadline, reminders, events)) {
+    warnings.push(`calendar_item_without_schedule:${id}:no_deadline_or_reminder_or_event (hint: set --deadline <ISO> or --reminder "<when>", or link an Event via --event "start=<ISO>,end=<ISO>"; otherwise this item never appears on pm calendar)`);
+  }
+  return warnings;
+}
+async function inheritFocusedParent(parent, resolvedOptions, unsetKeys, pmRoot) {
+  if (parent !== void 0 || unsetKeys.has("parent") || resolvedOptions.parent !== void 0) {
+    return { parent, parentSource: void 0 };
+  }
+  const focused = await getFocusedItem(pmRoot);
+  if (focused === void 0) {
+    return { parent, parentSource: void 0 };
+  }
+  return { parent: focused, parentSource: "focus" };
+}
+async function validateCreateParentReference(pmRoot, settings, typeRegistry, parent, policy) {
+  const normalized = normalizeParentReferenceValue(parent);
+  const parentLocated = await locateItem(pmRoot, normalized, settings.id_prefix, settings.item_format, typeRegistry.type_to_folder);
+  if (parentLocated) {
+    return { parent: normalized, warnings: [] };
+  }
+  const normalizedParentId = normalizeItemId(normalized, settings.id_prefix);
+  return { parent: normalized, warnings: validateMissingParentReference(normalizedParentId, policy).warnings };
+}
+function resolveCreateSprintOrRelease(unsetKeys, frontMatterKey, raw, field, policy) {
+  const resolved = resolveUnsettableOptionalString(unsetKeys, frontMatterKey, raw);
+  if (resolved === void 0) {
+    return { value: void 0, warnings: [] };
+  }
+  const validation = validateSprintOrReleaseValue(field, resolved, policy);
+  return { value: validation.value, warnings: validation.warnings };
+}
+async function resolveCreateBlockedByDependency(params) {
+  const { pmRoot, settings, typeRegistry, statusRegistry, blockedBy, status, statusExplicit, nowValue, author } = params;
+  let dependencyValues = params.dependencyValues;
+  if (blockedBy === void 0) {
+    return { dependencyValues, status };
+  }
+  const normalizedBlockedBy = normalizeItemId(blockedBy, settings.id_prefix);
+  const blockedByLocated = await locateItem(pmRoot, normalizedBlockedBy, settings.id_prefix, settings.item_format, typeRegistry.type_to_folder);
+  if (!blockedByLocated) {
+    return { dependencyValues, status };
+  }
+  const hasBlockedByDependency = (dependencyValues ?? []).some((dependency) => dependency.id === blockedByLocated.id && dependency.kind === "blocked_by");
+  if (!hasBlockedByDependency) {
+    dependencyValues = [
+      ...dependencyValues ?? [],
+      { id: blockedByLocated.id, kind: "blocked_by", created_at: nowValue, author }
+    ];
+  }
+  if (statusExplicit) {
+    return { dependencyValues, status };
+  }
+  const blockedStatus = statusRegistry.blocked_statuses.has("blocked") ? "blocked" : [...statusRegistry.blocked_statuses].sort((left, right) => left.localeCompare(right))[0] ?? statusRegistry.open_status;
+  return { dependencyValues, status: blockedStatus };
+}
+function applyCreateDefaultType(resolvedOptions, settings, typeRegistry) {
+  const explicitStrictMode = typeof resolvedOptions.createMode === "string" && resolvedOptions.createMode.trim().toLowerCase() === "strict";
+  if (explicitStrictMode) {
+    return;
+  }
+  const defaultType = settings.governance.create_default_type?.trim();
+  if (defaultType && defaultType.length > 0 && resolveTypeName(defaultType, typeRegistry)) {
+    resolvedOptions.type = defaultType;
+    return;
+  }
+  if (resolveTypeName("Task", typeRegistry)) {
+    resolvedOptions.type = "Task";
+  }
+}
+async function resolveCreateTypeSelection(options, global, pmRoot, settings, typeRegistry) {
+  let resolvedOptions = options;
   if (resolvedOptions.template !== void 0) {
     const templateName = resolvedOptions.template.trim();
     if (templateName.length === 0) {
@@ -1364,17 +1479,7 @@ async function runCreate(options, global) {
     resolvedOptions = normalizeLegacyNoneCreateOptions(mergeCreateOptionsWithTemplate(templateOptions, resolvedOptions));
   }
   if (resolvedOptions.type === void 0) {
-    const explicitStrictMode = typeof resolvedOptions.createMode === "string" && resolvedOptions.createMode.trim().toLowerCase() === "strict";
-    if (!explicitStrictMode) {
-      const defaultType = settings.governance.create_default_type?.trim();
-      if (defaultType && defaultType.length > 0 && resolveTypeName(defaultType, typeRegistry)) {
-        resolvedOptions.type = defaultType;
-      } else {
-        if (resolveTypeName("Task", typeRegistry)) {
-          resolvedOptions.type = "Task";
-        }
-      }
-    }
+    applyCreateDefaultType(resolvedOptions, settings, typeRegistry);
   }
   if (resolvedOptions.type === void 0) {
     throw new PmCliError("Missing required option --type <value>", EXIT_CODE.USAGE);
@@ -1401,90 +1506,22 @@ async function runCreate(options, global) {
     throw new PmCliError(`--schedule-preset ${schedulePreset} is only supported for Reminder, Meeting, or Event types`, EXIT_CODE.USAGE);
   }
   const createMode = resolveEffectiveCreateMode(resolvedOptions.createMode, schedulePreset, settings.governance.create_mode_default);
-  const unsetTargets = parseCreateUnsetTargets(resolvedOptions.unset, runtimeFieldRegistry);
+  return { resolvedOptions, typeDefinition, type, schedulePreset, createMode };
+}
+function collectCreateClearTargets(resolvedOptions, unsetTargets) {
   const explicitUnsets = new Set(unsetTargets.frontMatterKeys);
   const clearOptionKeys = new Set(unsetTargets.optionKeys);
   const clearCollectionDefinitions = [
-    {
-      enabled: resolvedOptions.clearDeps,
-      optionKey: "dep",
-      clearFlag: "--clear-deps",
-      valueFlag: "--dep",
-      values: resolvedOptions.dep,
-      frontMatterKey: "dependencies"
-    },
-    {
-      enabled: resolvedOptions.clearComments,
-      optionKey: "comment",
-      clearFlag: "--clear-comments",
-      valueFlag: "--comment",
-      values: resolvedOptions.comment,
-      frontMatterKey: "comments"
-    },
-    {
-      enabled: resolvedOptions.clearNotes,
-      optionKey: "note",
-      clearFlag: "--clear-notes",
-      valueFlag: "--note",
-      values: resolvedOptions.note,
-      frontMatterKey: "notes"
-    },
-    {
-      enabled: resolvedOptions.clearLearnings,
-      optionKey: "learning",
-      clearFlag: "--clear-learnings",
-      valueFlag: "--learning",
-      values: resolvedOptions.learning,
-      frontMatterKey: "learnings"
-    },
-    {
-      enabled: resolvedOptions.clearFiles,
-      optionKey: "file",
-      clearFlag: "--clear-files",
-      valueFlag: "--file",
-      values: resolvedOptions.file,
-      frontMatterKey: "files"
-    },
-    {
-      enabled: resolvedOptions.clearTests,
-      optionKey: "test",
-      clearFlag: "--clear-tests",
-      valueFlag: "--test",
-      values: resolvedOptions.test,
-      frontMatterKey: "tests"
-    },
-    {
-      enabled: resolvedOptions.clearDocs,
-      optionKey: "doc",
-      clearFlag: "--clear-docs",
-      valueFlag: "--doc",
-      values: resolvedOptions.doc,
-      frontMatterKey: "docs"
-    },
-    {
-      enabled: resolvedOptions.clearReminders,
-      optionKey: "reminder",
-      clearFlag: "--clear-reminders",
-      valueFlag: "--reminder",
-      values: resolvedOptions.reminder,
-      frontMatterKey: "reminders"
-    },
-    {
-      enabled: resolvedOptions.clearEvents,
-      optionKey: "event",
-      clearFlag: "--clear-events",
-      valueFlag: "--event",
-      values: resolvedOptions.event,
-      frontMatterKey: "events"
-    },
-    {
-      enabled: resolvedOptions.clearTypeOptions,
-      optionKey: "typeOption",
-      clearFlag: "--clear-type-options",
-      valueFlag: "--type-option",
-      values: resolvedOptions.typeOption,
-      frontMatterKey: "type_options"
-    }
+    { enabled: resolvedOptions.clearDeps, optionKey: "dep", clearFlag: "--clear-deps", valueFlag: "--dep", values: resolvedOptions.dep, frontMatterKey: "dependencies" },
+    { enabled: resolvedOptions.clearComments, optionKey: "comment", clearFlag: "--clear-comments", valueFlag: "--comment", values: resolvedOptions.comment, frontMatterKey: "comments" },
+    { enabled: resolvedOptions.clearNotes, optionKey: "note", clearFlag: "--clear-notes", valueFlag: "--note", values: resolvedOptions.note, frontMatterKey: "notes" },
+    { enabled: resolvedOptions.clearLearnings, optionKey: "learning", clearFlag: "--clear-learnings", valueFlag: "--learning", values: resolvedOptions.learning, frontMatterKey: "learnings" },
+    { enabled: resolvedOptions.clearFiles, optionKey: "file", clearFlag: "--clear-files", valueFlag: "--file", values: resolvedOptions.file, frontMatterKey: "files" },
+    { enabled: resolvedOptions.clearTests, optionKey: "test", clearFlag: "--clear-tests", valueFlag: "--test", values: resolvedOptions.test, frontMatterKey: "tests" },
+    { enabled: resolvedOptions.clearDocs, optionKey: "doc", clearFlag: "--clear-docs", valueFlag: "--doc", values: resolvedOptions.doc, frontMatterKey: "docs" },
+    { enabled: resolvedOptions.clearReminders, optionKey: "reminder", clearFlag: "--clear-reminders", valueFlag: "--reminder", values: resolvedOptions.reminder, frontMatterKey: "reminders" },
+    { enabled: resolvedOptions.clearEvents, optionKey: "event", clearFlag: "--clear-events", valueFlag: "--event", values: resolvedOptions.event, frontMatterKey: "events" },
+    { enabled: resolvedOptions.clearTypeOptions, optionKey: "typeOption", clearFlag: "--clear-type-options", valueFlag: "--type-option", values: resolvedOptions.typeOption, frontMatterKey: "type_options" }
   ];
   for (const definition of clearCollectionDefinitions) {
     if (!definition.enabled) {
@@ -1496,6 +1533,9 @@ async function runCreate(options, global) {
     explicitUnsets.add(definition.frontMatterKey);
     clearOptionKeys.add(definition.optionKey);
   }
+  return { explicitUnsets, clearOptionKeys };
+}
+function assertNoCreateScalarUnsetConflicts(resolvedOptions, unsetTargets) {
   const scalarOptionPresence = {
     tags: resolvedOptions.tags !== void 0,
     deadline: resolvedOptions.deadline !== void 0,
@@ -1541,10 +1581,12 @@ async function runCreate(options, global) {
     const unsetField = CREATE_OPTION_KEY_TO_UNSET_CANONICAL.get(optionKey) ?? optionKey;
     throw new PmCliError(`Cannot combine --unset ${unsetField} with ${commandOptionFlagLabel("create", optionKey)}`, EXIT_CODE.USAGE);
   }
-  const assertNoLegacyScalarToken = (value2, optionKey) => {
+}
+function assertNoLegacyCreateScalarTokens(resolvedOptions) {
+  const assertNoLegacyScalarToken = (value, optionKey) => {
     const unsetField = CREATE_OPTION_KEY_TO_UNSET_CANONICAL.get(optionKey);
     const hint = unsetField ? `Use --unset ${unsetField} to clear this field.` : void 0;
-    assertNoLegacyNoneToken(value2, commandOptionFlagLabel("create", optionKey), hint);
+    assertNoLegacyNoneToken(value, commandOptionFlagLabel("create", optionKey), hint);
   };
   assertNoLegacyScalarToken(resolvedOptions.tags, "tags");
   assertNoLegacyScalarToken(resolvedOptions.deadline, "deadline");
@@ -1581,6 +1623,143 @@ async function runCreate(options, global) {
   assertNoLegacyScalarToken(resolvedOptions.component, "component");
   assertNoLegacyScalarToken(resolvedOptions.regression, "regression");
   assertNoLegacyScalarToken(resolvedOptions.customerImpact, "customerImpact");
+}
+function assertNoCreateFieldUnsetConflicts(registeredItemFieldValues, runtimeCreateFieldValues, unsetTargets) {
+  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);
+  }
+  for (const fieldKey of Object.keys(runtimeCreateFieldValues.values ?? {})) {
+    if (!unsetTargets.frontMatterKeys.has(fieldKey)) {
+      continue;
+    }
+    throw new PmCliError(`Cannot combine --unset ${fieldKey.replaceAll("_", "-")} with its value flag`, EXIT_CODE.USAGE);
+  }
+}
+function assertNoMissingRequiredCreateOptions(params) {
+  const { combinedMissingFlags, typeDefinition, missingRequiredCreateFlags, missingRequiredTypeOptionKeys, openStatus, type, createMode } = params;
+  if (combinedMissingFlags.length === 0) {
+    return;
+  }
+  const nextValidExample = buildTypeSpecificCreateExample(typeDefinition, missingRequiredCreateFlags, missingRequiredTypeOptionKeys, openStatus);
+  const nextSteps = [`Run "pm create --help --type ${type}" for type-aware required option guidance.`];
+  if (combinedMissingFlags.includes("--title")) {
+    nextSteps.push('Title can also be passed as the first positional argument (example: pm create "Your title" --type ' + type + ").");
+  }
+  if (createMode === "strict") {
+    nextSteps.push('For staged onboarding, retry with "--create-mode progressive".');
+    if (SCHEDULE_CREATE_PRESET_TYPES.has(type)) {
+      nextSteps.push('For minimal scheduling inputs, try "--schedule-preset lightweight".');
+    }
+  }
+  const errorMessage = combinedMissingFlags.length === 1 ? `Missing required option ${combinedMissingFlags[0]} for type "${type}"` : `Missing required options ${combinedMissingFlags.join(", ")} for type "${type}"`;
+  throw new PmCliError(errorMessage, EXIT_CODE.USAGE, {
+    code: "missing_required_option",
+    required: `Provide all required create options and type options for type "${type}" in one invocation.`,
+    examples: [nextValidExample],
+    nextSteps,
+    recovery: createMode === "strict" ? {
+      recovery_mode: "compact",
+      missing_required_fields: combinedMissingFlags,
+      suggested_flags: ["--create-mode progressive", ...combinedMissingFlags]
+    } : void 0
+  });
+}
+function resolveCreateTags(unsetKeys, resolvedOptions) {
+  if (unsetKeys.has("tags") && Array.isArray(resolvedOptions.addTags) && resolvedOptions.addTags.length > 0) {
+    throw new PmCliError("Cannot combine --unset tags with --add-tags", EXIT_CODE.USAGE);
+  }
+  const baseTags = unsetKeys.has("tags") ? [] : resolvedOptions.tags !== void 0 ? parseTags(resolvedOptions.tags) : [];
+  return mergeAdditiveTags(baseTags, resolvedOptions.addTags);
+}
+function resolveCreateOrder(unsetKeys, resolvedOptions) {
+  if (resolvedOptions.order !== void 0 && resolvedOptions.rank !== void 0 && resolvedOptions.order !== resolvedOptions.rank) {
+    throw new PmCliError("--order and --rank must match when both are provided", EXIT_CODE.USAGE);
+  }
+  const orderRaw = resolvedOptions.order ?? resolvedOptions.rank;
+  const order = resolveUnsettableTransformed(unsetKeys, "order", orderRaw, (raw) => parseOptionalNumber(raw, "order"));
+  if (order !== void 0 && !Number.isInteger(order)) {
+    throw new PmCliError("Order must be an integer", EXIT_CODE.USAGE);
+  }
+  return order;
+}
+function resolveCreateCloseReason(status, statusRegistry, settings, resolvedOptions, resolution) {
+  if (status !== statusRegistry.close_status || !settings.governance.require_close_reason) {
+    return { closeReason: void 0, warnings: [] };
+  }
+  const messageText = typeof resolvedOptions.message === "string" ? resolvedOptions.message.trim() : "";
+  const resolutionText = typeof resolution === "string" ? resolution.trim() : "";
+  const closeReason = messageText || resolutionText || CREATE_DIRECT_CLOSE_REASON_DEFAULT;
+  const warnings = messageText.length === 0 && resolutionText.length === 0 ? ["close_reason_defaulted"] : [];
+  return { closeReason, warnings };
+}
+async function writeCreatedItem(params) {
+  const { pmRoot, type, id, settings, typeRegistry, author, extensionFieldNames, afterDocument, beforeDocument, historyMessage, changedFields, nowValue } = params;
+  const itemPath = getItemPath(pmRoot, type, id, settings.item_format, typeRegistry.type_to_folder);
+  const historyPath = getHistoryPath(pmRoot, id);
+  const lockRelease = await acquireLock(pmRoot, id, settings.locks.ttl_seconds, author, false, settings.governance.force_required_for_stale_lock);
+  let hookWarnings = [];
+  try {
+    await writeFileAtomic(itemPath, serializeItemDocument(afterDocument, { format: settings.item_format, schema: settings.schema, extensionFieldNames }));
+    try {
+      const entry = createHistoryEntry({ nowIso: nowValue, author, op: "create", before: beforeDocument, after: afterDocument, message: historyMessage });
+      await appendHistoryEntry(historyPath, entry);
+    } catch (error) {
+      await removeFileIfExists(itemPath);
+      throw error;
+    }
+    hookWarnings = [
+      ...await runActiveOnWriteHooks({
+        path: itemPath,
+        scope: "project",
+        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",
+        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();
+  }
+  return hookWarnings;
+}
+async function runCreate(options, global) {
+  let resolvedOptions = normalizeLegacyNoneCreateOptions(await resolveCreateStdinInputs(options));
+  const pmRoot = resolvePmRoot(process.cwd(), global.path);
+  await ensureInitHasRun(pmRoot);
+  const settings = await readSettings(pmRoot);
+  const statusRegistry = resolveRuntimeStatusRegistry(settings.schema);
+  const runtimeFieldRegistry = resolveRuntimeFieldRegistry(settings.schema);
+  const typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
+  const typeSelection = await resolveCreateTypeSelection(resolvedOptions, global, pmRoot, settings, typeRegistry);
+  resolvedOptions = typeSelection.resolvedOptions;
+  const { typeDefinition, type, createMode } = typeSelection;
+  const unsetTargets = parseCreateUnsetTargets(resolvedOptions.unset, runtimeFieldRegistry);
+  const { explicitUnsets, clearOptionKeys } = collectCreateClearTargets(resolvedOptions, unsetTargets);
+  assertNoCreateScalarUnsetConflicts(resolvedOptions, unsetTargets);
+  assertNoLegacyCreateScalarTokens(resolvedOptions);
   const missingRequiredCreateFlags = requireCreateOptionByType(typeDefinition, resolvedOptions, createMode, clearOptionKeys);
   const nowValue = nowIso();
   const author = selectAuthor(resolvedOptions.author, settings.author_default);
@@ -1598,19 +1777,8 @@ async function runCreate(options, global) {
   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 ?? {})) {
-    if (!unsetTargets.frontMatterKeys.has(fieldKey)) {
-      continue;
-    }
-    throw new PmCliError(`Cannot combine --unset ${fieldKey.replaceAll("_", "-")} with its value flag`, EXIT_CODE.USAGE);
-  }
+  assertNoCreateFieldUnsetConflicts(registeredItemFieldValues, runtimeCreateFieldValues, unsetTargets);
   const missingRequiredTypeOptionKeys = collectMissingRequiredTypeOptionKeys(validatedTypeOptions.errors, type);
   const missingRequiredTypeOptionFlags = missingRequiredTypeOptionKeys.map((key) => `--type-option ${key}=<value>`);
   const combinedMissingFlags = [
@@ -1621,31 +1789,15 @@ async function runCreate(options, global) {
       ...runtimeCreateFieldValues.missing_required_flags
     ])
   ].sort((left, right) => left.localeCompare(right));
-  if (combinedMissingFlags.length > 0) {
-    const nextValidExample = buildTypeSpecificCreateExample(typeDefinition, missingRequiredCreateFlags, missingRequiredTypeOptionKeys, statusRegistry.open_status);
-    const nextSteps = [`Run "pm create --help --type ${type}" for type-aware required option guidance.`];
-    if (combinedMissingFlags.includes("--title")) {
-      nextSteps.push('Title can also be passed as the first positional argument (example: pm create "Your title" --type ' + type + ").");
-    }
-    if (createMode === "strict") {
-      nextSteps.push('For staged onboarding, retry with "--create-mode progressive".');
-      if (SCHEDULE_CREATE_PRESET_TYPES.has(type)) {
-        nextSteps.push('For minimal scheduling inputs, try "--schedule-preset lightweight".');
-      }
-    }
-    const errorMessage = combinedMissingFlags.length === 1 ? `Missing required option ${combinedMissingFlags[0]} for type "${type}"` : `Missing required options ${combinedMissingFlags.join(", ")} for type "${type}"`;
-    throw new PmCliError(errorMessage, EXIT_CODE.USAGE, {
-      code: "missing_required_option",
-      required: `Provide all required create options and type options for type "${type}" in one invocation.`,
-      examples: [nextValidExample],
-      nextSteps,
-      recovery: createMode === "strict" ? {
-        recovery_mode: "compact",
-        missing_required_fields: combinedMissingFlags,
-        suggested_flags: ["--create-mode progressive", ...combinedMissingFlags]
-      } : void 0
-    });
-  }
+  assertNoMissingRequiredCreateOptions({
+    combinedMissingFlags,
+    typeDefinition,
+    missingRequiredCreateFlags,
+    missingRequiredTypeOptionKeys,
+    openStatus: statusRegistry.open_status,
+    type,
+    createMode
+  });
   const nonMissingTypeOptionErrors = filterNonMissingTypeOptionErrors(validatedTypeOptions.errors, type);
   if (nonMissingTypeOptionErrors.length > 0) {
     const nextValidExample = buildTypeSpecificCreateExample(typeDefinition, [], [], statusRegistry.open_status);
@@ -1659,132 +1811,77 @@ async function runCreate(options, global) {
   const id = await generateItemId(pmRoot, settings.id_prefix);
   let status = resolvedOptions.status !== void 0 ? parseStatusValue(resolvedOptions.status, statusRegistry) : resolveCreateDefaultStatus(typeDefinition, statusRegistry);
   const priority = resolvedOptions.priority !== void 0 ? ensurePriority(resolvedOptions.priority) : 2;
-  if (unsetTargets.frontMatterKeys.has("tags") && Array.isArray(resolvedOptions.addTags) && resolvedOptions.addTags.length > 0) {
-    throw new PmCliError("Cannot combine --unset tags with --add-tags", EXIT_CODE.USAGE);
-  }
-  const baseTags = unsetTargets.frontMatterKeys.has("tags") ? [] : resolvedOptions.tags !== void 0 ? parseTags(resolvedOptions.tags) : [];
-  const tags = mergeAdditiveTags(baseTags, resolvedOptions.addTags);
-  const deadline = unsetTargets.frontMatterKeys.has("deadline") ? void 0 : resolvedOptions.deadline === void 0 ? void 0 : resolveIsoOrRelative(resolvedOptions.deadline, new Date(nowValue), "deadline");
-  const estimatedMinutes = unsetTargets.frontMatterKeys.has("estimated_minutes") ? void 0 : resolvedOptions.estimatedMinutes === void 0 ? void 0 : parseOptionalNumber(resolvedOptions.estimatedMinutes, "estimated-minutes");
-  const acceptanceCriteria = unsetTargets.frontMatterKeys.has("acceptance_criteria") ? void 0 : resolvedOptions.acceptanceCriteria === void 0 ? void 0 : resolvedOptions.acceptanceCriteria;
-  const definitionOfReady = unsetTargets.frontMatterKeys.has("definition_of_ready") || resolvedOptions.definitionOfReady === void 0 ? void 0 : parseOptionalString(resolvedOptions.definitionOfReady);
-  if (resolvedOptions.order !== void 0 && resolvedOptions.rank !== void 0 && resolvedOptions.order !== resolvedOptions.rank) {
-    throw new PmCliError("--order and --rank must match when both are provided", EXIT_CODE.USAGE);
-  }
-  const orderRaw = resolvedOptions.order ?? resolvedOptions.rank;
-  const order = unsetTargets.frontMatterKeys.has("order") || orderRaw === void 0 ? void 0 : parseOptionalNumber(orderRaw, "order");
-  if (order !== void 0 && !Number.isInteger(order)) {
-    throw new PmCliError("Order must be an integer", EXIT_CODE.USAGE);
-  }
-  const goal = unsetTargets.frontMatterKeys.has("goal") || resolvedOptions.goal === void 0 ? void 0 : parseOptionalString(resolvedOptions.goal);
-  const objective = unsetTargets.frontMatterKeys.has("objective") || resolvedOptions.objective === void 0 ? void 0 : parseOptionalString(resolvedOptions.objective);
-  const value = unsetTargets.frontMatterKeys.has("value") || resolvedOptions.value === void 0 ? void 0 : parseOptionalString(resolvedOptions.value);
-  const impact = unsetTargets.frontMatterKeys.has("impact") || resolvedOptions.impact === void 0 ? void 0 : parseOptionalString(resolvedOptions.impact);
-  const outcome = unsetTargets.frontMatterKeys.has("outcome") || resolvedOptions.outcome === void 0 ? void 0 : parseOptionalString(resolvedOptions.outcome);
-  const whyNow = unsetTargets.frontMatterKeys.has("why_now") || resolvedOptions.whyNow === void 0 ? void 0 : parseOptionalString(resolvedOptions.whyNow);
-  const assignee = unsetTargets.frontMatterKeys.has("assignee") || resolvedOptions.assignee === void 0 ? void 0 : parseOptionalString(resolvedOptions.assignee);
-  const authorValue = unsetTargets.frontMatterKeys.has("author") ? void 0 : parseOptionalString(resolvedOptions.author) ?? author;
-  let parent = unsetTargets.frontMatterKeys.has("parent") || resolvedOptions.parent === void 0 ? void 0 : parseOptionalString(resolvedOptions.parent);
-  let parentSource;
-  if (parent === void 0 && !unsetTargets.frontMatterKeys.has("parent") && resolvedOptions.parent === void 0) {
-    const focused = await getFocusedItem(pmRoot);
-    if (focused !== void 0) {
-      parent = focused;
-      parentSource = "focus";
-    }
-  }
-  const reviewer = unsetTargets.frontMatterKeys.has("reviewer") || resolvedOptions.reviewer === void 0 ? void 0 : parseOptionalString(resolvedOptions.reviewer);
-  const riskRaw = unsetTargets.frontMatterKeys.has("risk") || resolvedOptions.risk === void 0 ? void 0 : parseOptionalString(resolvedOptions.risk);
-  const risk = riskRaw !== void 0 ? ensureEnumValue(normalizeRiskInput(riskRaw), RISK_VALUES, "risk") : void 0;
-  const confidenceRaw = unsetTargets.frontMatterKeys.has("confidence") || resolvedOptions.confidence === void 0 ? void 0 : parseOptionalString(resolvedOptions.confidence);
-  const confidence = confidenceRaw !== void 0 ? parseConfidenceInput(confidenceRaw) : void 0;
+  const unsetKeys = unsetTargets.frontMatterKeys;
+  const tags = resolveCreateTags(unsetKeys, resolvedOptions);
+  const deadline = resolveUnsettableTransformed(unsetKeys, "deadline", resolvedOptions.deadline, (raw) => resolveIsoOrRelative(raw, new Date(nowValue), "deadline"));
+  const estimatedMinutes = resolveUnsettableTransformed(unsetKeys, "estimated_minutes", resolvedOptions.estimatedMinutes, (raw) => parseOptionalNumber(raw, "estimated-minutes"));
+  const acceptanceCriteria = resolveUnsettableOptionalString(unsetKeys, "acceptance_criteria", resolvedOptions.acceptanceCriteria);
+  const definitionOfReady = resolveUnsettableOptionalString(unsetKeys, "definition_of_ready", resolvedOptions.definitionOfReady);
+  const order = resolveCreateOrder(unsetKeys, resolvedOptions);
+  const goal = resolveUnsettableOptionalString(unsetKeys, "goal", resolvedOptions.goal);
+  const objective = resolveUnsettableOptionalString(unsetKeys, "objective", resolvedOptions.objective);
+  const value = resolveUnsettableOptionalString(unsetKeys, "value", resolvedOptions.value);
+  const impact = resolveUnsettableOptionalString(unsetKeys, "impact", resolvedOptions.impact);
+  const outcome = resolveUnsettableOptionalString(unsetKeys, "outcome", resolvedOptions.outcome);
+  const whyNow = resolveUnsettableOptionalString(unsetKeys, "why_now", resolvedOptions.whyNow);
+  const assignee = resolveUnsettableOptionalString(unsetKeys, "assignee", resolvedOptions.assignee);
+  const authorValue = unsetKeys.has("author") ? void 0 : parseOptionalString(resolvedOptions.author) ?? author;
+  const initialParent = resolveUnsettableOptionalString(unsetKeys, "parent", resolvedOptions.parent);
+  const inheritedParent = await inheritFocusedParent(initialParent, resolvedOptions, unsetKeys, pmRoot);
+  let parent = inheritedParent.parent;
+  const parentSource = inheritedParent.parentSource;
+  const reviewer = resolveUnsettableOptionalString(unsetKeys, "reviewer", resolvedOptions.reviewer);
+  const risk = resolveUnsettableTransformed(unsetKeys, "risk", resolvedOptions.risk, (raw) => ensureEnumValue(normalizeRiskInput(raw), RISK_VALUES, "risk"));
+  const confidence = resolveUnsettableTransformed(unsetKeys, "confidence", resolvedOptions.confidence, (raw) => parseConfidenceInput(raw));
   const parentReferencePolicy = resolvedOptions.allowMissingParent === true && settings.validation.parent_reference === "strict_error" ? "warn" : settings.validation.parent_reference;
   const sprintReleasePolicy = settings.validation.sprint_release_format;
-  const validationWarnings = [];
-  if (type.toLowerCase() === "event" && (events.values === void 0 || events.values.length === 0)) {
-    validationWarnings.push(`event_without_schedule:${id}:no_time_set`);
-  }
-  const calendarRelevantTypes = /* @__PURE__ */ new Set(["milestone", "meeting", "reminder", "event"]);
-  const hasDeadline = deadline !== void 0;
-  const hasReminders = reminders.values !== void 0 && reminders.values.length > 0;
-  const hasEvents = events.values !== void 0 && events.values.length > 0;
-  if (calendarRelevantTypes.has(type.toLowerCase()) && !hasDeadline && !hasReminders && !hasEvents) {
-    validationWarnings.push(`calendar_item_without_schedule:${id}:no_deadline_or_reminder_or_event (hint: set --deadline <ISO> or --reminder "<when>", or link an Event via --event "start=<ISO>,end=<ISO>"; otherwise this item never appears on pm calendar)`);
-  }
+  const validationWarnings = collectCreateScheduleWarnings(type, id, deadline, reminders.values, events.values);
   if (parent !== void 0) {
-    parent = normalizeParentReferenceValue(parent);
-    const parentLocated = await locateItem(pmRoot, parent, settings.id_prefix, settings.item_format, typeRegistry.type_to_folder);
-    if (!parentLocated) {
-      const normalizedParentId = normalizeItemId(parent, settings.id_prefix);
-      validationWarnings.push(...validateMissingParentReference(normalizedParentId, parentReferencePolicy).warnings);
-    }
-  }
-  let sprint = unsetTargets.frontMatterKeys.has("sprint") || resolvedOptions.sprint === void 0 ? void 0 : parseOptionalString(resolvedOptions.sprint);
-  if (sprint !== void 0) {
-    const sprintValidation = validateSprintOrReleaseValue("sprint", sprint, sprintReleasePolicy);
-    sprint = sprintValidation.value;
-    validationWarnings.push(...sprintValidation.warnings);
-  }
-  let release = unsetTargets.frontMatterKeys.has("release") || resolvedOptions.release === void 0 ? void 0 : parseOptionalString(resolvedOptions.release);
-  if (release !== void 0) {
-    const releaseValidation = validateSprintOrReleaseValue("release", release, sprintReleasePolicy);
-    release = releaseValidation.value;
-    validationWarnings.push(...releaseValidation.warnings);
-  }
-  const blockedBy = unsetTargets.frontMatterKeys.has("blocked_by") || resolvedOptions.blockedBy === void 0 ? void 0 : parseOptionalString(resolvedOptions.blockedBy);
-  let dependencyValues = dependencies.values;
-  if (blockedBy !== void 0) {
-    const normalizedBlockedBy = normalizeItemId(blockedBy, settings.id_prefix);
-    const blockedByLocated = await locateItem(pmRoot, normalizedBlockedBy, settings.id_prefix, settings.item_format, typeRegistry.type_to_folder);
-    if (blockedByLocated) {
-      const hasBlockedByDependency = (dependencyValues ?? []).some((dependency) => dependency.id === blockedByLocated.id && dependency.kind === "blocked_by");
-      if (!hasBlockedByDependency) {
-        dependencyValues = [
-          ...dependencyValues ?? [],
-          {
-            id: blockedByLocated.id,
-            kind: "blocked_by",
-            created_at: nowValue,
-            author
-          }
-        ];
-      }
-      if (resolvedOptions.status === void 0) {
-        status = statusRegistry.blocked_statuses.has("blocked") ? "blocked" : [...statusRegistry.blocked_statuses].sort((left, right) => left.localeCompare(right))[0] ?? statusRegistry.open_status;
-      }
-    }
-  }
-  const blockedReason = unsetTargets.frontMatterKeys.has("blocked_reason") || resolvedOptions.blockedReason === void 0 ? void 0 : parseOptionalString(resolvedOptions.blockedReason);
-  const unblockNote = unsetTargets.frontMatterKeys.has("unblock_note") || resolvedOptions.unblockNote === void 0 ? void 0 : parseOptionalString(resolvedOptions.unblockNote);
-  const reporter = (
-    /* c8 ignore next -- reporter normalization branch is covered in issue-template integration tests. */
-    unsetTargets.frontMatterKeys.has("reporter") || resolvedOptions.reporter === void 0 ? void 0 : parseOptionalString(resolvedOptions.reporter)
-  );
-  const severityRaw = unsetTargets.frontMatterKeys.has("severity") || resolvedOptions.severity === void 0 ? void 0 : parseOptionalString(resolvedOptions.severity);
-  const severity = severityRaw !== void 0 ? ensureEnumValue(normalizeSeverityInput(severityRaw), ISSUE_SEVERITY_VALUES, "severity") : void 0;
-  const environment = unsetTargets.frontMatterKeys.has("environment") || resolvedOptions.environment === void 0 ? void 0 : parseOptionalString(resolvedOptions.environment);
-  const reproSteps = unsetTargets.frontMatterKeys.has("repro_steps") || resolvedOptions.reproSteps === void 0 ? void 0 : parseOptionalString(resolvedOptions.reproSteps);
-  const resolution = unsetTargets.frontMatterKeys.has("resolution") || resolvedOptions.resolution === void 0 ? void 0 : parseOptionalString(resolvedOptions.resolution);
-  const expectedResult = unsetTargets.frontMatterKeys.has("expected_result") || resolvedOptions.expectedResult === void 0 ? void 0 : parseOptionalString(resolvedOptions.expectedResult);
-  const actualResult = unsetTargets.frontMatterKeys.has("actual_result") || resolvedOptions.actualResult === void 0 ? void 0 : parseOptionalString(resolvedOptions.actualResult);
-  const affectedVersion = unsetTargets.frontMatterKeys.has("affected_version") || resolvedOptions.affectedVersion === void 0 ? void 0 : parseOptionalString(resolvedOptions.affectedVersion);
-  const fixedVersion = unsetTargets.frontMatterKeys.has("fixed_version") || resolvedOptions.fixedVersion === void 0 ? void 0 : parseOptionalString(resolvedOptions.fixedVersion);
-  const component = unsetTargets.frontMatterKeys.has("component") || resolvedOptions.component === void 0 ? void 0 : parseOptionalString(resolvedOptions.component);
-  const regressionRaw = unsetTargets.frontMatterKeys.has("regression") || resolvedOptions.regression === void 0 ? void 0 : parseOptionalString(resolvedOptions.regression);
-  const regression = regressionRaw !== void 0 ? parseRegressionInput(regressionRaw) : void 0;
-  const customerImpact = unsetTargets.frontMatterKeys.has("customer_impact") || resolvedOptions.customerImpact === void 0 ? void 0 : parseOptionalString(resolvedOptions.customerImpact);
+    const parentValidation = await validateCreateParentReference(pmRoot, settings, typeRegistry, parent, parentReferencePolicy);
+    parent = parentValidation.parent;
+    validationWarnings.push(...parentValidation.warnings);
+  }
+  const sprintResolved = resolveCreateSprintOrRelease(unsetKeys, "sprint", resolvedOptions.sprint, "sprint", sprintReleasePolicy);
+  const sprint = sprintResolved.value;
+  validationWarnings.push(...sprintResolved.warnings);
+  const releaseResolved = resolveCreateSprintOrRelease(unsetKeys, "release", resolvedOptions.release, "release", sprintReleasePolicy);
+  const release = releaseResolved.value;
+  validationWarnings.push(...releaseResolved.warnings);
+  const blockedBy = resolveUnsettableOptionalString(unsetKeys, "blocked_by", resolvedOptions.blockedBy);
+  const blockedByResolution = await resolveCreateBlockedByDependency({
+    pmRoot,
+    settings,
+    typeRegistry,
+    statusRegistry,
+    blockedBy,
+    dependencyValues: dependencies.values,
+    status,
+    statusExplicit: resolvedOptions.status !== void 0,
+    nowValue,
+    author
+  });
+  const dependencyValues = blockedByResolution.dependencyValues;
+  status = blockedByResolution.status;
+  const blockedReason = resolveUnsettableOptionalString(unsetKeys, "blocked_reason", resolvedOptions.blockedReason);
+  const unblockNote = resolveUnsettableOptionalString(unsetKeys, "unblock_note", resolvedOptions.unblockNote);
+  const reporter = resolveUnsettableOptionalString(unsetKeys, "reporter", resolvedOptions.reporter);
+  const severity = resolveUnsettableTransformed(unsetKeys, "severity", resolvedOptions.severity, (raw) => ensureEnumValue(normalizeSeverityInput(raw), ISSUE_SEVERITY_VALUES, "severity"));
+  const environment = resolveUnsettableOptionalString(unsetKeys, "environment", resolvedOptions.environment);
+  const reproSteps = resolveUnsettableOptionalString(unsetKeys, "repro_steps", resolvedOptions.reproSteps);
+  const resolution = resolveUnsettableOptionalString(unsetKeys, "resolution", resolvedOptions.resolution);
+  const expectedResult = resolveUnsettableOptionalString(unsetKeys, "expected_result", resolvedOptions.expectedResult);
+  const actualResult = resolveUnsettableOptionalString(unsetKeys, "actual_result", resolvedOptions.actualResult);
+  const affectedVersion = resolveUnsettableOptionalString(unsetKeys, "affected_version", resolvedOptions.affectedVersion);
+  const fixedVersion = resolveUnsettableOptionalString(unsetKeys, "fixed_version", resolvedOptions.fixedVersion);
+  const component = resolveUnsettableOptionalString(unsetKeys, "component", resolvedOptions.component);
+  const regression = resolveUnsettableTransformed(unsetKeys, "regression", resolvedOptions.regression, (raw) => parseRegressionInput(raw));
+  const customerImpact = resolveUnsettableOptionalString(unsetKeys, "customer_impact", resolvedOptions.customerImpact);
   const title = requireStringOption(resolvedOptions.title, "--title");
   const description = resolvedOptions.description ?? "";
   const body = resolvedOptions.body ?? "";
-  let closeReason;
-  if (status === statusRegistry.close_status && settings.governance.require_close_reason) {
-    const messageText = typeof resolvedOptions.message === "string" ? resolvedOptions.message.trim() : "";
-    const resolutionText = typeof resolution === "string" ? resolution.trim() : "";
-    closeReason = messageText || resolutionText || CREATE_DIRECT_CLOSE_REASON_DEFAULT;
-    if (messageText.length === 0 && resolutionText.length === 0) {
-      validationWarnings.push("close_reason_defaulted");
-    }
-  }
+  const closeReasonResolution = resolveCreateCloseReason(status, statusRegistry, settings, resolvedOptions, resolution);
+  const closeReason = closeReasonResolution.closeReason;
+  validationWarnings.push(...closeReasonResolution.warnings);
   const frontMatter = normalizeFrontMatter({
     id,
     title,
@@ -1841,9 +1938,7 @@ async function runCreate(options, global) {
     reminders: reminders.values,
     events: events.values,
     ...registeredItemFieldValues,
-    /* c8 ignore start -- collectRuntimeCreateFieldValues always returns a `values` object, so the `?? {}` fallback is unreachable. */
-    ...runtimeCreateFieldValues.values ?? {}
-    /* c8 ignore stop */
+    ...runtimeCreateFieldValues.values
   });
   try {
     applyRegisteredItemFieldDefaultsAndValidation(frontMatter, extensionRegistrations);
@@ -1858,9 +1953,6 @@ async function runCreate(options, global) {
     metadata: {},
     body: ""
   };
-  const itemPath = getItemPath(pmRoot, type, id, settings.item_format, typeRegistry.type_to_folder);
-  const historyPath = getHistoryPath(pmRoot, id);
-  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, [
@@ -1869,63 +1961,23 @@ async function runCreate(options, global) {
     ...Object.keys(runtimeCreateFieldValues.values ?? {})
     /* c8 ignore stop */
   ]);
-  let hookWarnings = [];
-  try {
-    await writeFileAtomic(itemPath, serializeItemDocument(afterDocument, {
-      format: settings.item_format,
-      schema: settings.schema,
-      extensionFieldNames
-    }));
-    try {
-      const entry = createHistoryEntry({
-        nowIso: nowValue,
-        author,
-        op: "create",
-        before: beforeDocument,
-        after: afterDocument,
-        message: historyMessage
-      });
-      await appendHistoryEntry(historyPath, entry);
-    } catch (error) {
-      await removeFileIfExists(itemPath);
-      throw error;
-    }
-    hookWarnings = [
-      ...await runActiveOnWriteHooks({
-        path: itemPath,
-        scope: "project",
-        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",
-        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 hookWarnings = await writeCreatedItem({
+    pmRoot,
+    type,
+    id,
+    settings,
+    typeRegistry,
+    author,
+    extensionFieldNames,
+    afterDocument,
+    beforeDocument,
+    historyMessage,
+    changedFields,
+    nowValue
+  });
   const outputItem = structuredClone(frontMatter);
   const nextTransition = suggestNextLifecycleTransition(id, type, status, statusRegistry);
-  if (calendarRelevantTypes.has(type.toLowerCase()) && !hasDeadline && !hasReminders && !hasEvents) {
+  if (createItemLacksSchedule(type, deadline, reminders.values, events.values)) {
     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>"'.`);
   }
   return {
@@ -1953,7 +2005,7 @@ var _testOnlyCreateCommand = {
   parseCreateUnsetTargets,
   requireStringOption,
   readTemplateOptionsFromRuntimeResult,
-  resolveRuntimeCreateUnsetDefinition,
+  resolveRuntimeCreateUnsetDefinition: (token, registry) => resolveRuntimeUnsetFieldDefinition(token, "create", registry),
   typeOptionExampleValue
 };
 
@@ -1966,6 +2018,11 @@ export {
   isLegacyNoneToken,
   assertNoLegacyNoneToken,
   assertNoLegacyNoneTokens,
+  applyLegacyNoneCollectionNormalizers,
+  COMMON_UNSET_FIELD_DEFINITIONS_BEFORE_CLOSE_REASON,
+  COMMON_UNSET_FIELD_DEFINITIONS_AFTER_CLOSE_REASON_BEFORE_AUTHOR,
+  COMMON_UNSET_FIELD_DEFINITIONS_AFTER_AUTHOR,
+  resolveRuntimeUnsetFieldDefinition,
   ensureEnumValue,
   parseReminderEntries,
   parseEventEntries,
@@ -1977,6 +2034,6 @@ export {
   runCreate,
   _testOnlyCreateCommand
 };
-//# sourceMappingURL=chunk-IAP5KYBQ.js.map
+//# sourceMappingURL=chunk-4XOIEKSD.js.map
 
-//# debugId=dd613437-a3c2-555c-9100-92271fb1f1db
+//# debugId=282e5a28-5e38-537b-8dd7-1c4731851fe2