pi-lsp-lite 0.2.4 → 0.3.2

package/.github/workflows/ci.yml

@@ -0,0 +1,30 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+permissions:
+  contents: read
+
+jobs:
+  check:
+    name: typecheck + unit tests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+
+      - uses: actions/setup-node@v6
+        with:
+          node-version: 20
+          cache: npm
+
+      - run: npm ci
+
+      - name: typecheck
+        run: npm run check
+
+      - name: unit tests
+        run: npm test

package/.github/workflows/integration.yml

@@ -0,0 +1,79 @@
+name: Integration Tests
+
+on:
+  pull_request:
+    branches: [main]
+
+permissions:
+  contents: read
+
+jobs:
+  gopls:
+    name: gopls
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-node@v6
+        with:
+          node-version: 20
+          cache: npm
+      - uses: actions/setup-go@v6
+        with:
+          go-version: stable
+      - run: go install golang.org/x/tools/gopls@latest
+      - run: npm ci
+      - run: INTEGRATION=1 npx tsx --test test/*.test.ts test/integration/gopls.test.ts
+
+  rust-analyzer:
+    name: rust-analyzer
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-node@v6
+        with:
+          node-version: 20
+          cache: npm
+      - run: |
+          rustup update stable
+          rustup component add rust-analyzer
+      - run: npm ci
+      - run: INTEGRATION=1 npx tsx --test test/*.test.ts test/integration/rust-analyzer.test.ts
+
+  typescript:
+    name: typescript-language-server
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-node@v6
+        with:
+          node-version: 20
+          cache: npm
+      - run: npm install -g typescript-language-server typescript
+      - run: npm ci
+      - run: INTEGRATION=1 npx tsx --test test/*.test.ts test/integration/typescript.test.ts
+
+  pylsp:
+    name: pylsp
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-node@v6
+        with:
+          node-version: 20
+          cache: npm
+      - run: pip install 'python-lsp-server[all]'
+      - run: npm ci
+      - run: INTEGRATION=1 npx tsx --test test/*.test.ts test/integration/pylsp.test.ts
+
+  clangd:
+    name: clangd
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-node@v6
+        with:
+          node-version: 20
+          cache: npm
+      - run: sudo apt-get update -qq && sudo apt-get install -y -qq clangd
+      - run: npm ci
+      - run: INTEGRATION=1 npx tsx --test test/*.test.ts test/integration/clangd.test.ts

package/.github/workflows/release.yml

@@ -0,0 +1,34 @@
+name: Publish to npm
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  publish:
+    name: publish to npm
+    runs-on: ubuntu-latest
+    environment: public
+    steps:
+      - uses: actions/checkout@v6
+
+      - uses: actions/setup-node@v6
+        with:
+          node-version: 24
+          registry-url: https://registry.npmjs.org
+          cache: npm
+
+      - run: npm ci
+
+      - name: typecheck
+        run: npm run check
+
+      - name: unit tests
+        run: npm test
+
+      - name: publish
+        run: npm publish --access public

package/README.md

@@ -1,62 +1,111 @@
 # pi-lsp-lite
 
-[pi](https://github.com/mariozechner/pi) extension that feeds LSP diagnostics back to the agent after every `write` and `edit`. Go, Rust, and TypeScript via `gopls`, `rust-analyzer`, and `typescript-language-server`.
+[![CI](https://img.shields.io/github/actions/workflow/status/mcphailtom/pi-lsp-lite/ci.yml?branch=main&label=CI)](https://github.com/mcphailtom/pi-lsp-lite/actions/workflows/ci.yml)
+[![npm](https://img.shields.io/npm/v/pi-lsp-lite)](https://www.npmjs.com/package/pi-lsp-lite)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 
-The agent sees errors and warnings inline on the same turn as the edit that caused them.
+Your agent can't see compiler errors. Now it can.
+
+[pi](https://github.com/mariozechner/pi) extension that runs language servers in the background and feeds diagnostics back inline after every edit. Errors appear on the same turn — no context switch, no separate command.
+
+**Go · Rust · TypeScript · Python · C/C++**
 
 ## Install
 
 ```bash
-pi install git:github.com/mcphailtom/pi-lsp-lite
+pi install npm:pi-lsp-lite
 ```
 
-Or from npm:
+That's it. If you have `gopls`, `rust-analyzer`, `typescript-language-server`, `pylsp`, or `clangd` on PATH, diagnostics start flowing automatically.
 
-```bash
-pi install npm:pi-lsp-lite
+## What you see
+
+```
+  edit ─ src/main.go
+  ✓ Edited src/main.go (replaced 2 lines)
+
+  ⚠ LSP diagnostics for src/main.go (2 errors):
+    error 12:5 [compiler] undefined: foo
+    error 18:2 [compiler] too many arguments in call to bar
+    + 1 diagnostic in 1 other file
 ```
 
-## Prerequisites
+The agent sees these too — they're appended to the tool result, so it can self-correct on the same turn.
+
+## Commands
 
-Language servers must be on `PATH`. If missing, that language is silently disabled.
+| Command | What it does |
+|---------|-------------|
+| `/lsp-status` | Show running servers, PIDs, workspace roots, uptime |
+| `/lsp-diag` | Show all current diagnostics (or `/lsp-diag path/to/file` for one file) |
+| `/lsp-add` | Interactively add a new language server |
+| `/lsp-remove` | Disable a configured server |
+| `/lsp-toggle` | Flip a server on/off without removing config |
+| `/lsp-install` | Install a missing server binary |
+
+## Supported servers
 
 | Server | Language | Install |
 |--------|----------|---------|
 | `gopls` | Go | `go install golang.org/x/tools/gopls@latest` |
 | `rust-analyzer` | Rust | `rustup component add rust-analyzer` |
-| `typescript-language-server` | TypeScript/JavaScript | `npm install -g typescript-language-server typescript` |
+| `typescript-language-server` | TypeScript/JS | `npm install -g typescript-language-server typescript` |
+| `pylsp` | Python | `pip install python-lsp-server` |
+| `clangd` | C/C++ | Xcode CLI tools / `apt install clangd` |
+
+Missing a server? `/lsp-add` lets you configure any LSP server that speaks stdio. Or add it to `.pi-lsp-lite.json`:
+
+```json
+{
+  "servers": {
+    "haskell": {
+      "extensions": [".hs"],
+      "command": "haskell-language-server-wrapper",
+      "args": ["--lsp"],
+      "rootPatterns": ["cabal.project", "stack.yaml"]
+    }
+  }
+}
+```
 
-## Usage
+## Configuration
 
-No configuration needed. Once installed, diagnostics appear automatically after every `write` or `edit` to a supported file:
+Works without config. For customisation, create `.pi-lsp-lite.json` (project) or `~/.pi-lsp-lite.json` (global):
 
-```
-⚠ LSP diagnostics for main.go (2 errors):
-  error 12:5 [compiler] undefined: foo
-  error 18:2 [compiler] too many arguments in call to bar
-  + 1 diagnostic in 1 other file
-```
+| Field | Description | Default |
+|-------|-------------|---------|
+| `servers.<id>.diagnosticTimeout` | Per-attempt timeout (ms) | per-language |
+| `servers.<id>.maxRetries` | Retry attempts on timeout (0-10) | `3` |
+| `servers.<id>.disabled` | Disable this server | `false` |
+| `diagnosticTimeout` | Global default timeout (ms) | `5000` |
+| `documentIdleTimeout` | Close idle documents after (ms) | `120000` |
 
-Use `/lsp-status` to see running servers.
+Project config merges over global. Partial overrides work — only specify what you want to change.
 
 ## How it works
 
-Edits trigger `textDocument/didOpen` or `textDocument/didChange` against a long-lived language server. Diagnostics are collected within a 3-second window and appended to the tool result. Workspace roots are detected automatically (`go.mod`, `Cargo.toml`, `tsconfig.json`, `package.json`).
+1. Agent writes/edits a file
+2. Extension detects the language, finds the workspace root
+3. Spawns (or reuses) an LSP server for that language + root
+4. Sends `didChange`, waits for `publishDiagnostics`
+5. If timeout: retries with exponential backoff + jitter (up to `maxRetries` times)
+6. Filters to errors + warnings, formats, appends to tool result + shows in TUI
+
+Cross-file impact is detected via snapshot-diff: if editing `lib.ts` breaks `caller.ts`, you see "+ N diagnostics in M other files".
 
-See [ARCHITECTURE.md](docs/ARCHITECTURE.md) for internals.
+Servers are lazy (spawn on first edit), idle-shutdown after 240s, and clean up on session end.
 
 ## Development
 
 ```bash
 git clone https://github.com/mcphailtom/pi-lsp-lite
-cd pi-lsp-lite
-npm install
-npm run check        # typecheck
-npm test             # unit tests
-npm run test:integration  # requires servers on PATH
+cd pi-lsp-lite && npm install
+npm run check              # typecheck
+npm test                   # unit tests (106, no servers needed)
+npm run test:integration   # real server tests (needs servers on PATH)
 ```
 
-See [CONTRIBUTING.md](docs/CONTRIBUTING.md) for details.
+See [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md) and [docs/CONTRIBUTING.md](docs/CONTRIBUTING.md).
 
 ## License
 

package/index.ts

@@ -1,16 +1,37 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { createServerManager } from "./src/server-manager.js";
-import { languageForFile, checkExtensionOverlaps } from "./src/languages.js";
+import { languageForFile, checkExtensionOverlaps, builtinLanguages, type LanguageServerConfig } from "./src/languages.js";
 import { formatDiagnostics } from "./src/format.js";
+import { DiagnosticSeverity } from "vscode-languageserver-protocol";
+import { loadConfig, writeGlobalConfig, readGlobalConfig } from "./src/config.js";
+import { fileUri, which } from "./src/util.js";
+import { installRegistry } from "./src/install-registry.js";
 import { resolve, relative, isAbsolute } from "node:path";
+import { fileURLToPath } from "node:url";
 
 export default function (pi: ExtensionAPI) {
-  const manager = createServerManager();
+  let servers: LanguageServerConfig[] = [];
+  let manager = createServerManager({});
 
-  for (const warning of checkExtensionOverlaps()) {
-    console.error(`[pi-lsp-lite] ${warning}`);
+  async function initConfig(cwd: string) {
+    await manager.shutdownAll();
+    const resolved = await loadConfig(cwd);
+    servers = resolved.servers;
+    manager = createServerManager({
+      diagnosticTimeout: resolved.diagnosticTimeout,
+      documentIdleTimeout: resolved.documentIdleTimeout,
+      perServerTimeout: resolved.perServerTimeout,
+    });
+
+    for (const warning of checkExtensionOverlaps(servers)) {
+      console.error(`[pi-lsp-lite] ${warning}`);
+    }
   }
 
+  pi.on("session_start", async (_event, ctx) => {
+    await initConfig(ctx.cwd);
+  });
+
   pi.on("tool_result", async (event, ctx) => {
     if (event.toolName !== "write" && event.toolName !== "edit") return;
 
@@ -21,11 +42,11 @@ export default function (pi: ExtensionAPI) {
     const absolutePath = resolve(ctx.cwd, filePath);
     const rel = relative(ctx.cwd, absolutePath);
     if (!rel || rel.startsWith("..") || isAbsolute(rel)) return;
-    const config = languageForFile(absolutePath);
-    if (!config) return;
+    const langConfig = languageForFile(absolutePath, servers);
+    if (!langConfig) return;
 
     try {
-      const result = await manager.handleEdit(absolutePath, config, ctx.cwd);
+      const result = await manager.handleEdit(absolutePath, langConfig, ctx.cwd);
       const formatted = formatDiagnostics(filePath, result);
       if (!formatted) return;
 
@@ -46,12 +67,12 @@ export default function (pi: ExtensionAPI) {
   pi.registerCommand("lsp-status", {
     description: "Show running LSP servers and recent diagnostic counts",
     handler: async (_args, ctx) => {
-      const servers = manager.status();
-      if (servers.length === 0) {
+      const running = manager.status();
+      if (running.length === 0) {
         ctx.ui.notify("pi-lsp-lite: no servers running", "info");
         return;
       }
-      const lines = servers.map((s) => {
+      const lines = running.map((s) => {
         const idle = Math.round((Date.now() - s.lastActivity) / 1000);
         const up = Math.round(s.uptime / 1000);
         return `${s.id} (pid ${s.pid}) root=${s.root} — ${s.openDocuments} open files, up ${up}s, idle ${idle}s`;
@@ -59,4 +80,211 @@ export default function (pi: ExtensionAPI) {
       ctx.ui.notify(lines.join("\n"), "info");
     },
   });
+
+  pi.registerCommand("lsp-diag", {
+    description: "Show current LSP diagnostics for all tracked files (or a specific file)",
+    handler: async (args, ctx) => {
+      const allDiags = manager.getAllDiagnostics();
+
+      if (allDiags.size === 0) {
+        ctx.ui.notify("pi-lsp-lite: no diagnostics", "info");
+        return;
+      }
+
+      const filterPath = args?.trim();
+      let filterUri: string | undefined;
+      if (filterPath) {
+        const abs = resolve(ctx.cwd, filterPath);
+        filterUri = fileUri(abs);
+      }
+
+      const lines: string[] = [];
+      for (const [uri, diags] of allDiags) {
+        if (filterUri && uri !== filterUri) continue;
+        const filePath = fileURLToPath(new URL(uri));
+        const relevant = diags.filter((d) => d.severity === DiagnosticSeverity.Error || d.severity === DiagnosticSeverity.Warning);
+        if (relevant.length === 0) continue;
+        lines.push(`${filePath} (${relevant.length} diagnostic${relevant.length !== 1 ? "s" : ""})`);
+        for (const d of relevant) {
+          const severity = d.severity === DiagnosticSeverity.Error ? "error" : "warning";
+          const line = d.range.start.line + 1;
+          const col = d.range.start.character + 1;
+          const source = d.source ? `[${d.source}] ` : "";
+          lines.push(`  ${severity} ${line}:${col} ${source}${d.message}`);
+        }
+      }
+
+      if (lines.length === 0) {
+        ctx.ui.notify(filterPath ? `pi-lsp-lite: no diagnostics for ${filterPath}` : "pi-lsp-lite: no diagnostics", "info");
+        return;
+      }
+
+      ctx.ui.notify(lines.join("\n"), "warning");
+    },
+  });
+
+  pi.registerCommand("lsp-add", {
+    description: "Add a new language server to global config",
+    handler: async (_args, ctx) => {
+      if (!ctx.hasUI) {
+        ctx.ui.notify("pi-lsp-lite: /lsp-add requires interactive mode", "error");
+        return;
+      }
+
+      const rawId = await ctx.ui.input("Server ID (e.g. haskell):");
+      if (!rawId) return;
+      const id = rawId.trim().toLowerCase();
+      if (!/^[a-z0-9_-]+$/.test(id)) {
+        ctx.ui.notify("pi-lsp-lite: server ID must be lowercase alphanumeric, hyphens, or underscores", "error");
+        return;
+      }
+      const RESERVED_IDS = new Set(["__proto__", "constructor", "prototype"]);
+      if (RESERVED_IDS.has(id)) {
+        ctx.ui.notify("pi-lsp-lite: reserved ID, choose a different name", "error");
+        return;
+      }
+
+      const rawCommand = await ctx.ui.input("Binary command (e.g. haskell-language-server-wrapper):");
+      const command = rawCommand?.trim();
+      if (!command) return;
+
+      const argsRaw = await ctx.ui.input("CLI args (comma-separated, or empty):");
+      const args = argsRaw ? argsRaw.split(",").map((a) => a.trim()).filter(Boolean) : [];
+
+      const extRaw = await ctx.ui.input("File extensions (comma-separated, e.g. .hs,.lhs):");
+      if (!extRaw) return;
+      const extensions = extRaw.split(",").map((e) => e.trim().toLowerCase()).filter(Boolean);
+      if (extensions.length === 0) {
+        ctx.ui.notify("pi-lsp-lite: at least one extension is required", "error");
+        return;
+      }
+
+      const rootRaw = await ctx.ui.input("Root pattern files (comma-separated, or empty):");
+      const rootPatterns = rootRaw ? rootRaw.split(",").map((r) => r.trim()).filter(Boolean) : [];
+
+      const resolved = await which(command);
+      if (!resolved) {
+        ctx.ui.notify(`pi-lsp-lite: "${command}" not found on PATH — server added but won't start until installed`, "warning");
+      }
+
+      await writeGlobalConfig({ servers: { [id]: { command, args, extensions, rootPatterns } } });
+      await initConfig(ctx.cwd);
+      ctx.ui.notify(`pi-lsp-lite: added server "${id}"`, "info");
+    },
+  });
+
+  pi.registerCommand("lsp-remove", {
+    description: "Remove or disable a language server",
+    handler: async (_args, ctx) => {
+      if (!ctx.hasUI) {
+        ctx.ui.notify("pi-lsp-lite: /lsp-remove requires interactive mode", "error");
+        return;
+      }
+
+      if (servers.length === 0) {
+        ctx.ui.notify("pi-lsp-lite: no servers configured", "info");
+        return;
+      }
+
+      const ids = servers.map((s) => s.id);
+      const selected = await ctx.ui.select("Remove which server?", ids);
+      if (!selected) return;
+
+      const confirmed = await ctx.ui.confirm("Confirm removal", `Disable server "${selected}"?`);
+      if (!confirmed) return;
+
+      await writeGlobalConfig({ servers: { [selected]: { disabled: true } } });
+      await initConfig(ctx.cwd);
+      ctx.ui.notify(`pi-lsp-lite: disabled server "${selected}"`, "info");
+    },
+  });
+
+  pi.registerCommand("lsp-toggle", {
+    description: "Enable or disable a language server",
+    handler: async (_args, ctx) => {
+      if (!ctx.hasUI) {
+        ctx.ui.notify("pi-lsp-lite: /lsp-toggle requires interactive mode", "error");
+        return;
+      }
+
+      const builtinIds = new Set(builtinLanguages.map((l) => l.id));
+      const activeIds = new Set(servers.map((s) => s.id));
+
+      // include disabled user-added servers from global config so they can be re-enabled
+      const globalConfig = await readGlobalConfig();
+      const RESERVED = new Set(["__proto__", "constructor", "prototype"]);
+      const globalServerIds = (globalConfig?.servers && typeof globalConfig.servers === "object" && !Array.isArray(globalConfig.servers))
+        ? Object.keys(globalConfig.servers).filter((k) => !RESERVED.has(k))
+        : [];
+      const allIds = new Set<string>([...builtinIds, ...activeIds, ...globalServerIds]);
+
+      if (allIds.size === 0) {
+        ctx.ui.notify("pi-lsp-lite: no servers configured", "info");
+        return;
+      }
+
+      const entries = [...allIds];
+      const options = entries.map((id) => `${id} ${activeIds.has(id) ? "[enabled]" : "[disabled]"}`);
+      const choice = await ctx.ui.select("Toggle which server?", options);
+      if (!choice) return;
+
+      const idx = options.indexOf(choice);
+      const id = entries[idx];
+      const isCurrentlyEnabled = activeIds.has(id);
+
+      if (isCurrentlyEnabled) {
+        await writeGlobalConfig({ servers: { [id]: { disabled: true } } });
+      } else {
+        // re-enable: works for both built-ins and user-added servers in global config
+        await writeGlobalConfig({ servers: { [id]: { disabled: false } } });
+      }
+
+      await initConfig(ctx.cwd);
+      ctx.ui.notify(`pi-lsp-lite: ${isCurrentlyEnabled ? "disabled" : "enabled"} server "${id}"`, "info");
+    },
+  });
+
+  pi.registerCommand("lsp-install", {
+    description: "Install a missing language server binary",
+    handler: async (_args, ctx) => {
+      if (!ctx.hasUI) {
+        ctx.ui.notify("pi-lsp-lite: /lsp-install requires interactive mode", "error");
+        return;
+      }
+
+      const checks = await Promise.all(
+        [...installRegistry].map(async ([id, entry]) => {
+          const lang = builtinLanguages.find((l) => l.id === id);
+          const binary = lang?.command ?? id;
+          const found = await which(binary);
+          return found ? null : { id, command: binary, installCmd: entry.command, description: entry.description };
+        }),
+      );
+      const missing = checks.filter((c): c is NonNullable<typeof c> => c !== null);
+
+      if (missing.length === 0) {
+        ctx.ui.notify("pi-lsp-lite: all known servers are available", "info");
+        return;
+      }
+
+      const options = missing.map((m) => `${m.id} — ${m.description} (${m.command})`);
+      const choice = await ctx.ui.select("Install which server?", options);
+      if (!choice) return;
+
+      const idx = options.indexOf(choice);
+      const selected = missing[idx];
+
+      const confirmed = await ctx.ui.confirm("Confirm install", `Run: ${selected.installCmd}`);
+      if (!confirmed) return;
+
+      const result = await pi.exec("sh", ["-c", selected.installCmd]);
+      if (result.code !== 0) {
+        ctx.ui.notify(`pi-lsp-lite: install failed (exit ${result.code})\n${result.stderr}`, "error");
+        return;
+      }
+
+      await initConfig(ctx.cwd);
+      ctx.ui.notify(`pi-lsp-lite: installed ${selected.id}`, "info");
+    },
+  });
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-lsp-lite",
-  "version": "0.2.4",
-  "description": "pi extension: feeds LSP diagnostics back to the agent after every write/edit. Go, Rust, and TypeScript.",
+  "version": "0.3.2",
+  "description": "LSP diagnostics for pi — errors and warnings on every edit, same turn. Go, Rust, TypeScript, Python, C/C++.",
   "type": "module",
   "private": false,
   "license": "MIT",
@@ -17,7 +17,11 @@
     "lsp",
     "gopls",
     "rust-analyzer",
-    "typescript-language-server"
+    "typescript-language-server",
+    "pylsp",
+    "clangd",
+    "python",
+    "cpp"
   ],
   "pi": {
     "extensions": [

package/src/client.ts

@@ -27,6 +27,7 @@ export interface DiagnosticResult {
   status: "ok" | "timeout" | "unavailable";
   diagnostics: Diagnostic[];
   otherFiles: OtherFileDiagnostics[];
+  retryAttempts: number;
 }
 
 export interface LspClient {
@@ -35,10 +36,12 @@ export interface LspClient {
   didChange(uri: string, content: string): void;
   didClose(uri: string): void;
   waitForDiagnostics(uri: string, timeoutMs: number): Promise<DiagnosticResult>;
+  getAllDiagnostics(): Map<string, Diagnostic[]>;
   shutdown(): Promise<void>;
 }
 
 const SHUTDOWN_TIMEOUT_MS = 5_000;
+const QUIESCENCE_MS = 200;
 
 function countDiagnostics(diags: Diagnostic[]): { errors: number; warnings: number } {
   let errors = 0;
@@ -70,21 +73,21 @@ export function createLspClient(child: ChildProcess): LspClient {
   const diagnosticsMap = new Map<string, DiagnosticEntry>();
   const documentVersion = new Map<string, number>();
   const uriGeneration = new Map<string, number>();
+  let crossFileCallback: ((changedUri: string) => void) | null = null;
 
   connection.onNotification(PublishDiagnosticsNotification.type, (params) => {
     const entry = diagnosticsMap.get(params.uri);
     if (entry) {
-      // only accept diagnostics for the current generation of this URI
       const currentGen = uriGeneration.get(params.uri) ?? 0;
       if (entry.generation !== currentGen) return;
       entry.diagnostics = params.diagnostics;
       entry.received = true;
       entry.resolve?.();
     } else {
-      // cross-file diagnostics for URIs we haven't opened — accept them
       const gen = uriGeneration.get(params.uri) ?? 0;
       diagnosticsMap.set(params.uri, { diagnostics: params.diagnostics, generation: gen, received: true });
     }
+    if (crossFileCallback) crossFileCallback(params.uri);
   });
 
   connection.listen();
@@ -137,7 +140,6 @@ export function createLspClient(child: ChildProcess): LspClient {
     },
 
     didClose(uri: string) {
-      // bump generation so any in-flight diagnostics for the old open are rejected
       const gen = (uriGeneration.get(uri) ?? 0) + 1;
       uriGeneration.set(uri, gen);
       connection.sendNotification(DidCloseTextDocumentNotification.type, {
@@ -150,7 +152,6 @@ export function createLspClient(child: ChildProcess): LspClient {
     async waitForDiagnostics(uri: string, timeoutMs: number): Promise<DiagnosticResult> {
       const targetGen = uriGeneration.get(uri) ?? 0;
 
-      // snapshot diagnostic counts for all other tracked URIs before the edit settles
       const preSnapshot = new Map<string, { errors: number; warnings: number }>();
       for (const [trackedUri, entry] of diagnosticsMap) {
         if (trackedUri !== uri) {
@@ -174,19 +175,26 @@ export function createLspClient(child: ChildProcess): LspClient {
       };
 
       return new Promise<DiagnosticResult>((resolve) => {
-        const SETTLE_MS = 50;
         let settled = false;
+        let quiescenceTimer: ReturnType<typeof setTimeout> | null = null;
 
         const settle = (status: "ok" | "timeout") => {
           if (settled) return;
           settled = true;
-          setTimeout(() => {
-            resolve({
-              status,
-              diagnostics: diagnosticsMap.get(uri)?.diagnostics ?? [],
-              otherFiles: collectOtherFiles(),
-            });
-          }, SETTLE_MS);
+          crossFileCallback = null;
+          if (quiescenceTimer) clearTimeout(quiescenceTimer);
+          resolve({
+            status,
+            diagnostics: diagnosticsMap.get(uri)?.diagnostics ?? [],
+            otherFiles: collectOtherFiles(),
+            retryAttempts: 0,
+          });
+        };
+
+        const resetQuiescence = () => {
+          if (settled) return;
+          if (quiescenceTimer) clearTimeout(quiescenceTimer);
+          quiescenceTimer = setTimeout(() => settle("ok"), QUIESCENCE_MS);
         };
 
         const timeout = setTimeout(() => {
@@ -194,19 +202,43 @@ export function createLspClient(child: ChildProcess): LspClient {
         }, timeoutMs);
 
         const entry = diagnosticsMap.get(uri) ?? { diagnostics: [], generation: targetGen, received: false };
-        if (entry.received) {
+
+        entry.resolve = () => {
           clearTimeout(timeout);
-          settle("ok");
-        } else {
-          entry.resolve = () => {
+          resetQuiescence();
+        };
+        diagnosticsMap.set(uri, entry);
+
+        // when a non-target URI publishes diagnostics that differ from the
+        // pre-snapshot, start quiescence — this catches the case where the
+        // edited file is valid but dependents break
+        crossFileCallback = (changedUri: string) => {
+          if (settled || changedUri === uri) return;
+          const pre = preSnapshot.get(changedUri) ?? { errors: 0, warnings: 0 };
+          const post = countDiagnostics(diagnosticsMap.get(changedUri)?.diagnostics ?? []);
+          if (post.errors !== pre.errors || post.warnings !== pre.warnings) {
             clearTimeout(timeout);
-            settle("ok");
-          };
-          diagnosticsMap.set(uri, entry);
+            resetQuiescence();
+          }
+        };
+
+        if (entry.received) {
+          clearTimeout(timeout);
+          resetQuiescence();
         }
       });
     },
 
+    getAllDiagnostics(): Map<string, Diagnostic[]> {
+      const result = new Map<string, Diagnostic[]>();
+      for (const [uri, entry] of diagnosticsMap) {
+        if (entry.diagnostics.length > 0) {
+          result.set(uri, [...entry.diagnostics]);
+        }
+      }
+      return result;
+    },
+
     async shutdown() {
       let timer: ReturnType<typeof setTimeout> | undefined;
       try {

package/src/config.ts

@@ -0,0 +1,295 @@
+import { readFile, writeFile, mkdir, rename, unlink } from "node:fs/promises";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { randomUUID } from "node:crypto";
+import { type LanguageServerConfig, builtinLanguages } from "./languages.js";
+
+export interface ServerConfigOverride {
+  extensions?: string[];
+  command?: string;
+  args?: string[];
+  rootPatterns?: string[];
+  diagnosticTimeout?: number;
+  maxRetries?: number;
+  disabled?: boolean;
+}
+
+export interface UserConfig {
+  servers?: Record<string, ServerConfigOverride>;
+  diagnosticTimeout?: number;
+  documentIdleTimeout?: number;
+}
+
+export interface ResolvedConfig {
+  servers: LanguageServerConfig[];
+  diagnosticTimeout: number;
+  documentIdleTimeout: number;
+  perServerTimeout: Map<string, number>;
+}
+
+export const DEFAULT_DIAGNOSTIC_TIMEOUT = 5_000;
+export const DEFAULT_DOCUMENT_IDLE_TIMEOUT = 120_000;
+export const DEFAULT_MAX_RETRIES = 3;
+
+const MIN_DIAGNOSTIC_TIMEOUT = 1_000;
+const MAX_DIAGNOSTIC_TIMEOUT = 60_000;
+const MIN_DOCUMENT_IDLE_TIMEOUT = 10_000;
+const MAX_DOCUMENT_IDLE_TIMEOUT = 600_000;
+const MIN_MAX_RETRIES = 0;
+const MAX_MAX_RETRIES = 10;
+
+function clamp(value: unknown, min: number, max: number, fallback: number): number {
+  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+  return Math.max(min, Math.min(max, value));
+}
+
+function isPlainObject(v: unknown): v is Record<string, unknown> {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+
+function isStringArray(v: unknown): v is string[] {
+  return Array.isArray(v) && v.every((item) => typeof item === "string");
+}
+
+function validateOverride(id: string, raw: unknown): ServerConfigOverride | null {
+  if (!isPlainObject(raw)) return null;
+
+  const override: ServerConfigOverride = {};
+
+  if (raw.disabled === true) {
+    override.disabled = true;
+    return override;
+  }
+
+  if (raw.extensions !== undefined) {
+    if (!isStringArray(raw.extensions) || raw.extensions.length === 0) {
+      console.error(`[pi-lsp-lite] config "${id}": extensions must be a non-empty string array, skipping`);
+      return null;
+    }
+    override.extensions = (raw.extensions as string[]).map((e) => e.toLowerCase());
+  }
+
+  if (raw.command !== undefined) {
+    if (typeof raw.command !== "string" || raw.command.length === 0) {
+      console.error(`[pi-lsp-lite] config "${id}": command must be a non-empty string, skipping`);
+      return null;
+    }
+    override.command = raw.command as string;
+  }
+
+  if (raw.args !== undefined) {
+    if (!isStringArray(raw.args)) {
+      console.error(`[pi-lsp-lite] config "${id}": args must be a string array, skipping`);
+      return null;
+    }
+    override.args = raw.args as string[];
+  }
+
+  if (raw.rootPatterns !== undefined) {
+    if (!isStringArray(raw.rootPatterns)) {
+      console.error(`[pi-lsp-lite] config "${id}": rootPatterns must be a string array, skipping`);
+      return null;
+    }
+    override.rootPatterns = raw.rootPatterns as string[];
+  }
+
+  if (raw.diagnosticTimeout !== undefined) {
+    override.diagnosticTimeout = clamp(
+      raw.diagnosticTimeout,
+      MIN_DIAGNOSTIC_TIMEOUT,
+      MAX_DIAGNOSTIC_TIMEOUT,
+      DEFAULT_DIAGNOSTIC_TIMEOUT,
+    );
+  }
+
+  if (raw.maxRetries !== undefined) {
+    override.maxRetries = clamp(
+      raw.maxRetries,
+      MIN_MAX_RETRIES,
+      MAX_MAX_RETRIES,
+      DEFAULT_MAX_RETRIES,
+    );
+  }
+
+  return override;
+}
+
+async function readConfigFile(path: string): Promise<UserConfig | null> {
+  let content: string;
+  try {
+    content = await readFile(path, "utf-8");
+  } catch (err: unknown) {
+    if (err && typeof err === "object" && "code" in err && err.code === "ENOENT") return null;
+    console.error(`[pi-lsp-lite] failed to read config ${path}:`, err);
+    return null;
+  }
+
+  try {
+    const parsed: unknown = JSON.parse(content);
+    if (!isPlainObject(parsed)) {
+      console.error(`[pi-lsp-lite] config ${path}: expected a JSON object, skipping`);
+      return null;
+    }
+    return parsed as UserConfig;
+  } catch (err) {
+    console.error(`[pi-lsp-lite] config ${path}: invalid JSON, skipping:`, err);
+    return null;
+  }
+}
+
+async function findProjectConfig(cwd: string): Promise<UserConfig | null> {
+  for (const candidate of [
+    join(cwd, ".pi-lsp-lite.json"),
+    join(cwd, ".pi", "lsp-lite.json"),
+  ]) {
+    const config = await readConfigFile(candidate);
+    if (config) return config;
+  }
+  return null;
+}
+
+type ConfigSource = "global" | "project";
+
+function mergeConfigs(
+  base: LanguageServerConfig[],
+  overrides: Record<string, ServerConfigOverride>,
+  source: ConfigSource,
+): LanguageServerConfig[] {
+  const result = new Map<string, LanguageServerConfig>();
+
+  for (const server of base) {
+    result.set(server.id, { ...server });
+  }
+
+  for (const [id, rawOverride] of Object.entries(overrides)) {
+    const override = validateOverride(id, rawOverride);
+    if (!override) continue;
+
+    if (override.disabled) {
+      result.delete(id);
+      continue;
+    }
+
+    const existing = result.get(id);
+    if (existing) {
+      const { disabled: _, diagnosticTimeout: __, ...lspFields } = override;
+      const defined = Object.fromEntries(
+        Object.entries(lspFields).filter(([, v]) => v !== undefined),
+      );
+      result.set(id, { ...existing, ...defined });
+    } else {
+      if (source === "project") {
+        console.error(`[pi-lsp-lite] project config cannot define new server "${id}" — only global config (~/.pi-lsp-lite.json) can add servers`);
+        continue;
+      }
+      if (!override.command || !override.extensions) {
+        console.error(`[pi-lsp-lite] config "${id}" must have at least "command" and "extensions" to define a new server, skipping`);
+        continue;
+      }
+      result.set(id, {
+        id,
+        extensions: override.extensions,
+        command: override.command,
+        args: override.args ?? [],
+        rootPatterns: override.rootPatterns ?? [],
+        ...(override.maxRetries !== undefined && { maxRetries: override.maxRetries }),
+      });
+    }
+  }
+
+  return Array.from(result.values());
+}
+
+export function globalConfigFilePath(globalConfigPath?: string): string {
+  return globalConfigPath ?? join(homedir(), ".pi-lsp-lite.json");
+}
+
+export async function readGlobalConfig(globalConfigPath?: string): Promise<UserConfig | null> {
+  return readConfigFile(globalConfigFilePath(globalConfigPath));
+}
+
+let writeLock = Promise.resolve();
+
+export function writeGlobalConfig(config: UserConfig, globalConfigPath?: string): Promise<void> {
+  const op = writeLock.then(() => writeGlobalConfigInner(config, globalConfigPath));
+  writeLock = op.catch(() => {});
+  return op;
+}
+
+async function writeGlobalConfigInner(config: UserConfig, globalConfigPath?: string): Promise<void> {
+  const filePath = globalConfigFilePath(globalConfigPath);
+  const existing = await readConfigFile(filePath);
+  const merged = deepMerge(
+    (existing ?? {}) as Record<string, unknown>,
+    config as Record<string, unknown>,
+  ) as UserConfig;
+  const dir = dirname(filePath);
+  await mkdir(dir, { recursive: true });
+  const tmpPath = join(dir, `.tmp-${randomUUID()}`);
+  try {
+    await writeFile(tmpPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+    await rename(tmpPath, filePath);
+  } catch (err) {
+    await unlink(tmpPath).catch(() => {});
+    throw err;
+  }
+}
+
+const RESERVED_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+
+function deepMerge(target: Record<string, unknown>, source: Record<string, unknown>): Record<string, unknown> {
+  const result: Record<string, unknown> = Object.create(null);
+  for (const key of Object.keys(target)) {
+    if (!RESERVED_KEYS.has(key)) result[key] = target[key];
+  }
+  for (const key of Object.keys(source)) {
+    if (RESERVED_KEYS.has(key)) continue;
+    const sv = source[key];
+    const tv = target[key];
+    if (sv === undefined) continue;
+    if (sv === null) {
+      delete result[key];
+    } else if (isPlainObject(sv) && isPlainObject(tv)) {
+      result[key] = deepMerge(tv, sv);
+    } else {
+      result[key] = sv;
+    }
+  }
+  return result;
+}
+
+export async function loadConfig(cwd: string, globalConfigPath?: string): Promise<ResolvedConfig> {
+  const globalConfig = await readConfigFile(globalConfigFilePath(globalConfigPath));
+  const projectConfig = await findProjectConfig(cwd);
+
+  let servers = [...builtinLanguages];
+  const perServerTimeout = new Map<string, number>();
+  let diagnosticTimeout = DEFAULT_DIAGNOSTIC_TIMEOUT;
+  let documentIdleTimeout = DEFAULT_DOCUMENT_IDLE_TIMEOUT;
+
+  const layers: [UserConfig | null, ConfigSource][] = [
+    [globalConfig, "global"],
+    [projectConfig, "project"],
+  ];
+
+  for (const [layer, source] of layers) {
+    if (!layer) continue;
+    if (layer.servers && isPlainObject(layer.servers)) {
+      servers = mergeConfigs(servers, layer.servers as Record<string, ServerConfigOverride>, source);
+      for (const [id, rawOverride] of Object.entries(layer.servers)) {
+        const override = validateOverride(id, rawOverride);
+        if (override?.diagnosticTimeout !== undefined) {
+          perServerTimeout.set(id, override.diagnosticTimeout);
+        }
+      }
+    }
+    if (layer.diagnosticTimeout !== undefined) {
+      diagnosticTimeout = clamp(layer.diagnosticTimeout, MIN_DIAGNOSTIC_TIMEOUT, MAX_DIAGNOSTIC_TIMEOUT, diagnosticTimeout);
+    }
+    if (layer.documentIdleTimeout !== undefined) {
+      documentIdleTimeout = clamp(layer.documentIdleTimeout, MIN_DOCUMENT_IDLE_TIMEOUT, MAX_DOCUMENT_IDLE_TIMEOUT, documentIdleTimeout);
+    }
+  }
+
+  return { servers, diagnosticTimeout, documentIdleTimeout, perServerTimeout };
+}

package/src/format.ts

@@ -9,6 +9,10 @@ export function formatDiagnostics(filePath: string, result: DiagnosticResult): s
   if (relevant.length === 0 && result.status === "ok" && result.otherFiles.length === 0) return "";
   if (result.status === "unavailable") return "";
 
+  const retryNote = result.status === "timeout" && result.retryAttempts > 0
+    ? ` after ${result.retryAttempts} ${result.retryAttempts === 1 ? "retry" : "retries"}`
+    : "";
+
   if (relevant.length === 0 && result.status === "ok" && result.otherFiles.length > 0) {
     return `\n⚠ LSP diagnostics for ${filePath}: no issues${otherFilesFooter(result)}`;
   }
@@ -27,7 +31,7 @@ export function formatDiagnostics(filePath: string, result: DiagnosticResult): s
   const summary = [
     errorCount > 0 ? `${errorCount} error${errorCount > 1 ? "s" : ""}` : "",
     warnCount > 0 ? `${warnCount} warning${warnCount > 1 ? "s" : ""}` : "",
-    result.status === "timeout" ? "timed out, may be incomplete" : "",
+    result.status === "timeout" ? `timed out${retryNote}, may be incomplete` : "",
   ]
     .filter(Boolean)
     .join(", ");

package/src/install-registry.ts

@@ -0,0 +1,27 @@
+export interface InstallEntry {
+  command: string;
+  description: string;
+}
+
+export const installRegistry = new Map<string, InstallEntry>([
+  ["go", {
+    command: "go install golang.org/x/tools/gopls@latest",
+    description: "Go language server",
+  }],
+  ["rust", {
+    command: "rustup component add rust-analyzer",
+    description: "Rust language server",
+  }],
+  ["typescript", {
+    command: "npm install -g typescript-language-server typescript",
+    description: "TypeScript/JavaScript language server",
+  }],
+  ["python", {
+    command: "pip install python-lsp-server",
+    description: "Python language server",
+  }],
+  ["cpp", {
+    command: "sudo apt-get install -y clangd || brew install llvm",
+    description: "C/C++ language server",
+  }],
+]);

package/src/languages.ts

@@ -4,15 +4,18 @@ export interface LanguageServerConfig {
   command: string;
   args: string[];
   rootPatterns: string[];
+  diagnosticTimeout?: number;
+  maxRetries?: number;
 }
 
-export const languages: LanguageServerConfig[] = [
+export const builtinLanguages: LanguageServerConfig[] = [
   {
     id: "go",
     extensions: [".go"],
     command: "gopls",
     args: ["serve"],
     rootPatterns: ["go.mod"],
+    diagnosticTimeout: 5_000,
   },
   {
     id: "rust",
@@ -20,6 +23,7 @@ export const languages: LanguageServerConfig[] = [
     command: "rust-analyzer",
     args: [],
     rootPatterns: ["Cargo.toml"],
+    diagnosticTimeout: 30_000,
   },
   {
     id: "typescript",
@@ -27,18 +31,35 @@ export const languages: LanguageServerConfig[] = [
     command: "typescript-language-server",
     args: ["--stdio"],
     rootPatterns: ["tsconfig.json", "package.json"],
+    diagnosticTimeout: 30_000,
+  },
+  {
+    id: "python",
+    extensions: [".py"],
+    command: "pylsp",
+    args: [],
+    rootPatterns: ["pyproject.toml", "setup.py", "requirements.txt"],
+    diagnosticTimeout: 15_000,
+  },
+  {
+    id: "cpp",
+    extensions: [".c", ".cc", ".cpp", ".cxx", ".h", ".hpp", ".hxx"],
+    command: "clangd",
+    args: [],
+    rootPatterns: ["compile_commands.json", "CMakeLists.txt", ".clangd"],
+    diagnosticTimeout: 15_000,
   },
 ];
 
-export function languageForFile(path: string): LanguageServerConfig | undefined {
+export function languageForFile(path: string, configs: LanguageServerConfig[]): LanguageServerConfig | undefined {
   const lower = path.toLowerCase();
-  return languages.find((lang) => lang.extensions.some((ext) => lower.endsWith(ext)));
+  return configs.find((lang) => lang.extensions.some((ext) => lower.endsWith(ext)));
 }
 
-export function checkExtensionOverlaps(): string[] {
+export function checkExtensionOverlaps(configs: LanguageServerConfig[]): string[] {
   const warnings: string[] = [];
   const seen = new Map<string, string>();
-  for (const lang of languages) {
+  for (const lang of configs) {
     for (const ext of lang.extensions) {
       const existing = seen.get(ext);
       if (existing) {

package/src/server-manager.ts

@@ -2,6 +2,8 @@ import { spawn, type ChildProcess } from "node:child_process";
 import { which, fileUri, findWorkspaceRoot } from "./util.js";
 import { createLspClient, type LspClient, type DiagnosticResult } from "./client.js";
 import type { LanguageServerConfig } from "./languages.js";
+import type { Diagnostic } from "vscode-languageserver-protocol";
+import { DEFAULT_DIAGNOSTIC_TIMEOUT, DEFAULT_DOCUMENT_IDLE_TIMEOUT, DEFAULT_MAX_RETRIES } from "./config.js";
 import { readFile } from "node:fs/promises";
 
 interface ManagedServer {
@@ -20,6 +22,7 @@ interface ManagedServer {
 export interface ServerManager {
   handleEdit(filePath: string, config: LanguageServerConfig, cwd: string): Promise<DiagnosticResult>;
   status(): ServerStatus[];
+  getAllDiagnostics(): Map<string, Diagnostic[]>;
   shutdownAll(): Promise<void>;
 }
 
@@ -33,12 +36,24 @@ export interface ServerStatus {
 }
 
 const IDLE_TIMEOUT_MS = 240_000;
-const DIAGNOSTIC_TIMEOUT_MS = 5_000;
 const INIT_TIMEOUT_MS = 10_000;
-const DOCUMENT_IDLE_MS = 120_000;
 const SWEEP_INTERVAL_MS = 60_000;
 
-export function createServerManager(): ServerManager {
+export interface ServerManagerOptions {
+  diagnosticTimeout?: number;
+  documentIdleTimeout?: number;
+  perServerTimeout?: Map<string, number>;
+  maxRetries?: number;
+}
+
+const RETRY_BASE_DELAY_MS = 500;
+const MAX_RETRY_DELAY_MS = 30_000;
+
+export function createServerManager(options: ServerManagerOptions = {}): ServerManager {
+  const diagnosticTimeout = options.diagnosticTimeout ?? DEFAULT_DIAGNOSTIC_TIMEOUT;
+  const documentIdleTimeout = options.documentIdleTimeout ?? DEFAULT_DOCUMENT_IDLE_TIMEOUT;
+  const perServerTimeout = options.perServerTimeout ?? new Map();
+  const defaultMaxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
   const servers = new Map<string, ManagedServer>();
   const pending = new Map<string, Promise<ManagedServer | null>>();
   const disabledBinaries = new Set<string>();
@@ -51,7 +66,7 @@ export function createServerManager(): ServerManager {
       const now = Date.now();
       for (const server of servers.values()) {
         const stale = [...server.openDocuments.entries()]
-          .filter(([, lastActive]) => now - lastActive > DOCUMENT_IDLE_MS);
+          .filter(([, lastActive]) => now - lastActive > documentIdleTimeout);
         for (const [docUri] of stale) {
           server.client.didClose(docUri);
           server.openDocuments.delete(docUri);
@@ -156,7 +171,7 @@ export function createServerManager(): ServerManager {
       idleTimer: null,
       startTime: now,
       lastActivity: now,
-      editQueue: Promise.resolve({ status: "ok", diagnostics: [], otherFiles: [] }),
+      editQueue: Promise.resolve({ status: "ok", diagnostics: [], otherFiles: [], retryAttempts: 0 }),
     };
 
     child.on("exit", () => {
@@ -189,11 +204,19 @@ export function createServerManager(): ServerManager {
     return promise;
   }
 
+  function getMaxRetries(config: LanguageServerConfig): number {
+    const raw = config.maxRetries ?? defaultMaxRetries;
+    if (typeof raw !== "number" || !Number.isFinite(raw)) return defaultMaxRetries;
+    return Math.max(0, Math.min(10, Math.floor(raw)));
+  }
+
   async function doEdit(server: ManagedServer, filePath: string): Promise<DiagnosticResult> {
     resetIdleTimer(server);
 
     const uri = fileUri(filePath);
     const content = await readFile(filePath, "utf-8");
+    const timeout = perServerTimeout.get(server.config.id) ?? server.config.diagnosticTimeout ?? diagnosticTimeout;
+    const retries = getMaxRetries(server.config);
 
     if (server.openDocuments.has(uri)) {
       server.client.didChange(uri, content);
@@ -202,14 +225,33 @@ export function createServerManager(): ServerManager {
     }
     server.openDocuments.set(uri, Date.now());
 
-    return server.client.waitForDiagnostics(uri, DIAGNOSTIC_TIMEOUT_MS);
+    let lastResult = await server.client.waitForDiagnostics(uri, timeout);
+
+    for (let attempt = 0; attempt < retries && lastResult.status === "timeout"; attempt++) {
+      resetIdleTimer(server);
+      const baseDelay = Math.min(RETRY_BASE_DELAY_MS * 2 ** attempt, MAX_RETRY_DELAY_MS);
+      const jitter = baseDelay * Math.random() * 0.5;
+      await new Promise((resolve) => setTimeout(resolve, baseDelay + jitter));
+
+      server.client.didChange(uri, content);
+      server.openDocuments.set(uri, Date.now());
+      const result = await server.client.waitForDiagnostics(uri, timeout);
+      result.retryAttempts = attempt + 1;
+
+      if (result.status === "ok") {
+        return result;
+      }
+      lastResult = result;
+    }
+
+    return lastResult;
   }
 
   return {
     async handleEdit(filePath: string, config: LanguageServerConfig, cwd: string): Promise<DiagnosticResult> {
       const root = await findWorkspaceRoot(filePath, config.rootPatterns, cwd);
       const server = await ensureServer(config, root);
-      if (!server) return { status: "unavailable" as const, diagnostics: [], otherFiles: [] };
+      if (!server) return { status: "unavailable" as const, diagnostics: [], otherFiles: [], retryAttempts: 0 };
 
       // serialize edits per server to avoid concurrent waitForDiagnostics races
       const result = server.editQueue.then(
@@ -231,6 +273,16 @@ export function createServerManager(): ServerManager {
       }));
     },
 
+    getAllDiagnostics(): Map<string, Diagnostic[]> {
+      const result = new Map<string, Diagnostic[]>();
+      for (const server of servers.values()) {
+        for (const [uri, diags] of server.client.getAllDiagnostics()) {
+          result.set(uri, diags);
+        }
+      }
+      return result;
+    },
+
     async shutdownAll() {
       stopSweepTimer();
       const shutdowns = Array.from(servers.values()).map((s) => shutdownServer(s));