pi-ui-extend 0.1.5 → 0.1.8

package/external/pi-tools-suite/src/default-pi-tools-suite-config.ts

@@ -5,7 +5,6 @@ export const DEFAULT_PI_TOOLS_SUITE_CONFIG_JSONC = `{
   "disabledModules": [
     // "ast-grep",
     // "async-subagents",
-    // "terminal-bell",
     // "lsp",
     // "repo-discovery",
     // "antigravity-auth",
@@ -16,6 +15,14 @@ export const DEFAULT_PI_TOOLS_SUITE_CONFIG_JSONC = `{
     // "dcp"
   ],
 
+  // Renderer bundled terminal-bell notification settings.
+  "terminalBell": {
+    // Toggle terminal-bell attention signals across supported OSes:
+    // terminal BEL, macOS notification sound, and system notifications
+    // (macOS terminal-notifier/osascript or Linux notify-send when available).
+    "sound": true
+  },
+
   // Dynamic Context Pruning (DCP) module config.
   // The DCP module owns the compress tool and /dcp commands.
   "dcp": {

package/external/pi-tools-suite/src/index.ts

@@ -12,7 +12,6 @@ type ExtensionModule = {
 const MODULES: Array<{ name: string; load: () => Promise<ExtensionModule> }> = [
 	{ name: "ast-grep", load: () => import("./ast-grep/index") },
 	{ name: "async-subagents", load: () => import("./async-subagents/index") },
-	{ name: "terminal-bell", load: () => import("./terminal-bell/index") },
 	{ name: "lsp", load: () => import("./lsp/index") },
 	{ name: "repo-discovery", load: () => import("./repo-discovery/index") },
 	{ name: "antigravity-auth", load: () => import("./antigravity-auth/index") },

package/external/pi-tools-suite/src/lsp/_shared/config.ts

@@ -1,12 +1,19 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { parse as parseJsonc } from "jsonc-parser";
+import { getPiToolsSuiteUserConfigPath } from "../../config";
 import { findUp } from "./paths";
 import { askProjectConfigTrust, sha256 } from "./trust";
 import type { ConfigLayer, LoadedConfig, LspConfigFile, LspServerConfig, MatchableConfig } from "./types";
 
-function defaultAgentDir(): string {
-  return process.env.PI_AGENT_DIR ?? path.join(process.env.HOME ?? "", ".pi", "agent");
+function getPiConfigDir(): string | undefined {
+  const configured = process.env.PI_CONFIG_DIR;
+  return configured && configured.trim() !== "" ? configured : undefined;
+}
+
+function findProjectSuiteConfig(startDir: string): string | undefined {
+  return findUp(startDir, path.join(".pi", "pi-tools-suite.jsonc"));
 }
 
 function asObject(value: unknown): Record<string, unknown> | undefined {
@@ -78,9 +85,16 @@ function parseLspItems(parsed: unknown): LspServerConfig[] {
   return out;
 }
 
-async function readJsonLayer<TItem extends MatchableConfig>(options: {
+function extractLspConfig(parsed: unknown): unknown {
+  const root = asObject(parsed);
+  if (!root) return undefined;
+  return root.lsp;
+}
+
+async function readJsoncLayer<TItem extends MatchableConfig>(options: {
   scope: "global" | "project";
   filePath: string;
+  selectConfig?: (parsed: unknown) => unknown;
   parseItems: (parsed: unknown) => TItem[];
 }): Promise<ConfigLayer<TItem> | undefined> {
   let raw: string;
@@ -91,14 +105,19 @@ async function readJsonLayer<TItem extends MatchableConfig>(options: {
     throw error;
   }
 
-  const parsed = JSON.parse(raw) as unknown;
+  const parsed = parseJsonc(raw) as unknown;
+  const selected = options.selectConfig ? options.selectConfig(parsed) : parsed;
+  if (selected === undefined) return undefined;
+  const items = options.parseItems(selected);
+  if (items.length === 0) return undefined;
+
   return {
     scope: options.scope,
     path: options.filePath,
     dir: path.dirname(options.filePath),
     raw,
     hash: sha256(raw),
-    items: options.parseItems(parsed),
+    items,
   };
 }
 
@@ -123,19 +142,25 @@ function binariesForLsp(items: LspServerConfig[]): string[] {
 export async function loadLspConfig(ctx: ExtensionContext): Promise<LoadedConfig<LspServerConfig>> {
   const warnings: string[] = [];
   const layers: ConfigLayer<LspServerConfig>[] = [];
-  const globalPath = path.join(defaultAgentDir(), "lsp.json");
+  const piConfigDir = getPiConfigDir();
+  const globalPaths = [
+    getPiToolsSuiteUserConfigPath(process.env.HOME),
+    piConfigDir ? path.join(piConfigDir, "pi-tools-suite.jsonc") : undefined,
+  ].filter((item): item is string => typeof item === "string");
 
-  try {
-    const globalLayer = await readJsonLayer({ scope: "global", filePath: globalPath, parseItems: parseLspItems });
-    if (globalLayer) layers.push(globalLayer);
-  } catch (error) {
-    warnings.push(`Failed to load global lsp config: ${(error as Error).message}`);
+  for (const globalPath of globalPaths) {
+    try {
+      const globalLayer = await readJsoncLayer({ scope: "global", filePath: globalPath, selectConfig: extractLspConfig, parseItems: parseLspItems });
+      if (globalLayer) layers.push(globalLayer);
+    } catch (error) {
+      warnings.push(`Failed to load global lsp config ${globalPath}: ${(error as Error).message}`);
+    }
   }
 
-  const projectPath = findUp(ctx.cwd, path.join(".pi", "lsp.json"));
+  const projectPath = findProjectSuiteConfig(ctx.cwd);
   if (projectPath) {
     try {
-      const projectLayer = await readJsonLayer({ scope: "project", filePath: projectPath, parseItems: parseLspItems });
+      const projectLayer = await readJsoncLayer({ scope: "project", filePath: projectPath, selectConfig: extractLspConfig, parseItems: parseLspItems });
       if (projectLayer) {
         const decision = await askProjectConfigTrust({
           ctx,

package/external/pi-tools-suite/src/lsp/_shared/paths.ts

@@ -3,6 +3,7 @@ import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import type { CommandConfig, PathPlaceholders, ResolvedCommand } from "./types";
 import { applyTemplate, applyTemplateArray, applyTemplateRecord } from "./template";
+import { matchesGlob } from "./glob";
 
 export function expandHome(input: string): string {
   if (input === "~") return process.env.HOME ?? input;
@@ -26,7 +27,16 @@ export function isSubPathOrSame(parent: string, child: string): boolean {
 }
 
 export function markerExists(candidateDir: string, marker: string): boolean {
-  return fs.existsSync(path.resolve(candidateDir, marker));
+  if (!/[?*[]/.test(marker)) return fs.existsSync(path.resolve(candidateDir, marker));
+
+  const markerDir = path.dirname(marker);
+  const markerPattern = path.basename(marker);
+  const absoluteMarkerDir = path.resolve(candidateDir, markerDir === "." ? "" : markerDir);
+  try {
+    return fs.readdirSync(absoluteMarkerDir).some((entry) => matchesGlob(markerPattern, entry));
+  } catch {
+    return false;
+  }
 }
 
 export function findProjectRoot(filePath: string, rootMarkers: string[] | undefined, fallbackRoot: string): string | undefined {

package/external/pi-tools-suite/src/lsp/async.ts

@@ -18,12 +18,17 @@ export function delay(ms: number, signal?: AbortSignal): Promise<void> {
   });
 }
 
-export async function withTimeout<T>(promise: Promise<T>, timeoutMs: number, label: string): Promise<T> {
+export async function withTimeout<T>(promise: Promise<T>, timeoutMs: number, label: string, signal?: AbortSignal): Promise<T> {
+  if (signal?.aborted) throw new Error("aborted");
   let timeout: NodeJS.Timeout | undefined;
+  let abort: (() => void) | undefined;
   const timeoutPromise = new Promise<never>((_resolve, reject) => {
     timeout = setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs);
+    abort = () => reject(new Error("aborted"));
+    signal?.addEventListener("abort", abort, { once: true });
   });
   return Promise.race([promise, timeoutPromise]).finally(() => {
     if (timeout) clearTimeout(timeout);
+    if (abort) signal?.removeEventListener("abort", abort);
   });
 }

package/external/pi-tools-suite/src/lsp/child-process.ts

@@ -10,6 +10,7 @@ function canWriteToChild(child: ChildProcessWithoutNullStreams): boolean {
 }
 
 export function killChild(child: ChildProcessWithoutNullStreams, signal: NodeJS.Signals): boolean {
+  let signaled = false;
   try {
     if (process.platform === "win32" && child.pid) {
       const result = spawnSync("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
@@ -19,9 +20,22 @@ export function killChild(child: ChildProcessWithoutNullStreams, signal: NodeJS.
       });
       if (!result.error && result.status === 0) return true;
     }
-    return child.kill(signal);
+
+    if (child.pid) {
+      try {
+        // LSP clients are spawned in their own process group on POSIX. Kill the
+        // whole group so wrapper scripts also lose children such as Godot and nc.
+        process.kill(-child.pid, signal);
+        signaled = true;
+      } catch {
+        // Fall back to the direct child below. The process may not be detached
+        // or may have already exited.
+      }
+    }
+
+    return child.kill(signal) || signaled;
   } catch {
-    return false;
+    return signaled;
   }
 }
 

package/external/pi-tools-suite/src/lsp/client.ts

@@ -1,13 +1,16 @@
 import path from "node:path";
+import fs from "node:fs/promises";
 import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
 import type { MessageConnection } from "vscode-jsonrpc";
 import { createMessageConnection, StreamMessageReader, StreamMessageWriter } from "vscode-jsonrpc/node";
 import {
   DefinitionRequest,
+  DiagnosticRefreshRequest,
   DidChangeConfigurationNotification,
   DidChangeTextDocumentNotification,
   DidOpenTextDocumentNotification,
   DidSaveTextDocumentNotification,
+  DocumentDiagnosticRequest,
   DocumentSymbolRequest,
   ExecuteCommandRequest,
   HoverRequest,
@@ -16,6 +19,7 @@ import {
   PublishDiagnosticsNotification,
   ReferencesRequest,
   type Diagnostic,
+  type DocumentDiagnosticReport,
   type InitializeResult,
   type ServerCapabilities,
 } from "vscode-languageserver-protocol";
@@ -24,11 +28,38 @@ import { bestEffortWriteJsonRpc, isChildRunning, killChild, terminateChild } fro
 import { DEFAULT_STARTUP_TIMEOUT_MS, REQUEST_TIMEOUT_MS } from "./constants";
 import { DocumentStore } from "./documents";
 import type { DiagnosticsStore } from "./diagnostics-store";
-import { filePathToUri } from "./_shared/paths";
+import { filePathToUri, uriToFilePath } from "./_shared/paths";
 import { isExecutableAvailable } from "./_shared/runner";
 import type { LspServerConfig, ResolvedCommand } from "./_shared/types";
 import { supportsSave } from "./lsp-utils";
 import type { OpenDocument } from "./types";
+
+interface MarkdownToken {
+  type: string;
+  markup: string;
+  content: string;
+  map: number[] | null;
+  children: MarkdownToken[] | null;
+}
+
+function markdownTextToken(content: string): MarkdownToken {
+  return { type: "text", markup: "", content, map: null, children: null };
+}
+
+function parseMarkdownTokens(text: string): MarkdownToken[] {
+  const tokens: MarkdownToken[] = [];
+  const lines = text.split(/\r?\n/);
+  for (let lineNumber = 0; lineNumber < lines.length; lineNumber += 1) {
+    const line = lines[lineNumber];
+    const heading = /^(#{1,6})\s+(.+?)\s*#*\s*$/.exec(line);
+    if (!heading) continue;
+    const [, markup, content] = heading;
+    tokens.push({ type: "heading_open", markup, content: "", map: [lineNumber, lineNumber + 1], children: null });
+    tokens.push({ type: "inline", markup: "", content, map: [lineNumber, lineNumber + 1], children: [markdownTextToken(content.trim())] });
+    tokens.push({ type: "heading_close", markup, content: "", map: null, children: null });
+  }
+  return tokens;
+}
 import { tsserverDiagnosticToLsp, tsserverDiagnosticsFromResponse } from "./tsserver";
 
 export class LspClient {
@@ -40,6 +71,8 @@ export class LspClient {
   private initialized = false;
   private unavailableReason: string | undefined;
   private stderrTail = "";
+  private readonly dynamicDiagnosticProviders = new Map<string, string | undefined>();
+  private diagnosticProviderWaiters: Array<() => void> = [];
 
   constructor(
     private readonly server: LspServerConfig,
@@ -76,6 +109,7 @@ export class LspClient {
     const child = spawn(this.command.bin, this.command.args, {
       cwd: this.command.cwd,
       env: this.command.env ? { ...process.env, ...this.command.env } : process.env,
+      detached: process.platform !== "win32",
       shell: false,
       stdio: ["pipe", "pipe", "pipe"],
     });
@@ -113,6 +147,7 @@ export class LspClient {
       Promise.race([connection.sendRequest(InitializeRequest.method, this.initializeParams()), startupFailure]),
       this.server.startupTimeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS,
       `${this.server.id} initialize`,
+      signal,
     )) as InitializeResult;
     this.capabilities = initializeResult.capabilities;
     failStartup = undefined;
@@ -136,10 +171,12 @@ export class LspClient {
         window: { workDoneProgress: true },
         workspace: {
           configuration: true,
+          diagnostics: { refreshSupport: true },
           workspaceFolders: true,
           didChangeWatchedFiles: { dynamicRegistration: true },
         },
         textDocument: {
+          diagnostic: { dynamicRegistration: true, relatedDocumentSupport: true },
           synchronization: {
             didOpen: true,
             didChange: true,
@@ -178,8 +215,67 @@ export class LspClient {
       return items.map(() => this.server.settings ?? {});
     });
     anyConnection.onRequest("workspace/workspaceFolders", () => [{ name: path.basename(this.root), uri: filePathToUri(this.root) }]);
-    anyConnection.onRequest("client/registerCapability", () => null);
-    anyConnection.onRequest("client/unregisterCapability", () => null);
+    anyConnection.onRequest("markdown/parse", async (params: unknown) => {
+      const request = params as { uri?: unknown; text?: unknown } | undefined;
+      const text = typeof request?.text === "string"
+        ? request.text
+        : typeof request?.uri === "string"
+          ? this.documents.get(uriToFilePath(request.uri))?.text ?? await fs.readFile(uriToFilePath(request.uri), "utf8")
+          : "";
+      return parseMarkdownTokens(text);
+    });
+    anyConnection.onRequest("markdown/fs/readFile", async (params: unknown) => {
+      const uri = (params as { uri?: unknown } | undefined)?.uri;
+      if (typeof uri !== "string") return [];
+      return [...await fs.readFile(uriToFilePath(uri))];
+    });
+    anyConnection.onRequest("markdown/fs/stat", async (params: unknown) => {
+      const uri = (params as { uri?: unknown } | undefined)?.uri;
+      if (typeof uri !== "string") return undefined;
+      try {
+        const stat = await fs.stat(uriToFilePath(uri));
+        return { isDirectory: stat.isDirectory() };
+      } catch {
+        return undefined;
+      }
+    });
+    anyConnection.onRequest("markdown/fs/readDirectory", async (params: unknown) => {
+      const uri = (params as { uri?: unknown } | undefined)?.uri;
+      if (typeof uri !== "string") return [];
+      try {
+        const entries = await fs.readdir(uriToFilePath(uri), { withFileTypes: true });
+        return entries.map((entry) => [entry.name, { isDirectory: entry.isDirectory() }]);
+      } catch {
+        return [];
+      }
+    });
+    anyConnection.onRequest("markdown/fs/watcher/create", () => null);
+    anyConnection.onRequest("markdown/fs/watcher/delete", () => null);
+    anyConnection.onRequest("markdown/findMarkdownFilesInWorkspace", () => []);
+    anyConnection.onRequest("client/registerCapability", (params: unknown) => {
+      const registrations = (params as { registrations?: unknown[] } | undefined)?.registrations;
+      if (!Array.isArray(registrations)) return null;
+
+      for (const registration of registrations) {
+        const item = registration as { id?: unknown; method?: unknown; registerOptions?: unknown };
+        if (typeof item.id !== "string" || item.method !== DocumentDiagnosticRequest.method) continue;
+        const options = item.registerOptions as { identifier?: unknown } | undefined;
+        this.dynamicDiagnosticProviders.set(item.id, typeof options?.identifier === "string" ? options.identifier : undefined);
+      }
+      this.resolveDiagnosticProviderWaiters();
+      return null;
+    });
+    anyConnection.onRequest("client/unregisterCapability", (params: unknown) => {
+      const unregisterations = (params as { unregisterations?: unknown[] } | undefined)?.unregisterations;
+      if (!Array.isArray(unregisterations)) return null;
+
+      for (const registration of unregisterations) {
+        const item = registration as { id?: unknown; method?: unknown };
+        if (typeof item.id === "string" && item.method === DocumentDiagnosticRequest.method) this.dynamicDiagnosticProviders.delete(item.id);
+      }
+      return null;
+    });
+    anyConnection.onRequest(DiagnosticRefreshRequest.method, () => null);
     anyConnection.onRequest("window/workDoneProgress/create", () => null);
     anyConnection.onNotification("window/logMessage", () => undefined);
     anyConnection.onNotification("telemetry/event", () => undefined);
@@ -226,7 +322,50 @@ export class LspClient {
     return Array.isArray(commands) && commands.includes("typescript.tsserverRequest");
   }
 
-  async tsserverDiagnostics(file: string, text: string, timeoutMs: number): Promise<Diagnostic[] | undefined> {
+  private supportsPullDiagnostics(): boolean {
+    return !!this.capabilities?.diagnosticProvider || this.dynamicDiagnosticProviders.size > 0;
+  }
+
+  private resolveDiagnosticProviderWaiters(): void {
+    const waiters = this.diagnosticProviderWaiters;
+    this.diagnosticProviderWaiters = [];
+    for (const waiter of waiters) waiter();
+  }
+
+  private async waitForPullDiagnosticsSupport(timeoutMs: number, signal?: AbortSignal): Promise<void> {
+    if (this.supportsPullDiagnostics() || timeoutMs <= 0) return;
+    await withTimeout(new Promise<void>((resolve) => {
+      this.diagnosticProviderWaiters.push(resolve);
+    }), timeoutMs, `${this.server.id} diagnostic registration`, signal).catch(() => undefined);
+  }
+
+  private diagnosticProviderIdentifiers(): Array<string | undefined> {
+    const identifiers: Array<string | undefined> = [];
+    const provider = this.capabilities?.diagnosticProvider;
+    if (provider) {
+      identifiers.push(
+        typeof provider === "object" && "identifier" in provider && typeof provider.identifier === "string"
+          ? provider.identifier
+          : undefined,
+      );
+    }
+    for (const identifier of this.dynamicDiagnosticProviders.values()) identifiers.push(identifier);
+
+    const seen = new Set<string>();
+    return identifiers.filter((identifier) => {
+      const key = identifier ?? "";
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+  }
+
+  private diagnosticsFromReport(report: DocumentDiagnosticReport | null | undefined): Diagnostic[] | undefined {
+    if (!report || report.kind !== "full") return undefined;
+    return report.items;
+  }
+
+  async tsserverDiagnostics(file: string, text: string, timeoutMs: number, signal?: AbortSignal): Promise<Diagnostic[] | undefined> {
     const connection = this.connection;
     if (!connection || !this.supportsTsserverDiagnostics()) return undefined;
 
@@ -252,11 +391,51 @@ export class LspClient {
       }),
       timeoutMs,
       `${this.server.id} ${request.command}`,
+      signal,
     )));
 
     return responses.flatMap((response) => tsserverDiagnosticsFromResponse(response).map((diagnostic) => tsserverDiagnosticToLsp(diagnostic, text)));
   }
 
+  async pullDiagnostics(file: string, timeoutMs: number, signal?: AbortSignal): Promise<Diagnostic[] | undefined> {
+    const connection = this.connection;
+    if (!connection) return undefined;
+    if (!this.supportsPullDiagnostics()) {
+      await this.waitForPullDiagnosticsSupport(this.server.id === "csharp" ? Math.min(timeoutMs, 5_000) : 250, signal);
+    }
+    if (!this.supportsPullDiagnostics()) return undefined;
+    const identifiers = this.diagnosticProviderIdentifiers();
+    if (identifiers.length === 0) return undefined;
+
+    const uri = filePathToUri(file);
+    const settled = await Promise.allSettled(identifiers.map(async (identifier) => {
+      const report = (await withTimeout(
+        connection.sendRequest(DocumentDiagnosticRequest.method, {
+          textDocument: { uri },
+          identifier,
+        }),
+        timeoutMs,
+        `${this.server.id} textDocument/diagnostic${identifier ? ` (${identifier})` : ""}`,
+        signal,
+      )) as DocumentDiagnosticReport | null;
+      return this.diagnosticsFromReport(report) ?? [];
+    }));
+
+    const fulfilled = settled.filter((result): result is PromiseFulfilledResult<Diagnostic[]> => result.status === "fulfilled");
+    if (fulfilled.length === 0) {
+      const firstError = settled.find((result): result is PromiseRejectedResult => result.status === "rejected")?.reason;
+      throw firstError instanceof Error ? firstError : new Error(String(firstError ?? "pull diagnostics failed"));
+    }
+
+    const seen = new Set<string>();
+    return fulfilled.flatMap((result) => result.value).filter((diagnostic) => {
+      const key = JSON.stringify([diagnostic.range, diagnostic.severity, diagnostic.source, diagnostic.code, diagnostic.message]);
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+  }
+
   async hover(file: string, line: number, character: number): Promise<unknown> {
     if (!this.connection) throw new Error(`${this.server.id}: LSP connection unavailable`);
     return withTimeout(

package/external/pi-tools-suite/src/lsp/manager.ts

@@ -9,6 +9,7 @@ import { filePathToUri, findProjectRoot, normalizeRelativePath, resolveCommand,
 import { formatLspDiagnostics, formatWarnings, joinSections } from "./_shared/output";
 import type { LspServerConfig, StoredDiagnostics } from "./_shared/types";
 import { clientKey, couldMatchBeforeRoot, fileSizeAllowed, languageIdForFile, readTextFile } from "./lsp-utils";
+import { localMarkdownDiagnostics } from "./markdown-diagnostics";
 import type { MatchedServer } from "./types";
 
 function isFreshDiagnosticsEntry(entry: StoredDiagnostics | undefined, since: number, version: number | undefined): entry is StoredDiagnostics {
@@ -17,6 +18,27 @@ function isFreshDiagnosticsEntry(entry: StoredDiagnostics | undefined, since: nu
     && (entry.version === undefined || version === undefined || entry.version >= version);
 }
 
+function diagnosticsWithLocalFallback(serverId: string, file: string, text: string, diagnostics: StoredDiagnostics["diagnostics"]): StoredDiagnostics["diagnostics"] {
+  if (serverId !== "markdown") return diagnostics;
+  const hasLanguageServerLinkDiagnostics = diagnostics.some((diagnostic) => typeof diagnostic.code === "string" && diagnostic.code.startsWith("link."));
+  const localDiagnostics = localMarkdownDiagnostics(file, text).filter((diagnostic) => {
+    if (!hasLanguageServerLinkDiagnostics) return true;
+    return !(typeof diagnostic.code === "string" && diagnostic.code.startsWith("link."));
+  });
+  if (localDiagnostics.length === 0) return diagnostics;
+
+  const seen = new Set(diagnostics.map((diagnostic) => JSON.stringify([diagnostic.range, diagnostic.severity, diagnostic.source, diagnostic.code, diagnostic.message])));
+  return [
+    ...diagnostics,
+    ...localDiagnostics.filter((diagnostic) => {
+      const key = JSON.stringify([diagnostic.range, diagnostic.severity, diagnostic.source, diagnostic.code, diagnostic.message]);
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    }),
+  ];
+}
+
 export class LspManager {
   private readonly diagnostics = new DiagnosticsStore();
   private readonly clients = new Map<string, LspClient>();
@@ -115,16 +137,30 @@ export class LspManager {
         // diagnostics don't degrade into a misleading publishDiagnostics timeout.
         let tsserverFallbackError: string | undefined;
         try {
-          const tsserverDiagnostics = await client.tsserverDiagnostics(file, text, diagnosticsWaitMs);
+          const tsserverDiagnostics = await client.tsserverDiagnostics(file, text, diagnosticsWaitMs, ctx.signal);
           if (tsserverDiagnostics !== undefined) {
-            this.diagnostics.set(match.server.id, match.root, filePathToUri(file), tsserverDiagnostics, doc.version);
-            lines.push(formatLspDiagnostics(match.server.id, file, tsserverDiagnostics, match.root));
+            const diagnostics = diagnosticsWithLocalFallback(match.server.id, file, text, tsserverDiagnostics);
+            this.diagnostics.set(match.server.id, match.root, filePathToUri(file), diagnostics, doc.version);
+            lines.push(formatLspDiagnostics(match.server.id, file, diagnostics, match.root));
             continue;
           }
         } catch (error) {
           tsserverFallbackError = (error as Error).message;
         }
 
+        let pullDiagnosticsError: string | undefined;
+        try {
+          const pulledDiagnostics = await client.pullDiagnostics(file, diagnosticsWaitMs, ctx.signal);
+          if (pulledDiagnostics !== undefined) {
+            const diagnostics = diagnosticsWithLocalFallback(match.server.id, file, text, pulledDiagnostics);
+            this.diagnostics.set(match.server.id, match.root, filePathToUri(file), diagnostics, doc.version);
+            lines.push(formatLspDiagnostics(match.server.id, file, diagnostics, match.root));
+            continue;
+          }
+        } catch (error) {
+          pullDiagnosticsError = (error as Error).message;
+        }
+
         const entry = await this.diagnostics.waitForFile(
           match.server.id,
           match.root,
@@ -136,10 +172,13 @@ export class LspManager {
         );
         if (!isFreshDiagnosticsEntry(entry, startedAt, doc.version)) {
           const fallbackSuffix = tsserverFallbackError ? `; tsserver fallback failed: ${tsserverFallbackError}` : "";
-          lines.push(`⚠️ ${match.server.id}: timed out after ${diagnosticsWaitMs}ms waiting for fresh diagnostics for ${match.relFile}${fallbackSuffix}`);
+          const pullSuffix = pullDiagnosticsError ? `; pull diagnostics failed: ${pullDiagnosticsError}` : "";
+          lines.push(`⚠️ ${match.server.id}: timed out after ${diagnosticsWaitMs}ms waiting for fresh diagnostics for ${match.relFile}${fallbackSuffix}${pullSuffix}`);
           continue;
         }
-        lines.push(formatLspDiagnostics(match.server.id, file, entry.diagnostics, match.root));
+        const diagnostics = diagnosticsWithLocalFallback(match.server.id, file, text, entry.diagnostics);
+        if (diagnostics !== entry.diagnostics) this.diagnostics.set(match.server.id, match.root, filePathToUri(file), diagnostics, doc.version);
+        lines.push(formatLspDiagnostics(match.server.id, file, diagnostics, match.root));
       } catch (error) {
         lines.push(`⚠️ ${match.server.id}: ${(error as Error).message}`);
       }