@mrclrchtr/supi-code-intelligence 6.1.0 → 6.3.0

package/node_modules/@mrclrchtr/supi-lsp/src/manager/manager.ts

@@ -21,9 +21,18 @@ import type { ClientDiagnosticSnapshot } from "../client/client-document-state.t
 
 export { RECOVERY_CLIENT_STARTUP_BOUND_MS } from "../client/client.ts";
 
-import { recordDebugEvent } from "@mrclrchtr/supi-core/debug";
+import {
+  recordDebugEvent,
+  truncateDebugIdentity as truncateIdentity,
+} from "@mrclrchtr/supi-core/debug";
+import { resolveToolPath as resolveSessionPath, uriToFile } from "@mrclrchtr/supi-core/path";
 import { getServerForFile } from "../config/config.ts";
-import { getFileScopeDecision } from "../config/tsconfig-scope.ts";
+import {
+  getFileScopeDecision,
+  invalidateTsconfigCacheForConfig,
+  invalidateTsconfigCacheForConfigDir,
+  isProjectConfigFileName,
+} from "../config/tsconfig-scope.ts";
 import type {
   DetectedProjectServer,
   Diagnostic,
@@ -35,7 +44,8 @@ import type {
   SymbolInformation,
   WorkspaceSymbol,
 } from "../config/types.ts";
-import { boundCwd, truncateIdentity } from "../debug-telemetry.ts";
+import { FileChangeType } from "../config/types.ts";
+import { boundCwd } from "../debug-telemetry.ts";
 import {
   accumulateOutstandingDiagnostics,
   collectDiagnosticSummaryCounts,
@@ -47,11 +57,19 @@ import {
   type DiagnosticEvidenceSummary,
   summarizeDiagnosticEvidence,
 } from "../diagnostics/evidence.ts";
+import {
+  scanWorkspaceSentinels as scanAutomaticWorkspaceSentinels,
+  syncWorkspaceSentinelSnapshot as syncAutomaticWorkspaceSentinelSnapshot,
+  type WorkspaceSentinelScanOptions,
+  type WorkspaceSentinelSyncResult,
+} from "../diagnostics/workspace-sentinels.ts";
 import { raceRequestControl } from "../session/readiness.ts";
-import type {
-  ScopeDecisionEntry,
-  ScopeDecisionSummary,
-  WorkspaceDiagnosticReport,
+import {
+  emptyProcessCrashRecoveryReport,
+  type ProcessCrashRecoveryReport,
+  type ScopeDecisionEntry,
+  type ScopeDecisionSummary,
+  type WorkspaceDiagnosticReport,
 } from "../session/runtime-diagnostics.ts";
 import {
   displayRelativeFilePath,
@@ -61,7 +79,11 @@ import {
   normalizeRelevantPaths,
   shouldIgnoreLspPath,
 } from "../summary.ts";
-import { commandExists, resolveSessionPath, uriToFile } from "../utils.ts";
+import { commandExists } from "../utils.ts";
+import {
+  type AutomaticLspPathPolicy,
+  createDefaultAutomaticLspPathPolicy,
+} from "../workspace-path-policy.ts";
 import {
   closeFileAcrossClients,
   pruneMissingFilesFromClients,
@@ -71,12 +93,12 @@ import {
   collectOutstandingDiagnosticsDetailed,
   syncClientFileAndGetDiagnostics,
 } from "./manager-diagnostics.ts";
+import { clientKey, rememberKnownRoot, resolveRootForFile } from "./manager-helpers.ts";
 import {
-  clientKey,
-  isExcludedByPattern,
-  rememberKnownRoot,
-  resolveRootForFile,
-} from "./manager-helpers.ts";
+  boundProcessCrashFailureMessage,
+  buildProcessCrashRecoveryReport,
+  type ProcessCrashRecoveryRouteResult,
+} from "./manager-process-crash-report.ts";
 import { buildProjectServerInfo } from "./manager-project-info.ts";
 import type {
   ActiveCoverageSummaryEntry,
@@ -161,6 +183,11 @@ type FileClientRequestOptions = {
   control?: CodeRequestControl;
 };
 
+interface FileReadinessResult {
+  client: LspClient | null;
+  processCrashRecovery: ProcessCrashRecoveryReport;
+}
+
 interface ProcessCrashRecoveryState {
   /** The one automatic attempt is consumed when a replacement starts. */
   attemptConsumed: boolean;
@@ -174,25 +201,57 @@ interface ProcessCrashRecoveryState {
   pending: Promise<LspClient | null> | null;
   /** Start time for the current replacement attempt, when one exists. */
   attemptStartedAt?: number;
+  /** Bounded caught Error.message from a failed replacement startup. */
+  failureMessage?: string;
 }
 
-type ProcessCrashRecoveryOutcome = "attempt" | "success" | "failure" | "exhausted" | "cancelled";
-
 type ProcessCrashDemandResult = {
-  /** Whether at least one required crashed route supports the operation. */
+  /** Whether at least one crashed route supports the operation. */
   hasSupport: boolean;
+  /** Whether replacement work changed the route set and needs a fresh pass. */
+  requiresFreshEvidence: boolean;
+  /** Separate route-level result for this explicit process-crash demand. */
+  processCrashRecovery: ProcessCrashRecoveryReport;
   /** Required routes that remain unavailable after shared recovery settles. */
   failures: string[];
   /** In-scope tracked files from required routes that remain unavailable. */
   failedFiles: string[];
 };
 
+type ProcessCrashRecoverySnapshot = {
+  readonly key: string;
+  /** Mutable state handle used only to await the shared replacement. */
+  readonly recovery: ProcessCrashRecoveryState;
+  readonly failedClient: LspClient;
+  readonly name: string;
+  readonly root: string;
+  readonly statusReason: NonNullable<ProcessCrashRecoveryState["statusReason"]>;
+  readonly files: readonly string[];
+};
+
 type RequiredProcessCrashDemand = {
-  key: string;
-  recovery: ProcessCrashRecoveryState;
+  snapshot: ProcessCrashRecoverySnapshot;
+  failedFiles: readonly string[];
+};
+
+type ImmediateProcessCrashDemand = {
+  route: ProcessCrashRecoveryRouteResult;
   failedFiles: readonly string[];
+  reportOnly: boolean;
 };
 
+type ProcessCrashDemandSelection = {
+  immediate: ImmediateProcessCrashDemand[];
+  required: RequiredProcessCrashDemand[];
+};
+
+type ProcessCrashRecoveryTelemetryOutcome =
+  | "attempt"
+  | "success"
+  | "failure"
+  | "exhausted"
+  | "cancelled";
+
 // ── LspManager ────────────────────────────────────────────────────────
 export class LspManager {
   /** Active clients keyed by "serverName:root" */
@@ -201,14 +260,14 @@ export class LspManager {
   private unavailable = new Map<string, UnavailableReason>();
   /** Memoized per-command availability of LSP server binaries on PATH */
   private commandAvailability = new Map<string, boolean>();
-  /** Guards against concurrent client creation for the same server:root key */
+  /** Guards against concurrent client creation for the same server:root key. */
   private pendingStarts = new Map<string, Promise<LspClient | null>>();
+  /** Shared diagnostic-recovery restart for each replaceable client route. */
+  private pendingRestarts = new Map<string, Promise<{ files: string[]; restarted: boolean }>>();
   /** Monotonic ownership generation for each replaceable client route. */
   private clientGenerations = new Map<string, number>();
   /** Preferred project roots discovered by proactive scan or lazy startup */
   private knownRoots = new Map<string, string[]>();
-  /** User-configured gitignore-style exclude patterns */
-  private excludePatterns: string[] = [];
   /** Monotonic workspace invalidation generation advanced by each invalidation event. */
   private invalidationEpoch = 0;
   /** Invalidation generation in which each route last received a recovery restart. */
@@ -231,17 +290,19 @@ export class LspManager {
     private readonly config: LspConfig,
     private readonly cwd: string,
     private readonly onLifecycleTransition?: ManagerLifecycleListener,
+    private readonly automaticPathPolicy: AutomaticLspPathPolicy = createDefaultAutomaticLspPathPolicy(
+      cwd,
+    ),
   ) {}
   getCwd(): string {
     return this.cwd;
   }
-  setExcludePatterns(patterns: string[]): void {
-    this.excludePatterns = patterns;
-  }
 
   // ── Public API ────────────────────────────────────────────────────
   registerDetectedServers(detected: DetectedProjectServer[]): void {
-    this.knownRoots = projectRoots.buildKnownRootsMap(detected);
+    this.knownRoots = projectRoots.buildKnownRootsMap(
+      detected.filter((entry) => this.automaticPathPolicy.isEligible(entry.root, "directory")),
+    );
   }
   /** Check whether a file path has an available LSP server for explicit semantic operations. */
   canServeFile(filePath: string): boolean {
@@ -252,18 +313,60 @@ export class LspManager {
   }
 
   /**
-   * Check whether a file should participate in runtime guidance and diagnostics.
-   * This is stricter than {@link canServeFile} and intentionally filters dependency
-   * and tsconfig-excluded paths from UI/context behavior.
+   * Return an exhausted process-crash outcome for a file readiness result.
+   * This is a passive read and never starts recovery. A crashed or pending
+   * route has no final result until an explicit operation observes it.
+   */
+  getProcessCrashRecoveryReportForFile(filePath: string): ProcessCrashRecoveryReport | null {
+    const route = this.resolveFileRoute(resolveSessionPath(this.cwd, filePath));
+    const recovery = route ? this.processCrashRecoveries.get(route.key) : undefined;
+    if (!route || recovery?.statusReason !== "process-crash-recovery-exhausted") return null;
+    return buildProcessCrashRecoveryReport(
+      [
+        {
+          name: route.serverName,
+          root: route.root,
+          outcome: "recovery-exhausted",
+        },
+      ],
+      this.cwd,
+    );
+  }
+
+  /**
+   * Check whether a file should participate in automatic LSP work.
+   * This is stricter than {@link canServeFile} and applies the workspace path
+   * policy plus tsconfig diagnostic suppression.
    */
   isSupportedSourceFile(filePath: string): boolean {
-    // Dependency directories are intentionally excluded from recent-path
-    // tracking and diagnostic summaries (shouldIgnoreLspPath). Keep runtime
-    // guidance activation consistent: reading or editing a file under
-    // node_modules / .pnpm must not arm LSP guidance for dependency sources.
-    if (shouldIgnoreLspPath(filePath, this.cwd)) return false;
+    if (!this.isAutomaticScopePath(filePath)) return false;
     return this.canServeFile(filePath);
   }
+
+  /** Inventory automatic workspace sentinel and source paths with the runtime policy. */
+  scanWorkspaceSentinels(options: WorkspaceSentinelScanOptions = {}): Map<string, number> {
+    return scanAutomaticWorkspaceSentinels(this.cwd, {
+      ...options,
+      policy: this.automaticPathPolicy,
+    });
+  }
+
+  /** Refresh the automatic workspace inventory with the runtime policy. */
+  syncWorkspaceSentinelSnapshot(
+    previous: Map<string, number>,
+    options: WorkspaceSentinelScanOptions = {},
+  ): WorkspaceSentinelSyncResult {
+    return syncAutomaticWorkspaceSentinelSnapshot(this.cwd, previous, {
+      ...options,
+      policy: this.automaticPathPolicy,
+    });
+  }
+
+  /** Apply automatic path exclusions plus diagnostic tsconfig suppression. */
+  private isAutomaticScopePath(filePath: string): boolean {
+    return !shouldIgnoreLspPath(filePath, this.cwd, this.automaticPathPolicy);
+  }
+
   private isServerCommandAvailable(command: string): boolean {
     // Only memoize positive lookups. A negative result may become stale if the
     // user installs the binary mid-session (e.g. `mise install`), and
@@ -431,6 +534,7 @@ export class LspManager {
       failedClient: client,
       files: this.trackedFilesForClient(client),
       pending: null,
+      failureMessage: undefined,
     });
   }
 
@@ -469,54 +573,192 @@ export class LspManager {
   /**
    * Recover all crashed routes selected by one evidence-producing operation.
    * Each route keeps its independent attempt budget and shared replacement.
+   * Selection uses one immutable route-fact snapshot so scope and retention
+   * facts cannot change halfway through the demand.
    */
   private async recoverProcessCrashDemand(
-    selectFiles: (recovery: ProcessCrashRecoveryState) => readonly string[] | null,
+    selectFiles: (snapshot: ProcessCrashRecoverySnapshot) => readonly string[] | null,
     control?: CodeRequestControl,
+    options: { skipWhenNoRetainedFile?: boolean } = {},
   ): Promise<ProcessCrashDemandResult> {
-    const required = Array.from(this.processCrashRecoveries.entries()).flatMap(
-      ([key, recovery]): RequiredProcessCrashDemand[] => {
-        if (recovery.statusReason === undefined) return [];
-        const failedFiles = selectFiles(recovery);
-        return failedFiles === null ? [] : [{ key, recovery, failedFiles }];
-      },
+    const { immediate, required } = this.selectProcessCrashDemandRoutes(
+      this.snapshotProcessCrashRoutes(),
+      selectFiles,
+      options,
     );
-    if (required.length === 0) return { hasSupport: false, failures: [], failedFiles: [] };
+    const hasSupport = immediate.length > 0 || required.length > 0;
+    if (required.length === 0) {
+      const failures = immediate
+        .filter((entry) => !entry.reportOnly)
+        .map((entry) => this.formatProcessCrashDemandFailure(entry.route, entry.route.outcome));
+      return {
+        hasSupport,
+        requiresFreshEvidence: false,
+        processCrashRecovery: buildProcessCrashRecoveryReport(
+          immediate.map(({ route }) => route),
+          this.cwd,
+        ),
+        failures,
+        failedFiles: Array.from(
+          new Set(
+            immediate
+              .filter((entry) => !entry.reportOnly)
+              .flatMap(({ failedFiles }) => failedFiles),
+          ),
+        ),
+      };
+    }
 
     await Promise.all(
-      required.map(async ({ key, recovery }) => {
-        const serverConfig = this.config.servers[recovery.failedClient.name];
+      required.map(async ({ snapshot }) => {
+        const serverConfig = this.config.servers[snapshot.name];
         if (!serverConfig) return;
         await this.acquireProcessCrashReplacement(
-          recovery,
+          snapshot.recovery,
           {
-            serverName: recovery.failedClient.name,
+            serverName: snapshot.name,
             serverConfig,
-            root: recovery.failedClient.root,
-            key,
+            root: snapshot.root,
+            key: snapshot.key,
           },
           control,
         );
       }),
     );
 
-    const failedDemands = required.filter(({ recovery }) => recovery.statusReason !== undefined);
+    const observedRequired = required.filter(
+      ({ snapshot }) => !this.isProcessCrashDemandCancelled(snapshot),
+    );
+    const failedDemands = observedRequired.filter(
+      ({ snapshot }) => snapshot.recovery.statusReason !== undefined,
+    );
+    const recoveredRoutes = observedRequired.map(
+      ({ snapshot }): ProcessCrashRecoveryRouteResult => ({
+        name: snapshot.name,
+        root: snapshot.root,
+        outcome: snapshot.recovery.statusReason === undefined ? "recovered" : "recovery-failed",
+        ...(snapshot.recovery.statusReason === undefined || !snapshot.recovery.failureMessage
+          ? {}
+          : { failureMessage: snapshot.recovery.failureMessage }),
+      }),
+    );
+    const failedImmediate = immediate.filter((entry) => !entry.reportOnly);
     return {
-      hasSupport: true,
-      failures: failedDemands.map(({ recovery }) => this.formatProcessCrashDemandFailure(recovery)),
-      failedFiles: Array.from(new Set(failedDemands.flatMap(({ failedFiles }) => failedFiles))),
+      hasSupport,
+      requiresFreshEvidence: observedRequired.length > 0,
+      processCrashRecovery: buildProcessCrashRecoveryReport(
+        [...immediate.map(({ route }) => route), ...recoveredRoutes],
+        this.cwd,
+      ),
+      failures: [
+        ...failedImmediate.map((entry) =>
+          this.formatProcessCrashDemandFailure(entry.route, entry.route.outcome),
+        ),
+        ...failedDemands.map(({ snapshot }) =>
+          this.formatProcessCrashDemandFailure(snapshot.recovery, "recovery-failed"),
+        ),
+      ],
+      failedFiles: Array.from(
+        new Set([
+          ...failedImmediate.flatMap(({ failedFiles }) => failedFiles),
+          ...failedDemands.flatMap(({ failedFiles }) => failedFiles),
+        ]),
+      ),
     };
   }
 
-  private formatProcessCrashDemandFailure(recovery: ProcessCrashRecoveryState): string {
-    const root = (path.relative(this.cwd, recovery.failedClient.root) || ".").replaceAll("\\", "/");
+  private isProcessCrashDemandCancelled(snapshot: ProcessCrashRecoverySnapshot): boolean {
+    return (
+      snapshot.recovery.statusReason !== undefined &&
+      (this.shuttingDown || this.processCrashRecoveries.get(snapshot.key) !== snapshot.recovery)
+    );
+  }
+
+  private selectProcessCrashDemandRoutes(
+    snapshots: readonly ProcessCrashRecoverySnapshot[],
+    selectFiles: (snapshot: ProcessCrashRecoverySnapshot) => readonly string[] | null,
+    options: { skipWhenNoRetainedFile?: boolean },
+  ): ProcessCrashDemandSelection {
+    const immediate: ImmediateProcessCrashDemand[] = [];
+    const required: RequiredProcessCrashDemand[] = [];
+
+    for (const snapshot of snapshots) {
+      const failedFiles = selectFiles(snapshot);
+      if (failedFiles === null) continue;
+
+      const exhausted = snapshot.statusReason === "process-crash-recovery-exhausted";
+      const noRetainedFile = failedFiles.length === 0;
+      if (exhausted) {
+        immediate.push({
+          route: {
+            name: snapshot.name,
+            root: snapshot.root,
+            outcome: "recovery-exhausted",
+          },
+          failedFiles,
+          reportOnly: options.skipWhenNoRetainedFile === true && noRetainedFile,
+        });
+        continue;
+      }
+      if (
+        options.skipWhenNoRetainedFile === true &&
+        noRetainedFile &&
+        snapshot.statusReason === "process-crashed"
+      ) {
+        immediate.push({
+          route: {
+            name: snapshot.name,
+            root: snapshot.root,
+            outcome: "skipped-no-retained-file",
+          },
+          failedFiles,
+          reportOnly: true,
+        });
+        continue;
+      }
+      required.push({ snapshot, failedFiles });
+    }
+    return { immediate, required };
+  }
+
+  private snapshotProcessCrashRoutes(): ProcessCrashRecoverySnapshot[] {
+    return Array.from(this.processCrashRecoveries.entries()).flatMap(([key, recovery]) => {
+      if (recovery.statusReason === undefined) return [];
+      return [
+        {
+          key,
+          recovery,
+          failedClient: recovery.failedClient,
+          name: recovery.failedClient.name,
+          root: recovery.failedClient.root,
+          statusReason: recovery.statusReason,
+          files: [...recovery.files],
+        },
+      ];
+    });
+  }
+
+  private formatProcessCrashDemandFailure(
+    recovery: ProcessCrashRecoveryState | ProcessCrashRecoveryRouteResult,
+    outcome?: ProcessCrashRecoveryRouteResult["outcome"],
+  ): string {
+    const isRouteResult = "outcome" in recovery;
+    const name = isRouteResult ? recovery.name : recovery.failedClient.name;
+    const root = isRouteResult
+      ? recovery.root
+      : (path.relative(this.cwd, recovery.failedClient.root) || ".").replaceAll("\\", "/");
+    const routeOutcome =
+      outcome ??
+      (isRouteResult
+        ? recovery.outcome
+        : recovery.statusReason === "process-crash-recovery-exhausted"
+          ? "recovery-exhausted"
+          : "recovery-failed");
     const reason =
-      recovery.statusReason === "process-crash-recovery-exhausted"
+      routeOutcome === "recovery-exhausted"
         ? "process recovery exhausted; reload required"
-        : recovery.statusReason === "process-crash-recovery-pending"
-          ? "process recovery in progress"
-          : "process crashed";
-    return `${recovery.failedClient.name} @ ${root} is unavailable — ${reason}.`;
+        : "process recovery failed";
+    return `${name} @ ${root} is unavailable — ${reason}.`;
   }
 
   private startProcessCrashRecovery(
@@ -580,6 +822,7 @@ export class LspManager {
 
       this.unavailable.delete(key);
       recovery.statusReason = undefined;
+      recovery.failureMessage = undefined;
       this.publishLifecycle("recovery");
       this.restoreTrackedDocuments(started, recovery.files);
       this.recordProcessCrashRecoveryEvent(
@@ -626,7 +869,7 @@ export class LspManager {
       // LspClient's initialize request already has the 30-second transport
       // bound. Do not apply the 5-second diagnostic-restart bound here.
       await replacement.start();
-    } catch {
+    } catch (error) {
       if (this.isProcessCrashRecoveryCancelled(recovery, route.key)) {
         await replacement.forceKill().catch(() => {});
         this.recordProcessCrashRecoveryEvent(
@@ -638,7 +881,7 @@ export class LspManager {
         return null;
       }
       if (recovery.statusReason !== "process-crash-recovery-exhausted") {
-        this.markProcessCrashRecoveryFailed(recovery, route.key, replacement);
+        this.markProcessCrashRecoveryFailed(recovery, route.key, replacement, error);
         this.recordProcessCrashRecoveryEvent(
           route.serverName,
           route.root,
@@ -686,8 +929,13 @@ export class LspManager {
     recovery: ProcessCrashRecoveryState,
     key: string,
     replacement: LspClient,
+    error: unknown,
   ): void {
     recovery.statusReason = "process-crash-recovery-exhausted";
+    recovery.failureMessage =
+      error instanceof Error && error.message
+        ? boundProcessCrashFailureMessage(error.message)
+        : undefined;
     this.unavailable.set(key, "start-failed");
     if (this.clients.get(key) === replacement) this.clients.delete(key);
     // A failed initialize may still leave a child process alive. The
@@ -699,7 +947,7 @@ export class LspManager {
   private recordProcessCrashRecoveryEvent(
     serverName: string,
     root: string,
-    outcome: ProcessCrashRecoveryOutcome,
+    outcome: ProcessCrashRecoveryTelemetryOutcome,
     startedAt?: number,
   ): void {
     try {
@@ -808,32 +1056,60 @@ export class LspManager {
     const seen = new Set<string>();
 
     for (const filePath of filePaths) {
-      const client = this.getExistingClientForFile(filePath);
-      if (!client) continue;
-      if (options?.pushOnly && client.hasDiagnosticProvider) continue;
-
-      const key = clientKey(client.name, client.root);
-      const processRecovery = this.processCrashRecoveries.get(key);
-      if (processRecovery?.pending) continue;
-      if (seen.has(key)) continue;
-      seen.add(key);
-      if (this.recoveryRestartEpochs.get(key) === this.invalidationEpoch) continue;
+      const candidate = this.getRestartCandidate(filePath, options?.pushOnly === true, seen);
+      if (!candidate) continue;
+      const { client, key } = candidate;
 
       // Observe cancellation between route restarts so a cancelled pass does
       // not keep restarting further clients.
       throwIfCodeRequestInterrupted(options?.control);
-      const result = await this.restartClient(client);
-      this.recoveryRestartEpochs.set(key, this.invalidationEpoch);
+      const restartPromise = this.pendingRestarts.get(key) ?? this.startSharedRestart(client, key);
+      const result = await raceRequestControl(restartPromise, options?.control);
       restarted.push({ key, serverName: client.name, ...result });
     }
 
     return restarted;
   }
 
+  private startSharedRestart(
+    client: LspClient,
+    key: string,
+  ): Promise<{ files: string[]; restarted: boolean }> {
+    const restartEpoch = this.invalidationEpoch;
+    const restartPromise = this.restartClient(client).then((result) => {
+      this.recoveryRestartEpochs.set(key, restartEpoch);
+      return result;
+    });
+    this.pendingRestarts.set(key, restartPromise);
+    void restartPromise
+      .finally(() => {
+        if (this.pendingRestarts.get(key) === restartPromise) this.pendingRestarts.delete(key);
+      })
+      .catch(() => {});
+    return restartPromise;
+  }
+
+  private getRestartCandidate(
+    filePath: string,
+    pushOnly: boolean,
+    seen: Set<string>,
+  ): { client: LspClient; key: string } | null {
+    const client = this.getExistingClientForFile(filePath);
+    if (!client || (pushOnly && client.hasDiagnosticProvider)) return null;
+
+    const key = clientKey(client.name, client.root);
+    if (this.processCrashRecoveries.get(key)?.pending || seen.has(key)) return null;
+    seen.add(key);
+    if (this.recoveryRestartEpochs.get(key) === this.invalidationEpoch) return null;
+    return { client, key };
+  }
+
   private async restartClient(client: LspClient): Promise<{ files: string[]; restarted: boolean }> {
     const key = clientKey(client.name, client.root);
     const serverConfig = this.config.servers[client.name];
-    if (!serverConfig) return { files: [], restarted: false };
+    if (!serverConfig || this.clients.get(key) !== client) {
+      return { files: [], restarted: false };
+    }
 
     const openFiles = client.openFiles;
     const trackedDiagnosticFiles = client
@@ -846,6 +1122,7 @@ export class LspManager {
       // Ignore shutdown failures when forcing a restart.
     }
 
+    if (this.clients.get(key) !== client) return { files, restarted: false };
     this.clients.delete(key);
     this.unavailable.delete(key);
     this.clearWarmedWorkspaceSymbolProjects(client.name, client.root);
@@ -862,12 +1139,18 @@ export class LspManager {
         RECOVERY_CLIENT_STARTUP_BOUND_MS,
         "replacement client startup bound exceeded",
       );
+      if (this.clients.get(key) !== replacement || this.shuttingDown) {
+        void replacement.forceKill().catch(() => {});
+        return { files, restarted: false };
+      }
       this.restoreTrackedDocuments(replacement, files);
       this.clearUnconsumedProcessCrashState(key, client);
       return { files, restarted: true };
     } catch {
-      this.clients.delete(key);
-      this.unavailable.set(key, "start-failed");
+      if (this.clients.get(key) === replacement) {
+        this.clients.delete(key);
+        this.unavailable.set(key, "start-failed");
+      }
       // A bound-exceeded start may have spawned a live process; terminate
       // the tree so the orphan cannot outlive the failed restart.
       void replacement.forceKill().catch(() => {});
@@ -893,6 +1176,7 @@ export class LspManager {
         unavailableReason:
           this.getUnavailableReason(key, this.config.servers[serverName]?.command) ?? undefined,
         statusReason: this.processCrashRecoveries.get(key)?.statusReason,
+        includeOpenFile: (file) => this.isAutomaticScopePath(file),
       },
       this.cwd,
     );
@@ -900,6 +1184,7 @@ export class LspManager {
   getKnownProjectServers(detected: DetectedProjectServer[]): ProjectServerInfo[] {
     const known = new Map<string, DetectedProjectServer>();
     for (const entry of detected) {
+      if (!this.automaticPathPolicy.isEligible(entry.root, "directory")) continue;
       known.set(clientKey(entry.name, entry.root), entry);
     }
     for (const client of this.clients.values()) {
@@ -938,20 +1223,101 @@ export class LspManager {
   async waitUntilFileReady(
     filePath: string,
     control?: CodeRequestControl,
-  ): Promise<LspClient | null> {
+    onProcessCrashRecovery?: (report: ProcessCrashRecoveryReport) => void,
+  ): Promise<FileReadinessResult> {
     throwIfCodeRequestInterrupted(control);
     const resolvedPath = resolveSessionPath(this.cwd, filePath);
+    const route = this.resolveFileRoute(resolvedPath);
+    const recovery = route ? this.processCrashRecoveries.get(route.key) : undefined;
+    const statusAtStart = recovery?.statusReason;
+    const processCrashRecoveryRequested = statusAtStart !== undefined;
     const client = await this.getClientForFile(resolvedPath, {
       recoverProcessCrash: true,
       control,
     });
-    if (!client) return null;
-    // The caller's wait stops on cancellation even though the shared
-    // readiness state keeps its own lifecycle.
-    await client.getReady(control);
-    await this.warmSemanticProject(client, resolvedPath, true, control);
-    throwIfCodeRequestInterrupted(control);
-    return client;
+    const processCrashRecovery = this.buildFileProcessCrashRecoveryReport(
+      route,
+      recovery,
+      statusAtStart,
+      client,
+    );
+    if (processCrashRecoveryRequested) onProcessCrashRecovery?.(processCrashRecovery);
+    if (!client) return { client: null, processCrashRecovery };
+    try {
+      await client.getReady(control);
+      await this.warmSemanticProject(client, resolvedPath, true, control);
+      throwIfCodeRequestInterrupted(control);
+    } catch (error) {
+      const failedRecovery = this.buildFileProcessCrashFailureReport(
+        route,
+        recovery,
+        statusAtStart,
+        error,
+      );
+      if (failedRecovery) {
+        onProcessCrashRecovery?.(failedRecovery);
+        return { client: null, processCrashRecovery: failedRecovery };
+      }
+      throw error;
+    }
+    return { client, processCrashRecovery };
+  }
+
+  private buildFileProcessCrashRecoveryReport(
+    route: FileRoute | null,
+    recovery: ProcessCrashRecoveryState | undefined,
+    statusAtStart: ProcessCrashRecoveryState["statusReason"],
+    client: LspClient | null,
+  ): ProcessCrashRecoveryReport {
+    if (statusAtStart === undefined) return emptyProcessCrashRecoveryReport();
+    return buildProcessCrashRecoveryReport(
+      [
+        {
+          name: route?.serverName ?? "unknown",
+          root: route?.root ?? this.cwd,
+          outcome:
+            statusAtStart === "process-crash-recovery-exhausted"
+              ? "recovery-exhausted"
+              : client
+                ? "recovered"
+                : "recovery-failed",
+          ...(client || !recovery?.failureMessage
+            ? {}
+            : { failureMessage: recovery.failureMessage }),
+        },
+      ],
+      this.cwd,
+    );
+  }
+
+  private buildFileProcessCrashFailureReport(
+    route: FileRoute | null,
+    recovery: ProcessCrashRecoveryState | undefined,
+    statusAtStart: ProcessCrashRecoveryState["statusReason"],
+    error: unknown,
+  ): ProcessCrashRecoveryReport | null {
+    if (
+      statusAtStart === undefined ||
+      statusAtStart === "process-crash-recovery-exhausted" ||
+      recovery?.statusReason !== "process-crash-recovery-exhausted"
+    ) {
+      return null;
+    }
+    return buildProcessCrashRecoveryReport(
+      [
+        {
+          name: route?.serverName ?? "unknown",
+          root: route?.root ?? this.cwd,
+          outcome: "recovery-failed",
+          ...(error instanceof Error && error.message
+            ? { failureMessage: boundProcessCrashFailureMessage(error.message) }
+            : recovery.failureMessage
+              ? { failureMessage: recovery.failureMessage }
+              : {}),
+        },
+      ],
+      this.cwd,
+    );
   }
 
   /**
@@ -989,6 +1355,7 @@ export class LspManager {
         firstReady.root,
         serverConfig.rootMarkers,
         serverConfig.fileTypes,
+        { policy: this.automaticPathPolicy },
       )[0];
       if (target) await this.warmSemanticProject(firstReady, target.file, false, control);
     }
@@ -1060,6 +1427,7 @@ export class LspManager {
    */
   noteWorkspaceChanges(changes: FileEvent[]): void {
     if (changes.length > 0) this.invalidationEpoch++;
+    invalidateProjectConfigCaches(changes);
     this.notifyWorkspaceFileChanges(changes);
   }
 
@@ -1105,34 +1473,63 @@ export class LspManager {
     processCrashDemand?: { scopes?: readonly string[] };
     control?: CodeRequestControl;
   }): Promise<WorkspaceRecoveryResult> {
-    const demand = options?.processCrashDemand
-      ? await this.recoverProcessCrashDemand((recovery) => {
-          const files = this.processCrashDiagnosticFiles(recovery, options.processCrashDemand);
-          return files.length > 0 ? files : null;
-        }, options.control)
-      : { hasSupport: false, failures: [], failedFiles: [] };
-    const recoveryOptions = demand.hasSupport
+    const processCrashDemand = options?.processCrashDemand;
+    const demand = processCrashDemand
+      ? await this.recoverProcessCrashDemand(
+          (snapshot) => {
+            if (!this.processCrashDiagnosticRouteInScope(snapshot, processCrashDemand)) {
+              return null;
+            }
+            return this.processCrashDiagnosticFiles(snapshot, processCrashDemand);
+          },
+          options?.control,
+          { skipWhenNoRetainedFile: true },
+        )
+      : {
+          hasSupport: false,
+          requiresFreshEvidence: false,
+          processCrashRecovery: emptyProcessCrashRecoveryReport(),
+          failures: [],
+          failedFiles: [],
+        };
+    const recoveryOptions = demand.requiresFreshEvidence
       ? { ...options, initialEvidence: undefined }
       : options;
     const result = await recoverWorkspaceDiagnosticsImpl(this, recoveryOptions);
-    return this.addProcessCrashDiagnosticEvidence(result, demand);
+    return this.addProcessCrashDiagnosticEvidence(
+      { ...result, processCrashRecovery: demand.processCrashRecovery },
+      demand,
+    );
+  }
+
+  private processCrashDiagnosticRouteInScope(
+    snapshot: ProcessCrashRecoverySnapshot,
+    demand: { scopes?: readonly string[] },
+  ): boolean {
+    return this.processCrashDiagnosticScopes(demand).some(
+      (scope) =>
+        projectRoots.isWithinOrEqual(scope, snapshot.root) ||
+        projectRoots.isWithinOrEqual(snapshot.root, scope),
+    );
   }
 
   private processCrashDiagnosticFiles(
-    recovery: ProcessCrashRecoveryState,
-    demand: { scopes?: readonly string[] } | undefined,
+    snapshot: ProcessCrashRecoverySnapshot,
+    demand: { scopes?: readonly string[] },
   ): string[] {
-    if (!demand) return [];
-    const scopes = demand.scopes?.map((scope) => resolveSessionPath(this.cwd, scope));
-    return recovery.files.filter(
+    const scopes = this.processCrashDiagnosticScopes(demand);
+    return snapshot.files.filter(
       (file) =>
         this.isDiagnosticFile(file) &&
-        (!scopes ||
-          scopes.length === 0 ||
-          scopes.some((scope) => projectRoots.isWithinOrEqual(scope, file))),
+        scopes.some((scope) => projectRoots.isWithinOrEqual(scope, file)),
     );
   }
 
+  private processCrashDiagnosticScopes(demand: { scopes?: readonly string[] }): string[] {
+    const scopes = demand.scopes?.map((scope) => resolveSessionPath(this.cwd, scope));
+    return scopes && scopes.length > 0 ? scopes : [this.cwd];
+  }
+
   private addProcessCrashDiagnosticEvidence(
     result: WorkspaceRecoveryResult,
     demand: ProcessCrashDemandResult,
@@ -1184,6 +1581,7 @@ export class LspManager {
     this.warmedWorkspaceSymbolProjects.clear();
     this.warmedSemanticProjects.clear();
     this.pendingWarmProbes.clear();
+    this.pendingRestarts.clear();
   }
   /** Get status of all servers. */
   getRunningClientCount(): number {
@@ -1197,13 +1595,9 @@ export class LspManager {
       .map((client) => client.name);
   }
 
-  /** Check whether a path belongs to the configured diagnostic evidence scope. */
+  /** Check whether a path belongs to the automatic diagnostic evidence scope. */
   isDiagnosticFile(filePath: string): boolean {
-    const relative = path.relative(this.cwd, path.resolve(this.cwd, filePath));
-    return (
-      !shouldIgnoreLspPath(relative, this.cwd) &&
-      !isExcludedByPattern(relative, this.excludePatterns)
-    );
+    return this.isAutomaticScopePath(filePath);
   }
 
   getDiagnosticEvidence(): DiagnosticEvidenceSummary {
@@ -1218,7 +1612,7 @@ export class LspManager {
         name: client.name,
         status: client.status === "running" ? "running" : "error",
         root: client.root,
-        openFiles: client.openFiles,
+        openFiles: client.openFiles.filter((file) => this.isAutomaticScopePath(file)),
       });
     }
     return { servers };
@@ -1259,8 +1653,7 @@ export class LspManager {
       const openFiles = activeServers.get(server.name) ?? new Set<string>();
       for (const file of server.openFiles) {
         const relativeFile = displayRelativeFilePath(file, this.cwd);
-        if (shouldIgnoreLspPath(relativeFile, this.cwd)) continue;
-        if (isExcludedByPattern(relativeFile, this.excludePatterns)) continue;
+        if (!this.isAutomaticScopePath(relativeFile)) continue;
         openFiles.add(relativeFile);
       }
       activeServers.set(server.name, openFiles);
@@ -1286,7 +1679,7 @@ export class LspManager {
       .map((entry) => ({
         ...entry,
         openFiles: entry.openFiles.filter((file) =>
-          isPathRelevant(file, normalizedPaths, this.cwd),
+          isPathRelevant(file, normalizedPaths, this.cwd, this.automaticPathPolicy),
         ),
       }))
       .filter((entry) => entry.openFiles.length > 0);
@@ -1318,7 +1711,9 @@ export class LspManager {
     const fileDiags = new Map<string, { errors: number; warnings: number }>();
     for (const snapshot of snapshots) {
       for (const entry of snapshot.entries) {
-        collectDiagnosticSummaryCounts(fileDiags, entry, this.cwd, this.excludePatterns);
+        collectDiagnosticSummaryCounts(fileDiags, entry, this.cwd, (file) =>
+          this.isAutomaticScopePath(file),
+        );
       }
     }
 
@@ -1332,7 +1727,7 @@ export class LspManager {
         entries: collectOutstandingDiagnosticsDetailed(
           snapshots.map((snapshot) => snapshot.entries),
           this.cwd,
-          this.excludePatterns,
+          (file) => this.isAutomaticScopePath(file),
           maxSeverity,
         ),
         current,
@@ -1364,7 +1759,9 @@ export class LspManager {
         });
       }
       for (const entry of snapshot.entries) {
-        collectDiagnosticSummaryCounts(fileDiags, entry, this.cwd, this.excludePatterns);
+        collectDiagnosticSummaryCounts(fileDiags, entry, this.cwd, (file) =>
+          this.isAutomaticScopePath(file),
+        );
       }
     }
     const evidence = this.toWorkspaceDiagnosticEvidence(evidenceDocuments);
@@ -1396,7 +1793,7 @@ export class LspManager {
       entries: collectOutstandingDiagnosticSummaryEntries(
         snapshots,
         this.cwd,
-        this.excludePatterns,
+        (file) => this.isAutomaticScopePath(file),
         maxSeverity,
       ),
       current:
@@ -1413,7 +1810,7 @@ export class LspManager {
     if (normalizedPaths.length === 0) return null;
     return formatOutstandingDiagnosticsSummaryText(
       this.getOutstandingDiagnosticSummary(maxSeverity).filter((entry) =>
-        isPathRelevant(entry.file, normalizedPaths, this.cwd),
+        isPathRelevant(entry.file, normalizedPaths, this.cwd, this.automaticPathPolicy),
       ),
       maxFiles,
     );
@@ -1443,7 +1840,7 @@ export class LspManager {
       entries: collectOutstandingDiagnosticsDetailed(
         snapshots.map((snapshot) => snapshot.entries),
         this.cwd,
-        this.excludePatterns,
+        (file) => this.isAutomaticScopePath(file),
         maxSeverity,
       ),
       current:
@@ -1472,6 +1869,7 @@ export class LspManager {
     for (const client of this.clients.values()) {
       for (const document of client.getDiagnosticSnapshot().documents) {
         const file = relativeFilePathFromUri(document.uri, this.cwd);
+        if (!this.isAutomaticScopePath(file)) continue;
         totalFiles++;
         accumulateScopeDecision(accumulator, file, getFileScopeDecision(file, this.cwd));
       }
@@ -1491,8 +1889,7 @@ export class LspManager {
     const byFile = new Map<string, DiagnosticEvidenceDocument>();
     for (const document of documents) {
       const file = path.relative(this.cwd, path.resolve(this.cwd, document.file));
-      if (shouldIgnoreLspPath(file, this.cwd)) continue;
-      if (isExcludedByPattern(file, this.excludePatterns)) continue;
+      if (!this.isAutomaticScopePath(file)) continue;
       const existing = byFile.get(file);
       if (!existing || evidenceStatusRank(document.status) > evidenceStatusRank(existing.status)) {
         byFile.set(file, { file, status: document.status });
@@ -1517,9 +1914,9 @@ export class LspManager {
       );
     }
     const demand = await this.recoverProcessCrashDemand(
-      (recovery) =>
-        recovery.failedClient.serverCapabilities?.workspaceSymbolProvider &&
-        routeMatches(recovery.failedClient)
+      (snapshot) =>
+        snapshot.failedClient.serverCapabilities?.workspaceSymbolProvider &&
+        routeMatches(snapshot.failedClient)
           ? []
           : null,
       control,
@@ -1539,7 +1936,10 @@ export class LspManager {
     }
 
     const warmed = await this.warmWorkspaceSymbolProjectsUntilResult({
-      findWarmTargets: findWorkspaceSymbolWarmTargets,
+      findWarmTargets: (root, rootMarkers, fileTypes) =>
+        findWorkspaceSymbolWarmTargets(root, rootMarkers, fileTypes, {
+          policy: this.automaticPathPolicy,
+        }),
       getWarmPosition: getWorkspaceSymbolWarmPosition,
       collect,
       routeMatches,
@@ -1637,28 +2037,21 @@ export class LspManager {
       for (const target of warmTargets) {
         const projectKey = this.workspaceSymbolProjectKey(client.name, target.projectRoot);
         if (this.warmedWorkspaceSymbolProjects.has(projectKey)) continue;
-        if (this.hasOpenFileInProject(client, target.projectRoot)) {
-          this.warmedWorkspaceSymbolProjects.add(projectKey);
-          continue;
-        }
 
         const openedClient = await this.ensureFileOpen(target.file);
         if (!openedClient) continue;
 
         // A cancelled pass must not mark projects warmed on its way out.
         throwIfCodeRequestInterrupted(control);
-        this.warmedWorkspaceSymbolProjects.add(projectKey);
-        warmedAny = true;
-
-        const symbols = control
-          ? await openedClient.documentSymbols(target.file, control)
-          : await openedClient.documentSymbols(target.file);
-        if (symbols.kind !== "unavailable") {
-          const hoverPosition = getWarmPosition(symbols.data);
-          if (hoverPosition) {
-            if (control) await openedClient.hover(target.file, hoverPosition, control);
-            else await openedClient.hover(target.file, hoverPosition);
-          }
+        const available = await this.probeDocumentSymbols(
+          openedClient,
+          target.file,
+          getWarmPosition,
+          control,
+        );
+        if (available) {
+          this.warmedWorkspaceSymbolProjects.add(projectKey);
+          warmedAny = true;
         }
 
         const collected = await collect(this.clients.values(), query);
@@ -1703,35 +2096,56 @@ export class LspManager {
     try {
       await raceRequestControl(probe, control);
     } finally {
-      this.pendingWarmProbes.delete(projectKey);
+      if (this.pendingWarmProbes.get(projectKey) === probe) {
+        this.pendingWarmProbes.delete(projectKey);
+      }
     }
   }
 
   private async performWarmProbe(
-    _client: LspClient,
+    client: LspClient,
     resolvedFile: string,
     projectKey: string,
     control?: CodeRequestControl,
   ): Promise<void> {
+    const key = clientKey(client.name, client.root);
+    if (this.clients.get(key) !== client) return;
     const openedClient = await this.ensureFileOpen(resolvedFile);
-    if (!openedClient) return;
-
-    this.warmedSemanticProjects.add(projectKey);
+    if (!openedClient || openedClient !== client || this.clients.get(key) !== client) return;
 
     // The probe is shared state for concurrent callers. One caller's
     // cancellation must not cancel the shared in-flight queries, so only the
     // Debug Operation ID is forwarded; each caller races its own wait above.
     const sharedControl = { operationId: control?.operationId };
-    const symbols = await openedClient.documentSymbols(resolvedFile, sharedControl);
-    if (symbols.kind === "unavailable") return;
-    const hoverPosition = getWorkspaceSymbolWarmPosition(symbols.data);
-    if (hoverPosition) {
-      await openedClient.hover(resolvedFile, hoverPosition, sharedControl);
+    const available = await this.probeDocumentSymbols(
+      openedClient,
+      resolvedFile,
+      getWorkspaceSymbolWarmPosition,
+      sharedControl,
+    );
+    if (available && this.clients.get(key) === client) {
+      this.warmedSemanticProjects.add(projectKey);
     }
   }
 
-  private hasOpenFileInProject(client: LspClient, projectRoot: string): boolean {
-    return client.openFiles.some((openFile) => projectRoots.isWithinOrEqual(projectRoot, openFile));
+  private async probeDocumentSymbols(
+    client: LspClient,
+    file: string,
+    getWarmPosition: (
+      symbols: import("../config/types.ts").DocumentSymbol[] | SymbolInformation[] | null,
+    ) => import("../config/types.ts").Position | null,
+    control?: CodeRequestControl,
+  ): Promise<boolean> {
+    const symbols = control
+      ? await client.documentSymbols(file, control)
+      : await client.documentSymbols(file);
+    if (symbols.kind === "unavailable") return false;
+    const hoverPosition = getWarmPosition(symbols.data);
+    if (hoverPosition) {
+      if (control) await client.hover(file, hoverPosition, control);
+      else await client.hover(file, hoverPosition);
+    }
+    return true;
   }
 
   private workspaceSymbolProjectKey(serverName: string, projectRoot: string): string {
@@ -1766,6 +2180,17 @@ export class LspManager {
   }
 }
 
+function invalidateProjectConfigCaches(changes: readonly FileEvent[]): void {
+  for (const change of changes) {
+    const configPath = uriToFile(change.uri);
+    if (!isProjectConfigFileName(path.basename(configPath))) continue;
+    invalidateTsconfigCacheForConfig(configPath);
+    if (change.type === FileChangeType.Created) {
+      invalidateTsconfigCacheForConfigDir(path.dirname(configPath));
+    }
+  }
+}
+
 function collectClientDiagnosticEvidenceDocuments(
   snapshots: Iterable<ClientDiagnosticSnapshot>,
   cwd: string,
@@ -1781,14 +2206,14 @@ function collectClientDiagnosticEvidenceDocuments(
 function collectOutstandingDiagnosticSummaryEntries(
   snapshots: Iterable<ClientDiagnosticSnapshot>,
   cwd: string,
-  excludePatterns: string[],
+  includeFile: (file: string) => boolean,
   maxSeverity: number,
 ): OutstandingDiagnosticSummaryEntry[] {
   const fileDiags = new Map<string, OutstandingDiagnosticSummaryEntry>();
   for (const snapshot of snapshots) {
     for (const entry of snapshot.entries) {
       const file = relativeFilePathFromUri(entry.uri, cwd);
-      if (shouldIgnoreLspPath(file, cwd) || isExcludedByPattern(file, excludePatterns)) continue;
+      if (!includeFile(file)) continue;
       const existing = fileDiags.get(file) ?? createOutstandingDiagnosticSummary(file);
       const next = accumulateOutstandingDiagnostics(existing, entry.diagnostics, maxSeverity);
       if (next.total > 0) fileDiags.set(file, next);