@mrclrchtr/supi-lsp 11.1.0 → 11.3.0

package/src/manager/manager.ts

@@ -19,6 +19,7 @@ import {
   withTimeout,
 } from "../client/client.ts";
 import type { ClientDiagnosticSnapshot } from "../client/client-document-state.ts";
+import type { ProjectMembership } from "../client/client-typescript-project.ts";
 
 export { RECOVERY_CLIENT_STARTUP_BOUND_MS } from "../client/client.ts";
 
@@ -48,6 +49,7 @@ import type {
   WorkspaceSymbol,
 } from "../config/types.ts";
 import { FileChangeType } from "../config/types.ts";
+import { inspectTypeScriptLaunch } from "../config/typescript-launch.ts";
 import { boundCwd } from "../debug-telemetry.ts";
 import {
   accumulateOutstandingDiagnostics,
@@ -134,8 +136,10 @@ import {
   collectWorkspaceSymbols,
   findWorkspaceSymbolWarmTargets,
   getWorkspaceSymbolWarmPosition,
+  isWithinAnyScope,
   type WorkspaceSymbolCollection,
   workspaceSymbolCollectionResult,
+  workspaceSymbolCoverageGap,
 } from "./manager-workspace-symbol.ts";
 
 type UnavailableReason = "missing-command" | "start-failed" | "runtime-error";
@@ -250,6 +254,8 @@ export interface ManagerLifecycleTransition {
 type ManagerLifecycleListener = (transition: ManagerLifecycleTransition) => void;
 
 type FileClientRequestOptions = {
+  /** Reject known input changes while this call's first open waits to dispatch original parameters. */
+  protectInputs?: boolean;
   /** Allow this request to start the route's one process-crash recovery. */
   recoverProcessCrash?: boolean;
   /** Control only this caller's wait for a shared replacement. */
@@ -396,8 +402,12 @@ export class LspManager {
   private invalidationEpoch = 0;
   /** Invalidation generation in which each route last received a recovery restart. */
   private recoveryRestartEpochs = new Map<string, number>();
-  /** Files already probed for workspace-symbol warm-up. */
-  private warmedWorkspaceSymbolFiles = new Set<string>();
+  /**
+   * Files already probed for workspace-symbol warm-up, with the project
+   * membership the server reported. `inferred` probes stay recorded so they
+   * are not reopened, but they do not prove project coverage.
+   */
+  private warmedWorkspaceSymbolFiles = new Map<string, ProjectMembership>();
   /** Project roots whose semantic state was warmed with a readiness probe. */
   private warmedSemanticProjects = new Set<string>();
   /** In-flight warm-up probes keyed by project key so concurrent callers share one probe. */
@@ -433,12 +443,29 @@ export class LspManager {
       detected.filter((entry) => this.automaticPathPolicy.isEligible(entry.root, "directory")),
     );
   }
+  /** Check configured routing only, independently of executable availability or startup state. */
+  hasConfiguredServerForFile(filePath: string): boolean {
+    return getServerForFile(this.config, resolveSessionPath(this.cwd, filePath)) !== null;
+  }
+
+  /** Observe a retained initial-start failure without retrying or conflating process-crash recovery. */
+  hasFailedStartupForFile(filePath: string): boolean {
+    const route = this.resolveFileRoute(filePath);
+    if (!route || this.processCrashRecoveries.has(route.key)) return false;
+    const reason = this.unavailable.get(route.key);
+    return reason === "start-failed" || reason === "missing-command";
+  }
+
   /** Check whether a file path has an available LSP server for explicit semantic operations. */
   canServeFile(filePath: string): boolean {
     const route = this.resolveFileRoute(filePath);
     if (!route) return false;
-    if (this.getUnavailableReason(route.key, route.serverConfig.command)) return false;
-    return this.isServerCommandAvailable(route.serverConfig.command);
+    if (this.getUnavailableReason(route.key, route.serverName, route.root)) return false;
+    if (this.clients.get(route.key)?.status === "running") return true;
+    const launch = inspectTypeScriptLaunch(route.serverName, route.serverConfig, route.root);
+    // A broken selection is a route failure, not an absent executable. Let
+    // startup record it so lazy readiness and health expose the actual error.
+    return Boolean(launch.failureMessage) || this.isServerCommandAvailable(launch.command);
   }
 
   /**
@@ -517,13 +544,21 @@ export class LspManager {
     return available;
   }
 
-  private getUnavailableReason(key: string, command?: string): UnavailableReason | null {
+  private getUnavailableReason(
+    key: string,
+    serverName: string,
+    root: string,
+  ): UnavailableReason | null {
     const reason = this.unavailable.get(key);
     if (!reason) return null;
 
-    if (reason === "missing-command" && command && this.isServerCommandAvailable(command)) {
-      this.unavailable.delete(key);
-      return null;
+    const config = this.config.servers[serverName];
+    if (reason === "missing-command" && config) {
+      const launch = inspectTypeScriptLaunch(serverName, config, root);
+      if (!launch.failureMessage && this.isServerCommandAvailable(launch.command)) {
+        this.unavailable.delete(key);
+        return null;
+      }
     }
 
     return reason;
@@ -573,7 +608,7 @@ export class LspManager {
     if (this.shouldBlockRetiredRoute(key, root, retryFailedStart)) return null;
     const routeGeneration = this.getRouteRetirementGeneration(key);
     if (retryFailedStart) this.unavailable.delete(key);
-    if (!retryFailedStart && this.getUnavailableReason(key, serverConfig.command)) return null;
+    if (!retryFailedStart && this.getUnavailableReason(key, serverName, root)) return null;
 
     // Return existing client
     const existing = this.clients.get(key);
@@ -1301,7 +1336,13 @@ export class LspManager {
       recovery.statusReason = undefined;
       recovery.failureMessage = undefined;
       this.publishLifecycle("recovery");
-      this.restoreTrackedDocuments(started, recovery.files);
+      await this.restoreTrackedDocuments(started, recovery.files);
+      if (
+        this.isProcessCrashRecoveryCancelled(recovery, key) ||
+        this.clients.get(key) !== started ||
+        started.status !== "running"
+      )
+        return null;
       this.recordProcessCrashRecoveryEvent(
         route.serverName,
         route.root,
@@ -1386,20 +1427,16 @@ export class LspManager {
   }
 
   /** Restore route documents from disk and retain failed-document evidence. */
-  private restoreTrackedDocuments(client: LspClient, files: readonly string[]): void {
-    const failedFiles: string[] = [];
+  private async restoreTrackedDocuments(
+    client: LspClient,
+    files: readonly string[],
+  ): Promise<void> {
+    const key = clientKey(client.name, client.root);
+    const isCurrent = () => !this.shuttingDown && this.clients.get(key) === client;
     for (const filePath of files) {
-      if (!fs.existsSync(filePath)) {
-        failedFiles.push(filePath);
-        continue;
-      }
-      try {
-        client.didOpen(filePath, fs.readFileSync(filePath, "utf-8"));
-      } catch {
-        failedFiles.push(filePath);
-      }
+      if (!isCurrent()) return;
+      await client.restoreDocument(filePath, () => fs.readFileSync(filePath, "utf-8"), isCurrent);
     }
-    for (const filePath of failedFiles) client.markFailedFile(filePath);
   }
 
   private markProcessCrashRecoveryFailed(
@@ -1460,22 +1497,30 @@ export class LspManager {
     }
   }
 
+  /** Record a root-aware selection/command failure without starting a client. */
+  private recordUnavailableLaunch(route: FileRoute): boolean {
+    const { serverName, serverConfig, root, key } = route;
+    const launch = inspectTypeScriptLaunch(serverName, serverConfig, root);
+    const command = launch.command;
+    if (!launch.failureMessage && commandExists(command)) return false;
+    this.unavailable.set(key, launch.failureMessage ? "start-failed" : "missing-command");
+    this.failedStarts.set(key, {
+      serverName,
+      root,
+      failureMessage:
+        launch.failureMessage ?? `Configured server command is not available: ${command}`,
+    });
+    return true;
+  }
+
   /**
    * Perform the actual server start — extracted so the public method can
    * deduplicate via pendingStarts without wrapping the entire body.
    */
   private async performStart(route: FileRoute, routeGeneration: number): Promise<LspClient | null> {
     const { serverName, serverConfig, root, key } = route;
-    // Validate command exists
-    if (!commandExists(serverConfig.command)) {
-      this.unavailable.set(key, "missing-command");
-      this.failedStarts.set(key, {
-        serverName,
-        root,
-        failureMessage: `Configured server command is not available: ${serverConfig.command}`,
-      });
-      return null;
-    }
+    // Client.start resolves again at actual spawn time, including every retry.
+    if (this.recordUnavailableLaunch(route)) return null;
 
     // Spawn new client
     const client = this.createClient(serverName, serverConfig, root, key);
@@ -1635,7 +1680,15 @@ export class LspManager {
         void replacement.forceKill().catch(() => {});
         return { files, restarted: false };
       }
-      this.restoreTrackedDocuments(replacement, files);
+      await this.restoreTrackedDocuments(replacement, files);
+      if (
+        this.clients.get(key) !== replacement ||
+        this.shuttingDown ||
+        replacement.status !== "running"
+      ) {
+        void replacement.forceKill().catch(() => {});
+        return { files, restarted: false };
+      }
       this.clearUnconsumedProcessCrashState(key, client);
       return { files, restarted: true };
     } catch {
@@ -1659,14 +1712,26 @@ export class LspManager {
 
   getProjectServerInfo(serverName: string, root: string, fileTypes: string[]): ProjectServerInfo {
     const key = clientKey(serverName, root);
+    const client = this.clients.get(key);
+    const config = this.config.servers[serverName];
+    const selection: Pick<DetectedProjectServer, "typescript" | "failureMessage"> =
+      client?.status === "running"
+        ? { typescript: client.typescriptSelection }
+        : config
+          ? inspectTypeScriptLaunch(serverName, config, root)
+          : {};
     return buildProjectServerInfo(
       {
+        ...selection,
+        failureMessage:
+          this.failedStarts.get(key)?.failureMessage ??
+          this.processCrashRecoveries.get(key)?.failureMessage ??
+          selection.failureMessage,
         serverName,
         root,
         fileTypes,
         client: this.clients.get(key),
-        unavailableReason:
-          this.getUnavailableReason(key, this.config.servers[serverName]?.command) ?? undefined,
+        unavailableReason: this.getUnavailableReason(key, serverName, root) ?? undefined,
         statusReason: this.processCrashRecoveries.get(key)?.statusReason,
         includeOpenFile: (file) => this.isAutomaticScopePath(file),
       },
@@ -1733,7 +1798,9 @@ export class LspManager {
     if (options.retryFailedRoute) {
       this.retireMissingProjectRoots();
       const route = this.resolveFileRoute(resolvedPath);
-      if (!route || !this.automaticPathPolicy.isEligible(route.root, "directory")) {
+      // Exact-file demand, including refresh, bypasses automatic discovery exclusions.
+      // Keep the original route identity for document synchronization and bounded retries.
+      if (!route) {
         return {
           client: null,
           processCrashRecovery: emptyProcessCrashRecoveryReport(),
@@ -2017,13 +2084,19 @@ export class LspManager {
 
     const serverConfig = this.config.servers[firstReady.name];
     if (serverConfig) {
-      const target = findWorkspaceSymbolWarmTargets(
+      // Candidates for the best-ranked marker root; later ones replace a probe
+      // that lands in an inferred project outside the configured program.
+      const targets = findWorkspaceSymbolWarmTargets(
         firstReady.root,
         serverConfig.rootMarkers,
         serverConfig.fileTypes,
         { policy: this.automaticPathPolicy },
-      )[0];
-      if (target) await this.warmSemanticProject(firstReady, target.file, false, control);
+      );
+      const primaryRoot = targets[0]?.projectRoot;
+      const files = targets
+        .filter((target) => target.projectRoot === primaryRoot)
+        .map((target) => target.file);
+      if (files.length > 0) await this.warmSemanticProject(firstReady, files, false, control);
       // The warm-up request can start server indexing after the initial
       // readiness wait resolves. Observe the resulting progress before
       // reporting the workspace as ready.
@@ -2866,7 +2939,20 @@ export class LspManager {
       return this.filterWorkspaceSymbolCollection(collection, resolvedScopes);
     };
     const initial = await collect(this.clients.values(), query);
-    if (!initial.hasSupport || initial.results.length > 0) {
+    // Allowed out-of-scope rows do not show that the server knows the scope yet.
+    const hasScopedResult = (collection: WorkspaceSymbolCollection) =>
+      collection.hasSupport &&
+      collection.results.some(
+        (result) =>
+          !resolvedScopes?.length ||
+          isWithinAnyScope(uriToFile(result.location.uri), resolvedScopes),
+      );
+    // Rows from a route whose warm-up reached only inferred projects may come
+    // from those files alone, so they cannot end the search early.
+    if (
+      !initial.hasSupport ||
+      (hasScopedResult(initial) && !this.hasInferredOnlyWarmRoute(routeMatches))
+    ) {
       return workspaceSymbolCollectionResult(initial);
     }
 
@@ -2878,11 +2964,32 @@ export class LspManager {
         }),
       getWarmPosition: getWorkspaceSymbolWarmPosition,
       collect,
+      hasResult: hasScopedResult,
       routeMatches,
       query,
       control,
     });
-    return workspaceSymbolCollectionResult(warmed.collection ?? initial);
+    const collection = warmed.collection ?? initial;
+    return workspaceSymbolCollectionResult(
+      warmed.coverageConfirmed
+        ? collection
+        : workspaceSymbolCoverageGap(collection, warmed.inferredProbeCount),
+    );
+  }
+
+  /** True when a matching route has inferred warm-up probes and no other probe. */
+  private hasInferredOnlyWarmRoute(routeMatches: (client: LspClient) => boolean): boolean {
+    return Array.from(this.clients.values()).some((client) => {
+      if (!routeMatches(client)) return false;
+      const prefix = `${client.name}:${path.resolve(client.root)}`;
+      let inferred = false;
+      for (const [key, membership] of this.warmedWorkspaceSymbolFiles) {
+        if (key !== prefix && !key.startsWith(`${prefix}${path.sep}`)) continue;
+        if (membership !== "inferred") return false;
+        inferred = true;
+      }
+      return inferred;
+    });
   }
 
   private addWorkspaceSymbolDemandEvidence(
@@ -2905,6 +3012,7 @@ export class LspManager {
     const results = collection.results.filter((result) => {
       const file = uriToFile(result.location.uri);
       if (this.isWorkspaceSymbolResultAllowed(file, scopes)) return true;
+      if (!this.isWorkspaceSymbolExclusionRelevant(file, scopes)) return false;
       excludedCount++;
       const example = displayRelativeFilePath(file, this.cwd);
       if (excludedExamples.size < 5) excludedExamples.add(example);
@@ -2918,6 +3026,26 @@ export class LspManager {
     };
   }
 
+  /** Only proven-disjoint exclusions can be omitted from scoped completeness. */
+  private isWorkspaceSymbolExclusionRelevant(
+    filePath: string,
+    scopes: readonly string[] | undefined,
+  ): boolean {
+    if (!scopes?.length || !path.isAbsolute(filePath)) return true;
+    if (scopes.some((scope) => projectRoots.isWithinOrEqual(scope, filePath))) return true;
+    try {
+      // Observed spellings and physical identities both matter: an excluded
+      // alias may point into scope even when its spelling is outside it.
+      const physicalFile = fs.realpathSync(filePath);
+      return scopes.some((scope) =>
+        projectRoots.isWithinOrEqual(fs.realpathSync(scope), physicalFile),
+      );
+    } catch {
+      // Missing, unreadable or otherwise unresolved paths cannot prove absence.
+      return true;
+    }
+  }
+
   /** Keep explicitly selected excluded scopes inspectable while filtering broad results. */
   private isWorkspaceSymbolResultAllowed(
     filePath: string,
@@ -3012,15 +3140,22 @@ export class LspManager {
     const client = await this.getClientForFile(resolvedPath, options);
     if (!client) return null;
     try {
-      const content = fs.readFileSync(resolvedPath, "utf-8");
-      // Route startup can be shared. The document open belongs to this
-      // caller, so check again after the shared wait before sending didOpen.
-      throwIfCodeRequestInterrupted(options.control);
-      client.didOpen(resolvedPath, content);
+      await client.openDocument(
+        resolvedPath,
+        () => {
+          try {
+            return fs.readFileSync(resolvedPath, "utf-8");
+          } catch (error) {
+            this.closeFile(resolvedPath);
+            throw error;
+          }
+        },
+        options.control,
+        options.protectInputs,
+      );
       return client;
     } catch (error) {
       if (isCodeRequestInterruption(error, options.control)) throw error;
-      this.closeFile(resolvedPath);
       return null;
     }
   }
@@ -3036,13 +3171,29 @@ export class LspManager {
       symbols: import("../config/types.ts").DocumentSymbol[] | SymbolInformation[] | null,
     ) => import("../config/types.ts").Position | null;
     collect: (clients: Iterable<LspClient>, query: string) => Promise<WorkspaceSymbolCollection>;
+    /** Stop warming once a collection contains a row that answers the request. */
+    hasResult: (collection: WorkspaceSymbolCollection) => boolean;
     routeMatches?: (client: LspClient) => boolean;
     query: string;
     control?: CodeRequestControl;
-  }): Promise<{ warmedAny: boolean; collection: WorkspaceSymbolCollection | null }> {
-    const { findWarmTargets, getWarmPosition, collect, routeMatches, query, control } = options;
-    let warmedAny = false;
+  }): Promise<{
+    collection: WorkspaceSymbolCollection | null;
+    /** False only when every probe the server classified landed in an inferred project. */
+    coverageConfirmed: boolean;
+    inferredProbeCount: number;
+  }> {
+    const { findWarmTargets, getWarmPosition, collect, hasResult, routeMatches, query, control } =
+      options;
     let latestCollection: WorkspaceSymbolCollection | null = null;
+    // A route with no inferred probe keeps today's evidence: non-TypeScript
+    // servers index the workspace, and `unknown` cannot prove a gap.
+    const routeCoverage: boolean[] = [];
+    let inferredProbeCount = 0;
+    const outcome = () => ({
+      collection: latestCollection,
+      coverageConfirmed: routeCoverage.every(Boolean),
+      inferredProbeCount,
+    });
 
     for (const client of Array.from(this.clients.values())) {
       if (routeMatches && !routeMatches(client)) continue;
@@ -3058,13 +3209,29 @@ export class LspManager {
         serverConfig.fileTypes,
       ).slice(0, 24);
 
+      // Marker roots whose program an earlier candidate already loaded.
+      const coveredRoots = new Set<string>();
+      let routeInferred = false;
       for (const target of warmTargets) {
+        if (coveredRoots.has(target.projectRoot)) continue;
         // A file probe does not load every program under the route root.
         const fileKey = `${client.name}:${path.resolve(target.file)}`;
-        if (this.warmedWorkspaceSymbolFiles.has(fileKey)) continue;
+        const previous = this.warmedWorkspaceSymbolFiles.get(fileKey);
+        if (previous === "inferred") {
+          routeInferred = true;
+          inferredProbeCount++;
+          continue;
+        }
+        if (previous !== undefined) {
+          coveredRoots.add(target.projectRoot);
+          continue;
+        }
 
-        const openedClient = await this.ensureFileOpen(target.file);
-        if (!openedClient) continue;
+        const openedClient = await this.ensureFileOpen(target.file, { control });
+        if (!openedClient) {
+          this.recordWarmProbeEvent(client.name, target.file, "open-failed", control);
+          continue;
+        }
 
         // A cancelled pass must not mark projects warmed on its way out.
         throwIfCodeRequestInterrupted(control);
@@ -3074,32 +3241,84 @@ export class LspManager {
           getWarmPosition,
           control,
         );
-        if (available) {
-          this.warmedWorkspaceSymbolFiles.add(fileKey);
-          warmedAny = true;
+        if (!available) {
+          this.recordWarmProbeEvent(client.name, target.file, "probe-unavailable", control);
+          continue;
+        }
+        const membership = await openedClient.projectMembership(target.file, control);
+        throwIfCodeRequestInterrupted(control);
+        this.warmedWorkspaceSymbolFiles.set(fileKey, membership);
+        this.recordWarmProbeEvent(client.name, target.file, membership, control);
+        if (membership === "inferred") {
+          // The file loaded only its own inferred project; workspace/symbol
+          // still cannot see the configured program, so try the next file
+          // without collecting: a hit here could come from that inferred
+          // project alone and would hide the configured program's rows.
+          routeInferred = true;
+          inferredProbeCount++;
+          continue;
         }
 
+        coveredRoots.add(target.projectRoot);
         latestCollection = await collect(this.clients.values(), query);
-        if (latestCollection.hasSupport && latestCollection.results.length > 0) {
-          return { warmedAny, collection: latestCollection };
+        if (hasResult(latestCollection)) {
+          return { ...outcome(), coverageConfirmed: true };
         }
       }
+      routeCoverage.push(coveredRoots.size > 0 || !routeInferred);
     }
 
+    if (inferredProbeCount > 0 && latestCollection === null) {
+      latestCollection = await collect(this.clients.values(), query);
+    }
     // A completed-empty retry replaces an earlier failure too.
-    return { warmedAny, collection: latestCollection };
+    return outcome();
+  }
+
+  /**
+   * Record one workspace-symbol warm-up probe: which file was opened and
+   * whether the server placed it in a configured project. `unknown` means the
+   * route cannot report membership (non-TypeScript or native TS7).
+   */
+  private recordWarmProbeEvent(
+    serverName: string,
+    file: string,
+    outcome: ProjectMembership | "open-failed" | "probe-unavailable",
+    control?: CodeRequestControl,
+  ): void {
+    try {
+      recordDebugEvent({
+        operationId: control?.operationId,
+        source: "lsp",
+        level: "debug",
+        category: "workspace-symbol.warm-probe",
+        message: `Workspace-symbol warm-up probe: ${outcome}`,
+        cwd: boundCwd(this.cwd),
+        data: {
+          server: truncateIdentity(serverName),
+          file: truncateIdentity(displayRelativeFilePath(file, this.cwd)),
+          outcome,
+        },
+      });
+    } catch {
+      // Warm-up telemetry must never change query behavior.
+    }
   }
 
   private async warmSemanticProject(
     client: LspClient,
-    filePath: string,
+    filePath: string | readonly string[],
     preferExactFile: boolean = false,
     control?: CodeRequestControl,
   ): Promise<void> {
     const serverConfig = this.config.servers[client.name];
     if (!serverConfig) return;
 
-    const resolvedFile = resolveSessionPath(this.cwd, filePath);
+    const candidates = (typeof filePath === "string" ? [filePath] : filePath).map((file) =>
+      resolveSessionPath(this.cwd, file),
+    );
+    const resolvedFile = candidates[0];
+    if (!resolvedFile) return;
     const projectRoot = preferExactFile
       ? resolveRootForFile(resolvedFile, client.name, serverConfig.rootMarkers, {
           knownRoots: this.knownRoots,
@@ -3117,7 +3336,7 @@ export class LspManager {
       return;
     }
 
-    const probe = this.performWarmProbe(client, resolvedFile, projectKey, control);
+    const probe = this.performWarmProbe(client, candidates, projectKey, control);
     this.pendingWarmProbes.set(projectKey, probe);
     try {
       await raceRequestControl(probe, control);
@@ -3128,28 +3347,40 @@ export class LspManager {
     }
   }
 
+  /**
+   * Probe candidates in order until one loads a non-inferred project.
+   * The project is marked warmed after any successful probe so files that
+   * really sit in inferred projects are not reprobed on every request.
+   */
   private async performWarmProbe(
     client: LspClient,
-    resolvedFile: string,
+    candidates: readonly 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 || 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 available = await this.probeDocumentSymbols(
-      openedClient,
-      resolvedFile,
-      getWorkspaceSymbolWarmPosition,
-      sharedControl,
-    );
-    if (available && this.clients.get(key) === client) {
+    let warmed = false;
+    for (const [index, resolvedFile] of candidates.entries()) {
+      if (this.clients.get(key) !== client) return;
+      const openedClient = await this.ensureFileOpen(resolvedFile);
+      if (!openedClient || openedClient !== client || this.clients.get(key) !== client) continue;
+      const available = await this.probeDocumentSymbols(
+        openedClient,
+        resolvedFile,
+        getWorkspaceSymbolWarmPosition,
+        sharedControl,
+      );
+      if (!available) continue;
+      warmed = true;
+      if (index === candidates.length - 1) break;
+      const membership = await openedClient.projectMembership(resolvedFile, sharedControl);
+      if (membership !== "inferred") break;
+    }
+    if (warmed && this.clients.get(key) === client) {
       this.warmedSemanticProjects.add(projectKey);
     }
   }
@@ -3180,7 +3411,7 @@ export class LspManager {
 
   private clearWarmedWorkspaceSymbolFiles(serverName: string, root: string): void {
     const prefix = `${serverName}:${path.resolve(root)}`;
-    for (const key of Array.from(this.warmedWorkspaceSymbolFiles)) {
+    for (const key of Array.from(this.warmedWorkspaceSymbolFiles.keys())) {
       if (key === prefix || key.startsWith(`${prefix}${path.sep}`)) {
         this.warmedWorkspaceSymbolFiles.delete(key);
       }

package/src/provider/refactor-planning.ts

@@ -87,8 +87,7 @@ export async function runFilteredCodeActionRefactor(options: {
   if (!response || response.reason) {
     return {
       kind: "unavailable",
-      reason:
-        response?.reason ?? `No code actions are available for refactor operation "${operation}".`,
+      reason: `Refactor operation "${operation}" is unavailable: ${response?.reason ?? "No code actions are available."}`,
     };
   }
   const actions = response.value;
@@ -136,7 +135,9 @@ export function isUpdateImportsCodeAction(action: CodeAction): boolean {
 
 export function isDeleteDeadCodeCodeAction(action: CodeAction): boolean {
   const kind = typeof action?.kind === "string" ? action.kind : "";
-  return kind === "source.removeUnused" || kind.startsWith("source.removeUnused.");
+  return codeActionKindsForOperation("delete_dead_code").some(
+    (requested) => kind === requested || kind.startsWith(`${requested}.`),
+  );
 }
 
 interface PreciseCodeActionPlan {

package/src/session/runtime-controller.ts

@@ -519,8 +519,8 @@ export class LspRuntimeController {
     return this.#configurationError;
   }
 
-  /** Get the missing servers warning (servers whose binary is not on PATH). */
-  getMissingServers(): Array<{ name: string; command: string }> {
+  /** Report missing executables and root-specific compiler selection failures. */
+  getMissingServers(): ReturnType<typeof scanMissingServers> {
     if (this.#state.kind !== "ready") return [];
     return scanMissingServers(
       this.#state.config,