@unbrained/pm-cli 2026.6.11 → 2026.6.12

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

@@ -1,12 +1,14 @@
 
-!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]="c8e3c91e-a467-515d-8fdd-02fd7c237ebe")}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]="50b9ae79-2f9d-56b7-8b52-24c0a6416cd8")}catch(e){}}();
 import {
-  buildRemediationCommands,
-  scanHistoryDrift
-} from "./chunk-UOO6BYIA.js";
+  buildRemediationCommands
+} from "./chunk-PNYAAB4S.js";
 import {
   extractReferencedPmItemIdsFromCommand
 } from "./chunk-EWFY7SLA.js";
+import {
+  scanHistoryDrift
+} from "./chunk-C6SAP27O.js";
 import "./chunk-ZYNJNPYD.js";
 import "./chunk-4HFU4UO2.js";
 import "./chunk-I7NYDZDV.js";
@@ -49,6 +51,205 @@ import { realpathSync } from "node:fs";
 import { execFile } from "node:child_process";
 import path from "node:path";
 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 DEFAULT_RESOLUTION_BACKFILL_VALUE = "completed";
+function quoteForCommand(value) {
+  return `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+}
+function toMeaningfulValue(value) {
+  const trimmed = value?.trim();
+  return trimmed !== void 0 && trimmed.length > 0 ? trimmed : void 0;
+}
+function planResolutionBackfillFixes(rows) {
+  const fixes = [];
+  for (const row of rows) {
+    if (!row.missing_fields.includes("resolution")) {
+      continue;
+    }
+    const value = toMeaningfulValue(row.close_reason) ?? DEFAULT_RESOLUTION_BACKFILL_VALUE;
+    fixes.push({
+      item_id: row.id,
+      check: "resolution",
+      field: "resolution",
+      kind: "set_resolution",
+      value,
+      command: `pm update ${row.id} --resolution ${quoteForCommand(value)}`,
+      gate: "resolution"
+    });
+  }
+  return fixes;
+}
+function planCloseReasonBackfillFixes(rows) {
+  const fixes = [];
+  for (const row of rows) {
+    const value = toMeaningfulValue(row.resolution);
+    if (value === void 0) {
+      continue;
+    }
+    fixes.push({
+      item_id: row.id,
+      check: "metadata",
+      field: "close_reason",
+      kind: "set_close_reason",
+      value,
+      command: `pm update ${row.id} --close-reason ${quoteForCommand(value)}`,
+      gate: "metadata"
+    });
+  }
+  return fixes;
+}
+function planTerminalParentFixes(rows) {
+  return rows.map((row) => {
+    if (row.grandparent_id !== void 0 && row.grandparent_active === true) {
+      return {
+        item_id: row.id,
+        check: "lifecycle",
+        field: "parent",
+        kind: "reparent",
+        parent_id: row.grandparent_id,
+        command: `pm update ${row.id} --parent ${row.grandparent_id}`,
+        gate: "lifecycle"
+      };
+    }
+    return {
+      item_id: row.id,
+      check: "lifecycle",
+      field: "parent",
+      kind: "unset_parent",
+      command: `pm update ${row.id} --unset parent`,
+      gate: "lifecycle"
+    };
+  });
+}
+function planStaleLinkPruneFixes(rows) {
+  const fixes = [];
+  for (const row of rows) {
+    if (row.classification !== "deleted") {
+      continue;
+    }
+    const noun = row.link_kind === "files" ? "files" : "docs";
+    fixes.push({
+      item_id: row.item_id,
+      check: "files",
+      field: row.link_kind,
+      kind: row.link_kind === "files" ? "prune_file_link" : "prune_doc_link",
+      path: row.path,
+      command: `pm ${noun} ${row.item_id} --remove ${quoteForCommand(row.path)}`
+    });
+  }
+  return fixes;
+}
+function resolveGrantedFixScopes(rawScopes) {
+  const tokens = (rawScopes ?? []).flatMap((raw) => raw.split(",")).map((raw) => raw.trim()).filter((raw) => raw.length > 0);
+  if (tokens.length === 0) {
+    if (rawScopes !== void 0 && rawScopes.length > 0) {
+      throw new PmCliError(`--fix-scope values must not be empty. Supported values: ${SUPPORTED_FIX_SCOPES.join(", ")}.`, EXIT_CODE.USAGE);
+    }
+    return new Set(DEFAULT_GRANTED_FIX_SCOPES);
+  }
+  const granted = /* @__PURE__ */ new Set();
+  for (const raw of tokens) {
+    const normalized = raw.toLowerCase().replaceAll("-", "_");
+    if (SUPPORTED_FIX_SCOPES.includes(normalized)) {
+      granted.add(normalized);
+      continue;
+    }
+    throw new PmCliError(`Unknown --fix-scope value "${raw}". Supported values: ${SUPPORTED_FIX_SCOPES.join(", ")}.`, EXIT_CODE.USAGE);
+  }
+  return granted;
+}
+function partitionFixesByGrant(fixes, granted) {
+  const applicable = [];
+  const gated = [];
+  for (const fix of fixes) {
+    if (fix.gate !== void 0 && !granted.has(fix.gate)) {
+      gated.push(fix);
+    } else {
+      applicable.push(fix);
+    }
+  }
+  return { applicable, gated };
+}
+function toFixOutputRow(fix) {
+  return {
+    item_id: fix.item_id,
+    check: fix.check,
+    field: fix.field,
+    command: fix.command,
+    ...fix.gate !== void 0 ? { gate: fix.gate } : {}
+  };
+}
+
+// dist/core/validate/missing-by-type.js
+function buildMissingByTypeCounts(occurrences) {
+  const countsByType = /* @__PURE__ */ new Map();
+  for (const occurrence of occurrences) {
+    let fieldCounts = countsByType.get(occurrence.item_type);
+    if (!fieldCounts) {
+      fieldCounts = /* @__PURE__ */ new Map();
+      countsByType.set(occurrence.item_type, fieldCounts);
+    }
+    fieldCounts.set(occurrence.field, (fieldCounts.get(occurrence.field) ?? 0) + 1);
+  }
+  const result = {};
+  for (const type of [...countsByType.keys()].sort((left, right) => left.localeCompare(right))) {
+    const fieldCounts = countsByType.get(type);
+    const fields = {};
+    for (const field of [...fieldCounts.keys()].sort((left, right) => left.localeCompare(right))) {
+      fields[field] = fieldCounts.get(field);
+    }
+    result[type] = fields;
+  }
+  return result;
+}
+
+// dist/core/validate/stale-file-classification.js
+var DEFAULT_STALE_PATH_CANDIDATE_LIMIT = 3;
+function basenameOf(relativePath) {
+  const lastSlash = Math.max(relativePath.lastIndexOf("/"), relativePath.lastIndexOf("\\"));
+  return lastSlash === -1 ? relativePath : relativePath.slice(lastSlash + 1);
+}
+function classifyStaleLinkedPaths(stalePaths, candidateFiles, candidateLimit = DEFAULT_STALE_PATH_CANDIDATE_LIMIT) {
+  const limit = Number.isFinite(candidateLimit) && candidateLimit >= 1 ? Math.floor(candidateLimit) : DEFAULT_STALE_PATH_CANDIDATE_LIMIT;
+  const candidatesByBasename = /* @__PURE__ */ new Map();
+  for (const candidate of candidateFiles) {
+    const basename = basenameOf(candidate);
+    if (basename.length === 0) {
+      continue;
+    }
+    const bucket = candidatesByBasename.get(basename);
+    if (bucket) {
+      bucket.push(candidate);
+    } else {
+      candidatesByBasename.set(basename, [candidate]);
+    }
+  }
+  return stalePaths.map((stalePath) => {
+    const matches = (candidatesByBasename.get(basenameOf(stalePath)) ?? []).filter((candidate) => candidate !== stalePath).sort((left, right) => left.localeCompare(right));
+    if (matches.length === 0) {
+      return {
+        path: stalePath,
+        classification: "deleted",
+        candidates: [],
+        candidates_truncated: false
+      };
+    }
+    return {
+      path: stalePath,
+      classification: "moved",
+      candidates: matches.slice(0, limit),
+      candidates_truncated: matches.length > limit
+    };
+  });
+}
+function summarizeStaleLinkedPathClassifications(classified) {
+  return classified.map((entry) => entry.classification === "moved" ? `${entry.path}:moved:${entry.candidates[0]}` : `${entry.path}:deleted`);
+}
+
+// dist/cli/commands/validate.js
 var FILE_SCAN_DIRECTORIES = ["src", "tests", "docs"];
 var FILE_SCAN_ROOT_FILES = [
   "README.md",
@@ -520,17 +721,32 @@ function resolveRequestedChecks(options) {
     requested.add("command_references");
   }
   if (requested.size === 0) {
-    requested.add("metadata");
-    requested.add("resolution");
-    requested.add("lifecycle");
+    if (options.autoFix) {
+      requested.add("metadata");
+      requested.add("resolution");
+      requested.add("lifecycle");
+    }
+    if (options.pruneMissing) {
+      requested.add("files");
+    }
+    if (requested.size === 0) {
+      requested.add("metadata");
+      requested.add("resolution");
+      requested.add("lifecycle");
+      requested.add("files");
+      requested.add("command_references");
+      requested.add("history_drift");
+    }
+    return requested;
+  }
+  if (options.pruneMissing) {
     requested.add("files");
-    requested.add("command_references");
-    requested.add("history_drift");
   }
   return requested;
 }
 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]));
   for (const item of items) {
     for (const field of SUPPORTED_METADATA_REQUIRED_FIELDS) {
       if (!isMetadataFieldMissing(item, field, statusRegistry)) {
@@ -555,6 +771,14 @@ function buildMetadataCheck(items, metadataPolicy, statusRegistry, verboseDiagno
       counts[countKey] = value;
     }
   }
+  const missingFieldOccurrences = [];
+  for (const field of metadataPolicy.required_fields) {
+    for (const itemId of missingByField[field] ?? []) {
+      const itemType = itemsById.get(itemId)?.type;
+      missingFieldOccurrences.push({ item_type: typeof itemType === "string" && itemType.length > 0 ? itemType : "Unknown", field });
+    }
+  }
+  const missingByType = buildMissingByTypeCounts(missingFieldOccurrences);
   const details = {
     checked_items: items.length,
     metadata_profile: metadataPolicy.profile,
@@ -562,7 +786,8 @@ function buildMetadataCheck(items, metadataPolicy, statusRegistry, verboseDiagno
     metadata_profile_fallback_to_core: metadataPolicy.fallback_to_core,
     required_fields: [...metadataPolicy.required_fields],
     supported_required_fields: [...SUPPORTED_METADATA_REQUIRED_FIELDS],
-    counts
+    counts,
+    missing_by_type: missingByType
   };
   if (metadataPolicy.configured_custom_fields.length > 0) {
     details.configured_custom_required_fields = [...metadataPolicy.configured_custom_fields];
@@ -581,13 +806,18 @@ 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) => ({
+    id: itemId,
+    resolution: toNonEmptyStringOrUndefined(itemsById.get(itemId)?.resolution)
+  })) : [];
   return {
     check: {
       name: "metadata",
       status: warningTokens.length === 0 ? "ok" : "warn",
       details
     },
-    warnings: warningTokens
+    warnings: warningTokens,
+    closeReasonBackfillRows
   };
 }
 function buildResolutionCheck(items, statusRegistry, verboseDiagnostics) {
@@ -595,6 +825,7 @@ function buildResolutionCheck(items, statusRegistry, verboseDiagnostics) {
   terminalDoneStatuses.add(statusRegistry.close_status);
   const closedItems = items.filter((item) => terminalDoneStatuses.has(normalizeStatusForRegistry(item.status, statusRegistry)));
   const missingResolutionRows = [];
+  const resolutionBackfillRows = [];
   for (const item of closedItems) {
     const missingFields = RESOLUTION_FIELD_KEYS.filter((field) => !toNonEmptyStringOrUndefined(item[field]));
     if (missingFields.length === 0) {
@@ -604,6 +835,11 @@ function buildResolutionCheck(items, statusRegistry, verboseDiagnostics) {
       id: item.id,
       missing_fields: missingFields
     });
+    resolutionBackfillRows.push({
+      id: item.id,
+      missing_fields: missingFields,
+      close_reason: toNonEmptyStringOrUndefined(item.close_reason)
+    });
   }
   const warnings = missingResolutionRows.length > 0 ? [`validate_resolution_missing_fields:${missingResolutionRows.length}`] : [];
   const diagnosticLimit = verboseDiagnostics ? Number.POSITIVE_INFINITY : DIAGNOSTIC_LIST_SUMMARY_LIMIT;
@@ -623,7 +859,8 @@ function buildResolutionCheck(items, statusRegistry, verboseDiagnostics) {
         missing_resolution_remediation_hints_truncated: summarizedHints.truncated
       }
     },
-    warnings
+    warnings,
+    resolutionBackfillRows
   };
 }
 function buildLifecycleDependencyGraph(activeItems) {
@@ -744,6 +981,7 @@ function buildLifecycleCheck(items, includeStaleBlockers, dependencyCycleSeverit
   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]) => {
@@ -769,6 +1007,14 @@ function buildLifecycleCheck(items, includeStaleBlockers, dependencyCycleSeverit
           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)
+        });
       }
     }
     if (includeStaleBlockers) {
@@ -806,6 +1052,7 @@ 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);
   const warnings = [];
@@ -862,31 +1109,43 @@ function buildLifecycleCheck(items, includeStaleBlockers, dependencyCycleSeverit
         closure_like_actual_result_pattern_source: lifecyclePatternPolicy.closure_like_metadata_field_pattern_sources.actual_result
       }
     },
-    warnings
+    warnings,
+    terminalParentFixRows
   };
 }
 async function buildFilesCheck(items, workspaceRoot, pmRoot, fileScanMode, includePmInternals, verboseFileLists) {
   const linkedProjectPaths = /* @__PURE__ */ new Set();
   const missingLinkedPaths = [];
+  const staleLinkRows = [];
   for (const item of items) {
-    const linkedArtifacts = [...item.files ?? [], ...item.docs ?? []];
-    for (const artifact of linkedArtifacts) {
-      if (artifact.scope !== "project") {
-        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);
-      try {
-        const stats = await fs.stat(absolutePath);
-        if (!stats.isFile()) {
+    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;
+        }
+        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()) {
+            missing = true;
+          }
+        } catch {
+          missing = true;
+        }
+        if (missing) {
           missingLinkedPaths.push(normalizedPath);
+          staleLinkRows.push({ item_id: item.id, path: normalizedPath, link_kind: group.link_kind });
         }
-      } catch {
-        missingLinkedPaths.push(normalizedPath);
       }
     }
   }
@@ -910,6 +1169,13 @@ async function buildFilesCheck(items, workspaceRoot, pmRoot, fileScanMode, inclu
     };
   }
   const orphanedFiles = candidateFiles.filter((candidate) => !linkedProjectPaths.has(candidate));
+  const classifiedStalePaths = classifyStaleLinkedPaths(uniqueMissingLinkedPaths, 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) => ({
+    ...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) {
     warnings.push("validate_files_tracked_all_strict_forces_pm_internals");
@@ -922,6 +1188,7 @@ async function buildFilesCheck(items, workspaceRoot, pmRoot, fileScanMode, inclu
   }
   const summarizedMissing = summarizeFileList(uniqueMissingLinkedPaths, verboseFileLists);
   const summarizedOrphaned = summarizeFileList(orphanedFiles, verboseFileLists);
+  const summarizedClassifications = summarizeFileList(summarizeStaleLinkedPathClassifications(classifiedStalePaths), verboseFileLists);
   return {
     check: {
       name: "files",
@@ -952,13 +1219,18 @@ async function buildFilesCheck(items, workspaceRoot, pmRoot, fileScanMode, inclu
         missing_linked_paths_total: summarizedMissing.total,
         missing_linked_paths: summarizedMissing.values,
         missing_linked_paths_truncated: summarizedMissing.truncated,
+        missing_linked_paths_moved_count: movedStalePathCount,
+        missing_linked_paths_deleted_count: uniqueMissingLinkedPaths.length - movedStalePathCount,
+        missing_linked_path_classifications: summarizedClassifications.values,
+        missing_linked_path_classifications_truncated: summarizedClassifications.truncated,
         orphaned_paths_count: orphanedFiles.length,
         orphaned_paths_total: summarizedOrphaned.total,
         orphaned_paths: summarizedOrphaned.values,
         orphaned_paths_truncated: summarizedOrphaned.truncated
       }
     },
-    warnings
+    warnings,
+    staleLinkPruneRows
   };
 }
 async function buildHistoryDriftCheck(pmRoot, items, verboseDiagnostics) {
@@ -1057,7 +1329,93 @@ function buildCommandReferencesCheck(items, idPrefix, verboseDiagnostics) {
     warnings
   };
 }
+var VALIDATE_AUTO_FIX_MESSAGE = "pm validate auto-fix";
+async function applyValidateFix(fix, global) {
+  switch (fix.kind) {
+    case "set_resolution":
+    case "set_close_reason":
+    case "reparent":
+    case "unset_parent": {
+      const { runUpdate } = await import("./update-I246PCLO.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 === "reparent") {
+        updateOptions.parent = fix.parent_id;
+      } else {
+        updateOptions.unset = ["parent"];
+      }
+      await runUpdate(fix.item_id, updateOptions, global);
+      return;
+    }
+    case "prune_file_link": {
+      throw new Error(`Unsupported non-batched fix kind: ${fix.kind}`);
+    }
+    case "prune_doc_link": {
+      throw new Error(`Unsupported non-batched fix kind: ${fix.kind}`);
+    }
+  }
+}
+function pruneBatchKey(fix) {
+  if (fix.kind !== "prune_file_link" && fix.kind !== "prune_doc_link") {
+    return null;
+  }
+  return `${fix.kind}:${fix.item_id}`;
+}
+async function applyValidateFixes(applicable, global) {
+  const applied = [];
+  const failed = [];
+  const pruneBatches = /* @__PURE__ */ new Map();
+  for (const fix of applicable) {
+    const batchKey = pruneBatchKey(fix);
+    if (batchKey === null) {
+      try {
+        await applyValidateFix(fix, global);
+        applied.push(fix);
+      } catch (error) {
+        failed.push({ fix, error });
+      }
+      continue;
+    }
+    const existing = pruneBatches.get(batchKey);
+    if (existing) {
+      existing.push(fix);
+    } else {
+      pruneBatches.set(batchKey, [fix]);
+    }
+  }
+  for (const batch of pruneBatches.values()) {
+    const first = batch[0];
+    if (!first) {
+      continue;
+    }
+    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");
+        await runFiles(first.item_id, { remove, message: VALIDATE_AUTO_FIX_MESSAGE }, global);
+      } else {
+        const { runDocs } = await import("./docs-I3BAF5WH.js");
+        await runDocs(first.item_id, { remove, message: VALIDATE_AUTO_FIX_MESSAGE }, global);
+      }
+      applied.push(...batch);
+    } catch (error) {
+      failed.push(...batch.map((fix) => ({ fix, error })));
+    }
+  }
+  return { applied, failed };
+}
 async function runValidate(options, global) {
+  const fixesRequested = options.autoFix === true || options.pruneMissing === true;
+  if (options.dryRun === true && !fixesRequested) {
+    throw new PmCliError("--dry-run requires --auto-fix or --prune-missing (there is nothing to preview otherwise).", EXIT_CODE.USAGE);
+  }
+  if (options.fixScope !== void 0 && options.fixScope.length > 0 && options.autoFix !== true) {
+    throw new PmCliError("--fix-scope requires --auto-fix.", EXIT_CODE.USAGE);
+  }
+  const grantedFixScopes = resolveGrantedFixScopes(options.fixScope);
   const pmRoot = resolvePmRoot(process.cwd(), global.path);
   if (!await pathExists(getSettingsPath(pmRoot))) {
     throw new PmCliError(`Tracker is not initialized at ${pmRoot}. Run pm init first.`, EXIT_CODE.NOT_FOUND);
@@ -1085,17 +1443,29 @@ async function runValidate(options, global) {
     checks.push(built.check);
     warnings.push(...built.warnings);
   };
+  let closeReasonBackfillRows = [];
+  let resolutionBackfillRows = [];
+  let terminalParentFixRows = [];
+  let staleLinkPruneRows = [];
   if (requestedChecks.has("metadata")) {
-    record(buildMetadataCheck(items, metadataPolicy, statusRegistry, Boolean(options.verboseDiagnostics)));
+    const built = buildMetadataCheck(items, metadataPolicy, statusRegistry, Boolean(options.verboseDiagnostics));
+    closeReasonBackfillRows = built.closeReasonBackfillRows;
+    record(built);
   }
   if (requestedChecks.has("resolution")) {
-    record(buildResolutionCheck(items, statusRegistry, Boolean(options.verboseDiagnostics)));
+    const built = buildResolutionCheck(items, statusRegistry, Boolean(options.verboseDiagnostics));
+    resolutionBackfillRows = built.resolutionBackfillRows;
+    record(built);
   }
   if (requestedChecks.has("lifecycle")) {
-    record(buildLifecycleCheck(items, Boolean(options.checkStaleBlockers), dependencyCycleSeverity, statusRegistry, lifecyclePatternPolicy, Boolean(options.verboseDiagnostics)));
+    const built = buildLifecycleCheck(items, Boolean(options.checkStaleBlockers), dependencyCycleSeverity, statusRegistry, lifecyclePatternPolicy, Boolean(options.verboseDiagnostics));
+    terminalParentFixRows = built.terminalParentFixRows;
+    record(built);
   }
   if (requestedChecks.has("files")) {
-    record(await buildFilesCheck(items, workspaceRoot, pmRoot, fileScanMode, Boolean(options.includePmInternals), Boolean(options.verboseFileLists)));
+    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, Boolean(options.verboseDiagnostics)));
@@ -1103,6 +1473,47 @@ async function runValidate(options, global) {
   if (requestedChecks.has("history_drift")) {
     record(await buildHistoryDriftCheck(pmRoot, items, Boolean(options.verboseDiagnostics)));
   }
+  let fixes;
+  if (fixesRequested) {
+    const planned = [];
+    if (options.autoFix === true) {
+      planned.push(...planCloseReasonBackfillFixes(closeReasonBackfillRows));
+      planned.push(...planResolutionBackfillFixes(resolutionBackfillRows));
+      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");
   return {
@@ -1110,12 +1521,13 @@ async function runValidate(options, global) {
     has_warnings: normalizedWarnings.length > 0,
     checks,
     warnings: normalizedWarnings,
+    ...fixes !== void 0 ? { fixes } : {},
     generated_at: nowIso()
   };
 }
 export {
   runValidate
 };
-//# sourceMappingURL=validate-EQTT6WVX.js.map
+//# sourceMappingURL=validate-46KCRHL7.js.map
 
-//# debugId=c8e3c91e-a467-515d-8fdd-02fd7c237ebe
+//# debugId=50b9ae79-2f9d-56b7-8b52-24c0a6416cd8