@unbrained/pm-cli 2026.3.12 → 2026.5.1

package/dist/cli/commands/validate.js

@@ -0,0 +1,1140 @@
+import fs from "node:fs/promises";
+import { execFile } from "node:child_process";
+import path from "node:path";
+import { promisify } from "node:util";
+import { getActiveExtensionRegistrations } from "../../core/extensions/index.js";
+import { pathExists } from "../../core/fs/fs-utils.js";
+import { hashDocument } from "../../core/history/history.js";
+import { normalizeStatusInput } from "../../core/item/status.js";
+import { resolveItemTypeRegistry } from "../../core/item/type-registry.js";
+import { resolveRuntimeStatusRegistry } from "../../core/schema/runtime-schema.js";
+import { DEFAULT_VALIDATE_CLOSURE_LIKE_METADATA_FIELD_PATTERNS, DEFAULT_VALIDATE_STALE_BLOCKER_REASON_PATTERNS, EXIT_CODE, PM_DIRNAME, } from "../../core/shared/constants.js";
+import { PmCliError } from "../../core/shared/errors.js";
+import { nowIso } from "../../core/shared/time.js";
+import { listAllFrontMatterWithBody } from "../../core/store/item-store.js";
+import { getHistoryPath, getSettingsPath, resolvePmRoot } from "../../core/store/paths.js";
+import { readSettings } from "../../core/store/settings.js";
+import { extractReferencedPmItemIdsFromCommand } from "./test.js";
+const FILE_SCAN_DIRECTORIES = ["src", "tests", "docs"];
+const FILE_SCAN_ROOT_FILES = [
+    "README.md",
+    "PRD.md",
+    "CHANGELOG.md",
+    "AGENTS.md",
+    "CONTRIBUTING.md",
+    "SECURITY.md",
+    "CODE_OF_CONDUCT.md",
+    "LICENSE",
+];
+const DIRECTORY_IGNORE_SET = new Set(["node_modules", ".git", ".cursor", ".agents", "dist", "coverage"]);
+const RESOLUTION_FIELD_KEYS = ["resolution", "expected_result", "actual_result"];
+const VALIDATE_FILE_SCAN_MODES = ["default", "tracked-all", "tracked-all-strict"];
+const VALIDATE_METADATA_PROFILE_VALUES = ["core", "strict", "custom"];
+const VALIDATE_DEPENDENCY_CYCLE_SEVERITY_VALUES = ["off", "warn", "error"];
+const LIFECYCLE_PATTERN_FIELD_KEYS = ["blocked_reason", "resolution", "actual_result"];
+const CORE_METADATA_REQUIRED_FIELDS = ["author", "acceptance_criteria", "estimated_minutes", "close_reason"];
+const STRICT_METADATA_REQUIRED_FIELDS = [
+    ...CORE_METADATA_REQUIRED_FIELDS,
+    "reviewer",
+    "risk",
+    "confidence",
+    "sprint",
+    "release",
+];
+const SUPPORTED_METADATA_REQUIRED_FIELDS = [
+    ...new Set([...STRICT_METADATA_REQUIRED_FIELDS]),
+];
+const METADATA_REQUIRED_FIELD_ALIASES = {
+    author: "author",
+    acceptance_criteria: "acceptance_criteria",
+    "acceptance-criteria": "acceptance_criteria",
+    estimated_minutes: "estimated_minutes",
+    "estimated-minutes": "estimated_minutes",
+    estimate: "estimated_minutes",
+    close_reason: "close_reason",
+    "close-reason": "close_reason",
+    reviewer: "reviewer",
+    risk: "risk",
+    confidence: "confidence",
+    sprint: "sprint",
+    release: "release",
+};
+const METADATA_WARNING_TOKEN_BY_FIELD = {
+    author: "validate_metadata_missing_author",
+    acceptance_criteria: "validate_metadata_missing_acceptance_criteria",
+    estimated_minutes: "validate_metadata_missing_estimate",
+    close_reason: "validate_metadata_missing_close_reason",
+    reviewer: "validate_metadata_missing_reviewer",
+    risk: "validate_metadata_missing_risk",
+    confidence: "validate_metadata_missing_confidence",
+    sprint: "validate_metadata_missing_sprint",
+    release: "validate_metadata_missing_release",
+};
+const METADATA_COUNT_KEY_BY_FIELD = {
+    author: "missing_author",
+    acceptance_criteria: "missing_acceptance_criteria",
+    estimated_minutes: "missing_estimated_minutes",
+    close_reason: "closed_missing_close_reason",
+    reviewer: "missing_reviewer",
+    risk: "missing_risk",
+    confidence: "missing_confidence",
+    sprint: "missing_sprint",
+    release: "missing_release",
+};
+const METADATA_ITEM_IDS_KEY_BY_FIELD = {
+    author: "missing_author_item_ids",
+    acceptance_criteria: "missing_acceptance_criteria_item_ids",
+    estimated_minutes: "missing_estimated_minutes_item_ids",
+    close_reason: "closed_missing_close_reason_item_ids",
+    reviewer: "missing_reviewer_item_ids",
+    risk: "missing_risk_item_ids",
+    confidence: "missing_confidence_item_ids",
+    sprint: "missing_sprint_item_ids",
+    release: "missing_release_item_ids",
+};
+const METADATA_TRUNCATED_KEY_BY_FIELD = {
+    author: "missing_author_truncated",
+    acceptance_criteria: "missing_acceptance_criteria_truncated",
+    estimated_minutes: "missing_estimated_minutes_truncated",
+    close_reason: "closed_missing_close_reason_truncated",
+    reviewer: "missing_reviewer_truncated",
+    risk: "missing_risk_truncated",
+    confidence: "missing_confidence_truncated",
+    sprint: "missing_sprint_truncated",
+    release: "missing_release_truncated",
+};
+const GIT_LS_FILES_MAX_BUFFER = 32 * 1024 * 1024;
+const FILE_LIST_SUMMARY_LIMIT = 40;
+const execFileAsync = promisify(execFile);
+function normalizeRelativePath(value) {
+    return value.replaceAll("\\", "/").replace(/^\.\/+/, "").replace(/^\/+/, "");
+}
+function normalizeRelativeDirectoryPath(value) {
+    const normalized = normalizeRelativePath(value);
+    return normalized.replace(/\/+$/, "");
+}
+function toNonEmptyString(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function toMeaningfulString(value) {
+    const normalized = toNonEmptyString(value);
+    if (!normalized) {
+        return undefined;
+    }
+    const lowered = normalized.toLowerCase();
+    if (lowered === "none" || lowered === "null" || lowered === "n/a" || lowered === "na") {
+        return undefined;
+    }
+    return normalized;
+}
+function normalizeStatusForRegistry(status, statusRegistry) {
+    return normalizeStatusInput(status, statusRegistry) ?? status;
+}
+function isTerminalStatus(status, statusRegistry) {
+    return statusRegistry.terminal_statuses.has(normalizeStatusForRegistry(status, statusRegistry));
+}
+function normalizeLifecyclePatternList(values) {
+    return [...new Set((values ?? []).map((value) => value.trim().toLowerCase()).filter((value) => value.length > 0))].sort((left, right) => left.localeCompare(right));
+}
+function areSortedStringListsEqual(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    return left.every((value, index) => value === right[index]);
+}
+function resolveLifecyclePatternPolicy(settings) {
+    const defaultStalePatterns = normalizeLifecyclePatternList(DEFAULT_VALIDATE_STALE_BLOCKER_REASON_PATTERNS);
+    const defaultClosureLikePatterns = {
+        blocked_reason: normalizeLifecyclePatternList(DEFAULT_VALIDATE_CLOSURE_LIKE_METADATA_FIELD_PATTERNS.blocked_reason),
+        resolution: normalizeLifecyclePatternList(DEFAULT_VALIDATE_CLOSURE_LIKE_METADATA_FIELD_PATTERNS.resolution),
+        actual_result: normalizeLifecyclePatternList(DEFAULT_VALIDATE_CLOSURE_LIKE_METADATA_FIELD_PATTERNS.actual_result),
+    };
+    const staleBlockerReasonPatterns = normalizeLifecyclePatternList(settings.validation.lifecycle_stale_blocker_reason_patterns);
+    const closureLikePatterns = {
+        blocked_reason: normalizeLifecyclePatternList(settings.validation.lifecycle_closure_like_blocked_reason_patterns),
+        resolution: normalizeLifecyclePatternList(settings.validation.lifecycle_closure_like_resolution_patterns),
+        actual_result: normalizeLifecyclePatternList(settings.validation.lifecycle_closure_like_actual_result_patterns),
+    };
+    return {
+        stale_blocker_reason_patterns: staleBlockerReasonPatterns,
+        stale_blocker_reason_pattern_source: areSortedStringListsEqual(staleBlockerReasonPatterns, defaultStalePatterns)
+            ? "default"
+            : "settings",
+        closure_like_metadata_field_patterns: closureLikePatterns,
+        closure_like_metadata_field_pattern_sources: {
+            blocked_reason: areSortedStringListsEqual(closureLikePatterns.blocked_reason, defaultClosureLikePatterns.blocked_reason)
+                ? "default"
+                : "settings",
+            resolution: areSortedStringListsEqual(closureLikePatterns.resolution, defaultClosureLikePatterns.resolution)
+                ? "default"
+                : "settings",
+            actual_result: areSortedStringListsEqual(closureLikePatterns.actual_result, defaultClosureLikePatterns.actual_result)
+                ? "default"
+                : "settings",
+        },
+    };
+}
+function resolveValidateMetadataProfile(value) {
+    const normalized = value?.trim().toLowerCase();
+    if (!normalized || normalized.length === 0) {
+        return "core";
+    }
+    if (VALIDATE_METADATA_PROFILE_VALUES.includes(normalized)) {
+        return normalized;
+    }
+    throw new PmCliError(`Unknown --metadata-profile value "${value}". Supported values: ${VALIDATE_METADATA_PROFILE_VALUES.join(", ")}.`, EXIT_CODE.USAGE);
+}
+function resolveDependencyCycleSeverity(value) {
+    const normalized = value?.trim().toLowerCase();
+    if (!normalized || normalized.length === 0) {
+        return "warn";
+    }
+    if (VALIDATE_DEPENDENCY_CYCLE_SEVERITY_VALUES.includes(normalized)) {
+        return normalized;
+    }
+    throw new PmCliError(`Unknown --dependency-cycle-severity value "${value}". Supported values: ${VALIDATE_DEPENDENCY_CYCLE_SEVERITY_VALUES.join(", ")}.`, EXIT_CODE.USAGE);
+}
+function normalizeMetadataRequiredFieldsFromSettings(values) {
+    const normalized = [...new Set((values ?? []).map((value) => value.trim().toLowerCase().replaceAll("-", "_")))];
+    return normalized
+        .map((value) => METADATA_REQUIRED_FIELD_ALIASES[value])
+        .filter((value) => value !== undefined)
+        .sort((left, right) => left.localeCompare(right));
+}
+function resolveValidateMetadataPolicy(profile, profileSource, configuredCustomFields) {
+    const normalizedCustomFields = normalizeMetadataRequiredFieldsFromSettings(configuredCustomFields);
+    if (profile === "core") {
+        return {
+            profile,
+            profile_source: profileSource,
+            required_fields: [...CORE_METADATA_REQUIRED_FIELDS],
+            configured_custom_fields: normalizedCustomFields,
+            fallback_to_core: false,
+            warnings: [],
+        };
+    }
+    if (profile === "strict") {
+        return {
+            profile,
+            profile_source: profileSource,
+            required_fields: [...STRICT_METADATA_REQUIRED_FIELDS],
+            configured_custom_fields: normalizedCustomFields,
+            fallback_to_core: false,
+            warnings: [],
+        };
+    }
+    if (normalizedCustomFields.length > 0) {
+        return {
+            profile,
+            profile_source: profileSource,
+            required_fields: normalizedCustomFields,
+            configured_custom_fields: normalizedCustomFields,
+            fallback_to_core: false,
+            warnings: [],
+        };
+    }
+    return {
+        profile,
+        profile_source: profileSource,
+        required_fields: [...CORE_METADATA_REQUIRED_FIELDS],
+        configured_custom_fields: normalizedCustomFields,
+        fallback_to_core: true,
+        warnings: ["validate_metadata_custom_profile_missing_required_fields:0"],
+    };
+}
+function isMetadataFieldMissing(item, field, statusRegistry) {
+    if (field === "author") {
+        return !toNonEmptyString(item.author);
+    }
+    if (field === "acceptance_criteria") {
+        return !toNonEmptyString(item.acceptance_criteria);
+    }
+    if (field === "estimated_minutes") {
+        return !Number.isFinite(item.estimated_minutes);
+    }
+    if (field === "close_reason") {
+        return normalizeStatusForRegistry(item.status, statusRegistry) === statusRegistry.close_status && !toNonEmptyString(item.close_reason);
+    }
+    if (field === "reviewer") {
+        return !toNonEmptyString(item.reviewer);
+    }
+    if (field === "risk") {
+        return !toNonEmptyString(item.risk);
+    }
+    if (field === "confidence") {
+        if (typeof item.confidence === "number") {
+            return !Number.isFinite(item.confidence);
+        }
+        return !toNonEmptyString(item.confidence);
+    }
+    if (field === "sprint") {
+        return !toNonEmptyString(item.sprint);
+    }
+    return !toNonEmptyString(item.release);
+}
+function resolveFileScanMode(scanMode) {
+    if (scanMode === undefined) {
+        return "default";
+    }
+    const normalized = scanMode.trim().toLowerCase();
+    if (normalized.length === 0) {
+        return "default";
+    }
+    if (normalized === "default") {
+        return "default";
+    }
+    if (normalized === "tracked-all" || normalized === "tracked_all") {
+        return "tracked-all";
+    }
+    if (normalized === "tracked-all-strict" || normalized === "tracked_all_strict") {
+        return "tracked-all-strict";
+    }
+    throw new PmCliError(`Unknown --scan-mode value "${scanMode}". Supported values: ${VALIDATE_FILE_SCAN_MODES.join(", ")}.`, EXIT_CODE.USAGE);
+}
+function resolveWorkspaceRoot(pmRoot) {
+    const resolvedPmRoot = path.resolve(pmRoot);
+    const normalizedPmRoot = resolvedPmRoot.replaceAll("\\", "/");
+    if (normalizedPmRoot.endsWith("/.agents/pm")) {
+        return path.dirname(path.dirname(resolvedPmRoot));
+    }
+    const resolvedCwd = path.resolve(process.cwd());
+    const relativeFromPmRoot = path.relative(resolvedPmRoot, resolvedCwd);
+    const cwdInsidePmRoot = relativeFromPmRoot.length === 0 ||
+        (!relativeFromPmRoot.startsWith("..") && !path.isAbsolute(relativeFromPmRoot));
+    if (cwdInsidePmRoot) {
+        return resolvedPmRoot;
+    }
+    /* c8 ignore next 2 -- non-standard PM root layouts are integration-only edge cases. */
+    return resolvedCwd;
+}
+async function listFilesRecursive(basePath, relativePath, output) {
+    const targetDirectory = relativePath.length > 0 ? path.join(basePath, relativePath) : basePath;
+    let entries;
+    try {
+        entries = await fs.readdir(targetDirectory, { withFileTypes: true });
+    }
+    catch (error) {
+        if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+            return;
+        }
+        throw error;
+    }
+    for (const entry of entries) {
+        if (entry.name.startsWith(".")) {
+            continue;
+        }
+        const childRelative = relativePath.length > 0 ? path.join(relativePath, entry.name) : entry.name;
+        if (entry.isDirectory()) {
+            if (DIRECTORY_IGNORE_SET.has(entry.name)) {
+                continue;
+            }
+            await listFilesRecursive(basePath, childRelative, output);
+            continue;
+        }
+        /* c8 ignore next 3 -- non-file dirent variants (symlink/socket) are filesystem-specific. */
+        if (!entry.isFile()) {
+            continue;
+        }
+        output.push(normalizeRelativePath(childRelative));
+    }
+}
+async function collectDefaultProjectFileCandidates(workspaceRoot) {
+    const discovered = [];
+    for (const directory of FILE_SCAN_DIRECTORIES) {
+        await listFilesRecursive(workspaceRoot, directory, discovered);
+    }
+    for (const candidate of FILE_SCAN_ROOT_FILES) {
+        const absolute = path.join(workspaceRoot, candidate);
+        try {
+            const stats = await fs.stat(absolute);
+            /* c8 ignore start -- root-candidate presence depends on fixture workspace composition. */
+            if (stats.isFile()) {
+                discovered.push(normalizeRelativePath(candidate));
+            }
+            /* c8 ignore stop */
+        }
+        catch {
+            // Ignore root-file candidates that are not present in this workspace.
+        }
+    }
+    return [...new Set(discovered)].sort((left, right) => left.localeCompare(right));
+}
+async function collectTrackedGitFileCandidates(workspaceRoot) {
+    try {
+        const { stdout } = await execFileAsync("git", ["ls-files", "-z"], {
+            cwd: workspaceRoot,
+            encoding: "utf8",
+            maxBuffer: GIT_LS_FILES_MAX_BUFFER,
+            windowsHide: true,
+        });
+        const discovered = stdout
+            .split("\0")
+            .map((value) => normalizeRelativePath(value))
+            .filter((value) => value.length > 0);
+        return [...new Set(discovered)].sort((left, right) => left.localeCompare(right));
+    }
+    catch {
+        /* c8 ignore start -- fallback path exercised only when git metadata is unavailable. */
+        return null;
+        /* c8 ignore stop */
+    }
+}
+function resolvePmInternalCandidatePrefixes(pmRoot, workspaceRoot) {
+    const prefixes = new Set();
+    const configuredDefault = normalizeRelativeDirectoryPath(PM_DIRNAME);
+    if (configuredDefault.length > 0) {
+        prefixes.add(configuredDefault);
+    }
+    const relativePmRoot = normalizeRelativeDirectoryPath(path.relative(workspaceRoot, pmRoot));
+    if (relativePmRoot.length > 0 && !relativePmRoot.startsWith("..")) {
+        prefixes.add(relativePmRoot);
+    }
+    return [...prefixes].sort((left, right) => left.localeCompare(right));
+}
+function hasPathPrefix(candidate, prefixes) {
+    for (const prefix of prefixes) {
+        if (candidate === prefix || candidate.startsWith(`${prefix}/`)) {
+            return true;
+        }
+    }
+    return false;
+}
+async function collectProjectFileCandidates(workspaceRoot, scanMode) {
+    if (scanMode === "tracked-all" || scanMode === "tracked-all-strict") {
+        const trackedCandidates = await collectTrackedGitFileCandidates(workspaceRoot);
+        if (trackedCandidates) {
+            return {
+                requestedMode: scanMode,
+                appliedMode: scanMode,
+                source: "tracked-git",
+                candidateFiles: trackedCandidates,
+                candidateTotal: trackedCandidates.length,
+                candidateScanned: trackedCandidates.length,
+            };
+        }
+        /* c8 ignore start -- deterministic fallback retained for non-git workspaces. */
+        const fallbackCandidates = await collectDefaultProjectFileCandidates(workspaceRoot);
+        return {
+            requestedMode: scanMode,
+            appliedMode: "default",
+            source: "tracked-all-fallback-default",
+            candidateFiles: fallbackCandidates,
+            candidateTotal: fallbackCandidates.length,
+            candidateScanned: fallbackCandidates.length,
+        };
+        /* c8 ignore stop */
+    }
+    const defaultCandidates = await collectDefaultProjectFileCandidates(workspaceRoot);
+    return {
+        requestedMode: scanMode,
+        appliedMode: "default",
+        source: "default-curated",
+        candidateFiles: defaultCandidates,
+        candidateTotal: defaultCandidates.length,
+        candidateScanned: defaultCandidates.length,
+    };
+}
+function summarizeList(values, limit = 200) {
+    /* c8 ignore start -- truncation behavior only surfaces with very large synthetic datasets. */
+    if (values.length <= limit) {
+        return { values, truncated: false };
+    }
+    return {
+        values: values.slice(0, limit),
+        truncated: true,
+    };
+    /* c8 ignore stop */
+}
+function summarizeFileList(values, verboseFileLists) {
+    if (verboseFileLists) {
+        return {
+            values,
+            truncated: false,
+            total: values.length,
+        };
+    }
+    const summary = summarizeList(values, FILE_LIST_SUMMARY_LIMIT);
+    return {
+        values: summary.values,
+        truncated: summary.truncated,
+        total: values.length,
+    };
+}
+const RESOLUTION_REMEDIATION_FLAG_BY_FIELD = {
+    resolution: "--resolution",
+    expected_result: "--expected-result",
+    actual_result: "--actual-result",
+};
+const RESOLUTION_REMEDIATION_PLACEHOLDER_BY_FIELD = {
+    resolution: "Describe how this item was resolved",
+    expected_result: "Describe the expected result",
+    actual_result: "Describe the actual result",
+};
+function buildResolutionRemediationCommand(row) {
+    const fieldArguments = row.missing_fields
+        .map((field) => `${RESOLUTION_REMEDIATION_FLAG_BY_FIELD[field]} \"${RESOLUTION_REMEDIATION_PLACEHOLDER_BY_FIELD[field]}\"`)
+        .join(" ");
+    return `pm update ${row.id} ${fieldArguments} --message \"Backfill resolution metadata\"`;
+}
+function resolveRequestedChecks(options) {
+    const requested = new Set();
+    if (options.checkMetadata) {
+        requested.add("metadata");
+    }
+    if (options.checkResolution) {
+        requested.add("resolution");
+    }
+    if (options.checkLifecycle || options.checkStaleBlockers) {
+        requested.add("lifecycle");
+    }
+    if (options.checkFiles) {
+        requested.add("files");
+    }
+    if (options.checkHistoryDrift) {
+        requested.add("history_drift");
+    }
+    if (options.checkCommandReferences) {
+        requested.add("command_references");
+    }
+    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;
+}
+function buildMetadataCheck(items, metadataPolicy, statusRegistry) {
+    const missingByField = Object.fromEntries(SUPPORTED_METADATA_REQUIRED_FIELDS.map((field) => [field, []]));
+    for (const item of items) {
+        for (const field of SUPPORTED_METADATA_REQUIRED_FIELDS) {
+            if (!isMetadataFieldMissing(item, field, statusRegistry)) {
+                continue;
+            }
+            missingByField[field].push(item.id);
+        }
+    }
+    const warningTokens = [...metadataPolicy.warnings];
+    for (const field of metadataPolicy.required_fields) {
+        const missingItems = missingByField[field];
+        if (missingItems.length === 0) {
+            continue;
+        }
+        warningTokens.push(`${METADATA_WARNING_TOKEN_BY_FIELD[field]}:${missingItems.length}`);
+    }
+    const counts = Object.fromEntries(SUPPORTED_METADATA_REQUIRED_FIELDS.map((field) => [METADATA_COUNT_KEY_BY_FIELD[field], missingByField[field].length]));
+    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],
+        configured_custom_required_fields: [...metadataPolicy.configured_custom_fields],
+        supported_required_fields: [...SUPPORTED_METADATA_REQUIRED_FIELDS],
+        counts,
+    };
+    for (const field of SUPPORTED_METADATA_REQUIRED_FIELDS) {
+        const summarized = summarizeList(missingByField[field]);
+        details[METADATA_ITEM_IDS_KEY_BY_FIELD[field]] = summarized.values;
+        details[METADATA_TRUNCATED_KEY_BY_FIELD[field]] = summarized.truncated;
+    }
+    return {
+        check: {
+            name: "metadata",
+            status: warningTokens.length === 0 ? "ok" : "warn",
+            details,
+        },
+        warnings: warningTokens,
+    };
+}
+function buildResolutionCheck(items, statusRegistry) {
+    const terminalDoneStatuses = new Set(statusRegistry.terminal_done_statuses);
+    terminalDoneStatuses.add(statusRegistry.close_status);
+    const closedItems = items.filter((item) => terminalDoneStatuses.has(normalizeStatusForRegistry(item.status, statusRegistry)));
+    const missingResolutionRows = [];
+    for (const item of closedItems) {
+        const missingFields = RESOLUTION_FIELD_KEYS.filter((field) => !toNonEmptyString(item[field]));
+        if (missingFields.length === 0) {
+            continue;
+        }
+        missingResolutionRows.push({
+            id: item.id,
+            missing_fields: missingFields,
+        });
+    }
+    const warnings = missingResolutionRows.length > 0 ? [`validate_resolution_missing_fields:${missingResolutionRows.length}`] : [];
+    const summarizedRows = summarizeList(missingResolutionRows.map((row) => `${row.id}:${row.missing_fields.join(",")}`));
+    const remediationHints = missingResolutionRows.map((row) => buildResolutionRemediationCommand(row));
+    const summarizedHints = summarizeList(remediationHints);
+    return {
+        check: {
+            name: "resolution",
+            status: warnings.length === 0 ? "ok" : "warn",
+            details: {
+                checked_closed_items: closedItems.length,
+                missing_resolution_items: missingResolutionRows.length,
+                missing_resolution_rows: summarizedRows.values,
+                missing_resolution_rows_truncated: summarizedRows.truncated,
+                missing_resolution_remediation_hints: summarizedHints.values,
+                missing_resolution_remediation_hints_truncated: summarizedHints.truncated,
+            },
+        },
+        warnings,
+    };
+}
+function buildLifecycleDependencyGraph(activeItems) {
+    const activeItemIds = new Set(activeItems.map((item) => item.id));
+    const graph = new Map();
+    const sortedItems = [...activeItems].sort((left, right) => left.id.localeCompare(right.id));
+    for (const item of sortedItems) {
+        const edges = new Set();
+        for (const dependency of item.dependencies ?? []) {
+            const dependencyId = toMeaningfulString(dependency.id);
+            if (!dependencyId || !activeItemIds.has(dependencyId)) {
+                continue;
+            }
+            edges.add(dependencyId);
+        }
+        graph.set(item.id, [...edges].sort((left, right) => left.localeCompare(right)));
+    }
+    return graph;
+}
+function findLifecycleDependencyCycleComponents(graph) {
+    let nextIndex = 0;
+    const indexById = new Map();
+    const lowLinkById = new Map();
+    const stack = [];
+    const inStack = new Set();
+    const components = [];
+    const visit = (id) => {
+        indexById.set(id, nextIndex);
+        lowLinkById.set(id, nextIndex);
+        nextIndex += 1;
+        stack.push(id);
+        inStack.add(id);
+        for (const dependencyId of graph.get(id) ?? []) {
+            if (!indexById.has(dependencyId)) {
+                visit(dependencyId);
+                lowLinkById.set(id, Math.min(lowLinkById.get(id), lowLinkById.get(dependencyId)));
+            }
+            else if (inStack.has(dependencyId)) {
+                lowLinkById.set(id, Math.min(lowLinkById.get(id), indexById.get(dependencyId)));
+            }
+        }
+        if (lowLinkById.get(id) !== indexById.get(id)) {
+            return;
+        }
+        const component = [];
+        while (stack.length > 0) {
+            const member = stack.pop();
+            inStack.delete(member);
+            component.push(member);
+            if (member === id) {
+                break;
+            }
+        }
+        component.sort((left, right) => left.localeCompare(right));
+        components.push(component);
+    };
+    const sortedNodeIds = [...graph.keys()].sort((left, right) => left.localeCompare(right));
+    for (const id of sortedNodeIds) {
+        if (!indexById.has(id)) {
+            visit(id);
+        }
+    }
+    const cycleComponents = components.filter((component) => {
+        if (component.length > 1) {
+            return true;
+        }
+        const selfId = component[0];
+        return (graph.get(selfId) ?? []).includes(selfId);
+    });
+    return cycleComponents.sort((left, right) => left[0].localeCompare(right[0]) ||
+        left.length - right.length ||
+        left.join(",").localeCompare(right.join(",")));
+}
+function resolveLifecycleDependencyCycleSamplePath(component, graph) {
+    const start = component[0];
+    if (component.length === 1) {
+        return [start, start];
+    }
+    const componentSet = new Set(component);
+    const path = [start];
+    const visited = new Set([start]);
+    const search = (current) => {
+        const neighbors = (graph.get(current) ?? []).filter((candidate) => componentSet.has(candidate));
+        for (const next of neighbors) {
+            if (next === start && path.length > 1) {
+                path.push(start);
+                return true;
+            }
+            if (visited.has(next)) {
+                continue;
+            }
+            visited.add(next);
+            path.push(next);
+            if (search(next)) {
+                return true;
+            }
+            path.pop();
+            visited.delete(next);
+        }
+        return false;
+    };
+    if (search(start)) {
+        return [...path];
+    }
+    return [...component, start];
+}
+function detectLifecycleDependencyCycles(activeItems) {
+    const graph = buildLifecycleDependencyGraph(activeItems);
+    const cycleComponents = findLifecycleDependencyCycleComponents(graph);
+    const cycleItemIds = [...new Set(cycleComponents.flat())].sort((left, right) => left.localeCompare(right));
+    const cycleSamplePaths = cycleComponents.map((component) => resolveLifecycleDependencyCycleSamplePath(component, graph).join("->"));
+    return {
+        cycle_count: cycleComponents.length,
+        cycle_item_ids: cycleItemIds,
+        cycle_sample_paths: cycleSamplePaths,
+    };
+}
+function buildLifecycleCheck(items, includeStaleBlockers, dependencyCycleSeverity, statusRegistry, lifecyclePatternPolicy) {
+    const itemsById = new Map(items.map((item) => [item.id, item]));
+    const blockedStatuses = statusRegistry.blocked_statuses.size > 0 ? statusRegistry.blocked_statuses : new Set(["blocked"]);
+    const activeItems = items.filter((item) => !isTerminalStatus(item.status, statusRegistry));
+    const closureLikeRows = [];
+    const terminalParentRows = [];
+    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));
+        if (closureLikeFields.length > 0) {
+            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,
+                });
+            }
+        }
+        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");
+                }
+            }
+            if (reasons.length > 0) {
+                staleBlockerRows.push({
+                    id: item.id,
+                    status: item.status,
+                    reasons: [...new Set(reasons)].sort((left, right) => left.localeCompare(right)),
+                });
+            }
+        }
+    }
+    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));
+    staleBlockerRows.sort((left, right) => left.id.localeCompare(right.id));
+    const dependencyCycleDiagnostics = detectLifecycleDependencyCycles(activeItems);
+    const warnings = [];
+    if (closureLikeRows.length > 0) {
+        warnings.push(`validate_lifecycle_active_closure_like_metadata:${closureLikeRows.length}`);
+    }
+    if (terminalParentRows.length > 0) {
+        warnings.push(`validate_lifecycle_active_terminal_parent:${terminalParentRows.length}`);
+    }
+    if (includeStaleBlockers && staleBlockerRows.length > 0) {
+        warnings.push(`validate_lifecycle_stale_blockers:${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 summarizedClosureLikeRows = summarizeList(closureLikeRows.map((row) => `${row.id}:${row.fields.join(",")}`));
+    const summarizedTerminalParentRows = summarizeList(terminalParentRows.map((row) => `${row.id}:${row.parent_id}:${row.parent_status}`));
+    const summarizedStaleBlockerRows = summarizeList(staleBlockerRows.map((row) => `${row.id}:${row.status}:${row.reasons.join(",")}`));
+    const summarizedDependencyCycleItemIds = summarizeList(dependencyCycleDiagnostics.cycle_item_ids);
+    const summarizedDependencyCycleSamplePaths = summarizeList(dependencyCycleDiagnostics.cycle_sample_paths);
+    return {
+        check: {
+            name: "lifecycle",
+            status: warnings.length === 0 ? "ok" : "warn",
+            details: {
+                checked_active_items: activeItems.length,
+                active_closure_like_metadata_items: 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_rows: summarizedTerminalParentRows.values,
+                active_terminal_parent_rows_truncated: summarizedTerminalParentRows.truncated,
+                stale_blocker_checks_enabled: includeStaleBlockers,
+                stale_blocker_items: staleBlockerRows.length,
+                stale_blocker_rows: summarizedStaleBlockerRows.values,
+                stale_blocker_rows_truncated: summarizedStaleBlockerRows.truncated,
+                dependency_cycle_severity_policy: dependencyCycleSeverity,
+                dependency_cycle_count: dependencyCycleDiagnostics.cycle_count,
+                dependency_cycle_item_count: dependencyCycleDiagnostics.cycle_item_ids.length,
+                dependency_cycle_item_ids: summarizedDependencyCycleItemIds.values,
+                dependency_cycle_item_ids_truncated: summarizedDependencyCycleItemIds.truncated,
+                dependency_cycle_sample_paths: summarizedDependencyCycleSamplePaths.values,
+                dependency_cycle_sample_paths_truncated: summarizedDependencyCycleSamplePaths.truncated,
+                stale_blocker_reason_patterns: [...lifecyclePatternPolicy.stale_blocker_reason_patterns],
+                stale_blocker_reason_pattern_source: lifecyclePatternPolicy.stale_blocker_reason_pattern_source,
+                closure_like_blocked_reason_patterns: [
+                    ...lifecyclePatternPolicy.closure_like_metadata_field_patterns.blocked_reason,
+                ],
+                closure_like_blocked_reason_pattern_source: lifecyclePatternPolicy.closure_like_metadata_field_pattern_sources.blocked_reason,
+                closure_like_resolution_patterns: [...lifecyclePatternPolicy.closure_like_metadata_field_patterns.resolution],
+                closure_like_resolution_pattern_source: lifecyclePatternPolicy.closure_like_metadata_field_pattern_sources.resolution,
+                closure_like_actual_result_patterns: [...lifecyclePatternPolicy.closure_like_metadata_field_patterns.actual_result],
+                closure_like_actual_result_pattern_source: lifecyclePatternPolicy.closure_like_metadata_field_pattern_sources.actual_result,
+            },
+        },
+        warnings,
+    };
+}
+async function buildFilesCheck(items, workspaceRoot, pmRoot, fileScanMode, includePmInternals, verboseFileLists) {
+    const linkedProjectPaths = new Set();
+    const missingLinkedPaths = [];
+    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()) {
+                    missingLinkedPaths.push(normalizedPath);
+                }
+            }
+            catch {
+                missingLinkedPaths.push(normalizedPath);
+            }
+        }
+    }
+    const uniqueMissingLinkedPaths = [...new Set(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 warnings = [];
+    if (strictModeForcesPmInternals) {
+        warnings.push("validate_files_tracked_all_strict_forces_pm_internals");
+    }
+    if (uniqueMissingLinkedPaths.length > 0) {
+        warnings.push(`validate_files_missing_linked_paths:${uniqueMissingLinkedPaths.length}`);
+    }
+    if (orphanedFiles.length > 0) {
+        warnings.push(`validate_files_orphaned_paths:${orphanedFiles.length}`);
+    }
+    const summarizedMissing = summarizeFileList(uniqueMissingLinkedPaths, verboseFileLists);
+    const summarizedOrphaned = summarizeFileList(orphanedFiles, verboseFileLists);
+    return {
+        check: {
+            name: "files",
+            status: warnings.length === 0 ? "ok" : "warn",
+            details: {
+                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,
+                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_requested: includePmInternals,
+                pm_internal_candidate_prefixes: pmInternalCandidatePrefixes,
+                pm_internal_excluded_count: excludedPmInternalCount,
+                excluded_total: excludedPmInternalCount,
+                excluded_by_reason: excludedByReason,
+                linked_project_paths: linkedProjectPaths.size,
+                candidate_total_raw: fileCandidates.candidateTotal,
+                candidate_scanned_raw: fileCandidates.candidateScanned,
+                candidate_total: candidateFiles.length,
+                candidate_scanned: candidateFiles.length,
+                scanned_candidate_files: candidateFiles.length,
+                missing_linked_paths_count: uniqueMissingLinkedPaths.length,
+                missing_linked_paths_total: summarizedMissing.total,
+                missing_linked_paths: summarizedMissing.values,
+                missing_linked_paths_truncated: summarizedMissing.truncated,
+                orphaned_paths_count: orphanedFiles.length,
+                orphaned_paths_total: summarizedOrphaned.total,
+                orphaned_paths: summarizedOrphaned.values,
+                orphaned_paths_truncated: summarizedOrphaned.truncated,
+            },
+        },
+        warnings,
+    };
+}
+async function buildHistoryDriftCheck(pmRoot, items) {
+    const missingStreams = [];
+    const unreadableStreams = [];
+    const hashMismatches = [];
+    for (const item of items) {
+        const historyPath = getHistoryPath(pmRoot, item.id);
+        let latestAfterHash = null;
+        try {
+            const raw = await fs.readFile(historyPath, "utf8");
+            if (raw.trim().length === 0) {
+                missingStreams.push(item.id);
+                continue;
+            }
+            for (const line of raw.split(/\r?\n/)) {
+                const trimmed = line.trim();
+                if (trimmed.length === 0) {
+                    continue;
+                }
+                const parsed = JSON.parse(trimmed);
+                if (typeof parsed.after_hash !== "string" || parsed.after_hash.trim().length === 0) {
+                    throw new Error("missing after_hash");
+                }
+                latestAfterHash = parsed.after_hash;
+            }
+        }
+        catch (error) {
+            if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+                missingStreams.push(item.id);
+            }
+            else {
+                unreadableStreams.push(item.id);
+            }
+            continue;
+        }
+        /* c8 ignore start -- defensive guard for future history schema changes. */
+        if (!latestAfterHash) {
+            missingStreams.push(item.id);
+            continue;
+        }
+        /* c8 ignore stop */
+        const { body, ...frontMatter } = item;
+        const currentHash = hashDocument({
+            front_matter: frontMatter,
+            body,
+        });
+        if (currentHash !== latestAfterHash) {
+            hashMismatches.push(item.id);
+        }
+    }
+    const driftedItems = [...new Set([...missingStreams, ...unreadableStreams, ...hashMismatches])].sort((a, b) => a.localeCompare(b));
+    const warnings = [];
+    if (missingStreams.length > 0) {
+        warnings.push(`validate_history_drift_missing_streams:${missingStreams.length}`);
+    }
+    if (unreadableStreams.length > 0) {
+        warnings.push(`validate_history_drift_unreadable_streams:${unreadableStreams.length}`);
+    }
+    if (hashMismatches.length > 0) {
+        warnings.push(`validate_history_drift_hash_mismatches:${hashMismatches.length}`);
+    }
+    const summarizedDrifted = summarizeList(driftedItems);
+    return {
+        check: {
+            name: "history_drift",
+            status: warnings.length === 0 ? "ok" : "warn",
+            details: {
+                checked_items: items.length,
+                drifted_items_count: driftedItems.length,
+                drifted_items: summarizedDrifted.values,
+                drifted_items_truncated: summarizedDrifted.truncated,
+                counts: {
+                    missing_streams: missingStreams.length,
+                    unreadable_streams: unreadableStreams.length,
+                    hash_mismatches: hashMismatches.length,
+                },
+            },
+        },
+        warnings,
+    };
+}
+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}`;
+}
+function buildCommandReferencesCheck(items, idPrefix) {
+    const knownIds = new Set(items.map((item) => item.id.toLowerCase()));
+    let linkedCommandsScanned = 0;
+    let referencedPmIdCount = 0;
+    const referencedPmIds = new Set();
+    const staleReferenceRows = [];
+    for (const item of items) {
+        for (const linkedTest of item.tests ?? []) {
+            if (typeof linkedTest.command !== "string" || linkedTest.command.trim().length === 0) {
+                continue;
+            }
+            linkedCommandsScanned += 1;
+            const referencedIds = extractReferencedPmItemIdsFromCommand(linkedTest.command, idPrefix);
+            if (referencedIds.length === 0) {
+                continue;
+            }
+            referencedPmIdCount += referencedIds.length;
+            for (const referencedId of referencedIds) {
+                referencedPmIds.add(referencedId);
+                if (!knownIds.has(referencedId.toLowerCase())) {
+                    staleReferenceRows.push(summarizeCommandReferenceRow(item.id, referencedId, linkedTest.command));
+                }
+            }
+        }
+    }
+    const uniqueStaleReferenceRows = [...new Set(staleReferenceRows)].sort((left, right) => left.localeCompare(right));
+    const stalePmIds = [...new Set(uniqueStaleReferenceRows.map((row) => row.split(":")[1] ?? ""))]
+        .filter((value) => value.length > 0)
+        .sort((left, right) => left.localeCompare(right));
+    const warnings = uniqueStaleReferenceRows.length > 0 ? [`validate_command_references_stale_pm_ids:${uniqueStaleReferenceRows.length}`] : [];
+    const summarizedRows = summarizeList(uniqueStaleReferenceRows);
+    const summarizedStalePmIds = summarizeList(stalePmIds);
+    const summarizedReferencedPmIds = summarizeList([...referencedPmIds].sort((left, right) => left.localeCompare(right)));
+    return {
+        check: {
+            name: "command_references",
+            status: warnings.length === 0 ? "ok" : "warn",
+            details: {
+                checked_items: items.length,
+                linked_commands_scanned: linkedCommandsScanned,
+                referenced_pm_ids_count: referencedPmIdCount,
+                unique_referenced_pm_ids_count: referencedPmIds.size,
+                unique_referenced_pm_ids: summarizedReferencedPmIds.values,
+                unique_referenced_pm_ids_truncated: summarizedReferencedPmIds.truncated,
+                stale_pm_id_references_count: uniqueStaleReferenceRows.length,
+                stale_pm_ids_count: stalePmIds.length,
+                stale_pm_ids: summarizedStalePmIds.values,
+                stale_pm_ids_truncated: summarizedStalePmIds.truncated,
+                stale_pm_id_reference_rows: summarizedRows.values,
+                stale_pm_id_reference_rows_truncated: summarizedRows.truncated,
+            },
+        },
+        warnings,
+    };
+}
+export async function runValidate(options, global) {
+    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);
+    }
+    const settings = await readSettings(pmRoot);
+    const statusRegistry = resolveRuntimeStatusRegistry(settings.schema);
+    const typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
+    const itemReadWarnings = [];
+    const items = await listAllFrontMatterWithBody(pmRoot, settings.item_format, typeRegistry.type_to_folder, itemReadWarnings, settings.schema);
+    const requestedChecks = resolveRequestedChecks(options);
+    const metadataProfileSource = typeof options.metadataProfile === "string" ? "option" : "settings";
+    const metadataProfile = resolveValidateMetadataProfile(typeof options.metadataProfile === "string" ? options.metadataProfile : settings.validation.metadata_profile);
+    const metadataPolicy = resolveValidateMetadataPolicy(metadataProfile, metadataProfileSource, settings.validation.metadata_required_fields);
+    const lifecyclePatternPolicy = resolveLifecyclePatternPolicy(settings);
+    const dependencyCycleSeverity = resolveDependencyCycleSeverity(options.dependencyCycleSeverity);
+    const fileScanMode = resolveFileScanMode(options.scanMode);
+    const workspaceRoot = resolveWorkspaceRoot(pmRoot);
+    const checks = [];
+    const warnings = [...new Set(itemReadWarnings)];
+    if (requestedChecks.has("metadata")) {
+        const metadataCheck = buildMetadataCheck(items, metadataPolicy, statusRegistry);
+        checks.push(metadataCheck.check);
+        warnings.push(...metadataCheck.warnings);
+    }
+    if (requestedChecks.has("resolution")) {
+        const resolutionCheck = buildResolutionCheck(items, statusRegistry);
+        checks.push(resolutionCheck.check);
+        warnings.push(...resolutionCheck.warnings);
+    }
+    if (requestedChecks.has("lifecycle")) {
+        const lifecycleCheck = buildLifecycleCheck(items, Boolean(options.checkStaleBlockers), dependencyCycleSeverity, statusRegistry, lifecyclePatternPolicy);
+        checks.push(lifecycleCheck.check);
+        warnings.push(...lifecycleCheck.warnings);
+    }
+    if (requestedChecks.has("files")) {
+        const filesCheck = await buildFilesCheck(items, workspaceRoot, pmRoot, fileScanMode, Boolean(options.includePmInternals), Boolean(options.verboseFileLists));
+        checks.push(filesCheck.check);
+        warnings.push(...filesCheck.warnings);
+    }
+    if (requestedChecks.has("command_references")) {
+        const commandReferencesCheck = buildCommandReferencesCheck(items, settings.id_prefix);
+        checks.push(commandReferencesCheck.check);
+        warnings.push(...commandReferencesCheck.warnings);
+    }
+    if (requestedChecks.has("history_drift")) {
+        const historyDriftCheck = await buildHistoryDriftCheck(pmRoot, items);
+        checks.push(historyDriftCheck.check);
+        warnings.push(...historyDriftCheck.warnings);
+    }
+    const normalizedWarnings = [...new Set(warnings)].sort((left, right) => left.localeCompare(right));
+    return {
+        ok: normalizedWarnings.length === 0,
+        checks,
+        warnings: normalizedWarnings,
+        generated_at: nowIso(),
+    };
+}
+//# sourceMappingURL=validate.js.map