@ian-pascoe/pi-lsp 0.1.0 → 0.2.0

package/src/lsp-workspace-edit.ts

@@ -1,4 +1,4 @@
-import { createHash, randomUUID } from "node:crypto";
+import { randomUUID } from "node:crypto";
 import {
   chmod,
   lstat,
@@ -27,6 +27,12 @@ import {
   convertLspProtocolPosition,
   normalizeLspPositionEncoding,
 } from "./lsp-position-encoding.js";
+import {
+  FileSnapshotSchema,
+  LspWorkspaceEditPreviewRecordSchema,
+  WorkspaceEditOperationSchema,
+} from "./lsp-tool-contract.js";
+import type { Static } from "typebox";
 
 const UTF8_BOM = Buffer.from([0xef, 0xbb, 0xbf]);
 const UTF8_DECODER = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
@@ -48,63 +54,19 @@ export interface LspMutationManifest {
   readonly entries: readonly LspMutationManifestEntry[];
 }
 
-type FileSnapshot =
-  | { readonly kind: "missing" }
-  | {
-      readonly kind: "file";
-      readonly content_base64: string;
-      readonly hash: string;
-      readonly mode: number;
-    }
-  | { readonly kind: "symlink"; readonly link_target: string; readonly mode: number };
-
-type ModifyOperation = {
-  readonly kind: "modify";
-  readonly named_path: string;
-  readonly path: string;
-  readonly named_before: FileSnapshot;
-  readonly before: FileSnapshot;
-  after_base64: string;
-  readonly mode: number;
-};
+/** Canonical pre-mutation snapshot of one filesystem path used by guarded rollback. */
+type FileSnapshot = Static<typeof FileSnapshotSchema>;
 
-type CreateOperation = {
-  readonly kind: "create";
-  readonly named_path: string;
-  readonly before: FileSnapshot;
-  after_base64: string;
-  readonly mode: number;
-};
+/** Schema-derived operation with a writable `after_base64` for incremental document edits. */
+type Writable<T> = { -readonly [K in keyof T]: T[K] };
+type EditableOperation = Writable<
+  Extract<Static<typeof WorkspaceEditOperationSchema>, { kind: "modify" | "create" }>
+>;
 
-type DeleteOperation = {
-  readonly kind: "delete";
-  readonly named_path: string;
-  readonly before: Exclude<FileSnapshot, { readonly kind: "missing" }>;
-};
-
-type RenameOperation = {
-  readonly kind: "rename";
-  readonly named_path: string;
-  readonly destination_path: string;
-  readonly before: Exclude<FileSnapshot, { readonly kind: "missing" }>;
-  readonly destination_before: FileSnapshot;
-};
-
-type NormalizedWorkspaceOperation =
-  | ModifyOperation
-  | CreateOperation
-  | DeleteOperation
-  | RenameOperation;
+type NormalizedWorkspaceOperation = Static<typeof WorkspaceEditOperationSchema>;
 
 /** Schema-friendly preview record persisted in LSP tool result details. */
-export interface LspWorkspaceEditPreview {
-  readonly kind: "workspace_edit_preview";
-  readonly preview_id: string;
-  readonly server_id: string;
-  readonly summary: string;
-  readonly state: "available" | "applied";
-  readonly operations: readonly NormalizedWorkspaceOperation[];
-}
+type LspWorkspaceEditPreview = Static<typeof LspWorkspaceEditPreviewRecordSchema>;
 
 /** Result of one guarded Workspace Edit application. */
 export interface LspWorkspaceEditApplyResult {
@@ -164,8 +126,6 @@ type WorkspaceEditErrorCode =
 
 /** Expected preview normalization, validation, apply, or rollback failure. */
 export class LspWorkspaceEditError extends Error {
-  readonly _tag = "LspWorkspaceEditError" as const;
-
   /** Construct a stable Workspace Edit failure with optional unrecovered paths. */
   constructor(
     readonly code: WorkspaceEditErrorCode,
@@ -194,16 +154,6 @@ interface DecodedUtf8Document {
   readonly text: string;
 }
 
-/** Counts accepted and rejected persisted Workspace Edit Preview records. */
-export interface LspWorkspaceEditReplayResult {
-  readonly accepted: number;
-  readonly rejected: number;
-}
-
-function hashContents(contents: Buffer): string {
-  return createHash("sha256").update(contents).digest("hex");
-}
-
 function contentsFromSnapshot(snapshot: FileSnapshot): Buffer {
   if (snapshot.kind !== "file") {
     throw new LspWorkspaceEditError("invalid_destination", "expected a regular file");
@@ -236,7 +186,6 @@ async function snapshotNamedPath(path: string): Promise<FileSnapshot> {
   return {
     kind: "file",
     content_base64: contents.toString("base64"),
-    hash: hashContents(contents),
     mode,
   };
 }
@@ -424,10 +373,6 @@ async function restorePath(
   await symlink(snapshot.link_target, path);
 }
 
-function mutablePreview(preview: LspWorkspaceEditPreview): LspWorkspaceEditPreview {
-  return structuredClone(preview);
-}
-
 /** Own persisted Workspace Edit Preview state and guarded one-use application. */
 export class LspWorkspaceEditStore {
   private readonly previews = new Map<string, LspWorkspaceEditPreview>();
@@ -446,7 +391,7 @@ export class LspWorkspaceEditStore {
   /** Normalize and persist one language-server Workspace Edit without mutating files. */
   async createPreview(input: CreateWorkspaceEditPreviewInput): Promise<LspWorkspaceEditPreview> {
     const operations: NormalizedWorkspaceOperation[] = [];
-    const editableOperations = new Map<string, ModifyOperation | CreateOperation>();
+    const editableOperations = new Map<string, EditableOperation>();
     const resourceActions = new Map<string, string>();
     const destinations = new Set<string>();
     const encoding = input.positionEncoding ?? "utf-16";
@@ -500,7 +445,7 @@ export class LspWorkspaceEditStore {
       const current = contentsFromSnapshot(before);
       const decoded = decodeUtf8(current, targetPath);
       const after = encodeUtf8(applyTextEdits(decoded.text, edits, encoding), decoded.bom);
-      const operation: ModifyOperation = {
+      const operation: EditableOperation = {
         kind: "modify",
         named_path: namedPath,
         path: targetPath,
@@ -540,7 +485,7 @@ export class LspWorkspaceEditStore {
             `create destination exists: ${path}`,
           );
         }
-        const operation: CreateOperation = {
+        const operation: EditableOperation = {
           kind: "create",
           named_path: path,
           before,
@@ -649,18 +594,16 @@ export class LspWorkspaceEditStore {
   }
 
   /** Rebuild branch-local available/applied preview state from persisted tool result records. */
-  replayPreviewRecords(records: readonly LSPAny[]): LspWorkspaceEditReplayResult {
-    let accepted = 0;
+  replayPreviewRecords(records: readonly LSPAny[]): number {
     let rejected = 0;
     for (const record of records) {
       if (!isWorkspaceEditPreview(record)) {
         rejected++;
         continue;
       }
-      this.previews.set(record.preview_id, mutablePreview(record));
-      accepted++;
+      this.previews.set(record.preview_id, structuredClone(record));
     }
-    return { accepted, rejected };
+    return rejected;
   }
 
   /** Revalidate and apply one preview inside every sorted canonical mutation queue. */

package/src/pi-lsp-extension.ts

@@ -1,11 +1,8 @@
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import {
-  DEFAULT_MAX_BYTES,
-  DEFAULT_MAX_LINES,
   getAgentDir,
   SettingsManager,
-  truncateHead,
   type ExtensionAPI,
   type ExtensionContext,
   type ExtensionFactory,
@@ -14,13 +11,16 @@ import {
 } from "@earendil-works/pi-coding-agent";
 import { type Static, Type } from "typebox";
 import { Value } from "typebox/value";
-import { PositionEncodingKind, type Diagnostic } from "vscode-languageserver-protocol/node";
 import {
-  appendPiPostEditDiagnostics,
+  DocumentDiagnosticRequest,
+  PositionEncodingKind,
+  type Diagnostic,
+} from "vscode-languageserver-protocol/node";
+import {
+  appendPostEditDiagnostics,
   type PostEditDiagnosticOutcome,
   type PostEditDiagnosticPath,
   type PostEditDiagnosticsResultPatch,
-  type PostEditDiagnosticsRunner,
 } from "./lsp-post-edit-diagnostics.js";
 import {
   createPostEditDiagnosticsEntryData,
@@ -41,6 +41,7 @@ import {
   type LspWorkspaceEditPreviewRecord,
 } from "./lsp-tool-contract.js";
 import { registerLspTool } from "./lsp-tool.js";
+import { truncateLspOutputText } from "./lsp-tool-output.js";
 import { LspWorkspaceEditStore } from "./lsp-workspace-edit.js";
 import { resolveLspSettings } from "./pi-lsp-settings.js";
 
@@ -139,13 +140,13 @@ function failureDiagnosticOutcome(
   return { kind: "unavailable_server", path, serverId: failure.serverId };
 }
 
-class ManagerPostEditDiagnosticsRunner implements PostEditDiagnosticsRunner {
+class ManagerPostEditDiagnosticsRunner {
   constructor(
     private readonly session: ActivePiLspSession,
     private readonly signal: AbortSignal | undefined,
   ) {}
 
-  async runPostEditDiagnostics(
+  async run(
     paths: readonly PostEditDiagnosticPath[],
   ): Promise<readonly PostEditDiagnosticOutcome[]> {
     const outcomes: PostEditDiagnosticOutcome[] = [];
@@ -154,7 +155,7 @@ class ManagerPostEditDiagnosticsRunner implements PostEditDiagnosticsRunner {
       const result = await this.session.manager.runRead(
         filePath,
         undefined,
-        () => true,
+        (client) => client.hasCapability(DocumentDiagnosticRequest.method),
         async (client, route): Promise<readonly PostEditDiagnosticOutcome[]> => {
           const diagnostics = await client.documentDiagnostics(
             filePath,
@@ -185,7 +186,13 @@ class ManagerPostEditDiagnosticsRunner implements PostEditDiagnosticsRunner {
       const successfulOutcomes = result.successes.flatMap(({ value }) => value);
       outcomes.push(...successfulOutcomes);
       outcomes.push(
-        ...result.failures.map((failure) => failureDiagnosticOutcome(filePath, failure)),
+        ...result.failures.flatMap((failure) =>
+          failure.code === "no-capable-server" ||
+          (failure.code === "no-matching-server" &&
+            this.session.manager.hasConfiguredLanguageServerForFile(filePath))
+            ? []
+            : [failureDiagnosticOutcome(filePath, failure)],
+        ),
       );
     }
     return outcomes;
@@ -197,24 +204,20 @@ async function appendSessionPostEditDiagnostics(
   session: ActivePiLspSession,
   context: ExtensionContext,
 ): Promise<PostEditDiagnosticsResultPatch | undefined> {
-  const patch = await appendPiPostEditDiagnostics(
-    event,
-    new ManagerPostEditDiagnosticsRunner(session, context.signal),
+  const patch = await appendPostEditDiagnostics(event, (paths) =>
+    new ManagerPostEditDiagnosticsRunner(session, context.signal).run(paths),
   );
   if (patch === undefined) return undefined;
   const appendedValue = patch.content.at(-1);
   if (!Value.Check(AppendedTextContentSchema, appendedValue)) return undefined;
   let appended: Static<typeof AppendedTextContentSchema> = appendedValue;
-  const truncation = truncateHead(appended.text, {
-    maxBytes: DEFAULT_MAX_BYTES,
-    maxLines: DEFAULT_MAX_LINES,
-  });
-  if (truncation.truncated) {
-    const spillPath = await session.sessionFiles.writeResultSpill(appended.text);
-    appended = {
-      type: "text",
-      text: `${truncation.content}\n\n[Pi LSP: diagnostics truncated; complete Result Spill: ${spillPath}]`,
-    };
+  const truncation = await truncateLspOutputText(
+    appended.text,
+    session.sessionFiles,
+    "diagnostics",
+  );
+  if (truncation.spillPath !== undefined) {
+    appended = { type: "text", text: truncation.text };
   }
   const partialApplyFailure =
     event.toolName === "lsp" &&
@@ -270,9 +273,9 @@ export class PiLspLifecycleController {
     const replay = workspaceEdits.replayPreviewRecords(
       branchLspToolResultDetails(context.sessionManager.getBranch()),
     );
-    if (replay.rejected > 0) {
+    if (replay > 0) {
       context.ui.notify(
-        `Pi LSP ignored ${replay.rejected} invalid Workspace Edit Preview record${replay.rejected === 1 ? "" : "s"} on the active session branch.`,
+        `Pi LSP ignored ${replay} invalid Workspace Edit Preview record${replay === 1 ? "" : "s"} on the active session branch.`,
         "warning",
       );
     }

package/src/pi-lsp-settings.ts

@@ -12,6 +12,7 @@ const DEFAULT_LSP_TIMEOUTS = {
 const NonEmptyStringSchema = Type.String({ minLength: 1 });
 const PositiveMillisecondsSchema = Type.Integer({ minimum: 1, maximum: Number.MAX_SAFE_INTEGER });
 const JsonValueSchema = Type.Any();
+const JsonObjectSchema = Type.Record(Type.String(), JsonValueSchema);
 const LspLanguageMappingSchema = Type.Object(
   {
     extensions: Type.Optional(Type.Array(NonEmptyStringSchema, { minItems: 1 })),
@@ -29,6 +30,7 @@ const LspServerDefinitionSchema = Type.Object(
     ),
     initializationOptions: Type.Optional(JsonValueSchema),
     languages: Type.Optional(Type.Array(LspLanguageMappingSchema, { minItems: 1 })),
+    requireRootMarker: Type.Optional(Type.Boolean()),
     rootMarkers: Type.Optional(Type.Array(NonEmptyStringSchema)),
     settings: Type.Optional(JsonValueSchema),
   },
@@ -43,18 +45,6 @@ const LspTimeoutsSchema = Type.Object(
   },
   { additionalProperties: false },
 );
-const LspLayerSchema = Type.Object(
-  {
-    servers: Type.Optional(
-      Type.Record(
-        Type.String({ minLength: 1 }),
-        Type.Union([LspServerDefinitionSchema, Type.Null()]),
-      ),
-    ),
-    timeouts: Type.Optional(LspTimeoutsSchema),
-  },
-  { additionalProperties: false },
-);
 const SettingsDocumentSchema = Type.Object({ lsp: Type.Optional(JsonValueSchema) });
 
 interface JsonObject {
@@ -64,7 +54,16 @@ interface JsonObject {
 type JsonValue = null | boolean | number | string | readonly JsonValue[] | JsonObject;
 type LspServerDefinitionWire = Static<typeof LspServerDefinitionSchema>;
 type LspTimeoutsWire = Static<typeof LspTimeoutsSchema>;
-type LspLayerWire = Static<typeof LspLayerSchema>;
+type LspTimeoutName = keyof typeof DEFAULT_LSP_TIMEOUTS;
+const LSP_TIMEOUT_NAMES: readonly LspTimeoutName[] = [
+  "diagnosticsMs",
+  "initializeMs",
+  "requestMs",
+  "shutdownMs",
+];
+type ParsedLspServerDefinition =
+  | { readonly kind: "excluded" }
+  | { readonly kind: "valid"; readonly value: LspServerDefinitionWire };
 
 /** Describes one configured filename or extension mapping to an LSP language identifier. */
 export interface LspLanguageMapping {
@@ -73,7 +72,7 @@ export interface LspLanguageMapping {
   readonly languageId: string;
 }
 
-/** Contains the parsed command and protocol values for one enabled language server. */
+/** Contains the parsed command and protocol values for one configured language server. */
 export interface LspServerDefinition {
   readonly args: readonly string[];
   readonly command: string;
@@ -81,6 +80,8 @@ export interface LspServerDefinition {
   readonly id: string;
   readonly initializationOptions?: JsonValue;
   readonly languages: readonly LspLanguageMapping[];
+  /** Require any root marker above a candidate file; false falls back to Pi's working directory. */
+  readonly requireRootMarker: boolean;
   readonly rootMarkers: readonly string[];
   readonly settings?: JsonValue;
 }
@@ -93,9 +94,8 @@ export interface LspTimeouts {
   readonly shutdownMs: number;
 }
 
-/** Reports resolved trusted configuration, or disabled startup when either layer is malformed. */
+/** Reports resolved trusted configuration, retaining valid entries when other settings are invalid. */
 export interface ResolvedLspSettings {
-  readonly enabled: boolean;
   readonly servers: ReadonlyMap<string, LspServerDefinition>;
   readonly timeouts: LspTimeouts;
   readonly warnings: readonly string[];
@@ -113,58 +113,150 @@ type PiSettingsDocument = ReturnType<SettingsManager["getGlobalSettings"]>;
 /** Pi's core Settings type or a test/boundary document carrying the extension-owned `lsp` value. */
 export type LspSettingsDocumentInput = PiSettingsDocument | { readonly lsp?: JsonValue };
 
-type ParsedLspLayer =
-  | { readonly kind: "absent" }
-  | { readonly kind: "invalid"; readonly warning: string }
-  | { readonly kind: "valid"; readonly value: LspLayerWire };
+interface ParsedLspLayer {
+  readonly servers: ReadonlyMap<string, ParsedLspServerDefinition>;
+  readonly timeouts: LspTimeoutsWire;
+  readonly warnings: readonly string[];
+}
+
+function isJsonObject(value: JsonValue): value is JsonObject {
+  return Value.Check(JsonObjectSchema, value);
+}
 
-function lspValidationWarning(value: JsonValue, scope: "global" | "project"): string {
-  const error = Value.Errors(LspLayerSchema, value)[0];
+function schemaValidationWarning(
+  schema: typeof LspServerDefinitionSchema | typeof PositiveMillisecondsSchema,
+  value: JsonValue,
+  prefix: string,
+): string {
+  const error = Value.Errors(schema, value)[0];
   const path = error?.instancePath.replaceAll("/", ".") ?? "";
   const unknownField =
     error?.keyword === "additionalProperties" ? error.params.additionalProperties[0] : undefined;
-  return `${scope} lsp${path}${unknownField === undefined ? "" : `.${unknownField}`}: ${error?.message ?? "invalid settings"}`;
+  const unknownFieldSuffix = unknownField === undefined ? "" : `.${String(unknownField)}`;
+  return `${prefix}${path}${unknownFieldSuffix}: ${error?.message ?? "invalid settings"}`;
 }
 
-function readLspLayer(
-  settings: LspSettingsDocumentInput,
+function parseLspServerDefinitions(
+  value: JsonValue | undefined,
   scope: "global" | "project",
-): ParsedLspLayer {
-  if (!Value.Check(SettingsDocumentSchema, settings)) {
-    return { kind: "invalid", warning: `${scope} settings: expected a JSON object` };
-  }
-  if (settings.lsp === undefined) return { kind: "absent" };
-  if (!Value.Check(LspLayerSchema, settings.lsp)) {
-    return { kind: "invalid", warning: lspValidationWarning(settings.lsp, scope) };
+): Pick<ParsedLspLayer, "servers" | "warnings"> {
+  const warnings: string[] = [];
+  const servers = new Map<string, ParsedLspServerDefinition>();
+  if (value === undefined) return { servers, warnings };
+  if (!isJsonObject(value)) {
+    return { servers, warnings: [`${scope} lsp.servers: expected a JSON object`] };
   }
-  for (const [serverId, server] of Object.entries(settings.lsp.servers ?? {})) {
-    if (server === null) continue;
+  for (const [id, server] of Object.entries(value)) {
+    if (!Value.Check(NonEmptyStringSchema, id)) {
+      warnings.push(`${scope} lsp.servers.${String(id)}: server ID must be a non-empty string`);
+      continue;
+    }
+    if (server === null) {
+      servers.set(id, { kind: "excluded" });
+      continue;
+    }
+    if (!Value.Check(LspServerDefinitionSchema, server)) {
+      warnings.push(
+        schemaValidationWarning(LspServerDefinitionSchema, server, `${scope} lsp.servers.${id}`),
+      );
+      servers.set(id, { kind: "excluded" });
+      continue;
+    }
     if (server.command === undefined || server.languages === undefined) {
-      return {
-        kind: "invalid",
-        warning: `${scope} lsp.servers.${serverId}: command and languages are required`,
-      };
+      warnings.push(`${scope} lsp.servers.${id}: command and languages are required`);
+      servers.set(id, { kind: "excluded" });
+      continue;
     }
     if (
       server.languages.some(
         (language) => language.extensions === undefined && language.fileNames === undefined,
       )
     ) {
-      return {
-        kind: "invalid",
-        warning: `${scope} lsp.servers.${serverId}.languages: each language needs extensions or fileNames`,
-      };
+      warnings.push(
+        `${scope} lsp.servers.${id}.languages: each language needs extensions or fileNames`,
+      );
+      servers.set(id, { kind: "excluded" });
+      continue;
+    }
+    if (server.requireRootMarker === true && (server.rootMarkers?.length ?? 0) === 0) {
+      warnings.push(
+        `${scope} lsp.servers.${id}.rootMarkers: at least one root marker is required when requireRootMarker is true`,
+      );
+      servers.set(id, { kind: "excluded" });
+      continue;
+    }
+    servers.set(id, { kind: "valid", value: server });
+  }
+  return { servers, warnings };
+}
+
+function isLspTimeoutName(name: string): name is LspTimeoutName {
+  return LSP_TIMEOUT_NAMES.some((timeoutName) => timeoutName === name);
+}
+
+function parseLspTimeouts(
+  value: JsonValue | undefined,
+  scope: "global" | "project",
+): Pick<ParsedLspLayer, "timeouts" | "warnings"> {
+  const warnings: string[] = [];
+  const timeouts: LspTimeoutsWire = {};
+  if (value === undefined) return { timeouts, warnings };
+  if (!isJsonObject(value)) {
+    return { timeouts, warnings: [`${scope} lsp.timeouts: expected a JSON object`] };
+  }
+  for (const [name, timeout] of Object.entries(value)) {
+    if (!isLspTimeoutName(name)) {
+      warnings.push(`${scope} lsp.timeouts.${name}: unknown field`);
+      continue;
     }
+    if (!Value.Check(PositiveMillisecondsSchema, timeout)) {
+      warnings.push(
+        schemaValidationWarning(
+          PositiveMillisecondsSchema,
+          timeout,
+          `${scope} lsp.timeouts.${name}`,
+        ),
+      );
+      continue;
+    }
+    timeouts[name] = timeout;
   }
-  return { kind: "valid", value: settings.lsp };
+  return { timeouts, warnings };
+}
+
+function readLspLayer(
+  settings: LspSettingsDocumentInput,
+  scope: "global" | "project",
+): ParsedLspLayer {
+  if (!Value.Check(SettingsDocumentSchema, settings)) {
+    return {
+      servers: new Map(),
+      timeouts: {},
+      warnings: [`${scope} settings: expected a JSON object`],
+    };
+  }
+  if (settings.lsp === undefined) return { servers: new Map(), timeouts: {}, warnings: [] };
+  if (!isJsonObject(settings.lsp)) {
+    return {
+      servers: new Map(),
+      timeouts: {},
+      warnings: [`${scope} lsp: expected a JSON object`],
+    };
+  }
+  const warnings = Object.keys(settings.lsp)
+    .filter((field) => field !== "servers" && field !== "timeouts")
+    .map((field) => `${scope} lsp.${field}: unknown field`);
+  const parsedServers = parseLspServerDefinitions(settings.lsp.servers, scope);
+  const parsedTimeouts = parseLspTimeouts(settings.lsp.timeouts, scope);
+  return {
+    servers: parsedServers.servers,
+    timeouts: parsedTimeouts.timeouts,
+    warnings: [...warnings, ...parsedServers.warnings, ...parsedTimeouts.warnings],
+  };
 }
 
 function mergeLspTimeouts(globalLayer: ParsedLspLayer, projectLayer: ParsedLspLayer): LspTimeouts {
-  const timeoutValues: readonly (LspTimeoutsWire | undefined)[] = [
-    globalLayer.kind === "valid" ? globalLayer.value.timeouts : undefined,
-    projectLayer.kind === "valid" ? projectLayer.value.timeouts : undefined,
-  ];
-  return Object.assign({}, DEFAULT_LSP_TIMEOUTS, ...timeoutValues);
+  return Object.assign({}, DEFAULT_LSP_TIMEOUTS, globalLayer.timeouts, projectLayer.timeouts);
 }
 
 function resolveLspEnvironment(
@@ -199,6 +291,7 @@ function resolveLspServerDefinition(
     environment: resolveLspEnvironment(server.environment),
     id,
     languages,
+    requireRootMarker: server.requireRootMarker ?? false,
     rootMarkers: server.rootMarkers ?? [],
   };
   const initializationOptions = server.initializationOptions;
@@ -224,18 +317,13 @@ function mergeLspServers(
   projectLayer: ParsedLspLayer,
 ): ReadonlyMap<string, LspServerDefinition> {
   const serverDefinitions = new Map<string, LspServerDefinitionWire>();
-  const addServers = (layer: ParsedLspLayer, projectLayerValue: boolean): void => {
-    if (layer.kind !== "valid") return;
-    for (const [id, server] of Object.entries(layer.value.servers ?? {})) {
-      if (server === null) {
-        if (projectLayerValue) serverDefinitions.delete(id);
-        continue;
-      }
-      serverDefinitions.set(id, server);
-    }
-  };
-  addServers(globalLayer, false);
-  addServers(projectLayer, true);
+  for (const [id, server] of globalLayer.servers) {
+    if (server.kind === "valid") serverDefinitions.set(id, server.value);
+  }
+  for (const [id, server] of projectLayer.servers) {
+    serverDefinitions.delete(id);
+    if (server.kind === "valid") serverDefinitions.set(id, server.value);
+  }
   return new Map(
     [...serverDefinitions]
       .sort(([left], [right]) => left.localeCompare(right))
@@ -243,21 +331,13 @@ function mergeLspServers(
   );
 }
 
-/** Resolve global and trusted-project LSP settings without adding an `lsp` field to Pi's Settings type. */
+/** Resolve global and trusted-project LSP settings, quarantining invalid entries instead of disabling valid settings. */
 export function resolveLspSettings(reader: LspSettingsReader): ResolvedLspSettings {
   const globalLayer = readLspLayer(reader.getGlobalSettings(), "global");
   const projectLayer = readLspLayer(reader.getProjectSettings(), "project");
-  const warnings = [globalLayer, projectLayer]
-    .filter(
-      (layer): layer is Extract<ParsedLspLayer, { readonly kind: "invalid" }> =>
-        layer.kind === "invalid",
-    )
-    .map((layer) => layer.warning);
-  const enabled = warnings.length === 0;
   return {
-    enabled,
-    servers: enabled ? mergeLspServers(globalLayer, projectLayer) : new Map(),
+    servers: mergeLspServers(globalLayer, projectLayer),
     timeouts: mergeLspTimeouts(globalLayer, projectLayer),
-    warnings,
+    warnings: [...globalLayer.warnings, ...projectLayer.warnings],
   };
 }