@unbrained/pm-cli 2026.6.12 → 2026.6.16

package/dist/cli-bundle/chunks/{validate-46KCRHL7.js → validate-7BLDG3AT.js}

@@ -1,35 +1,35 @@
 
-!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]="50b9ae79-2f9d-56b7-8b52-24c0a6416cd8")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="d32289f9-55ec-5478-8348-157ab845d3c7")}catch(e){}}();
 import {
   buildRemediationCommands
-} from "./chunk-PNYAAB4S.js";
+} from "./chunk-LWGMDLQ6.js";
 import {
   extractReferencedPmItemIdsFromCommand
-} from "./chunk-EWFY7SLA.js";
+} from "./chunk-BJWTFOZM.js";
 import {
   scanHistoryDrift
-} from "./chunk-C6SAP27O.js";
-import "./chunk-ZYNJNPYD.js";
-import "./chunk-4HFU4UO2.js";
-import "./chunk-I7NYDZDV.js";
-import "./chunk-F75JSIOZ.js";
-import "./chunk-FDH2X65L.js";
-import "./chunk-S2ZLDYGS.js";
-import "./chunk-VAOUX6TK.js";
+} from "./chunk-O46LTCXQ.js";
+import "./chunk-UUKORJSN.js";
+import "./chunk-ILHLIA47.js";
+import "./chunk-F7WSO5UX.js";
+import "./chunk-HDIDUME4.js";
+import "./chunk-Z3MUNQRV.js";
+import "./chunk-RKKIH2ZQ.js";
+import "./chunk-FTAZLAR7.js";
 import "./chunk-LXYVKYMQ.js";
 import {
   listAllFrontMatterWithBody
-} from "./chunk-HI7STVF2.js";
-import "./chunk-ATEES5SX.js";
+} from "./chunk-7K2MXFMX.js";
+import "./chunk-2JEGCDYT.js";
 import {
   normalizeStatusInput
-} from "./chunk-UUWGCWBU.js";
+} from "./chunk-GAVE4MYM.js";
 import {
   resolveItemTypeRegistry
-} from "./chunk-CCX4RSYZ.js";
+} from "./chunk-ZONXMSVB.js";
 import {
   nowIso
-} from "./chunk-WUNFKP7M.js";
+} from "./chunk-G2YVUY7I.js";
 import {
   DEFAULT_VALIDATE_CLOSURE_LIKE_METADATA_FIELD_PATTERNS,
   DEFAULT_VALIDATE_STALE_BLOCKER_REASON_PATTERNS,
@@ -40,10 +40,11 @@ import {
   getSettingsPath,
   pathExists,
   readSettings,
+  resolveEstimateDefaultMinutes,
   resolvePmRoot,
   resolveRuntimeStatusRegistry,
   toNonEmptyStringOrUndefined
-} from "./chunk-A6LXQFO7.js";
+} from "./chunk-KTVETP66.js";
 
 // dist/cli/commands/validate.js
 import fs from "node:fs/promises";
@@ -54,7 +55,7 @@ import { promisify } from "node:util";
 
 // dist/core/validate/fix-planning.js
 var DEFAULT_GRANTED_FIX_SCOPES = ["metadata", "resolution"];
-var SUPPORTED_FIX_SCOPES = ["metadata", "resolution", "lifecycle"];
+var SUPPORTED_FIX_SCOPES = ["metadata", "resolution", "estimates", "lifecycle"];
 var DEFAULT_RESOLUTION_BACKFILL_VALUE = "completed";
 function quoteForCommand(value) {
   return `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
@@ -101,6 +102,20 @@ function planCloseReasonBackfillFixes(rows) {
   }
   return fixes;
 }
+function planEstimateBackfillFixes(rows, overrides) {
+  return rows.map((row) => {
+    const minutes = resolveEstimateDefaultMinutes(row.type, overrides);
+    return {
+      item_id: row.id,
+      check: "metadata",
+      field: "estimated_minutes",
+      kind: "set_estimate",
+      value: String(minutes),
+      command: `pm update ${row.id} --estimate ${minutes}`,
+      gate: "estimates"
+    };
+  });
+}
 function planTerminalParentFixes(rows) {
   return rows.map((row) => {
     if (row.grandparent_id !== void 0 && row.grandparent_active === true) {
@@ -183,6 +198,54 @@ function toFixOutputRow(fix) {
   };
 }
 
+// dist/core/governance/issue-codes.js
+var ISSUE_CODE_PATTERN = /^([A-Z][A-Z0-9]*-\d+)\b/;
+function extractIssueCode(title) {
+  if (typeof title !== "string") {
+    return null;
+  }
+  const normalized = title.trim().toUpperCase();
+  if (normalized.length === 0) {
+    return null;
+  }
+  const match = ISSUE_CODE_PATTERN.exec(normalized);
+  return match ? match[1] : null;
+}
+function findDuplicateIssueCodes(items) {
+  const byCode = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    if (typeof item.title !== "string") {
+      continue;
+    }
+    const code = extractIssueCode(item.title);
+    if (code === null) {
+      continue;
+    }
+    let entries = byCode.get(code);
+    if (!entries) {
+      entries = [];
+      byCode.set(code, entries);
+    }
+    if (!entries.some((entry) => entry.id === item.id)) {
+      entries.push({ id: item.id, title: item.title });
+    }
+  }
+  const duplicates = [];
+  for (const [code, entries] of byCode) {
+    if (entries.length < 2) {
+      continue;
+    }
+    const sorted = [...entries].sort((left, right) => left.id.localeCompare(right.id));
+    duplicates.push({
+      code,
+      count: sorted.length,
+      ids: sorted.map((entry) => entry.id),
+      titles: sorted.map((entry) => entry.title)
+    });
+  }
+  return duplicates.sort((left, right) => left.code.localeCompare(right.code));
+}
+
 // dist/core/validate/missing-by-type.js
 function buildMissingByTypeCounts(occurrences) {
   const countsByType = /* @__PURE__ */ new Map();
@@ -249,6 +312,58 @@ function summarizeStaleLinkedPathClassifications(classified) {
   return classified.map((entry) => entry.classification === "moved" ? `${entry.path}:moved:${entry.candidates[0]}` : `${entry.path}:deleted`);
 }
 
+// dist/core/validate/missing-link-owners.js
+function preferClassification(current, next) {
+  return current === "moved" || next === "moved" ? "moved" : "deleted";
+}
+function ownerKey(input) {
+  return `${input.item_id} ${input.link_kind}`;
+}
+function buildMissingLinkedPathRows(rows, lookup) {
+  const buckets = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const bucket = buckets.get(row.path);
+    if (bucket) {
+      bucket.classification = preferClassification(bucket.classification, row.classification);
+      bucket.owners.set(ownerKey(row), row);
+    } else {
+      buckets.set(row.path, {
+        classification: row.classification,
+        owners: /* @__PURE__ */ new Map([[ownerKey(row), row]])
+      });
+    }
+  }
+  return [...buckets.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([path2, bucket]) => ({
+    path: path2,
+    classification: bucket.classification,
+    items: [...bucket.owners.values()].map((owner) => {
+      const metadata = lookup(owner.item_id);
+      return {
+        id: owner.item_id,
+        type: metadata?.type ?? "Unknown",
+        title: metadata?.title ?? "",
+        status: metadata?.status ?? "",
+        field: owner.link_kind
+      };
+    }).sort((leftOwner, rightOwner) => {
+      const byId = leftOwner.id.localeCompare(rightOwner.id);
+      return byId !== 0 ? byId : leftOwner.field.localeCompare(rightOwner.field);
+    })
+  }));
+}
+function escapeTitle(title) {
+  return title.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function summarizeMissingLinkedPathRows(rows) {
+  const lines = [];
+  for (const row of rows) {
+    for (const owner of row.items) {
+      lines.push(`${row.path}:${row.classification} owner=${owner.id} status=${owner.status} field=${owner.field} title="${escapeTitle(owner.title)}"`);
+    }
+  }
+  return lines;
+}
+
 // dist/cli/commands/validate.js
 var FILE_SCAN_DIRECTORIES = ["src", "tests", "docs"];
 var FILE_SCAN_ROOT_FILES = [
@@ -744,6 +859,26 @@ function resolveRequestedChecks(options) {
   }
   return requested;
 }
+var DUPLICATE_ISSUE_CODE_WARNING_TOKEN = "validate_metadata_duplicate_issue_codes";
+function summarizeDuplicateIssueCodes(duplicates, verboseDiagnostics) {
+  if (duplicates.length === 0) {
+    return { rows: [], truncated: false, warnings: [] };
+  }
+  const limit = verboseDiagnostics ? duplicates.length : DIAGNOSTIC_LIST_SUMMARY_LIMIT;
+  const shown = duplicates.slice(0, limit);
+  const rows = shown.map((duplicate) => ({
+    code: duplicate.code,
+    count: duplicate.count,
+    ids: duplicate.ids,
+    titles: duplicate.titles,
+    remediation_hint: `Items ${duplicate.ids.join(", ")} share issue code "${duplicate.code}"; rename or merge so each logical code maps to one item.`
+  }));
+  return {
+    rows,
+    truncated: shown.length < duplicates.length,
+    warnings: [`${DUPLICATE_ISSUE_CODE_WARNING_TOKEN}:${duplicates.length}`]
+  };
+}
 function buildMetadataCheck(items, metadataPolicy, statusRegistry, verboseDiagnostics) {
   const missingByField = Object.fromEntries(SUPPORTED_METADATA_REQUIRED_FIELDS.map((field) => [field, []]));
   const itemsById = new Map(items.map((item) => [item.id, item]));
@@ -763,6 +898,9 @@ function buildMetadataCheck(items, metadataPolicy, statusRegistry, verboseDiagno
     }
     warningTokens.push(`${METADATA_WARNING_TOKEN_BY_FIELD[field]}:${missingItems.length}`);
   }
+  const duplicateIssueCodes = findDuplicateIssueCodes(items);
+  const duplicateIssueCodeSummary = summarizeDuplicateIssueCodes(duplicateIssueCodes, verboseDiagnostics);
+  warningTokens.push(...duplicateIssueCodeSummary.warnings);
   const counts = {};
   for (const field of metadataPolicy.required_fields) {
     const value = missingByField[field]?.length ?? 0;
@@ -787,7 +925,10 @@ function buildMetadataCheck(items, metadataPolicy, statusRegistry, verboseDiagno
     required_fields: [...metadataPolicy.required_fields],
     supported_required_fields: [...SUPPORTED_METADATA_REQUIRED_FIELDS],
     counts,
-    missing_by_type: missingByType
+    missing_by_type: missingByType,
+    duplicate_issue_codes_count: duplicateIssueCodes.length,
+    duplicate_issue_codes: duplicateIssueCodeSummary.rows,
+    duplicate_issue_codes_truncated: duplicateIssueCodeSummary.truncated
   };
   if (metadataPolicy.configured_custom_fields.length > 0) {
     details.configured_custom_required_fields = [...metadataPolicy.configured_custom_fields];
@@ -810,6 +951,10 @@ function buildMetadataCheck(items, metadataPolicy, statusRegistry, verboseDiagno
     id: itemId,
     resolution: toNonEmptyStringOrUndefined(itemsById.get(itemId)?.resolution)
   })) : [];
+  const estimateBackfillRows = metadataPolicy.required_fields.includes("estimated_minutes") ? (missingByField.estimated_minutes ?? []).map((itemId) => ({
+    id: itemId,
+    type: toNonEmptyStringOrUndefined(itemsById.get(itemId)?.type)
+  })) : [];
   return {
     check: {
       name: "metadata",
@@ -817,7 +962,8 @@ function buildMetadataCheck(items, metadataPolicy, statusRegistry, verboseDiagno
       details
     },
     warnings: warningTokens,
-    closeReasonBackfillRows
+    closeReasonBackfillRows,
+    estimateBackfillRows
   };
 }
 function buildResolutionCheck(items, statusRegistry, verboseDiagnostics) {
@@ -1117,6 +1263,7 @@ async function buildFilesCheck(items, workspaceRoot, pmRoot, fileScanMode, inclu
   const linkedProjectPaths = /* @__PURE__ */ new Set();
   const missingLinkedPaths = [];
   const staleLinkRows = [];
+  const itemsById = new Map(items.map((item) => [item.id, item]));
   for (const item of items) {
     const linkedArtifactGroups = [
       { link_kind: "files", artifacts: item.files ?? [] },
@@ -1136,7 +1283,7 @@ async function buildFilesCheck(items, workspaceRoot, pmRoot, fileScanMode, inclu
         let missing = false;
         try {
           const stats = await fs.stat(absolutePath);
-          if (!stats.isFile()) {
+          if (!stats.isFile() && !stats.isDirectory()) {
             missing = true;
           }
         } catch {
@@ -1189,6 +1336,17 @@ async function buildFilesCheck(items, workspaceRoot, pmRoot, fileScanMode, inclu
   const summarizedMissing = summarizeFileList(uniqueMissingLinkedPaths, verboseFileLists);
   const summarizedOrphaned = summarizeFileList(orphanedFiles, verboseFileLists);
   const summarizedClassifications = summarizeFileList(summarizeStaleLinkedPathClassifications(classifiedStalePaths), verboseFileLists);
+  const missingLinkedPathRows = staleLinkPruneRows.map((row) => ({
+    item_id: row.item_id,
+    path: row.path,
+    link_kind: row.link_kind,
+    classification: row.classification
+  }));
+  const ownerRows = buildMissingLinkedPathRows(missingLinkedPathRows, (id) => {
+    const owner = itemsById.get(id);
+    return owner ? { type: owner.type, title: owner.title, status: owner.status } : void 0;
+  });
+  const ownerRowDetail = verboseFileLists ? ownerRows : summarizeFileList(summarizeMissingLinkedPathRows(ownerRows), false).values;
   return {
     check: {
       name: "files",
@@ -1223,6 +1381,8 @@ async function buildFilesCheck(items, workspaceRoot, pmRoot, fileScanMode, inclu
         missing_linked_paths_deleted_count: uniqueMissingLinkedPaths.length - movedStalePathCount,
         missing_linked_path_classifications: summarizedClassifications.values,
         missing_linked_path_classifications_truncated: summarizedClassifications.truncated,
+        missing_linked_path_rows_count: ownerRows.length,
+        missing_linked_path_rows: ownerRowDetail,
         orphaned_paths_count: orphanedFiles.length,
         orphaned_paths_total: summarizedOrphaned.total,
         orphaned_paths: summarizedOrphaned.values,
@@ -1334,14 +1494,17 @@ async function applyValidateFix(fix, global) {
   switch (fix.kind) {
     case "set_resolution":
     case "set_close_reason":
+    case "set_estimate":
     case "reparent":
     case "unset_parent": {
-      const { runUpdate } = await import("./update-I246PCLO.js");
+      const { runUpdate } = await import("./update-MPGM6SBE.js");
       const updateOptions = { message: VALIDATE_AUTO_FIX_MESSAGE };
       if (fix.kind === "set_resolution") {
         updateOptions.resolution = fix.value;
       } else if (fix.kind === "set_close_reason") {
         updateOptions.closeReason = fix.value;
+      } else if (fix.kind === "set_estimate") {
+        updateOptions.estimatedMinutes = fix.value;
       } else if (fix.kind === "reparent") {
         updateOptions.parent = fix.parent_id;
       } else {
@@ -1394,10 +1557,10 @@ async function applyValidateFixes(applicable, global) {
     const remove = batch.map((fix) => fix.path).filter((value) => typeof value === "string" && value.length > 0);
     try {
       if (first.kind === "prune_file_link") {
-        const { runFiles } = await import("./files-GUXUM2MB.js");
+        const { runFiles } = await import("./files-3TCQHUHA.js");
         await runFiles(first.item_id, { remove, message: VALIDATE_AUTO_FIX_MESSAGE }, global);
       } else {
-        const { runDocs } = await import("./docs-I3BAF5WH.js");
+        const { runDocs } = await import("./docs-RCLNSKID.js");
         await runDocs(first.item_id, { remove, message: VALIDATE_AUTO_FIX_MESSAGE }, global);
       }
       applied.push(...batch);
@@ -1407,6 +1570,29 @@ async function applyValidateFixes(applicable, global) {
   }
   return { applied, failed };
 }
+var _testOnlyValidateCommand = {
+  applyValidateFix,
+  applyValidateFixes,
+  attachValidateFixHints,
+  buildCommandReferencesCheck,
+  buildFilesCheck,
+  buildLifecycleCheck,
+  buildLifecycleDependencyGraph,
+  collectDefaultProjectFileCandidates,
+  collectTrackedGitFileCandidates,
+  detectLifecycleDependencyCycles,
+  findLifecycleDependencyCycleComponents,
+  isMetadataFieldMissing,
+  listFilesRecursive,
+  resolveDependencyCycleSeverity,
+  resolveFileScanMode,
+  resolveLifecycleDependencyCycleSamplePath,
+  resolveRequestedChecks,
+  resolveValidateMetadataProfile,
+  resolveWorkspaceRoot,
+  summarizeDuplicateIssueCodes,
+  toMeaningfulString
+};
 async function runValidate(options, global) {
   const fixesRequested = options.autoFix === true || options.pruneMissing === true;
   if (options.dryRun === true && !fixesRequested) {
@@ -1436,6 +1622,7 @@ async function runValidate(options, global) {
   const checks = [];
   const warnings = [...new Set(itemReadWarnings)];
   const fixHintsEnabled = options.fixHints === true;
+  const fullDiagnostics = options.verboseDiagnostics === true || options.allAffectedIds === true || global.json === true;
   const record = (built) => {
     if (fixHintsEnabled) {
       attachValidateFixHints(built.check, built.warnings);
@@ -1444,21 +1631,23 @@ async function runValidate(options, global) {
     warnings.push(...built.warnings);
   };
   let closeReasonBackfillRows = [];
+  let estimateBackfillRows = [];
   let resolutionBackfillRows = [];
   let terminalParentFixRows = [];
   let staleLinkPruneRows = [];
   if (requestedChecks.has("metadata")) {
-    const built = buildMetadataCheck(items, metadataPolicy, statusRegistry, Boolean(options.verboseDiagnostics));
+    const built = buildMetadataCheck(items, metadataPolicy, statusRegistry, fullDiagnostics);
     closeReasonBackfillRows = built.closeReasonBackfillRows;
+    estimateBackfillRows = built.estimateBackfillRows;
     record(built);
   }
   if (requestedChecks.has("resolution")) {
-    const built = buildResolutionCheck(items, statusRegistry, Boolean(options.verboseDiagnostics));
+    const built = buildResolutionCheck(items, statusRegistry, fullDiagnostics);
     resolutionBackfillRows = built.resolutionBackfillRows;
     record(built);
   }
   if (requestedChecks.has("lifecycle")) {
-    const built = buildLifecycleCheck(items, Boolean(options.checkStaleBlockers), dependencyCycleSeverity, statusRegistry, lifecyclePatternPolicy, Boolean(options.verboseDiagnostics));
+    const built = buildLifecycleCheck(items, Boolean(options.checkStaleBlockers), dependencyCycleSeverity, statusRegistry, lifecyclePatternPolicy, fullDiagnostics);
     terminalParentFixRows = built.terminalParentFixRows;
     record(built);
   }
@@ -1468,10 +1657,10 @@ async function runValidate(options, global) {
     record(built);
   }
   if (requestedChecks.has("command_references")) {
-    record(buildCommandReferencesCheck(items, settings.id_prefix, Boolean(options.verboseDiagnostics)));
+    record(buildCommandReferencesCheck(items, settings.id_prefix, fullDiagnostics));
   }
   if (requestedChecks.has("history_drift")) {
-    record(await buildHistoryDriftCheck(pmRoot, items, Boolean(options.verboseDiagnostics)));
+    record(await buildHistoryDriftCheck(pmRoot, items, fullDiagnostics));
   }
   let fixes;
   if (fixesRequested) {
@@ -1479,6 +1668,7 @@ async function runValidate(options, global) {
     if (options.autoFix === true) {
       planned.push(...planCloseReasonBackfillFixes(closeReasonBackfillRows));
       planned.push(...planResolutionBackfillFixes(resolutionBackfillRows));
+      planned.push(...planEstimateBackfillFixes(estimateBackfillRows, settings.validation.estimate_defaults_by_type));
       planned.push(...planTerminalParentFixes(terminalParentFixRows));
     }
     if (options.pruneMissing === true) {
@@ -1526,8 +1716,9 @@ async function runValidate(options, global) {
   };
 }
 export {
+  _testOnlyValidateCommand,
   runValidate
 };
-//# sourceMappingURL=validate-46KCRHL7.js.map
+//# sourceMappingURL=validate-7BLDG3AT.js.map
 
-//# debugId=50b9ae79-2f9d-56b7-8b52-24c0a6416cd8
+//# debugId=d32289f9-55ec-5478-8348-157ab845d3c7