@unbrained/pm-cli 2026.7.5 → 2026.7.6

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

@@ -0,0 +1,2132 @@
+
+!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]="3b2e2c0b-d9a3-51c6-ba51-0bad9aa69284")}catch(e){}}();
+import {
+  looksLikeStructuredLinkedTestEntry,
+  normalizeStructuredLinkedTestEntry,
+  parseLinkedTestAssertionEqualsMap,
+  parseLinkedTestAssertionGteMap,
+  parseLinkedTestBoolean,
+  parseLinkedTestContextMode,
+  parseLinkedTestEnvClear,
+  parseLinkedTestEnvSet,
+  parseLinkedTestMinLines,
+  parseLinkedTestRegexList,
+  parseLinkedTestStringList
+} from "./chunk-RFNYTESG.js";
+import {
+  assertNoUnknownCsvKeys,
+  createStdinTokenResolver,
+  looksLikeGenericKeyValueEntry,
+  mergeAdditiveTags,
+  parseCsvKv,
+  parseOptionalNumber,
+  parseTags
+} from "./chunk-IWVU4C2F.js";
+import {
+  getFocusedItem
+} from "./chunk-XG625QP4.js";
+import {
+  printError
+} from "./chunk-MLIYFOE7.js";
+import {
+  acquireLock,
+  appendHistoryEntry,
+  applyRegisteredItemFieldDefaultsAndValidation,
+  collectRegisteredItemFieldNames,
+  createHistoryEntry,
+  locateItem,
+  parseRegisteredItemFieldAssignments
+} from "./chunk-ENGQOEUY.js";
+import {
+  assertParentReferenceIsNotSelf,
+  isPlaceholderReferenceToken,
+  normalizeParentReferenceValue,
+  validateMissingParentReference,
+  validateSprintOrReleaseValue
+} from "./chunk-7WBAJSS6.js";
+import {
+  canonicalDocument,
+  collectRuntimeCreateFieldValues,
+  generateItemId,
+  normalizeFrontMatter,
+  normalizeItemId,
+  normalizeStatusInput,
+  serializeItemDocument
+} from "./chunk-G24G7ZAV.js";
+import {
+  nowIso,
+  resolveIsoOrRelative
+} from "./chunk-3GCS5SKL.js";
+import {
+  PmCliError,
+  getActiveExtensionRegistrations,
+  projectAfterCommandItemSnapshot,
+  readSettings,
+  recordAfterCommandAffectedItem,
+  runActiveCommandHandler,
+  runActiveOnWriteHooks
+} from "./chunk-E3SZTQ4K.js";
+import {
+  buildInvalidTypeError
+} from "./chunk-KUOOJR35.js";
+import {
+  CONFIDENCE_TEXT_VALUES,
+  CREATE_DIRECT_CLOSE_REASON_DEFAULT,
+  DEPENDENCY_KIND_VALUES,
+  EXIT_CODE,
+  FRONT_MATTER_KEY_ORDER,
+  ISSUE_SEVERITY_VALUES,
+  RECURRENCE_FREQUENCY_VALUES,
+  RECURRENCE_WEEKDAY_VALUES,
+  RISK_VALUES,
+  SCOPE_VALUES,
+  canonicalizeCommandOptionKey,
+  commandOptionFlagLabel,
+  getHistoryPath,
+  getItemPath,
+  getSettingsPath,
+  normalizeStatusInputWithRegistry,
+  pathExists,
+  removeFileIfExists,
+  resolveCommandOptionPolicyState,
+  resolveItemTypeRegistry,
+  resolveItemTypesFilePath,
+  resolvePmRoot,
+  resolveRuntimeFieldRegistry,
+  resolveRuntimeStatusRegistry,
+  resolveTypeDefinition,
+  resolveTypeName,
+  validateTypeOptions,
+  weekdayOrderIndex,
+  writeFileAtomic
+} from "./chunk-57NWPFF2.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);
+}
+function applyLegacyNoneCollectionNormalizers(normalized, definitions) {
+  for (const definition of definitions) {
+    const candidate = normalized[definition.optionKey];
+    if (!Array.isArray(candidate) || candidate.length === 0) {
+      continue;
+    }
+    if (!candidate.every((entry) => typeof entry === "string")) {
+      throw new PmCliError(`${definition.valueFlag} entries must be strings.`, EXIT_CODE.USAGE);
+    }
+    const entries = candidate;
+    const hasLegacy = entries.some((entry) => isLegacyNoneToken(entry));
+    if (!hasLegacy) {
+      continue;
+    }
+    const concreteEntries = entries.filter((entry) => !isLegacyNoneToken(entry));
+    if (concreteEntries.length > 0) {
+      throw new PmCliError(`Cannot mix legacy clear token "none"/"null" with concrete ${definition.valueFlag} entries. Use ${definition.clearFlag} to clear or provide explicit entries.`, EXIT_CODE.USAGE);
+    }
+    normalized[definition.optionKey] = void 0;
+    normalized[definition.clearFlagKey] = true;
+    if (definition.disableFlagKey) {
+      normalized[definition.disableFlagKey] = false;
+    }
+  }
+  return normalized;
+}
+
+// dist/cli/commands/lifecycle-transitions.js
+var NON_WORKABLE_TYPES = /* @__PURE__ */ new Set([
+  "event",
+  "meeting",
+  "reminder",
+  "milestone",
+  "decision",
+  "adr"
+]);
+function suggestNextLifecycleTransition(id, type, status, statusRegistry) {
+  if (NON_WORKABLE_TYPES.has(type.trim().toLowerCase())) {
+    return void 0;
+  }
+  if (status !== statusRegistry.open_status) {
+    return void 0;
+  }
+  const inProgress = normalizeStatusInputWithRegistry("in_progress", statusRegistry);
+  if (inProgress === void 0 || inProgress === statusRegistry.open_status) {
+    return void 0;
+  }
+  return { command: `pm start-task ${id}`, to_status: inProgress };
+}
+
+// dist/cli/commands/shared-unset-fields.js
+var COMMON_UNSET_FIELD_DEFINITIONS_BEFORE_CLOSE_REASON = [
+  { canonical: "tags", aliases: ["tags"], optionKey: "tags", frontMatterKey: "tags" }
+];
+var COMMON_UNSET_FIELD_DEFINITIONS_AFTER_CLOSE_REASON_BEFORE_AUTHOR = [
+  { canonical: "deadline", aliases: ["deadline"], optionKey: "deadline", frontMatterKey: "deadline" },
+  {
+    canonical: "estimate",
+    aliases: ["estimate", "estimated_minutes", "estimated-minutes"],
+    optionKey: "estimatedMinutes",
+    frontMatterKey: "estimated_minutes"
+  },
+  {
+    canonical: "acceptance-criteria",
+    aliases: ["acceptance_criteria", "acceptance-criteria", "ac"],
+    optionKey: "acceptanceCriteria",
+    frontMatterKey: "acceptance_criteria"
+  },
+  {
+    canonical: "definition-of-ready",
+    aliases: ["definition_of_ready", "definition-of-ready"],
+    optionKey: "definitionOfReady",
+    frontMatterKey: "definition_of_ready"
+  },
+  { canonical: "order", aliases: ["order", "rank"], optionKey: "order", frontMatterKey: "order" },
+  { canonical: "goal", aliases: ["goal"], optionKey: "goal", frontMatterKey: "goal" },
+  { canonical: "objective", aliases: ["objective"], optionKey: "objective", frontMatterKey: "objective" },
+  { canonical: "value", aliases: ["value"], optionKey: "value", frontMatterKey: "value" },
+  { canonical: "impact", aliases: ["impact"], optionKey: "impact", frontMatterKey: "impact" },
+  { canonical: "outcome", aliases: ["outcome"], optionKey: "outcome", frontMatterKey: "outcome" },
+  { canonical: "why-now", aliases: ["why_now", "why-now"], optionKey: "whyNow", frontMatterKey: "why_now" }
+];
+var COMMON_UNSET_FIELD_DEFINITIONS_BEFORE_AUTHOR = [
+  ...COMMON_UNSET_FIELD_DEFINITIONS_BEFORE_CLOSE_REASON,
+  ...COMMON_UNSET_FIELD_DEFINITIONS_AFTER_CLOSE_REASON_BEFORE_AUTHOR
+];
+var COMMON_UNSET_FIELD_DEFINITIONS_AFTER_AUTHOR = [
+  { canonical: "assignee", aliases: ["assignee"], optionKey: "assignee", frontMatterKey: "assignee" },
+  { canonical: "parent", aliases: ["parent"], optionKey: "parent", frontMatterKey: "parent" },
+  { canonical: "reviewer", aliases: ["reviewer"], optionKey: "reviewer", frontMatterKey: "reviewer" },
+  { canonical: "risk", aliases: ["risk"], optionKey: "risk", frontMatterKey: "risk" },
+  { canonical: "confidence", aliases: ["confidence"], optionKey: "confidence", frontMatterKey: "confidence" },
+  { canonical: "sprint", aliases: ["sprint"], optionKey: "sprint", frontMatterKey: "sprint" },
+  { canonical: "release", aliases: ["release"], optionKey: "release", frontMatterKey: "release" },
+  {
+    canonical: "blocked-by",
+    aliases: ["blocked_by", "blocked-by"],
+    optionKey: "blockedBy",
+    frontMatterKey: "blocked_by"
+  },
+  {
+    canonical: "blocked-reason",
+    aliases: ["blocked_reason", "blocked-reason"],
+    optionKey: "blockedReason",
+    frontMatterKey: "blocked_reason"
+  },
+  {
+    canonical: "unblock-note",
+    aliases: ["unblock_note", "unblock-note"],
+    optionKey: "unblockNote",
+    frontMatterKey: "unblock_note"
+  },
+  { canonical: "reporter", aliases: ["reporter"], optionKey: "reporter", frontMatterKey: "reporter" },
+  { canonical: "severity", aliases: ["severity"], optionKey: "severity", frontMatterKey: "severity" },
+  {
+    canonical: "environment",
+    aliases: ["environment"],
+    optionKey: "environment",
+    frontMatterKey: "environment"
+  },
+  {
+    canonical: "repro-steps",
+    aliases: ["repro_steps", "repro-steps"],
+    optionKey: "reproSteps",
+    frontMatterKey: "repro_steps"
+  },
+  {
+    canonical: "resolution",
+    aliases: ["resolution"],
+    optionKey: "resolution",
+    frontMatterKey: "resolution"
+  },
+  {
+    canonical: "expected-result",
+    aliases: ["expected_result", "expected-result"],
+    optionKey: "expectedResult",
+    frontMatterKey: "expected_result"
+  },
+  {
+    canonical: "actual-result",
+    aliases: ["actual_result", "actual-result"],
+    optionKey: "actualResult",
+    frontMatterKey: "actual_result"
+  },
+  {
+    canonical: "affected-version",
+    aliases: ["affected_version", "affected-version"],
+    optionKey: "affectedVersion",
+    frontMatterKey: "affected_version"
+  },
+  {
+    canonical: "fixed-version",
+    aliases: ["fixed_version", "fixed-version"],
+    optionKey: "fixedVersion",
+    frontMatterKey: "fixed_version"
+  },
+  { canonical: "component", aliases: ["component"], optionKey: "component", frontMatterKey: "component" },
+  { canonical: "regression", aliases: ["regression"], optionKey: "regression", frontMatterKey: "regression" },
+  {
+    canonical: "customer-impact",
+    aliases: ["customer_impact", "customer-impact"],
+    optionKey: "customerImpact",
+    frontMatterKey: "customer_impact"
+  }
+];
+function parseCommandUnsetTargets(options) {
+  const frontMatterKeys = /* @__PURE__ */ new Set();
+  const optionKeys = /* @__PURE__ */ new Set();
+  if (!options.raw || options.raw.length === 0) {
+    return { frontMatterKeys, optionKeys };
+  }
+  for (const entry of options.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 = options.resolveDefinition(trimmed);
+    if (!definition) {
+      throw new PmCliError(`Unsupported --unset field "${entry}". Supported fields: ${options.supportedFields}`, EXIT_CODE.USAGE);
+    }
+    frontMatterKeys.add(definition.frontMatterKey);
+    optionKeys.add(definition.optionKey);
+  }
+  return { frontMatterKeys, optionKeys };
+}
+function resolveRuntimeUnsetFieldDefinition(token, command, runtimeFieldRegistry) {
+  const normalizedToken = token.trim().toLowerCase();
+  if (!runtimeFieldRegistry) {
+    return void 0;
+  }
+  const definitions = runtimeFieldRegistry.command_to_fields?.get(command) ?? [];
+  for (const definition of definitions) {
+    if (definition.allow_unset === false) {
+      continue;
+    }
+    const candidates = /* @__PURE__ */ new Set();
+    if (typeof definition.key === "string" && definition.key.length > 0) {
+      candidates.add(definition.key.toLowerCase());
+    }
+    if (typeof definition.metadata_key === "string" && definition.metadata_key.length > 0) {
+      candidates.add(definition.metadata_key.toLowerCase());
+    }
+    if (typeof definition.cli_flag === "string" && definition.cli_flag.length > 0) {
+      candidates.add(definition.cli_flag.replaceAll("-", "_").toLowerCase());
+      candidates.add(definition.cli_flag.toLowerCase());
+    }
+    if (Array.isArray(definition.cli_aliases)) {
+      for (const alias of definition.cli_aliases) {
+        if (typeof alias !== "string" || alias.length === 0) {
+          continue;
+        }
+        candidates.add(alias.replaceAll("-", "_").toLowerCase());
+        candidates.add(alias.toLowerCase());
+      }
+    }
+    if (!candidates.has(normalizedToken)) {
+      continue;
+    }
+    return {
+      optionKey: definition.key,
+      frontMatterKey: definition.metadata_key
+    };
+  }
+  return void 0;
+}
+
+// dist/cli/commands/recurrence-parsers.js
+function parseEventBoolean(value, flag) {
+  const normalized = value.trim().toLowerCase();
+  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;
+}
+var RECURRENCE_CSV_KEYS = [
+  "recur_freq",
+  "recur_interval",
+  "recur_count",
+  "recur_until",
+  "recur_by_weekday",
+  "recur_by_month_day",
+  "recur_exdates"
+];
+function numericRecurrenceValueProvided(raw, guard) {
+  return guard === "defined" ? raw !== void 0 : Boolean(raw);
+}
+function parsePositiveRecurrenceInteger(raw, label, guard) {
+  if (!numericRecurrenceValueProvided(raw, guard)) {
+    return void 0;
+  }
+  const parsed = parseOptionalNumber(raw, `event ${label}`);
+  if (!Number.isInteger(parsed) || parsed < 1) {
+    throw new PmCliError(`--event ${label} must be an integer >= 1`, EXIT_CODE.USAGE);
+  }
+  return parsed;
+}
+function parseRecurrenceUntil(untilRaw, startAt, nowValue) {
+  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);
+  }
+  return until;
+}
+function parseRecurrenceWeekdays(raw) {
+  return Array.from(new Set(parseDelimitedList(raw).map((value) => ensureEnumValue(value.toLowerCase(), RECURRENCE_WEEKDAY_VALUES, "event weekday")))).sort((left, right) => weekdayOrderIndex(left) - weekdayOrderIndex(right));
+}
+function parseRecurrenceMonthDays(raw) {
+  return Array.from(new Set(parseDelimitedList(raw).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);
+}
+function parseRecurrenceExdates(raw, nowValue) {
+  return Array.from(new Set(parseDelimitedList(raw).map((value) => resolveIsoOrRelative(value, nowValue, "event.recur_exdates")))).sort((left, right) => left.localeCompare(right));
+}
+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 freq = ensureEnumValue(freqRaw.toLowerCase(), RECURRENCE_FREQUENCY_VALUES, "event recurrence frequency");
+  const interval = parsePositiveRecurrenceInteger(intervalRaw, "recur_interval", emptyNumericGuard);
+  const count = parsePositiveRecurrenceInteger(countRaw, "recur_count", emptyNumericGuard);
+  const until = parseRecurrenceUntil(untilRaw, startAt, nowValue);
+  const byWeekday = parseRecurrenceWeekdays(byWeekdayRaw);
+  const byMonthDay = parseRecurrenceMonthDays(byMonthDayRaw);
+  const exdates = parseRecurrenceExdates(exdatesRaw, nowValue);
+  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, duration=30min, or duration=PT30M, or set an explicit end).";
+var MINUTE_DURATION = /^([+-]?)(\d+)(min|mins|minute|minutes)$/i;
+var ISO_8601_TIME_DURATION = /^([+-]?)[Pp][Tt](?:(\d+)[Hh])?(?:(\d+)[Mm])?(?:(\d+)[Ss])?$/;
+var MILLIS_PER_SECOND = 1e3;
+var MILLIS_PER_MINUTE = 60 * MILLIS_PER_SECOND;
+var MILLIS_PER_HOUR = 60 * MILLIS_PER_MINUTE;
+function toIsoTimestampOrThrow(timestampMs, durationRaw) {
+  const resolved = new Date(timestampMs);
+  if (!Number.isFinite(resolved.getTime())) {
+    throw new PmCliError(`Invalid event.duration value "${durationRaw}". Duration is out of supported timestamp range.`, EXIT_CODE.USAGE);
+  }
+  return resolved.toISOString();
+}
+function resolveDurationAgainstStart(startAt, durationRaw) {
+  const start = new Date(startAt);
+  const trimmedDuration = durationRaw.trim();
+  const minuteDuration = MINUTE_DURATION.exec(trimmedDuration);
+  if (minuteDuration) {
+    const sign = minuteDuration[1] === "-" ? -1 : 1;
+    const amount = Number.parseInt(minuteDuration[2], 10) * sign;
+    return toIsoTimestampOrThrow(start.getTime() + amount * MILLIS_PER_MINUTE, trimmedDuration);
+  }
+  const isoDuration = ISO_8601_TIME_DURATION.exec(trimmedDuration);
+  if (isoDuration) {
+    const [, signToken, hoursToken, minutesToken, secondsToken] = isoDuration;
+    const hasComponent = hoursToken || minutesToken || secondsToken;
+    if (hasComponent) {
+      const sign = signToken === "-" ? -1 : 1;
+      const hours = Number.parseInt(hoursToken ?? "0", 10);
+      const minutes = Number.parseInt(minutesToken ?? "0", 10);
+      const seconds = Number.parseInt(secondsToken ?? "0", 10);
+      const totalMillis = hours * MILLIS_PER_HOUR + minutes * MILLIS_PER_MINUTE + seconds * MILLIS_PER_SECOND;
+      return toIsoTimestampOrThrow(start.getTime() + sign * totalMillis, trimmedDuration);
+    }
+  }
+  const normalizedDuration = trimmedDuration.startsWith("+") || trimmedDuration.startsWith("-") ? trimmedDuration : `+${trimmedDuration}`;
+  return resolveIsoOrRelative(normalizedDuration, start, "event.duration");
+}
+function resolveEventEndAt(startAt, endRaw, durationRaw, referenceDate) {
+  if (endRaw && durationRaw) {
+    throw new PmCliError(EVENT_END_DURATION_MUTUALLY_EXCLUSIVE_MESSAGE, EXIT_CODE.USAGE);
+  }
+  if (durationRaw) {
+    const endAt2 = resolveDurationAgainstStart(startAt, durationRaw);
+    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
+var REMINDER_KEYS = ["at", "date", "text", "title"];
+var EVENT_KEYS = [
+  "start",
+  "date",
+  "end",
+  "duration",
+  "title",
+  "description",
+  "location",
+  "timezone",
+  "all_day",
+  ...RECURRENCE_CSV_KEYS
+];
+var TYPE_OPTION_KEYS = ["key", "value"];
+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");
+    assertNoUnknownCsvKeys(kv, "--reminder", REMINDER_KEYS);
+    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");
+    assertNoUnknownCsvKeys(kv, "--event", EVENT_KEYS);
+    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();
+    const optionalTextFields = [
+      ["title", titleRaw, title],
+      ["description", descriptionRaw, description],
+      ["location", locationRaw, location],
+      ["timezone", timezoneRaw, timezone]
+    ];
+    for (const [fieldLabel, rawValue, trimmedValue] of optionalTextFields) {
+      if (rawValue !== void 0 && !trimmedValue) {
+        throw new PmCliError(`--event ${fieldLabel} must not be empty`, EXIT_CODE.USAGE);
+      }
+    }
+    const allDayRaw = kv.all_day?.trim();
+    const recurrence = parseRecurrenceRule(kv, startAt, nowValue, options.recurrenceEmptyNumericGuard);
+    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");
+      assertNoUnknownCsvKeys(kv, "--type-option", TYPE_OPTION_KEYS);
+      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 = [
+  ...COMMON_UNSET_FIELD_DEFINITIONS_BEFORE_AUTHOR,
+  { canonical: "author", aliases: ["author"], optionKey: "author", frontMatterKey: "author" },
+  ...COMMON_UNSET_FIELD_DEFINITIONS_AFTER_AUTHOR
+];
+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 buildInvalidLogSeedKeysMessage(optionName, unsupportedKeys) {
+  const sortedUnsupported = [...unsupportedKeys].sort((left, right) => left.localeCompare(right));
+  const keyLabel = sortedUnsupported.length === 1 ? "key" : "keys";
+  return `${optionName} supports only author, created_at, and text seed fields. Found unsupported ${keyLabel}: ${sortedUnsupported.join(", ")}. If text contains comma-separated key:value-like fragments, wrap text in quotes (for example text="first,scope:project"), use markdown-style key/value input, or pass ${optionName} - with piped stdin.`;
+}
+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;
+  }
+  return applyLegacyNoneCollectionNormalizers(normalized, CREATE_LEGACY_NONE_COLLECTION_NORMALIZERS);
+}
+function parseOptionalString(value) {
+  if (value === void 0)
+    return void 0;
+  return value;
+}
+function parseCreateUnsetTargets(raw, runtimeFieldRegistry) {
+  return parseCommandUnsetTargets({
+    raw,
+    supportedFields: CREATE_UNSET_SUPPORTED_CANONICAL_FIELDS,
+    resolveDefinition: (trimmed) => CREATE_UNSET_ALIAS_MAP.get(trimmed) ?? resolveRuntimeUnsetFieldDefinition(trimmed, "create", runtimeFieldRegistry)
+  });
+}
+var DEP_SEED_KEYS = ["id", "kind", "type", "author", "created_at"];
+var LINKED_ARTIFACT_SEED_KEYS = ["path", "scope", "note"];
+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 isStructured = looksLikeStructuredEntry(trimmedEntry, DEP_SEED_KEYS);
+    const kv = isStructured ? parseCsvKv(entry, "--dep") : { id: trimmedEntry, kind: "related" };
+    if (isStructured) {
+      assertNoUnknownCsvKeys(kv, "--dep", DEP_SEED_KEYS);
+    }
+    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("|");
+  if (new RegExp(`^(?:[-*+]\\s+)?(?:${keyPattern})\\s*[:=]`, "i").test(raw)) {
+    return true;
+  }
+  return looksLikeGenericKeyValueEntry(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 isStructured = looksLikeStructuredEntry(trimmedEntry, LINKED_ARTIFACT_SEED_KEYS);
+    const kv = isStructured ? parseCsvKv(entry, "--file") : { path: trimmedEntry };
+    if (isStructured) {
+      assertNoUnknownCsvKeys(kv, "--file", LINKED_ARTIFACT_SEED_KEYS);
+    }
+    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 isStructured = looksLikeStructuredEntry(trimmedEntry, LINKED_ARTIFACT_SEED_KEYS);
+    const kv = isStructured ? parseCsvKv(entry, "--doc") : { path: trimmedEntry };
+    if (isStructured) {
+      assertNoUnknownCsvKeys(kv, "--doc", LINKED_ARTIFACT_SEED_KEYS);
+    }
+    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 buildCreateOptionValueLookup(options) {
+  return {
+    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
+    },
+    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
+    },
+    addTags: options.addTags
+  };
+}
+function hasCreateOptionValue(lookup, optionKey) {
+  if (optionKey === "tags") {
+    return lookup.scalarValues.tags !== void 0 || Array.isArray(lookup.addTags) && lookup.addTags.length > 0;
+  }
+  if (Object.prototype.hasOwnProperty.call(lookup.scalarValues, optionKey)) {
+    return lookup.scalarValues[optionKey] !== void 0;
+  }
+  if (Object.prototype.hasOwnProperty.call(lookup.repeatableValues, optionKey)) {
+    const value = lookup.repeatableValues[optionKey];
+    return Array.isArray(value) && value.length > 0;
+  }
+  return false;
+}
+function buildRequiredCreateOptions(typeDefinition, createMode) {
+  const requiredOptions = /* @__PURE__ */ new Set(["title", "type"]);
+  if (createMode !== "strict") {
+    return requiredOptions;
+  }
+  for (const field of typeDefinition.required_create_fields) {
+    requiredOptions.add(normalizeCreatePolicyOptionKey(field, typeDefinition.name, "required_create_fields"));
+  }
+  for (const field of typeDefinition.required_create_repeatables) {
+    requiredOptions.add(normalizeCreatePolicyOptionKey(field, typeDefinition.name, "required_create_repeatables"));
+  }
+  return requiredOptions;
+}
+function assertNoDisabledCreateOptions(disabledOptions, lookup, clearOptionKeys, typeName) {
+  for (const option of disabledOptions) {
+    if (!hasCreateOptionValue(lookup, option) && !clearOptionKeys.has(option)) {
+      continue;
+    }
+    throw new PmCliError(`Option ${commandOptionFlagLabel("create", option)} is disabled for type "${typeName}" by command_option_policies`, EXIT_CODE.USAGE);
+  }
+}
+function assertNoStrictRequiredOptionClears(requiredOptions, createMode, clearOptionKeys) {
+  if (createMode !== "strict") {
+    return;
+  }
+  const strictRequiredClears = requiredOptions.filter((required) => clearOptionKeys.has(required));
+  if (strictRequiredClears.length === 0) {
+    return;
+  }
+  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);
+}
+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 optionLookup = buildCreateOptionValueLookup(options);
+  const baseRequiredOptions = buildRequiredCreateOptions(typeDefinition, createMode);
+  const policyState = resolveCommandOptionPolicyState(typeDefinition, "create", baseRequiredOptions);
+  if (policyState.errors.length > 0) {
+    throw new PmCliError(policyState.errors.join("; "), EXIT_CODE.CONFLICT);
+  }
+  assertNoDisabledCreateOptions(policyState.disabled, optionLookup, clearOptionKeys, typeName);
+  assertNoStrictRequiredOptionClears(policyState.required, createMode, clearOptionKeys);
+  const satisfiesRequiredOption = (optionKey) => {
+    if (optionKey === "status" && typeDefinition.default_status !== void 0) {
+      return true;
+    }
+    return hasCreateOptionValue(optionLookup, 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 assertNoInvalidTypeOptions(errors, type, typeDefinition, statusRegistry) {
+  const nonMissingTypeOptionErrors = filterNonMissingTypeOptionErrors(errors, type);
+  if (nonMissingTypeOptionErrors.length === 0) {
+    return;
+  }
+  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.`]
+  });
+}
+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);
+    }
+  });
+}
+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, itemId, parent, policy) {
+  const normalized = normalizeParentReferenceValue(parent);
+  assertParentReferenceIsNotSelf(itemId, normalized, settings.id_prefix);
+  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 };
+}
+async function resolveCreateParentWithWarnings(params) {
+  if (params.parent === void 0) {
+    return { parent: void 0, warnings: [] };
+  }
+  const parentValidation = await validateCreateParentReference(params.pmRoot, params.settings, params.typeRegistry, params.itemId, params.parent, params.policy);
+  return parentValidation;
+}
+async function resolveCreateItemId(params) {
+  if (params.explicitId === void 0) {
+    return generateItemId(params.pmRoot, params.settings.id_prefix);
+  }
+  if (typeof params.explicitId !== "string") {
+    throw new PmCliError("--id must be a string", EXIT_CODE.USAGE);
+  }
+  const trimmedId = params.explicitId.trim();
+  if (trimmedId.length === 0 || isPlaceholderReferenceToken(trimmedId)) {
+    throw new PmCliError("--id must not be empty or use a placeholder token", EXIT_CODE.USAGE);
+  }
+  const normalizedId = normalizeItemId(trimmedId, params.settings.id_prefix);
+  if (!/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/.test(normalizedId)) {
+    throw new PmCliError("--id must contain only letters, numbers, and dashes after normalization", EXIT_CODE.USAGE);
+  }
+  return normalizedId;
+}
+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) {
+      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) {
+    applyCreateDefaultType(resolvedOptions, settings, typeRegistry);
+  }
+  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, resolveItemTypesFilePath(pmRoot, settings.schema)), 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);
+  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" }
+  ];
+  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);
+  }
+  return { explicitUnsets, clearOptionKeys };
+}
+function assertNoCreateScalarUnsetConflicts(resolvedOptions, unsetTargets) {
+  const scalarOptionPresence = {
+    tags: resolvedOptions.tags !== void 0,
+    deadline: resolvedOptions.deadline !== void 0,
+    estimatedMinutes: resolvedOptions.estimatedMinutes !== void 0,
+    acceptanceCriteria: resolvedOptions.acceptanceCriteria !== void 0,
+    /* c8 ignore next -- definitionOfReady option presence is covered by legacy migration tests. */
+    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);
+  }
+}
+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(value, 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");
+}
+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, settings.locks.wait_ms);
+  let hookWarnings = [];
+  try {
+    const existing = await locateItem(pmRoot, id, settings.id_prefix, settings.item_format, typeRegistry.type_to_folder);
+    if (existing) {
+      throw new PmCliError(`Item "${id}" already exists`, EXIT_CODE.CONFLICT);
+    }
+    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);
+  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);
+  const runtimeCreateFieldValues = collectRuntimeCreateFieldValues(resolvedOptions, runtimeFieldRegistry, type);
+  assertNoCreateFieldUnsetConflicts(registeredItemFieldValues, runtimeCreateFieldValues, unsetTargets);
+  const missingRequiredTypeOptionKeys = collectMissingRequiredTypeOptionKeys(validatedTypeOptions.errors, type);
+  const missingRequiredTypeOptionFlags = missingRequiredTypeOptionKeys.map((key) => `--type-option ${key}=<value>`);
+  const combinedMissingFlags = [
+    .../* @__PURE__ */ new Set([
+      ...missingRequiredCreateFlags,
+      ...missingRequiredTypeOptionFlags,
+      /* c8 ignore next -- runtime-required flag aggregation is covered in runtime schema create tests. */
+      ...runtimeCreateFieldValues.missing_required_flags
+    ])
+  ].sort((left, right) => left.localeCompare(right));
+  assertNoMissingRequiredCreateOptions({
+    combinedMissingFlags,
+    typeDefinition,
+    missingRequiredCreateFlags,
+    missingRequiredTypeOptionKeys,
+    openStatus: statusRegistry.open_status,
+    type,
+    createMode
+  });
+  assertNoInvalidTypeOptions(validatedTypeOptions.errors, type, typeDefinition, statusRegistry);
+  const id = await resolveCreateItemId({
+    pmRoot,
+    settings,
+    explicitId: resolvedOptions.id
+  });
+  let status = resolvedOptions.status !== void 0 ? parseStatusValue(resolvedOptions.status, statusRegistry) : resolveCreateDefaultStatus(typeDefinition, statusRegistry);
+  const priority = resolvedOptions.priority !== void 0 ? ensurePriority(resolvedOptions.priority) : 2;
+  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 = collectCreateScheduleWarnings(type, id, deadline, reminders.values, events.values);
+  const parentValidation = await resolveCreateParentWithWarnings({
+    itemId: id,
+    parent,
+    pmRoot,
+    settings,
+    typeRegistry,
+    policy: 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 ?? "";
+  const closeReasonResolution = resolveCreateCloseReason(status, statusRegistry, settings, resolvedOptions, resolution);
+  const closeReason = closeReasonResolution.closeReason;
+  validationWarnings.push(...closeReasonResolution.warnings);
+  const frontMatter = normalizeFrontMatter({
+    id,
+    title,
+    description,
+    type,
+    type_options: validatedTypeOptions.normalized,
+    status,
+    close_reason: closeReason,
+    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 explicitUnsetKeys = [...explicitUnsets].sort((left, right) => left.localeCompare(right));
+  const historyMessage = buildHistoryMessage(resolvedOptions.message, explicitUnsetKeys);
+  const changedFields = buildChangedFields(frontMatter, body, explicitUnsetKeys, [
+    ...Object.keys(registeredItemFieldValues),
+    /* c8 ignore start -- collectRuntimeCreateFieldValues always returns a `values` object, so the `?? {}` fallback is unreachable. */
+    ...Object.keys(runtimeCreateFieldValues.values ?? {})
+    /* c8 ignore stop */
+  ]);
+  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 (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 {
+    item: outputItem,
+    changed_fields: changedFields,
+    warnings: [...validationWarnings, ...hookWarnings],
+    ...parentSource !== void 0 ? { parent_source: parentSource } : {},
+    ...nextTransition !== void 0 ? { next_transition: nextTransition } : {}
+  };
+}
+var _testOnlyCreateCommand = {
+  buildHistoryMessage,
+  buildInvalidLogSeedKeysMessage,
+  buildTypeSpecificCreateExample,
+  collectMissingRequiredTypeOptionKeys,
+  createExampleTokensForFlag,
+  filterNonMissingTypeOptionErrors,
+  hasTemplatesShowHandler,
+  hasCreateOptionValue,
+  loadCreateTemplateOptionsFromRuntime,
+  looksLikeStructuredEntry,
+  mergeCreateOptionsWithTemplate,
+  normalizeCreatePolicyOptionKey,
+  normalizeDependencyKindInput,
+  normalizeExtensionCommandPath,
+  parseCreateUnsetTargets,
+  requireStringOption,
+  readTemplateOptionsFromRuntimeResult,
+  resolveRuntimeCreateUnsetDefinition: (token, registry) => resolveRuntimeUnsetFieldDefinition(token, "create", registry),
+  typeOptionExampleValue
+};
+
+export {
+  resolvePriority,
+  normalizeRiskInput,
+  normalizeSeverityInput,
+  parseConfidenceInput,
+  parseRegressionInput,
+  isLegacyNoneToken,
+  assertNoLegacyNoneToken,
+  assertNoLegacyNoneTokens,
+  applyLegacyNoneCollectionNormalizers,
+  COMMON_UNSET_FIELD_DEFINITIONS_BEFORE_CLOSE_REASON,
+  COMMON_UNSET_FIELD_DEFINITIONS_AFTER_CLOSE_REASON_BEFORE_AUTHOR,
+  COMMON_UNSET_FIELD_DEFINITIONS_AFTER_AUTHOR,
+  parseCommandUnsetTargets,
+  resolveRuntimeUnsetFieldDefinition,
+  ensureEnumValue,
+  parseReminderEntries,
+  parseEventEntries,
+  parseTypeOptionEntries,
+  parseLogSeed,
+  parseFiles,
+  parseTests,
+  parseDocs,
+  runCreate,
+  _testOnlyCreateCommand
+};
+//# sourceMappingURL=chunk-TULGS6X6.js.map
+
+//# debugId=3b2e2c0b-d9a3-51c6-ba51-0bad9aa69284