@unbrained/pm-cli 2026.6.30 → 2026.7.1

package/dist/cli-bundle/chunks/{chunk-UB3V5WUI.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]="fda2d3e3-d8fb-5267-a33c-580f9d20a672")}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-4YIMPANT.js";
+} from "./chunk-EJUDVUYZ.js";
 import {
   assertNoUnknownCsvKeys,
   createStdinTokenResolver,
@@ -21,21 +21,21 @@ import {
   parseCsvKv,
   parseOptionalNumber,
   parseTags
-} from "./chunk-D6USKAMA.js";
+} from "./chunk-ZRP4VG5U.js";
 import {
   getFocusedItem
-} from "./chunk-OB3RJV5F.js";
+} from "./chunk-N74UMG5H.js";
 import {
   normalizeParentReferenceValue,
   validateMissingParentReference,
   validateSprintOrReleaseValue
-} from "./chunk-7RIJGN4R.js";
+} from "./chunk-HZZEHPRG.js";
 import {
   buildInvalidTypeError
-} from "./chunk-YEDFE4DC.js";
+} from "./chunk-MAUKX7JC.js";
 import {
   printError
-} from "./chunk-QE5UFCCO.js";
+} from "./chunk-NWMZWYYB.js";
 import {
   acquireLock,
   appendHistoryEntry,
@@ -46,18 +46,18 @@ import {
   locateItem,
   normalizeItemId,
   parseRegisteredItemFieldAssignments
-} from "./chunk-KGQ3W65B.js";
+} from "./chunk-JSU5P7VS.js";
 import {
   canonicalDocument,
   collectRuntimeCreateFieldValues,
   normalizeFrontMatter,
   normalizeStatusInput,
   serializeItemDocument
-} from "./chunk-V3KLX7U7.js";
+} from "./chunk-QCWF6IYD.js";
 import {
   nowIso,
   resolveIsoOrRelative
-} from "./chunk-KRASIL6M.js";
+} from "./chunk-AXIDKKAT.js";
 import {
   CONFIDENCE_TEXT_VALUES,
   CREATE_DIRECT_CLOSE_REASON_DEFAULT,
@@ -95,7 +95,7 @@ import {
   validateTypeOptions,
   weekdayOrderIndex,
   writeFileAtomic
-} from "./chunk-CY5IJMUM.js";
+} from "./chunk-7R4QEMZZ.js";
 
 // dist/core/item/priority.js
 var PRIORITY_NAME_TO_VALUE = {
@@ -1380,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) {
@@ -1397,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);
@@ -1434,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) {
@@ -1529,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,
@@ -1574,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");
@@ -1614,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);
@@ -1631,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 = [
@@ -1654,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);
@@ -1692,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,
@@ -1889,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, [
@@ -1900,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 {
@@ -2013,6 +2034,6 @@ export {
   runCreate,
   _testOnlyCreateCommand
 };
-//# sourceMappingURL=chunk-UB3V5WUI.js.map
+//# sourceMappingURL=chunk-4XOIEKSD.js.map
 
-//# debugId=fda2d3e3-d8fb-5267-a33c-580f9d20a672
+//# debugId=282e5a28-5e38-537b-8dd7-1c4731851fe2