@unbrained/pm-cli 2026.5.31 → 2026.6.5

package/dist/cli-bundle/chunks/chunk-ZRVSMOMR.js

@@ -0,0 +1,1809 @@
+
+!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]="67af10d9-cb2f-5b7f-9238-a7eae5edeb4d")}catch(e){}}();
+import {
+  looksLikeStructuredLinkedTestEntry,
+  normalizeStructuredLinkedTestEntry,
+  parseLinkedTestAssertionEqualsMap,
+  parseLinkedTestAssertionGteMap,
+  parseLinkedTestBoolean,
+  parseLinkedTestContextMode,
+  parseLinkedTestEnvClear,
+  parseLinkedTestEnvSet,
+  parseLinkedTestMinLines,
+  parseLinkedTestRegexList,
+  parseLinkedTestStringList
+} from "./chunk-KCMIYKTA.js";
+import {
+  createStdinTokenResolver,
+  mergeAdditiveTags,
+  parseCsvKv,
+  parseOptionalNumber,
+  parseTags
+} from "./chunk-O5IBJE6S.js";
+import {
+  normalizeParentReferenceValue,
+  validateMissingParentReference,
+  validateSprintOrReleaseValue
+} from "./chunk-MISYRLEP.js";
+import {
+  buildInvalidTypeError
+} from "./chunk-26KTVXJW.js";
+import {
+  printError
+} from "./chunk-AXXKLVTW.js";
+import {
+  acquireLock,
+  appendHistoryEntry,
+  applyRegisteredItemFieldDefaultsAndValidation,
+  collectRegisteredItemFieldNames,
+  createHistoryEntry,
+  locateItem,
+  parseRegisteredItemFieldAssignments
+} from "./chunk-CWT53EYT.js";
+import {
+  generateItemId,
+  normalizeItemId
+} from "./chunk-SSFMJCPF.js";
+import {
+  canonicalDocument,
+  collectRuntimeCreateFieldValues,
+  normalizeFrontMatter,
+  normalizeStatusInput,
+  serializeItemDocument
+} from "./chunk-KBG47ZOY.js";
+import {
+  canonicalizeCommandOptionKey,
+  commandOptionFlagLabel,
+  resolveCommandOptionPolicyState,
+  resolveItemTypeRegistry,
+  resolveTypeDefinition,
+  resolveTypeName,
+  validateTypeOptions
+} from "./chunk-SZQCER6S.js";
+import {
+  nowIso,
+  resolveIsoOrRelative
+} from "./chunk-NQP3ECKF.js";
+import {
+  CONFIDENCE_TEXT_VALUES,
+  DEPENDENCY_KIND_VALUES,
+  EXIT_CODE,
+  FRONT_MATTER_KEY_ORDER,
+  ISSUE_SEVERITY_VALUES,
+  PmCliError,
+  RECURRENCE_FREQUENCY_VALUES,
+  RECURRENCE_WEEKDAY_VALUES,
+  RISK_VALUES,
+  SCOPE_VALUES,
+  getActiveExtensionRegistrations,
+  getHistoryPath,
+  getItemPath,
+  getSettingsPath,
+  pathExists,
+  projectAfterCommandItemSnapshot,
+  readSettings,
+  recordAfterCommandAffectedItem,
+  removeFileIfExists,
+  resolvePmRoot,
+  resolveRuntimeFieldRegistry,
+  resolveRuntimeStatusRegistry,
+  runActiveCommandHandler,
+  runActiveOnWriteHooks,
+  weekdayOrderIndex,
+  writeFileAtomic
+} from "./chunk-4LTBNUYT.js";
+
+// dist/core/item/priority.js
+var PRIORITY_NAME_TO_VALUE = {
+  critical: 0,
+  high: 1,
+  medium: 2,
+  low: 3,
+  minimal: 4
+};
+var PRIORITY_NAME_LIST = Object.keys(PRIORITY_NAME_TO_VALUE);
+var PRIORITY_ACCEPTED_FORMS_HINT = `numbers 0..4 (0=critical, 1=high, 2=medium, 3=low, 4=minimal) or names (${PRIORITY_NAME_LIST.join(", ")}), case-insensitive`;
+function priorityUsageError(raw) {
+  return new PmCliError(`Invalid priority "${raw}". Accepted values: ${PRIORITY_ACCEPTED_FORMS_HINT}.`, EXIT_CODE.USAGE);
+}
+function resolvePriority(raw) {
+  if (typeof raw === "number") {
+    if (Number.isInteger(raw) && raw >= 0 && raw <= 4) {
+      return raw;
+    }
+    throw priorityUsageError(String(raw));
+  }
+  if (typeof raw !== "string") {
+    throw priorityUsageError(String(raw));
+  }
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) {
+    throw priorityUsageError(raw);
+  }
+  const normalizedName = trimmed.toLowerCase();
+  if (Object.prototype.hasOwnProperty.call(PRIORITY_NAME_TO_VALUE, normalizedName)) {
+    return PRIORITY_NAME_TO_VALUE[normalizedName];
+  }
+  if (/^[0-4]$/.test(trimmed)) {
+    return Number(trimmed);
+  }
+  throw priorityUsageError(raw);
+}
+
+// dist/core/item/type-synonyms.js
+var TYPE_SYNONYMS = {
+  bug: "Issue",
+  bugfix: "Issue",
+  defect: "Issue",
+  incident: "Issue",
+  enhancement: "Feature",
+  story: "Feature",
+  userstory: "Feature",
+  "user-story": "Feature",
+  "user story": "Feature",
+  change: "Chore",
+  ticket: "Task",
+  todo: "Task"
+};
+function resolveTypeSynonym(rawType) {
+  if (rawType === void 0) {
+    return void 0;
+  }
+  return TYPE_SYNONYMS[rawType.trim().toLowerCase()];
+}
+
+// dist/cli/commands/metadata-normalizers.js
+function normalizeRiskInput(value) {
+  const trimmed = value.trim();
+  return trimmed.toLowerCase() === "med" ? "medium" : trimmed;
+}
+function normalizeSeverityInput(value) {
+  const trimmed = value.trim();
+  return trimmed.toLowerCase() === "med" ? "medium" : trimmed;
+}
+function parseConfidenceInput(value) {
+  const trimmed = value.trim().toLowerCase();
+  if (trimmed === "med") {
+    return "medium";
+  }
+  if (CONFIDENCE_TEXT_VALUES.includes(trimmed)) {
+    return trimmed;
+  }
+  const parsed = parseOptionalNumber(value, "confidence");
+  if (!Number.isInteger(parsed) || parsed < 0 || parsed > 100) {
+    throw new PmCliError("Confidence must be an integer 0..100 or one of low|med|medium|high", EXIT_CODE.USAGE);
+  }
+  return parsed;
+}
+function parseRegressionInput(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "true" || normalized === "1") {
+    return true;
+  }
+  if (normalized === "false" || normalized === "0") {
+    return false;
+  }
+  throw new PmCliError("Regression must be one of true|false|1|0", EXIT_CODE.USAGE);
+}
+
+// dist/cli/commands/legacy-none-tokens.js
+var LEGACY_NONE_TOKENS = /* @__PURE__ */ new Set(["none", "null"]);
+function isLegacyNoneToken(value) {
+  if (value === void 0) {
+    return false;
+  }
+  return LEGACY_NONE_TOKENS.has(value.trim().toLowerCase());
+}
+function assertNoLegacyNoneToken(value, flag, replacementHint) {
+  if (!isLegacyNoneToken(value)) {
+    return;
+  }
+  const suffix = replacementHint ? ` ${replacementHint}` : "";
+  throw new PmCliError(`${flag} no longer accepts "none" or "null".${suffix}`.trim(), EXIT_CODE.USAGE);
+}
+function assertNoLegacyNoneTokens(values, flag, replacementHint) {
+  if (!values || values.length === 0) {
+    return;
+  }
+  const hasLegacyToken = values.some((value) => isLegacyNoneToken(value));
+  if (!hasLegacyToken) {
+    return;
+  }
+  const suffix = replacementHint ? ` ${replacementHint}` : "";
+  throw new PmCliError(`${flag} no longer accepts "none" or "null".${suffix}`.trim(), EXIT_CODE.USAGE);
+}
+
+// dist/cli/commands/recurrence-parsers.js
+function parseEventBoolean(value, flag) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "true" || normalized === "1" || normalized === "yes") {
+    return true;
+  }
+  if (normalized === "false" || normalized === "0" || normalized === "no") {
+    return false;
+  }
+  throw new PmCliError(`${flag} must be one of true|false|1|0|yes|no`, EXIT_CODE.USAGE);
+}
+function parseDelimitedList(raw) {
+  if (!raw) {
+    return [];
+  }
+  return raw.split("|").map((value) => value.trim()).filter((value) => value.length > 0);
+}
+function ensureEnumValue(value, allowed, label) {
+  if (!allowed.includes(value)) {
+    throw new PmCliError(`Invalid ${label} value "${value}". Allowed: ${allowed.join(", ")}`, EXIT_CODE.USAGE);
+  }
+  return value;
+}
+function parseRecurrenceRule(kv, startAt, nowValue, emptyNumericGuard) {
+  const freqRaw = kv.recur_freq?.trim();
+  const intervalRaw = kv.recur_interval?.trim();
+  const countRaw = kv.recur_count?.trim();
+  const untilRaw = kv.recur_until?.trim();
+  const byWeekdayRaw = kv.recur_by_weekday?.trim();
+  const byMonthDayRaw = kv.recur_by_month_day?.trim();
+  const exdatesRaw = kv.recur_exdates?.trim();
+  const recurrenceInputsProvided = [freqRaw, intervalRaw, countRaw, untilRaw, byWeekdayRaw, byMonthDayRaw, exdatesRaw].some((value) => value !== void 0);
+  if (!recurrenceInputsProvided) {
+    return void 0;
+  }
+  if (!freqRaw) {
+    throw new PmCliError("--event recurrence fields require recur_freq=<daily|weekly|monthly|yearly>", EXIT_CODE.USAGE);
+  }
+  const numericProvided = (raw) => emptyNumericGuard === "defined" ? raw !== void 0 : Boolean(raw);
+  const freq = ensureEnumValue(freqRaw.toLowerCase(), RECURRENCE_FREQUENCY_VALUES, "event recurrence frequency");
+  const interval = numericProvided(intervalRaw) ? parseOptionalNumber(intervalRaw, "event recur_interval") : void 0;
+  if (interval !== void 0 && (!Number.isInteger(interval) || interval < 1)) {
+    throw new PmCliError("--event recur_interval must be an integer >= 1", EXIT_CODE.USAGE);
+  }
+  const count = numericProvided(countRaw) ? parseOptionalNumber(countRaw, "event recur_count") : void 0;
+  if (count !== void 0 && (!Number.isInteger(count) || count < 1)) {
+    throw new PmCliError("--event recur_count must be an integer >= 1", EXIT_CODE.USAGE);
+  }
+  const until = untilRaw ? resolveIsoOrRelative(untilRaw, nowValue, "event.recur_until") : void 0;
+  if (until && until < startAt) {
+    throw new PmCliError("--event recur_until must be at or after start", EXIT_CODE.USAGE);
+  }
+  const byWeekday = Array.from(new Set(parseDelimitedList(byWeekdayRaw).map((value) => ensureEnumValue(value.toLowerCase(), RECURRENCE_WEEKDAY_VALUES, "event weekday")))).sort((left, right) => weekdayOrderIndex(left) - weekdayOrderIndex(right));
+  const byMonthDay = Array.from(new Set(parseDelimitedList(byMonthDayRaw).map((value) => {
+    const day = parseOptionalNumber(value, "event recur_by_month_day");
+    if (!Number.isInteger(day) || day < 1 || day > 31) {
+      throw new PmCliError("--event recur_by_month_day values must be integers 1..31", EXIT_CODE.USAGE);
+    }
+    return day;
+  }))).sort((left, right) => left - right);
+  const exdates = Array.from(new Set(parseDelimitedList(exdatesRaw).map((value) => resolveIsoOrRelative(value, nowValue, "event.recur_exdates")))).sort((left, right) => left.localeCompare(right));
+  return {
+    freq,
+    interval,
+    count,
+    until,
+    by_weekday: byWeekday.length > 0 ? byWeekday : void 0,
+    by_month_day: byMonthDay.length > 0 ? byMonthDay : void 0,
+    exdates: exdates.length > 0 ? exdates : void 0
+  };
+}
+
+// dist/cli/commands/event-validation-messages.js
+var EVENT_END_AFTER_START_MESSAGE = "--event end must be strictly after start. Equal start/end timestamps are treated as an instant event (end is dropped); an end earlier than start is rejected. Omit end for an instant event or set end later than start.";
+var EVENT_END_DURATION_MUTUALLY_EXCLUSIVE_MESSAGE = "--event end and duration are mutually exclusive; provide only one (use duration=<relative> like duration=2h, or set an explicit end).";
+function resolveEventEndAt(startAt, endRaw, durationRaw, referenceDate) {
+  if (endRaw && durationRaw) {
+    throw new PmCliError(EVENT_END_DURATION_MUTUALLY_EXCLUSIVE_MESSAGE, EXIT_CODE.USAGE);
+  }
+  if (durationRaw) {
+    const normalizedDuration = durationRaw.startsWith("+") ? durationRaw : `+${durationRaw}`;
+    const endAt2 = resolveIsoOrRelative(normalizedDuration, new Date(startAt), "event.duration");
+    if (endAt2 < startAt) {
+      throw new PmCliError(EVENT_END_AFTER_START_MESSAGE, EXIT_CODE.USAGE);
+    }
+    if (endAt2 === startAt) {
+      return void 0;
+    }
+    return endAt2;
+  }
+  if (!endRaw) {
+    return void 0;
+  }
+  const endAt = resolveIsoOrRelative(endRaw, referenceDate, "event.end");
+  if (endAt < startAt) {
+    throw new PmCliError(EVENT_END_AFTER_START_MESSAGE, EXIT_CODE.USAGE);
+  }
+  if (endAt === startAt) {
+    return void 0;
+  }
+  return endAt;
+}
+
+// dist/cli/commands/repeatable-metadata-parsers.js
+function optionalString(value, mode) {
+  return mode === "trimmed" ? value?.trim() : value;
+}
+function isProvided(value, guard) {
+  return guard === "defined" ? value !== void 0 : Boolean(value);
+}
+function parseReminderEntries(raw, nowValue, options) {
+  return raw.map((entry) => {
+    const kv = parseCsvKv(entry, "--reminder");
+    const atRaw = optionalString(kv.at ?? kv.date, options.valueMode);
+    const textRaw = optionalString(kv.text ?? kv.title, options.valueMode);
+    if (!atRaw || !textRaw) {
+      throw new PmCliError("--reminder requires at=<iso|relative> or date=<iso|relative>, plus text=<value> or title=<value>", EXIT_CODE.USAGE);
+    }
+    const text = textRaw.trim();
+    if (!text) {
+      throw new PmCliError("--reminder text must not be empty", EXIT_CODE.USAGE);
+    }
+    return {
+      at: resolveIsoOrRelative(atRaw, nowValue, "reminder.at"),
+      text
+    };
+  });
+}
+function parseEventEntries(raw, nowValue, options) {
+  return raw.map((entry) => {
+    const kv = parseCsvKv(entry, "--event");
+    const startRaw = (kv.start ?? kv.date)?.trim();
+    if (!startRaw) {
+      throw new PmCliError("--event requires start=<iso|relative> or date=<iso|relative>", EXIT_CODE.USAGE);
+    }
+    const startAt = resolveIsoOrRelative(startRaw, nowValue, "event.start");
+    const endRaw = kv.end?.trim();
+    const durationRaw = kv.duration?.trim();
+    const endAt = resolveEventEndAt(startAt, endRaw, durationRaw, nowValue);
+    const titleRaw = kv.title;
+    const descriptionRaw = kv.description;
+    const locationRaw = kv.location;
+    const timezoneRaw = kv.timezone;
+    const title = titleRaw?.trim();
+    const description = descriptionRaw?.trim();
+    const location = locationRaw?.trim();
+    const timezone = timezoneRaw?.trim();
+    if (titleRaw !== void 0 && !title) {
+      throw new PmCliError("--event title must not be empty", EXIT_CODE.USAGE);
+    }
+    if (descriptionRaw !== void 0 && !description) {
+      throw new PmCliError("--event description must not be empty", EXIT_CODE.USAGE);
+    }
+    if (locationRaw !== void 0 && !location) {
+      throw new PmCliError("--event location must not be empty", EXIT_CODE.USAGE);
+    }
+    if (timezoneRaw !== void 0 && !timezone) {
+      throw new PmCliError("--event timezone must not be empty", EXIT_CODE.USAGE);
+    }
+    const allDayRaw = kv.all_day?.trim();
+    const recurrence = parseRecurrenceRule(kv, startAt, nowValue, options.recurrenceEmptyNumericGuard);
+    const allDay = isProvided(allDayRaw, options.allDayEmptyGuard) ? parseEventBoolean(allDayRaw, "--event all_day") : void 0;
+    return {
+      start_at: startAt,
+      end_at: endAt,
+      title,
+      description,
+      location,
+      all_day: allDay,
+      timezone,
+      recurrence
+    };
+  });
+}
+function parseTypeOptionEntries(raw) {
+  const values = {};
+  for (const entry of raw) {
+    const trimmedEntry = entry.trim();
+    if (trimmedEntry.length === 0) {
+      throw new PmCliError("--type-option values must not be empty", EXIT_CODE.USAGE);
+    }
+    let key;
+    let value;
+    const prefersStructuredKv = trimmedEntry.includes(",") || trimmedEntry.includes("\n") || trimmedEntry.startsWith("```") || /^(?:[-*+]\s+)?(?:key|value)\s*[:=]/i.test(trimmedEntry);
+    if (prefersStructuredKv) {
+      const kv = parseCsvKv(trimmedEntry, "--type-option");
+      key = kv.key?.trim();
+      value = kv.value?.trim();
+    } else {
+      const equalsIndex = trimmedEntry.indexOf("=");
+      const colonIndex = trimmedEntry.indexOf(":");
+      let separatorIndex = equalsIndex;
+      if (equalsIndex <= 0 && colonIndex > 0) {
+        separatorIndex = colonIndex;
+      }
+      if (separatorIndex <= 0 || separatorIndex === trimmedEntry.length - 1) {
+        throw new PmCliError("--type-option requires key=value or key=<name>,value=<value> entries", EXIT_CODE.USAGE);
+      }
+      key = trimmedEntry.slice(0, separatorIndex).trim();
+      value = trimmedEntry.slice(separatorIndex + 1).trim();
+    }
+    if (!key || !value) {
+      throw new PmCliError("--type-option requires key and value", EXIT_CODE.USAGE);
+    }
+    values[key] = value;
+  }
+  return Object.fromEntries(Object.entries(values).sort((left, right) => left[0].localeCompare(right[0])));
+}
+
+// dist/cli/commands/create.js
+var CREATE_MODE_VALUES = ["strict", "progressive"];
+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" },
+  { 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"
+  }
+];
+var CREATE_UNSET_ALIAS_MAP = (() => {
+  const map = /* @__PURE__ */ new Map();
+  for (const definition of CREATE_UNSET_FIELD_DEFINITIONS) {
+    for (const alias of definition.aliases) {
+      map.set(alias, {
+        optionKey: definition.optionKey,
+        frontMatterKey: definition.frontMatterKey
+      });
+    }
+  }
+  return map;
+})();
+var CREATE_OPTION_KEY_TO_UNSET_CANONICAL = new Map(CREATE_UNSET_FIELD_DEFINITIONS.map((definition) => [definition.optionKey, definition.canonical]));
+var CREATE_UNSET_SUPPORTED_CANONICAL_FIELDS = CREATE_UNSET_FIELD_DEFINITIONS.map((definition) => definition.canonical).sort((left, right) => left.localeCompare(right)).join(", ");
+function parseStatusValue(value, statusRegistry) {
+  const normalized = normalizeStatusInput(value, statusRegistry);
+  if (!normalized) {
+    const allowedStatuses = statusRegistry.definitions.map((definition) => definition.id);
+    throw new PmCliError(`Invalid status value "${value}". Allowed: ${allowedStatuses.join(", ")}`, EXIT_CODE.USAGE);
+  }
+  return normalized;
+}
+function resolveCreateDefaultStatus(typeDefinition, statusRegistry) {
+  const configured = typeDefinition.default_status;
+  if (configured !== void 0) {
+    const normalized = normalizeStatusInput(configured, statusRegistry);
+    if (normalized) {
+      return normalized;
+    }
+  }
+  return statusRegistry.open_status;
+}
+function parseCreatedAt(value, currentIso) {
+  if (!value || value.trim() === "" || value.trim().toLowerCase() === "now") {
+    return currentIso;
+  }
+  const parsed = Date.parse(value);
+  if (!Number.isFinite(parsed)) {
+    throw new PmCliError(`Invalid created_at timestamp "${value}"`, EXIT_CODE.USAGE);
+  }
+  return new Date(parsed).toISOString();
+}
+var CREATE_LEGACY_NONE_COLLECTION_NORMALIZERS = [
+  { optionKey: "dep", clearFlagKey: "clearDeps", valueFlag: "--dep", clearFlag: "--clear-deps" },
+  { optionKey: "comment", clearFlagKey: "clearComments", valueFlag: "--comment", clearFlag: "--clear-comments" },
+  { optionKey: "note", clearFlagKey: "clearNotes", valueFlag: "--note", clearFlag: "--clear-notes" },
+  { optionKey: "learning", clearFlagKey: "clearLearnings", valueFlag: "--learning", clearFlag: "--clear-learnings" },
+  { optionKey: "file", clearFlagKey: "clearFiles", valueFlag: "--file", clearFlag: "--clear-files" },
+  { optionKey: "test", clearFlagKey: "clearTests", valueFlag: "--test", clearFlag: "--clear-tests" },
+  { optionKey: "doc", clearFlagKey: "clearDocs", valueFlag: "--doc", clearFlag: "--clear-docs" },
+  { optionKey: "reminder", clearFlagKey: "clearReminders", valueFlag: "--reminder", clearFlag: "--clear-reminders" },
+  { optionKey: "event", clearFlagKey: "clearEvents", valueFlag: "--event", clearFlag: "--clear-events" },
+  { optionKey: "typeOption", clearFlagKey: "clearTypeOptions", valueFlag: "--type-option", clearFlag: "--clear-type-options" }
+];
+function normalizeLegacyNoneCreateOptions(options) {
+  const normalized = {
+    ...options,
+    unset: options.unset ? [...options.unset] : void 0
+  };
+  const appendUnsetTarget = (value) => {
+    const current = normalized.unset ? [...normalized.unset] : [];
+    if (!current.includes(value)) {
+      current.push(value);
+    }
+    normalized.unset = current;
+  };
+  if (isLegacyNoneToken(normalized.template)) {
+    normalized.template = void 0;
+  }
+  const scalarOptionKeys = /* @__PURE__ */ new Set([...CREATE_OPTION_KEY_TO_UNSET_CANONICAL.keys(), "rank"]);
+  for (const optionKey of scalarOptionKeys) {
+    const candidate = normalized[optionKey];
+    if (typeof candidate !== "string" || !isLegacyNoneToken(candidate)) {
+      continue;
+    }
+    const canonicalUnset = optionKey === "rank" ? "order" : CREATE_OPTION_KEY_TO_UNSET_CANONICAL.get(optionKey) ?? optionKey;
+    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;
+}
+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();
+  if (!raw || raw.length === 0) {
+    return { frontMatterKeys, optionKeys };
+  }
+  for (const entry of raw) {
+    const trimmed = entry.trim().toLowerCase();
+    if (!trimmed) {
+      throw new PmCliError("--unset values must not be empty", EXIT_CODE.USAGE);
+    }
+    if (isLegacyNoneToken(trimmed)) {
+      throw new PmCliError('--unset no longer accepts "none" or "null". Specify concrete field names such as --unset deadline', EXIT_CODE.USAGE);
+    }
+    const definition = CREATE_UNSET_ALIAS_MAP.get(trimmed) ?? resolveRuntimeCreateUnsetDefinition(trimmed, runtimeFieldRegistry);
+    if (!definition) {
+      throw new PmCliError(`Unsupported --unset field "${entry}". Supported fields: ${CREATE_UNSET_SUPPORTED_CANONICAL_FIELDS}`, EXIT_CODE.USAGE);
+    }
+    frontMatterKeys.add(definition.frontMatterKey);
+    optionKeys.add(definition.optionKey);
+  }
+  return { frontMatterKeys, optionKeys };
+}
+function parseDependencies(raw, nowValue, prefix) {
+  if (!raw || raw.length === 0)
+    return { values: void 0, explicitEmpty: false };
+  assertNoLegacyNoneTokens(raw, "--dep", "Use --clear-deps to clear dependencies.");
+  const values = raw.map((entry) => {
+    const trimmedEntry = entry.trim();
+    const kv = looksLikeStructuredEntry(trimmedEntry, ["id", "kind", "type", "author", "created_at"]) ? parseCsvKv(entry, "--dep") : { id: trimmedEntry, kind: "related" };
+    const id = parseOptionalString(kv.id);
+    const kind = normalizeDependencyKindInput(parseOptionalString(kv.kind ?? kv.type));
+    if (!id || !kind) {
+      throw new PmCliError("--dep requires id and kind, or a bare item id to create a related dependency", EXIT_CODE.USAGE);
+    }
+    if (id.trim().toLowerCase() === "undefined") {
+      throw new PmCliError(`--dep id must not use placeholder token "${id}". Use --clear-deps to clear dependencies.`, EXIT_CODE.USAGE);
+    }
+    return {
+      id: normalizeItemId(id, prefix),
+      kind: ensureEnumValue(kind, DEPENDENCY_KIND_VALUES, "dependency kind"),
+      created_at: parseCreatedAt(kv.created_at, nowValue),
+      author: parseOptionalString(kv.author)
+    };
+  });
+  return { values, explicitEmpty: false };
+}
+var DEPENDENCY_KIND_INPUT_ALIASES = {
+  "blocked-by": "blocked_by",
+  depends_on: "blocked_by",
+  "depends-on": "blocked_by"
+};
+function normalizeDependencyKindInput(raw) {
+  if (typeof raw !== "string") {
+    return raw;
+  }
+  const alias = DEPENDENCY_KIND_INPUT_ALIASES[raw.toLowerCase()];
+  return alias ?? raw;
+}
+function looksLikeStructuredEntry(raw, keys) {
+  if (raw.startsWith("```") || raw.includes("\n")) {
+    return true;
+  }
+  const keyPattern = keys.map((key) => key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+  return new RegExp(`^(?:[-*+]\\s+)?(?:${keyPattern})\\s*[:=]`, "i").test(raw);
+}
+function parseLogSeed(optionName, raw, nowValue, fallbackAuthor) {
+  if (!raw || raw.length === 0)
+    return { values: void 0, explicitEmpty: false };
+  const clearHint = optionName === "--comment" ? "Use --clear-comments to clear comments." : optionName === "--note" ? "Use --clear-notes to clear notes." : "Use --clear-learnings to clear learnings.";
+  assertNoLegacyNoneTokens(raw, optionName, clearHint);
+  const values = raw.map((entry) => {
+    const trimmedEntry = entry.trim();
+    const buildPlainTextCommentSeed = () => {
+      if (trimmedEntry.length === 0) {
+        throw new PmCliError(`${optionName} requires text=<value>`, EXIT_CODE.USAGE);
+      }
+      return {
+        created_at: nowValue,
+        author: fallbackAuthor,
+        text: trimmedEntry
+      };
+    };
+    let kv;
+    try {
+      kv = parseCsvKv(entry, optionName);
+    } catch (error) {
+      if (optionName === "--comment" || optionName === "--note" || optionName === "--learning") {
+        return buildPlainTextCommentSeed();
+      }
+      throw error;
+    }
+    const unsupportedKeys = Object.keys(kv).filter((key) => !LOG_SEED_ALLOWED_KEYS.has(key));
+    if (unsupportedKeys.length > 0) {
+      return {
+        created_at: parseCreatedAt(kv.created_at, nowValue),
+        author: parseOptionalString(kv.author) ?? fallbackAuthor,
+        text: trimmedEntry
+      };
+    }
+    const text = kv.text ?? "";
+    if (text === "") {
+      throw new PmCliError(`${optionName} requires text=<value>`, EXIT_CODE.USAGE);
+    }
+    return {
+      created_at: parseCreatedAt(kv.created_at, nowValue),
+      author: parseOptionalString(kv.author) ?? fallbackAuthor,
+      text
+    };
+  });
+  return { values, explicitEmpty: false };
+}
+function parseFiles(raw) {
+  if (!raw || raw.length === 0)
+    return { values: void 0, explicitEmpty: false };
+  assertNoLegacyNoneTokens(raw, "--file", "Use --clear-files to clear linked files.");
+  const values = raw.map((entry) => {
+    const trimmedEntry = entry.trim();
+    const kv = looksLikeStructuredEntry(trimmedEntry, ["path", "scope", "note"]) ? parseCsvKv(entry, "--file") : { path: trimmedEntry };
+    if (!kv.path) {
+      throw new PmCliError("--file requires path=<value> or a bare file path", EXIT_CODE.USAGE);
+    }
+    return {
+      path: kv.path,
+      scope: ensureEnumValue(kv.scope ?? "project", SCOPE_VALUES, "file scope"),
+      note: parseOptionalString(kv.note)
+    };
+  });
+  return { values, explicitEmpty: false };
+}
+function parseTests(raw) {
+  if (!raw || raw.length === 0)
+    return { values: void 0, explicitEmpty: false };
+  assertNoLegacyNoneTokens(raw, "--test", "Use --clear-tests to clear linked tests.");
+  const values = raw.map((entry) => {
+    const trimmedEntry = entry.trim();
+    const kv = looksLikeStructuredLinkedTestEntry(trimmedEntry) ? normalizeStructuredLinkedTestEntry(parseCsvKv(entry, "--test"), "--test") : { command: trimmedEntry };
+    const command = parseOptionalString(kv.command);
+    const filePath = parseOptionalString(kv.path);
+    if (!command) {
+      throw new PmCliError("--test requires command=<value> or a bare command (path=<value> is optional metadata)", EXIT_CODE.USAGE);
+    }
+    const timeoutSecondsRaw = parseOptionalString(kv.timeout_seconds);
+    const timeoutAliasRaw = parseOptionalString(kv.timeout);
+    if (timeoutSecondsRaw && timeoutAliasRaw && timeoutSecondsRaw !== timeoutAliasRaw) {
+      throw new PmCliError("--test timeout and timeout_seconds must match when both are provided", EXIT_CODE.USAGE);
+    }
+    const timeoutRaw = timeoutSecondsRaw ?? timeoutAliasRaw;
+    return {
+      command,
+      path: filePath,
+      scope: ensureEnumValue(kv.scope ?? "project", SCOPE_VALUES, "test scope"),
+      timeout_seconds: timeoutRaw ? parseOptionalNumber(timeoutRaw, "timeout_seconds") : void 0,
+      pm_context_mode: parseLinkedTestContextMode(kv.pm_context_mode, "--test"),
+      env_set: parseLinkedTestEnvSet(kv.env_set, "--test"),
+      env_clear: parseLinkedTestEnvClear(kv.env_clear, "--test"),
+      shared_host_safe: parseLinkedTestBoolean(kv.shared_host_safe, "--test", "shared_host_safe"),
+      assert_stdout_contains: parseLinkedTestStringList(kv.assert_stdout_contains),
+      assert_stdout_regex: parseLinkedTestRegexList(kv.assert_stdout_regex, "--test", "assert_stdout_regex"),
+      assert_stderr_contains: parseLinkedTestStringList(kv.assert_stderr_contains),
+      assert_stderr_regex: parseLinkedTestRegexList(kv.assert_stderr_regex, "--test", "assert_stderr_regex"),
+      assert_stdout_min_lines: parseLinkedTestMinLines(kv.assert_stdout_min_lines, "--test"),
+      assert_json_field_equals: parseLinkedTestAssertionEqualsMap(kv.assert_json_field_equals, "--test"),
+      assert_json_field_gte: parseLinkedTestAssertionGteMap(kv.assert_json_field_gte, "--test"),
+      note: parseOptionalString(kv.note)
+    };
+  });
+  return { values, explicitEmpty: false };
+}
+function parseDocs(raw) {
+  if (!raw || raw.length === 0)
+    return { values: void 0, explicitEmpty: false };
+  assertNoLegacyNoneTokens(raw, "--doc", "Use --clear-docs to clear linked docs.");
+  const values = raw.map((entry) => {
+    const trimmedEntry = entry.trim();
+    const kv = looksLikeStructuredEntry(trimmedEntry, ["path", "scope", "note"]) ? parseCsvKv(entry, "--doc") : { path: trimmedEntry };
+    if (!kv.path) {
+      throw new PmCliError("--doc requires path=<value> or a bare doc path", EXIT_CODE.USAGE);
+    }
+    return {
+      path: kv.path,
+      scope: ensureEnumValue(kv.scope ?? "project", SCOPE_VALUES, "doc scope"),
+      note: parseOptionalString(kv.note)
+    };
+  });
+  return { values, explicitEmpty: false };
+}
+function parseReminders(raw, nowValue) {
+  if (!raw || raw.length === 0)
+    return { values: void 0, explicitEmpty: false };
+  assertNoLegacyNoneTokens(raw, "--reminder", "Use --clear-reminders to clear reminders.");
+  return {
+    values: parseReminderEntries(raw, new Date(nowValue), { valueMode: "raw" }),
+    explicitEmpty: false
+  };
+}
+function parseEvents(raw, nowValue) {
+  if (!raw || raw.length === 0)
+    return { values: void 0, explicitEmpty: false };
+  assertNoLegacyNoneTokens(raw, "--event", "Use --clear-events to clear linked events.");
+  return {
+    values: parseEventEntries(raw, new Date(nowValue), {
+      allDayEmptyGuard: "defined",
+      recurrenceEmptyNumericGuard: "defined"
+    }),
+    explicitEmpty: false
+  };
+}
+function buildChangedFields(frontMatter, body, explicitUnsets, additionalFrontMatterKeys = []) {
+  const changed = [
+    ...FRONT_MATTER_KEY_ORDER.filter((key) => frontMatter[key] !== void 0),
+    ...additionalFrontMatterKeys.filter((key) => frontMatter[key] !== void 0),
+    ...body.length > 0 ? ["body"] : [],
+    ...explicitUnsets.map((key) => `unset:${key}`)
+  ];
+  return Array.from(new Set(changed));
+}
+function buildHistoryMessage(baseMessage, explicitUnsets) {
+  const trimmed = baseMessage ?? "";
+  if (explicitUnsets.length === 0) {
+    return trimmed;
+  }
+  const suffix = `explicit_unset=${explicitUnsets.join(",")}`;
+  return trimmed ? `${trimmed} | ${suffix}` : suffix;
+}
+function normalizeCreatePolicyOptionKey(raw, typeName, sourceLabel) {
+  const canonical = canonicalizeCommandOptionKey("create", raw);
+  if (!canonical) {
+    throw new PmCliError(`Unsupported ${sourceLabel} entry "${raw}" for type "${typeName}"`, EXIT_CODE.CONFLICT);
+  }
+  return canonical;
+}
+function parseTypeOptions(raw) {
+  if (!raw || raw.length === 0) {
+    return { values: void 0, explicitEmpty: false };
+  }
+  assertNoLegacyNoneTokens(raw, "--type-option", "Use --clear-type-options to clear existing type options.");
+  return {
+    values: parseTypeOptionEntries(raw),
+    explicitEmpty: false
+  };
+}
+async function resolveCreateStdinInputs(options) {
+  const stdinResolver = createStdinTokenResolver();
+  return {
+    ...options,
+    body: await stdinResolver.resolveValue(options.body, "--body"),
+    dep: await stdinResolver.resolveList(options.dep, "--dep"),
+    comment: await stdinResolver.resolveList(options.comment, "--comment"),
+    note: await stdinResolver.resolveList(options.note, "--note"),
+    learning: await stdinResolver.resolveList(options.learning, "--learning"),
+    file: await stdinResolver.resolveList(options.file, "--file"),
+    test: await stdinResolver.resolveList(options.test, "--test"),
+    doc: await stdinResolver.resolveList(options.doc, "--doc"),
+    reminder: await stdinResolver.resolveList(options.reminder, "--reminder"),
+    event: await stdinResolver.resolveList(options.event, "--event"),
+    typeOption: await stdinResolver.resolveList(options.typeOption, "--type-option"),
+    field: await stdinResolver.resolveList(options.field, "--field")
+  };
+}
+function resolveCreateMode(createMode, defaultMode) {
+  if (createMode === void 0) {
+    return defaultMode;
+  }
+  const normalized = createMode.trim().toLowerCase();
+  if (normalized.length === 0) {
+    return defaultMode;
+  }
+  if (normalized === "strict" || normalized === "progressive") {
+    return normalized;
+  }
+  throw new PmCliError(`Invalid --create-mode value "${createMode}". Allowed: ${CREATE_MODE_VALUES.join(", ")}`, EXIT_CODE.USAGE);
+}
+function resolveScheduleCreatePreset(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  const normalized = raw.trim().toLowerCase();
+  if (normalized.length === 0) {
+    throw new PmCliError("--schedule-preset must not be empty", EXIT_CODE.USAGE);
+  }
+  if (normalized === "lightweight" || normalized === "lite" || normalized === "schedule-lite") {
+    return "lightweight";
+  }
+  throw new PmCliError(`Invalid --schedule-preset value "${raw}". Allowed: ${SCHEDULE_CREATE_PRESET_VALUES.join(", ")}`, EXIT_CODE.USAGE);
+}
+function resolveEffectiveCreateMode(createMode, schedulePreset, defaultMode) {
+  const resolvedMode = resolveCreateMode(createMode, defaultMode);
+  if (schedulePreset === void 0) {
+    return resolvedMode;
+  }
+  const createModeWasExplicit = typeof createMode === "string" && createMode.trim().length > 0;
+  if (createModeWasExplicit && resolvedMode === "strict") {
+    throw new PmCliError("--schedule-preset lightweight cannot be combined with --create-mode strict. Use --create-mode progressive or omit --create-mode.", EXIT_CODE.USAGE);
+  }
+  return "progressive";
+}
+function requireCreateOptionByType(typeDefinition, options, createMode, clearOptionKeys) {
+  const typeName = typeDefinition.name;
+  const scalarValues = {
+    title: options.title,
+    description: options.description,
+    type: options.type,
+    status: options.status,
+    priority: options.priority,
+    tags: options.tags,
+    body: options.body,
+    deadline: options.deadline,
+    estimatedMinutes: options.estimatedMinutes,
+    acceptanceCriteria: options.acceptanceCriteria,
+    definitionOfReady: options.definitionOfReady,
+    order: options.order ?? options.rank,
+    goal: options.goal,
+    objective: options.objective,
+    value: options.value,
+    impact: options.impact,
+    outcome: options.outcome,
+    whyNow: options.whyNow,
+    author: options.author,
+    message: options.message,
+    assignee: options.assignee,
+    parent: options.parent,
+    reviewer: options.reviewer,
+    risk: options.risk,
+    confidence: options.confidence,
+    sprint: options.sprint,
+    release: options.release,
+    blockedBy: options.blockedBy,
+    blockedReason: options.blockedReason,
+    unblockNote: options.unblockNote,
+    reporter: options.reporter,
+    severity: options.severity,
+    environment: options.environment,
+    reproSteps: options.reproSteps,
+    resolution: options.resolution,
+    expectedResult: options.expectedResult,
+    actualResult: options.actualResult,
+    affectedVersion: options.affectedVersion,
+    fixedVersion: options.fixedVersion,
+    component: options.component,
+    regression: options.regression,
+    customerImpact: options.customerImpact
+  };
+  const repeatableValues = {
+    dep: options.dep,
+    comment: options.comment,
+    note: options.note,
+    learning: options.learning,
+    file: options.file,
+    test: options.test,
+    doc: options.doc,
+    reminder: options.reminder,
+    event: options.event,
+    typeOption: options.typeOption,
+    field: options.field
+  };
+  const hasOptionValue = (optionKey) => {
+    if (optionKey === "tags") {
+      return scalarValues.tags !== void 0 || Array.isArray(options.addTags) && options.addTags.length > 0;
+    }
+    if (optionKey in scalarValues) {
+      return scalarValues[optionKey] !== void 0;
+    }
+    if (optionKey in repeatableValues) {
+      const value = repeatableValues[optionKey];
+      return Array.isArray(value) && value.length > 0;
+    }
+    return false;
+  };
+  const hasOptionMutation = (optionKey) => hasOptionValue(optionKey) || clearOptionKeys.has(optionKey);
+  const baseRequiredOptions = /* @__PURE__ */ new Set(["title", "type"]);
+  if (createMode === "strict") {
+    for (const field of typeDefinition.required_create_fields) {
+      baseRequiredOptions.add(normalizeCreatePolicyOptionKey(field, typeName, "required_create_fields"));
+    }
+    for (const field of typeDefinition.required_create_repeatables) {
+      baseRequiredOptions.add(normalizeCreatePolicyOptionKey(field, typeName, "required_create_repeatables"));
+    }
+  }
+  const policyState = resolveCommandOptionPolicyState(typeDefinition, "create", baseRequiredOptions);
+  if (policyState.errors.length > 0) {
+    throw new PmCliError(policyState.errors.join("; "), EXIT_CODE.CONFLICT);
+  }
+  for (const option of policyState.disabled) {
+    if (hasOptionMutation(option)) {
+      throw new PmCliError(`Option ${commandOptionFlagLabel("create", option)} is disabled for type "${typeName}" by command_option_policies`, EXIT_CODE.USAGE);
+    }
+  }
+  if (createMode === "strict") {
+    const strictRequiredClears = policyState.required.filter((required) => clearOptionKeys.has(required));
+    if (strictRequiredClears.length > 0) {
+      const requiredFlags = [...new Set(strictRequiredClears.map((required) => commandOptionFlagLabel("create", required)))].sort((left, right) => left.localeCompare(right));
+      throw new PmCliError(`Strict create mode requires concrete values for ${requiredFlags.join(", ")}; --unset/--clear-* directives cannot satisfy required options`, EXIT_CODE.USAGE);
+    }
+  }
+  const satisfiesRequiredOption = (optionKey) => {
+    if (optionKey === "status" && typeDefinition.default_status !== void 0) {
+      return true;
+    }
+    return hasOptionValue(optionKey);
+  };
+  const missingRequiredOptions = policyState.required.filter((required) => !satisfiesRequiredOption(required));
+  return [...new Set(missingRequiredOptions.map((required) => commandOptionFlagLabel("create", required)))].sort((left, right) => left.localeCompare(right));
+}
+var MISSING_REQUIRED_TYPE_OPTION_PATTERN = /^Missing required type option "([^"]+)" for type "([^"]+)"$/;
+function collectMissingRequiredTypeOptionKeys(errors, typeName) {
+  const missingKeys = [];
+  for (const error of errors) {
+    const match = error.match(MISSING_REQUIRED_TYPE_OPTION_PATTERN);
+    if (!match) {
+      continue;
+    }
+    if (match[2] !== typeName) {
+      continue;
+    }
+    missingKeys.push(match[1]);
+  }
+  return [...new Set(missingKeys)].sort((left, right) => left.localeCompare(right));
+}
+function filterNonMissingTypeOptionErrors(errors, typeName) {
+  return errors.filter((error) => {
+    const match = error.match(MISSING_REQUIRED_TYPE_OPTION_PATTERN);
+    return !match || match[2] !== typeName;
+  });
+}
+function typeOptionExampleValue(typeDefinition, key) {
+  const optionDefinition = typeDefinition.options.find((option) => option.key === key);
+  const firstAllowed = optionDefinition?.values[0];
+  if (typeof firstAllowed === "string" && firstAllowed.trim().length > 0) {
+    return firstAllowed;
+  }
+  return "<value>";
+}
+function createExampleTokensForFlag(flag, typeName, openStatus) {
+  switch (flag) {
+    case "--title":
+      return ["--title", `"${typeName} example title"`];
+    case "--description":
+      return ["--description", `"${typeName} example description"`];
+    case "--type":
+      return ["--type", typeName];
+    case "--status":
+      return ["--status", openStatus];
+    case "--priority":
+      return ["--priority", "1"];
+    case "--message":
+      return ["--message", `"Create ${typeName} item"`];
+    case "--dep":
+      return ["--dep", '"id=pm-xxxx,kind=related,author=maintainer,created_at=now"'];
+    case "--comment":
+      return ["--comment", '"author=maintainer,created_at=now,text=Implementation context"'];
+    case "--note":
+      return ["--note", '"author=maintainer,created_at=now,text=Design note"'];
+    case "--learning":
+      return ["--learning", '"author=maintainer,created_at=now,text=Durable lesson"'];
+    case "--file":
+      return ["--file", '"path=src/example.ts,note=implementation file"'];
+    case "--test":
+      return ["--test", '"command=node scripts/run-tests.mjs test,timeout_seconds=240"'];
+    case "--doc":
+      return ["--doc", '"path=README.md,note=reference doc"'];
+    default:
+      return [flag, '"<value>"'];
+  }
+}
+function buildTypeSpecificCreateExample(typeDefinition, missingCreateFlags, missingTypeOptionKeys, openStatus) {
+  const tokens = ["pm", "create", "--title", `"${typeDefinition.name} example title"`, "--description", `"${typeDefinition.name} example description"`, "--type", typeDefinition.name];
+  const optionalRecommendationFlags = ["--status", "--priority", "--message"];
+  const orderedFlags = [.../* @__PURE__ */ new Set([...optionalRecommendationFlags, ...missingCreateFlags])];
+  const includedFlags = /* @__PURE__ */ new Set(["--title", "--description", "--type"]);
+  for (const flag of orderedFlags) {
+    if (includedFlags.has(flag)) {
+      continue;
+    }
+    tokens.push(...createExampleTokensForFlag(flag, typeDefinition.name, openStatus));
+    includedFlags.add(flag);
+  }
+  for (const key of missingTypeOptionKeys) {
+    const value = typeOptionExampleValue(typeDefinition, key);
+    tokens.push("--type-option", `${key}=${value}`);
+  }
+  return tokens.join(" ");
+}
+function requireStringOption(value, flag) {
+  if (value === void 0) {
+    if (flag === "--title") {
+      throw new PmCliError('Missing required option --title. Why required: every item needs a human-readable title for lookup, search, and reporting. Retry: pass the title as the first positional argument (example: pm create "Fix login bug" --type Issue) or with --title.', EXIT_CODE.USAGE);
+    }
+    throw new PmCliError(`Missing required option ${flag}`, EXIT_CODE.USAGE);
+  }
+  return value;
+}
+function selectAuthor(explicitAuthor, settingsAuthor) {
+  const candidate = parseOptionalString(explicitAuthor) ?? process.env.PM_AUTHOR ?? settingsAuthor;
+  const trimmed = candidate.trim();
+  return trimmed || "unknown";
+}
+function ensurePriority(rawPriority) {
+  return resolvePriority(rawPriority);
+}
+function mergeCreateOptionsWithTemplate(templateOptions, explicitOptions) {
+  const merged = {};
+  for (const [key, value] of Object.entries(templateOptions)) {
+    merged[key] = Array.isArray(value) ? [...value] : value;
+  }
+  for (const [key, value] of Object.entries(explicitOptions)) {
+    if (value !== void 0) {
+      merged[key] = Array.isArray(value) ? [...value] : value;
+    }
+  }
+  return merged;
+}
+function normalizeExtensionCommandPath(command) {
+  return command.trim().toLowerCase().split(/\s+/).filter((part) => part.length > 0).join(" ");
+}
+function hasTemplatesShowHandler() {
+  const registrations = getActiveExtensionRegistrations();
+  if (!registrations) {
+    return false;
+  }
+  return registrations.commands.some((entry) => {
+    return entry.action === "templates-show" || normalizeExtensionCommandPath(entry.command) === "templates show";
+  });
+}
+function readTemplateOptionsFromRuntimeResult(result, templateName) {
+  if (typeof result !== "object" || result === null || !("options" in result)) {
+    throw new PmCliError(`Templates package returned invalid payload for template "${templateName}". Expected an options object.`, EXIT_CODE.GENERIC_FAILURE);
+  }
+  const options = result.options;
+  if (typeof options !== "object" || options === null || Array.isArray(options)) {
+    throw new PmCliError(`Templates package returned invalid options for template "${templateName}".`, EXIT_CODE.GENERIC_FAILURE);
+  }
+  const normalized = {};
+  for (const [key, value] of Object.entries(options)) {
+    if (typeof value === "string") {
+      normalized[key] = value;
+      continue;
+    }
+    if (Array.isArray(value) && value.every((entry) => typeof entry === "string")) {
+      normalized[key] = [...value];
+      continue;
+    }
+    throw new PmCliError(`Templates package returned unsupported option value for "${key}" in template "${templateName}".`, EXIT_CODE.GENERIC_FAILURE);
+  }
+  return normalized;
+}
+async function loadCreateTemplateOptionsFromRuntime(templateName, global, pmRoot) {
+  if (!hasTemplatesShowHandler()) {
+    throw new PmCliError(`--template requires the templates package. Install it first (for example: pm install templates --project).`, EXIT_CODE.USAGE);
+  }
+  const handlerResult = await runActiveCommandHandler({
+    command: "templates show",
+    args: [templateName],
+    options: {},
+    global,
+    pm_root: pmRoot
+  });
+  if (!handlerResult.handled) {
+    const warningSuffix = handlerResult.warnings.length > 0 ? ` (${handlerResult.warnings.join(", ")})` : "";
+    throw new PmCliError(`Unable to resolve template "${templateName}" via templates package. Run "pm templates show ${templateName}" for details.${warningSuffix}`, EXIT_CODE.USAGE);
+  }
+  return readTemplateOptionsFromRuntimeResult(handlerResult.result, templateName);
+}
+function ensureInitHasRun(pmRoot) {
+  return pathExists(getSettingsPath(pmRoot)).then((exists) => {
+    if (!exists) {
+      throw new PmCliError(`Tracker is not initialized at ${pmRoot}. Run pm init first.`, EXIT_CODE.NOT_FOUND);
+    }
+  });
+}
+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());
+  if (resolvedOptions.template !== void 0) {
+    const templateName = resolvedOptions.template.trim();
+    if (templateName.length === 0) {
+      throw new PmCliError("--template must not be empty. Omit --template to disable template usage.", EXIT_CODE.USAGE);
+    }
+    const templateOptions = await loadCreateTemplateOptionsFromRuntime(templateName, global, pmRoot);
+    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";
+      }
+    }
+  }
+  if (resolvedOptions.type === void 0) {
+    throw new PmCliError("Missing required option --type <value>", EXIT_CODE.USAGE);
+  }
+  let resolvedTypeName = resolveTypeName(resolvedOptions.type, typeRegistry);
+  if (!resolvedTypeName) {
+    const synonymCanonical = resolveTypeSynonym(resolvedOptions.type);
+    const synonymResolved = synonymCanonical ? resolveTypeName(synonymCanonical, typeRegistry) : void 0;
+    if (synonymResolved) {
+      printError(`[pm] note: type '${resolvedOptions.type.trim()}' is not defined; using closest match '${synonymResolved}'. Run 'pm schema add-type "${resolvedOptions.type.trim()}"' to track it as a distinct type.`);
+      resolvedOptions.type = synonymResolved;
+      resolvedTypeName = synonymResolved;
+    } else {
+      throw new PmCliError(buildInvalidTypeError(resolvedOptions.type, typeRegistry.types), EXIT_CODE.USAGE);
+    }
+  }
+  const typeDefinition = resolveTypeDefinition(resolvedTypeName, typeRegistry);
+  if (!typeDefinition) {
+    throw new PmCliError(`Invalid type value "${resolvedOptions.type}"`, EXIT_CODE.USAGE);
+  }
+  const type = typeDefinition.name;
+  const schedulePreset = resolveScheduleCreatePreset(resolvedOptions.schedulePreset);
+  if (schedulePreset !== void 0 && !SCHEDULE_CREATE_PRESET_TYPES.has(type)) {
+    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);
+  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"
+    }
+  ];
+  for (const definition of clearCollectionDefinitions) {
+    if (!definition.enabled) {
+      continue;
+    }
+    if (definition.values && definition.values.length > 0) {
+      throw new PmCliError(`Cannot combine ${definition.clearFlag} with ${definition.valueFlag}`, EXIT_CODE.USAGE);
+    }
+    explicitUnsets.add(definition.frontMatterKey);
+    clearOptionKeys.add(definition.optionKey);
+  }
+  const scalarOptionPresence = {
+    tags: resolvedOptions.tags !== void 0,
+    deadline: resolvedOptions.deadline !== void 0,
+    estimatedMinutes: resolvedOptions.estimatedMinutes !== void 0,
+    acceptanceCriteria: resolvedOptions.acceptanceCriteria !== void 0,
+    definitionOfReady: resolvedOptions.definitionOfReady !== void 0,
+    order: resolvedOptions.order !== void 0 || resolvedOptions.rank !== void 0,
+    goal: resolvedOptions.goal !== void 0,
+    objective: resolvedOptions.objective !== void 0,
+    value: resolvedOptions.value !== void 0,
+    impact: resolvedOptions.impact !== void 0,
+    outcome: resolvedOptions.outcome !== void 0,
+    whyNow: resolvedOptions.whyNow !== void 0,
+    author: resolvedOptions.author !== void 0,
+    assignee: resolvedOptions.assignee !== void 0,
+    parent: resolvedOptions.parent !== void 0,
+    reviewer: resolvedOptions.reviewer !== void 0,
+    risk: resolvedOptions.risk !== void 0,
+    confidence: resolvedOptions.confidence !== void 0,
+    sprint: resolvedOptions.sprint !== void 0,
+    release: resolvedOptions.release !== void 0,
+    blockedBy: resolvedOptions.blockedBy !== void 0,
+    blockedReason: resolvedOptions.blockedReason !== void 0,
+    unblockNote: resolvedOptions.unblockNote !== void 0,
+    reporter: resolvedOptions.reporter !== void 0,
+    severity: resolvedOptions.severity !== void 0,
+    environment: resolvedOptions.environment !== void 0,
+    reproSteps: resolvedOptions.reproSteps !== void 0,
+    resolution: resolvedOptions.resolution !== void 0,
+    expectedResult: resolvedOptions.expectedResult !== void 0,
+    actualResult: resolvedOptions.actualResult !== void 0,
+    affectedVersion: resolvedOptions.affectedVersion !== void 0,
+    fixedVersion: resolvedOptions.fixedVersion !== void 0,
+    component: resolvedOptions.component !== void 0,
+    regression: resolvedOptions.regression !== void 0,
+    customerImpact: resolvedOptions.customerImpact !== void 0
+  };
+  for (const [optionKey, hasValue] of Object.entries(scalarOptionPresence)) {
+    if (!hasValue || !unsetTargets.optionKeys.has(optionKey)) {
+      continue;
+    }
+    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) => {
+    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);
+  };
+  assertNoLegacyScalarToken(resolvedOptions.tags, "tags");
+  assertNoLegacyScalarToken(resolvedOptions.deadline, "deadline");
+  assertNoLegacyScalarToken(resolvedOptions.estimatedMinutes, "estimatedMinutes");
+  assertNoLegacyScalarToken(resolvedOptions.acceptanceCriteria, "acceptanceCriteria");
+  assertNoLegacyScalarToken(resolvedOptions.definitionOfReady, "definitionOfReady");
+  assertNoLegacyScalarToken(resolvedOptions.order ?? resolvedOptions.rank, "order");
+  assertNoLegacyScalarToken(resolvedOptions.goal, "goal");
+  assertNoLegacyScalarToken(resolvedOptions.objective, "objective");
+  assertNoLegacyScalarToken(resolvedOptions.value, "value");
+  assertNoLegacyScalarToken(resolvedOptions.impact, "impact");
+  assertNoLegacyScalarToken(resolvedOptions.outcome, "outcome");
+  assertNoLegacyScalarToken(resolvedOptions.whyNow, "whyNow");
+  assertNoLegacyScalarToken(resolvedOptions.author, "author");
+  assertNoLegacyScalarToken(resolvedOptions.assignee, "assignee");
+  assertNoLegacyScalarToken(resolvedOptions.parent, "parent");
+  assertNoLegacyScalarToken(resolvedOptions.reviewer, "reviewer");
+  assertNoLegacyScalarToken(resolvedOptions.risk, "risk");
+  assertNoLegacyScalarToken(resolvedOptions.confidence, "confidence");
+  assertNoLegacyScalarToken(resolvedOptions.sprint, "sprint");
+  assertNoLegacyScalarToken(resolvedOptions.release, "release");
+  assertNoLegacyScalarToken(resolvedOptions.blockedBy, "blockedBy");
+  assertNoLegacyScalarToken(resolvedOptions.blockedReason, "blockedReason");
+  assertNoLegacyScalarToken(resolvedOptions.unblockNote, "unblockNote");
+  assertNoLegacyScalarToken(resolvedOptions.reporter, "reporter");
+  assertNoLegacyScalarToken(resolvedOptions.severity, "severity");
+  assertNoLegacyScalarToken(resolvedOptions.environment, "environment");
+  assertNoLegacyScalarToken(resolvedOptions.reproSteps, "reproSteps");
+  assertNoLegacyScalarToken(resolvedOptions.resolution, "resolution");
+  assertNoLegacyScalarToken(resolvedOptions.expectedResult, "expectedResult");
+  assertNoLegacyScalarToken(resolvedOptions.actualResult, "actualResult");
+  assertNoLegacyScalarToken(resolvedOptions.affectedVersion, "affectedVersion");
+  assertNoLegacyScalarToken(resolvedOptions.fixedVersion, "fixedVersion");
+  assertNoLegacyScalarToken(resolvedOptions.component, "component");
+  assertNoLegacyScalarToken(resolvedOptions.regression, "regression");
+  assertNoLegacyScalarToken(resolvedOptions.customerImpact, "customerImpact");
+  const missingRequiredCreateFlags = requireCreateOptionByType(typeDefinition, resolvedOptions, createMode, clearOptionKeys);
+  const nowValue = nowIso();
+  const author = selectAuthor(resolvedOptions.author, settings.author_default);
+  const dependencies = parseDependencies(resolvedOptions.dep, nowValue, settings.id_prefix);
+  const comments = parseLogSeed("--comment", resolvedOptions.comment, nowValue, author);
+  const notes = parseLogSeed("--note", resolvedOptions.note, nowValue, author);
+  const learnings = parseLogSeed("--learning", resolvedOptions.learning, nowValue, author);
+  const files = parseFiles(resolvedOptions.file);
+  const tests = parseTests(resolvedOptions.test);
+  const docs = parseDocs(resolvedOptions.doc);
+  const reminders = parseReminders(resolvedOptions.reminder, nowValue);
+  const events = parseEvents(resolvedOptions.event, nowValue);
+  const typeOptions = parseTypeOptions(resolvedOptions.typeOption);
+  const validatedTypeOptions = validateTypeOptions(type, typeOptions.values, typeRegistry);
+  const extensionRegistrations = getActiveExtensionRegistrations();
+  const extensionFieldNames = collectRegisteredItemFieldNames(extensionRegistrations);
+  const registeredItemFieldValues = parseRegisteredItemFieldAssignments(resolvedOptions.field, extensionRegistrations);
+  for (const fieldKey of Object.keys(registeredItemFieldValues)) {
+    if (!unsetTargets.frontMatterKeys.has(fieldKey)) {
+      continue;
+    }
+    throw new PmCliError(`Cannot combine --unset ${fieldKey.replaceAll("_", "-")} with --field ${fieldKey}=...`, EXIT_CODE.USAGE);
+  }
+  const runtimeCreateFieldValues = collectRuntimeCreateFieldValues(resolvedOptions, runtimeFieldRegistry, type);
+  for (const fieldKey of Object.keys(runtimeCreateFieldValues.values ?? {})) {
+    if (!unsetTargets.frontMatterKeys.has(fieldKey)) {
+      continue;
+    }
+    throw new PmCliError(`Cannot combine --unset ${fieldKey.replaceAll("_", "-")} with its value flag`, EXIT_CODE.USAGE);
+  }
+  const missingRequiredTypeOptionKeys = collectMissingRequiredTypeOptionKeys(validatedTypeOptions.errors, type);
+  const missingRequiredTypeOptionFlags = missingRequiredTypeOptionKeys.map((key) => `--type-option ${key}=<value>`);
+  const combinedMissingFlags = [
+    .../* @__PURE__ */ new Set([
+      ...missingRequiredCreateFlags,
+      ...missingRequiredTypeOptionFlags,
+      ...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
+    });
+  }
+  const nonMissingTypeOptionErrors = filterNonMissingTypeOptionErrors(validatedTypeOptions.errors, type);
+  if (nonMissingTypeOptionErrors.length > 0) {
+    const nextValidExample = buildTypeSpecificCreateExample(typeDefinition, [], [], statusRegistry.open_status);
+    throw new PmCliError(nonMissingTypeOptionErrors.join("; "), EXIT_CODE.USAGE, {
+      code: "invalid_argument_value",
+      required: `Provide valid --type-option key/value pairs for type "${type}".`,
+      examples: [nextValidExample],
+      nextSteps: [`Run "pm create --help --type ${type}" to review allowed type-option keys and values.`]
+    });
+  }
+  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);
+  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 parentReferencePolicy = 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`);
+  }
+  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 = 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 title = requireStringOption(resolvedOptions.title, "--title");
+  const description = resolvedOptions.description ?? "";
+  const body = resolvedOptions.body ?? "";
+  const frontMatter = normalizeFrontMatter({
+    id,
+    title,
+    description,
+    type,
+    type_options: validatedTypeOptions.normalized,
+    status,
+    priority,
+    tags,
+    created_at: nowValue,
+    updated_at: nowValue,
+    deadline,
+    assignee,
+    author: authorValue,
+    estimated_minutes: estimatedMinutes,
+    acceptance_criteria: acceptanceCriteria,
+    definition_of_ready: definitionOfReady,
+    order,
+    goal,
+    objective,
+    value,
+    impact,
+    outcome,
+    why_now: whyNow,
+    parent,
+    reviewer,
+    risk,
+    confidence,
+    sprint,
+    release,
+    blocked_by: blockedBy,
+    blocked_reason: blockedReason,
+    unblock_note: unblockNote,
+    reporter,
+    severity,
+    environment,
+    repro_steps: reproSteps,
+    resolution,
+    expected_result: expectedResult,
+    actual_result: actualResult,
+    affected_version: affectedVersion,
+    fixed_version: fixedVersion,
+    component,
+    regression,
+    customer_impact: customerImpact,
+    dependencies: dependencyValues,
+    comments: comments.values,
+    notes: notes.values,
+    learnings: learnings.values,
+    files: files.values,
+    tests: tests.values,
+    docs: docs.values,
+    reminders: reminders.values,
+    events: events.values,
+    ...registeredItemFieldValues,
+    ...runtimeCreateFieldValues.values ?? {}
+  });
+  try {
+    applyRegisteredItemFieldDefaultsAndValidation(frontMatter, extensionRegistrations);
+  } catch (error) {
+    throw new PmCliError(error instanceof Error ? error.message : "Invalid extension item field values", EXIT_CODE.USAGE);
+  }
+  const afterDocument = canonicalDocument({
+    metadata: frontMatter,
+    body
+  }, { schema: settings.schema, extensionFieldNames });
+  const beforeDocument = {
+    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, [
+    ...Object.keys(registeredItemFieldValues),
+    ...Object.keys(runtimeCreateFieldValues.values ?? {})
+  ]);
+  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 outputItem = structuredClone(frontMatter);
+  if (calendarRelevantTypes.has(type.toLowerCase()) && !hasDeadline && !hasReminders && !hasEvents) {
+    printError(`[pm] warning: ${type} '${id}' has no deadline/reminder/event \u2014 it will not appear on the calendar. Add one via 'pm update ${id} --deadline <ISO>' or 'pm update ${id} --event "start=<ISO>,end=<ISO>"'.`);
+  }
+  return {
+    item: outputItem,
+    changed_fields: changedFields,
+    warnings: [...validationWarnings, ...hookWarnings]
+  };
+}
+
+export {
+  resolvePriority,
+  normalizeRiskInput,
+  normalizeSeverityInput,
+  parseConfidenceInput,
+  parseRegressionInput,
+  isLegacyNoneToken,
+  assertNoLegacyNoneToken,
+  assertNoLegacyNoneTokens,
+  ensureEnumValue,
+  parseReminderEntries,
+  parseEventEntries,
+  parseTypeOptionEntries,
+  parseLogSeed,
+  parseFiles,
+  parseTests,
+  parseDocs,
+  runCreate
+};
+//# sourceMappingURL=chunk-ZRVSMOMR.js.map
+
+//# debugId=67af10d9-cb2f-5b7f-9238-a7eae5edeb4d