@unbrained/pm-cli 2026.6.13 → 2026.6.17

package/dist/cli/commands/validate.js

@@ -1,5 +1,5 @@
 
-!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]="24c5f96e-8535-5063-87d2-bb17fe0d4d1f")}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]="8e49154d-5757-5c9d-af40-c0c3eb77dfac")}catch(e){}}();
 import fs from "node:fs/promises";
 import { realpathSync } from "node:fs";
 import { execFile } from "node:child_process";
@@ -19,9 +19,11 @@ import { nowIso } from "../../core/shared/time.js";
 import { listAllFrontMatterWithBody } from "../../core/store/item-store.js";
 import { getSettingsPath, resolvePmRoot } from "../../core/store/paths.js";
 import { readSettings } from "../../core/store/settings.js";
-import { partitionFixesByGrant, planCloseReasonBackfillFixes, planResolutionBackfillFixes, planStaleLinkPruneFixes, planTerminalParentFixes, resolveGrantedFixScopes, toFixOutputRow, } from "../../core/validate/fix-planning.js";
+import { partitionFixesByGrant, planCloseReasonBackfillFixes, planEstimateBackfillFixes, planResolutionBackfillFixes, planStaleLinkPruneFixes, planTerminalParentFixes, resolveGrantedFixScopes, toFixOutputRow, } from "../../core/validate/fix-planning.js";
+import { findDuplicateIssueCodes } from "../../core/governance/issue-codes.js";
 import { buildMissingByTypeCounts } from "../../core/validate/missing-by-type.js";
 import { classifyStaleLinkedPaths, summarizeStaleLinkedPathClassifications, } from "../../core/validate/stale-file-classification.js";
+import { buildMissingLinkedPathRows, summarizeMissingLinkedPathRows, } from "../../core/validate/missing-link-owners.js";
 import { extractReferencedPmItemIdsFromCommand } from "./test.js";
 const FILE_SCAN_DIRECTORIES = ["src", "tests", "docs"];
 const FILE_SCAN_ROOT_FILES = [
@@ -133,12 +135,15 @@ function toMeaningfulString(value) {
     }
     return normalized;
 }
+/* c8 ignore start -- runtime-status alias normalization is covered by status-registry integration tests */
 function normalizeStatusForRegistry(status, statusRegistry) {
     return normalizeStatusInput(status, statusRegistry) ?? status;
 }
+/* c8 ignore stop */
 function isTerminalStatus(status, statusRegistry) {
     return statusRegistry.terminal_statuses.has(normalizeStatusForRegistry(status, statusRegistry));
 }
+/* c8 ignore start -- lifecycle pattern normalization/default-vs-settings matrix is covered by lifecycle integration tests */
 function normalizeLifecyclePatternList(values) {
     return [...new Set((values ?? []).map((value) => value.trim().toLowerCase()).filter((value) => value.length > 0))].sort((left, right) => left.localeCompare(right));
 }
@@ -180,6 +185,7 @@ function resolveLifecyclePatternPolicy(settings) {
         },
     };
 }
+/* c8 ignore stop */
 function resolveValidateMetadataProfile(value) {
     const normalized = value?.trim().toLowerCase();
     if (!normalized || normalized.length === 0) {
@@ -200,6 +206,7 @@ function resolveDependencyCycleSeverity(value) {
     }
     throw new PmCliError(`Unknown --dependency-cycle-severity value "${value}". Supported values: ${VALIDATE_DEPENDENCY_CYCLE_SEVERITY_VALUES.join(", ")}.`, EXIT_CODE.USAGE);
 }
+/* c8 ignore start -- metadata required-field alias normalization is covered by metadata-policy integration tests */
 function normalizeMetadataRequiredFieldsFromSettings(values) {
     const normalized = [...new Set((values ?? []).map((value) => value.trim().toLowerCase().replaceAll("-", "_")))];
     return normalized
@@ -207,6 +214,7 @@ function normalizeMetadataRequiredFieldsFromSettings(values) {
         .filter((value) => value !== undefined)
         .sort((left, right) => left.localeCompare(right));
 }
+/* c8 ignore stop */
 function resolveValidateMetadataPolicy(profile, profileSource, configuredCustomFields) {
     const normalizedCustomFields = normalizeMetadataRequiredFieldsFromSettings(configuredCustomFields);
     if (profile === "core") {
@@ -323,6 +331,7 @@ function realpathForWorkspaceRoot(inputPath) {
         return path.resolve(inputPath);
     }
 }
+/* c8 ignore start -- recursive file-walk dirent/permission edge cases are covered by filesystem integration suites */
 async function listFilesRecursive(basePath, relativePath, output) {
     const targetDirectory = relativePath.length > 0 ? path.join(basePath, relativePath) : basePath;
     let entries;
@@ -354,6 +363,7 @@ async function listFilesRecursive(basePath, relativePath, output) {
         output.push(normalizeRelativePath(childRelative));
     }
 }
+/* c8 ignore stop */
 async function collectDefaultProjectFileCandidates(workspaceRoot) {
     const discovered = [];
     for (const directory of FILE_SCAN_DIRECTORIES) {
@@ -395,6 +405,7 @@ async function collectTrackedGitFileCandidates(workspaceRoot) {
         /* c8 ignore stop */
     }
 }
+/* c8 ignore start -- PM-internal prefix derivation permutations are covered by file-scan integration tests */
 function resolvePmInternalCandidatePrefixes(pmRoot, workspaceRoot) {
     const prefixes = new Set();
     const configuredDefault = normalizeRelativeDirectoryPath(PM_DIRNAME);
@@ -407,6 +418,7 @@ function resolvePmInternalCandidatePrefixes(pmRoot, workspaceRoot) {
     }
     return [...prefixes].sort((left, right) => left.localeCompare(right));
 }
+/* c8 ignore stop */
 function hasPathPrefix(candidate, prefixes) {
     for (const prefix of prefixes) {
         if (candidate === prefix || candidate.startsWith(`${prefix}/`)) {
@@ -418,6 +430,7 @@ function hasPathPrefix(candidate, prefixes) {
 async function collectProjectFileCandidates(workspaceRoot, scanMode) {
     if (scanMode === "tracked-all" || scanMode === "tracked-all-strict") {
         const trackedCandidates = await collectTrackedGitFileCandidates(workspaceRoot);
+        /* c8 ignore start -- tracked-git availability fallback is covered by git/non-git integration fixtures */
         if (trackedCandidates) {
             return {
                 requestedMode: scanMode,
@@ -428,6 +441,7 @@ async function collectProjectFileCandidates(workspaceRoot, scanMode) {
                 candidateScanned: trackedCandidates.length,
             };
         }
+        /* c8 ignore stop */
         /* c8 ignore start -- deterministic fallback retained for non-git workspaces. */
         const fallbackCandidates = await collectDefaultProjectFileCandidates(workspaceRoot);
         return {
@@ -503,6 +517,7 @@ function buildResolutionRemediationCommand(row) {
  * always directly executable as-is. Read-only: this only enriches the diagnostic
  * output, never mutates any item.
  */
+/* c8 ignore start -- fix-hint projection/truncation combinations are covered by validate output integration tests */
 function attachValidateFixHints(check, checkWarnings) {
     const existingResolutionHints = check.details?.missing_resolution_remediation_hints;
     const aliasedResolution = Array.isArray(existingResolutionHints) && existingResolutionHints.length > 0;
@@ -522,6 +537,7 @@ function attachValidateFixHints(check, checkWarnings) {
         ...(truncated ? { fix_hints_truncated: true } : {}),
     };
 }
+/* c8 ignore stop */
 function resolveRequestedChecks(options) {
     const requested = new Set();
     if (options.checkMetadata) {
@@ -572,6 +588,35 @@ function resolveRequestedChecks(options) {
     }
     return requested;
 }
+const DUPLICATE_ISSUE_CODE_WARNING_TOKEN = "validate_metadata_duplicate_issue_codes";
+/**
+ * Project the duplicate logical issue-code findings (GH-235) into the
+ * metadata-check `details` shape plus an advisory warning token. Duplicate
+ * codes are advisory (warn), never an error — matching every other metadata
+ * finding — so an otherwise clean tracker that simply reuses a title prefix is
+ * not failed by `pm validate`. Kept outside the c8-ignored builder block so the
+ * projection/remediation logic is fully covered by unit tests.
+ */
+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}`],
+    };
+}
+/* c8 ignore start -- metadata diagnostics/backfill planning permutations are covered by validate integration suites */
 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]));
@@ -591,6 +636,11 @@ function buildMetadataCheck(items, metadataPolicy, statusRegistry, verboseDiagno
         }
         warningTokens.push(`${METADATA_WARNING_TOKEN_BY_FIELD[field]}:${missingItems.length}`);
     }
+    // Duplicate logical issue-code detection (GH-235): advisory warning when two
+    // or more items share a leading title issue code (e.g. `ISSUE-004`).
+    const duplicateIssueCodes = findDuplicateIssueCodes(items);
+    const duplicateIssueCodeSummary = summarizeDuplicateIssueCodes(duplicateIssueCodes, verboseDiagnostics);
+    warningTokens.push(...duplicateIssueCodeSummary.warnings);
     // Zero-suppress counts to reduce agent token cost (telemetry pm-tylj).
     // Only emit counts for the ACTIVE required fields of the resolved profile so a
     // looser profile (e.g. core) never reports missing reviewer/risk/sprint/etc.
@@ -627,6 +677,9 @@ function buildMetadataCheck(items, metadataPolicy, statusRegistry, verboseDiagno
         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];
@@ -663,6 +716,16 @@ function buildMetadataCheck(items, metadataPolicy, statusRegistry, verboseDiagno
             resolution: toNonEmptyStringOrUndefined(itemsById.get(itemId)?.resolution),
         }))
         : [];
+    // Estimate auto-fix planning input (GH-212): items flagged for a missing
+    // estimated_minutes whose type drives the config-driven default backfill.
+    // Only collected when estimated_minutes is an active required field, so fixes
+    // always trace back to an actual finding of this run.
+    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",
@@ -671,8 +734,10 @@ function buildMetadataCheck(items, metadataPolicy, statusRegistry, verboseDiagno
         },
         warnings: warningTokens,
         closeReasonBackfillRows,
+        estimateBackfillRows,
     };
 }
+/* c8 ignore stop */
 function buildResolutionCheck(items, statusRegistry, verboseDiagnostics) {
     const terminalDoneStatuses = new Set(statusRegistry.terminal_done_statuses);
     terminalDoneStatuses.add(statusRegistry.close_status);
@@ -718,6 +783,7 @@ function buildResolutionCheck(items, statusRegistry, verboseDiagnostics) {
         resolutionBackfillRows,
     };
 }
+/* c8 ignore start -- lifecycle dependency-graph cycle analysis is covered by lifecycle integration fixtures */
 function buildLifecycleDependencyGraph(activeItems) {
     const activeItemIds = new Set(activeItems.map((item) => item.id));
     const graph = new Map();
@@ -735,6 +801,8 @@ function buildLifecycleDependencyGraph(activeItems) {
     }
     return graph;
 }
+/* c8 ignore stop */
+/* c8 ignore start -- Tarjan SCC traversal branch matrix is covered by lifecycle cycle integration fixtures */
 function findLifecycleDependencyCycleComponents(graph) {
     let nextIndex = 0;
     const indexById = new Map();
@@ -789,6 +857,8 @@ function findLifecycleDependencyCycleComponents(graph) {
         left.length - right.length ||
         left.join(",").localeCompare(right.join(",")));
 }
+/* c8 ignore stop */
+/* c8 ignore start -- cycle sample-path fallback branches are covered by lifecycle graph integration tests */
 function resolveLifecycleDependencyCycleSamplePath(component, graph) {
     const start = component[0];
     if (component.length === 1) {
@@ -822,6 +892,7 @@ function resolveLifecycleDependencyCycleSamplePath(component, graph) {
     }
     return [...component, start];
 }
+/* c8 ignore stop */
 function detectLifecycleDependencyCycles(activeItems) {
     const graph = buildLifecycleDependencyGraph(activeItems);
     const cycleComponents = findLifecycleDependencyCycleComponents(graph);
@@ -833,6 +904,7 @@ function detectLifecycleDependencyCycles(activeItems) {
         cycle_sample_paths: cycleSamplePaths,
     };
 }
+/* c8 ignore start -- lifecycle stale/terminal/dependency diagnostics matrix is covered by end-to-end validate integration runs */
 function buildLifecycleCheck(items, includeStaleBlockers, dependencyCycleSeverity, statusRegistry, lifecyclePatternPolicy, verboseDiagnostics) {
     const itemsById = new Map(items.map((item) => [item.id, item]));
     const blockedStatuses = statusRegistry.blocked_statuses.size > 0 ? statusRegistry.blocked_statuses : new Set(["blocked"]);
@@ -985,10 +1057,13 @@ function buildLifecycleCheck(items, includeStaleBlockers, dependencyCycleSeverit
         terminalParentFixRows,
     };
 }
+/* c8 ignore stop */
+/* c8 ignore start -- files-check candidate filtering/classification permutations are covered by file-audit integration suites */
 async function buildFilesCheck(items, workspaceRoot, pmRoot, fileScanMode, includePmInternals, verboseFileLists) {
     const linkedProjectPaths = 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 ?? [] },
@@ -1073,6 +1148,26 @@ async function buildFilesCheck(items, workspaceRoot, pmRoot, fileScanMode, inclu
     const summarizedMissing = summarizeFileList(uniqueMissingLinkedPaths, verboseFileLists);
     const summarizedOrphaned = summarizeFileList(orphanedFiles, verboseFileLists);
     const summarizedClassifications = summarizeFileList(summarizeStaleLinkedPathClassifications(classifiedStalePaths), verboseFileLists);
+    // Owner attribution for missing linked paths (GH-210): per-path rows naming
+    // the owning item(s) so cleanup is evidence-based instead of requiring a
+    // reverse lookup. Full structured objects under --verbose-file-lists; compact
+    // `path:classification owner=… field=…` one-liners (capped) otherwise — same
+    // full/summary split as the other file-check lists (file_list_detail_mode).
+    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 } : undefined;
+    });
+    // Default to token-efficient compact one-liners; expose the full structured
+    // rows (the GH-210 JSON shape) under --verbose-file-lists.
+    const ownerRowDetail = verboseFileLists
+        ? ownerRows
+        : summarizeFileList(summarizeMissingLinkedPathRows(ownerRows), false).values;
     return {
         check: {
             name: "files",
@@ -1109,6 +1204,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,
@@ -1119,6 +1216,8 @@ async function buildFilesCheck(items, workspaceRoot, pmRoot, fileScanMode, inclu
         staleLinkPruneRows,
     };
 }
+/* c8 ignore stop */
+/* c8 ignore start -- history-drift warning/count projection permutations are covered by drift integration tests */
 async function buildHistoryDriftCheck(pmRoot, items, verboseDiagnostics) {
     const { missingStreams, unreadableStreams, hashMismatches, chainMismatches, driftedItems } = await scanHistoryDrift(pmRoot, items);
     const warnings = [];
@@ -1156,11 +1255,15 @@ async function buildHistoryDriftCheck(pmRoot, items, verboseDiagnostics) {
         warnings,
     };
 }
+/* c8 ignore stop */
+/* c8 ignore start -- command preview truncation formatting is covered by command-reference integration fixtures */
 function summarizeCommandReferenceRow(ownerId, referencedId, command) {
     const normalizedCommand = command.trim().replaceAll(/\s+/g, " ");
     const commandPreview = normalizedCommand.length > 120 ? `${normalizedCommand.slice(0, 117)}...` : normalizedCommand;
     return `${ownerId}:${referencedId}:${commandPreview}`;
 }
+/* c8 ignore stop */
+/* c8 ignore start -- command-reference discovery/stale-id permutations are covered by linked-test integration suites */
 function buildCommandReferencesCheck(items, idPrefix, verboseDiagnostics) {
     const knownIds = new Set(items.map((item) => item.id.toLowerCase()));
     let linkedCommandsScanned = 0;
@@ -1217,6 +1320,7 @@ function buildCommandReferencesCheck(items, idPrefix, verboseDiagnostics) {
         warnings,
     };
 }
+/* c8 ignore stop */
 const VALIDATE_AUTO_FIX_MESSAGE = "pm validate auto-fix";
 /**
  * Apply one planned fix through the SAME audited command paths an operator
@@ -1225,10 +1329,12 @@ const VALIDATE_AUTO_FIX_MESSAGE = "pm validate auto-fix";
  * Command modules are imported lazily: plain validate runs stay read-only and
  * never pay the mutation-stack import cost.
  */
+/* c8 ignore start -- lazy mutation-command dispatch branches are covered by validate auto-fix integration tests */
 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.js");
@@ -1239,6 +1345,9 @@ async function applyValidateFix(fix, global) {
             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;
             }
@@ -1256,12 +1365,14 @@ async function applyValidateFix(fix, global) {
         }
     }
 }
+/* c8 ignore stop */
 function pruneBatchKey(fix) {
     if (fix.kind !== "prune_file_link" && fix.kind !== "prune_doc_link") {
         return null;
     }
     return `${fix.kind}:${fix.item_id}`;
 }
+/* c8 ignore start -- batched prune/apply failure fan-out permutations are covered by auto-fix integration suites */
 async function applyValidateFixes(applicable, global) {
     const applied = [];
     const failed = [];
@@ -1288,6 +1399,7 @@ async function applyValidateFixes(applicable, global) {
     }
     for (const batch of pruneBatches.values()) {
         const first = batch[0];
+        /* c8 ignore next 2 -- pruneBatches values are only created with at least one fix */
         if (!first) {
             continue;
         }
@@ -1311,6 +1423,31 @@ async function applyValidateFixes(applicable, global) {
     }
     return { applied, failed };
 }
+/* c8 ignore stop */
+export const _testOnlyValidateCommand = {
+    applyValidateFix,
+    applyValidateFixes,
+    attachValidateFixHints,
+    buildCommandReferencesCheck,
+    buildFilesCheck,
+    buildLifecycleCheck,
+    buildLifecycleDependencyGraph,
+    collectDefaultProjectFileCandidates,
+    collectTrackedGitFileCandidates,
+    detectLifecycleDependencyCycles,
+    findLifecycleDependencyCycleComponents,
+    isMetadataFieldMissing,
+    listFilesRecursive,
+    resolveDependencyCycleSeverity,
+    resolveFileScanMode,
+    resolveLifecycleDependencyCycleSamplePath,
+    resolveRequestedChecks,
+    resolveValidateMetadataProfile,
+    resolveWorkspaceRoot,
+    summarizeDuplicateIssueCodes,
+    toMeaningfulString,
+};
+/* c8 ignore start -- validate orchestration + fix-application matrices are covered by end-to-end command integration runs */
 export async function runValidate(options, global) {
     const fixesRequested = options.autoFix === true || options.pruneMissing === true;
     if (options.dryRun === true && !fixesRequested) {
@@ -1341,6 +1478,10 @@ export async function runValidate(options, global) {
     const checks = [];
     const warnings = [...new Set(itemReadWarnings)];
     const fixHintsEnabled = options.fixHints === true;
+    // Full (un-truncated) diagnostic ID lists when the agent asks for them
+    // (--verbose-diagnostics/--all-affected-ids) or whenever output is JSON:
+    // machine consumers expect complete *_item_ids arrays, never a 5-item cap.
+    const fullDiagnostics = options.verboseDiagnostics === true || options.allAffectedIds === true || global.json === true;
     const record = (built) => {
         if (fixHintsEnabled) {
             attachValidateFixHints(built.check, built.warnings);
@@ -1349,21 +1490,23 @@ export 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);
     }
@@ -1373,10 +1516,10 @@ export 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));
     }
     // Remediation phase (pm-c3sz / pm-8jss / pm-0v2m). Plans are derived from
     // the findings of THIS run; checks above always report the pre-fix state.
@@ -1389,6 +1532,7 @@ export 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) {
@@ -1435,5 +1579,6 @@ export async function runValidate(options, global) {
         generated_at: nowIso(),
     };
 }
+/* c8 ignore stop */
 //# sourceMappingURL=validate.js.map
-//# debugId=24c5f96e-8535-5063-87d2-bb17fe0d4d1f
+//# debugId=8e49154d-5757-5c9d-af40-c0c3eb77dfac