@unbrained/pm-cli 2026.6.30 → 2026.7.2

package/dist/cli-bundle/chunks/{health-Q66C43GN.js → health-L2U3AFKV.js}

@@ -1,5 +1,5 @@
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="fff5e3e1-ebbe-586a-b8e4-34f2882d28a3")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="444ac065-004e-58be-b6c4-7c7ce2f10d2a")}catch(e){}}();
 import {
   buildRemediationMap
 } from "./chunk-R2EMWY7Q.js";
@@ -8,25 +8,25 @@ import {
 } from "./chunk-37E72CNS.js";
 import {
   scanHistoryDrift
-} from "./chunk-IHXXUIXS.js";
+} from "./chunk-TTHCEV5Q.js";
 import {
   collectStaleVectorizationIds
 } from "./chunk-ROGZTCCB.js";
-import "./chunk-SJZTPVFT.js";
+import "./chunk-2ASNV4DH.js";
 import {
   PM_TELEMETRY_SOURCE_CONTEXT_VALUES,
   TELEMETRY_MAX_QUEUE_ENTRY_ATTEMPTS,
   TELEMETRY_SCHEMA_VERSION
-} from "./chunk-74PUWBGN.js";
+} from "./chunk-LTRAF2D7.js";
 import {
   buildCapabilityContractMetadata,
   buildRegistrationCollisionRemediation,
   collectUnknownCapabilityGuidance,
   readManagedExtensionState
-} from "./chunk-JZG5ADVE.js";
+} from "./chunk-3AZUFQK6.js";
 import "./chunk-P4SESZGT.js";
-import "./chunk-WTRUDJ3R.js";
-import "./chunk-YEDFE4DC.js";
+import "./chunk-YLZZ6T54.js";
+import "./chunk-ZNT7KEWE.js";
 import {
   buildVectorizationEmbeddingIdentity,
   hasVectorizationEmbeddingIdentityChanged,
@@ -36,24 +36,25 @@ import {
   resolveProviderConfigSource,
   resolveSettingsWithSemanticRuntimeDefaults,
   resolveVectorStores
-} from "./chunk-D5LYZVGB.js";
-import "./chunk-T7ZMQI4J.js";
-import "./chunk-C2KCIZKZ.js";
+} from "./chunk-TPOFWBMY.js";
+import "./chunk-KIYCOJ63.js";
+import "./chunk-OTUJZKGI.js";
+import "./chunk-5GVTFFTC.js";
 import {
   collectRegisteredItemFieldNames,
   enforceHistoryStreamPolicyForItems,
   listAllFrontMatter,
   listAllFrontMatterWithBody
-} from "./chunk-KGQ3W65B.js";
+} from "./chunk-NRZS637N.js";
 import {
   effectiveItemFormatVersion,
   findFirstMergeConflictMarker,
   parseItemDocument,
   scanItemFormatVersions
-} from "./chunk-V3KLX7U7.js";
+} from "./chunk-KN3URLKS.js";
 import {
   nowIso
-} from "./chunk-KRASIL6M.js";
+} from "./chunk-K2VYLVX4.js";
 import {
   EXIT_CODE,
   ITEM_FILE_EXTENSIONS,
@@ -74,7 +75,7 @@ import {
   resolvePmRoot,
   runActiveOnReadHooks,
   toNonEmptyStringOrUndefined
-} from "./chunk-CY5IJMUM.js";
+} from "./chunk-I66WE2HE.js";
 
 // dist/cli/commands/health.js
 import fs from "node:fs/promises";
@@ -182,6 +183,9 @@ async function listItemDocumentPaths(pmRoot, typeToFolder) {
   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 = [];
@@ -223,7 +227,7 @@ async function buildIntegrityCheck(pmRoot, typeToFolder, schema) {
   try {
     historyFiles = (await fs.readdir(historyDir)).filter((entry) => entry.endsWith(".jsonl")).sort((left, right) => left.localeCompare(right));
   } catch (error) {
-    if (!(typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT")) {
+    if (shouldReportHistoryDirectoryUnreadable(error)) {
       historyUnreadable.push("history");
     }
   }
@@ -885,6 +889,92 @@ function parseTelemetryQueue(raw) {
     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 {
@@ -930,74 +1020,19 @@ async function buildTelemetryCheck(settings, options) {
   const queueRaw = await readFileIfExists(queuePath);
   const queueExists = queueRaw !== null;
   const queueSizeBytes = queueRaw ? Buffer.byteLength(queueRaw, "utf8") : 0;
-  const queueSummary = queueRaw ? parseTelemetryQueue(queueRaw) : { validEntries: 0, invalidRows: 0, totalRows: 0, highRetryEntries: 0, maxAttempts: 0 };
+  const queueSummary = queueRaw ? parseTelemetryQueue(queueRaw) : emptyTelemetryQueueSummary();
   const stateRaw = await readFileIfExists(statePath);
-  let runtimeState = {};
-  let stateParseFailed = false;
-  if (stateRaw && stateRaw.trim().length > 0) {
-    try {
-      const parsed = JSON.parse(stateRaw);
-      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
-        runtimeState = parsed;
-      } else {
-        stateParseFailed = true;
-      }
-    } catch {
-      stateParseFailed = true;
-    }
-  }
+  const { runtimeState, stateParseFailed } = parseTelemetryRuntimeState(stateRaw);
   const endpoint = settings.telemetry.endpoint.trim();
   const endpointDisplay = normalizeEndpointForDisplay(endpoint);
-  let endpointProbe;
-  if (options.checkTelemetry && settings.telemetry.enabled && endpoint.length > 0) {
-    const probe = await probeTelemetryEndpointHealth(endpoint);
-    endpointProbe = {
-      attempted: true,
-      ...probe
-    };
-  }
+  const endpointProbe = await maybeProbeTelemetryEndpoint(settings, options.checkTelemetry);
   const warnings = [];
   if (stateParseFailed) {
     warnings.push("telemetry_state_invalid_json");
   }
-  if (queueSummary.invalidRows > 0) {
-    warnings.push(`telemetry_queue_invalid_rows:${queueSummary.invalidRows}`);
-  }
-  const queueHasEntries = settings.telemetry.enabled && queueSummary.validEntries > 0;
-  if (queueHasEntries) {
-    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;
-    const highRetries = queueSummary.highRetryEntries > 0;
-    if (activeFailure || neverFlushed || highWater) {
-      warnings.push(`telemetry_queue_pending:${queueSummary.validEntries}`);
-    }
-    if (highRetries) {
-      warnings.push(`telemetry_queue_high_retries:${queueSummary.highRetryEntries}`);
-    }
-  }
-  if (endpointProbe && !endpointProbe.ok) {
-    if (typeof endpointProbe.status === "number") {
-      warnings.push(`telemetry_endpoint_probe_http_status:${endpointProbe.status}`);
-    } else {
-      warnings.push("telemetry_endpoint_probe_failed");
-    }
-  }
-  const parsedMaxSchemaVersion = Number.parseInt(endpointProbe?.max_schema_version ?? "", 10);
-  if (endpointProbe && endpointProbe.ok && Number.isInteger(parsedMaxSchemaVersion) && parsedMaxSchemaVersion > TELEMETRY_SCHEMA_VERSION) {
-    warnings.push(`telemetry_schema_version_behind:${parsedMaxSchemaVersion}`);
-  }
+  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;
-  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);
-  if (otelExportFailing) {
-    warnings.push(`telemetry_otel_export_failing:${pendingOtelSpans}`);
-  }
   return {
     check: {
       name: "telemetry",
@@ -1010,7 +1045,7 @@ async function buildTelemetryCheck(settings, options) {
         queue_path: queuePath,
         queue_exists: queueExists,
         queue_entries: queueSummary.validEntries,
-        queue_draining: queueHasEntries && warnings.every((warning) => !warning.startsWith("telemetry_queue_pending:") && !warning.startsWith("telemetry_queue_high_retries:")),
+        queue_draining: isTelemetryQueueDraining(queueHasEntries, warnings),
         queue_invalid_rows: queueSummary.invalidRows,
         queue_rows_total: queueSummary.totalRows,
         queue_size_bytes: queueSizeBytes,
@@ -1027,18 +1062,8 @@ async function buildTelemetryCheck(settings, options) {
         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
-        },
-        /* c8 ignore start -- env-override combinations are validated through runtime integration suites */
-        env_overrides: {
-          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()
-        }
-        /* c8 ignore stop */
+        endpoint_probe: endpointProbe ?? { attempted: false },
+        env_overrides: buildTelemetryEnvOverrideDetails()
       }
     },
     warnings
@@ -1121,71 +1146,128 @@ async function buildHistoryDriftCheck(pmRoot, items) {
     warnings
   };
 }
-async function buildVectorizationCheck(pmRoot, settings, items, refreshPolicy, verboseStaleItems) {
+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;
-  const semanticRuntimeAvailable = Boolean(providerResolution.active && vectorStoreResolution.active);
-  const ledgerBefore = await readVectorizationStatusLedger(pmRoot);
-  const staleBefore = semanticRuntimeAvailable ? collectStaleVectorizationIds(items, ledgerBefore.entries) : [];
-  let refreshResult = {
+  return {
+    runtimeDefaults,
+    providerResolution,
+    vectorStoreResolution,
+    runtimeEmbeddingIdentity,
+    semanticRuntimeAvailable: Boolean(providerResolution.active && vectorStoreResolution.active)
+  };
+}
+function emptyVectorizationRefreshResult() {
+  return {
     refreshed: [],
     skipped: [],
     warnings: []
   };
-  if (refreshPolicy.enabled && semanticRuntimeAvailable && staleBefore.length > 0) {
-    refreshResult = await refreshSemanticEmbeddingsForMutatedItems(pmRoot, staleBefore, {
-      settings: runtimeDefaults.settings,
-      apply_runtime_defaults: false
-    });
+}
+async function refreshStaleVectorizationItems(params) {
+  if (!params.refreshPolicy.enabled || !params.snapshot.semanticRuntimeAvailable || params.staleBefore.length === 0) {
+    return emptyVectorizationRefreshResult();
   }
-  const ledgerAfter = await readVectorizationStatusLedger(pmRoot);
-  const staleAfter = semanticRuntimeAvailable ? collectStaleVectorizationIds(items, ledgerAfter.entries) : [];
-  const strictVectorizationWarnings = !runtimeDefaults.auto_ollama_defaults_applied;
-  const embeddingIdentityChanged = strictVectorizationWarnings && semanticRuntimeAvailable && Boolean(ledgerBefore.embedding && runtimeEmbeddingIdentity && hasVectorizationEmbeddingIdentityChanged(ledgerBefore.embedding, runtimeEmbeddingIdentity));
-  const warningSet = /* @__PURE__ */ new Set([...ledgerBefore.warnings, ...ledgerAfter.warnings]);
-  if (strictVectorizationWarnings) {
-    for (const warning of refreshResult.warnings) {
+  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 (embeddingIdentityChanged) {
+  if (params.embeddingIdentityChanged) {
     warningSet.add("vectorization_embedding_identity_changed");
   }
-  if (strictVectorizationWarnings && semanticRuntimeAvailable && staleAfter.length > 0) {
-    warningSet.add(`vectorization_stale_items_remaining:${staleAfter.length}`);
+  if (params.strictVectorizationWarnings && params.semanticRuntimeAvailable && params.staleAfter.length > 0) {
+    warningSet.add(`vectorization_stale_items_remaining:${params.staleAfter.length}`);
   }
-  const warnings = [...warningSet].sort((left, right) => left.localeCompare(right));
+  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: semanticRuntimeAvailable,
-        compatibility_mode_auto_defaults: runtimeDefaults.auto_ollama_defaults_applied,
-        auto_ollama_defaults_applied: runtimeDefaults.auto_ollama_defaults_applied,
-        refresh_policy: {
-          enabled: refreshPolicy.enabled,
-          check_only: refreshPolicy.checkOnly,
-          no_refresh: refreshPolicy.noRefresh,
-          refresh_vectors: refreshPolicy.refreshVectors
-        },
-        provider_active: providerResolution.active?.name ?? null,
-        // 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(providerResolution.active?.name ?? null, settings.search?.provider ?? null),
-        vector_store_active: vectorStoreResolution.active?.name ?? null,
-        vector_store_configured: typeof settings.vector_store?.adapter === "string" ? settings.vector_store.adapter : null,
-        vector_store_source: resolveProviderConfigSource(vectorStoreResolution.active?.name ?? null, settings.vector_store?.adapter ?? null),
+        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: runtimeEmbeddingIdentity ?? 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",
@@ -1193,8 +1275,8 @@ async function buildVectorizationCheck(pmRoot, settings, items, refreshPolicy, v
         stale_items_before_total: staleBeforeDetail.total,
         stale_items_before: staleBeforeDetail.values,
         stale_items_before_truncated: staleBeforeDetail.truncated,
-        refresh_attempted: refreshPolicy.enabled && staleBefore.length > 0 && semanticRuntimeAvailable,
-        refresh_skipped_reason: refreshPolicy.enabled && semanticRuntimeAvailable && staleBefore.length > 0 ? null : !refreshPolicy.enabled ? "refresh_disabled" : !semanticRuntimeAvailable ? "semantic_runtime_unavailable" : "no_stale_items",
+        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,
@@ -1232,17 +1314,7 @@ function resolveVectorRefreshPolicy(options) {
     refreshVectors
   };
 }
-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);
+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();
@@ -1253,41 +1325,202 @@ async function runHealth(global, options = {}) {
     }
     requiredDirSet.add(folder);
   }
-  const requiredDirs = [...requiredDirSet].sort((left, right) => left.localeCompare(right));
-  const optionalDirs = [...optionalDirSet].sort((left, right) => left.localeCompare(right));
+  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)) {
-      if (optionalDirSet.has(relativeDir)) {
-        missingOptionalDirs.push(relativeDir);
-      } else {
-        missingRequiredDirs.push(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);
     }
   }
-  const missingDirs = strictDirectories ? [...missingRequiredDirs, ...missingOptionalDirs] : [...missingRequiredDirs];
+  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 summaryMode = options.summary === true && options.full !== true;
-  const fastProjectionCheckOnly = options.checkOnly === true && (options.brief === true || options.summary === true) && options.full !== true;
-  const skipIntegrity = (options.skipIntegrity === true || fastProjectionCheckOnly) && options.full !== true;
-  const skipDrift = (options.skipDrift === true || fastProjectionCheckOnly) && options.full !== true;
-  const skipVectors = (options.skipVectors === true || fastProjectionCheckOnly) && options.full !== true;
+  const skipPolicy = resolveHealthSkipPolicy(options);
   const itemReadWarnings = [];
-  const items = skipDrift && skipVectors ? await listAllFrontMatter(pmRoot, settings.item_format, typeRegistry.type_to_folder, itemReadWarnings, settings.schema) : await listAllFrontMatterWithBody(pmRoot, settings.item_format, typeRegistry.type_to_folder, itemReadWarnings, settings.schema);
+  const items = await readHealthItems({ pmRoot, settings, typeRegistry, skipPolicy, itemReadWarnings });
   const itemsWithBody = items;
   const normalizedItemReadWarnings = [...new Set(itemReadWarnings)];
-  const historyPolicy = skipDrift ? { warnings: [] } : await enforceHistoryStreamPolicyForItems({
+  const historyPolicy = skipPolicy.skipDrift ? { warnings: [] } : await enforceHistoryStreamPolicyForItems({
     pmRoot,
     settings,
     itemIds: items.map((item) => item.id),
@@ -1295,110 +1528,52 @@ async function runHealth(global, options = {}) {
   });
   const historySummary = await countHistoryStreams(pmRoot, settings.history.compact_policy);
   const locksCheck = await buildLocksCheck(pmRoot);
-  const integrityCheck = skipIntegrity ? { check: { name: "integrity", status: "ok", details: { skipped: true } }, warnings: [] } : await buildIntegrityCheck(pmRoot, typeRegistry.type_to_folder, settings.schema);
-  const historyDriftCheck = skipDrift ? { check: { name: "history_drift", status: "ok", details: { skipped: true } }, warnings: [] } : await buildHistoryDriftCheck(pmRoot, itemsWithBody);
-  const vectorizationCheck = skipVectors ? { check: { name: "vectorization", status: "ok", details: { skipped: true } }, warnings: [] } : await buildVectorizationCheck(pmRoot, settings, itemsWithBody, refreshPolicy, options.verboseStaleItems === true);
+  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 = [
-    {
-      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
-      }
-    },
-    {
-      name: "directories",
-      status: missingDirs.length === 0 ? "ok" : "warn",
-      details: {
-        required: requiredDirs,
-        optional: optionalDirs,
-        missing_required: missingRequiredDirs,
-        missing_optional: missingOptionalDirs,
-        missing: missingDirs,
-        strict_directories: strictDirectories
-      }
-    },
-    {
-      name: "settings_values",
-      status: settingWarnings.length === 0 ? "ok" : "warn",
-      details: {
-        warnings: settingWarnings
-      }
-    },
+    buildSettingsHealthCheck(settingsPath, settings, normalizedSettingsReadWarnings),
+    buildDirectoriesHealthCheck(directoryState, strictDirectories),
+    buildSettingsValuesHealthCheck(settingWarnings),
     telemetryCheck.check,
     extensionCheck.check,
-    {
-      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
-          }
-        } : {}
-      }
-    },
+    buildStorageHealthCheck(items, settings, historySummary),
     locksCheck.check,
     integrityCheck.check,
     historyDriftCheck.check,
     vectorizationCheck.check
   ];
-  const warnings = [
-    ...missingDirs.map((dir) => `missing_directory:${dir}`),
-    ...normalizedSettingsReadWarnings,
-    ...settingWarnings,
-    ...normalizedItemReadWarnings,
-    ...telemetryCheck.warnings,
-    ...extensionCheck.warnings,
-    ...historyPolicy.warnings,
-    ...historySummary.warnings,
-    ...locksCheck.warnings,
-    ...integrityCheck.warnings,
-    ...historyDriftCheck.warnings,
-    ...vectorizationCheck.warnings,
-    ...hookWarnings
-  ];
-  const normalizedWarnings = [...new Set(warnings)];
-  const checkRemediationSources = {
-    settings: normalizedSettingsReadWarnings,
-    directories: missingDirs.map((dir) => `missing_directory:${dir}`),
-    settings_values: settingWarnings,
-    telemetry: telemetryCheck.warnings,
-    extensions: extensionCheck.warnings,
-    storage: historySummary.over_threshold.map((id) => `history_stream_over_compact_threshold:${id}`),
-    locks: locksCheck.warnings,
-    integrity: integrityCheck.warnings,
-    history_drift: historyDriftCheck.warnings,
-    vectorization: vectorizationCheck.warnings
-  };
-  const historyDriftedCount = typeof historyDriftCheck.check.details.counts?.drifted === "number" ? historyDriftCheck.check.details.counts.drifted : 0;
-  for (const check of checks) {
-    const remediationMap = buildRemediationMap(checkRemediationSources[check.name]);
-    if (check.name === "history_drift" && historyDriftedCount > 1) {
-      for (const code of Object.keys(remediationMap)) {
-        remediationMap[code] = "pm history-repair --all";
-      }
-    }
-    if (check.name === "storage" && historySummary.over_threshold.length > 1) {
-      for (const code of Object.keys(remediationMap)) {
-        remediationMap[code] = "pm history-compact --all-streams";
-      }
-    }
-    if (Object.keys(remediationMap).length > 0) {
-      check.details = { ...check.details, remediation_map: remediationMap };
-    }
-  }
+  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,
@@ -1406,14 +1581,12 @@ async function runHealth(global, options = {}) {
     warnings: normalizedWarnings,
     generated_at: nowIso()
   };
-  if (summaryMode) {
-    return applySummaryHealthProjection(result);
-  }
-  return options.brief === true ? applyBriefHealthProjection(result) : result;
+  return projectHealthResult(result, options, skipPolicy.summaryMode);
 }
 var _testOnlyHealthCommand = {
   buildExtensionHealthTriageSummary,
   buildCapabilityContractMetadata,
+  buildVectorizationProviderDetails,
   collectUnknownCapabilityGuidance,
   isAdvisoryHealthWarning,
   isDirectory,
@@ -1435,6 +1608,6 @@ export {
   _testOnlyHealthCommand,
   runHealth
 };
-//# sourceMappingURL=health-Q66C43GN.js.map
+//# sourceMappingURL=health-L2U3AFKV.js.map
 
-//# debugId=fff5e3e1-ebbe-586a-b8e4-34f2882d28a3
+//# debugId=444ac065-004e-58be-b6c4-7c7ce2f10d2a