@mrclrchtr/supi-code-intelligence 6.1.0 → 6.3.0

package/node_modules/@mrclrchtr/supi-lsp/src/provider/lsp-semantic-provider.ts

@@ -96,7 +96,10 @@ export function createLspSemanticProvider(lsp: WorkspaceLspRuntime): SemanticPro
     ): Promise<CodeQueryResult<CodeSymbol[]>> {
       const result = await lsp.workspaceSymbol(query, control, scopes);
       return mapCodeQueryResult(result, (results) =>
-        results.map((symbol) => toCodeSymbol(symbol as SymbolInformation)),
+        results.flatMap((symbol) => {
+          const mapped = toCodeSymbol(symbol as SymbolInformation);
+          return mapped ? [mapped] : [];
+        }),
       );
     },
 

package/node_modules/@mrclrchtr/supi-lsp/src/provider/semantic-symbol-mapper.ts

@@ -30,20 +30,34 @@ function toCodeLocation(item: Location | LocationLink): CodeLocation | null {
   const loc = item as Record<string, unknown>;
   const uri = loc.uri ?? loc.targetUri;
   if (typeof uri !== "string") return null;
-  const range = loc.targetSelectionRange ?? loc.targetRange ?? loc.range;
-  if (!range || typeof range !== "object") return null;
-  const r = range as { start: Record<string, unknown>; end: Record<string, unknown> };
-  if (!r.start || !r.end) return null;
-  return {
-    uri,
-    range: {
-      start: {
-        line: (r.start.line as number) ?? 0,
-        character: (r.start.character as number) ?? 0,
-      },
-      end: { line: (r.end.line as number) ?? 0, character: (r.end.character as number) ?? 0 },
-    },
-  };
+  const range = toValidRange(loc.targetSelectionRange ?? loc.targetRange ?? loc.range);
+  return range ? { uri, range } : null;
+}
+
+function toValidRange(value: unknown): SourceRange | null {
+  if (!value || typeof value !== "object") return null;
+  const range = value as { start?: unknown; end?: unknown };
+  const start = toValidPosition(range.start);
+  const end = toValidPosition(range.end);
+  return start && end && !isPositionBefore(end, start) ? { start, end } : null;
+}
+
+function toValidPosition(value: unknown): { line: number; character: number } | null {
+  if (!value || typeof value !== "object") return null;
+  const position = value as Record<string, unknown>;
+  return Number.isInteger(position.line) &&
+    (position.line as number) >= 0 &&
+    Number.isInteger(position.character) &&
+    (position.character as number) >= 0
+    ? { line: position.line as number, character: position.character as number }
+    : null;
+}
+
+function isPositionBefore(
+  left: { line: number; character: number },
+  right: { line: number; character: number },
+): boolean {
+  return left.line < right.line || (left.line === right.line && left.character < right.character);
 }
 
 const SYMBOL_KIND_NAMES: Record<number, string> = {
@@ -102,8 +116,19 @@ function flattenDocumentSymbols(
     let document: DocumentSymbol | null = null;
     if (isSymbolInformation(sym)) information = sym;
     else document = sym;
-    const declStart = document?.range.start ?? information?.location.range.start;
-    if (!declStart) continue;
+    const declarationRange = toValidRange(document?.range ?? information?.location.range);
+    if (!declarationRange) {
+      if (document?.children?.length) {
+        result.push(
+          ...flattenDocumentSymbols(document.children, filePath, sym.name, {
+            sourceLines: context.sourceLines,
+            nesting: "nested",
+          }),
+        );
+      }
+      continue;
+    }
+    const declStart = declarationRange.start;
     const nameStart = document
       ? resolveDocumentSymbolNameStart(document, context.sourceLines)
       : null;
@@ -149,8 +174,9 @@ function resolveDocumentSymbolNameStart(
   symbol: DocumentSymbol,
   sourceLines: readonly string[] | null,
 ): { line: number; character: number } | null {
-  const selectionStart = symbol.selectionRange?.start;
-  if (!selectionStart) return null;
+  const selectionRange = toValidRange(symbol.selectionRange);
+  if (!selectionRange) return null;
+  const selectionStart = selectionRange.start;
   if (!sourceLines) return selectionStart;
   const sourceLine = sourceLines[selectionStart.line];
   if (sourceLine === undefined) return null;
@@ -160,25 +186,30 @@ function resolveDocumentSymbolNameStart(
   ) {
     return selectionStart;
   }
-  const rangeStart = symbol.range?.start;
-  const rangeEnd = symbol.range?.end;
-  const from = rangeStart?.line === selectionStart.line ? rangeStart.character : 0;
-  const until = rangeEnd?.line === selectionStart.line ? rangeEnd.character : sourceLine.length;
+  const declarationRange = toValidRange(symbol.range);
+  if (!declarationRange) return null;
+  const from =
+    declarationRange.start.line === selectionStart.line ? declarationRange.start.character : 0;
+  const until =
+    declarationRange.end.line === selectionStart.line
+      ? declarationRange.end.character
+      : sourceLine.length;
   const character = sourceLine.indexOf(symbol.name, from);
   if (character < 0 || character + symbol.name.length > until) return null;
   return { line: selectionStart.line, character };
 }
 
-/** Map one workspace symbol to the shared representation. */
-export function toCodeSymbol(sym: SymbolInformation): CodeSymbol {
-  const start = sym.location?.range?.start;
+/** Map one valid workspace symbol to the shared representation. */
+export function toCodeSymbol(sym: SymbolInformation): CodeSymbol | null {
+  const location = toCodeLocation(sym.location);
+  if (!location) return null;
   return {
     name: sym.name,
     kind: symbolKindName(sym.kind),
-    file: uriToFile(sym.location?.uri ?? ""),
+    file: uriToFile(location.uri),
     declarationAnchor: {
-      line: start ? start.line + 1 : 0,
-      character: start ? start.character + 1 : 0,
+      line: location.range.start.line + 1,
+      character: location.range.start.character + 1,
     },
     container: sym.containerName ?? null,
   };

package/node_modules/@mrclrchtr/supi-lsp/src/session/runtime-controller.ts

@@ -9,14 +9,19 @@
 
 // biome-ignore lint/style/noExcessiveLinesPerFile: session lifecycle, capability projection, and telemetry stay in one controller.
 import type { WorkspaceRuntime } from "@mrclrchtr/supi-code-runtime/api";
-import { recordDebugEvent } from "@mrclrchtr/supi-core/debug";
+import {
+  recordDebugEvent,
+  truncateDebugIdentity as truncateIdentity,
+} from "@mrclrchtr/supi-core/debug";
 import { loadConfig } from "../config/config.ts";
 import { type LspSettings, loadLspSettings } from "../config/lsp-settings.ts";
 import { clearTsconfigCache } from "../config/tsconfig-scope.ts";
 import type { DetectedProjectServer, LspConfig, ProjectServerInfo } from "../config/types.ts";
-import { truncateIdentity } from "../debug-telemetry.ts";
-import { scanWorkspaceSentinels } from "../diagnostics/workspace-sentinels.ts";
 import { LspManager, type ManagerLifecycleTransition } from "../manager/manager.ts";
+import {
+  type AutomaticLspPathPolicy,
+  createAutomaticLspPathPolicy,
+} from "../workspace-path-policy.ts";
 import {
   markLspCapabilitiesReady,
   registerPendingLspCapabilities,
@@ -58,6 +63,7 @@ interface LspControllerReady {
   projectServers: ProjectServerInfo[];
   detectedServers: DetectedProjectServer[];
   settings: LspSettings;
+  automaticPathPolicy: AutomaticLspPathPolicy;
 }
 
 interface LspControllerDisabled {
@@ -207,7 +213,6 @@ export class LspRuntimeController {
    *
    * Always attempts detected servers unless they were explicitly disabled
    * per language via `lsp.servers.<language>.enabled: false`.
-   * The global `lsp.enabled` and `lsp.active` keys are deprecated and ignored.
    *
    * Returns the start result and updates the controller's state.
    */
@@ -220,11 +225,6 @@ export class LspRuntimeController {
     if (generation !== this.#readinessGeneration) return supersededStartResult();
 
     const lspSettings = loadLspSettings(this.#cwd);
-    // Note: lspSettings.enabled is ignored — the global switch is deprecated.
-    // Per-language `lsp.servers.<language>.enabled: false` is the supported
-    // way to opt out and is already handled by loadConfig.
-    // lspSettings.active is also ignored — the allowlist is deprecated.
-
     const config = loadConfig(this.#cwd);
 
     try {
@@ -287,27 +287,35 @@ export class LspRuntimeController {
     if (Object.keys(config.servers).length === 0) return this.setDisabled(generation);
     this.#state = { kind: "pending" };
 
+    const automaticPathPolicy = createAutomaticLspPathPolicy(this.#cwd, settings.exclude);
     let manager: LspManager;
-    manager = new LspManager(config, this.#cwd, (transition) => {
-      this.handleManagerLifecycle(manager, generation, transition);
-    });
+    manager = new LspManager(
+      config,
+      this.#cwd,
+      (transition) => {
+        this.handleManagerLifecycle(manager, generation, transition);
+      },
+      automaticPathPolicy,
+    );
     this.#activeManager = manager;
     this.#latestManagerTransition = null;
     this.publishLifecycle("startup", false, []);
-    manager.setExcludePatterns(settings.exclude);
     setWorkspaceLspRuntimeState(this.#cwd, { kind: "pending" });
 
-    const detectedServers = scanProjectCapabilities(config, this.#cwd);
+    const detectedServers = scanProjectCapabilities(
+      config,
+      this.#cwd,
+      undefined,
+      automaticPathPolicy,
+    );
     manager.registerDetectedServers(detectedServers);
-    await startDetectedServers(manager, detectedServers);
+    await startDetectedServers(manager, detectedServers, automaticPathPolicy);
     if (generation !== this.#readinessGeneration) {
       if (this.#activeManager === manager) this.#activeManager = null;
       await manager.shutdownAll();
       return supersededStartResult();
     }
 
-    scanWorkspaceSentinels(this.#cwd);
-
     const runtimeOwner = createWorkspaceLspRuntimeOwner(manager);
     const workspaceRuntime = runtimeOwner.runtime;
     setWorkspaceLspRuntimeState(this.#cwd, { kind: "ready", runtime: workspaceRuntime });
@@ -333,6 +341,7 @@ export class LspRuntimeController {
       projectServers,
       detectedServers,
       settings,
+      automaticPathPolicy,
     };
 
     this.projectSemanticReadiness(workspaceRuntime, semanticReady);
@@ -397,7 +406,6 @@ export class LspRuntimeController {
       projectServers: projectServers.map((server) => ({
         ...server,
         fileTypes: [...server.fileTypes],
-        supportedActions: [...server.supportedActions],
         openFiles: [...server.openFiles],
       })),
     };
@@ -452,6 +460,6 @@ export class LspRuntimeController {
   getMissingServers(): Array<{ name: string; command: string }> {
     if (this.#state.kind !== "ready") return [];
     const config = loadConfig(this.#cwd);
-    return scanMissingServers(config, this.#cwd);
+    return scanMissingServers(config, this.#cwd, undefined, this.#state.automaticPathPolicy);
   }
 }

package/node_modules/@mrclrchtr/supi-lsp/src/session/runtime-diagnostics.ts

@@ -45,11 +45,65 @@ export interface OutstandingDiagnosticSummaryEntry {
   hints: number;
 }
 
+/** Stable outcome for one route in an explicit process-crash report. */
+export type ProcessCrashRecoveryOutcome =
+  | "recovered"
+  | "skipped-no-retained-file"
+  | "recovery-failed"
+  | "recovery-exhausted";
+
+/** Typed next action for a non-recovered process-crash route. */
+export type ProcessCrashRecoveryNextAction = "use-exact-file" | "reload-workspace";
+
+/** One bounded route entry in a process-crash recovery report. */
+export interface ProcessCrashRecoveryEntry {
+  /** Configured server name. */
+  readonly name: string;
+  /** Workspace-relative route root. */
+  readonly root: string;
+  readonly outcome: ProcessCrashRecoveryOutcome;
+  /** Available action when the route was not recovered. */
+  readonly nextAction?: ProcessCrashRecoveryNextAction;
+  /** Bounded caught Error.message for a failed recovery, when available. */
+  readonly failureMessage?: string;
+}
+
+/** Maximum number of route entries retained in a process-crash report. */
+export const MAX_PROCESS_CRASH_RECOVERY_ENTRIES = 16;
+
+/** Bounded, route-specific result of one explicit process-crash demand. */
+export interface ProcessCrashRecoveryReport {
+  /** Exact counts include entries omitted from the visible route list. */
+  readonly recoveredRoutes: number;
+  readonly skippedRoutes: number;
+  readonly failedRoutes: number;
+  readonly exhaustedRoutes: number;
+  /** At most 16 entries, ordered by action priority, root, and server name. */
+  readonly entries: readonly ProcessCrashRecoveryEntry[];
+  /** Exact number of route entries not included in {@link entries}. */
+  readonly omittedEntries: number;
+}
+
+/** Create the empty outcome for a pass with no process-crash demand. */
+export function emptyProcessCrashRecoveryReport(): ProcessCrashRecoveryReport {
+  return {
+    recoveredRoutes: 0,
+    skippedRoutes: 0,
+    failedRoutes: 0,
+    exhaustedRoutes: 0,
+    entries: [],
+    omittedEntries: 0,
+  };
+}
+
 /** Result from a workspace diagnostic recovery pass. */
 export interface RecoverDiagnosticsResult {
   /** Active clients targeted by the best-effort refresh, not confirmed successful refreshes. */
   attemptedClients: number;
+  /** Clients restarted by stale-diagnostic recovery, not process-crash recovery. */
   restartedClients: number;
+  /** Separate outcome for process-crash route recovery selected by this pass. */
+  processCrashRecovery: ProcessCrashRecoveryReport;
   /** Evidence collected by the refresh and recovery operations. */
   diagnosticEvidence: DiagnosticEvidenceSummary;
   /** Final diagnostic report captured after all refresh and recovery work. */

package/node_modules/@mrclrchtr/supi-lsp/src/session/runtime-registration.ts

@@ -26,23 +26,6 @@ export function registerPendingLspCapabilities(
   runtime.registerSemanticPending(cwd, provider);
 }
 
-/**
- * Register LSP capabilities for a workspace cwd as ready.
- *
- * Wraps WorkspaceLspRuntime into a SemanticProvider via the existing semantic
- * adapter and publishes it into the shared workspace runtime so that
- * code-intelligence and other consumers can discover semantic analysis
- * availability.
- */
-export function registerLspCapabilities(
-  runtime: WorkspaceRuntime,
-  cwd: string,
-  service: WorkspaceLspRuntime,
-): void {
-  const provider = createLspSemanticProvider(service);
-  runtime.registerSemantic(cwd, provider);
-}
-
 /** Promote an already-registered pending semantic provider to ready. */
 export function markLspCapabilitiesReady(runtime: WorkspaceRuntime, cwd: string): void {
   runtime.markSemanticReady(cwd);

package/node_modules/@mrclrchtr/supi-lsp/src/session/runtime-registry.ts

@@ -9,7 +9,11 @@ import {
   throwIfCodeRequestInterrupted,
   unavailableCodeQuery,
 } from "@mrclrchtr/supi-code-runtime/api";
-import { recordDebugEvent } from "@mrclrchtr/supi-core/debug";
+import {
+  recordDebugEvent,
+  truncateDebugIdentity as truncateIdentity,
+} from "@mrclrchtr/supi-core/debug";
+import { resolveToolPath as resolveSessionPath } from "@mrclrchtr/supi-core/path";
 import { createSessionStateRegistry } from "@mrclrchtr/supi-core/session";
 import type {
   CodeAction,
@@ -26,11 +30,18 @@ import type {
   WorkspaceEdit,
   WorkspaceSymbol,
 } from "../config/types.ts";
-import { boundServerNames, truncateIdentity } from "../debug-telemetry.ts";
+import { boundServerNames } from "../debug-telemetry.ts";
+import type {
+  WorkspaceSentinelScanOptions,
+  WorkspaceSentinelSyncResult,
+} from "../diagnostics/workspace-sentinels.ts";
 import type { LspManager } from "../manager/manager.ts";
-import { resolveSessionPath } from "../utils.ts";
 import { raceReadinessValue } from "./readiness.ts";
-import type { DiagnosticEvidenceSummary, RecoverDiagnosticsResult } from "./runtime-diagnostics.ts";
+import type {
+  DiagnosticEvidenceSummary,
+  ProcessCrashRecoveryReport,
+  RecoverDiagnosticsResult,
+} from "./runtime-diagnostics.ts";
 import type {
   RoutedMutationResponse,
   SemanticReadinessResult,
@@ -42,15 +53,21 @@ export type {
   ProcessCrashDiagnosticDemand,
   WorkspaceLspDiagnosticSurface,
 } from "./runtime-diagnostic-surface.ts";
-export type {
-  DiagnosticEvidenceDocument,
-  DiagnosticEvidenceStatus,
-  DiagnosticEvidenceSummary,
-  OutstandingDiagnosticSummaryEntry,
-  RecoverDiagnosticsResult,
-  WorkspaceDiagnosticReport,
-  WorkspaceDiagnosticSnapshot,
-  WorkspaceDiagnosticSummaryEntry,
+export {
+  type DiagnosticEvidenceDocument,
+  type DiagnosticEvidenceStatus,
+  type DiagnosticEvidenceSummary,
+  emptyProcessCrashRecoveryReport,
+  MAX_PROCESS_CRASH_RECOVERY_ENTRIES,
+  type OutstandingDiagnosticSummaryEntry,
+  type ProcessCrashRecoveryEntry,
+  type ProcessCrashRecoveryNextAction,
+  type ProcessCrashRecoveryOutcome,
+  type ProcessCrashRecoveryReport,
+  type RecoverDiagnosticsResult,
+  type WorkspaceDiagnosticReport,
+  type WorkspaceDiagnosticSnapshot,
+  type WorkspaceDiagnosticSummaryEntry,
 } from "./runtime-diagnostics.ts";
 export type {
   RoutedMutationResponse,
@@ -67,6 +84,15 @@ function unavailableFileQuery<T>(operation: string, file: string): CodeQueryResu
   return unavailableCodeQuery(`No routed LSP client could complete ${operation} for ${file}.`);
 }
 
+function hasProcessCrashRecovery(report: ProcessCrashRecoveryReport): boolean {
+  return (
+    report.recoveredRoutes > 0 ||
+    report.skippedRoutes > 0 ||
+    report.failedRoutes > 0 ||
+    report.exhaustedRoutes > 0
+  );
+}
+
 /** Emit one aggregate tsconfig scope-decision event after a recovery pass. */
 function recordScopeDecisionEvent(manager: LspManager): void {
   try {
@@ -246,25 +272,40 @@ class DefaultWorkspaceLspRuntime implements WorkspaceLspRuntime {
   ): Promise<SemanticReadinessResult> {
     const resolvedPath = this.resolveFilePath(filePath);
     if (!this.manager.canServeFile(resolvedPath)) {
+      const processCrashRecovery = this.manager.getProcessCrashRecoveryReportForFile(resolvedPath);
       return {
         kind: "unavailable",
         reason: "No LSP client can serve this file",
+        ...(processCrashRecovery ? { processCrashRecovery } : {}),
       };
     }
 
+    let eagerProcessCrashRecovery: ProcessCrashRecoveryReport | undefined;
     const readiness = await raceReadinessValue(
-      this.manager.waitUntilFileReady(resolvedPath, control),
+      this.manager.waitUntilFileReady(resolvedPath, control, (report) => {
+        eagerProcessCrashRecovery = report;
+      }),
       options.timeoutMs,
       control,
     );
-    if (readiness.kind !== "resolved") return readiness;
-    if (readiness.value === null) {
+    if (readiness.kind !== "resolved") {
+      // A timeout can happen before shared recovery settles. Do not create a
+      // route outcome for work that has no final result yet.
+      const currentProcessCrashRecovery =
+        this.manager.getProcessCrashRecoveryReportForFile(resolvedPath);
+      const processCrashRecovery = currentProcessCrashRecovery ?? eagerProcessCrashRecovery;
+      return processCrashRecovery ? { ...readiness, processCrashRecovery } : readiness;
+    }
+    const { client, processCrashRecovery } = readiness.value;
+    const recovery = hasProcessCrashRecovery(processCrashRecovery) ? { processCrashRecovery } : {};
+    if (!client) {
       return {
         kind: "unavailable",
         reason: "The routed LSP client could not be started for this file",
+        ...recovery,
       };
     }
-    return { kind: "ready" };
+    return { kind: "ready", ...recovery };
   }
 
   /**
@@ -294,9 +335,22 @@ class DefaultWorkspaceLspRuntime implements WorkspaceLspRuntime {
     return this.manager.getKnownProjectServers([]);
   }
 
-  /** Check whether the file can be served semantically for explicit LSP operations. */
+  /** Check whether automatic LSP work can use and serve the source file. */
   isSupportedSourceFile(filePath: string): boolean {
-    return this.manager.canServeFile(this.resolveFilePath(filePath));
+    return this.manager.isSupportedSourceFile(this.resolveFilePath(filePath));
+  }
+
+  /** Inventory automatic workspace sentinel and source paths. */
+  scanWorkspaceSentinels(options: WorkspaceSentinelScanOptions = {}): Map<string, number> {
+    return this.manager.scanWorkspaceSentinels(options);
+  }
+
+  /** Refresh the automatic workspace sentinel and source inventory. */
+  syncWorkspaceSentinelSnapshot(
+    previous: Map<string, number>,
+    options: WorkspaceSentinelScanOptions = {},
+  ): WorkspaceSentinelSyncResult {
+    return this.manager.syncWorkspaceSentinelSnapshot(previous, options);
   }
 
   /** Track a file in its routed client without exposing that client. */
@@ -389,6 +443,7 @@ class DefaultWorkspaceLspRuntime implements WorkspaceLspRuntime {
           elapsedMs: result.elapsedMs,
           attemptedClients: result.attemptedClients,
           restartedClients: result.restartedClients,
+          processCrashRecovery: result.processCrashRecovery,
           attemptedServers: boundServerNames(result.attemptedServers ?? []),
           restartedServers: boundServerNames(result.restartedServers ?? []),
           ...(result.restartReason ? { reason: result.restartReason } : {}),

package/node_modules/@mrclrchtr/supi-lsp/src/session/runtime-transition-debug.ts

@@ -1,6 +1,9 @@
-import { recordDebugEvent } from "@mrclrchtr/supi-core/debug";
+import {
+  recordDebugEvent,
+  truncateDebugIdentity as truncateIdentity,
+} from "@mrclrchtr/supi-core/debug";
 import type { ProjectServerInfo } from "../config/types.ts";
-import { MAX_SERVERS, truncateIdentity } from "../debug-telemetry.ts";
+import { MAX_SERVERS } from "../debug-telemetry.ts";
 import type { LspRuntimeTransition } from "./runtime-controller.ts";
 
 /** One bounded server entry in a runtime-transition payload. */

package/node_modules/@mrclrchtr/supi-lsp/src/session/scanner.ts

@@ -1,15 +1,19 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { dedupeTopmostRoots, walkProject } from "@mrclrchtr/supi-core/project";
+import { dedupeTopmostRoots } from "@mrclrchtr/supi-core/project";
 import type {
   DetectedProjectServer,
   LspConfig,
   MissingServer,
-  ProjectServerInfo,
   ServerConfig,
 } from "../config/types.ts";
 import type { LspManager } from "../manager/manager.ts";
 import { commandExists } from "../utils.ts";
+import {
+  type AutomaticLspPathPolicy,
+  createDefaultAutomaticLspPathPolicy,
+  walkAutomaticLspTree,
+} from "../workspace-path-policy.ts";
 
 const DEFAULT_MAX_DEPTH = 3;
 
@@ -17,8 +21,14 @@ export function scanProjectCapabilities(
   config: LspConfig,
   cwd: string,
   maxDepth: number = DEFAULT_MAX_DEPTH,
+  policy: AutomaticLspPathPolicy = createDefaultAutomaticLspPathPolicy(cwd),
 ): DetectedProjectServer[] {
-  const { markerMatches, extensionBasedServers } = collectServerHints(config, cwd, maxDepth);
+  const { markerMatches, extensionBasedServers } = collectServerHints(
+    config,
+    cwd,
+    maxDepth,
+    policy,
+  );
 
   return Object.entries(config.servers)
     .flatMap(([serverName, server]) => {
@@ -45,11 +55,12 @@ function collectServerHints(
   config: LspConfig,
   cwd: string,
   maxDepth: number,
+  policy: AutomaticLspPathPolicy,
 ): { markerMatches: Map<string, Set<string>>; extensionBasedServers: Set<string> } {
   const ctx: HintContext = { markerMatches: new Map(), extensionBasedServers: new Set() };
 
-  walkProject(cwd, maxDepth, (directory, entryNames) => {
-    inspectDirectory(directory, entryNames, config.servers, ctx);
+  walkAutomaticLspTree(policy, cwd, maxDepth, (directory, entries) => {
+    inspectDirectory(directory, new Set(entries.map((entry) => entry.name)), config.servers, ctx);
   });
 
   return { markerMatches: ctx.markerMatches, extensionBasedServers: ctx.extensionBasedServers };
@@ -103,15 +114,10 @@ function hasMatchingFile(directory: string, entryNames: Set<string>, fileTypes:
 export async function startDetectedServers(
   manager: LspManager,
   detected: DetectedProjectServer[],
+  policy: AutomaticLspPathPolicy = createDefaultAutomaticLspPathPolicy(manager.getCwd()),
 ): Promise<void> {
-  await Promise.all(detected.map((entry) => manager.startServerForRoot(entry.name, entry.root)));
-}
-
-export function introspectCapabilities(
-  manager: LspManager,
-  detected: DetectedProjectServer[],
-): ProjectServerInfo[] {
-  return manager.getKnownProjectServers(detected);
+  const eligible = detected.filter((entry) => policy.isEligible(entry.root, "directory"));
+  await Promise.all(eligible.map((entry) => manager.startServerForRoot(entry.name, entry.root)));
 }
 
 /**
@@ -123,17 +129,14 @@ export function scanMissingServers(
   config: LspConfig,
   cwd: string,
   maxDepth: number = DEFAULT_MAX_DEPTH,
+  policy: AutomaticLspPathPolicy = createDefaultAutomaticLspPathPolicy(cwd),
 ): MissingServer[] {
   const foundExtensions = new Set<string>();
 
-  walkProject(cwd, maxDepth, (directory, entryNames) => {
-    for (const name of entryNames) {
-      try {
-        if (!fs.statSync(path.join(directory, name)).isFile()) continue;
-      } catch {
-        continue;
-      }
-      const ext = path.extname(name).slice(1).toLowerCase();
+  walkAutomaticLspTree(policy, cwd, maxDepth, (_directory, entries) => {
+    for (const entry of entries) {
+      if (!entry.isFile() && !entry.isSymbolicLink()) continue;
+      const ext = path.extname(entry.name).slice(1).toLowerCase();
       if (ext) foundExtensions.add(ext);
     }
   });

package/node_modules/@mrclrchtr/supi-lsp/src/session/workspace-lsp-runtime.ts

@@ -13,7 +13,12 @@ import type {
   WorkspaceEdit,
   WorkspaceSymbol,
 } from "../config/types.ts";
+import type {
+  WorkspaceSentinelScanOptions,
+  WorkspaceSentinelSyncResult,
+} from "../diagnostics/workspace-sentinels.ts";
 import type { WorkspaceLspDiagnosticSurface } from "./runtime-diagnostic-surface.ts";
+import type { ProcessCrashRecoveryReport } from "./runtime-diagnostics.ts";
 
 export type WorkspaceLspRuntimeState =
   | { kind: "ready"; runtime: WorkspaceLspRuntime }
@@ -23,9 +28,22 @@ export type WorkspaceLspRuntimeState =
   | { kind: "unavailable"; reason: string };
 
 export type SemanticReadinessResult =
-  | { kind: "ready" }
-  | { kind: "timeout" }
-  | { kind: "unavailable"; reason: string };
+  | {
+      kind: "ready";
+      /** Process-crash route recovery observed while establishing file readiness. */
+      processCrashRecovery?: ProcessCrashRecoveryReport;
+    }
+  | {
+      kind: "timeout";
+      /** Process-crash route recovery observed before the readiness timeout. */
+      processCrashRecovery?: ProcessCrashRecoveryReport;
+    }
+  | {
+      kind: "unavailable";
+      reason: string;
+      /** Process-crash route recovery observed before readiness became unavailable. */
+      processCrashRecovery?: ProcessCrashRecoveryReport;
+    };
 
 /** One mutation response and the exact provider roots from its semantic route. */
 export interface RoutedMutationResponse<T> {
@@ -96,7 +114,15 @@ export interface WorkspaceLspRuntime extends WorkspaceLspDiagnosticSurface {
     control?: CodeRequestControl,
   ): Promise<SemanticReadinessResult>;
   getProjectServers(): ProjectServerInfo[];
+  /** Check whether automatic LSP work can use and serve the source file. */
   isSupportedSourceFile(filePath: string): boolean;
+  /** Inventory policy-eligible workspace sentinels and optional source files. */
+  scanWorkspaceSentinels(options?: WorkspaceSentinelScanOptions): Map<string, number>;
+  /** Refresh one policy-eligible workspace sentinel and source inventory. */
+  syncWorkspaceSentinelSnapshot(
+    previous: Map<string, number>,
+    options?: WorkspaceSentinelScanOptions,
+  ): WorkspaceSentinelSyncResult;
   trackFile(filePath: string): Promise<boolean>;
   closeFile(filePath: string): void;
   pruneMissingFiles(): readonly string[];