@unbrained/pm-cli 2026.7.1 → 2026.7.3

package/dist/cli-bundle/chunks/{validate-X5W76YJL.js → validate-GAJ6FUSI.js}

@@ -1,8 +1,8 @@
 
-!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]="7af30e70-6b7d-5750-9dab-2031781c0d9d")}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]="a4633e01-6951-59e5-83cd-351f590aec99")}catch(e){}}();
 import {
   extractReferencedPmItemIdsFromCommand
-} from "./chunk-3XZCOZ5J.js";
+} from "./chunk-NOIEVOK5.js";
 import {
   buildRemediationCommands
 } from "./chunk-R2EMWY7Q.js";
@@ -11,30 +11,30 @@ import {
 } from "./chunk-IBMFIKVS.js";
 import {
   scanHistoryDrift
-} from "./chunk-OTUHB4HS.js";
-import "./chunk-EJUDVUYZ.js";
-import "./chunk-ZRP4VG5U.js";
-import "./chunk-SLMUGTK3.js";
-import "./chunk-V3NOKJF2.js";
-import "./chunk-NU2UEROZ.js";
+} from "./chunk-BE2SR6QL.js";
+import "./chunk-KEZOIPCR.js";
+import "./chunk-JBZ2NTKX.js";
+import "./chunk-7CLLC75T.js";
+import "./chunk-MHRS5FUX.js";
+import "./chunk-YF746GTH.js";
 import "./chunk-P4SESZGT.js";
-import "./chunk-2D4HATP2.js";
-import "./chunk-MAUKX7JC.js";
-import "./chunk-6AQZPVHQ.js";
-import "./chunk-4A3BJ675.js";
-import "./chunk-HXTQJXWT.js";
+import "./chunk-EJ2OCBHF.js";
+import "./chunk-GVJE5T7Q.js";
+import "./chunk-6CDCWKSX.js";
+import "./chunk-QNNQAAZ5.js";
+import "./chunk-572FKBRL.js";
 import {
   listAllFrontMatterWithBody
-} from "./chunk-JSU5P7VS.js";
+} from "./chunk-4WB6S4YX.js";
 import {
   CURRENT_ITEM_FORMAT_VERSION,
   effectiveItemFormatVersion,
   normalizeStatusInput,
   scanItemFormatVersions
-} from "./chunk-QCWF6IYD.js";
+} from "./chunk-YSDFIY7N.js";
 import {
   nowIso
-} from "./chunk-AXIDKKAT.js";
+} from "./chunk-CXR3CMBQ.js";
 import {
   DEFAULT_VALIDATE_CLOSURE_LIKE_METADATA_FIELD_PATTERNS,
   DEFAULT_VALIDATE_STALE_BLOCKER_REASON_PATTERNS,
@@ -50,7 +50,7 @@ import {
   resolvePmRoot,
   resolveRuntimeStatusRegistry,
   toNonEmptyStringOrUndefined
-} from "./chunk-7R4QEMZZ.js";
+} from "./chunk-L4SLHV6G.js";
 
 // dist/cli/commands/validate.js
 import fs from "node:fs/promises";
@@ -470,6 +470,8 @@ var METADATA_TRUNCATED_KEY_BY_FIELD = {
 var GIT_LS_FILES_MAX_BUFFER = 32 * 1024 * 1024;
 var FILE_LIST_SUMMARY_LIMIT = 40;
 var DIAGNOSTIC_LIST_SUMMARY_LIMIT = 5;
+var LINKED_ARTIFACT_MAX_PATH_LENGTH = 4096;
+var LINKED_ARTIFACT_MAX_SEGMENT_LENGTH = 255;
 var execFileAsync = promisify(execFile);
 function normalizeRelativePath(value) {
   return value.replaceAll("\\", "/").replace(/^\.\/+/, "").replace(/^\/+/, "");
@@ -912,61 +914,59 @@ function summarizeDuplicateIssueCodes(duplicates, verboseDiagnostics) {
     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]));
-  const enforcePlanningFieldsOnTerminal = metadataPolicy.profile === "strict";
+function initializeMissingMetadataByField() {
+  return Object.fromEntries(SUPPORTED_METADATA_REQUIRED_FIELDS.map((field) => [field, []]));
+}
+function collectMissingMetadataByField(items, statusRegistry, enforcePlanningFieldsOnTerminal) {
+  const missingByField = initializeMissingMetadataByField();
   for (const item of items) {
     for (const field of SUPPORTED_METADATA_REQUIRED_FIELDS) {
-      if (!isMetadataFieldMissing(item, field, statusRegistry, enforcePlanningFieldsOnTerminal)) {
-        continue;
+      if (isMetadataFieldMissing(item, field, statusRegistry, enforcePlanningFieldsOnTerminal)) {
+        missingByField[field].push(item.id);
       }
-      missingByField[field].push(item.id);
     }
   }
+  return missingByField;
+}
+function buildMetadataWarningTokens(metadataPolicy, missingByField, duplicateWarnings) {
   const warningTokens = [...metadataPolicy.warnings];
   for (const field of metadataPolicy.required_fields) {
     const missingItems = missingByField[field];
-    if (missingItems.length === 0) {
-      continue;
+    if (missingItems.length > 0) {
+      warningTokens.push(`${METADATA_WARNING_TOKEN_BY_FIELD[field]}:${missingItems.length}`);
     }
-    warningTokens.push(`${METADATA_WARNING_TOKEN_BY_FIELD[field]}:${missingItems.length}`);
   }
-  const duplicateIssueCodes = findDuplicateIssueCodes(items);
-  const duplicateIssueCodeSummary = summarizeDuplicateIssueCodes(duplicateIssueCodes, verboseDiagnostics);
-  warningTokens.push(...duplicateIssueCodeSummary.warnings);
+  warningTokens.push(...duplicateWarnings);
+  return warningTokens;
+}
+function buildMetadataCounts(metadataPolicy, missingByField) {
   const counts = {};
   for (const field of metadataPolicy.required_fields) {
-    const value = missingByField[field]?.length ?? 0;
+    const missing = missingByField[field];
+    const value = missing ? missing.length : 0;
     const countKey = METADATA_COUNT_KEY_BY_FIELD[field];
     if (value > 0 && countKey) {
       counts[countKey] = value;
     }
   }
-  const missingFieldOccurrences = [];
+  return counts;
+}
+function buildMissingFieldOccurrences(metadataPolicy, missingByField, itemsById) {
+  const occurrences = [];
   for (const field of metadataPolicy.required_fields) {
-    for (const itemId of missingByField[field] ?? []) {
+    const missing = missingByField[field];
+    if (!missing) {
+      continue;
+    }
+    for (const itemId of missing) {
       const itemType = itemsById.get(itemId)?.type;
-      missingFieldOccurrences.push({ item_type: typeof itemType === "string" && itemType.length > 0 ? itemType : "Unknown", field });
+      const normalizedItemType = typeof itemType === "string" && itemType.length > 0 ? itemType : "Unknown";
+      occurrences.push({ item_type: normalizedItemType, field });
     }
   }
-  const missingByType = buildMissingByTypeCounts(missingFieldOccurrences);
-  const details = {
-    checked_items: items.length,
-    metadata_profile: metadataPolicy.profile,
-    metadata_profile_source: metadataPolicy.profile_source,
-    metadata_profile_fallback_to_core: metadataPolicy.fallback_to_core,
-    required_fields: [...metadataPolicy.required_fields],
-    supported_required_fields: [...SUPPORTED_METADATA_REQUIRED_FIELDS],
-    counts,
-    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];
-  }
+  return occurrences;
+}
+function attachMissingMetadataItemIds(details, metadataPolicy, missingByField, verboseDiagnostics) {
   for (const field of metadataPolicy.required_fields) {
     const missing = missingByField[field];
     if (!missing || missing.length === 0) {
@@ -981,14 +981,62 @@ function buildMetadataCheck(items, metadataPolicy, statusRegistry, verboseDiagno
     details[idsKey] = summarized.values;
     details[truncatedKey] = summarized.truncated;
   }
-  const closeReasonBackfillRows = metadataPolicy.required_fields.includes("close_reason") ? (missingByField.close_reason ?? []).map((itemId) => ({
+}
+function buildCloseReasonBackfillRows(metadataPolicy, missingByField, itemsById) {
+  if (!metadataPolicy.required_fields.includes("close_reason")) {
+    return [];
+  }
+  const missing = missingByField.close_reason;
+  if (!missing) {
+    return [];
+  }
+  return missing.map((itemId) => ({
     id: itemId,
     resolution: toNonEmptyStringOrUndefined(itemsById.get(itemId)?.resolution)
-  })) : [];
-  const estimateBackfillRows = metadataPolicy.required_fields.includes("estimated_minutes") ? (missingByField.estimated_minutes ?? []).map((itemId) => ({
+  }));
+}
+function buildEstimateBackfillRows(metadataPolicy, missingByField, itemsById) {
+  if (!metadataPolicy.required_fields.includes("estimated_minutes")) {
+    return [];
+  }
+  const missing = missingByField.estimated_minutes;
+  if (!missing) {
+    return [];
+  }
+  return missing.map((itemId) => ({
     id: itemId,
     type: toNonEmptyStringOrUndefined(itemsById.get(itemId)?.type)
-  })) : [];
+  }));
+}
+function buildMetadataCheck(items, metadataPolicy, statusRegistry, verboseDiagnostics) {
+  const itemsById = new Map(items.map((item) => [item.id, item]));
+  const enforcePlanningFieldsOnTerminal = metadataPolicy.profile === "strict";
+  const missingByField = collectMissingMetadataByField(items, statusRegistry, enforcePlanningFieldsOnTerminal);
+  const duplicateIssueCodes = findDuplicateIssueCodes(items);
+  const duplicateIssueCodeSummary = summarizeDuplicateIssueCodes(duplicateIssueCodes, verboseDiagnostics);
+  const warningTokens = buildMetadataWarningTokens(metadataPolicy, missingByField, duplicateIssueCodeSummary.warnings);
+  const counts = buildMetadataCounts(metadataPolicy, missingByField);
+  const missingFieldOccurrences = buildMissingFieldOccurrences(metadataPolicy, missingByField, itemsById);
+  const missingByType = buildMissingByTypeCounts(missingFieldOccurrences);
+  const details = {
+    checked_items: items.length,
+    metadata_profile: metadataPolicy.profile,
+    metadata_profile_source: metadataPolicy.profile_source,
+    metadata_profile_fallback_to_core: metadataPolicy.fallback_to_core,
+    required_fields: [...metadataPolicy.required_fields],
+    supported_required_fields: [...SUPPORTED_METADATA_REQUIRED_FIELDS],
+    counts,
+    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];
+  }
+  attachMissingMetadataItemIds(details, metadataPolicy, missingByField, verboseDiagnostics);
+  const closeReasonBackfillRows = buildCloseReasonBackfillRows(metadataPolicy, missingByField, itemsById);
+  const estimateBackfillRows = buildEstimateBackfillRows(metadataPolicy, missingByField, itemsById);
   return {
     check: {
       name: "metadata",
@@ -1229,6 +1277,24 @@ function sharedDirectoryPrefixLength(left, right) {
   }
   return count;
 }
+function scoreOrphanOwnerCandidate(pathValue, linkedPath) {
+  const linkedDir = directoryOf(linkedPath);
+  const orphanDir = directoryOf(pathValue);
+  const directoryPrefix = linkedPath.endsWith("/") ? linkedPath : `${linkedPath}/`;
+  const isDirectoryPrefix = pathValue.startsWith(directoryPrefix);
+  const sameDirectory = linkedDir.length > 0 && linkedDir === orphanDir;
+  const sharedPrefixLength = sharedDirectoryPrefixLength(pathValue, linkedPath);
+  if (!isDirectoryPrefix && !sameDirectory && sharedPrefixLength === 0) {
+    return null;
+  }
+  if (isDirectoryPrefix) {
+    return { score: linkedPath.length + 1e3, confidence: "path_prefix" };
+  }
+  return sameDirectory ? { score: sharedPrefixLength + 500, confidence: "same_directory" } : { score: sharedPrefixLength, confidence: "shared_directory" };
+}
+function shouldReplaceOrphanOwnerCandidate(best, item, score) {
+  return best === void 0 || score > best.score || score === best.score && item.id.localeCompare(best.item.id) < 0;
+}
 function findOrphanOwnerCandidate(pathValue, classification, items) {
   const linkKind = classification === "docs_unowned" ? "docs" : "files";
   let best;
@@ -1242,21 +1308,15 @@ function findOrphanOwnerCandidate(pathValue, classification, items) {
       if (linkedPath.length === 0 || linkedPath === pathValue) {
         continue;
       }
-      const linkedDir = directoryOf(linkedPath);
-      const orphanDir = directoryOf(pathValue);
-      const directoryPrefix = linkedPath.endsWith("/") ? linkedPath : `${linkedPath}/`;
-      const isDirectoryPrefix = pathValue.startsWith(directoryPrefix);
-      const sameDirectory = linkedDir.length > 0 && linkedDir === orphanDir;
-      const sharedPrefixLength = sharedDirectoryPrefixLength(pathValue, linkedPath);
-      if (!isDirectoryPrefix && !sameDirectory && sharedPrefixLength === 0) {
+      const scored = scoreOrphanOwnerCandidate(pathValue, linkedPath);
+      if (scored === null) {
         continue;
       }
-      const score = isDirectoryPrefix ? linkedPath.length + 1e3 : sameDirectory ? sharedPrefixLength + 500 : sharedPrefixLength;
-      if (best === void 0 || score > best.score || score === best.score && item.id.localeCompare(best.item.id) < 0) {
+      if (shouldReplaceOrphanOwnerCandidate(best, item, scored.score)) {
         best = {
           item,
-          score,
-          confidence: isDirectoryPrefix ? "path_prefix" : sameDirectory ? "same_directory" : "shared_directory"
+          score: scored.score,
+          confidence: scored.confidence
         };
       }
     }
@@ -1289,74 +1349,74 @@ function buildOrphanedPathRows(orphanedFiles, items) {
 function summarizeOrphanedPathRows(rows) {
   return rows.map((row) => `${row.path}:${row.classification} owner_candidate=${row.owner_candidate?.id ?? "unowned"} hint=${JSON.stringify(row.remediation_hint)}`);
 }
-function buildLifecycleCheck(items, includeStaleBlockers, dependencyCycleSeverity, parentCycleSeverity, statusRegistry, lifecyclePatternPolicy, verboseDiagnostics, idPrefix = "pm") {
+function closureLikeFieldsForItem(item, lifecyclePatternPolicy) {
+  return Object.entries(lifecyclePatternPolicy.closure_like_metadata_field_patterns).filter(([field, patterns]) => {
+    const value = toMeaningfulString(item[field]);
+    return value ? patterns.some((pattern) => value.toLowerCase().includes(pattern)) : false;
+  }).map(([field]) => field).sort((left, right) => left.localeCompare(right));
+}
+function buildTerminalParentFixRow(item, parent, itemsById, canonicalIdByLowercase, statusRegistry) {
+  const grandparentId = toMeaningfulString(parent.parent);
+  const grandparent = grandparentId ? itemsById.get(canonicalIdByLowercase.get(grandparentId.toLowerCase()) ?? grandparentId) : void 0;
+  return {
+    id: item.id,
+    parent_id: parent.id,
+    grandparent_id: grandparent?.id,
+    grandparent_active: grandparent !== void 0 && !isTerminalStatus(grandparent.status, statusRegistry)
+  };
+}
+function staleBlockerReasonsForItem(item, blockedStatuses, statusRegistry, lifecyclePatternPolicy) {
+  const blockedBy = toMeaningfulString(item.blocked_by);
+  const blockedReason = toMeaningfulString(item.blocked_reason);
+  const blockedReasonNormalized = blockedReason?.toLowerCase();
+  const normalizedStatus = normalizeStatusForRegistry(item.status, statusRegistry);
+  const reasons = [];
+  if (!blockedStatuses.has(normalizedStatus)) {
+    if (blockedBy) {
+      reasons.push("non_blocked_status_has_blocked_by");
+    }
+    if (blockedReason) {
+      reasons.push("non_blocked_status_has_blocked_reason");
+    }
+    return reasons;
+  }
+  if (!blockedBy && !blockedReason) {
+    reasons.push("blocked_status_missing_blocker_context");
+  }
+  if (blockedReasonNormalized?.includes("no active blocker")) {
+    reasons.push("blocked_status_reason_reports_no_active_blocker");
+  }
+  if (blockedReasonNormalized && lifecyclePatternPolicy.stale_blocker_reason_patterns.some((pattern) => blockedReasonNormalized.includes(pattern))) {
+    reasons.push("blocked_status_reason_matches_stale_pattern");
+  }
+  return reasons;
+}
+function collectLifecycleScanRows(items, includeStaleBlockers, statusRegistry, lifecyclePatternPolicy) {
   const itemsById = new Map(items.map((item) => [item.id, item]));
+  const canonicalIdByLowercase = new Map(items.map((item) => [item.id.toLowerCase(), item.id]));
   const blockedStatuses = statusRegistry.blocked_statuses.size > 0 ? statusRegistry.blocked_statuses : /* @__PURE__ */ new Set(["blocked"]);
-  const activeItems = items.filter((item) => !isTerminalStatus(item.status, statusRegistry));
-  const closureLikeRows = [];
-  const terminalParentRows = [];
-  const terminalParentFixRows = [];
-  const staleBlockerRows = [];
-  for (const item of activeItems) {
-    const closureLikeFields = Object.entries(lifecyclePatternPolicy.closure_like_metadata_field_patterns).filter(([field, patterns]) => {
-      const value = toMeaningfulString(item[field]);
-      if (!value) {
-        return false;
-      }
-      const normalized = value.toLowerCase();
-      return patterns.some((pattern) => normalized.includes(pattern));
-    }).map(([field]) => field).sort((left, right) => left.localeCompare(right));
+  const rows = {
+    activeItems: items.filter((item) => !isTerminalStatus(item.status, statusRegistry)),
+    closureLikeRows: [],
+    terminalParentRows: [],
+    terminalParentFixRows: [],
+    staleBlockerRows: []
+  };
+  for (const item of rows.activeItems) {
+    const closureLikeFields = closureLikeFieldsForItem(item, lifecyclePatternPolicy);
     if (closureLikeFields.length > 0) {
-      closureLikeRows.push({
-        id: item.id,
-        fields: closureLikeFields
-      });
+      rows.closureLikeRows.push({ id: item.id, fields: closureLikeFields });
     }
     const parentId = toMeaningfulString(item.parent);
-    if (parentId) {
-      const parent = itemsById.get(parentId);
-      if (parent && isTerminalStatus(parent.status, statusRegistry)) {
-        terminalParentRows.push({
-          id: item.id,
-          parent_id: parent.id,
-          parent_status: parent.status
-        });
-        const grandparentId = toMeaningfulString(parent.parent);
-        const grandparent = grandparentId ? itemsById.get(grandparentId) : void 0;
-        terminalParentFixRows.push({
-          id: item.id,
-          parent_id: parent.id,
-          grandparent_id: grandparent?.id,
-          grandparent_active: grandparent !== void 0 && !isTerminalStatus(grandparent.status, statusRegistry)
-        });
-      }
+    const parent = parentId ? itemsById.get(canonicalIdByLowercase.get(parentId.toLowerCase()) ?? parentId) : void 0;
+    if (parent && isTerminalStatus(parent.status, statusRegistry)) {
+      rows.terminalParentRows.push({ id: item.id, parent_id: parent.id, parent_status: parent.status });
+      rows.terminalParentFixRows.push(buildTerminalParentFixRow(item, parent, itemsById, canonicalIdByLowercase, statusRegistry));
     }
     if (includeStaleBlockers) {
-      const blockedBy = toMeaningfulString(item.blocked_by);
-      const blockedReason = toMeaningfulString(item.blocked_reason);
-      const blockedReasonNormalized = blockedReason?.toLowerCase();
-      const reasons = [];
-      const normalizedStatus = normalizeStatusForRegistry(item.status, statusRegistry);
-      if (!blockedStatuses.has(normalizedStatus)) {
-        if (blockedBy) {
-          reasons.push("non_blocked_status_has_blocked_by");
-        }
-        if (blockedReason) {
-          reasons.push("non_blocked_status_has_blocked_reason");
-        }
-      } else {
-        if (!blockedBy && !blockedReason) {
-          reasons.push("blocked_status_missing_blocker_context");
-        }
-        if (blockedReasonNormalized?.includes("no active blocker")) {
-          reasons.push("blocked_status_reason_reports_no_active_blocker");
-        }
-        if (blockedReasonNormalized && lifecyclePatternPolicy.stale_blocker_reason_patterns.some((pattern) => blockedReasonNormalized.includes(pattern))) {
-          reasons.push("blocked_status_reason_matches_stale_pattern");
-        }
-      }
+      const reasons = staleBlockerReasonsForItem(item, blockedStatuses, statusRegistry, lifecyclePatternPolicy);
       if (reasons.length > 0) {
-        staleBlockerRows.push({
+        rows.staleBlockerRows.push({
           id: item.id,
           status: item.status,
           reasons: [...new Set(reasons)].sort((left, right) => left.localeCompare(right))
@@ -1364,32 +1424,124 @@ function buildLifecycleCheck(items, includeStaleBlockers, dependencyCycleSeverit
       }
     }
   }
-  closureLikeRows.sort((left, right) => left.id.localeCompare(right.id));
-  terminalParentRows.sort((left, right) => left.id.localeCompare(right.id) || left.parent_id.localeCompare(right.parent_id));
-  terminalParentFixRows.sort((left, right) => left.id.localeCompare(right.id) || left.parent_id.localeCompare(right.parent_id));
-  staleBlockerRows.sort((left, right) => left.id.localeCompare(right.id));
-  const dependencyCycleDiagnostics = detectLifecycleDependencyCycles(activeItems, idPrefix);
-  const parentCycleDiagnostics = detectLifecycleParentCycles(items);
+  return rows;
+}
+function sortLifecycleScanRows(rows) {
+  rows.closureLikeRows.sort((left, right) => left.id.localeCompare(right.id));
+  rows.terminalParentRows.sort((left, right) => left.id.localeCompare(right.id) || left.parent_id.localeCompare(right.parent_id));
+  rows.terminalParentFixRows.sort((left, right) => left.id.localeCompare(right.id) || left.parent_id.localeCompare(right.parent_id));
+  rows.staleBlockerRows.sort((left, right) => left.id.localeCompare(right.id));
+}
+function lifecycleCycleWarningToken(prefix, severity, count) {
+  if (count <= 0 || severity === "off") {
+    return null;
+  }
+  return `${severity === "error" ? `${prefix}_error` : prefix}:${count}`;
+}
+function buildLifecycleWarnings(rows, includeStaleBlockers, dependencyCycleSeverity, parentCycleSeverity, dependencyCycleCount, parentCycleCount) {
   const warnings = [];
-  if (closureLikeRows.length > 0) {
-    warnings.push(`validate_lifecycle_active_closure_like_metadata:${closureLikeRows.length}`);
+  if (rows.closureLikeRows.length > 0) {
+    warnings.push(`validate_lifecycle_active_closure_like_metadata:${rows.closureLikeRows.length}`);
   }
-  if (terminalParentRows.length > 0) {
-    warnings.push(`validate_lifecycle_active_terminal_parent:${terminalParentRows.length}`);
+  if (rows.terminalParentRows.length > 0) {
+    warnings.push(`validate_lifecycle_active_terminal_parent:${rows.terminalParentRows.length}`);
   }
-  if (includeStaleBlockers && staleBlockerRows.length > 0) {
-    warnings.push(`validate_lifecycle_stale_blockers:${staleBlockerRows.length}`);
+  if (includeStaleBlockers && rows.staleBlockerRows.length > 0) {
+    warnings.push(`validate_lifecycle_stale_blockers:${rows.staleBlockerRows.length}`);
   }
-  if (dependencyCycleDiagnostics.cycle_count > 0 && dependencyCycleSeverity !== "off") {
-    warnings.push(`${dependencyCycleSeverity === "error" ? "validate_lifecycle_dependency_cycles_error" : "validate_lifecycle_dependency_cycles"}:${dependencyCycleDiagnostics.cycle_count}`);
+  const dependencyWarning = lifecycleCycleWarningToken("validate_lifecycle_dependency_cycles", dependencyCycleSeverity, dependencyCycleCount);
+  const parentWarning = lifecycleCycleWarningToken("validate_hierarchy_parent_cycle", parentCycleSeverity, parentCycleCount);
+  return [...warnings, ...dependencyWarning ? [dependencyWarning] : [], ...parentWarning ? [parentWarning] : []];
+}
+function linkedArtifactPathExceedsFilesystemLimits(artifactPath) {
+  const normalized = normalizeRelativePath(artifactPath);
+  return normalized.length > LINKED_ARTIFACT_MAX_PATH_LENGTH || normalized.split(/[\\/]/).some((segment) => segment.length > LINKED_ARTIFACT_MAX_SEGMENT_LENGTH);
+}
+async function linkedArtifactIsMissing(workspaceRoot, artifactPath) {
+  const absolutePath = path.isAbsolute(artifactPath) ? artifactPath : path.resolve(workspaceRoot, artifactPath);
+  if (linkedArtifactPathExceedsFilesystemLimits(absolutePath)) {
+    return false;
+  }
+  try {
+    const stats = await fs.stat(absolutePath);
+    return !stats.isFile() && !stats.isDirectory();
+  } catch (error) {
+    const code = typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
+    return code === "ENOENT" || code === "ENOTDIR";
+  }
+}
+async function collectLinkedPathScanState(items, workspaceRoot) {
+  const state = {
+    linkedProjectPaths: /* @__PURE__ */ new Set(),
+    remoteLinkedPaths: /* @__PURE__ */ new Set(),
+    missingLinkedPaths: [],
+    staleLinkRows: []
+  };
+  for (const item of items) {
+    const linkedArtifactGroups = [
+      { link_kind: "files", artifacts: item.files ?? [] },
+      { link_kind: "docs", artifacts: item.docs ?? [] }
+    ];
+    for (const group of linkedArtifactGroups) {
+      for (const artifact of group.artifacts) {
+        if (artifact.scope !== "project") {
+          continue;
+        }
+        if (isRemoteLinkedArtifactReference(artifact.path)) {
+          state.remoteLinkedPaths.add(artifact.path.trim());
+          continue;
+        }
+        const normalizedPath = normalizeRelativePath(artifact.path);
+        if (normalizedPath.length === 0) {
+          continue;
+        }
+        state.linkedProjectPaths.add(normalizedPath);
+        if (await linkedArtifactIsMissing(workspaceRoot, artifact.path)) {
+          state.missingLinkedPaths.push(normalizedPath);
+          state.staleLinkRows.push({ item_id: item.id, path: normalizedPath, link_kind: group.link_kind });
+        }
+      }
+    }
   }
-  if (parentCycleDiagnostics.cycle_count > 0 && parentCycleSeverity !== "off") {
-    warnings.push(`${parentCycleSeverity === "error" ? "validate_hierarchy_parent_cycle_error" : "validate_hierarchy_parent_cycle"}:${parentCycleDiagnostics.cycle_count}`);
+  return state;
+}
+function partitionFileCandidates(fileCandidates, pmRoot, workspaceRoot, fileScanMode, includePmInternals, verboseFileLists) {
+  const strictTrackedAllMode = fileScanMode === "tracked-all-strict";
+  const strictModeForcesPmInternals = strictTrackedAllMode && !includePmInternals;
+  const includePmInternalsEffective = includePmInternals || strictTrackedAllMode;
+  const pmInternalCandidatePrefixes = includePmInternalsEffective ? [] : resolvePmInternalCandidatePrefixes(pmRoot, workspaceRoot);
+  const excludedPmInternalPaths = pmInternalCandidatePrefixes.length === 0 ? [] : fileCandidates.candidateFiles.filter((candidate) => hasPathPrefix(candidate, pmInternalCandidatePrefixes));
+  const candidateFiles = pmInternalCandidatePrefixes.length === 0 ? fileCandidates.candidateFiles : fileCandidates.candidateFiles.filter((candidate) => !hasPathPrefix(candidate, pmInternalCandidatePrefixes));
+  const excludedByReason = {};
+  if (excludedPmInternalPaths.length > 0) {
+    const summarizedPmInternalPaths = summarizeFileList(excludedPmInternalPaths, verboseFileLists);
+    excludedByReason.pm_internals = {
+      count: excludedPmInternalPaths.length,
+      paths: summarizedPmInternalPaths.values,
+      paths_truncated: summarizedPmInternalPaths.truncated,
+      paths_total: summarizedPmInternalPaths.total
+    };
   }
+  return {
+    strictTrackedAllMode,
+    strictModeForcesPmInternals,
+    includePmInternalsEffective,
+    pmInternalCandidatePrefixes,
+    excludedPmInternalPaths,
+    candidateFiles,
+    excludedByReason
+  };
+}
+function buildLifecycleCheck(items, includeStaleBlockers, dependencyCycleSeverity, parentCycleSeverity, statusRegistry, lifecyclePatternPolicy, verboseDiagnostics, idPrefix = "pm") {
+  const rows = collectLifecycleScanRows(items, includeStaleBlockers, statusRegistry, lifecyclePatternPolicy);
+  sortLifecycleScanRows(rows);
+  const dependencyCycleDiagnostics = detectLifecycleDependencyCycles(rows.activeItems, idPrefix);
+  const parentCycleDiagnostics = detectLifecycleParentCycles(items);
+  const warnings = buildLifecycleWarnings(rows, includeStaleBlockers, dependencyCycleSeverity, parentCycleSeverity, dependencyCycleDiagnostics.cycle_count, parentCycleDiagnostics.cycle_count);
   const diagnosticLimit = verboseDiagnostics ? Number.POSITIVE_INFINITY : DIAGNOSTIC_LIST_SUMMARY_LIMIT;
-  const summarizedClosureLikeRows = summarizeList(closureLikeRows.map((row) => `${row.id}:${row.fields.join(",")}`), diagnosticLimit);
-  const summarizedTerminalParentRows = summarizeList(terminalParentRows.map((row) => `${row.id}:${row.parent_id}:${row.parent_status}`), diagnosticLimit);
-  const summarizedStaleBlockerRows = summarizeList(staleBlockerRows.map((row) => `${row.id}:${row.status}:${row.reasons.join(",")}`), diagnosticLimit);
+  const summarizedClosureLikeRows = summarizeList(rows.closureLikeRows.map((row) => `${row.id}:${row.fields.join(",")}`), diagnosticLimit);
+  const summarizedTerminalParentRows = summarizeList(rows.terminalParentRows.map((row) => `${row.id}:${row.parent_id}:${row.parent_status}`), diagnosticLimit);
+  const summarizedStaleBlockerRows = summarizeList(rows.staleBlockerRows.map((row) => `${row.id}:${row.status}:${row.reasons.join(",")}`), diagnosticLimit);
   const summarizedDependencyCycleItemIds = summarizeList(dependencyCycleDiagnostics.cycle_item_ids, diagnosticLimit);
   const summarizedDependencyCycleSamplePaths = summarizeList(dependencyCycleDiagnostics.cycle_sample_paths, diagnosticLimit);
   const summarizedParentCycleItemIds = summarizeList(parentCycleDiagnostics.cycle_item_ids, diagnosticLimit);
@@ -1400,15 +1552,15 @@ function buildLifecycleCheck(items, includeStaleBlockers, dependencyCycleSeverit
       name: "lifecycle",
       status: hasErrorSeverityCycle ? "error" : warnings.length === 0 ? "ok" : "warn",
       details: {
-        checked_active_items: activeItems.length,
-        active_closure_like_metadata_items: closureLikeRows.length,
+        checked_active_items: rows.activeItems.length,
+        active_closure_like_metadata_items: rows.closureLikeRows.length,
         active_closure_like_metadata_rows: summarizedClosureLikeRows.values,
         active_closure_like_metadata_rows_truncated: summarizedClosureLikeRows.truncated,
-        active_terminal_parent_items: terminalParentRows.length,
+        active_terminal_parent_items: rows.terminalParentRows.length,
         active_terminal_parent_rows: summarizedTerminalParentRows.values,
         active_terminal_parent_rows_truncated: summarizedTerminalParentRows.truncated,
         stale_blocker_checks_enabled: includeStaleBlockers,
-        stale_blocker_items: staleBlockerRows.length,
+        stale_blocker_items: rows.staleBlockerRows.length,
         stale_blocker_rows: summarizedStaleBlockerRows.values,
         stale_blocker_rows_truncated: summarizedStaleBlockerRows.truncated,
         dependency_cycle_severity_policy: dependencyCycleSeverity,
@@ -1438,81 +1590,26 @@ function buildLifecycleCheck(items, includeStaleBlockers, dependencyCycleSeverit
       }
     },
     warnings,
-    terminalParentFixRows
+    terminalParentFixRows: rows.terminalParentFixRows
   };
 }
 async function buildFilesCheck(items, workspaceRoot, pmRoot, fileScanMode, includePmInternals, verboseFileLists) {
-  const linkedProjectPaths = /* @__PURE__ */ new Set();
-  const remoteLinkedPaths = /* @__PURE__ */ new Set();
-  const missingLinkedPaths = [];
-  const staleLinkRows = [];
+  const linkedPathState = await collectLinkedPathScanState(items, workspaceRoot);
   const itemsById = new Map(items.map((item) => [item.id, item]));
-  for (const item of items) {
-    const linkedArtifactGroups = [
-      { link_kind: "files", artifacts: item.files ?? [] },
-      { link_kind: "docs", artifacts: item.docs ?? [] }
-    ];
-    for (const group of linkedArtifactGroups) {
-      for (const artifact of group.artifacts) {
-        if (artifact.scope !== "project") {
-          continue;
-        }
-        if (isRemoteLinkedArtifactReference(artifact.path)) {
-          remoteLinkedPaths.add(artifact.path.trim());
-          continue;
-        }
-        const normalizedPath = normalizeRelativePath(artifact.path);
-        if (normalizedPath.length === 0) {
-          continue;
-        }
-        linkedProjectPaths.add(normalizedPath);
-        const absolutePath = path.isAbsolute(artifact.path) ? artifact.path : path.resolve(workspaceRoot, artifact.path);
-        let missing = false;
-        try {
-          const stats = await fs.stat(absolutePath);
-          if (!stats.isFile() && !stats.isDirectory()) {
-            missing = true;
-          }
-        } catch {
-          missing = true;
-        }
-        if (missing) {
-          missingLinkedPaths.push(normalizedPath);
-          staleLinkRows.push({ item_id: item.id, path: normalizedPath, link_kind: group.link_kind });
-        }
-      }
-    }
-  }
-  const uniqueMissingLinkedPaths = [...new Set(missingLinkedPaths)].sort((left, right) => left.localeCompare(right));
+  const uniqueMissingLinkedPaths = [...new Set(linkedPathState.missingLinkedPaths)].sort((left, right) => left.localeCompare(right));
   const fileCandidates = await collectProjectFileCandidates(workspaceRoot, fileScanMode);
-  const strictTrackedAllMode = fileScanMode === "tracked-all-strict";
-  const strictModeForcesPmInternals = strictTrackedAllMode && !includePmInternals;
-  const includePmInternalsEffective = includePmInternals || strictTrackedAllMode;
-  const pmInternalCandidatePrefixes = includePmInternalsEffective ? [] : resolvePmInternalCandidatePrefixes(pmRoot, workspaceRoot);
-  const excludedPmInternalPaths = pmInternalCandidatePrefixes.length === 0 ? [] : fileCandidates.candidateFiles.filter((candidate) => hasPathPrefix(candidate, pmInternalCandidatePrefixes));
-  const candidateFiles = pmInternalCandidatePrefixes.length === 0 ? fileCandidates.candidateFiles : fileCandidates.candidateFiles.filter((candidate) => !hasPathPrefix(candidate, pmInternalCandidatePrefixes));
-  const excludedPmInternalCount = excludedPmInternalPaths.length;
-  const excludedByReason = {};
-  if (excludedPmInternalCount > 0) {
-    const summarizedPmInternalPaths = summarizeFileList(excludedPmInternalPaths, verboseFileLists);
-    excludedByReason.pm_internals = {
-      count: excludedPmInternalCount,
-      paths: summarizedPmInternalPaths.values,
-      paths_truncated: summarizedPmInternalPaths.truncated,
-      paths_total: summarizedPmInternalPaths.total
-    };
-  }
-  const orphanedFiles = candidateFiles.filter((candidate) => !linkedProjectPaths.has(candidate));
+  const partition = partitionFileCandidates(fileCandidates, pmRoot, workspaceRoot, fileScanMode, includePmInternals, verboseFileLists);
+  const orphanedFiles = partition.candidateFiles.filter((candidate) => !linkedPathState.linkedProjectPaths.has(candidate));
   const orphanedPathRows = buildOrphanedPathRows(orphanedFiles, items);
-  const classifiedStalePaths = classifyStaleLinkedPaths(uniqueMissingLinkedPaths, candidateFiles);
+  const classifiedStalePaths = classifyStaleLinkedPaths(uniqueMissingLinkedPaths, partition.candidateFiles);
   const classificationByPath = new Map(classifiedStalePaths.map((entry) => [entry.path, entry.classification]));
   const movedStalePathCount = classifiedStalePaths.filter((entry) => entry.classification === "moved").length;
-  const staleLinkPruneRows = staleLinkRows.map((row) => ({
+  const staleLinkPruneRows = linkedPathState.staleLinkRows.map((row) => ({
     ...row,
     classification: classificationByPath.get(row.path) ?? "deleted"
   })).sort((left, right) => left.item_id.localeCompare(right.item_id) || left.path.localeCompare(right.path) || left.link_kind.localeCompare(right.link_kind));
   const warnings = [];
-  if (strictModeForcesPmInternals) {
+  if (partition.strictModeForcesPmInternals) {
     warnings.push("validate_files_tracked_all_strict_forces_pm_internals");
   }
   if (uniqueMissingLinkedPaths.length > 0) {
@@ -1521,7 +1618,7 @@ async function buildFilesCheck(items, workspaceRoot, pmRoot, fileScanMode, inclu
   if (orphanedFiles.length > 0) {
     warnings.push(`validate_files_orphaned_paths:${orphanedFiles.length}`);
   }
-  const uniqueRemoteLinkedPaths = [...remoteLinkedPaths].sort((left, right) => left.localeCompare(right));
+  const uniqueRemoteLinkedPaths = [...linkedPathState.remoteLinkedPaths].sort((left, right) => left.localeCompare(right));
   const summarizedRemote = summarizeFileList(uniqueRemoteLinkedPaths, verboseFileLists);
   const summarizedMissing = summarizeFileList(uniqueMissingLinkedPaths, verboseFileLists);
   const summarizedOrphaned = summarizeFileList(orphanedFiles, verboseFileLists);
@@ -1547,28 +1644,28 @@ async function buildFilesCheck(items, workspaceRoot, pmRoot, fileScanMode, inclu
         workspace_root: workspaceRoot,
         scan_mode_requested: fileCandidates.requestedMode,
         scan_mode_applied: fileCandidates.appliedMode,
-        strict_tracked_all_mode: strictTrackedAllMode,
-        strict_mode_forces_pm_internals: strictModeForcesPmInternals,
-        strict_mode_forces_pm_internals_notice: strictModeForcesPmInternals ? "tracked-all-strict force-enables PM internals; pass --include-pm-internals to make inclusion explicit." : null,
+        strict_tracked_all_mode: partition.strictTrackedAllMode,
+        strict_mode_forces_pm_internals: partition.strictModeForcesPmInternals,
+        strict_mode_forces_pm_internals_notice: partition.strictModeForcesPmInternals ? "tracked-all-strict force-enables PM internals; pass --include-pm-internals to make inclusion explicit." : null,
         file_list_detail_mode: verboseFileLists ? "full" : "summary",
         file_list_summary_limit: FILE_LIST_SUMMARY_LIMIT,
         candidate_scan_source: fileCandidates.source,
-        include_pm_internals: includePmInternalsEffective,
+        include_pm_internals: partition.includePmInternalsEffective,
         include_pm_internals_requested: includePmInternals,
-        pm_internal_candidate_prefixes: pmInternalCandidatePrefixes,
-        pm_internal_excluded_count: excludedPmInternalCount,
-        excluded_total: excludedPmInternalCount,
-        excluded_by_reason: excludedByReason,
-        linked_project_paths: linkedProjectPaths.size,
+        pm_internal_candidate_prefixes: partition.pmInternalCandidatePrefixes,
+        pm_internal_excluded_count: partition.excludedPmInternalPaths.length,
+        excluded_total: partition.excludedPmInternalPaths.length,
+        excluded_by_reason: partition.excludedByReason,
+        linked_project_paths: linkedPathState.linkedProjectPaths.size,
         remote_linked_paths_count: uniqueRemoteLinkedPaths.length,
         remote_linked_paths_total: summarizedRemote.total,
         remote_linked_paths: summarizedRemote.values,
         remote_linked_paths_truncated: summarizedRemote.truncated,
         candidate_total_raw: fileCandidates.candidateTotal,
         candidate_scanned_raw: fileCandidates.candidateScanned,
-        candidate_total: candidateFiles.length,
-        candidate_scanned: candidateFiles.length,
-        scanned_candidate_files: candidateFiles.length,
+        candidate_total: partition.candidateFiles.length,
+        candidate_scanned: partition.candidateFiles.length,
+        scanned_candidate_files: partition.candidateFiles.length,
         missing_linked_paths_count: uniqueMissingLinkedPaths.length,
         missing_linked_paths_total: summarizedMissing.total,
         missing_linked_paths: summarizedMissing.values,
@@ -1728,7 +1825,7 @@ async function applyValidateFix(fix, global) {
     case "set_estimate":
     case "reparent":
     case "unset_parent": {
-      const { runUpdate } = await import("./update-KFX2SIAC.js");
+      const { runUpdate } = await import("./update-IKJZWLQC.js");
       const updateOptions = { message: VALIDATE_AUTO_FIX_MESSAGE };
       if (fix.kind === "set_resolution") {
         updateOptions.resolution = fix.value;
@@ -1788,10 +1885,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-NQHEXUZD.js");
+        const { runFiles } = await import("./files-6SGKHS6O.js");
         await runFiles(first.item_id, { remove, message: VALIDATE_AUTO_FIX_MESSAGE }, global);
       } else {
-        const { runDocs } = await import("./docs-GYZNVS26.js");
+        const { runDocs } = await import("./docs-6LQ3GLM7.js");
         await runDocs(first.item_id, { remove, message: VALIDATE_AUTO_FIX_MESSAGE }, global);
       }
       applied.push(...batch);
@@ -1806,10 +1903,14 @@ var _testOnlyValidateCommand = {
   applyValidateFixes,
   attachValidateFixHints,
   buildCommandReferencesCheck,
+  buildCloseReasonBackfillRows,
   buildFilesCheck,
   buildLifecycleCheck,
   buildLifecycleDependencyGraph,
   buildLifecycleParentGraph,
+  buildEstimateBackfillRows,
+  buildMetadataCounts,
+  buildMissingFieldOccurrences,
   buildOrphanedPathRows,
   classifyOrphanedPath,
   collectDefaultProjectFileCandidates,
@@ -1820,6 +1921,7 @@ var _testOnlyValidateCommand = {
   extractItemIds,
   findLifecycleDependencyCycleComponents,
   isMetadataFieldMissing,
+  linkedArtifactPathExceedsFilesystemLimits,
   listFilesRecursive,
   resolveDependencyCycleSeverity,
   resolveParentCycleSeverity,
@@ -1833,6 +1935,105 @@ var _testOnlyValidateCommand = {
   summarizeDuplicateIssueCodes,
   toMeaningfulString
 };
+function recordValidateCheck(state, built, fixHintsEnabled) {
+  if (fixHintsEnabled) {
+    attachValidateFixHints(built.check, built.warnings);
+  }
+  state.checks.push(built.check);
+  state.warnings.push(...built.warnings);
+}
+async function executeRequestedValidateChecks(params) {
+  const state = {
+    checks: [],
+    warnings: [...params.initialWarnings],
+    closeReasonBackfillRows: [],
+    estimateBackfillRows: [],
+    resolutionBackfillRows: [],
+    terminalParentFixRows: [],
+    staleLinkPruneRows: []
+  };
+  const fixHintsEnabled = params.options.fixHints === true;
+  const fullDiagnostics = params.options.verboseDiagnostics === true || params.options.allAffectedIds === true || params.global.json === true;
+  if (params.requestedChecks.has("metadata")) {
+    const built = buildMetadataCheck(params.items, params.metadataPolicy, params.statusRegistry, fullDiagnostics);
+    state.closeReasonBackfillRows = built.closeReasonBackfillRows;
+    state.estimateBackfillRows = built.estimateBackfillRows;
+    recordValidateCheck(state, built, fixHintsEnabled);
+  }
+  if (params.requestedChecks.has("resolution")) {
+    const built = buildResolutionCheck(params.items, params.statusRegistry, fullDiagnostics);
+    state.resolutionBackfillRows = built.resolutionBackfillRows;
+    recordValidateCheck(state, built, fixHintsEnabled);
+  }
+  if (params.requestedChecks.has("lifecycle")) {
+    const built = buildLifecycleCheck(params.items, Boolean(params.options.checkStaleBlockers), params.dependencyCycleSeverity, params.parentCycleSeverity, params.statusRegistry, params.lifecyclePatternPolicy, fullDiagnostics, params.settings.id_prefix);
+    state.terminalParentFixRows = built.terminalParentFixRows;
+    recordValidateCheck(state, built, fixHintsEnabled);
+  }
+  if (params.requestedChecks.has("files")) {
+    const built = await buildFilesCheck(params.items, params.workspaceRoot, params.pmRoot, params.fileScanMode, Boolean(params.options.includePmInternals), Boolean(params.options.verboseFileLists));
+    state.staleLinkPruneRows = built.staleLinkPruneRows;
+    recordValidateCheck(state, built, fixHintsEnabled);
+  }
+  if (params.requestedChecks.has("command_references")) {
+    recordValidateCheck(state, buildCommandReferencesCheck(params.items, params.settings.id_prefix, fullDiagnostics), fixHintsEnabled);
+  }
+  if (params.requestedChecks.has("history_drift")) {
+    recordValidateCheck(state, await buildHistoryDriftCheck(params.pmRoot, params.items, fullDiagnostics), fixHintsEnabled);
+  }
+  if (params.requestedChecks.has("format_version")) {
+    recordValidateCheck(state, buildFormatVersionCheck(params.items, fullDiagnostics), fixHintsEnabled);
+  }
+  return state;
+}
+function planValidateFixes(options, state, settings) {
+  const planned = [];
+  if (options.autoFix === true) {
+    planned.push(...planCloseReasonBackfillFixes(state.closeReasonBackfillRows));
+    planned.push(...planResolutionBackfillFixes(state.resolutionBackfillRows));
+    planned.push(...planEstimateBackfillFixes(state.estimateBackfillRows, settings.validation.estimate_defaults_by_type));
+    planned.push(...planTerminalParentFixes(state.terminalParentFixRows));
+  }
+  if (options.pruneMissing === true) {
+    planned.push(...planStaleLinkPruneFixes(state.staleLinkPruneRows));
+  }
+  return planned;
+}
+async function buildValidateFixesSummary(options, state, settings, grantedFixScopes, global) {
+  if (options.autoFix !== true && options.pruneMissing !== true) {
+    return void 0;
+  }
+  const planned = planValidateFixes(options, state, settings);
+  const { applicable, gated } = partitionFixesByGrant(planned, grantedFixScopes);
+  const dryRun = options.dryRun === true;
+  const appliedFixRows = [];
+  const failedFixRows = [];
+  if (!dryRun) {
+    const applied = await applyValidateFixes(applicable, global);
+    appliedFixRows.push(...applied.applied.map(toFixOutputRow));
+    failedFixRows.push(...applied.failed.map(({ fix, error }) => ({
+      ...toFixOutputRow(fix),
+      error: error instanceof Error ? error.message : String(error)
+    })));
+  }
+  return {
+    mode: dryRun ? "dry_run" : "apply",
+    auto_fix: options.autoFix === true,
+    prune_missing: options.pruneMissing === true,
+    granted_fix_scopes: [...grantedFixScopes].sort((left, right) => left.localeCompare(right)),
+    planned_count: planned.length,
+    applied_count: appliedFixRows.length,
+    gated_count: gated.length,
+    failed_count: failedFixRows.length,
+    planned_fixes: planned.map(toFixOutputRow),
+    applied_fixes: appliedFixRows,
+    gated_fixes: gated.map((fix) => ({
+      ...toFixOutputRow(fix),
+      gate_hint: `Withheld: re-run with --fix-scope ${fix.gate} to apply.`
+    })),
+    failed_fixes: failedFixRows
+  };
+}
 async function runValidate(options, global) {
   const fixesRequested = options.autoFix === true || options.pruneMissing === true;
   if (options.dryRun === true && !fixesRequested) {
@@ -1860,100 +2061,29 @@ async function runValidate(options, global) {
   const parentCycleSeverity = resolveParentCycleSeverity(options.parentCycleSeverity);
   const fileScanMode = resolveFileScanMode(options.scanMode);
   const workspaceRoot = resolveWorkspaceRoot(pmRoot);
-  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);
-    }
-    checks.push(built.check);
-    warnings.push(...built.warnings);
-  };
-  let closeReasonBackfillRows = [];
-  let estimateBackfillRows = [];
-  let resolutionBackfillRows = [];
-  let terminalParentFixRows = [];
-  let staleLinkPruneRows = [];
-  if (requestedChecks.has("metadata")) {
-    const built = buildMetadataCheck(items, metadataPolicy, statusRegistry, fullDiagnostics);
-    closeReasonBackfillRows = built.closeReasonBackfillRows;
-    estimateBackfillRows = built.estimateBackfillRows;
-    record(built);
-  }
-  if (requestedChecks.has("resolution")) {
-    const built = buildResolutionCheck(items, statusRegistry, fullDiagnostics);
-    resolutionBackfillRows = built.resolutionBackfillRows;
-    record(built);
-  }
-  if (requestedChecks.has("lifecycle")) {
-    const built = buildLifecycleCheck(items, Boolean(options.checkStaleBlockers), dependencyCycleSeverity, parentCycleSeverity, statusRegistry, lifecyclePatternPolicy, fullDiagnostics, settings.id_prefix);
-    terminalParentFixRows = built.terminalParentFixRows;
-    record(built);
-  }
-  if (requestedChecks.has("files")) {
-    const built = await buildFilesCheck(items, workspaceRoot, pmRoot, fileScanMode, Boolean(options.includePmInternals), Boolean(options.verboseFileLists));
-    staleLinkPruneRows = built.staleLinkPruneRows;
-    record(built);
-  }
-  if (requestedChecks.has("command_references")) {
-    record(buildCommandReferencesCheck(items, settings.id_prefix, fullDiagnostics));
-  }
-  if (requestedChecks.has("history_drift")) {
-    record(await buildHistoryDriftCheck(pmRoot, items, fullDiagnostics));
-  }
-  if (requestedChecks.has("format_version")) {
-    record(buildFormatVersionCheck(items, fullDiagnostics));
-  }
-  let fixes;
-  if (fixesRequested) {
-    const planned = [];
-    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) {
-      planned.push(...planStaleLinkPruneFixes(staleLinkPruneRows));
-    }
-    const { applicable, gated } = partitionFixesByGrant(planned, grantedFixScopes);
-    const dryRun = options.dryRun === true;
-    const appliedFixRows = [];
-    const failedFixRows = [];
-    if (!dryRun) {
-      const applied = await applyValidateFixes(applicable, global);
-      appliedFixRows.push(...applied.applied.map(toFixOutputRow));
-      failedFixRows.push(...applied.failed.map(({ fix, error }) => ({
-        ...toFixOutputRow(fix),
-        error: error instanceof Error ? error.message : String(error)
-      })));
-    }
-    fixes = {
-      mode: dryRun ? "dry_run" : "apply",
-      auto_fix: options.autoFix === true,
-      prune_missing: options.pruneMissing === true,
-      granted_fix_scopes: [...grantedFixScopes].sort((left, right) => left.localeCompare(right)),
-      planned_count: planned.length,
-      applied_count: appliedFixRows.length,
-      gated_count: gated.length,
-      failed_count: failedFixRows.length,
-      planned_fixes: planned.map(toFixOutputRow),
-      applied_fixes: appliedFixRows,
-      gated_fixes: gated.map((fix) => ({
-        ...toFixOutputRow(fix),
-        gate_hint: `Withheld: re-run with --fix-scope ${fix.gate} to apply.`
-      })),
-      failed_fixes: failedFixRows
-    };
-  }
-  const normalizedWarnings = [...new Set(warnings)].sort((left, right) => left.localeCompare(right));
-  const hasErrors = checks.some((check) => check.status === "error");
+  const state = await executeRequestedValidateChecks({
+    requestedChecks,
+    options,
+    global,
+    pmRoot,
+    workspaceRoot,
+    settings,
+    items,
+    statusRegistry,
+    metadataPolicy,
+    lifecyclePatternPolicy,
+    dependencyCycleSeverity,
+    parentCycleSeverity,
+    fileScanMode,
+    initialWarnings: [...new Set(itemReadWarnings)]
+  });
+  const fixes = fixesRequested ? await buildValidateFixesSummary(options, state, settings, grantedFixScopes, global) : void 0;
+  const normalizedWarnings = [...new Set(state.warnings)].sort((left, right) => left.localeCompare(right));
+  const hasErrors = state.checks.some((check) => check.status === "error");
   return {
     ok: !hasErrors,
     has_warnings: normalizedWarnings.length > 0,
-    checks,
+    checks: state.checks,
     warnings: normalizedWarnings,
     ...fixes !== void 0 ? { fixes } : {},
     generated_at: nowIso()
@@ -1963,6 +2093,6 @@ export {
   _testOnlyValidateCommand,
   runValidate
 };
-//# sourceMappingURL=validate-X5W76YJL.js.map
+//# sourceMappingURL=validate-GAJ6FUSI.js.map
 
-//# debugId=7af30e70-6b7d-5750-9dab-2031781c0d9d
+//# debugId=a4633e01-6951-59e5-83cd-351f590aec99