@unbrained/pm-cli 2026.7.4 → 2026.7.5

package/dist/cli-bundle/chunks/{chunk-2VK677OA.js → chunk-MTTXDAK4.js}

@@ -10,10 +10,7 @@ import {
   parseLinkedTestMinLines,
   parseLinkedTestRegexList,
   parseLinkedTestStringList
-} from "./chunk-7ITQSEBL.js";
-import {
-  getFocusedItem
-} from "./chunk-MZ4NH46V.js";
+} from "./chunk-BVEUCSH2.js";
 import {
   assertNoUnknownCsvKeys,
   createStdinTokenResolver,
@@ -22,40 +19,54 @@ import {
   parseCsvKv,
   parseOptionalNumber,
   parseTags
-} from "./chunk-N2LOJUBB.js";
-import {
-  normalizeParentReferenceValue,
-  validateMissingParentReference,
-  validateSprintOrReleaseValue
-} from "./chunk-TUV7SIWZ.js";
+} from "./chunk-T3ABIMGW.js";
 import {
-  buildInvalidTypeError
-} from "./chunk-A2W3XKAD.js";
+  getFocusedItem
+} from "./chunk-ZMD35NYG.js";
 import {
   printError
-} from "./chunk-WSDIALO4.js";
+} from "./chunk-ZD34OFFQ.js";
 import {
   acquireLock,
   appendHistoryEntry,
   applyRegisteredItemFieldDefaultsAndValidation,
   collectRegisteredItemFieldNames,
   createHistoryEntry,
-  generateItemId,
   locateItem,
-  normalizeItemId,
   parseRegisteredItemFieldAssignments
-} from "./chunk-CN4OAA2G.js";
+} from "./chunk-3U3VEWK6.js";
+import {
+  assertParentReferenceIsNotSelf,
+  isPlaceholderReferenceToken,
+  normalizeParentReferenceValue,
+  validateMissingParentReference,
+  validateSprintOrReleaseValue
+} from "./chunk-OWTIRHX4.js";
 import {
   canonicalDocument,
   collectRuntimeCreateFieldValues,
+  generateItemId,
   normalizeFrontMatter,
+  normalizeItemId,
   normalizeStatusInput,
   serializeItemDocument
-} from "./chunk-CQFZRLXQ.js";
+} from "./chunk-EZFKWSC7.js";
 import {
   nowIso,
   resolveIsoOrRelative
-} from "./chunk-MZG6I2Q2.js";
+} from "./chunk-DRBV5UC2.js";
+import {
+  PmCliError,
+  getActiveExtensionRegistrations,
+  projectAfterCommandItemSnapshot,
+  readSettings,
+  recordAfterCommandAffectedItem,
+  runActiveCommandHandler,
+  runActiveOnWriteHooks
+} from "./chunk-P5YORJRH.js";
+import {
+  buildInvalidTypeError
+} from "./chunk-T35XLYZF.js";
 import {
   CONFIDENCE_TEXT_VALUES,
   CREATE_DIRECT_CLOSE_REASON_DEFAULT,
@@ -63,22 +74,17 @@ import {
   EXIT_CODE,
   FRONT_MATTER_KEY_ORDER,
   ISSUE_SEVERITY_VALUES,
-  PmCliError,
   RECURRENCE_FREQUENCY_VALUES,
   RECURRENCE_WEEKDAY_VALUES,
   RISK_VALUES,
   SCOPE_VALUES,
   canonicalizeCommandOptionKey,
   commandOptionFlagLabel,
-  getActiveExtensionRegistrations,
   getHistoryPath,
   getItemPath,
   getSettingsPath,
   normalizeStatusInputWithRegistry,
   pathExists,
-  projectAfterCommandItemSnapshot,
-  readSettings,
-  recordAfterCommandAffectedItem,
   removeFileIfExists,
   resolveCommandOptionPolicyState,
   resolveItemTypeRegistry,
@@ -88,12 +94,10 @@ import {
   resolveRuntimeStatusRegistry,
   resolveTypeDefinition,
   resolveTypeName,
-  runActiveCommandHandler,
-  runActiveOnWriteHooks,
   validateTypeOptions,
   weekdayOrderIndex,
   writeFileAtomic
-} from "./chunk-BDDYM4LH.js";
+} from "./chunk-5VVUKE3U.js";
 
 // dist/core/item/priority.js
 !(function() {
@@ -799,7 +803,7 @@ function parseTypeOptionEntries(raw) {
 !(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] = "c697cd34-7adc-574e-9180-0b0a387ca5e9");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "f7516a2a-f728-55b0-99a6-50501443acb4");
   } catch (e2) {
   }
 })();
@@ -1136,6 +1140,113 @@ function normalizeCreatePolicyOptionKey(raw, typeName, sourceLabel) {
   }
   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 };
@@ -1203,107 +1314,19 @@ function resolveEffectiveCreateMode(createMode, schedulePreset, defaultMode) {
 }
 function requireCreateOptionByType(typeDefinition, options, createMode, clearOptionKeys) {
   const typeName = typeDefinition.name;
-  const scalarValues = {
-    title: options.title,
-    description: options.description,
-    type: options.type,
-    status: options.status,
-    priority: options.priority,
-    tags: options.tags,
-    body: options.body,
-    deadline: options.deadline,
-    estimatedMinutes: options.estimatedMinutes,
-    acceptanceCriteria: options.acceptanceCriteria,
-    definitionOfReady: options.definitionOfReady,
-    order: options.order ?? options.rank,
-    goal: options.goal,
-    objective: options.objective,
-    value: options.value,
-    impact: options.impact,
-    outcome: options.outcome,
-    whyNow: options.whyNow,
-    author: options.author,
-    message: options.message,
-    assignee: options.assignee,
-    parent: options.parent,
-    reviewer: options.reviewer,
-    risk: options.risk,
-    confidence: options.confidence,
-    sprint: options.sprint,
-    release: options.release,
-    blockedBy: options.blockedBy,
-    blockedReason: options.blockedReason,
-    unblockNote: options.unblockNote,
-    reporter: options.reporter,
-    severity: options.severity,
-    environment: options.environment,
-    reproSteps: options.reproSteps,
-    resolution: options.resolution,
-    expectedResult: options.expectedResult,
-    actualResult: options.actualResult,
-    affectedVersion: options.affectedVersion,
-    fixedVersion: options.fixedVersion,
-    component: options.component,
-    regression: options.regression,
-    customerImpact: options.customerImpact
-  };
-  const repeatableValues = {
-    dep: options.dep,
-    comment: options.comment,
-    note: options.note,
-    learning: options.learning,
-    file: options.file,
-    test: options.test,
-    doc: options.doc,
-    reminder: options.reminder,
-    event: options.event,
-    typeOption: options.typeOption,
-    field: options.field
-  };
-  const hasOptionValue = (optionKey) => {
-    if (optionKey === "tags") {
-      return scalarValues.tags !== void 0 || Array.isArray(options.addTags) && options.addTags.length > 0;
-    }
-    if (optionKey in scalarValues) {
-      return scalarValues[optionKey] !== void 0;
-    }
-    if (optionKey in repeatableValues) {
-      const value = repeatableValues[optionKey];
-      return Array.isArray(value) && value.length > 0;
-    }
-    return false;
-  };
-  const hasOptionMutation = (optionKey) => hasOptionValue(optionKey) || clearOptionKeys.has(optionKey);
-  const baseRequiredOptions = /* @__PURE__ */ new Set(["title", "type"]);
-  if (createMode === "strict") {
-    for (const field of typeDefinition.required_create_fields) {
-      baseRequiredOptions.add(normalizeCreatePolicyOptionKey(field, typeName, "required_create_fields"));
-    }
-    for (const field of typeDefinition.required_create_repeatables) {
-      baseRequiredOptions.add(normalizeCreatePolicyOptionKey(field, typeName, "required_create_repeatables"));
-    }
-  }
+  const 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);
   }
-  for (const option of policyState.disabled) {
-    if (hasOptionMutation(option)) {
-      throw new PmCliError(`Option ${commandOptionFlagLabel("create", option)} is disabled for type "${typeName}" by command_option_policies`, EXIT_CODE.USAGE);
-    }
-  }
-  if (createMode === "strict") {
-    const strictRequiredClears = policyState.required.filter((required) => clearOptionKeys.has(required));
-    if (strictRequiredClears.length > 0) {
-      const requiredFlags = [...new Set(strictRequiredClears.map((required) => commandOptionFlagLabel("create", required)))].sort((left, right) => left.localeCompare(right));
-      throw new PmCliError(`Strict create mode requires concrete values for ${requiredFlags.join(", ")}; --unset/--clear-* directives cannot satisfy required options`, EXIT_CODE.USAGE);
-    }
-  }
+  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 hasOptionValue(optionKey);
+    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));
@@ -1520,8 +1543,9 @@ async function inheritFocusedParent(parent, resolvedOptions, unsetKeys, pmRoot)
   }
   return { parent: focused, parentSource: "focus" };
 }
-async function validateCreateParentReference(pmRoot, settings, typeRegistry, parent, policy) {
+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: [] };
@@ -1533,9 +1557,26 @@ 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.parent, params.policy);
+  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) {
@@ -1813,9 +1854,13 @@ 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);
+  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 });
@@ -1913,7 +1958,11 @@ async function runCreate(options, global2) {
     createMode
   });
   assertNoInvalidTypeOptions(validatedTypeOptions.errors, type, typeDefinition, statusRegistry);
-  const id = await generateItemId(pmRoot, settings.id_prefix);
+  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;
@@ -1942,6 +1991,7 @@ async function runCreate(options, global2) {
   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,
@@ -2105,6 +2155,7 @@ var _testOnlyCreateCommand = {
   createExampleTokensForFlag,
   filterNonMissingTypeOptionErrors,
   hasTemplatesShowHandler,
+  hasCreateOptionValue,
   loadCreateTemplateOptionsFromRuntime,
   looksLikeStructuredEntry,
   mergeCreateOptionsWithTemplate,
@@ -2144,4 +2195,4 @@ export {
   runCreate,
   _testOnlyCreateCommand
 };
-//# sourceMappingURL=chunk-2VK677OA.js.map
+//# sourceMappingURL=chunk-MTTXDAK4.js.map