@unbrained/pm-cli 2026.7.5 → 2026.7.7

package/dist/cli-bundle/chunks/validate-Z7L75YEJ.js

@@ -1,2105 +0,0 @@
-
-!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]="7b42ea6d-c9b5-5d22-b82e-64af26f3173c")}catch(e){}}();
-import {
-  extractReferencedPmItemIdsFromCommand
-} from "./chunk-3PL6LEKP.js";
-import {
-  buildRemediationCommands
-} from "./chunk-R2EMWY7Q.js";
-import {
-  scanHistoryDrift
-} from "./chunk-TT42JUMF.js";
-import {
-  isRemoteLinkedArtifactReference
-} from "./chunk-IBMFIKVS.js";
-import "./chunk-BFVHCAOO.js";
-import "./chunk-MZ7VNEVY.js";
-import "./chunk-7WYXBPYQ.js";
-import "./chunk-5JZ7APJU.js";
-import "./chunk-JFCVQXZX.js";
-import "./chunk-K32L7HZO.js";
-import "./chunk-OK5NXCZB.js";
-import "./chunk-53BTLLAF.js";
-import "./chunk-P4SESZGT.js";
-import "./chunk-FUM6UMY4.js";
-import "./chunk-PPE4YUQM.js";
-import "./chunk-AAEQMOC6.js";
-import "./chunk-PJ3A56YF.js";
-import {
-  listAllFrontMatterWithBody
-} from "./chunk-57C2RLW5.js";
-import "./chunk-ZAHXPXVY.js";
-import {
-  CURRENT_ITEM_FORMAT_VERSION,
-  effectiveItemFormatVersion,
-  normalizeStatusInput,
-  scanItemFormatVersions
-} from "./chunk-HK72NWAD.js";
-import {
-  nowIso
-} from "./chunk-FJRKQREY.js";
-import {
-  PmCliError,
-  getActiveExtensionRegistrations,
-  readSettings,
-  resolveEstimateDefaultMinutes
-} from "./chunk-US3T3W5J.js";
-import "./chunk-NER3KUUS.js";
-import "./chunk-NNHHXJB2.js";
-import {
-  DEFAULT_VALIDATE_CLOSURE_LIKE_METADATA_FIELD_PATTERNS,
-  DEFAULT_VALIDATE_STALE_BLOCKER_REASON_PATTERNS,
-  EXIT_CODE,
-  PM_DIRNAME,
-  getSettingsPath,
-  pathExists,
-  resolveItemTypeRegistry,
-  resolvePmRoot,
-  resolveRuntimeStatusRegistry,
-  toNonEmptyStringOrUndefined
-} from "./chunk-YD5FML7K.js";
-
-// dist/cli/commands/validate.js
-import fs from "node:fs/promises";
-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", "estimates", "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 planEstimateBackfillFixes(rows, overrides) {
-  return rows.map((row) => {
-    const minutes = resolveEstimateDefaultMinutes(row.type, overrides);
-    return {
-      item_id: row.id,
-      check: "metadata",
-      field: "estimated_minutes",
-      kind: "set_estimate",
-      value: String(minutes),
-      command: `pm update ${row.id} --estimate ${minutes}`,
-      gate: "estimates"
-    };
-  });
-}
-function planTerminalParentFixes(rows) {
-  return rows.map((row) => {
-    if (row.grandparent_id !== void 0 && row.grandparent_active === true) {
-      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/governance/issue-codes.js
-var ISSUE_CODE_PATTERN = /^([A-Z][A-Z0-9]*-\d+)\b/;
-function extractIssueCode(title) {
-  if (typeof title !== "string") {
-    return null;
-  }
-  const normalized = title.trim().toUpperCase();
-  if (normalized.length === 0) {
-    return null;
-  }
-  const match = ISSUE_CODE_PATTERN.exec(normalized);
-  return match ? match[1] : null;
-}
-function isNonEmptyIdReference(value) {
-  return typeof value === "string" && value.trim().length > 0;
-}
-function findDuplicateIssueCodes(items) {
-  const byCode = /* @__PURE__ */ new Map();
-  for (const item of items) {
-    if (typeof item.title !== "string") {
-      continue;
-    }
-    if (isNonEmptyIdReference(item.duplicate_of)) {
-      continue;
-    }
-    const code = extractIssueCode(item.title);
-    if (code === null) {
-      continue;
-    }
-    let entries = byCode.get(code);
-    if (!entries) {
-      entries = [];
-      byCode.set(code, entries);
-    }
-    if (!entries.some((entry) => entry.id === item.id)) {
-      entries.push({ id: item.id, title: item.title, parent: isNonEmptyIdReference(item.parent) ? item.parent.trim() : null });
-    }
-  }
-  const duplicates = [];
-  for (const [code, entries] of byCode) {
-    if (entries.length < 2) {
-      continue;
-    }
-    const idsInGroup = new Set(entries.map((entry) => entry.id.toLowerCase()));
-    const collisionEntries = entries.filter((entry) => entry.parent === null || !idsInGroup.has(entry.parent.toLowerCase()));
-    if (collisionEntries.length < 2) {
-      continue;
-    }
-    const sorted = [...collisionEntries].sort((left, right) => left.id.localeCompare(right.id));
-    duplicates.push({
-      code,
-      count: sorted.length,
-      ids: sorted.map((entry) => entry.id),
-      titles: sorted.map((entry) => entry.title)
-    });
-  }
-  return duplicates.sort((left, right) => left.code.localeCompare(right.code));
-}
-
-// dist/core/validate/missing-by-type.js
-function buildMissingByTypeCounts(occurrences) {
-  const countsByType = /* @__PURE__ */ new Map();
-  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/core/validate/missing-link-owners.js
-function preferClassification(current, next) {
-  return current === "moved" || next === "moved" ? "moved" : "deleted";
-}
-function ownerKey(input) {
-  return `${input.item_id} ${input.link_kind}`;
-}
-function buildMissingLinkedPathRows(rows, lookup) {
-  const buckets = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    const bucket = buckets.get(row.path);
-    if (bucket) {
-      bucket.classification = preferClassification(bucket.classification, row.classification);
-      bucket.owners.set(ownerKey(row), row);
-    } else {
-      buckets.set(row.path, {
-        classification: row.classification,
-        owners: /* @__PURE__ */ new Map([[ownerKey(row), row]])
-      });
-    }
-  }
-  return [...buckets.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([path2, bucket]) => ({
-    path: path2,
-    classification: bucket.classification,
-    items: [...bucket.owners.values()].map((owner) => {
-      const metadata = lookup(owner.item_id);
-      return {
-        id: owner.item_id,
-        type: metadata?.type ?? "Unknown",
-        title: metadata?.title ?? "",
-        status: metadata?.status ?? "",
-        field: owner.link_kind
-      };
-    }).sort((leftOwner, rightOwner) => {
-      const byId = leftOwner.id.localeCompare(rightOwner.id);
-      return byId !== 0 ? byId : leftOwner.field.localeCompare(rightOwner.field);
-    })
-  }));
-}
-function escapeTitle(title) {
-  return title.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
-}
-function summarizeMissingLinkedPathRows(rows) {
-  const lines = [];
-  for (const row of rows) {
-    for (const owner of row.items) {
-      lines.push(`${row.path}:${row.classification} owner=${owner.id} status=${owner.status} field=${owner.field} title="${escapeTitle(owner.title)}"`);
-    }
-  }
-  return lines;
-}
-
-// dist/cli/commands/validate.js
-var FILE_SCAN_DIRECTORIES = ["src", "tests", "docs"];
-var FILE_SCAN_ROOT_FILES = [
-  "README.md",
-  "PRD.md",
-  "CHANGELOG.md",
-  "AGENTS.md",
-  "CONTRIBUTING.md",
-  "SECURITY.md",
-  "CODE_OF_CONDUCT.md",
-  "LICENSE"
-];
-var DIRECTORY_IGNORE_SET = /* @__PURE__ */ new Set(["node_modules", ".git", ".cursor", ".agents", "dist", "coverage"]);
-var RESOLUTION_FIELD_KEYS = ["resolution", "expected_result", "actual_result"];
-var VALIDATE_FILE_SCAN_MODES = ["default", "tracked-all", "tracked-all-strict"];
-var VALIDATE_METADATA_PROFILE_VALUES = ["core", "strict", "custom"];
-var VALIDATE_DEPENDENCY_CYCLE_SEVERITY_VALUES = ["off", "warn", "error"];
-var CORE_METADATA_REQUIRED_FIELDS = ["author", "acceptance_criteria", "estimated_minutes", "close_reason"];
-var STRICT_METADATA_REQUIRED_FIELDS = [
-  ...CORE_METADATA_REQUIRED_FIELDS,
-  "reviewer",
-  "risk",
-  "confidence",
-  "sprint",
-  "release"
-];
-var SUPPORTED_METADATA_REQUIRED_FIELDS = Array.from(new Set(STRICT_METADATA_REQUIRED_FIELDS));
-var 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"
-};
-var 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"
-};
-var 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"
-};
-var 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"
-};
-var 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"
-};
-var GIT_LS_FILES_MAX_BUFFER = 32 * 1024 * 1024;
-var FILE_LIST_SUMMARY_LIMIT = 40;
-var DIAGNOSTIC_LIST_SUMMARY_LIMIT = 5;
-var LINKED_ARTIFACT_MAX_PATH_LENGTH = 4096;
-var LINKED_ARTIFACT_MAX_SEGMENT_LENGTH = 255;
-var execFileAsync = promisify(execFile);
-function normalizeRelativePath(value) {
-  return value.replaceAll("\\", "/").replace(/^\.\/+/, "").replace(/^\/+/, "");
-}
-function normalizeRelativeDirectoryPath(value) {
-  const normalized = normalizeRelativePath(value);
-  return normalized.replace(/\/+$/, "");
-}
-function toMeaningfulString(value) {
-  const normalized = toNonEmptyStringOrUndefined(value);
-  if (!normalized) {
-    return void 0;
-  }
-  const lowered = normalized.toLowerCase();
-  if (lowered === "none" || lowered === "null" || lowered === "n/a" || lowered === "na") {
-    return void 0;
-  }
-  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 resolveParentCycleSeverity(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 --parent-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 !== void 0).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"]
-  };
-}
-var TERMINAL_EXEMPT_PLANNING_FIELDS = /* @__PURE__ */ new Set([
-  "acceptance_criteria",
-  "estimated_minutes"
-]);
-function isMetadataFieldMissing(item, field, statusRegistry, enforcePlanningFieldsOnTerminal) {
-  if (!enforcePlanningFieldsOnTerminal && TERMINAL_EXEMPT_PLANNING_FIELDS.has(field) && isTerminalStatus(item.status, statusRegistry)) {
-    return false;
-  }
-  if (field === "author") {
-    return !toNonEmptyStringOrUndefined(item.author);
-  }
-  if (field === "acceptance_criteria") {
-    return !toNonEmptyStringOrUndefined(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 && !toNonEmptyStringOrUndefined(item.close_reason);
-  }
-  if (field === "reviewer") {
-    return !toNonEmptyStringOrUndefined(item.reviewer);
-  }
-  if (field === "risk") {
-    return !toNonEmptyStringOrUndefined(item.risk);
-  }
-  if (field === "confidence") {
-    if (typeof item.confidence === "number") {
-      return !Number.isFinite(item.confidence);
-    }
-    return !toNonEmptyStringOrUndefined(item.confidence);
-  }
-  if (field === "sprint") {
-    return !toNonEmptyStringOrUndefined(item.sprint);
-  }
-  return !toNonEmptyStringOrUndefined(item.release);
-}
-function resolveFileScanMode(scanMode) {
-  if (scanMode === void 0) {
-    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 canonicalPmRoot = realpathForWorkspaceRoot(resolvedPmRoot);
-  const canonicalCwd = realpathForWorkspaceRoot(resolvedCwd);
-  const relativeFromPmRoot = path.relative(canonicalPmRoot, canonicalCwd);
-  const cwdInsidePmRoot = relativeFromPmRoot.length === 0 || !relativeFromPmRoot.startsWith("..") && !path.isAbsolute(relativeFromPmRoot);
-  if (cwdInsidePmRoot) {
-    return resolvedPmRoot;
-  }
-  return resolvedCwd;
-}
-function realpathForWorkspaceRoot(inputPath) {
-  try {
-    return realpathSync.native(inputPath);
-  } catch {
-    return path.resolve(inputPath);
-  }
-}
-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;
-    }
-    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);
-      if (stats.isFile()) {
-        discovered.push(normalizeRelativePath(candidate));
-      }
-    } catch {
-    }
-  }
-  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 {
-    return null;
-  }
-}
-function resolvePmInternalCandidatePrefixes(pmRoot, workspaceRoot) {
-  const prefixes = /* @__PURE__ */ 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
-      };
-    }
-    const fallbackCandidates = await collectDefaultProjectFileCandidates(workspaceRoot);
-    return {
-      requestedMode: scanMode,
-      appliedMode: "default",
-      source: "tracked-all-fallback-default",
-      candidateFiles: fallbackCandidates,
-      candidateTotal: fallbackCandidates.length,
-      candidateScanned: fallbackCandidates.length
-    };
-  }
-  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 = DIAGNOSTIC_LIST_SUMMARY_LIMIT) {
-  if (values.length <= limit) {
-    return { values, truncated: false };
-  }
-  return {
-    values: values.slice(0, limit),
-    truncated: true
-  };
-}
-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
-  };
-}
-var RESOLUTION_REMEDIATION_FLAG_BY_FIELD = {
-  resolution: "--resolution",
-  expected_result: "--expected-result",
-  actual_result: "--actual-result"
-};
-var 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 attachValidateFixHints(check, checkWarnings) {
-  const existingResolutionHints = check.details?.missing_resolution_remediation_hints;
-  const aliasedResolution = Array.isArray(existingResolutionHints) && existingResolutionHints.length > 0;
-  const fixHints = aliasedResolution ? existingResolutionHints.filter((hint) => typeof hint === "string") : buildRemediationCommands(checkWarnings);
-  if (fixHints.length === 0) {
-    return;
-  }
-  const truncated = aliasedResolution && check.details?.missing_resolution_remediation_hints_truncated === true;
-  check.details = {
-    ...check.details,
-    fix_hints: fixHints,
-    ...truncated ? { fix_hints_truncated: true } : {}
-  };
-}
-function resolveRequestedChecks(options) {
-  const requested = /* @__PURE__ */ 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) {
-    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");
-      requested.add("format_version");
-    }
-    return requested;
-  }
-  if (options.pruneMissing) {
-    requested.add("files");
-  }
-  return requested;
-}
-var DUPLICATE_ISSUE_CODE_WARNING_TOKEN = "validate_metadata_duplicate_issue_codes";
-function summarizeDuplicateIssueCodes(duplicates, verboseDiagnostics) {
-  if (duplicates.length === 0) {
-    return { rows: [], truncated: false, warnings: [] };
-  }
-  const limit = verboseDiagnostics ? duplicates.length : DIAGNOSTIC_LIST_SUMMARY_LIMIT;
-  const shown = duplicates.slice(0, limit);
-  const rows = shown.map((duplicate) => ({
-    code: duplicate.code,
-    count: duplicate.count,
-    ids: duplicate.ids,
-    titles: duplicate.titles,
-    remediation_hint: `Items ${duplicate.ids.join(", ")} share issue code "${duplicate.code}"; rename or merge so each logical code maps to one item.`
-  }));
-  return {
-    rows,
-    truncated: shown.length < duplicates.length,
-    warnings: [`${DUPLICATE_ISSUE_CODE_WARNING_TOKEN}:${duplicates.length}`]
-  };
-}
-function initializeMissingMetadataByField() {
-  return Object.fromEntries(SUPPORTED_METADATA_REQUIRED_FIELDS.map((field) => [field, []]));
-}
-function collectMissingMetadataByField(items, statusRegistry, enforcePlanningFieldsOnTerminal) {
-  const missingByField = initializeMissingMetadataByField();
-  for (const item of items) {
-    for (const field of SUPPORTED_METADATA_REQUIRED_FIELDS) {
-      if (isMetadataFieldMissing(item, field, statusRegistry, enforcePlanningFieldsOnTerminal)) {
-        missingByField[field].push(item.id);
-      }
-    }
-  }
-  return missingByField;
-}
-function buildMetadataWarningTokens(metadataPolicy, missingByField, duplicateWarnings) {
-  const warningTokens = [...metadataPolicy.warnings];
-  for (const field of metadataPolicy.required_fields) {
-    const missingItems = missingByField[field];
-    if (missingItems.length > 0) {
-      warningTokens.push(`${METADATA_WARNING_TOKEN_BY_FIELD[field]}:${missingItems.length}`);
-    }
-  }
-  warningTokens.push(...duplicateWarnings);
-  return warningTokens;
-}
-function buildMetadataCounts(metadataPolicy, missingByField) {
-  const counts = {};
-  for (const field of metadataPolicy.required_fields) {
-    const missing = missingByField[field];
-    const value = missing ? missing.length : 0;
-    const countKey = METADATA_COUNT_KEY_BY_FIELD[field];
-    if (value > 0 && countKey) {
-      counts[countKey] = value;
-    }
-  }
-  return counts;
-}
-function buildMissingFieldOccurrences(metadataPolicy, missingByField, itemsById) {
-  const occurrences = [];
-  for (const field of metadataPolicy.required_fields) {
-    const missing = missingByField[field];
-    if (!missing) {
-      continue;
-    }
-    for (const itemId of missing) {
-      const itemType = itemsById.get(itemId)?.type;
-      const normalizedItemType = typeof itemType === "string" && itemType.length > 0 ? itemType : "Unknown";
-      occurrences.push({ item_type: normalizedItemType, field });
-    }
-  }
-  return occurrences;
-}
-function attachMissingMetadataItemIds(details, metadataPolicy, missingByField, verboseDiagnostics) {
-  for (const field of metadataPolicy.required_fields) {
-    const missing = missingByField[field];
-    if (!missing || missing.length === 0) {
-      continue;
-    }
-    const idsKey = METADATA_ITEM_IDS_KEY_BY_FIELD[field];
-    const truncatedKey = METADATA_TRUNCATED_KEY_BY_FIELD[field];
-    if (!idsKey || !truncatedKey) {
-      continue;
-    }
-    const summarized = summarizeList(missing, verboseDiagnostics ? missing.length : DIAGNOSTIC_LIST_SUMMARY_LIMIT);
-    details[idsKey] = summarized.values;
-    details[truncatedKey] = summarized.truncated;
-  }
-}
-function buildCloseReasonBackfillRows(metadataPolicy, missingByField, itemsById) {
-  if (!metadataPolicy.required_fields.includes("close_reason")) {
-    return [];
-  }
-  const missing = missingByField.close_reason;
-  if (!missing) {
-    return [];
-  }
-  return missing.map((itemId) => ({
-    id: itemId,
-    resolution: toNonEmptyStringOrUndefined(itemsById.get(itemId)?.resolution)
-  }));
-}
-function buildEstimateBackfillRows(metadataPolicy, missingByField, itemsById) {
-  if (!metadataPolicy.required_fields.includes("estimated_minutes")) {
-    return [];
-  }
-  const missing = missingByField.estimated_minutes;
-  if (!missing) {
-    return [];
-  }
-  return missing.map((itemId) => ({
-    id: itemId,
-    type: toNonEmptyStringOrUndefined(itemsById.get(itemId)?.type)
-  }));
-}
-function buildMetadataCheck(items, metadataPolicy, statusRegistry, verboseDiagnostics) {
-  const itemsById = new Map(items.map((item) => [item.id, item]));
-  const enforcePlanningFieldsOnTerminal = metadataPolicy.profile === "strict";
-  const missingByField = collectMissingMetadataByField(items, statusRegistry, enforcePlanningFieldsOnTerminal);
-  const duplicateIssueCodes = findDuplicateIssueCodes(items);
-  const duplicateIssueCodeSummary = summarizeDuplicateIssueCodes(duplicateIssueCodes, verboseDiagnostics);
-  const warningTokens = buildMetadataWarningTokens(metadataPolicy, missingByField, duplicateIssueCodeSummary.warnings);
-  const counts = buildMetadataCounts(metadataPolicy, missingByField);
-  const missingFieldOccurrences = buildMissingFieldOccurrences(metadataPolicy, missingByField, itemsById);
-  const missingByType = buildMissingByTypeCounts(missingFieldOccurrences);
-  const details = {
-    checked_items: items.length,
-    metadata_profile: metadataPolicy.profile,
-    metadata_profile_source: metadataPolicy.profile_source,
-    metadata_profile_fallback_to_core: metadataPolicy.fallback_to_core,
-    required_fields: [...metadataPolicy.required_fields],
-    supported_required_fields: [...SUPPORTED_METADATA_REQUIRED_FIELDS],
-    counts,
-    missing_by_type: missingByType,
-    duplicate_issue_codes_count: duplicateIssueCodes.length,
-    duplicate_issue_codes: duplicateIssueCodeSummary.rows,
-    duplicate_issue_codes_truncated: duplicateIssueCodeSummary.truncated
-  };
-  if (metadataPolicy.configured_custom_fields.length > 0) {
-    details.configured_custom_required_fields = [...metadataPolicy.configured_custom_fields];
-  }
-  attachMissingMetadataItemIds(details, metadataPolicy, missingByField, verboseDiagnostics);
-  const closeReasonBackfillRows = buildCloseReasonBackfillRows(metadataPolicy, missingByField, itemsById);
-  const estimateBackfillRows = buildEstimateBackfillRows(metadataPolicy, missingByField, itemsById);
-  return {
-    check: {
-      name: "metadata",
-      status: warningTokens.length === 0 ? "ok" : "warn",
-      details
-    },
-    warnings: warningTokens,
-    closeReasonBackfillRows,
-    estimateBackfillRows
-  };
-}
-function buildResolutionCheck(items, statusRegistry, verboseDiagnostics) {
-  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 = [];
-  const resolutionBackfillRows = [];
-  for (const item of closedItems) {
-    const missingFields = RESOLUTION_FIELD_KEYS.filter((field) => !toNonEmptyStringOrUndefined(item[field]));
-    if (missingFields.length === 0) {
-      continue;
-    }
-    missingResolutionRows.push({
-      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;
-  const summarizedRows = summarizeList(missingResolutionRows.map((row) => `${row.id}:${row.missing_fields.join(",")}`), diagnosticLimit);
-  const remediationHints = missingResolutionRows.map((row) => buildResolutionRemediationCommand(row));
-  const summarizedHints = summarizeList(remediationHints, diagnosticLimit);
-  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,
-    resolutionBackfillRows
-  };
-}
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function buildLifecycleDependencyGraph(activeItems, idPrefix = "pm") {
-  const activeItemIds = new Set(activeItems.map((item) => item.id));
-  const graph = /* @__PURE__ */ new Map();
-  const sortedItems = [...activeItems].sort((left, right) => left.id.localeCompare(right.id));
-  for (const item of sortedItems) {
-    const edges = /* @__PURE__ */ new Set();
-    const blockedBy = toMeaningfulString(item.blocked_by);
-    if (blockedBy && activeItemIds.has(blockedBy)) {
-      edges.add(blockedBy);
-    }
-    for (const dependency of item.dependencies ?? []) {
-      const dependencyId = toMeaningfulString(dependency.id);
-      if (!dependencyId || !activeItemIds.has(dependencyId)) {
-        continue;
-      }
-      edges.add(dependencyId);
-    }
-    const definitionOfReady = toMeaningfulString(item.definition_of_ready);
-    if (definitionOfReady) {
-      for (const referencedId of extractItemIds(definitionOfReady, idPrefix)) {
-        if (activeItemIds.has(referencedId)) {
-          edges.add(referencedId);
-        }
-      }
-    }
-    graph.set(item.id, [...edges].sort((left, right) => left.localeCompare(right)));
-  }
-  return graph;
-}
-function extractItemIds(value, idPrefix = "pm") {
-  const normalizedPrefix = (idPrefix.trim().toLowerCase() || "pm").replace(/-+$/g, "");
-  const pattern = new RegExp(`(?:^|[^a-z0-9-])(${escapeRegExp(normalizedPrefix)}-[a-z0-9][a-z0-9-]*)`, "gi");
-  return [...new Set([...value.matchAll(pattern)].map((match) => match[1].toLowerCase()))].sort((left, right) => left.localeCompare(right));
-}
-function findLifecycleDependencyCycleComponents(graph) {
-  let nextIndex = 0;
-  const indexById = /* @__PURE__ */ new Map();
-  const lowLinkById = /* @__PURE__ */ new Map();
-  const stack = [];
-  const inStack = /* @__PURE__ */ 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 path2 = [start];
-  const visited = /* @__PURE__ */ new Set([start]);
-  const search = (current) => {
-    const neighbors = (graph.get(current) ?? []).filter((candidate) => componentSet.has(candidate));
-    for (const next of neighbors) {
-      if (next === start && path2.length > 1) {
-        path2.push(start);
-        return true;
-      }
-      if (visited.has(next)) {
-        continue;
-      }
-      visited.add(next);
-      path2.push(next);
-      if (search(next)) {
-        return true;
-      }
-      path2.pop();
-      visited.delete(next);
-    }
-    return false;
-  };
-  if (search(start)) {
-    return [...path2];
-  }
-  return [...component, start];
-}
-function detectLifecycleDependencyCycles(activeItems, idPrefix = "pm") {
-  const graph = buildLifecycleDependencyGraph(activeItems, idPrefix);
-  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 buildLifecycleParentGraph(items) {
-  const canonicalIdByLowercase = new Map(items.map((item) => [item.id.toLowerCase(), item.id]));
-  const graph = /* @__PURE__ */ new Map();
-  const sortedItems = [...items].sort((left, right) => left.id.localeCompare(right.id));
-  for (const item of sortedItems) {
-    const edges = [];
-    const parentId = toMeaningfulString(item.parent);
-    const canonicalParentId = parentId ? canonicalIdByLowercase.get(parentId.toLowerCase()) : void 0;
-    if (canonicalParentId) {
-      edges.push(canonicalParentId);
-    }
-    graph.set(item.id, edges);
-  }
-  return graph;
-}
-function detectLifecycleParentCycles(items) {
-  const graph = buildLifecycleParentGraph(items);
-  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 classifyOrphanedPath(pathValue) {
-  if (pathValue.startsWith("docs/")) {
-    return "docs_unowned";
-  }
-  if (pathValue.startsWith("tests/")) {
-    return "tests_unowned";
-  }
-  if (pathValue.startsWith("src/")) {
-    return "source_unowned";
-  }
-  if (pathValue.endsWith(".md")) {
-    return "docs_unowned";
-  }
-  return "unlinked_existing";
-}
-function directoryOf(relativePath) {
-  const slash = relativePath.lastIndexOf("/");
-  return slash === -1 ? "" : relativePath.slice(0, slash);
-}
-function sharedDirectoryPrefixLength(left, right) {
-  const leftParts = directoryOf(left).split("/").filter(Boolean);
-  const rightParts = directoryOf(right).split("/").filter(Boolean);
-  let count = 0;
-  while (count < leftParts.length && count < rightParts.length && leftParts[count] === rightParts[count]) {
-    count += 1;
-  }
-  return count;
-}
-function scoreOrphanOwnerCandidate(pathValue, linkedPath) {
-  const linkedDir = directoryOf(linkedPath);
-  const orphanDir = directoryOf(pathValue);
-  const directoryPrefix = linkedPath.endsWith("/") ? linkedPath : `${linkedPath}/`;
-  const isDirectoryPrefix = pathValue.startsWith(directoryPrefix);
-  const sameDirectory = linkedDir.length > 0 && linkedDir === orphanDir;
-  const sharedPrefixLength = sharedDirectoryPrefixLength(pathValue, linkedPath);
-  if (!isDirectoryPrefix && !sameDirectory && sharedPrefixLength === 0) {
-    return null;
-  }
-  if (isDirectoryPrefix) {
-    return { score: linkedPath.length + 1e3, confidence: "path_prefix" };
-  }
-  return sameDirectory ? { score: sharedPrefixLength + 500, confidence: "same_directory" } : { score: sharedPrefixLength, confidence: "shared_directory" };
-}
-function shouldReplaceOrphanOwnerCandidate(best, item, score) {
-  return best === void 0 || score > best.score || score === best.score && item.id.localeCompare(best.item.id) < 0;
-}
-function findOrphanOwnerCandidate(pathValue, classification, items) {
-  const linkKind = classification === "docs_unowned" ? "docs" : "files";
-  let best;
-  for (const item of items) {
-    const links = linkKind === "docs" ? item.docs ?? [] : item.files ?? [];
-    for (const link of links) {
-      if (link.scope !== "project") {
-        continue;
-      }
-      const linkedPath = normalizeRelativePath(link.path);
-      if (linkedPath.length === 0 || linkedPath === pathValue) {
-        continue;
-      }
-      const scored = scoreOrphanOwnerCandidate(pathValue, linkedPath);
-      if (scored === null) {
-        continue;
-      }
-      if (shouldReplaceOrphanOwnerCandidate(best, item, scored.score)) {
-        best = {
-          item,
-          score: scored.score,
-          confidence: scored.confidence
-        };
-      }
-    }
-  }
-  if (!best) {
-    return null;
-  }
-  return {
-    id: best.item.id,
-    type: best.item.type,
-    title: best.item.title,
-    status: best.item.status,
-    confidence: best.confidence
-  };
-}
-function buildOrphanedPathRows(orphanedFiles, items) {
-  return orphanedFiles.map((pathValue) => {
-    const classification = classifyOrphanedPath(pathValue);
-    const linkCommand = classification === "docs_unowned" ? "docs" : "files";
-    const ownerCandidate = findOrphanOwnerCandidate(pathValue, classification, items);
-    const target = ownerCandidate?.id ?? "<id>";
-    return {
-      path: pathValue,
-      classification,
-      owner_candidate: ownerCandidate,
-      remediation_hint: `pm ${linkCommand} ${target} --add path=${pathValue},scope=project,note="<why this artifact belongs to the item>"`
-    };
-  });
-}
-function summarizeOrphanedPathRows(rows) {
-  return rows.map((row) => `${row.path}:${row.classification} owner_candidate=${row.owner_candidate?.id ?? "unowned"} hint=${JSON.stringify(row.remediation_hint)}`);
-}
-function closureLikeFieldsForItem(item, lifecyclePatternPolicy) {
-  return Object.entries(lifecyclePatternPolicy.closure_like_metadata_field_patterns).filter(([field, patterns]) => {
-    const value = toMeaningfulString(item[field]);
-    return value ? patterns.some((pattern) => value.toLowerCase().includes(pattern)) : false;
-  }).map(([field]) => field).sort((left, right) => left.localeCompare(right));
-}
-function buildTerminalParentFixRow(item, parent, itemsById, canonicalIdByLowercase, statusRegistry) {
-  const grandparentId = toMeaningfulString(parent.parent);
-  const grandparent = grandparentId ? itemsById.get(canonicalIdByLowercase.get(grandparentId.toLowerCase()) ?? grandparentId) : void 0;
-  return {
-    id: item.id,
-    parent_id: parent.id,
-    grandparent_id: grandparent?.id,
-    grandparent_active: grandparent !== void 0 && !isTerminalStatus(grandparent.status, statusRegistry)
-  };
-}
-function staleBlockerReasonsForItem(item, blockedStatuses, statusRegistry, lifecyclePatternPolicy) {
-  const blockedBy = toMeaningfulString(item.blocked_by);
-  const blockedReason = toMeaningfulString(item.blocked_reason);
-  const blockedReasonNormalized = blockedReason?.toLowerCase();
-  const normalizedStatus = normalizeStatusForRegistry(item.status, statusRegistry);
-  const reasons = [];
-  if (!blockedStatuses.has(normalizedStatus)) {
-    if (blockedBy) {
-      reasons.push("non_blocked_status_has_blocked_by");
-    }
-    if (blockedReason) {
-      reasons.push("non_blocked_status_has_blocked_reason");
-    }
-    return reasons;
-  }
-  if (!blockedBy && !blockedReason) {
-    reasons.push("blocked_status_missing_blocker_context");
-  }
-  if (blockedReasonNormalized?.includes("no active blocker")) {
-    reasons.push("blocked_status_reason_reports_no_active_blocker");
-  }
-  if (blockedReasonNormalized && lifecyclePatternPolicy.stale_blocker_reason_patterns.some((pattern) => blockedReasonNormalized.includes(pattern))) {
-    reasons.push("blocked_status_reason_matches_stale_pattern");
-  }
-  return reasons;
-}
-function collectLifecycleScanRows(items, includeStaleBlockers, statusRegistry, lifecyclePatternPolicy) {
-  const itemsById = new Map(items.map((item) => [item.id, item]));
-  const canonicalIdByLowercase = new Map(items.map((item) => [item.id.toLowerCase(), item.id]));
-  const blockedStatuses = statusRegistry.blocked_statuses.size > 0 ? statusRegistry.blocked_statuses : /* @__PURE__ */ new Set(["blocked"]);
-  const rows = {
-    activeItems: items.filter((item) => !isTerminalStatus(item.status, statusRegistry)),
-    closureLikeRows: [],
-    terminalParentRows: [],
-    terminalParentFixRows: [],
-    staleBlockerRows: []
-  };
-  for (const item of rows.activeItems) {
-    const closureLikeFields = closureLikeFieldsForItem(item, lifecyclePatternPolicy);
-    if (closureLikeFields.length > 0) {
-      rows.closureLikeRows.push({ id: item.id, fields: closureLikeFields });
-    }
-    const parentId = toMeaningfulString(item.parent);
-    const parent = parentId ? itemsById.get(canonicalIdByLowercase.get(parentId.toLowerCase()) ?? parentId) : void 0;
-    if (parent && isTerminalStatus(parent.status, statusRegistry)) {
-      rows.terminalParentRows.push({ id: item.id, parent_id: parent.id, parent_status: parent.status });
-      rows.terminalParentFixRows.push(buildTerminalParentFixRow(item, parent, itemsById, canonicalIdByLowercase, statusRegistry));
-    }
-    if (includeStaleBlockers) {
-      const reasons = staleBlockerReasonsForItem(item, blockedStatuses, statusRegistry, lifecyclePatternPolicy);
-      if (reasons.length > 0) {
-        rows.staleBlockerRows.push({
-          id: item.id,
-          status: item.status,
-          reasons: [...new Set(reasons)].sort((left, right) => left.localeCompare(right))
-        });
-      }
-    }
-  }
-  return rows;
-}
-function sortLifecycleScanRows(rows) {
-  rows.closureLikeRows.sort((left, right) => left.id.localeCompare(right.id));
-  rows.terminalParentRows.sort((left, right) => left.id.localeCompare(right.id) || left.parent_id.localeCompare(right.parent_id));
-  rows.terminalParentFixRows.sort((left, right) => left.id.localeCompare(right.id) || left.parent_id.localeCompare(right.parent_id));
-  rows.staleBlockerRows.sort((left, right) => left.id.localeCompare(right.id));
-}
-function lifecycleCycleWarningToken(prefix, severity, count) {
-  if (count <= 0 || severity === "off") {
-    return null;
-  }
-  return `${severity === "error" ? `${prefix}_error` : prefix}:${count}`;
-}
-function buildLifecycleWarnings(rows, includeStaleBlockers, dependencyCycleSeverity, parentCycleSeverity, dependencyCycleCount, parentCycleCount) {
-  const warnings = [];
-  if (rows.closureLikeRows.length > 0) {
-    warnings.push(`validate_lifecycle_active_closure_like_metadata:${rows.closureLikeRows.length}`);
-  }
-  if (rows.terminalParentRows.length > 0) {
-    warnings.push(`validate_lifecycle_active_terminal_parent:${rows.terminalParentRows.length}`);
-  }
-  if (includeStaleBlockers && rows.staleBlockerRows.length > 0) {
-    warnings.push(`validate_lifecycle_stale_blockers:${rows.staleBlockerRows.length}`);
-  }
-  const dependencyWarning = lifecycleCycleWarningToken("validate_lifecycle_dependency_cycles", dependencyCycleSeverity, dependencyCycleCount);
-  const parentWarning = lifecycleCycleWarningToken("validate_hierarchy_parent_cycle", parentCycleSeverity, parentCycleCount);
-  return [...warnings, ...dependencyWarning ? [dependencyWarning] : [], ...parentWarning ? [parentWarning] : []];
-}
-function linkedArtifactPathExceedsFilesystemLimits(artifactPath) {
-  const normalized = normalizeRelativePath(artifactPath);
-  return normalized.length > LINKED_ARTIFACT_MAX_PATH_LENGTH || normalized.split(/[\\/]/).some((segment) => segment.length > LINKED_ARTIFACT_MAX_SEGMENT_LENGTH);
-}
-async function linkedArtifactIsMissing(workspaceRoot, artifactPath) {
-  const absolutePath = path.isAbsolute(artifactPath) ? artifactPath : path.resolve(workspaceRoot, artifactPath);
-  if (linkedArtifactPathExceedsFilesystemLimits(absolutePath)) {
-    return false;
-  }
-  try {
-    const stats = await fs.stat(absolutePath);
-    return !stats.isFile() && !stats.isDirectory();
-  } catch (error) {
-    const code = typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
-    return code === "ENOENT" || code === "ENOTDIR";
-  }
-}
-async function collectLinkedPathScanState(items, workspaceRoot) {
-  const state = {
-    linkedProjectPaths: /* @__PURE__ */ new Set(),
-    remoteLinkedPaths: /* @__PURE__ */ new Set(),
-    missingLinkedPaths: [],
-    staleLinkRows: []
-  };
-  for (const item of items) {
-    const linkedArtifactGroups = [
-      { link_kind: "files", artifacts: item.files ?? [] },
-      { link_kind: "docs", artifacts: item.docs ?? [] }
-    ];
-    for (const group of linkedArtifactGroups) {
-      for (const artifact of group.artifacts) {
-        if (artifact.scope !== "project") {
-          continue;
-        }
-        if (isRemoteLinkedArtifactReference(artifact.path)) {
-          state.remoteLinkedPaths.add(artifact.path.trim());
-          continue;
-        }
-        const normalizedPath = normalizeRelativePath(artifact.path);
-        if (normalizedPath.length === 0) {
-          continue;
-        }
-        state.linkedProjectPaths.add(normalizedPath);
-        if (await linkedArtifactIsMissing(workspaceRoot, artifact.path)) {
-          state.missingLinkedPaths.push(normalizedPath);
-          state.staleLinkRows.push({ item_id: item.id, path: normalizedPath, link_kind: group.link_kind });
-        }
-      }
-    }
-  }
-  return state;
-}
-function partitionFileCandidates(fileCandidates, pmRoot, workspaceRoot, fileScanMode, includePmInternals, verboseFileLists) {
-  const strictTrackedAllMode = fileScanMode === "tracked-all-strict";
-  const strictModeForcesPmInternals = strictTrackedAllMode && !includePmInternals;
-  const includePmInternalsEffective = includePmInternals || strictTrackedAllMode;
-  const pmInternalCandidatePrefixes = includePmInternalsEffective ? [] : resolvePmInternalCandidatePrefixes(pmRoot, workspaceRoot);
-  const excludedPmInternalPaths = pmInternalCandidatePrefixes.length === 0 ? [] : fileCandidates.candidateFiles.filter((candidate) => hasPathPrefix(candidate, pmInternalCandidatePrefixes));
-  const candidateFiles = pmInternalCandidatePrefixes.length === 0 ? fileCandidates.candidateFiles : fileCandidates.candidateFiles.filter((candidate) => !hasPathPrefix(candidate, pmInternalCandidatePrefixes));
-  const excludedByReason = {};
-  if (excludedPmInternalPaths.length > 0) {
-    const summarizedPmInternalPaths = summarizeFileList(excludedPmInternalPaths, verboseFileLists);
-    excludedByReason.pm_internals = {
-      count: excludedPmInternalPaths.length,
-      paths: summarizedPmInternalPaths.values,
-      paths_truncated: summarizedPmInternalPaths.truncated,
-      paths_total: summarizedPmInternalPaths.total
-    };
-  }
-  return {
-    strictTrackedAllMode,
-    strictModeForcesPmInternals,
-    includePmInternalsEffective,
-    pmInternalCandidatePrefixes,
-    excludedPmInternalPaths,
-    candidateFiles,
-    excludedByReason
-  };
-}
-function buildLifecycleCheck(items, includeStaleBlockers, dependencyCycleSeverity, parentCycleSeverity, statusRegistry, lifecyclePatternPolicy, verboseDiagnostics, idPrefix = "pm") {
-  const rows = collectLifecycleScanRows(items, includeStaleBlockers, statusRegistry, lifecyclePatternPolicy);
-  sortLifecycleScanRows(rows);
-  const dependencyCycleDiagnostics = detectLifecycleDependencyCycles(rows.activeItems, idPrefix);
-  const parentCycleDiagnostics = detectLifecycleParentCycles(items);
-  const warnings = buildLifecycleWarnings(rows, includeStaleBlockers, dependencyCycleSeverity, parentCycleSeverity, dependencyCycleDiagnostics.cycle_count, parentCycleDiagnostics.cycle_count);
-  const diagnosticLimit = verboseDiagnostics ? Number.POSITIVE_INFINITY : DIAGNOSTIC_LIST_SUMMARY_LIMIT;
-  const summarizedClosureLikeRows = summarizeList(rows.closureLikeRows.map((row) => `${row.id}:${row.fields.join(",")}`), diagnosticLimit);
-  const summarizedTerminalParentRows = summarizeList(rows.terminalParentRows.map((row) => `${row.id}:${row.parent_id}:${row.parent_status}`), diagnosticLimit);
-  const summarizedStaleBlockerRows = summarizeList(rows.staleBlockerRows.map((row) => `${row.id}:${row.status}:${row.reasons.join(",")}`), diagnosticLimit);
-  const summarizedDependencyCycleItemIds = summarizeList(dependencyCycleDiagnostics.cycle_item_ids, diagnosticLimit);
-  const summarizedDependencyCycleSamplePaths = summarizeList(dependencyCycleDiagnostics.cycle_sample_paths, diagnosticLimit);
-  const summarizedParentCycleItemIds = summarizeList(parentCycleDiagnostics.cycle_item_ids, diagnosticLimit);
-  const summarizedParentCycleSamplePaths = summarizeList(parentCycleDiagnostics.cycle_sample_paths, diagnosticLimit);
-  const hasErrorSeverityCycle = dependencyCycleDiagnostics.cycle_count > 0 && dependencyCycleSeverity === "error" || parentCycleDiagnostics.cycle_count > 0 && parentCycleSeverity === "error";
-  return {
-    check: {
-      name: "lifecycle",
-      status: hasErrorSeverityCycle ? "error" : warnings.length === 0 ? "ok" : "warn",
-      details: {
-        checked_active_items: rows.activeItems.length,
-        active_closure_like_metadata_items: rows.closureLikeRows.length,
-        active_closure_like_metadata_rows: summarizedClosureLikeRows.values,
-        active_closure_like_metadata_rows_truncated: summarizedClosureLikeRows.truncated,
-        active_terminal_parent_items: rows.terminalParentRows.length,
-        active_terminal_parent_rows: summarizedTerminalParentRows.values,
-        active_terminal_parent_rows_truncated: summarizedTerminalParentRows.truncated,
-        stale_blocker_checks_enabled: includeStaleBlockers,
-        stale_blocker_items: rows.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,
-        parent_cycle_severity_policy: parentCycleSeverity,
-        parent_cycle_count: parentCycleDiagnostics.cycle_count,
-        parent_cycle_item_count: parentCycleDiagnostics.cycle_item_ids.length,
-        parent_cycle_item_ids: summarizedParentCycleItemIds.values,
-        parent_cycle_item_ids_truncated: summarizedParentCycleItemIds.truncated,
-        parent_cycle_sample_paths: summarizedParentCycleSamplePaths.values,
-        parent_cycle_sample_paths_truncated: summarizedParentCycleSamplePaths.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,
-    terminalParentFixRows: rows.terminalParentFixRows
-  };
-}
-async function buildFilesCheck(items, workspaceRoot, pmRoot, fileScanMode, includePmInternals, verboseFileLists) {
-  const linkedPathState = await collectLinkedPathScanState(items, workspaceRoot);
-  const itemsById = new Map(items.map((item) => [item.id, item]));
-  const uniqueMissingLinkedPaths = [...new Set(linkedPathState.missingLinkedPaths)].sort((left, right) => left.localeCompare(right));
-  const fileCandidates = await collectProjectFileCandidates(workspaceRoot, fileScanMode);
-  const partition = partitionFileCandidates(fileCandidates, pmRoot, workspaceRoot, fileScanMode, includePmInternals, verboseFileLists);
-  const orphanedFiles = partition.candidateFiles.filter((candidate) => !linkedPathState.linkedProjectPaths.has(candidate));
-  const orphanedPathRows = buildOrphanedPathRows(orphanedFiles, items);
-  const classifiedStalePaths = classifyStaleLinkedPaths(uniqueMissingLinkedPaths, partition.candidateFiles);
-  const classificationByPath = new Map(classifiedStalePaths.map((entry) => [entry.path, entry.classification]));
-  const movedStalePathCount = classifiedStalePaths.filter((entry) => entry.classification === "moved").length;
-  const staleLinkPruneRows = linkedPathState.staleLinkRows.map((row) => ({
-    ...row,
-    classification: classificationByPath.get(row.path) ?? "deleted"
-  })).sort((left, right) => left.item_id.localeCompare(right.item_id) || left.path.localeCompare(right.path) || left.link_kind.localeCompare(right.link_kind));
-  const warnings = [];
-  if (partition.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 uniqueRemoteLinkedPaths = [...linkedPathState.remoteLinkedPaths].sort((left, right) => left.localeCompare(right));
-  const summarizedRemote = summarizeFileList(uniqueRemoteLinkedPaths, verboseFileLists);
-  const summarizedMissing = summarizeFileList(uniqueMissingLinkedPaths, verboseFileLists);
-  const summarizedOrphaned = summarizeFileList(orphanedFiles, verboseFileLists);
-  const summarizedOrphanedClassifications = summarizeFileList(orphanedPathRows.map((row) => `${row.path}:${row.classification}:owner_candidate=${row.owner_candidate?.id ?? "unowned"}`), verboseFileLists);
-  const orphanedPathRowDetail = verboseFileLists ? orphanedPathRows : summarizeFileList(summarizeOrphanedPathRows(orphanedPathRows), false).values;
-  const summarizedClassifications = summarizeFileList(summarizeStaleLinkedPathClassifications(classifiedStalePaths), verboseFileLists);
-  const missingLinkedPathRows = staleLinkPruneRows.map((row) => ({
-    item_id: row.item_id,
-    path: row.path,
-    link_kind: row.link_kind,
-    classification: row.classification
-  }));
-  const ownerRows = buildMissingLinkedPathRows(missingLinkedPathRows, (id) => {
-    const owner = itemsById.get(id);
-    return owner ? { type: owner.type, title: owner.title, status: owner.status } : void 0;
-  });
-  const ownerRowDetail = verboseFileLists ? ownerRows : summarizeFileList(summarizeMissingLinkedPathRows(ownerRows), false).values;
-  return {
-    check: {
-      name: "files",
-      status: warnings.length === 0 ? "ok" : "warn",
-      details: {
-        workspace_root: workspaceRoot,
-        scan_mode_requested: fileCandidates.requestedMode,
-        scan_mode_applied: fileCandidates.appliedMode,
-        strict_tracked_all_mode: partition.strictTrackedAllMode,
-        strict_mode_forces_pm_internals: partition.strictModeForcesPmInternals,
-        strict_mode_forces_pm_internals_notice: partition.strictModeForcesPmInternals ? "tracked-all-strict force-enables PM internals; pass --include-pm-internals to make inclusion explicit." : null,
-        file_list_detail_mode: verboseFileLists ? "full" : "summary",
-        file_list_summary_limit: FILE_LIST_SUMMARY_LIMIT,
-        candidate_scan_source: fileCandidates.source,
-        include_pm_internals: partition.includePmInternalsEffective,
-        include_pm_internals_requested: includePmInternals,
-        pm_internal_candidate_prefixes: partition.pmInternalCandidatePrefixes,
-        pm_internal_excluded_count: partition.excludedPmInternalPaths.length,
-        excluded_total: partition.excludedPmInternalPaths.length,
-        excluded_by_reason: partition.excludedByReason,
-        linked_project_paths: linkedPathState.linkedProjectPaths.size,
-        remote_linked_paths_count: uniqueRemoteLinkedPaths.length,
-        remote_linked_paths_total: summarizedRemote.total,
-        remote_linked_paths: summarizedRemote.values,
-        remote_linked_paths_truncated: summarizedRemote.truncated,
-        candidate_total_raw: fileCandidates.candidateTotal,
-        candidate_scanned_raw: fileCandidates.candidateScanned,
-        candidate_total: partition.candidateFiles.length,
-        candidate_scanned: partition.candidateFiles.length,
-        scanned_candidate_files: partition.candidateFiles.length,
-        missing_linked_paths_count: uniqueMissingLinkedPaths.length,
-        missing_linked_paths_total: summarizedMissing.total,
-        missing_linked_paths: summarizedMissing.values,
-        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,
-        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,
-        orphaned_paths_truncated: summarizedOrphaned.truncated,
-        orphaned_path_classifications: summarizedOrphanedClassifications.values,
-        orphaned_path_classifications_truncated: summarizedOrphanedClassifications.truncated,
-        orphaned_path_rows_count: orphanedPathRows.length,
-        orphaned_path_rows: orphanedPathRowDetail
-      }
-    },
-    warnings,
-    staleLinkPruneRows
-  };
-}
-async function buildHistoryDriftCheck(pmRoot, items, verboseDiagnostics) {
-  const { missingStreams, unreadableStreams, hashMismatches, chainMismatches, driftedItems } = await scanHistoryDrift(pmRoot, items);
-  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}`);
-  }
-  if (chainMismatches.length > 0) {
-    warnings.push(`validate_history_drift_chain_mismatches:${chainMismatches.length}`);
-  }
-  const diagnosticLimit = verboseDiagnostics ? Number.POSITIVE_INFINITY : DIAGNOSTIC_LIST_SUMMARY_LIMIT;
-  const summarizedDrifted = summarizeList(driftedItems, diagnosticLimit);
-  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,
-          chain_mismatches: chainMismatches.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, verboseDiagnostics) {
-  const knownIds = new Set(items.map((item) => item.id.toLowerCase()));
-  let linkedCommandsScanned = 0;
-  let referencedPmIdCount = 0;
-  const referencedPmIds = /* @__PURE__ */ 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 diagnosticLimit = verboseDiagnostics ? Number.POSITIVE_INFINITY : DIAGNOSTIC_LIST_SUMMARY_LIMIT;
-  const summarizedRows = summarizeList(uniqueStaleReferenceRows, diagnosticLimit);
-  const summarizedStalePmIds = summarizeList(stalePmIds, diagnosticLimit);
-  const summarizedReferencedPmIds = summarizeList([...referencedPmIds].sort((left, right) => left.localeCompare(right)), diagnosticLimit);
-  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
-  };
-}
-function buildFormatVersionCheck(items, verboseDiagnostics) {
-  const scan = scanItemFormatVersions(items.map((item) => ({ ref: item.id, version: effectiveItemFormatVersion(item) })));
-  const warnings = [];
-  if (scan.outdated.length > 0) {
-    warnings.push(`validate_format_version_outdated_items:${scan.outdated.length}`);
-  }
-  if (scan.ahead.length > 0) {
-    warnings.push(`validate_format_version_ahead_items:${scan.ahead.length}`);
-  }
-  const diagnosticLimit = verboseDiagnostics ? Number.POSITIVE_INFINITY : DIAGNOSTIC_LIST_SUMMARY_LIMIT;
-  const summarizedOutdated = summarizeList(scan.outdated, diagnosticLimit);
-  const summarizedAhead = summarizeList(scan.ahead, diagnosticLimit);
-  const status = scan.ahead.length > 0 ? "error" : scan.outdated.length > 0 ? "warn" : "ok";
-  return {
-    check: {
-      name: "format_version",
-      status,
-      details: {
-        checked_items: items.length,
-        current_format_version: CURRENT_ITEM_FORMAT_VERSION,
-        outdated_items_count: scan.outdated.length,
-        outdated_items: summarizedOutdated.values,
-        outdated_items_truncated: summarizedOutdated.truncated,
-        ahead_items_count: scan.ahead.length,
-        ahead_items: summarizedAhead.values,
-        ahead_items_truncated: summarizedAhead.truncated
-      }
-    },
-    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 "set_estimate":
-    case "reparent":
-    case "unset_parent": {
-      const { runUpdate } = await import("./update-SFLZPJXX.js");
-      const updateOptions = { message: VALIDATE_AUTO_FIX_MESSAGE };
-      if (fix.kind === "set_resolution") {
-        updateOptions.resolution = fix.value;
-      } else if (fix.kind === "set_close_reason") {
-        updateOptions.closeReason = fix.value;
-      } else if (fix.kind === "set_estimate") {
-        updateOptions.estimatedMinutes = fix.value;
-      } else if (fix.kind === "reparent") {
-        updateOptions.parent = fix.parent_id;
-      } else {
-        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-JPU3FNJ7.js");
-        await runFiles(first.item_id, { remove, message: VALIDATE_AUTO_FIX_MESSAGE }, global);
-      } else {
-        const { runDocs } = await import("./docs-6CRCSVKK.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 };
-}
-var _testOnlyValidateCommand = {
-  applyValidateFix,
-  applyValidateFixes,
-  attachValidateFixHints,
-  buildCommandReferencesCheck,
-  buildCloseReasonBackfillRows,
-  buildFilesCheck,
-  buildLifecycleCheck,
-  buildLifecycleDependencyGraph,
-  buildLifecycleParentGraph,
-  buildEstimateBackfillRows,
-  buildMetadataCounts,
-  buildMissingFieldOccurrences,
-  buildOrphanedPathRows,
-  classifyOrphanedPath,
-  collectDefaultProjectFileCandidates,
-  collectTrackedGitFileCandidates,
-  detectLifecycleDependencyCycles,
-  detectLifecycleParentCycles,
-  escapeRegExp,
-  extractItemIds,
-  findLifecycleDependencyCycleComponents,
-  isMetadataFieldMissing,
-  linkedArtifactPathExceedsFilesystemLimits,
-  listFilesRecursive,
-  resolveDependencyCycleSeverity,
-  resolveParentCycleSeverity,
-  resolveFileScanMode,
-  resolveLifecycleDependencyCycleSamplePath,
-  resolveRequestedChecks,
-  resolveValidateMetadataProfile,
-  resolveWorkspaceRoot,
-  sharedDirectoryPrefixLength,
-  summarizeOrphanedPathRows,
-  summarizeDuplicateIssueCodes,
-  toMeaningfulString
-};
-function recordValidateCheck(state, built, fixHintsEnabled) {
-  if (fixHintsEnabled) {
-    attachValidateFixHints(built.check, built.warnings);
-  }
-  state.checks.push(built.check);
-  state.warnings.push(...built.warnings);
-}
-async function executeRequestedValidateChecks(params) {
-  const state = {
-    checks: [],
-    warnings: [...params.initialWarnings],
-    closeReasonBackfillRows: [],
-    estimateBackfillRows: [],
-    resolutionBackfillRows: [],
-    terminalParentFixRows: [],
-    staleLinkPruneRows: []
-  };
-  const fixHintsEnabled = params.options.fixHints === true;
-  const fullDiagnostics = params.options.verboseDiagnostics === true || params.options.allAffectedIds === true || params.global.json === true;
-  if (params.requestedChecks.has("metadata")) {
-    const built = buildMetadataCheck(params.items, params.metadataPolicy, params.statusRegistry, fullDiagnostics);
-    state.closeReasonBackfillRows = built.closeReasonBackfillRows;
-    state.estimateBackfillRows = built.estimateBackfillRows;
-    recordValidateCheck(state, built, fixHintsEnabled);
-  }
-  if (params.requestedChecks.has("resolution")) {
-    const built = buildResolutionCheck(params.items, params.statusRegistry, fullDiagnostics);
-    state.resolutionBackfillRows = built.resolutionBackfillRows;
-    recordValidateCheck(state, built, fixHintsEnabled);
-  }
-  if (params.requestedChecks.has("lifecycle")) {
-    const built = buildLifecycleCheck(params.items, Boolean(params.options.checkStaleBlockers), params.dependencyCycleSeverity, params.parentCycleSeverity, params.statusRegistry, params.lifecyclePatternPolicy, fullDiagnostics, params.settings.id_prefix);
-    state.terminalParentFixRows = built.terminalParentFixRows;
-    recordValidateCheck(state, built, fixHintsEnabled);
-  }
-  if (params.requestedChecks.has("files")) {
-    const built = await buildFilesCheck(params.items, params.workspaceRoot, params.pmRoot, params.fileScanMode, Boolean(params.options.includePmInternals), Boolean(params.options.verboseFileLists));
-    state.staleLinkPruneRows = built.staleLinkPruneRows;
-    recordValidateCheck(state, built, fixHintsEnabled);
-  }
-  if (params.requestedChecks.has("command_references")) {
-    recordValidateCheck(state, buildCommandReferencesCheck(params.items, params.settings.id_prefix, fullDiagnostics), fixHintsEnabled);
-  }
-  if (params.requestedChecks.has("history_drift")) {
-    recordValidateCheck(state, await buildHistoryDriftCheck(params.pmRoot, params.items, fullDiagnostics), fixHintsEnabled);
-  }
-  if (params.requestedChecks.has("format_version")) {
-    recordValidateCheck(state, buildFormatVersionCheck(params.items, fullDiagnostics), fixHintsEnabled);
-  }
-  return state;
-}
-function planValidateFixes(options, state, settings) {
-  const planned = [];
-  if (options.autoFix === true) {
-    planned.push(...planCloseReasonBackfillFixes(state.closeReasonBackfillRows));
-    planned.push(...planResolutionBackfillFixes(state.resolutionBackfillRows));
-    planned.push(...planEstimateBackfillFixes(state.estimateBackfillRows, settings.validation.estimate_defaults_by_type));
-    planned.push(...planTerminalParentFixes(state.terminalParentFixRows));
-  }
-  if (options.pruneMissing === true) {
-    planned.push(...planStaleLinkPruneFixes(state.staleLinkPruneRows));
-  }
-  return planned;
-}
-async function buildValidateFixesSummary(options, state, settings, grantedFixScopes, global) {
-  if (options.autoFix !== true && options.pruneMissing !== true) {
-    return void 0;
-  }
-  const planned = planValidateFixes(options, state, settings);
-  const { applicable, gated } = partitionFixesByGrant(planned, grantedFixScopes);
-  const dryRun = options.dryRun === true;
-  const appliedFixRows = [];
-  const failedFixRows = [];
-  if (!dryRun) {
-    const applied = await applyValidateFixes(applicable, global);
-    appliedFixRows.push(...applied.applied.map(toFixOutputRow));
-    failedFixRows.push(...applied.failed.map(({ fix, error }) => ({
-      ...toFixOutputRow(fix),
-      error: error instanceof Error ? error.message : String(error)
-    })));
-  }
-  return {
-    mode: dryRun ? "dry_run" : "apply",
-    auto_fix: options.autoFix === true,
-    prune_missing: options.pruneMissing === true,
-    granted_fix_scopes: [...grantedFixScopes].sort((left, right) => left.localeCompare(right)),
-    planned_count: planned.length,
-    applied_count: appliedFixRows.length,
-    gated_count: gated.length,
-    failed_count: failedFixRows.length,
-    planned_fixes: planned.map(toFixOutputRow),
-    applied_fixes: appliedFixRows,
-    gated_fixes: gated.map((fix) => ({
-      ...toFixOutputRow(fix),
-      gate_hint: `Withheld: re-run with --fix-scope ${fix.gate} to apply.`
-    })),
-    failed_fixes: failedFixRows
-  };
-}
-async function runValidate(options, global) {
-  const fixesRequested = options.autoFix === true || options.pruneMissing === true;
-  if (options.dryRun === true && !fixesRequested) {
-    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);
-  }
-  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 parentCycleSeverity = resolveParentCycleSeverity(options.parentCycleSeverity);
-  const fileScanMode = resolveFileScanMode(options.scanMode);
-  const workspaceRoot = resolveWorkspaceRoot(pmRoot);
-  const state = await executeRequestedValidateChecks({
-    requestedChecks,
-    options,
-    global,
-    pmRoot,
-    workspaceRoot,
-    settings,
-    items,
-    statusRegistry,
-    metadataPolicy,
-    lifecyclePatternPolicy,
-    dependencyCycleSeverity,
-    parentCycleSeverity,
-    fileScanMode,
-    initialWarnings: [...new Set(itemReadWarnings)]
-  });
-  const fixes = fixesRequested ? await buildValidateFixesSummary(options, state, settings, grantedFixScopes, global) : void 0;
-  const normalizedWarnings = [...new Set(state.warnings)].sort((left, right) => left.localeCompare(right));
-  const hasErrors = state.checks.some((check) => check.status === "error");
-  return {
-    ok: !hasErrors,
-    has_warnings: normalizedWarnings.length > 0,
-    checks: state.checks,
-    warnings: normalizedWarnings,
-    ...fixes !== void 0 ? { fixes } : {},
-    generated_at: nowIso()
-  };
-}
-export {
-  _testOnlyValidateCommand,
-  runValidate
-};
-//# sourceMappingURL=validate-Z7L75YEJ.js.map
-
-//# debugId=7b42ea6d-c9b5-5d22-b82e-64af26f3173c