@mrclrchtr/supi-code-intelligence 6.0.1 → 6.2.0

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

@@ -92,12 +92,14 @@ export function createLspSemanticProvider(lsp: WorkspaceLspRuntime): SemanticPro
     async workspaceSymbols(
       query: string,
       control?: CodeRequestControl,
+      scopes?: readonly string[],
     ): Promise<CodeQueryResult<CodeSymbol[]>> {
-      const result = control
-        ? await lsp.workspaceSymbol(query, control)
-        : await lsp.workspaceSymbol(query);
+      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-diagnostic-surface.ts

@@ -8,6 +8,14 @@ import type {
   WorkspaceDiagnosticSummaryEntry,
 } from "./runtime-diagnostics.ts";
 
+/**
+ * Explicit diagnostic demand that can recover previously running crashed
+ * routes. Omitted scopes include every route with retained tracked files.
+ */
+export interface ProcessCrashDiagnosticDemand {
+  readonly scopes?: readonly string[];
+}
+
 /** Diagnostic and recovery operations owned by a workspace LSP runtime. */
 export interface WorkspaceLspDiagnosticSurface {
   fileDiagnostics(
@@ -37,6 +45,8 @@ export interface WorkspaceLspDiagnosticSurface {
     quietMs?: number;
     /** Evidence from a refresh the caller already completed; skips this pass's own refresh when no watched-file changes apply. */
     initialEvidence?: DiagnosticEvidenceSummary;
+    /** Explicit demand to recover crashed routes with tracked files in scope. */
+    processCrashDemand?: ProcessCrashDiagnosticDemand;
     control?: CodeRequestControl;
   }): Promise<RecoverDiagnosticsResult>;
 }

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

@@ -45,11 +45,37 @@ export interface OutstandingDiagnosticSummaryEntry {
   hints: number;
 }
 
+/**
+ * Outcome of explicit process-crash recovery demand in one diagnostic pass.
+ *
+ * Routes are counted rather than client generations because process-crash
+ * recovery owns one budget per LSP route. `attemptedRoutes` is the number of
+ * crashed routes selected by the demand; a route can be failed already or
+ * have a shared replacement in progress when the demand observes it.
+ */
+export interface ProcessCrashRecoverySummary {
+  attemptedRoutes: number;
+  recoveredRoutes: number;
+  failedRoutes: number;
+}
+
+/** Create the empty outcome for a pass with no process-crash demand. */
+export function emptyProcessCrashRecoverySummary(): ProcessCrashRecoverySummary {
+  return {
+    attemptedRoutes: 0,
+    recoveredRoutes: 0,
+    failedRoutes: 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: ProcessCrashRecoverySummary;
   /** 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,
+  ProcessCrashRecoverySummary,
+  RecoverDiagnosticsResult,
+} from "./runtime-diagnostics.ts";
 import type {
   RoutedMutationResponse,
   SemanticReadinessResult,
@@ -38,16 +49,21 @@ import type {
   WorkspaceLspRuntimeState,
 } from "./workspace-lsp-runtime.ts";
 
-export type { WorkspaceLspDiagnosticSurface } from "./runtime-diagnostic-surface.ts";
 export type {
-  DiagnosticEvidenceDocument,
-  DiagnosticEvidenceStatus,
-  DiagnosticEvidenceSummary,
-  OutstandingDiagnosticSummaryEntry,
-  RecoverDiagnosticsResult,
-  WorkspaceDiagnosticReport,
-  WorkspaceDiagnosticSnapshot,
-  WorkspaceDiagnosticSummaryEntry,
+  ProcessCrashDiagnosticDemand,
+  WorkspaceLspDiagnosticSurface,
+} from "./runtime-diagnostic-surface.ts";
+export {
+  type DiagnosticEvidenceDocument,
+  type DiagnosticEvidenceStatus,
+  type DiagnosticEvidenceSummary,
+  emptyProcessCrashRecoverySummary,
+  type OutstandingDiagnosticSummaryEntry,
+  type ProcessCrashRecoverySummary,
+  type RecoverDiagnosticsResult,
+  type WorkspaceDiagnosticReport,
+  type WorkspaceDiagnosticSnapshot,
+  type WorkspaceDiagnosticSummaryEntry,
 } from "./runtime-diagnostics.ts";
 export type {
   RoutedMutationResponse,
@@ -64,6 +80,29 @@ function unavailableFileQuery<T>(operation: string, file: string): CodeQueryResu
   return unavailableCodeQuery(`No routed LSP client could complete ${operation} for ${file}.`);
 }
 
+function hasProcessCrashRecovery(summary: ProcessCrashRecoverySummary): boolean {
+  return summary.attemptedRoutes > 0 || summary.recoveredRoutes > 0 || summary.failedRoutes > 0;
+}
+
+/**
+ * Combine the eager and current state for one readiness wait.
+ * A current failure replaces the older pending view; max avoids double-counting
+ * one route when both views describe the same recovery attempt.
+ */
+function mergeProcessCrashRecoverySummaries(
+  eager: ProcessCrashRecoverySummary | undefined,
+  current: ProcessCrashRecoverySummary | null,
+): ProcessCrashRecoverySummary | undefined {
+  if (!eager) return current ?? undefined;
+  if (!current) return eager;
+  if (current.failedRoutes > 0) return current;
+  return {
+    attemptedRoutes: Math.max(eager.attemptedRoutes, current.attemptedRoutes),
+    recoveredRoutes: Math.max(eager.recoveredRoutes, current.recoveredRoutes),
+    failedRoutes: Math.max(eager.failedRoutes, current.failedRoutes),
+  };
+}
+
 /** Emit one aggregate tsconfig scope-decision event after a recovery pass. */
 function recordScopeDecisionEvent(manager: LspManager): void {
   try {
@@ -107,7 +146,10 @@ class DefaultWorkspaceLspRuntime implements WorkspaceLspRuntime {
     control?: CodeRequestControl,
   ): Promise<CodeQueryResult<Hover | null>> {
     const resolvedPath = this.resolveFilePath(filePath);
-    const client = await this.manager.ensureFileOpen(resolvedPath);
+    const client = await this.manager.ensureFileOpen(resolvedPath, {
+      recoverProcessCrash: true,
+      control,
+    });
     if (!client) return unavailableFileQuery("hover", resolvedPath);
     return client.hover(resolvedPath, position, control);
   }
@@ -118,7 +160,10 @@ class DefaultWorkspaceLspRuntime implements WorkspaceLspRuntime {
     control?: CodeRequestControl,
   ): Promise<CodeQueryResult<Location | Location[] | LocationLink[] | null>> {
     const resolvedPath = this.resolveFilePath(filePath);
-    const client = await this.manager.ensureFileOpen(resolvedPath);
+    const client = await this.manager.ensureFileOpen(resolvedPath, {
+      recoverProcessCrash: true,
+      control,
+    });
     if (!client) return unavailableFileQuery("definition", resolvedPath);
     return client.definition(resolvedPath, position, control);
   }
@@ -129,7 +174,10 @@ class DefaultWorkspaceLspRuntime implements WorkspaceLspRuntime {
     control?: CodeRequestControl,
   ): Promise<CodeQueryResult<Location[]>> {
     const resolvedPath = this.resolveFilePath(filePath);
-    const client = await this.manager.ensureFileOpen(resolvedPath);
+    const client = await this.manager.ensureFileOpen(resolvedPath, {
+      recoverProcessCrash: true,
+      control,
+    });
     if (!client) return unavailableFileQuery("references", resolvedPath);
     return mapCodeQueryResult(
       await client.references(resolvedPath, position, control),
@@ -143,7 +191,10 @@ class DefaultWorkspaceLspRuntime implements WorkspaceLspRuntime {
     control?: CodeRequestControl,
   ): Promise<CodeQueryResult<Location | Location[] | LocationLink[] | null>> {
     const resolvedPath = this.resolveFilePath(filePath);
-    const client = await this.manager.ensureFileOpen(resolvedPath);
+    const client = await this.manager.ensureFileOpen(resolvedPath, {
+      recoverProcessCrash: true,
+      control,
+    });
     if (!client) return unavailableFileQuery("implementation", resolvedPath);
     return client.implementation(resolvedPath, position, control);
   }
@@ -153,7 +204,10 @@ class DefaultWorkspaceLspRuntime implements WorkspaceLspRuntime {
     control?: CodeRequestControl,
   ): Promise<CodeQueryResult<DocumentSymbol[] | SymbolInformation[]>> {
     const resolvedPath = this.resolveFilePath(filePath);
-    const client = await this.manager.ensureFileOpen(resolvedPath);
+    const client = await this.manager.ensureFileOpen(resolvedPath, {
+      recoverProcessCrash: true,
+      control,
+    });
     if (!client) return unavailableFileQuery("document symbols", resolvedPath);
     return mapCodeQueryResult(
       await client.documentSymbols(resolvedPath, control),
@@ -164,8 +218,9 @@ class DefaultWorkspaceLspRuntime implements WorkspaceLspRuntime {
   async workspaceSymbol(
     query: string,
     control?: CodeRequestControl,
+    scopes?: readonly string[],
   ): Promise<CodeQueryResult<SymbolInformation[] | WorkspaceSymbol[]>> {
-    return this.manager.workspaceSymbol(query, control);
+    return this.manager.workspaceSymbol(query, control, scopes);
   }
 
   async rename(
@@ -175,7 +230,10 @@ class DefaultWorkspaceLspRuntime implements WorkspaceLspRuntime {
     control?: CodeRequestControl,
   ): Promise<RoutedMutationResponse<WorkspaceEdit | null> | null> {
     const resolvedPath = this.resolveFilePath(filePath);
-    const client = await this.manager.ensureFileOpen(resolvedPath);
+    const client = await this.manager.ensureFileOpen(resolvedPath, {
+      recoverProcessCrash: true,
+      control,
+    });
     if (!client) return null;
     return {
       value: await client.rename(resolvedPath, position, newName, control),
@@ -193,7 +251,10 @@ class DefaultWorkspaceLspRuntime implements WorkspaceLspRuntime {
     control?: CodeRequestControl,
   ): Promise<RoutedMutationResponse<CodeAction[] | null> | null> {
     const resolvedPath = this.resolveFilePath(filePath);
-    const client = await this.manager.ensureFileOpen(resolvedPath);
+    const client = await this.manager.ensureFileOpen(resolvedPath, {
+      recoverProcessCrash: true,
+      control,
+    });
     if (!client) return null;
 
     const range = isRange(positionOrRange)
@@ -221,25 +282,39 @@ class DefaultWorkspaceLspRuntime implements WorkspaceLspRuntime {
   ): Promise<SemanticReadinessResult> {
     const resolvedPath = this.resolveFilePath(filePath);
     if (!this.manager.canServeFile(resolvedPath)) {
+      const processCrashRecovery = this.manager.getProcessCrashRecoverySummaryForFile(resolvedPath);
       return {
         kind: "unavailable",
         reason: "No LSP client can serve this file",
+        ...(processCrashRecovery ? { processCrashRecovery } : {}),
       };
     }
 
+    let eagerProcessCrashRecovery: ProcessCrashRecoverySummary | undefined;
     const readiness = await raceReadinessValue(
-      this.manager.waitUntilFileReady(resolvedPath, control),
+      this.manager.waitUntilFileReady(resolvedPath, control, (summary) => {
+        eagerProcessCrashRecovery = summary;
+      }),
       options.timeoutMs,
       control,
     );
-    if (readiness.kind !== "resolved") return readiness;
-    if (readiness.value === null) {
+    if (readiness.kind !== "resolved") {
+      const processCrashRecovery = mergeProcessCrashRecoverySummaries(
+        eagerProcessCrashRecovery,
+        this.manager.getProcessCrashRecoverySummaryForFile(resolvedPath),
+      );
+      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 };
   }
 
   /**
@@ -269,9 +344,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. */
@@ -345,6 +433,8 @@ class DefaultWorkspaceLspRuntime implements WorkspaceLspRuntime {
     quietMs?: number;
     /** Evidence from a refresh the caller already completed; skips this pass's own refresh when no watched-file changes apply. */
     initialEvidence?: DiagnosticEvidenceSummary;
+    /** Explicit demand to recover crashed routes with tracked files in scope. */
+    processCrashDemand?: import("./runtime-diagnostic-surface.ts").ProcessCrashDiagnosticDemand;
     control?: CodeRequestControl;
   }): Promise<RecoverDiagnosticsResult> {
     const recoveryStartedAt = Date.now();
@@ -362,6 +452,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. */
@@ -8,6 +11,7 @@ export interface TransitionServerEntry {
   readonly name: string;
   readonly status: ProjectServerInfo["status"];
   readonly ready: boolean;
+  readonly statusReason?: NonNullable<ProjectServerInfo["statusReason"]>;
 }
 
 /** Bound a project-server snapshot to MAX_SERVERS name/status/ready entries. */
@@ -18,6 +22,7 @@ function boundedServerEntries(
     name: truncateIdentity(server.name),
     status: server.status,
     ready: server.ready,
+    ...(server.statusReason ? { statusReason: server.statusReason } : {}),
   }));
 }