@unbrained/pm-cli 2026.7.5 → 2026.7.6

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

@@ -1,2132 +0,0 @@
-
-!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-MZ7VNEVY.js";
-import {
-  assertNoUnknownCsvKeys,
-  createStdinTokenResolver,
-  looksLikeGenericKeyValueEntry,
-  mergeAdditiveTags,
-  parseCsvKv,
-  parseOptionalNumber,
-  parseTags
-} from "./chunk-7WYXBPYQ.js";
-import {
-  getFocusedItem
-} from "./chunk-PDXT6Q55.js";
-import {
-  printError
-} from "./chunk-4OFLJHX6.js";
-import {
-  acquireLock,
-  appendHistoryEntry,
-  applyRegisteredItemFieldDefaultsAndValidation,
-  collectRegisteredItemFieldNames,
-  createHistoryEntry,
-  locateItem,
-  parseRegisteredItemFieldAssignments
-} from "./chunk-57C2RLW5.js";
-import {
-  assertParentReferenceIsNotSelf,
-  isPlaceholderReferenceToken,
-  normalizeParentReferenceValue,
-  validateMissingParentReference,
-  validateSprintOrReleaseValue
-} from "./chunk-7MDXZAZS.js";
-import {
-  canonicalDocument,
-  collectRuntimeCreateFieldValues,
-  generateItemId,
-  normalizeFrontMatter,
-  normalizeItemId,
-  normalizeStatusInput,
-  serializeItemDocument
-} from "./chunk-HK72NWAD.js";
-import {
-  nowIso,
-  resolveIsoOrRelative
-} from "./chunk-FJRKQREY.js";
-import {
-  PmCliError,
-  getActiveExtensionRegistrations,
-  projectAfterCommandItemSnapshot,
-  readSettings,
-  recordAfterCommandAffectedItem,
-  runActiveCommandHandler,
-  runActiveOnWriteHooks
-} from "./chunk-US3T3W5J.js";
-import {
-  buildInvalidTypeError
-} from "./chunk-NER3KUUS.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-YD5FML7K.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-NBFCNJ7Q.js.map
-
-//# debugId=3b2e2c0b-d9a3-51c6-ba51-0bad9aa69284