@mrclrchtr/supi-lsp 11.1.0 → 11.2.0

package/src/config/config.ts

@@ -3,10 +3,16 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
-import { loadSupiConfigForScope, loadSupiConfigSectionForScope } from "@mrclrchtr/supi-core/config";
+import {
+  getSupiConfigPath,
+  loadSupiConfigForScope,
+  loadSupiConfigSectionForScope,
+} from "@mrclrchtr/supi-core/config";
 import { truncateDebugIdentity } from "@mrclrchtr/supi-core/debug";
 import type { JsonObject, JsonValue, LspConfig, ServerConfig } from "./types.ts";
 
+import { isManualTypeScriptLaunch, isTypeScriptPackageName } from "./typescript-launch.ts";
+
 const CONFIG_DIR = path.dirname(fileURLToPath(import.meta.url));
 
 // Load defaults at module level — resolve relative to this file.
@@ -65,11 +71,47 @@ export function loadConfig(cwd: string, options?: LoadConfigOptions): LspConfig
           { scope: "project" },
         );
 
+  const fields: NonNullable<ServerConfig["typescriptExplicitFields"]> = {};
+  for (const [scope, servers] of [
+    ["global", globalLsp.servers],
+    ["project", projectLsp.servers],
+  ] as const) {
+    captureTypeScriptOrigins(fields, servers?.typescript, getSupiConfigPath(scope, cwd, options));
+  }
   const merged = mergeServerConfigs(defaults.servers, globalLsp.servers, projectLsp.servers);
-
+  if (merged.typescript) {
+    merged.typescript = { ...merged.typescript, typescriptExplicitFields: fields };
+    isManualTypeScriptLaunch(merged.typescript, cwd);
+  }
   return { servers: merged };
 }
 
+/** Retain only effective explicit launch fields; initializationOptions replaces its inherited object. */
+function captureTypeScriptOrigins(
+  fields: NonNullable<ServerConfig["typescriptExplicitFields"]>,
+  value: unknown,
+  origin: string,
+): void {
+  if (!isRecord(value)) return;
+  if (
+    Object.hasOwn(value, "typescriptPackage") &&
+    !isTypeScriptPackageName(value.typescriptPackage)
+  ) {
+    throw new Error(
+      `Invalid lsp.servers.typescript.typescriptPackage in ${origin}: use an installed package name or alias, not a path.`,
+    );
+  }
+  const { override } = validateServerOverride(value);
+  for (const field of ["command", "args", "typescriptPackage"] as const) {
+    if (Object.hasOwn(override, field)) fields[field] = origin;
+  }
+  if (!Object.hasOwn(override, "initializationOptions")) return;
+  delete fields.tsserverPath;
+  const init = override.initializationOptions;
+  if (isRecord(init) && isRecord(init.tsserver) && Object.hasOwn(init.tsserver, "path"))
+    fields.tsserverPath = origin;
+}
+
 /**
  * Read effective explicit language disablement for the active LSP snapshot.
  * Project values override global values, including an explicit re-enable.
@@ -205,6 +247,10 @@ function mergeSingleServer(options: {
 }): ServerConfig | null {
   const { name, base, value, builtIn, reportWarning } = options;
   const { override, invalidFields } = validateServerOverride(value);
+  if (name !== "typescript" && override.typescriptPackage !== undefined) {
+    delete override.typescriptPackage;
+    invalidFields.push("typescriptPackage");
+  }
   const missingFields = base
     ? []
     : [
@@ -232,6 +278,11 @@ function mergeSingleServer(options: {
 type ServerOverrideSetter = (override: Partial<ServerConfig>, candidate: unknown) => boolean;
 
 const SERVER_OVERRIDE_SETTERS: Record<string, ServerOverrideSetter> = {
+  typescriptPackage(override, candidate) {
+    if (!isTypeScriptPackageName(candidate)) return false;
+    override.typescriptPackage = candidate;
+    return true;
+  },
   command(override, candidate) {
     if (typeof candidate !== "string" || candidate.trim().length === 0) return false;
     override.command = candidate;

package/src/config/operation-support.ts

@@ -26,12 +26,15 @@ export type ServerOperationSupportMap = Partial<
   Record<ServerOperationName, ServerOperationSupport>
 >;
 
+const REMOVE_UNUSED_KIND = "source.removeUnused";
+const REMOVE_UNUSED_IMPORTS_KIND = "source.removeUnusedImports";
+
 /** Code-action kinds requested by each operation-specific planner. */
 export const REFACTOR_CODE_ACTION_KINDS = {
   extract_function: ["refactor.extract.function"],
   extract_variable: ["refactor.extract.constant", "refactor.extract.variable"],
   update_imports: ["source.organizeImports"],
-  delete_dead_code: ["source.removeUnused"],
+  delete_dead_code: [REMOVE_UNUSED_KIND, REMOVE_UNUSED_IMPORTS_KIND],
 } as const satisfies Record<
   "extract_function" | "extract_variable" | "update_imports" | "delete_dead_code",
   readonly string[]
@@ -143,6 +146,20 @@ function supportedOperation(
   return { server, supi, ...(reason ? { reason } : {}) };
 }
 
+function deleteDeadCodeSupport(capabilities: ServerCapabilities | null): ServerOperationSupport {
+  const server = codeActionAdvertisement(capabilities, REFACTOR_CODE_ACTION_KINDS.delete_dead_code);
+  const importsOnly =
+    codeActionAdvertisement(capabilities, [REMOVE_UNUSED_KIND]) !== "advertised" &&
+    codeActionAdvertisement(capabilities, [REMOVE_UNUSED_IMPORTS_KIND]) === "advertised";
+  return importsOnly
+    ? supportedOperation(
+        server,
+        "limited",
+        "Only unused-import removal is supported by this mapping, not arbitrary unused declarations.",
+      )
+    : supportedOperation(server);
+}
+
 /** Build the honest operation-support projection for one negotiated server. */
 export function getServerOperationSupport(
   capabilities: ServerCapabilities | null,
@@ -181,9 +198,7 @@ export function getServerOperationSupport(
     update_imports: supportedOperation(
       codeActionAdvertisement(capabilities, REFACTOR_CODE_ACTION_KINDS.update_imports),
     ),
-    delete_dead_code: supportedOperation(
-      codeActionAdvertisement(capabilities, REFACTOR_CODE_ACTION_KINDS.delete_dead_code),
-    ),
+    delete_dead_code: deleteDeadCodeSupport(capabilities),
     code_action_resolve: supportedOperation(resolveServer),
   };
 }

package/src/config/server-config.ts

@@ -26,6 +26,20 @@ export interface ServerConfig {
   initializationOptions?: unknown;
   /** Maximum time to wait for a single $/progress cycle, in ms. Default: 10_000. */
   readinessTimeoutMs?: number;
+  /** TypeScript compiler package name or installed alias, resolved from the route root. */
+  typescriptPackage?: string;
+  /** @internal Effective explicit-field origins for TypeScript launch policy, not user configuration. */
+  typescriptExplicitFields?: Partial<
+    Record<"command" | "args" | "tsserverPath" | "typescriptPackage", string>
+  >;
+}
+
+/** Compiler selection facts; absent versions are unknown, not inferred from the wrapper. */
+export interface TypeScriptSelection {
+  backend: "tsserver" | "native";
+  packageName: string;
+  compilerVersion?: string;
+  wrapperVersion?: string;
 }
 
 /** LSP configuration keyed by language name (e.g. `typescript`, `python`). */
@@ -37,6 +51,10 @@ export interface DetectedProjectServer {
   name: string;
   root: string;
   fileTypes: string[];
+  /** Resolved automatic compiler selection, when available. */
+  typescript?: TypeScriptSelection;
+  /** Actionable launch-selection failure, including its root and package. */
+  failureMessage?: string;
 }
 
 /** Structured reason for a route-level process-crash recovery state. */
@@ -64,4 +82,8 @@ export interface MissingServer {
   command: string;
   /** File extensions found in the project (subset of server.fileTypes). */
   foundExtensions: string[];
+  /** Route root when a compiler-selection failure prevents launch. */
+  root?: string;
+  /** Compiler selection failure, distinct from a missing executable. */
+  failureMessage?: string;
 }

package/src/config/typescript-launch.ts

@@ -0,0 +1,276 @@
+import * as fs from "node:fs";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import { major, prerelease, valid } from "semver";
+import type { ServerConfig, TypeScriptSelection } from "./server-config.ts";
+
+interface CompilerPackage {
+  directory: string;
+  name?: string;
+  version?: string;
+  bin?: unknown;
+}
+
+/** Launch options and truthful compiler facts for one root; never cached across starts. */
+export interface TypeScriptLaunch {
+  /** Native packages use their declared Node launcher, without a PATH dependency. */
+  command?: string;
+  args?: string[];
+  initializationOptions: unknown;
+  typescript?: TypeScriptSelection;
+}
+
+/** Retain already-known selection facts when validating launch files fails. */
+class TypeScriptLaunchError extends Error {
+  readonly typescript: TypeScriptSelection | undefined;
+  constructor(message: string, options: ErrorOptions & { typescript?: TypeScriptSelection }) {
+    super(message, options);
+    this.typescript = options.typescript;
+  }
+}
+
+/** True for an installed package name/alias, never a path, URL, or package subpath. */
+export function isTypeScriptPackageName(value: unknown): value is string {
+  return (
+    typeof value === "string" &&
+    /^(?:@[a-z0-9._-]+\/)?[a-z0-9_][a-z0-9._-]*$/i.test(value) &&
+    ![".", ".."].includes(value)
+  );
+}
+
+function record(value: unknown): Record<string, unknown> | undefined {
+  return value !== null && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : undefined;
+}
+
+/** Resolve fresh package files using Node's root-relative node_modules search paths.
+ * Probing the package directory (rather than require.resolve's cached realpath) both
+ * detects broken selections and observes package-manager symlink changes on retry.
+ * Package exports need not expose package.json; no compiler code is executed.
+ */
+function findPackage(name: string, from: string): CompilerPackage | undefined {
+  const require = createRequire(path.join(from, "__supi_lsp_resolve__.cjs"));
+  for (const base of require.resolve.paths(name) ?? []) {
+    const directory = path.join(base, name);
+    try {
+      fs.lstatSync(directory);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") continue;
+      throw error;
+    }
+    return readCompilerPackage(fs.realpathSync(directory));
+  }
+  return undefined;
+}
+
+function readCompilerPackage(directory: string): CompilerPackage {
+  const manifest = record(
+    JSON.parse(fs.readFileSync(path.join(directory, "package.json"), "utf8")),
+  );
+  if (
+    !manifest ||
+    (manifest.name !== undefined && typeof manifest.name !== "string") ||
+    (manifest.version !== undefined &&
+      (typeof manifest.version !== "string" || !valid(manifest.version)))
+  ) {
+    throw new Error(`Invalid package manifest at ${directory}`);
+  }
+  return {
+    directory,
+    name: typeof manifest.name === "string" ? manifest.name : undefined,
+    version: typeof manifest.version === "string" ? manifest.version : undefined,
+    bin: manifest.bin,
+  };
+}
+
+/** Apply the bounded TypeScript compiler policy without changing the settings snapshot.
+ * Programmatic configurations without loader provenance remain manual. Explicit
+ * launch fields bypass all package probing; a selector may not coexist with them.
+ */
+export function resolveTypeScriptLaunch(
+  name: string,
+  config: ServerConfig,
+  root: string,
+): TypeScriptLaunch {
+  const unchanged = { initializationOptions: config.initializationOptions };
+  if (name !== "typescript") return unchanged;
+  if (isManualTypeScriptLaunch(config, root)) return unchanged;
+  const selector = config.typescriptPackage;
+  let selected = selector ?? "typescript";
+  try {
+    if (!isTypeScriptPackageName(selected))
+      throw new Error("Expected an installed package name or alias, not a filesystem path.");
+    const probe = (installedName: string) => {
+      selected = installedName; // Retain the failing candidate's identity for the error.
+      return findPackage(installedName, root);
+    };
+    const selection =
+      selector === undefined ? selectAutomaticCompiler(probe) : { selected, pkg: probe(selected) };
+    const { pkg } = selection;
+    selected = selection.selected;
+    if (!pkg) {
+      if (selector !== undefined) throw new Error("Selected package is not installed.");
+      return unchanged; // Preserve TLS's legacy lookup when neither candidate exists.
+    }
+    return compilerLaunch(config.initializationOptions, pkg, selected);
+  } catch (error) {
+    throw new TypeScriptLaunchError(
+      `TypeScript launch at ${root}, package "${selected}": ${error instanceof Error ? error.message : String(error)} Repair/install the selected TypeScript package, or use explicit launch configuration; then refresh health. Reload after changing launch settings.`,
+      {
+        cause: error,
+        typescript: error instanceof TypeScriptLaunchError ? error.typescript : undefined,
+      },
+    );
+  }
+}
+
+/** Short-circuit on native metadata; validate only the winner's launch files later. */
+function selectAutomaticCompiler(probe: (name: string) => CompilerPackage | undefined): {
+  selected: string;
+  pkg?: CompilerPackage;
+} {
+  const canonical = probe("typescript");
+  if (canonical && compilerBackend(canonical) === "native")
+    return { selected: "typescript", pkg: canonical };
+  const native = probe("@typescript/native");
+  if (native) {
+    if (compilerBackend(native) !== "native")
+      throw new Error("@typescript/native must alias the stable native typescript package.");
+    return { selected: "@typescript/native", pkg: native };
+  }
+  if (canonical) return { selected: "typescript", pkg: canonical };
+  return { selected: "@typescript/typescript6", pkg: probe("@typescript/typescript6") };
+}
+
+/** Determine launch authority and reject conflicting selectors without probing installations. */
+export function isManualTypeScriptLaunch(config: ServerConfig, root: string): boolean {
+  const fields = config.typescriptExplicitFields ?? { command: "programmatic configuration" };
+  const tsserver = record(record(config.initializationOptions)?.tsserver);
+  const conflicts = [
+    ...(fields.command ? [`command (${fields.command})`] : []),
+    ...(fields.args ? [`args (${fields.args})`] : []),
+    ...(tsserver && Object.hasOwn(tsserver, "path")
+      ? [
+          `initializationOptions.tsserver.path (${fields.tsserverPath ?? "programmatic configuration"})`,
+        ]
+      : []),
+  ];
+  if (config.typescriptPackage !== undefined && conflicts.length) {
+    throw new Error(
+      `TypeScript launch at ${root}: typescriptPackage "${config.typescriptPackage}" (${fields.typescriptPackage ?? "programmatic configuration"}) conflicts with ${conflicts.join(", ")}. Remove the selector or the explicit launch fields and reload.`,
+    );
+  }
+  return conflicts.length > 0;
+}
+
+/** Classify consulted metadata before considering a lower-priority candidate. */
+function compilerBackend(pkg: CompilerPackage): "native" | "tsserver" {
+  if (pkg.name === "@typescript/typescript6" && !pkg.version) return "tsserver";
+  if (pkg.name === "typescript" && !pkg.version)
+    throw new Error(
+      `Selected implementation at ${pkg.directory} has no compiler version in package.json.`,
+    );
+  const version = pkg.version && !prerelease(pkg.version) ? major(pkg.version) : undefined;
+  if (pkg.name === "@typescript/typescript6" && version === 6) return "tsserver";
+  if (pkg.name === "typescript" && version !== undefined && version <= 7)
+    return version === 7 ? "native" : "tsserver";
+  throw new Error(
+    `Unsupported automatic TypeScript backend ${pkg.name ?? "(unknown identity)"} ${pkg.version ?? "(unknown version)"}. Select an installed stable TS7 or legacy TypeScript package with typescriptPackage, or configure command/args manually.`,
+  );
+}
+
+function compilerLaunch(
+  initializationOptions: unknown,
+  selectedPackage: CompilerPackage,
+  selected: string,
+): TypeScriptLaunch {
+  let pkg = selectedPackage;
+  const backend = compilerBackend(pkg);
+  if (backend === "native") return nativeLaunch(initializationOptions, pkg, selected);
+  const wrapper = pkg.name === "@typescript/typescript6" ? pkg : undefined;
+  if (wrapper) {
+    const underlying = findPackage("@typescript/old", wrapper.directory);
+    if (!underlying)
+      throw new Error(`Wrapper at ${wrapper.directory} has no @typescript/old dependency.`);
+    pkg = underlying;
+  }
+  // TLS ignores an explicit path without implementation version metadata and
+  // tries other installations. Fail here rather than report a compiler it won't use.
+  if (!pkg.version)
+    throw new Error(
+      `Selected implementation at ${pkg.directory} has no compiler version in package.json; TLS would ignore this selection.`,
+    );
+  if (compilerBackend(pkg) !== "tsserver" || pkg.name !== "typescript")
+    throw new Error(`Wrapper implementation at ${pkg.directory} must be legacy TypeScript.`);
+  const serverPath = path.join(pkg.directory, "lib/tsserver.js");
+  if (!fs.statSync(serverPath).isFile()) throw new Error(`No tsserver.js at ${serverPath}.`);
+  const options = record(initializationOptions);
+  const tsserver = record(options?.tsserver);
+  return {
+    initializationOptions: { ...options, tsserver: { ...tsserver, path: serverPath } },
+    typescript: {
+      backend: "tsserver",
+      packageName: selected,
+      compilerVersion: pkg.version,
+      ...(wrapper?.version ? { wrapperVersion: wrapper.version } : {}),
+    },
+  };
+}
+
+function nativeLaunch(
+  initializationOptions: unknown,
+  pkg: CompilerPackage,
+  selected: string,
+): TypeScriptLaunch {
+  const typescript: TypeScriptSelection = {
+    backend: "native",
+    packageName: selected,
+    compilerVersion: pkg.version,
+  };
+  try {
+    return {
+      command: process.execPath,
+      args: [nativeLauncher(pkg), "--lsp", "--stdio"],
+      initializationOptions,
+      typescript,
+    };
+  } catch (error) {
+    throw new TypeScriptLaunchError(error instanceof Error ? error.message : String(error), {
+      cause: error,
+      typescript,
+    });
+  }
+}
+
+function nativeLauncher(pkg: CompilerPackage): string {
+  const executable = record(pkg.bin)?.tsc;
+  if (typeof executable !== "string" || !executable || path.isAbsolute(executable))
+    throw new Error(
+      `Native package at ${pkg.directory} must declare a relative bin.tsc executable.`,
+    );
+  const launcher = path.resolve(pkg.directory, executable);
+  const relative = path.relative(pkg.directory, launcher);
+  if (relative === ".." || relative.startsWith(`..${path.sep}`) || !fs.statSync(launcher).isFile())
+    throw new Error(`Invalid native tsc executable at ${launcher}.`);
+  return launcher;
+}
+
+/** Non-throwing selection probe shared by discovery and missing-server reporting. */
+export function inspectTypeScriptLaunch(
+  name: string,
+  config: ServerConfig,
+  root: string,
+): Pick<TypeScriptLaunch, "typescript"> & { command: string; failureMessage?: string } {
+  try {
+    const { command, typescript } = resolveTypeScriptLaunch(name, config, root);
+    return { command: command ?? config.command, ...(typescript ? { typescript } : {}) };
+  } catch (error) {
+    const typescript = error instanceof TypeScriptLaunchError ? error.typescript : undefined;
+    return {
+      command: typescript?.backend === "native" ? process.execPath : config.command,
+      ...(typescript ? { typescript } : {}),
+      failureMessage: error instanceof Error ? error.message : String(error),
+    };
+  }
+}

package/src/manager/manager-project-info.ts

@@ -1,6 +1,10 @@
 import type { LspClient } from "../client/client.ts";
 import { getServerOperationSupport } from "../config/operation-support.ts";
-import type { ProjectServerInfo, ProjectServerStatusReason } from "../config/server-config.ts";
+import type {
+  ProjectServerInfo,
+  ProjectServerStatusReason,
+  TypeScriptSelection,
+} from "../config/server-config.ts";
 import { displayRelativeFilePath } from "../summary.ts";
 
 interface ProjectServerInfoInput {
@@ -10,29 +14,37 @@ interface ProjectServerInfoInput {
   client: LspClient | undefined;
   unavailableReason?: "missing-command" | "start-failed" | "runtime-error";
   statusReason?: ProjectServerStatusReason;
+  typescript?: TypeScriptSelection;
+  failureMessage?: string;
   /** Filter files from ambient project status without changing explicit routing. */
   includeOpenFile?: (file: string) => boolean;
 }
 
+function projectStatus(input: ProjectServerInfoInput): ProjectServerInfo["status"] {
+  if (input.statusReason || input.failureMessage) return "error";
+  if (input.client?.status === "running") return "running";
+  if (
+    input.client?.status === "error" ||
+    input.unavailableReason === "start-failed" ||
+    input.unavailableReason === "runtime-error"
+  )
+    return "error";
+  return "unavailable";
+}
+
 export function buildProjectServerInfo(
   input: ProjectServerInfoInput,
   cwd: string,
 ): ProjectServerInfo {
-  const status = input.statusReason
-    ? "error"
-    : input.client?.status === "running"
-      ? "running"
-      : input.client?.status === "error" || input.unavailableReason === "start-failed"
-        ? "error"
-        : input.unavailableReason === "runtime-error"
-          ? "error"
-          : "unavailable";
+  const status = projectStatus(input);
 
   return {
     name: input.serverName,
     root: input.root,
     fileTypes: input.fileTypes,
     status,
+    ...(input.typescript ? { typescript: input.typescript } : {}),
+    ...(input.failureMessage ? { failureMessage: input.failureMessage } : {}),
     ...(input.statusReason ? { statusReason: input.statusReason } : {}),
     openFiles:
       input.client?.openFiles

package/src/manager/manager.ts

@@ -48,6 +48,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,
@@ -437,8 +438,12 @@ export class LspManager {
   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 +522,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 +586,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);
@@ -1460,22 +1473,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);
@@ -1659,14 +1680,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),
       },

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,