@unbrained/pm-cli 2026.7.5 → 2026.7.6

package/dist/cli-bundle/chunks/chunk-MAWDPCJW.js

@@ -0,0 +1,1601 @@
+
+!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]="f3d2b3b5-0c76-5b07-af27-5951e49d4128")}catch(e){}}();
+import {
+  buildRemediationMap
+} from "./chunk-R2EMWY7Q.js";
+import {
+  scanLockHealth
+} from "./chunk-37E72CNS.js";
+import {
+  scanHistoryDrift
+} from "./chunk-K46RF36U.js";
+import {
+  collectStaleVectorizationIds
+} from "./chunk-ROGZTCCB.js";
+import {
+  PM_TELEMETRY_SOURCE_CONTEXT_VALUES,
+  TELEMETRY_MAX_QUEUE_ENTRY_ATTEMPTS,
+  TELEMETRY_SCHEMA_VERSION
+} from "./chunk-SQYJ4HF2.js";
+import {
+  buildVectorizationEmbeddingIdentity,
+  hasVectorizationEmbeddingIdentityChanged,
+  readVectorizationStatusLedger,
+  refreshSemanticEmbeddingsForMutatedItems,
+  resolveEmbeddingProviders,
+  resolveProviderConfigSource,
+  resolveSettingsWithSemanticRuntimeDefaults,
+  resolveVectorStores
+} from "./chunk-EOKXK3R3.js";
+import {
+  buildCapabilityContractMetadata,
+  buildRegistrationCollisionRemediation,
+  collectUnknownCapabilityGuidance,
+  readManagedExtensionState
+} from "./chunk-WG34ZNQQ.js";
+import {
+  collectRegisteredItemFieldNames,
+  enforceHistoryStreamPolicyForItems,
+  listAllFrontMatter,
+  listAllFrontMatterWithBody
+} from "./chunk-ENGQOEUY.js";
+import {
+  effectiveItemFormatVersion,
+  findFirstMergeConflictMarker,
+  parseItemDocument,
+  scanItemFormatVersions
+} from "./chunk-G24G7ZAV.js";
+import {
+  nowIso
+} from "./chunk-3GCS5SKL.js";
+import {
+  PmCliError,
+  getActiveExtensionRegistrations,
+  readSettingsWithMetadata,
+  runActiveOnReadHooks
+} from "./chunk-E3SZTQ4K.js";
+import {
+  EXIT_CODE,
+  ITEM_FILE_EXTENSIONS,
+  KNOWN_EXTENSION_CAPABILITIES,
+  PM_CORE_REQUIRED_SUBDIRS,
+  PM_OPTIONAL_TYPE_SUBDIRS,
+  activateExtensions,
+  getItemFormatFromPath,
+  getSettingsPath,
+  loadExtensions,
+  pathExists,
+  readFileIfExists,
+  resolveGlobalPmRoot,
+  resolveItemTypeRegistry,
+  resolvePmRoot,
+  toNonEmptyStringOrUndefined
+} from "./chunk-57NWPFF2.js";
+
+// dist/cli/commands/health.js
+import fs from "node:fs/promises";
+import path from "node:path";
+var PM_TELEMETRY_SOURCE_CONTEXT_SET = new Set(PM_TELEMETRY_SOURCE_CONTEXT_VALUES);
+var STALE_VECTORIZATION_SUMMARY_LIMIT = 25;
+var BRIEF_HEALTH_DETAIL_LIMIT = 8;
+var TELEMETRY_QUEUE_RELATIVE_PATH = path.join("runtime", "telemetry", "events.jsonl");
+var TELEMETRY_STATE_RELATIVE_PATH = path.join("runtime", "telemetry", "state.json");
+var TELEMETRY_ENDPOINT_PROBE_TIMEOUT_MS = 2500;
+var TELEMETRY_QUEUE_HIGH_WATER_MARK = 500;
+var TELEMETRY_QUEUE_HIGH_RETRY_THRESHOLD = TELEMETRY_MAX_QUEUE_ENTRY_ATTEMPTS - 3;
+var TELEMETRY_SERVER_MAX_SCHEMA_VERSION_HEADERS = [
+  "x-pm-telemetry-max-schema-version",
+  "x-pm-telemetry-max-version"
+];
+function isAdvisoryHealthWarning(warning) {
+  return warning.startsWith("telemetry_") || warning.startsWith("history_stream_over_compact_threshold:");
+}
+function warningCode(value) {
+  const normalized = value.trim();
+  const separator = normalized.indexOf(":");
+  if (separator === -1) {
+    return normalized;
+  }
+  return normalized.slice(0, separator);
+}
+function normalizeExtensionNameForMatch(value) {
+  return value.trim().toLowerCase();
+}
+function isExpectedUnmanagedExtension(name, directory) {
+  const normalizedName = normalizeExtensionNameForMatch(name);
+  const normalizedDirectory = normalizeExtensionNameForMatch(directory);
+  if (normalizedName.startsWith("builtin-")) {
+    return true;
+  }
+  return normalizedDirectory === "beads" || normalizedDirectory === "todos";
+}
+async function isDirectory(targetPath) {
+  try {
+    const stats = await fs.stat(targetPath);
+    return stats.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function countHistoryStreams(pmRoot, compactPolicy) {
+  const historyDir = path.join(pmRoot, "history");
+  if (!await isDirectory(historyDir)) {
+    return { count: 0, warnings: [], over_threshold: [], max_entries: null };
+  }
+  const historyFiles = (await fs.readdir(historyDir)).filter((entry) => entry.endsWith(".jsonl")).sort((left, right) => left.localeCompare(right));
+  const policyActive = compactPolicy.enabled;
+  const maxEntries = policyActive ? compactPolicy.max_entries : null;
+  const warnings = [];
+  const overThreshold = [];
+  for (const fileName of historyFiles) {
+    const streamPath = path.join(historyDir, fileName);
+    warnings.push(...await runActiveOnReadHooks({ path: streamPath, scope: "project" }));
+    if (!policyActive) {
+      continue;
+    }
+    const raw = await fs.readFile(streamPath, "utf8");
+    let entries = 0;
+    for (const line of raw.split(/\r?\n/)) {
+      if (line.trim().length > 0) {
+        entries += 1;
+      }
+    }
+    if (entries > compactPolicy.max_entries) {
+      overThreshold.push(fileName.slice(0, -".jsonl".length));
+    }
+  }
+  return {
+    count: historyFiles.length,
+    warnings: [...warnings, ...overThreshold.map((id) => `history_stream_over_compact_threshold:${id}`)],
+    over_threshold: overThreshold,
+    max_entries: maxEntries
+  };
+}
+function normalizeRelativePath(pmRoot, targetPath) {
+  return path.relative(pmRoot, targetPath).replaceAll("\\", "/");
+}
+async function listItemDocumentPaths(pmRoot, typeToFolder) {
+  const folders = [...new Set(Object.values(typeToFolder))].sort((left, right) => left.localeCompare(right));
+  const itemPaths = [];
+  for (const folder of folders) {
+    const directoryPath = path.join(pmRoot, folder);
+    let entries = [];
+    try {
+      entries = await fs.readdir(directoryPath);
+    } catch (error) {
+      if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+        continue;
+      }
+      continue;
+    }
+    for (const entry of entries) {
+      if (!ITEM_FILE_EXTENSIONS.some((extension) => entry.toLowerCase().endsWith(extension))) {
+        continue;
+      }
+      itemPaths.push(path.join(directoryPath, entry));
+    }
+  }
+  itemPaths.sort((left, right) => normalizeRelativePath(pmRoot, left).localeCompare(normalizeRelativePath(pmRoot, right)));
+  return itemPaths;
+}
+function shouldReportHistoryDirectoryUnreadable(error) {
+  return !(typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT");
+}
+async function buildIntegrityCheck(pmRoot, typeToFolder, schema) {
+  const itemPaths = await listItemDocumentPaths(pmRoot, typeToFolder);
+  const itemUnreadable = [];
+  const itemConflictMarkers = [];
+  const itemParseFailures = [];
+  const formatVersionEntries = [];
+  const extensionFieldNames = collectRegisteredItemFieldNames(getActiveExtensionRegistrations());
+  for (const itemPath of itemPaths) {
+    const relativePath = normalizeRelativePath(pmRoot, itemPath);
+    let raw = "";
+    try {
+      raw = await fs.readFile(itemPath, "utf8");
+    } catch {
+      itemUnreadable.push(relativePath);
+      continue;
+    }
+    const conflictMarker = findFirstMergeConflictMarker(raw);
+    if (conflictMarker) {
+      itemConflictMarkers.push({
+        path: relativePath,
+        line: conflictMarker.line,
+        marker: conflictMarker.marker
+      });
+      continue;
+    }
+    try {
+      const parsed = parseItemDocument(raw, { format: getItemFormatFromPath(itemPath), schema, extensionFieldNames });
+      formatVersionEntries.push({ ref: relativePath, version: effectiveItemFormatVersion(parsed.metadata) });
+    } catch {
+      itemParseFailures.push(relativePath);
+    }
+  }
+  const formatVersionScan = scanItemFormatVersions(formatVersionEntries);
+  const historyDir = path.join(pmRoot, "history");
+  const historyUnreadable = [];
+  const historyConflictMarkers = [];
+  const historyInvalidJson = [];
+  let historyFiles = [];
+  try {
+    historyFiles = (await fs.readdir(historyDir)).filter((entry) => entry.endsWith(".jsonl")).sort((left, right) => left.localeCompare(right));
+  } catch (error) {
+    if (shouldReportHistoryDirectoryUnreadable(error)) {
+      historyUnreadable.push("history");
+    }
+  }
+  for (const fileName of historyFiles) {
+    const itemId = fileName.slice(0, -".jsonl".length);
+    const historyPath = path.join(historyDir, fileName);
+    let raw = "";
+    try {
+      raw = await fs.readFile(historyPath, "utf8");
+    } catch {
+      historyUnreadable.push(itemId);
+      continue;
+    }
+    const conflictMarker = findFirstMergeConflictMarker(raw);
+    if (conflictMarker) {
+      historyConflictMarkers.push({
+        id: itemId,
+        line: conflictMarker.line,
+        marker: conflictMarker.marker
+      });
+      continue;
+    }
+    const lines = raw.split(/\r?\n/);
+    for (let index = 0; index < lines.length; index += 1) {
+      const line = lines[index]?.trim();
+      if (!line) {
+        continue;
+      }
+      try {
+        JSON.parse(line);
+      } catch {
+        historyInvalidJson.push({
+          id: itemId,
+          line: index + 1
+        });
+      }
+    }
+  }
+  const warnings = [
+    ...itemUnreadable.map((entry) => `integrity_item_unreadable:${entry}`),
+    ...itemConflictMarkers.map((entry) => `integrity_item_conflict_marker:${entry.path}:L${entry.line}`),
+    ...itemParseFailures.map((entry) => `integrity_item_parse_failed:${entry}`),
+    ...historyUnreadable.map((entry) => `integrity_history_unreadable:${entry}`),
+    ...historyConflictMarkers.map((entry) => `integrity_history_conflict_marker:${entry.id}:L${entry.line}`),
+    ...historyInvalidJson.map((entry) => `integrity_history_invalid_json:${entry.id}:L${entry.line}`),
+    /* c8 ignore start -- outdated-version items are unreachable until CURRENT_ITEM_FORMAT_VERSION advances past the baseline (an effective version below 1 cannot occur); the per-item mapping is covered in item-format-version.spec, and the ahead path below is covered by health-command.spec */
+    ...formatVersionScan.outdated.map((entry) => `integrity_item_outdated_format_version:${entry}`),
+    /* c8 ignore stop */
+    ...formatVersionScan.ahead.map((entry) => `integrity_item_ahead_format_version:${entry}`)
+  ];
+  const normalizedWarnings = [...new Set(warnings)].sort((left, right) => left.localeCompare(right));
+  return {
+    check: {
+      name: "integrity",
+      status: normalizedWarnings.length === 0 ? "ok" : "warn",
+      details: {
+        checked_item_files: itemPaths.length,
+        checked_history_streams: historyFiles.length,
+        counts: {
+          item_unreadable: itemUnreadable.length,
+          item_conflict_markers: itemConflictMarkers.length,
+          item_parse_failures: itemParseFailures.length,
+          history_unreadable: historyUnreadable.length,
+          history_conflict_markers: historyConflictMarkers.length,
+          history_invalid_json: historyInvalidJson.length,
+          item_outdated_format_version: formatVersionScan.outdated.length,
+          item_ahead_format_version: formatVersionScan.ahead.length
+        },
+        item_unreadable: itemUnreadable,
+        item_conflict_markers: itemConflictMarkers,
+        item_parse_failures: itemParseFailures,
+        item_outdated_format_version: formatVersionScan.outdated,
+        item_ahead_format_version: formatVersionScan.ahead,
+        history_unreadable: historyUnreadable,
+        history_conflict_markers: historyConflictMarkers,
+        history_invalid_json: historyInvalidJson
+      }
+    },
+    warnings: normalizedWarnings
+  };
+}
+function hasActivateExport(moduleRecord) {
+  if (typeof moduleRecord.activate === "function") {
+    return true;
+  }
+  const defaultExport = moduleRecord.default;
+  if (typeof defaultExport !== "object" || defaultExport === null) {
+    return false;
+  }
+  return typeof defaultExport.activate === "function";
+}
+function summarizeLoadedExtension(extension) {
+  const summary = {
+    layer: extension.layer,
+    directory: extension.directory,
+    manifest_path: extension.manifest_path,
+    name: extension.name,
+    version: extension.version,
+    entry: extension.entry,
+    priority: extension.priority,
+    entry_path: extension.entry_path,
+    has_activate: hasActivateExport(extension.module)
+  };
+  if (Array.isArray(extension.capabilities)) {
+    summary.capabilities = [...extension.capabilities];
+  }
+  return summary;
+}
+function resolveMigrationId(definition, fallbackIndex) {
+  const explicitId = toNonEmptyStringOrUndefined(definition.id);
+  if (explicitId) {
+    return explicitId;
+  }
+  return `migration-${String(fallbackIndex + 1).padStart(3, "0")}`;
+}
+function resolveMigrationStatus(definition) {
+  const rawStatus = toNonEmptyStringOrUndefined(definition.status);
+  const normalized = rawStatus?.toLowerCase();
+  if (normalized === "failed") {
+    return "failed";
+  }
+  if (normalized === "applied") {
+    return "applied";
+  }
+  return "pending";
+}
+function resolveMigrationFailureReason(definition) {
+  return toNonEmptyStringOrUndefined(definition.reason) ?? toNonEmptyStringOrUndefined(definition.error) ?? toNonEmptyStringOrUndefined(definition.message);
+}
+function compareMigrationEntries(left, right) {
+  const byLayer = (left.layer ?? "").localeCompare(right.layer ?? "");
+  if (byLayer !== 0) {
+    return byLayer;
+  }
+  const byName = (left.name ?? "").localeCompare(right.name ?? "");
+  if (byName !== 0) {
+    return byName;
+  }
+  return (left.id ?? "").localeCompare(right.id ?? "");
+}
+function summarizeMigrationStatuses(migrations) {
+  const applied = [];
+  const pending = [];
+  const failed = [];
+  migrations.forEach((migration, index) => {
+    const id = resolveMigrationId(migration.definition, index);
+    const status = resolveMigrationStatus(migration.definition);
+    if (status === "applied") {
+      applied.push({
+        layer: migration.layer,
+        name: migration.name,
+        id,
+        status
+      });
+      return;
+    }
+    if (status === "failed") {
+      failed.push({
+        layer: migration.layer,
+        name: migration.name,
+        id,
+        status,
+        reason: resolveMigrationFailureReason(migration.definition)
+      });
+      return;
+    }
+    pending.push({
+      layer: migration.layer,
+      name: migration.name,
+      id,
+      status
+    });
+  });
+  applied.sort(compareMigrationEntries);
+  pending.sort(compareMigrationEntries);
+  failed.sort(compareMigrationEntries);
+  const warnings = [
+    ...failed.map((entry) => `extension_migration_failed:${entry.layer}:${entry.name}:${entry.id}`),
+    ...pending.map((entry) => `extension_migration_pending:${entry.layer}:${entry.name}:${entry.id}`)
+  ];
+  return {
+    summary: {
+      applied,
+      pending,
+      failed,
+      applied_count: applied.length,
+      pending_count: pending.length,
+      failed_count: failed.length
+    },
+    warnings
+  };
+}
+function buildExtensionHealthTriageSummary(warnings, loadFailureCount, activationFailureCount, migrationStatus, managedStateWarningCount, managedExtensionEntriesCount, unmanagedLoadedExtensions, unmanagedExpectedExtensions, unmanagedActionRequiredExtensions) {
+  const normalizedWarnings = [...new Set(warnings)].sort((left, right) => left.localeCompare(right));
+  const warningCodes = [...new Set(normalizedWarnings.map((value) => warningCode(value)))].sort((left, right) => left.localeCompare(right));
+  const unknownCapabilityCount = normalizedWarnings.filter((warning) => warning.startsWith("extension_capability_unknown:")).length;
+  const updateHealthPartial = unmanagedActionRequiredExtensions.length > 0;
+  const updateHealthCoverage = updateHealthPartial ? "partial" : "full";
+  const remediation = [];
+  const registrationCollisionRemediation = buildRegistrationCollisionRemediation(normalizedWarnings, {
+    deactivate: "pm extension --deactivate <name> --project/--global",
+    doctor: "pm extension --doctor --project/--global --detail deep --trace"
+  });
+  if (registrationCollisionRemediation) {
+    remediation.push(registrationCollisionRemediation);
+  }
+  if (loadFailureCount > 0) {
+    remediation.push("Run pm extension --explore --project and pm extension --explore --global to inspect load failures.");
+  }
+  if (activationFailureCount > 0) {
+    remediation.push("Review checks[name=extensions].details.activation.failed in pm health --json for activation error details.");
+  }
+  if (migrationStatus.failed_count > 0 || migrationStatus.pending_count > 0) {
+    remediation.push("Resolve pending/failed extension migrations before write commands; use --force only when policy allows.");
+  }
+  if (managedStateWarningCount > 0) {
+    remediation.push("Run pm extension --manage --project and pm extension --manage --global to refresh managed-state diagnostics.");
+  }
+  if (unknownCapabilityCount > 0) {
+    remediation.push(`Unknown extension capabilities detected. Allowed capabilities: ${KNOWN_EXTENSION_CAPABILITIES.join(", ")}. Review extension_capability_unknown warning details for suggested replacements.`);
+  }
+  if (normalizedWarnings.some((warning) => warning.startsWith("extension_capability_legacy_alias:"))) {
+    remediation.push("Legacy extension capability aliases were auto-remapped to canonical capabilities. Update manifests to canonical names (migration/validation -> schema).");
+  }
+  if (normalizedWarnings.some((warning) => warning.startsWith("extension_command_definition_legacy_handler_alias:"))) {
+    remediation.push("Extension command definitions using legacy handler were auto-remapped. Update command definitions to use run: (context) => ... for forward compatibility.");
+  }
+  if (updateHealthPartial) {
+    remediation.push("Update-check coverage is partial because unmanaged extensions need adoption. Adopt existing installs via pm extension --manage --project/--global --fix-managed-state, pm extension --adopt-all --project/--global, or pm extension --adopt <name>.");
+  } else if (unmanagedLoadedExtensions.length > 0) {
+    remediation.push("Loaded unmanaged extensions are currently treated as informational. Use pm extension --manage --project/--global --fix-managed-state to adopt them for update checks.");
+  }
+  if (remediation.length === 0) {
+    remediation.push("No immediate action required. Re-run pm health after extension configuration changes.");
+  }
+  return {
+    status: normalizedWarnings.length === 0 ? "ok" : "warn",
+    warning_count: normalizedWarnings.length,
+    warning_codes: warningCodes,
+    load_failure_count: loadFailureCount,
+    activation_failure_count: activationFailureCount,
+    migration_failed_count: migrationStatus.failed_count,
+    migration_pending_count: migrationStatus.pending_count,
+    managed_state_warning_count: managedStateWarningCount,
+    managed_extension_entries_count: managedExtensionEntriesCount,
+    unmanaged_loaded_extension_count: unmanagedLoadedExtensions.length,
+    unmanaged_loaded_extensions: unmanagedLoadedExtensions,
+    unmanaged_expected_extension_count: unmanagedExpectedExtensions.length,
+    unmanaged_expected_extensions: unmanagedExpectedExtensions,
+    unmanaged_action_required_extension_count: unmanagedActionRequiredExtensions.length,
+    unmanaged_action_required_extensions: unmanagedActionRequiredExtensions,
+    update_health_coverage: updateHealthCoverage,
+    update_health_partial: updateHealthPartial,
+    unknown_capability_count: unknownCapabilityCount,
+    top_warnings: normalizedWarnings.slice(0, 8),
+    remediation
+  };
+}
+async function buildExtensionCheck(pmRoot, settings, noExtensionsFlag) {
+  const loadResult = await loadExtensions({
+    pmRoot,
+    settings,
+    cwd: process.cwd(),
+    noExtensions: noExtensionsFlag
+  });
+  const loadedSummaries = loadResult.loaded.map((extension) => summarizeLoadedExtension(extension));
+  const activationResult = await activateExtensions({
+    ...loadResult,
+    loaded: loadResult.loaded
+  });
+  const [projectManagedState, globalManagedState] = await Promise.all([
+    readManagedExtensionState(loadResult.roots.project),
+    readManagedExtensionState(loadResult.roots.global)
+  ]);
+  const migrationStatus = summarizeMigrationStatuses(activationResult.registrations.migrations);
+  const activationDetails = {
+    failed: activationResult.failed,
+    warnings: activationResult.warnings,
+    hook_counts: activationResult.hook_counts,
+    command_override_count: activationResult.command_override_count,
+    command_handler_count: activationResult.command_handler_count,
+    parser_override_count: activationResult.parser_override_count,
+    preflight_override_count: activationResult.preflight_override_count,
+    service_override_count: activationResult.service_override_count,
+    renderer_override_count: activationResult.renderer_override_count,
+    registration_counts: activationResult.registration_counts,
+    registrations: activationResult.registrations,
+    migration_status: migrationStatus.summary,
+    managed_extensions: {
+      project: {
+        path: projectManagedState.path,
+        count: projectManagedState.state.entries.length,
+        entries: projectManagedState.state.entries
+      },
+      global: {
+        path: globalManagedState.path,
+        count: globalManagedState.state.entries.length,
+        entries: globalManagedState.state.entries
+      }
+    }
+  };
+  const managedProjectNames = new Set(projectManagedState.state.entries.map((entry) => normalizeExtensionNameForMatch(entry.name)));
+  const managedGlobalNames = new Set(globalManagedState.state.entries.map((entry) => normalizeExtensionNameForMatch(entry.name)));
+  const unmanagedLoadedEntries = [
+    ...new Map(loadResult.loaded.filter((entry) => {
+      const managedNames = entry.layer === "project" ? managedProjectNames : managedGlobalNames;
+      return !managedNames.has(normalizeExtensionNameForMatch(entry.name));
+    }).map((entry) => [
+      `${entry.layer}:${entry.name}`,
+      {
+        layer: entry.layer,
+        name: entry.name,
+        directory: entry.directory
+      }
+    ])).values()
+  ].sort((left, right) => {
+    const leftKey = `${left.layer}:${left.name}`;
+    const rightKey = `${right.layer}:${right.name}`;
+    return leftKey.localeCompare(rightKey);
+  });
+  const unmanagedLoadedExtensions = unmanagedLoadedEntries.map((entry) => `${entry.layer}:${entry.name}`).sort((left, right) => left.localeCompare(right));
+  const unmanagedExpectedExtensions = unmanagedLoadedEntries.filter((entry) => isExpectedUnmanagedExtension(entry.name, entry.directory)).map((entry) => `${entry.layer}:${entry.name}`).sort((left, right) => left.localeCompare(right));
+  const unmanagedActionRequiredExtensions = unmanagedLoadedEntries.filter((entry) => !isExpectedUnmanagedExtension(entry.name, entry.directory)).map((entry) => `${entry.layer}:${entry.name}`).sort((left, right) => left.localeCompare(right));
+  const updateCoverageWarnings = unmanagedActionRequiredExtensions.length > 0 ? [`extension_update_health_partial_coverage:skipped_unmanaged:${unmanagedActionRequiredExtensions.length}`] : [];
+  const extensionWarnings = [
+    ...loadResult.warnings,
+    ...activationDetails.warnings,
+    ...migrationStatus.warnings,
+    ...projectManagedState.warnings,
+    ...globalManagedState.warnings,
+    ...updateCoverageWarnings
+  ];
+  const capabilityGuidance = collectUnknownCapabilityGuidance(extensionWarnings);
+  const capabilityContract = buildCapabilityContractMetadata();
+  const extensionTriage = buildExtensionHealthTriageSummary(extensionWarnings, loadResult.failed.length, activationResult.failed.length, migrationStatus.summary, projectManagedState.warnings.length + globalManagedState.warnings.length, projectManagedState.state.entries.length + globalManagedState.state.entries.length, unmanagedLoadedExtensions, unmanagedExpectedExtensions, unmanagedActionRequiredExtensions);
+  return {
+    check: {
+      name: "extensions",
+      status: extensionWarnings.length === 0 ? "ok" : "warn",
+      details: {
+        ...loadResult,
+        loaded: loadedSummaries,
+        warnings: extensionWarnings,
+        activation: activationDetails,
+        triage: extensionTriage,
+        capability_contract: capabilityContract,
+        capability_guidance: capabilityGuidance
+      }
+    },
+    warnings: extensionWarnings
+  };
+}
+function summarizeList(values, limit) {
+  if (values.length <= limit) {
+    return { values, truncated: false };
+  }
+  return {
+    values: values.slice(0, limit),
+    truncated: true
+  };
+}
+function summarizeRecordList(value, limit) {
+  if (!Array.isArray(value)) {
+    return {
+      count: 0,
+      sample: [],
+      truncated: false
+    };
+  }
+  return {
+    count: value.length,
+    sample: value.slice(0, limit),
+    truncated: value.length > limit
+  };
+}
+function summarizeExtensionRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return {};
+  }
+  const record = value;
+  return {
+    layer: record.layer,
+    directory: record.directory,
+    name: record.name,
+    version: record.version,
+    enabled: record.enabled,
+    status: record.status,
+    has_activate: record.has_activate,
+    capabilities: record.capabilities
+  };
+}
+function summarizeExtensionList(value, limit) {
+  const summary = summarizeRecordList(value, limit);
+  return {
+    ...summary,
+    sample: summary.sample.map((entry) => summarizeExtensionRecord(entry))
+  };
+}
+function summarizeStringList(value, limit) {
+  if (!Array.isArray(value)) {
+    return {
+      count: 0,
+      sample: [],
+      truncated: false
+    };
+  }
+  const strings = value.filter((entry) => typeof entry === "string");
+  return {
+    count: strings.length,
+    sample: strings.slice(0, limit),
+    truncated: strings.length > limit
+  };
+}
+function summarizeActivationMigrationStatus(value) {
+  if (typeof value !== "object" || value === null) {
+    return null;
+  }
+  const status = value;
+  return {
+    applied_count: status.applied_count,
+    pending_count: status.pending_count,
+    failed_count: status.failed_count
+  };
+}
+var HEALTH_DETAIL_SUMMARIZERS = {
+  settings: (details, limit) => ({
+    version: details.version,
+    id_prefix: details.id_prefix,
+    locks_ttl_seconds: details.locks_ttl_seconds,
+    warnings: summarizeStringList(details.warnings, limit)
+  }),
+  directories: (details, limit) => ({
+    required_count: Array.isArray(details.required) ? details.required.length : 0,
+    optional_count: Array.isArray(details.optional) ? details.optional.length : 0,
+    missing_required: summarizeStringList(details.missing_required, limit),
+    missing_optional: summarizeStringList(details.missing_optional, limit),
+    missing: summarizeStringList(details.missing, limit),
+    strict_directories: details.strict_directories
+  }),
+  settings_values: (details, limit) => ({
+    warnings: summarizeStringList(details.warnings, limit)
+  }),
+  telemetry: (details) => ({
+    enabled: details.enabled,
+    capture_level: details.capture_level,
+    endpoint: details.endpoint,
+    queue_exists: details.queue_exists,
+    queue_entries: details.queue_entries,
+    queue_draining: details.queue_draining,
+    queue_invalid_rows: details.queue_invalid_rows,
+    queue_rows_total: details.queue_rows_total,
+    last_successful_flush_at: details.last_successful_flush_at,
+    last_failed_flush_at: details.last_failed_flush_at,
+    endpoint_probe: details.endpoint_probe,
+    env_overrides: details.env_overrides
+  }),
+  extensions: (details, limit) => {
+    const activation = typeof details.activation === "object" && details.activation !== null ? details.activation : {};
+    return {
+      disabled_by_flag: details.disabled_by_flag,
+      discovered: summarizeExtensionList(details.discovered, limit),
+      effective: summarizeExtensionList(details.effective, limit),
+      loaded: summarizeExtensionList(details.loaded, limit),
+      failed: summarizeRecordList(details.failed, limit),
+      warnings: summarizeStringList(details.warnings, limit),
+      activation: {
+        failed: summarizeRecordList(activation.failed, limit),
+        warnings: summarizeStringList(activation.warnings, limit),
+        hook_counts: activation.hook_counts,
+        command_handler_count: activation.command_handler_count,
+        service_override_count: activation.service_override_count,
+        renderer_override_count: activation.renderer_override_count,
+        registration_counts: activation.registration_counts,
+        migration_status: summarizeActivationMigrationStatus(activation.migration_status)
+      },
+      triage: details.triage,
+      capability_contract: details.capability_contract,
+      capability_guidance: summarizeRecordList(details.capability_guidance, limit)
+    };
+  },
+  // Storage details are already compact counters; keep the pre-refactor pass-through shape.
+  storage: (details) => details,
+  locks: (details) => ({
+    active_lock_count: details.active_lock_count,
+    stale_lock_count: details.stale_lock_count,
+    unreadable_lock_count: details.unreadable_lock_count,
+    unparseable_lock_count: details.unparseable_lock_count
+  }),
+  integrity: (details, limit) => ({
+    checked_item_files: details.checked_item_files,
+    checked_history_streams: details.checked_history_streams,
+    counts: details.counts,
+    item_unreadable: summarizeStringList(details.item_unreadable, limit),
+    item_conflict_markers: summarizeRecordList(details.item_conflict_markers, limit),
+    item_parse_failures: summarizeStringList(details.item_parse_failures, limit),
+    history_unreadable: summarizeStringList(details.history_unreadable, limit),
+    history_conflict_markers: summarizeRecordList(details.history_conflict_markers, limit),
+    history_invalid_json: summarizeRecordList(details.history_invalid_json, limit),
+    skipped: details.skipped
+  }),
+  history_drift: (details, limit) => ({
+    checked_items: details.checked_items,
+    counts: details.counts,
+    drifted_items: summarizeStringList(details.drifted_items, limit),
+    missing_streams: summarizeStringList(details.missing_streams, limit),
+    unreadable_streams: summarizeStringList(details.unreadable_streams, limit),
+    hash_mismatches: summarizeStringList(details.hash_mismatches, limit),
+    chain_mismatches: summarizeStringList(details.chain_mismatches, limit),
+    skipped: details.skipped
+  }),
+  vectorization: (details, limit) => ({
+    semantic_runtime_available: details.semantic_runtime_available,
+    compatibility_mode_auto_defaults: details.compatibility_mode_auto_defaults,
+    auto_ollama_defaults_applied: details.auto_ollama_defaults_applied,
+    refresh_policy: details.refresh_policy,
+    provider_active: details.provider_active,
+    vector_store_active: details.vector_store_active,
+    items: details.items,
+    ledger_entries_before: details.ledger_entries_before,
+    stale_items_before_total: details.stale_items_before_total,
+    stale_items_before: summarizeStringList(details.stale_items_before, limit),
+    refresh_attempted: details.refresh_attempted,
+    refresh_skipped_reason: details.refresh_skipped_reason,
+    refresh_result: details.refresh_result,
+    ledger_entries_after: details.ledger_entries_after,
+    stale_items_after_total: details.stale_items_after_total,
+    stale_items_after: summarizeStringList(details.stale_items_after, limit),
+    skipped: details.skipped
+  })
+};
+function summarizeHealthCheckDetails(check, limit) {
+  const summarize = HEALTH_DETAIL_SUMMARIZERS[check.name];
+  return summarize ? summarize(check.details, limit) : check.details;
+}
+function applyBriefHealthProjection(result) {
+  const warningsSummary = summarizeStringList(result.warnings, BRIEF_HEALTH_DETAIL_LIMIT);
+  return {
+    ok: result.ok,
+    checks: result.checks.map((check) => ({
+      name: check.name,
+      status: check.status,
+      details: summarizeHealthCheckDetails(check, BRIEF_HEALTH_DETAIL_LIMIT)
+    })),
+    warnings: warningsSummary.sample,
+    projection: {
+      mode: "brief",
+      warning_count: warningsSummary.count,
+      warnings_truncated: warningsSummary.truncated,
+      detail_limit: BRIEF_HEALTH_DETAIL_LIMIT
+    },
+    generated_at: result.generated_at
+  };
+}
+function isSkippedHealthCheck(check) {
+  return check.details.skipped === true;
+}
+function applySummaryHealthProjection(result) {
+  const warningsSummary = summarizeStringList(result.warnings, BRIEF_HEALTH_DETAIL_LIMIT);
+  const omittedChecks = result.checks.filter(isSkippedHealthCheck).map((check) => check.name);
+  return {
+    ok: result.ok,
+    checks: result.checks.filter((check) => !isSkippedHealthCheck(check)).map((check) => ({
+      name: check.name,
+      status: check.status,
+      details: {}
+    })),
+    warning_count: warningsSummary.count,
+    warnings: warningsSummary.sample,
+    projection: {
+      mode: "summary",
+      warning_count: warningsSummary.count,
+      warnings_truncated: warningsSummary.truncated,
+      detail_limit: BRIEF_HEALTH_DETAIL_LIMIT,
+      omitted_checks: omittedChecks
+    },
+    generated_at: result.generated_at
+  };
+}
+function selectStaleItemDetail(values, verboseStaleItems) {
+  if (verboseStaleItems) {
+    return {
+      values,
+      truncated: false,
+      total: values.length
+    };
+  }
+  const summary = summarizeList(values, STALE_VECTORIZATION_SUMMARY_LIMIT);
+  return {
+    values: summary.values,
+    truncated: summary.truncated,
+    total: values.length
+  };
+}
+function telemetryEnvFlagEnabled(envKey) {
+  const value = (process.env[envKey] ?? "").trim().toLowerCase();
+  return value === "1" || value === "true" || value === "yes" || value === "on";
+}
+function telemetrySourceContextOverride() {
+  const value = (process.env.PM_TELEMETRY_SOURCE_CONTEXT ?? "").trim().toLowerCase();
+  return PM_TELEMETRY_SOURCE_CONTEXT_SET.has(value) ? value : null;
+}
+function normalizeEndpointForDisplay(rawEndpoint) {
+  const trimmed = rawEndpoint.trim();
+  if (trimmed.length === 0) {
+    return "";
+  }
+  try {
+    const parsed = new URL(trimmed);
+    parsed.username = "";
+    parsed.password = "";
+    parsed.search = "";
+    parsed.hash = "";
+    return parsed.toString();
+  } catch {
+    return trimmed;
+  }
+}
+function parseTelemetryQueue(raw) {
+  let validEntries = 0;
+  let invalidRows = 0;
+  let totalRows = 0;
+  let highRetryEntries = 0;
+  let maxAttempts = 0;
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) {
+      continue;
+    }
+    totalRows += 1;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (typeof parsed === "object" && parsed !== null && typeof parsed.attempts === "number" && Number.isFinite(parsed.attempts)) {
+        const attempts = Math.max(0, Math.trunc(parsed.attempts));
+        validEntries += 1;
+        maxAttempts = Math.max(maxAttempts, attempts);
+        if (attempts >= TELEMETRY_QUEUE_HIGH_RETRY_THRESHOLD) {
+          highRetryEntries += 1;
+        }
+      } else {
+        invalidRows += 1;
+      }
+    } catch {
+      invalidRows += 1;
+    }
+  }
+  return {
+    validEntries,
+    invalidRows,
+    totalRows,
+    highRetryEntries,
+    maxAttempts
+  };
+}
+function emptyTelemetryQueueSummary() {
+  return { validEntries: 0, invalidRows: 0, totalRows: 0, highRetryEntries: 0, maxAttempts: 0 };
+}
+function parseTelemetryRuntimeState(stateRaw) {
+  if (!stateRaw || stateRaw.trim().length === 0) {
+    return { runtimeState: {}, stateParseFailed: false };
+  }
+  try {
+    const parsed = JSON.parse(stateRaw);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return { runtimeState: parsed, stateParseFailed: false };
+    }
+    return { runtimeState: {}, stateParseFailed: true };
+  } catch {
+    return { runtimeState: {}, stateParseFailed: true };
+  }
+}
+async function maybeProbeTelemetryEndpoint(settings, checkTelemetry) {
+  const endpoint = settings.telemetry.endpoint.trim();
+  if (!checkTelemetry || !settings.telemetry.enabled || endpoint.length === 0) {
+    return void 0;
+  }
+  const probe = await probeTelemetryEndpointHealth(endpoint);
+  return {
+    attempted: true,
+    ...probe
+  };
+}
+function collectTelemetryQueueWarnings(settings, queueSummary, runtimeState) {
+  const warnings = [];
+  if (queueSummary.invalidRows > 0) {
+    warnings.push(`telemetry_queue_invalid_rows:${queueSummary.invalidRows}`);
+  }
+  if (!settings.telemetry.enabled || queueSummary.validEntries === 0) {
+    return warnings;
+  }
+  const lastSuccess = runtimeState.last_successful_flush_at;
+  const lastFailure = runtimeState.last_failed_flush_at;
+  const activeFailure = lastFailure && (!lastSuccess || lastFailure > lastSuccess);
+  const neverFlushed = !lastSuccess;
+  const highWater = queueSummary.validEntries >= TELEMETRY_QUEUE_HIGH_WATER_MARK;
+  if (activeFailure || neverFlushed || highWater) {
+    warnings.push(`telemetry_queue_pending:${queueSummary.validEntries}`);
+  }
+  if (queueSummary.highRetryEntries > 0) {
+    warnings.push(`telemetry_queue_high_retries:${queueSummary.highRetryEntries}`);
+  }
+  return warnings;
+}
+function collectTelemetryEndpointWarnings(endpointProbe) {
+  if (!endpointProbe || endpointProbe.ok !== false) {
+    return [];
+  }
+  return typeof endpointProbe.status === "number" ? [`telemetry_endpoint_probe_http_status:${endpointProbe.status}`] : ["telemetry_endpoint_probe_failed"];
+}
+function collectTelemetrySchemaWarnings(endpointProbe) {
+  const parsedMaxSchemaVersion = Number.parseInt(endpointProbe?.max_schema_version ?? "", 10);
+  if (endpointProbe?.ok === true && Number.isInteger(parsedMaxSchemaVersion) && parsedMaxSchemaVersion > TELEMETRY_SCHEMA_VERSION) {
+    return [`telemetry_schema_version_behind:${parsedMaxSchemaVersion}`];
+  }
+  return [];
+}
+function collectTelemetryOtelWarnings(settings, runtimeState) {
+  const pendingOtelSpans = typeof runtimeState.pending_otel_spans === "number" ? runtimeState.pending_otel_spans : 0;
+  const lastOtelSuccess = runtimeState.last_otel_success_at;
+  const lastOtelFailure = runtimeState.last_otel_failure_at;
+  const otelExportFailing = settings.telemetry.enabled && pendingOtelSpans > 0 && Boolean(lastOtelFailure) && // >= so a mixed-outcome batch (success + failure share the same attempt
+  // timestamp) still surfaces the warning rather than being masked by the tie.
+  (!lastOtelSuccess || lastOtelFailure >= lastOtelSuccess);
+  return otelExportFailing ? [`telemetry_otel_export_failing:${pendingOtelSpans}`] : [];
+}
+function buildTelemetryEnvOverrideDetails() {
+  return {
+    telemetry_disabled: telemetryEnvFlagEnabled("PM_TELEMETRY_DISABLED") || telemetryEnvFlagEnabled("PM_NO_TELEMETRY"),
+    pm_no_telemetry: telemetryEnvFlagEnabled("PM_NO_TELEMETRY"),
+    telemetry_otel_disabled: telemetryEnvFlagEnabled("PM_TELEMETRY_OTEL_DISABLED"),
+    telemetry_inline_flush: telemetryEnvFlagEnabled("PM_TELEMETRY_INLINE_FLUSH"),
+    telemetry_source_context: telemetrySourceContextOverride()
+  };
+}
+function telemetryQueueHasEntries(settings, queueSummary) {
+  return settings.telemetry.enabled && queueSummary.validEntries > 0;
+}
+function isTelemetryQueueDraining(queueHasEntries, warnings) {
+  return queueHasEntries && warnings.every((warning) => !warning.startsWith("telemetry_queue_pending:") && !warning.startsWith("telemetry_queue_high_retries:"));
+}
+async function probeTelemetryEndpointHealth(endpoint) {
+  let probeUrl = endpoint;
+  try {
+    const parsed = new URL(endpoint);
+    parsed.pathname = "/healthz";
+    parsed.search = "";
+    parsed.hash = "";
+    probeUrl = parsed.toString();
+  } catch {
+  }
+  try {
+    const response = await fetch(probeUrl, {
+      method: "GET",
+      signal: AbortSignal.timeout(TELEMETRY_ENDPOINT_PROBE_TIMEOUT_MS)
+    });
+    return {
+      probe_url: normalizeEndpointForDisplay(probeUrl),
+      ok: response.ok,
+      status: response.status,
+      max_schema_version: (() => {
+        for (const headerName of TELEMETRY_SERVER_MAX_SCHEMA_VERSION_HEADERS) {
+          const value = response.headers.get(headerName)?.trim();
+          if (value && value.length > 0) {
+            return value;
+          }
+        }
+        return void 0;
+      })()
+    };
+  } catch (error) {
+    return {
+      probe_url: normalizeEndpointForDisplay(probeUrl),
+      ok: false,
+      /* c8 ignore next -- non-Error throwables require transport-layer fault injection */
+      error: error instanceof Error ? error.message : "probe_failed"
+    };
+  }
+}
+async function buildTelemetryCheck(settings, options) {
+  const globalPmRoot = resolveGlobalPmRoot(process.cwd());
+  const queuePath = path.join(globalPmRoot, TELEMETRY_QUEUE_RELATIVE_PATH);
+  const statePath = path.join(globalPmRoot, TELEMETRY_STATE_RELATIVE_PATH);
+  const queueRaw = await readFileIfExists(queuePath);
+  const queueExists = queueRaw !== null;
+  const queueSizeBytes = queueRaw ? Buffer.byteLength(queueRaw, "utf8") : 0;
+  const queueSummary = queueRaw ? parseTelemetryQueue(queueRaw) : emptyTelemetryQueueSummary();
+  const stateRaw = await readFileIfExists(statePath);
+  const { runtimeState, stateParseFailed } = parseTelemetryRuntimeState(stateRaw);
+  const endpoint = settings.telemetry.endpoint.trim();
+  const endpointDisplay = normalizeEndpointForDisplay(endpoint);
+  const endpointProbe = await maybeProbeTelemetryEndpoint(settings, options.checkTelemetry);
+  const warnings = [];
+  if (stateParseFailed) {
+    warnings.push("telemetry_state_invalid_json");
+  }
+  warnings.push(...collectTelemetryQueueWarnings(settings, queueSummary, runtimeState), ...collectTelemetryEndpointWarnings(endpointProbe), ...collectTelemetrySchemaWarnings(endpointProbe), ...collectTelemetryOtelWarnings(settings, runtimeState));
+  const queueHasEntries = telemetryQueueHasEntries(settings, queueSummary);
+  const pendingOtelSpans = typeof runtimeState.pending_otel_spans === "number" ? runtimeState.pending_otel_spans : 0;
+  return {
+    check: {
+      name: "telemetry",
+      status: warnings.length === 0 ? "ok" : "warn",
+      details: {
+        enabled: settings.telemetry.enabled,
+        capture_level: settings.telemetry.capture_level,
+        endpoint: endpointDisplay,
+        global_pm_root: globalPmRoot,
+        queue_path: queuePath,
+        queue_exists: queueExists,
+        queue_entries: queueSummary.validEntries,
+        queue_draining: isTelemetryQueueDraining(queueHasEntries, warnings),
+        queue_invalid_rows: queueSummary.invalidRows,
+        queue_rows_total: queueSummary.totalRows,
+        queue_size_bytes: queueSizeBytes,
+        queue_high_retry_entries: queueSummary.highRetryEntries,
+        queue_high_retry_threshold: TELEMETRY_QUEUE_HIGH_RETRY_THRESHOLD,
+        queue_max_attempts: queueSummary.maxAttempts,
+        runtime_state_path: statePath,
+        last_attempted_flush_at: runtimeState.last_attempted_flush_at ?? null,
+        last_successful_flush_at: runtimeState.last_successful_flush_at ?? null,
+        last_failed_flush_at: runtimeState.last_failed_flush_at ?? null,
+        last_failed_flush_error: runtimeState.last_failed_flush_error ?? null,
+        pending_otel_spans: pendingOtelSpans,
+        last_otel_attempt_at: runtimeState.last_otel_attempt_at ?? null,
+        last_otel_success_at: runtimeState.last_otel_success_at ?? null,
+        last_otel_failure_at: runtimeState.last_otel_failure_at ?? null,
+        last_otel_failure_error: runtimeState.last_otel_failure_error ?? null,
+        endpoint_probe: endpointProbe ?? { attempted: false },
+        env_overrides: buildTelemetryEnvOverrideDetails()
+      }
+    },
+    warnings
+  };
+}
+async function buildLocksCheck(pmRoot) {
+  let scan;
+  try {
+    scan = await scanLockHealth(pmRoot);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      check: {
+        name: "locks",
+        status: "warn",
+        details: {
+          active_lock_count: 0,
+          stale_lock_count: 0,
+          unreadable_lock_count: 0,
+          unparseable_lock_count: 0,
+          scan_failed: true,
+          error: message,
+          pm_root: pmRoot
+        }
+      },
+      warnings: [`locks_scan_failed:${message}`]
+    };
+  }
+  const warnings = [];
+  if (scan.stale_lock_count > 0) {
+    warnings.push(`locks_stale_count:${scan.stale_lock_count}`);
+  }
+  if (scan.unreadable_lock_count > 0) {
+    warnings.push(`locks_unreadable:${scan.unreadable_lock_count}`);
+  }
+  return {
+    check: {
+      name: "locks",
+      status: warnings.length === 0 ? "ok" : "warn",
+      details: {
+        active_lock_count: scan.active_lock_count,
+        stale_lock_count: scan.stale_lock_count,
+        unreadable_lock_count: scan.unreadable_lock_count,
+        unparseable_lock_count: scan.unparseable_lock_count
+      }
+    },
+    warnings
+  };
+}
+async function buildHistoryDriftCheck(pmRoot, items) {
+  const cacheHitVerification = "metadata";
+  const { missingStreams, unreadableStreams, hashMismatches, chainMismatches, driftedItems } = await scanHistoryDrift(pmRoot, items, { cacheHitVerification });
+  const warnings = [
+    ...missingStreams.map((id) => `history_drift_missing_stream:${id}`),
+    ...unreadableStreams.map((id) => `history_drift_unreadable_stream:${id}`),
+    ...hashMismatches.map((id) => `history_drift_hash_mismatch:${id}`),
+    ...chainMismatches.map((id) => `history_drift_chain_mismatch:${id}`)
+  ];
+  return {
+    check: {
+      name: "history_drift",
+      status: warnings.length === 0 ? "ok" : "warn",
+      details: {
+        checked_items: items.length,
+        cache_hit_verification: cacheHitVerification,
+        drifted_items: driftedItems,
+        counts: {
+          drifted: driftedItems.length,
+          missing_streams: missingStreams.length,
+          unreadable_streams: unreadableStreams.length,
+          hash_mismatches: hashMismatches.length,
+          chain_mismatches: chainMismatches.length
+        },
+        missing_streams: missingStreams,
+        unreadable_streams: unreadableStreams,
+        hash_mismatches: hashMismatches,
+        chain_mismatches: chainMismatches
+      }
+    },
+    warnings
+  };
+}
+function buildVectorizationRuntimeSnapshot(settings) {
+  const runtimeDefaults = resolveSettingsWithSemanticRuntimeDefaults(settings);
+  const providerResolution = resolveEmbeddingProviders(runtimeDefaults.settings);
+  const vectorStoreResolution = resolveVectorStores(runtimeDefaults.settings);
+  const runtimeEmbeddingIdentity = providerResolution.active ? buildVectorizationEmbeddingIdentity(providerResolution.active.name, providerResolution.active.model) : null;
+  return {
+    runtimeDefaults,
+    providerResolution,
+    vectorStoreResolution,
+    runtimeEmbeddingIdentity,
+    semanticRuntimeAvailable: Boolean(providerResolution.active && vectorStoreResolution.active)
+  };
+}
+function emptyVectorizationRefreshResult() {
+  return {
+    refreshed: [],
+    skipped: [],
+    warnings: []
+  };
+}
+async function refreshStaleVectorizationItems(params) {
+  if (!params.refreshPolicy.enabled || !params.snapshot.semanticRuntimeAvailable || params.staleBefore.length === 0) {
+    return emptyVectorizationRefreshResult();
+  }
+  return refreshSemanticEmbeddingsForMutatedItems(params.pmRoot, params.staleBefore, {
+    settings: params.snapshot.runtimeDefaults.settings,
+    apply_runtime_defaults: false
+  });
+}
+function vectorizationEmbeddingIdentityChanged(params) {
+  return params.strictVectorizationWarnings && params.semanticRuntimeAvailable && Boolean(params.ledgerBefore.embedding && params.runtimeEmbeddingIdentity && hasVectorizationEmbeddingIdentityChanged(params.ledgerBefore.embedding, params.runtimeEmbeddingIdentity));
+}
+function collectVectorizationWarnings(params) {
+  const warningSet = /* @__PURE__ */ new Set([...params.ledgerBefore.warnings, ...params.ledgerAfter.warnings]);
+  if (params.strictVectorizationWarnings) {
+    for (const warning of params.refreshResult.warnings) {
+      warningSet.add(warning);
+    }
+  }
+  if (params.embeddingIdentityChanged) {
+    warningSet.add("vectorization_embedding_identity_changed");
+  }
+  if (params.strictVectorizationWarnings && params.semanticRuntimeAvailable && params.staleAfter.length > 0) {
+    warningSet.add(`vectorization_stale_items_remaining:${params.staleAfter.length}`);
+  }
+  return [...warningSet].sort((left, right) => left.localeCompare(right));
+}
+function resolveVectorizationRefreshSkippedReason(refreshPolicy, semanticRuntimeAvailable, staleBefore) {
+  if (refreshPolicy.enabled && semanticRuntimeAvailable && staleBefore.length > 0) {
+    return null;
+  }
+  if (!refreshPolicy.enabled) {
+    return "refresh_disabled";
+  }
+  return semanticRuntimeAvailable ? "no_stale_items" : "semantic_runtime_unavailable";
+}
+function buildVectorizationProviderDetails(settings, snapshot) {
+  const activeProvider = snapshot.providerResolution.active?.name ?? null;
+  const activeVectorStore = snapshot.vectorStoreResolution.active?.name ?? null;
+  return {
+    provider_active: activeProvider,
+    // GH-244: surface the persisted (possibly empty) configured value and
+    // how the active resolution was sourced, so a config audit can tell
+    // "auto-detected" apart from a genuine misconfiguration when
+    // settings.search.provider / vector_store.adapter are empty strings.
+    provider_configured: typeof settings.search?.provider === "string" ? settings.search.provider : null,
+    provider_source: resolveProviderConfigSource(activeProvider, settings.search?.provider ?? null),
+    vector_store_active: activeVectorStore,
+    vector_store_configured: typeof settings.vector_store?.adapter === "string" ? settings.vector_store.adapter : null,
+    vector_store_source: resolveProviderConfigSource(activeVectorStore, settings.vector_store?.adapter ?? null)
+  };
+}
+function buildVectorizationRefreshPolicyDetails(refreshPolicy) {
+  return {
+    enabled: refreshPolicy.enabled,
+    check_only: refreshPolicy.checkOnly,
+    no_refresh: refreshPolicy.noRefresh,
+    refresh_vectors: refreshPolicy.refreshVectors
+  };
+}
+function vectorizationRefreshAttempted(refreshPolicy, semanticRuntimeAvailable, staleBefore) {
+  return refreshPolicy.enabled && staleBefore.length > 0 && semanticRuntimeAvailable;
+}
+async function buildVectorizationCheck(pmRoot, settings, items, refreshPolicy, verboseStaleItems) {
+  const snapshot = buildVectorizationRuntimeSnapshot(settings);
+  const ledgerBefore = await readVectorizationStatusLedger(pmRoot);
+  const staleBefore = snapshot.semanticRuntimeAvailable ? collectStaleVectorizationIds(items, ledgerBefore.entries) : [];
+  const refreshResult = await refreshStaleVectorizationItems({ pmRoot, snapshot, refreshPolicy, staleBefore });
+  const ledgerAfter = await readVectorizationStatusLedger(pmRoot);
+  const staleAfter = snapshot.semanticRuntimeAvailable ? collectStaleVectorizationIds(items, ledgerAfter.entries) : [];
+  const strictVectorizationWarnings = !snapshot.runtimeDefaults.auto_ollama_defaults_applied;
+  const embeddingIdentityChanged = vectorizationEmbeddingIdentityChanged({
+    strictVectorizationWarnings,
+    semanticRuntimeAvailable: snapshot.semanticRuntimeAvailable,
+    ledgerBefore,
+    runtimeEmbeddingIdentity: snapshot.runtimeEmbeddingIdentity
+  });
+  const warnings = collectVectorizationWarnings({
+    ledgerBefore,
+    ledgerAfter,
+    refreshResult,
+    strictVectorizationWarnings,
+    semanticRuntimeAvailable: snapshot.semanticRuntimeAvailable,
+    embeddingIdentityChanged,
+    staleAfter
+  });
+  const staleBeforeDetail = selectStaleItemDetail(staleBefore, verboseStaleItems);
+  const staleAfterDetail = selectStaleItemDetail(staleAfter, verboseStaleItems);
+  const refreshAttempted = vectorizationRefreshAttempted(refreshPolicy, snapshot.semanticRuntimeAvailable, staleBefore);
+  return {
+    check: {
+      name: "vectorization",
+      status: warnings.length === 0 ? "ok" : "warn",
+      details: {
+        semantic_runtime_available: snapshot.semanticRuntimeAvailable,
+        compatibility_mode_auto_defaults: snapshot.runtimeDefaults.auto_ollama_defaults_applied,
+        auto_ollama_defaults_applied: snapshot.runtimeDefaults.auto_ollama_defaults_applied,
+        refresh_policy: buildVectorizationRefreshPolicyDetails(refreshPolicy),
+        ...buildVectorizationProviderDetails(settings, snapshot),
+        embedding_identity_changed: embeddingIdentityChanged,
+        embedding_identity_before: ledgerBefore.embedding ?? null,
+        embedding_identity_runtime: snapshot.runtimeEmbeddingIdentity ?? null,
+        items: items.length,
+        ledger_entries_before: Object.keys(ledgerBefore.entries).length,
+        stale_items_detail_mode: verboseStaleItems ? "full" : "summary",
+        stale_items_summary_limit: STALE_VECTORIZATION_SUMMARY_LIMIT,
+        stale_items_before_total: staleBeforeDetail.total,
+        stale_items_before: staleBeforeDetail.values,
+        stale_items_before_truncated: staleBeforeDetail.truncated,
+        refresh_attempted: refreshAttempted,
+        refresh_skipped_reason: resolveVectorizationRefreshSkippedReason(refreshPolicy, snapshot.semanticRuntimeAvailable, staleBefore),
+        refresh_result: refreshResult,
+        ledger_entries_after: Object.keys(ledgerAfter.entries).length,
+        stale_items_after_total: staleAfterDetail.total,
+        stale_items_after: staleAfterDetail.values,
+        stale_items_after_truncated: staleAfterDetail.truncated
+      }
+    },
+    warnings
+  };
+}
+function validateSettingsValues(settings) {
+  const warnings = [];
+  if (settings.id_prefix.trim().length === 0) {
+    warnings.push("settings:id_prefix_empty");
+  }
+  if (settings.locks.ttl_seconds <= 0) {
+    warnings.push("settings:locks_ttl_non_positive");
+  }
+  return warnings;
+}
+function resolveVectorRefreshPolicy(options) {
+  const checkOnly = options.checkOnly === true;
+  const noRefresh = options.noRefresh === true || checkOnly;
+  const refreshVectors = options.refreshVectors === true;
+  if (refreshVectors && checkOnly) {
+    throw new PmCliError("--check-only cannot be combined with --refresh-vectors", EXIT_CODE.USAGE);
+  }
+  if (refreshVectors && options.noRefresh === true) {
+    throw new PmCliError("--no-refresh cannot be combined with --refresh-vectors", EXIT_CODE.USAGE);
+  }
+  return {
+    enabled: refreshVectors || !noRefresh,
+    checkOnly,
+    noRefresh,
+    refreshVectors
+  };
+}
+function resolveHealthDirectoryLists(typeRegistry) {
+  const optionalBuiltinDirs = new Set(PM_OPTIONAL_TYPE_SUBDIRS.filter((entry) => entry.length > 0));
+  const requiredDirSet = new Set(PM_CORE_REQUIRED_SUBDIRS.filter((entry) => entry.length > 0));
+  const optionalDirSet = /* @__PURE__ */ new Set();
+  for (const folder of typeRegistry.folders) {
+    if (optionalBuiltinDirs.has(folder)) {
+      optionalDirSet.add(folder);
+      continue;
+    }
+    requiredDirSet.add(folder);
+  }
+  return {
+    requiredDirs: [...requiredDirSet].sort((left, right) => left.localeCompare(right)),
+    optionalDirs: [...optionalDirSet].sort((left, right) => left.localeCompare(right)),
+    optionalDirSet
+  };
+}
+async function scanHealthDirectories(pmRoot, typeRegistry, strictDirectories) {
+  const { requiredDirs, optionalDirs, optionalDirSet } = resolveHealthDirectoryLists(typeRegistry);
+  const missingRequiredDirs = [];
+  const missingOptionalDirs = [];
+  const hookWarnings = [];
+  for (const relativeDir of [...requiredDirs, ...optionalDirs]) {
+    const directoryPath = path.join(pmRoot, relativeDir);
+    hookWarnings.push(...await runActiveOnReadHooks({ path: directoryPath, scope: "project" }));
+    if (await isDirectory(directoryPath)) {
+      continue;
+    }
+    if (optionalDirSet.has(relativeDir)) {
+      missingOptionalDirs.push(relativeDir);
+    } else {
+      missingRequiredDirs.push(relativeDir);
+    }
+  }
+  return {
+    requiredDirs,
+    optionalDirs,
+    missingRequiredDirs,
+    missingOptionalDirs,
+    missingDirs: strictDirectories ? [...missingRequiredDirs, ...missingOptionalDirs] : [...missingRequiredDirs],
+    hookWarnings
+  };
+}
+function resolveHealthSkipPolicy(options) {
+  const summaryMode = options.summary === true && options.full !== true;
+  const fastProjectionCheckOnly = options.checkOnly === true && (options.brief === true || options.summary === true) && options.full !== true;
+  return {
+    summaryMode,
+    skipIntegrity: (options.skipIntegrity === true || fastProjectionCheckOnly) && options.full !== true,
+    skipDrift: (options.skipDrift === true || fastProjectionCheckOnly) && options.full !== true,
+    skipVectors: (options.skipVectors === true || fastProjectionCheckOnly) && options.full !== true
+  };
+}
+async function readHealthItems(params) {
+  if (params.skipPolicy.skipDrift && params.skipPolicy.skipVectors) {
+    return listAllFrontMatter(params.pmRoot, params.settings.item_format, params.typeRegistry.type_to_folder, params.itemReadWarnings, params.settings.schema);
+  }
+  return listAllFrontMatterWithBody(params.pmRoot, params.settings.item_format, params.typeRegistry.type_to_folder, params.itemReadWarnings, params.settings.schema);
+}
+function buildSkippedHealthCheck(name) {
+  return { check: { name, status: "ok", details: { skipped: true } }, warnings: [] };
+}
+function buildSettingsHealthCheck(settingsPath, settings, normalizedSettingsReadWarnings) {
+  return {
+    name: "settings",
+    /* c8 ignore next -- settings read-warning status split is covered in broader read-settings integration tests */
+    status: normalizedSettingsReadWarnings.length === 0 ? "ok" : "warn",
+    details: {
+      path: settingsPath,
+      version: settings.version,
+      id_prefix: settings.id_prefix,
+      locks_ttl_seconds: settings.locks.ttl_seconds,
+      warnings: normalizedSettingsReadWarnings
+    }
+  };
+}
+function buildDirectoriesHealthCheck(directoryState, strictDirectories) {
+  return {
+    name: "directories",
+    status: directoryState.missingDirs.length === 0 ? "ok" : "warn",
+    details: {
+      required: directoryState.requiredDirs,
+      optional: directoryState.optionalDirs,
+      missing_required: directoryState.missingRequiredDirs,
+      missing_optional: directoryState.missingOptionalDirs,
+      missing: directoryState.missingDirs,
+      strict_directories: strictDirectories
+    }
+  };
+}
+function buildSettingsValuesHealthCheck(settingWarnings) {
+  return {
+    name: "settings_values",
+    status: settingWarnings.length === 0 ? "ok" : "warn",
+    details: { warnings: settingWarnings }
+  };
+}
+function buildStorageHealthCheck(items, settings, historySummary) {
+  return {
+    name: "storage",
+    status: historySummary.over_threshold.length === 0 ? "ok" : "warn",
+    details: {
+      items: items.length,
+      history_streams: historySummary.count,
+      ...historySummary.max_entries !== null ? {
+        compact_policy: {
+          enabled: settings.history.compact_policy.enabled,
+          max_entries: historySummary.max_entries,
+          trigger: settings.history.compact_policy.trigger,
+          over_threshold_count: historySummary.over_threshold.length,
+          over_threshold: historySummary.over_threshold
+        }
+      } : {}
+    }
+  };
+}
+function collectHealthWarnings(params) {
+  const warnings = [
+    ...params.directoryState.missingDirs.map((dir) => `missing_directory:${dir}`),
+    ...params.normalizedSettingsReadWarnings,
+    ...params.settingWarnings,
+    ...params.normalizedItemReadWarnings,
+    ...params.telemetryCheck.warnings,
+    ...params.extensionCheck.warnings,
+    ...params.historyPolicyWarnings,
+    ...params.historySummary.warnings,
+    ...params.locksCheck.warnings,
+    ...params.integrityCheck.warnings,
+    ...params.historyDriftCheck.warnings,
+    ...params.vectorizationCheck.warnings,
+    ...params.directoryState.hookWarnings
+  ];
+  return [...new Set(warnings)];
+}
+function extractHistoryDriftedCount(historyDriftCheck) {
+  const counts = historyDriftCheck.check.details.counts;
+  return typeof counts?.drifted === "number" ? counts.drifted : 0;
+}
+function buildHealthRemediationSources(params) {
+  return {
+    settings: params.normalizedSettingsReadWarnings,
+    directories: params.directoryState.missingDirs.map((dir) => `missing_directory:${dir}`),
+    settings_values: params.settingWarnings,
+    telemetry: params.telemetryCheck.warnings,
+    extensions: params.extensionCheck.warnings,
+    storage: params.historySummary.over_threshold.map((id) => `history_stream_over_compact_threshold:${id}`),
+    locks: params.locksCheck.warnings,
+    integrity: params.integrityCheck.warnings,
+    history_drift: params.historyDriftCheck.warnings,
+    vectorization: params.vectorizationCheck.warnings
+  };
+}
+function rewriteBulkHealthRemediation(params) {
+  if (params.check.name === "history_drift" && params.historyDriftedCount > 1) {
+    for (const code of Object.keys(params.remediationMap)) {
+      params.remediationMap[code] = "pm history-repair --all";
+    }
+  }
+  if (params.check.name === "storage" && params.overThresholdCount > 1) {
+    for (const code of Object.keys(params.remediationMap)) {
+      params.remediationMap[code] = "pm history-compact --all-streams";
+    }
+  }
+}
+function attachHealthRemediationMaps(params) {
+  for (const check of params.checks) {
+    const remediationMap = buildRemediationMap(params.remediationSources[check.name]);
+    rewriteBulkHealthRemediation({
+      check,
+      remediationMap,
+      historyDriftedCount: params.historyDriftedCount,
+      overThresholdCount: params.overThresholdCount
+    });
+    if (Object.keys(remediationMap).length > 0) {
+      check.details = { ...check.details, remediation_map: remediationMap };
+    }
+  }
+}
+function projectHealthResult(result, options, summaryMode) {
+  if (summaryMode) {
+    return applySummaryHealthProjection(result);
+  }
+  return options.brief === true ? applyBriefHealthProjection(result) : result;
+}
+async function runHealth(global, options = {}) {
+  const pmRoot = resolvePmRoot(process.cwd(), global.path);
+  const settingsPath = getSettingsPath(pmRoot);
+  if (!await pathExists(settingsPath)) {
+    throw new PmCliError(`Tracker is not initialized at ${pmRoot}. Run pm init first.`, EXIT_CODE.NOT_FOUND);
+  }
+  const { settings, warnings: settingsReadWarnings } = await readSettingsWithMetadata(pmRoot);
+  const normalizedSettingsReadWarnings = [...new Set(settingsReadWarnings)];
+  const typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
+  const strictDirectories = options.strictDirectories === true;
+  const refreshPolicy = resolveVectorRefreshPolicy(options);
+  const directoryState = await scanHealthDirectories(pmRoot, typeRegistry, strictDirectories);
+  const settingWarnings = validateSettingsValues(settings);
+  const telemetryCheck = await buildTelemetryCheck(settings, {
+    checkTelemetry: options.checkTelemetry === true
+  });
+  const extensionCheck = await buildExtensionCheck(pmRoot, settings, Boolean(global.noExtensions));
+  const skipPolicy = resolveHealthSkipPolicy(options);
+  const itemReadWarnings = [];
+  const items = await readHealthItems({ pmRoot, settings, typeRegistry, skipPolicy, itemReadWarnings });
+  const itemsWithBody = items;
+  const normalizedItemReadWarnings = [...new Set(itemReadWarnings)];
+  const historyPolicy = skipPolicy.skipDrift ? { warnings: [] } : await enforceHistoryStreamPolicyForItems({
+    pmRoot,
+    settings,
+    itemIds: items.map((item) => item.id),
+    commandLabel: "health"
+  });
+  const historySummary = await countHistoryStreams(pmRoot, settings.history.compact_policy);
+  const locksCheck = await buildLocksCheck(pmRoot);
+  const integrityCheck = skipPolicy.skipIntegrity ? buildSkippedHealthCheck("integrity") : await buildIntegrityCheck(pmRoot, typeRegistry.type_to_folder, settings.schema);
+  const historyDriftCheck = skipPolicy.skipDrift ? buildSkippedHealthCheck("history_drift") : await buildHistoryDriftCheck(pmRoot, itemsWithBody);
+  const vectorizationCheck = skipPolicy.skipVectors ? buildSkippedHealthCheck("vectorization") : await buildVectorizationCheck(pmRoot, settings, itemsWithBody, refreshPolicy, options.verboseStaleItems === true);
+  const checks = [
+    buildSettingsHealthCheck(settingsPath, settings, normalizedSettingsReadWarnings),
+    buildDirectoriesHealthCheck(directoryState, strictDirectories),
+    buildSettingsValuesHealthCheck(settingWarnings),
+    telemetryCheck.check,
+    extensionCheck.check,
+    buildStorageHealthCheck(items, settings, historySummary),
+    locksCheck.check,
+    integrityCheck.check,
+    historyDriftCheck.check,
+    vectorizationCheck.check
+  ];
+  const normalizedWarnings = collectHealthWarnings({
+    directoryState,
+    normalizedSettingsReadWarnings,
+    settingWarnings,
+    normalizedItemReadWarnings,
+    telemetryCheck,
+    extensionCheck,
+    historyPolicyWarnings: historyPolicy.warnings,
+    historySummary,
+    locksCheck,
+    integrityCheck,
+    historyDriftCheck,
+    vectorizationCheck
+  });
+  attachHealthRemediationMaps({
+    checks,
+    remediationSources: buildHealthRemediationSources({
+      directoryState,
+      normalizedSettingsReadWarnings,
+      settingWarnings,
+      telemetryCheck,
+      extensionCheck,
+      historySummary,
+      locksCheck,
+      integrityCheck,
+      historyDriftCheck,
+      vectorizationCheck
+    }),
+    historyDriftedCount: extractHistoryDriftedCount(historyDriftCheck),
+    overThresholdCount: historySummary.over_threshold.length
+  });
+  const blockingWarnings = normalizedWarnings.filter((warning) => !isAdvisoryHealthWarning(warning));
+  const result = {
+    ok: blockingWarnings.length === 0,
+    checks,
+    warnings: normalizedWarnings,
+    generated_at: nowIso()
+  };
+  return projectHealthResult(result, options, skipPolicy.summaryMode);
+}
+var _testOnlyHealthCommand = {
+  buildExtensionHealthTriageSummary,
+  buildCapabilityContractMetadata,
+  buildVectorizationProviderDetails,
+  collectUnknownCapabilityGuidance,
+  isAdvisoryHealthWarning,
+  isDirectory,
+  isExpectedUnmanagedExtension,
+  listItemDocumentPaths,
+  normalizeEndpointForDisplay,
+  normalizeExtensionNameForMatch,
+  parseTelemetryQueue,
+  probeTelemetryEndpointHealth,
+  selectStaleItemDetail,
+  summarizeHealthCheckDetails,
+  summarizeExtensionList,
+  summarizeRecordList,
+  summarizeStringList,
+  telemetryEnvFlagEnabled,
+  warningCode
+};
+
+export {
+  runHealth,
+  _testOnlyHealthCommand
+};
+//# sourceMappingURL=chunk-MAWDPCJW.js.map
+
+//# debugId=f3d2b3b5-0c76-5b07-af27-5951e49d4128