@duckmind/dm-linux-x64 0.63.9 → 0.64.2

package/extensions/dm-lens/tools/lsp-diagnostics.js

@@ -0,0 +1,1026 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { Type } from "../clients/deps/typebox.js";
+import {
+  getProjectIgnoreMatcher,
+  isExcludedDirName
+} from "../clients/file-utils.js";
+import {
+  getLSPService,
+  groupFilesByPrimaryServer,
+  runPerServerGroups
+} from "../clients/lsp/index.js";
+import {
+  buildScopeKey,
+  createWorkspaceDiagnosticsCacheContext
+} from "../clients/lsp/workspace-diagnostics-cache.js";
+import {
+  getServersForFileWithConfig,
+  primaryServerId
+} from "../clients/lsp/config.js";
+import {
+  combineAbortSignals,
+  withDeadline
+} from "../clients/deadline-utils.js";
+import {
+  applyAuxiliarySuppressions,
+  retagAuxiliaryDiagnostics
+} from "../clients/dispatch/auxiliary-lsp.js";
+import { detectFileRole } from "../clients/file-role.js";
+import {
+  hashDiagnosticContent,
+  touchCompletedConfirmationPolicy,
+  touchCoverageGap
+} from "../clients/lsp/diagnostic-binding.js";
+import { classifyCascadeWaitTier } from "../clients/lsp/wait-policy/index.js";
+import { attemptTsserverSyncDiagnostics } from "../clients/lsp/tsserver-sync.js";
+import { convertLspDiagnostics } from "../clients/dispatch/utils/lsp-diagnostics.js";
+import { demoteInferredProjectDiagnostics } from "../clients/lsp/inferred-project.js";
+import {
+  isBlocking,
+  reconcileScanDiagnostics
+} from "../clients/widget-state.js";
+import { baseName, compactRenderResult } from "./render-compact.js";
+import { makeProgressReporter, scanningSummaryLine } from "./scan-progress.js";
+import {
+  isWarmAttached,
+  tryWarmAttachedDiagnostics
+} from "../clients/warm-attach.js";
+import {
+  extensionsForLanguage,
+  SCAN_LANGUAGE_PRIORITY
+} from "../clients/language-registry.js";
+const MAX_FILES = 100;
+const MAX_BATCH_FILES = 100;
+const MAX_DIAGNOSTICS = 200;
+const DEFAULT_BATCH_CONCURRENCY = 8;
+const MAX_BATCH_CONCURRENCY = 16;
+const DEFAULT_BATCH_FILE_DEADLINE_MS = 15000;
+const SEVERITY_NAMES = {
+  1: "error",
+  2: "warning",
+  3: "information",
+  4: "hint"
+};
+function batchFileDeadlineMs() {
+  const raw = Number(process.env.DM_LENS_LSP_BATCH_FILE_MS);
+  return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_BATCH_FILE_DEADLINE_MS;
+}
+function lspUnavailableMessage(filePath, health) {
+  if (!health || !String(health.health ?? "").startsWith("no_clients")) {
+    return;
+  }
+  const candidates = health.candidateServerIds?.length ? ` candidates=${health.candidateServerIds.join(",")}` : "";
+  const reason = (health.serverCountAttempted ?? 0) === 0 ? "no LSP server configured" : "no LSP client is currently ready";
+  const stale = (health.mergedCount ?? 0) > 0 ? " Showing stale last-known diagnostics below." : " No diagnostics were collected.";
+  return `LSP unavailable for ${filePath}: ${reason}; ready=${health.serverCountReady ?? 0}/${health.serverCountAttempted ?? 0}.${candidates}.${stale}`;
+}
+function boundedPositiveInt(value, fallback, min, max) {
+  const parsed = typeof value === "number" ? Math.floor(value) : Number.NaN;
+  if (!Number.isFinite(parsed))
+    return fallback;
+  return Math.max(min, Math.min(max, parsed));
+}
+async function mapWithConcurrency(items, concurrency, mapper, lspService, signal, onProgress) {
+  const results = [];
+  let completed = 0;
+  const pendingIndices = new Map;
+  items.forEach((item, index) => {
+    const queue = pendingIndices.get(item);
+    if (queue)
+      queue.push(index);
+    else
+      pendingIndices.set(item, [index]);
+  });
+  const groups = groupFilesByPrimaryServer(items);
+  await runPerServerGroups(groups, concurrency, async (group) => {
+    if (signal?.aborted)
+      return;
+    const first = group.files[0];
+    if (first && lspService && !isWarmAttached() && typeof lspService.ensureWarmForSweep === "function") {
+      await lspService.ensureWarmForSweep(first, { signal });
+      if (signal?.aborted)
+        return;
+    }
+    for (const item of group.files) {
+      if (signal?.aborted)
+        return;
+      const index = pendingIndices.get(item).shift();
+      results[index] = await mapper(item, index);
+      completed += 1;
+      onProgress?.(completed, items.length);
+    }
+  }, signal);
+  return results;
+}
+function projectIgnorePredicate(root) {
+  try {
+    const matcher = getProjectIgnoreMatcher(root);
+    return (fullPath, isDir) => matcher.isIgnored(fullPath, isDir);
+  } catch {
+    return () => false;
+  }
+}
+async function collectFiles(dir, extensions, maxFiles, isIgnored = () => false) {
+  const files = [];
+  async function walk(current) {
+    if (files.length >= maxFiles)
+      return;
+    let entries;
+    try {
+      entries = await fs.promises.readdir(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (files.length >= maxFiles)
+        return;
+      if (entry.isSymbolicLink())
+        continue;
+      const full = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        if (!isExcludedDirName(entry.name) && !isIgnored(full, true))
+          await walk(full);
+      } else if (entry.isFile() && extensions.includes(path.extname(full))) {
+        if (isIgnored(full, false))
+          continue;
+        files.push(full);
+      }
+    }
+  }
+  await walk(dir);
+  return files;
+}
+export function createLspDiagnosticsTool(nextWriteIndex, onConfirmedNoBlockers) {
+  return {
+    name: "lsp_diagnostics",
+    label: "LSP Diagnostics",
+    description: "Get errors, warnings, and hints from language servers for a file or directory. " + "Use BEFORE running builds to proactively check for issues. " + "Works on directories by auto-detecting file extensions and scanning all matching files.",
+    promptSnippet: "Get LSP diagnostics for a file or directory (use before builds)",
+    renderResult: compactRenderResult(({ details, args, isError, text }) => {
+      const scanning = scanningSummaryLine(details, text);
+      if (scanning)
+        return scanning;
+      if (isError) {
+        return `lsp_diagnostics — ${text.split(`
+`)[0] ?? "error"}`;
+      }
+      const count = details?.totalDiagnostics ?? details?.diagnostics?.length ?? 0;
+      const target = baseName(details?.filePath ?? args.path) || "workspace";
+      const files = details?.filesChecked ?? details?.filesScanned;
+      const scope = typeof files === "number" && files > 1 ? ` across ${files} files` : target ? ` ${target}` : "";
+      const noun = count === 1 ? "diagnostic" : "diagnostics";
+      const unconfirmedFiles = details?.unconfirmedFiles ?? 0;
+      if (unconfirmedFiles > 0) {
+        const cleanFiles = details?.cleanFiles ?? 0;
+        const timedOutFiles = details?.timedOutFiles ?? 0;
+        const suffix = timedOutFiles > 0 ? ` (${timedOutFiles} timed out)` : "";
+        return `lsp_diagnostics${scope} — ${count} ${noun} · ${cleanFiles} clean · ${unconfirmedFiles} unconfirmed${suffix}`;
+      }
+      const outcomeCounts = details?.outcomeCounts;
+      const notConfirmed = outcomeCounts ? (outcomeCounts.inconclusive ?? 0) + (outcomeCounts.unavailable ?? 0) + (outcomeCounts.unsupported ?? 0) + (outcomeCounts.failed ?? 0) : 0;
+      if (notConfirmed > 0) {
+        return `lsp_diagnostics${scope} — ${count} ${noun} · ${notConfirmed} checks not confirmed`;
+      }
+      if ((details?.incompleteFiles ?? 0) > 0) {
+        return `lsp_diagnostics${scope} — incomplete (${details?.incompleteFiles} files not confirmed)`;
+      }
+      if (count === 0 && details?.unconfirmed) {
+        return details?.timedOut ? `lsp_diagnostics${scope} — timed out (result may be incomplete)` : `lsp_diagnostics${scope} — unconfirmed (server cannot confirm clean)`;
+      }
+      return `lsp_diagnostics${scope} — ${count} ${noun}`;
+    }),
+    parameters: Type.Object({
+      path: Type.Optional(Type.String({
+        description: "File or directory path to check. For directories, all matching source files are scanned."
+      })),
+      paths: Type.Optional(Type.Array(Type.String(), {
+        minItems: 1,
+        maxItems: MAX_BATCH_FILES,
+        description: "Explicit files to check as a bounded-concurrency batch. When provided, path is ignored."
+      })),
+      severity: Type.Optional(Type.String({
+        enum: ["error", "warning", "information", "hint", "all"],
+        description: "Filter by severity level (default: all)"
+      })),
+      concurrency: Type.Optional(Type.Number({
+        description: "Batch/directory concurrency, in distinct LSP server groups run in parallel " + "(default 8, max 16) — not individual files. Files sharing one server " + "(e.g. a same-language batch) are always processed one at a time against " + "that server regardless of this value; this caps how many DIFFERENT " + "servers run concurrently."
+      })),
+      waitMs: Type.Optional(Type.Number({
+        description: "Optional per-file LSP wait budget for batch diagnostics. Uses server defaults when omitted."
+      })),
+      serverScope: Type.Optional(Type.String({
+        enum: ["primary", "all"],
+        description: "'primary' (fast, low-noise): only the file's actual language " + "server (e.g. typescript) — for 'does this have real type " + "errors'. 'all' (default): also touches cross-cutting auxiliary " + "scanners (ast-grep, opengrep, zizmor, typos, marksman) attached " + "to this file, including findings for files not yet dispatched " + "this session. Primary confirmation is always reported " + "separately from auxiliary findings regardless of this setting."
+      }))
+    }),
+    async execute(_toolCallId, params, _signal, onUpdate, ctx) {
+      const signal = combineAbortSignals(_signal, ctx.signal);
+      const onProgress = makeProgressReporter(onUpdate, "Scanning LSP diagnostics");
+      const typedParams = params;
+      const severity = typedParams.severity ?? "all";
+      const cwd = ctx.cwd ?? process.cwd();
+      const concurrency = boundedPositiveInt(typedParams.concurrency, DEFAULT_BATCH_CONCURRENCY, 1, MAX_BATCH_CONCURRENCY);
+      const waitMs = typeof typedParams.waitMs === "number" && typedParams.waitMs >= 0 ? Math.floor(typedParams.waitMs) : undefined;
+      const serverScope = typedParams.serverScope === "primary" ? "primary" : "all";
+      const lspService = getLSPService();
+      if (!lspService) {
+        return {
+          content: [
+            { type: "text", text: "LSP service not available." }
+          ],
+          isError: true,
+          details: {}
+        };
+      }
+      if (Array.isArray(typedParams.paths) && typedParams.paths.length > 0) {
+        if (typedParams.paths.length > MAX_BATCH_FILES) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `paths accepts at most ${MAX_BATCH_FILES} files; received ${typedParams.paths.length}.`
+              }
+            ],
+            isError: true,
+            details: { mode: "batch", filesChecked: 0 }
+          };
+        }
+        const rawPaths = typedParams.paths.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
+        if (rawPaths.length !== typedParams.paths.length) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "paths must contain non-empty file paths."
+              }
+            ],
+            isError: true,
+            details: { mode: "batch", filesChecked: 0 }
+          };
+        }
+        const absPaths = rawPaths.map((entry) => path.normalize(path.isAbsolute(entry) ? entry : path.resolve(cwd, entry)));
+        return runBatchFileDiagnostics(absPaths, severity, lspService, {
+          concurrency,
+          waitMs,
+          signal,
+          onProgress,
+          nextWriteIndex,
+          serverScope,
+          cwd,
+          onConfirmedNoBlockers
+        });
+      }
+      const rawPath = typedParams.path;
+      if (!rawPath || rawPath.trim().length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "path or paths is required."
+            }
+          ],
+          isError: true,
+          details: {}
+        };
+      }
+      const absPath = path.isAbsolute(rawPath) ? rawPath : path.resolve(cwd, rawPath);
+      let stat;
+      try {
+        stat = fs.statSync(absPath);
+      } catch {
+        return {
+          content: [
+            { type: "text", text: `Path not found: ${absPath}` }
+          ],
+          isError: true,
+          details: {}
+        };
+      }
+      if (stat.isDirectory()) {
+        return runDirectoryDiagnostics(absPath, severity, lspService, {
+          concurrency,
+          waitMs,
+          signal,
+          onProgress,
+          nextWriteIndex,
+          serverScope,
+          cwd,
+          onConfirmedNoBlockers
+        });
+      }
+      return runFileDiagnostics(absPath, severity, lspService, waitMs, nextWriteIndex, serverScope, cwd, onConfirmedNoBlockers);
+    }
+  };
+}
+async function collectDiagnosticsForFile(absPath, lspService, waitMs, serverScope = "all") {
+  let timedOut = false;
+  let content;
+  let touched;
+  let usedTouch = false;
+  try {
+    content = fs.readFileSync(absPath, "utf-8");
+    if (isWarmAttached()) {
+      const attachedBudgetMs = waitMs ?? 15000;
+      const attached = await tryWarmAttachedDiagnostics(absPath, content, attachedBudgetMs, "sweep");
+      if (attached?.available) {
+        const scopedDiagnostics = serverScope === "primary" ? attached.response.diagnostics.filter((item) => item.source === primaryServerId(absPath)) : attached.response.diagnostics;
+        const filtered = applyAuxiliarySuppressions(scopedDiagnostics, content, { fileRole: detectFileRole(absPath, content) });
+        return {
+          diagnostics: filtered,
+          timedOut: false,
+          confirmedByTouch: attached.response.confirmation !== undefined && primaryServerId(absPath) !== "typescript",
+          unconfirmedServerIds: attached.response.unconfirmedServerIds ?? [],
+          content
+        };
+      }
+    }
+    const serviceWithTouch = lspService;
+    if (typeof serviceWithTouch.touchFile === "function") {
+      usedTouch = true;
+      touched = await serviceWithTouch.touchFile(absPath, content, {
+        diagnostics: "document",
+        collectDiagnostics: true,
+        maxClientWaitMs: waitMs,
+        source: "lsp_diagnostics",
+        clientScope: serverScope
+      });
+      timedOut = touched?.inconclusive === true;
+    } else {
+      await lspService.openFile(absPath, content, {
+        preserveDiagnostics: false
+      });
+    }
+  } catch {}
+  const diagnostics = usedTouch && touched !== undefined ? touched.diags : await lspService.getDiagnostics(absPath, waitMs !== undefined ? "document" : "full");
+  const filtered = content !== undefined ? applyAuxiliarySuppressions(diagnostics, content, {
+    fileRole: detectFileRole(absPath, content)
+  }) : diagnostics;
+  const binding = usedTouch ? touched?.binding : undefined;
+  const confirmedByTouch = usedTouch && touchCompletedConfirmationPolicy(touched);
+  return {
+    diagnostics: filtered,
+    timedOut,
+    skipReason: touched?.skipReason,
+    confirmedByTouch,
+    unconfirmedServerIds: usedTouch ? touchCoverageGap(touched) : [],
+    content,
+    binding
+  };
+}
+function diagnosticsToFileDiags(file, diagnostics) {
+  return diagnostics.map((d) => ({
+    file,
+    line: d.range?.start?.line,
+    character: d.range?.start?.character,
+    severity: d.severity,
+    message: d.message,
+    source: d.source,
+    code: d.code
+  }));
+}
+async function classifyEmptyResult(file, lspService) {
+  try {
+    const snapshots = await lspService.getCapabilitySnapshots(file);
+    const tier = classifyCascadeWaitTier(lspService, file, snapshots);
+    return tier === "tier3-silent" ? "unconfirmed" : "clean";
+  } catch {
+    return "clean";
+  }
+}
+async function resolveEmptyResult(file, lspService) {
+  try {
+    const snapshots = await lspService.getCapabilitySnapshots(file);
+    const tier = classifyCascadeWaitTier(lspService, file, snapshots);
+    if (tier !== "tier3-silent") {
+      return { confirmed: true, diagnostics: [] };
+    }
+    const syncDiagnostics = await attemptTsserverSyncDiagnostics(file, lspService);
+    if (syncDiagnostics === undefined) {
+      return { confirmed: false, diagnostics: [] };
+    }
+    return { confirmed: true, diagnostics: syncDiagnostics };
+  } catch {
+    return { confirmed: true, diagnostics: [] };
+  }
+}
+function canTrustTouchConfirmation(file, serverScope, confirmedByTouch) {
+  return confirmedByTouch && (serverScope === "primary" || primaryServerId(file) !== "typescript");
+}
+function coveredSourcesForCheck(file, serverScope, unconfirmedServerIds) {
+  const unconfirmed = new Set(unconfirmedServerIds);
+  const covered = new Set;
+  let servers = [];
+  try {
+    servers = getServersForFileWithConfig(file) ?? [];
+  } catch {
+    return [];
+  }
+  for (const server of servers) {
+    const auxiliary = server.role === "auxiliary";
+    if (auxiliary && serverScope === "primary")
+      continue;
+    if (unconfirmed.has(server.id))
+      continue;
+    covered.add(auxiliary ? server.id : "lsp");
+  }
+  return [...covered];
+}
+function demoteInferredForFile(file, diagnostics, cwd, lspService) {
+  return demoteInferredProjectDiagnostics(diagnostics, {
+    filePath: file,
+    cwd,
+    service: lspService
+  });
+}
+function reconcileWidgetFromLspResult(file, rawDiags, confirmation, writeIndex, cwd, content, boundMismatch = false, observedAt) {
+  const confirmed = (rawDiags.length > 0 || confirmation !== "unconfirmed") && !boundMismatch;
+  if (!confirmed)
+    return { confirmed: false, blocking: true };
+  try {
+    const diagnostics = convertLspDiagnostics(rawDiags, file, {
+      scanOrigin: "lsp_diagnostics"
+    });
+    const retagged = retagAuxiliaryDiagnostics(diagnostics, rawDiags, content ?? "", { cwd, fileRole: detectFileRole(file, content) });
+    reconcileScanDiagnostics(file, retagged, true, writeIndex, observedAt);
+    return { confirmed: true, blocking: retagged.some(isBlocking) };
+  } catch {
+    return { confirmed: false, blocking: true };
+  }
+}
+async function collectFileDiagnosticResult(file, severity, lspService, waitMs, nextWriteIndex, serverScope = "all", cacheCtx, scopeKey, cwd = process.cwd(), onConfirmedNoBlockers) {
+  const writeIndex = nextWriteIndex?.();
+  let stat;
+  try {
+    stat = fs.statSync(file);
+    if (!stat.isFile()) {
+      return { file, diagnostics: [], error: `${file}: not a file` };
+    }
+  } catch {
+    return { file, diagnostics: [], error: `${file}: path not found` };
+  }
+  if (cacheCtx && scopeKey !== undefined) {
+    const cached = cacheCtx.lookup(file, scopeKey);
+    if (cached && cached.binding.boundToCurrentDisk !== false) {
+      const confirmation = cached.diagnostics.length === 0 ? "clean" : undefined;
+      const cachedDiags = await demoteInferredForFile(file, cached.diagnostics, cwd, lspService);
+      const filteredDiags = applySeverityFilter(cachedDiags, severity);
+      reconcileWidgetFromLspResult(file, cachedDiags, confirmation, writeIndex, cwd, undefined, false, cached.scannedAt);
+      return {
+        file,
+        diagnostics: diagnosticsToFileDiags(file, filteredDiags),
+        confirmation,
+        primaryServerId: primaryServerId(file)
+      };
+    }
+  }
+  const {
+    diagnostics: rawDiags,
+    timedOut,
+    confirmedByTouch,
+    unconfirmedServerIds,
+    content: collectedContent,
+    binding,
+    skipReason
+  } = await collectDiagnosticsForFile(file, lspService, waitMs, serverScope);
+  const health = lspService.getDiagnosticsHealth?.(file);
+  let effectiveRawDiags = rawDiags;
+  let confirmation;
+  if (skipReason !== undefined) {
+    confirmation = "unconfirmed";
+  } else if (timedOut) {
+    if (applySeverityFilter(rawDiags, severity).length === 0) {
+      confirmation = "unconfirmed";
+    }
+  } else if (canTrustTouchConfirmation(file, serverScope, confirmedByTouch)) {
+    if (applySeverityFilter(rawDiags, severity).length === 0) {
+      confirmation = "clean";
+    }
+  } else if (rawDiags.length === 0) {
+    const resolved = await resolveEmptyResult(file, lspService);
+    effectiveRawDiags = resolved.diagnostics;
+    confirmation = resolved.confirmed ? resolved.diagnostics.length === 0 ? "clean" : undefined : "unconfirmed";
+  } else if (applySeverityFilter(rawDiags, severity).length === 0) {
+    confirmation = await classifyEmptyResult(file, lspService);
+  }
+  const boundMismatch = binding?.boundToCurrentDisk === false;
+  if (boundMismatch)
+    confirmation = "unconfirmed";
+  if (unconfirmedServerIds.length > 0 && confirmation === "clean") {
+    confirmation = "unconfirmed";
+  }
+  effectiveRawDiags = await demoteInferredForFile(file, effectiveRawDiags, cwd, lspService);
+  const filteredDiags = applySeverityFilter(effectiveRawDiags, severity);
+  const verdict = reconcileWidgetFromLspResult(file, effectiveRawDiags, confirmation, writeIndex, cwd, collectedContent, boundMismatch);
+  if (verdict.confirmed && !verdict.blocking) {
+    onConfirmedNoBlockers?.({
+      filePath: file,
+      writeIndex,
+      coveredSources: coveredSourcesForCheck(file, serverScope, unconfirmedServerIds),
+      cwd
+    });
+  }
+  if (cacheCtx && scopeKey !== undefined && confirmation !== "unconfirmed" && unconfirmedServerIds.length === 0) {
+    cacheCtx.record(file, scopeKey, effectiveRawDiags, stat.mtimeMs, collectedContent !== undefined ? hashDiagnosticContent(collectedContent) : undefined, stat.size);
+  }
+  return {
+    file,
+    diagnostics: diagnosticsToFileDiags(file, filteredDiags),
+    unavailable: lspUnavailableMessage(file, health),
+    confirmation,
+    timedOut: confirmation === "unconfirmed" ? timedOut : undefined,
+    ...skipReason !== undefined && { skipReason },
+    primaryServerId: primaryServerId(file)
+  };
+}
+async function runFileDiagnostics(absPath, severity, lspService, waitMs, nextWriteIndex, serverScope = "all", cwd = process.cwd(), onConfirmedNoBlockers) {
+  const writeIndex = nextWriteIndex?.();
+  const {
+    diagnostics: rawDiags,
+    timedOut,
+    confirmedByTouch,
+    unconfirmedServerIds,
+    content: collectedContent,
+    binding,
+    skipReason
+  } = await collectDiagnosticsForFile(absPath, lspService, waitMs, serverScope);
+  const lspHealth = lspService.getDiagnosticsHealth?.(absPath);
+  const unavailable = lspUnavailableMessage(absPath, lspHealth);
+  let effectiveRawDiags = rawDiags;
+  let confirmation;
+  if (skipReason !== undefined) {
+    confirmation = "unconfirmed";
+  } else if (timedOut) {
+    if (applySeverityFilter(rawDiags, severity).length === 0) {
+      confirmation = "unconfirmed";
+    }
+  } else if (canTrustTouchConfirmation(absPath, serverScope, confirmedByTouch)) {
+    if (applySeverityFilter(rawDiags, severity).length === 0) {
+      confirmation = "clean";
+    }
+  } else if (rawDiags.length === 0) {
+    const resolved = await resolveEmptyResult(absPath, lspService);
+    effectiveRawDiags = resolved.diagnostics;
+    confirmation = resolved.confirmed ? resolved.diagnostics.length === 0 ? "clean" : undefined : "unconfirmed";
+  } else if (applySeverityFilter(rawDiags, severity).length === 0) {
+    confirmation = await classifyEmptyResult(absPath, lspService);
+  }
+  const boundMismatch = binding?.boundToCurrentDisk === false;
+  if (boundMismatch)
+    confirmation = "unconfirmed";
+  const primaryCoverageGapOnly = unconfirmedServerIds.length > 0 && confirmation === "clean";
+  if (primaryCoverageGapOnly)
+    confirmation = "unconfirmed";
+  effectiveRawDiags = await demoteInferredForFile(absPath, effectiveRawDiags, cwd, lspService);
+  const filtered = applySeverityFilter(effectiveRawDiags, severity);
+  const total = filtered.length;
+  const truncated = total > MAX_DIAGNOSTICS;
+  const limited = truncated ? filtered.slice(0, MAX_DIAGNOSTICS) : filtered;
+  const unconfirmed = confirmation === "unconfirmed";
+  const verdict = reconcileWidgetFromLspResult(absPath, effectiveRawDiags, confirmation, writeIndex, cwd, collectedContent, boundMismatch);
+  if (verdict.confirmed && !verdict.blocking) {
+    onConfirmedNoBlockers?.({
+      filePath: absPath,
+      writeIndex,
+      coveredSources: coveredSourcesForCheck(absPath, serverScope, unconfirmedServerIds),
+      cwd
+    });
+  }
+  const primaryId = primaryServerId(absPath);
+  const primaryDiags = limited.filter((d) => d.source === primaryId);
+  const auxiliaryDiags = limited.filter((d) => d.source !== primaryId);
+  const primaryLine = (() => {
+    if (timedOut) {
+      return "Primary LSP: check timed out — NOT the same as 0 diagnostics; the " + "file may still have errors that just hadn't been reported yet. " + "Re-check after the server settles, or increase waitMs.";
+    }
+    if (unconfirmed && !primaryCoverageGapOnly) {
+      return `Primary LSP${primaryId ? ` (${primaryId})` : ""}: unconfirmed — ` + "cannot confirm clean (push-only, silent-on-clean, e.g. classic " + "typescript-language-server never publishes on a clean re-check). " + "NOT the same as 0 diagnostics; re-check after an edit, or use " + "waitMs to wait longer.";
+    }
+    if (primaryDiags.length === 0) {
+      return `Primary LSP${primaryId ? ` (${primaryId})` : ""}: confirmed clean.`;
+    }
+    return `Primary LSP${primaryId ? ` (${primaryId})` : ""}: ${primaryDiags.length} diagnostic${primaryDiags.length === 1 ? "" : "s"}.`;
+  })();
+  const coverageLine = unconfirmedServerIds.length > 0 ? `Auxiliary coverage INCOMPLETE — ${[...unconfirmedServerIds].join(", ")} did not answer within the wait budget, so ${unconfirmedServerIds.length === 1 ? "its findings are" : "their findings are"} NOT included here. This is not a clean bill of health for ${unconfirmedServerIds.length === 1 ? "that scanner" : "those scanners"}; re-check after the next edit, or use waitMs to wait longer.` : undefined;
+  let text;
+  if (total === 0) {
+    text = [
+      primaryLine,
+      "",
+      unavailable ?? "No auxiliary findings.",
+      ...coverageLine ? [coverageLine] : []
+    ].join(`
+`);
+  } else {
+    const lines = [primaryLine, ""];
+    if (primaryDiags.length > 0) {
+      lines.push(...primaryDiags.map(formatDiag), "");
+    }
+    if (auxiliaryDiags.length > 0) {
+      lines.push(`Auxiliary findings (${auxiliaryDiags.length}):`);
+      lines.push(...auxiliaryDiags.map(formatDiag));
+    }
+    if (coverageLine)
+      lines.push("", coverageLine);
+    if (unavailable)
+      lines.unshift(unavailable, "");
+    if (truncated) {
+      lines.unshift(`Found ${total} diagnostics (showing first ${MAX_DIAGNOSTICS}):`);
+    }
+    text = lines.join(`
+`);
+  }
+  return {
+    content: [{ type: "text", text }],
+    details: {
+      filePath: absPath,
+      mode: "file",
+      severity,
+      serverScope,
+      primaryServerId: primaryId,
+      primaryDiagnosticsCount: primaryDiags.length,
+      auxiliaryDiagnosticsCount: auxiliaryDiags.length,
+      diagnostics: limited.map((d) => ({
+        line: d.range?.start?.line,
+        character: d.range?.start?.character,
+        severity: d.severity,
+        message: d.message,
+        source: d.source,
+        code: d.code
+      })),
+      totalDiagnostics: total,
+      truncated,
+      unconfirmed,
+      timedOut: unconfirmed ? timedOut : undefined,
+      ...skipReason !== undefined && { skipReason },
+      ...unconfirmedServerIds.length > 0 && {
+        unconfirmedServerIds: [...unconfirmedServerIds]
+      },
+      lspHealth,
+      waitMs
+    }
+  };
+}
+function tallyConfirmation(results) {
+  let clean = 0;
+  let unconfirmed = 0;
+  let timedOut = 0;
+  for (const result of results) {
+    if (result.diagnostics.length > 0)
+      continue;
+    if (result.confirmation === "unconfirmed") {
+      unconfirmed += 1;
+      if (result.timedOut)
+        timedOut += 1;
+    } else {
+      clean += 1;
+    }
+  }
+  return { clean, unconfirmed, timedOut };
+}
+function classifyBatchFileOutcome(result) {
+  if (result.error)
+    return "failed";
+  if (result.timedOut || result.confirmation === "unconfirmed") {
+    return "inconclusive";
+  }
+  if (result.diagnostics.length > 0)
+    return "findings";
+  if (result.unavailable) {
+    return result.primaryServerId ? "unavailable" : "unsupported";
+  }
+  if (!result.primaryServerId)
+    return "unsupported";
+  return "clean";
+}
+function inconclusiveBatchResult(file, reason) {
+  return {
+    file,
+    diagnostics: [],
+    confirmation: "unconfirmed",
+    timedOut: true,
+    outcome: "inconclusive",
+    inconclusiveReason: reason
+  };
+}
+function unconfirmedReasonClause(unconfirmed, timedOut) {
+  const silent = unconfirmed - timedOut;
+  if (timedOut > 0 && silent > 0) {
+    return `${timedOut} timed out (check didn't complete within budget) and ` + `${silent} from a server that cannot confirm clean (push-only, ` + "silent-on-clean).";
+  }
+  if (timedOut > 0) {
+    return `${timedOut} timed out (check didn't complete within the wait budget).`;
+  }
+  return "from a server that cannot confirm clean (push-only, silent-on-clean; " + "e.g. classic typescript-language-server does not publish on a clean " + "re-check).";
+}
+async function collectBatchDiagnostics(files, severity, lspService, options) {
+  const resolvedCwd = options.cwd ?? process.cwd();
+  const cacheCtx = createWorkspaceDiagnosticsCacheContext(resolvedCwd);
+  const scopeKey = buildScopeKey(options.serverScope ?? "all");
+  const results = await mapWithConcurrency(files, options.concurrency, async (file) => {
+    const work = collectFileDiagnosticResult(file, severity, lspService, options.waitMs, options.nextWriteIndex, options.serverScope, cacheCtx, scopeKey, resolvedCwd, options.onConfirmedNoBlockers);
+    const bounded = withDeadline(work, {
+      ms: batchFileDeadlineMs(),
+      onTimeout: "undefined",
+      onReject: "undefined"
+    });
+    const result = options.signal ? await Promise.race([
+      bounded,
+      new Promise((resolve) => {
+        if (options.signal?.aborted) {
+          resolve(undefined);
+          return;
+        }
+        options.signal?.addEventListener("abort", () => resolve(undefined), {
+          once: true
+        });
+      })
+    ]) : await bounded;
+    return result ?? inconclusiveBatchResult(file, options.signal?.aborted ? "Batch aborted before this file completed." : `File check exceeded ${batchFileDeadlineMs()}ms.`);
+  }, lspService, options.signal, options.onProgress);
+  cacheCtx.persist();
+  const fileErrors = results.flatMap((result) => result.error ? [result.error] : []);
+  const lspHealthWarnings = results.flatMap((result) => result.unavailable ? [result.unavailable] : []);
+  const allDiags = results.flatMap((result) => result.diagnostics);
+  const total = allDiags.length;
+  const truncated = total > MAX_DIAGNOSTICS;
+  const display = truncated ? allDiags.slice(0, MAX_DIAGNOSTICS) : allDiags;
+  const { clean, unconfirmed, timedOut } = tallyConfirmation(results);
+  for (const result of results) {
+    result.outcome = classifyBatchFileOutcome(result);
+  }
+  const outcomeCounts = Object.fromEntries([
+    "clean",
+    "findings",
+    "unsupported",
+    "unavailable",
+    "failed",
+    "inconclusive"
+  ].map((outcome) => [
+    outcome,
+    results.filter((result) => result.outcome === outcome).length
+  ]));
+  const primaryIdByFile = new Map(results.map((r) => [r.file, r.primaryServerId]));
+  const primaryDisplay = display.filter((d) => d.source === primaryIdByFile.get(d.file));
+  const auxiliaryDisplay = display.filter((d) => d.source !== primaryIdByFile.get(d.file));
+  return {
+    results,
+    fileErrors,
+    lspHealthWarnings,
+    total,
+    truncated,
+    display,
+    primaryDisplay,
+    auxiliaryDisplay,
+    clean,
+    unconfirmed,
+    timedOut,
+    outcomeCounts,
+    incompleteFiles: Math.max(0, files.length - results.length)
+  };
+}
+async function runBatchFileDiagnostics(absPaths, severity, lspService, options) {
+  if (absPaths.length === 0) {
+    return {
+      content: [{ type: "text", text: "No file paths provided." }],
+      isError: true,
+      details: { mode: "batch", severity, filesChecked: 0 }
+    };
+  }
+  const {
+    results,
+    fileErrors,
+    lspHealthWarnings,
+    total,
+    truncated,
+    display,
+    primaryDisplay,
+    auxiliaryDisplay,
+    clean,
+    unconfirmed,
+    timedOut,
+    outcomeCounts,
+    incompleteFiles
+  } = await collectBatchDiagnostics(absPaths, severity, lspService, options);
+  const lines = [
+    `Files checked: ${results.length}`,
+    `Total diagnostics: ${total}`,
+    `Concurrency: ${options.concurrency}`
+  ];
+  if (options.waitMs !== undefined)
+    lines.push(`Wait budget: ${options.waitMs}ms`);
+  lines.push(`Outcomes: ${Object.entries(outcomeCounts).map(([outcome, count]) => `${outcome}=${count}`).join(", ")}`);
+  const notConfirmed = outcomeCounts.inconclusive + outcomeCounts.unavailable + outcomeCounts.unsupported + outcomeCounts.failed + incompleteFiles;
+  if (notConfirmed > 0) {
+    lines.push("", `Checks not confirmed: ${notConfirmed} (inconclusive/unavailable/unsupported/failed or not started).`);
+  }
+  if (incompleteFiles > 0) {
+    lines.push("", `Batch incomplete: ${incompleteFiles} file${incompleteFiles === 1 ? "" : "s"} were not confirmed because the batch was aborted.`);
+  }
+  if (fileErrors.length > 0)
+    lines.push("", "File errors:", ...fileErrors);
+  if (lspHealthWarnings.length > 0) {
+    lines.push("", "LSP health warnings:", ...lspHealthWarnings.slice(0, 10));
+  }
+  if (unconfirmed > 0) {
+    lines.push("", `${clean} file${clean === 1 ? "" : "s"} confirmed clean, ${unconfirmed} unconfirmed: ` + `${unconfirmedReasonClause(unconfirmed, timedOut)} NOT the same as 0 diagnostics.`);
+  }
+  if (display.length === 0) {
+    if (unconfirmed === 0) {
+      lines.push("", "No diagnostics found.");
+    }
+  } else {
+    if (primaryDisplay.length > 0) {
+      lines.push("", `Primary findings (${primaryDisplay.length}):`);
+      lines.push(...primaryDisplay.map(formatDisplayDiag));
+    }
+    if (auxiliaryDisplay.length > 0) {
+      lines.push("", `Auxiliary findings (${auxiliaryDisplay.length}):`);
+      lines.push(...auxiliaryDisplay.map(formatDisplayDiag));
+    }
+    if (truncated) {
+      lines.push("", `... (${total - MAX_DIAGNOSTICS} more diagnostics not shown)`);
+    }
+  }
+  return {
+    content: [{ type: "text", text: lines.join(`
+`) }],
+    details: {
+      mode: "batch",
+      severity,
+      serverScope: options.serverScope ?? "all",
+      filesChecked: results.length,
+      concurrency: options.concurrency,
+      waitMs: options.waitMs,
+      diagnostics: display,
+      primaryDiagnosticsCount: primaryDisplay.length,
+      auxiliaryDiagnosticsCount: auxiliaryDisplay.length,
+      totalDiagnostics: total,
+      truncated,
+      cleanFiles: clean,
+      unconfirmedFiles: unconfirmed,
+      timedOutFiles: timedOut > 0 ? timedOut : undefined,
+      outcomes: results.map((result) => ({
+        file: result.file,
+        outcome: result.outcome,
+        reason: result.inconclusiveReason ?? result.error ?? result.unavailable,
+        primaryDiagnosticsCount: result.diagnostics.filter((diagnostic) => diagnostic.source === result.primaryServerId).length,
+        auxiliaryDiagnosticsCount: result.diagnostics.filter((diagnostic) => diagnostic.source !== result.primaryServerId).length
+      })),
+      outcomeCounts,
+      incompleteFiles: incompleteFiles > 0 ? incompleteFiles : undefined,
+      fileErrors: fileErrors.length > 0 ? fileErrors : undefined,
+      lspHealthWarnings: lspHealthWarnings.length > 0 ? lspHealthWarnings : undefined
+    }
+  };
+}
+export async function resolveDirectoryScanExtensions(hasMatch) {
+  for (const family of SCAN_LANGUAGE_PRIORITY) {
+    const exts = family.flatMap((languageId) => extensionsForLanguage(languageId));
+    if (await hasMatch(exts)) {
+      return exts;
+    }
+  }
+  return;
+}
+async function runDirectoryDiagnostics(absPath, severity, lspService, options) {
+  let collectedFiles = [];
+  const isIgnored = projectIgnorePredicate(absPath);
+  await resolveDirectoryScanExtensions(async (exts) => {
+    collectedFiles = await collectFiles(absPath, [...exts], MAX_FILES + 1, isIgnored);
+    return collectedFiles.length > 0;
+  });
+  if (collectedFiles.length === 0) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `No supported source files found in: ${absPath}`
+        }
+      ],
+      details: {
+        filePath: absPath,
+        mode: "directory",
+        severity,
+        filesScanned: 0
+      }
+    };
+  }
+  const wasCapped = collectedFiles.length > MAX_FILES;
+  const filesToProcess = collectedFiles.slice(0, MAX_FILES);
+  const {
+    fileErrors,
+    lspHealthWarnings,
+    total,
+    truncated,
+    display,
+    primaryDisplay,
+    auxiliaryDisplay,
+    clean,
+    unconfirmed,
+    timedOut
+  } = await collectBatchDiagnostics(filesToProcess, severity, lspService, options);
+  let text;
+  if (total === 0) {
+    const cleanLine = unconfirmed > 0 ? `${clean} clean · ${unconfirmed} unconfirmed: ` + `${unconfirmedReasonClause(unconfirmed, timedOut)} NOT the same as 0 diagnostics.` : "No diagnostics found.";
+    text = [
+      `Directory: ${absPath}`,
+      `Files scanned: ${filesToProcess.length}${wasCapped ? ` (capped at ${MAX_FILES})` : ""}`,
+      ...lspHealthWarnings.length > 0 ? [
+        "LSP unavailable for one or more files:",
+        ...lspHealthWarnings.slice(0, 10)
+      ] : [cleanLine]
+    ].join(`
+`);
+  } else {
+    const lines = [
+      `Directory: ${absPath}`,
+      `Files scanned: ${filesToProcess.length}${wasCapped ? ` (capped at ${MAX_FILES})` : ""}`,
+      `Files with errors: ${new Set(display.map((d) => d.file)).size}`,
+      `Total diagnostics: ${total}`,
+      ...lspHealthWarnings.length > 0 ? ["", "LSP health warnings:", ...lspHealthWarnings.slice(0, 10)] : [],
+      ...unconfirmed > 0 ? [
+        "",
+        `${clean} other file${clean === 1 ? "" : "s"} confirmed clean, ${unconfirmed} unconfirmed: ` + unconfirmedReasonClause(unconfirmed, timedOut)
+      ] : [],
+      ""
+    ];
+    const toRelative = (d) => ({
+      ...d,
+      file: path.relative(absPath, d.file)
+    });
+    if (primaryDisplay.length > 0) {
+      lines.push(`Primary findings (${primaryDisplay.length}):`);
+      lines.push(...primaryDisplay.map(toRelative).map(formatDisplayDiag));
+      lines.push("");
+    }
+    if (auxiliaryDisplay.length > 0) {
+      lines.push(`Auxiliary findings (${auxiliaryDisplay.length}):`);
+      lines.push(...auxiliaryDisplay.map(toRelative).map(formatDisplayDiag));
+    }
+    if (truncated) {
+      lines.push("", `... (${total - MAX_DIAGNOSTICS} more diagnostics not shown)`);
+    }
+    text = lines.join(`
+`);
+  }
+  return {
+    content: [{ type: "text", text }],
+    details: {
+      filePath: absPath,
+      mode: "directory",
+      severity,
+      serverScope: options.serverScope ?? "all",
+      filesScanned: filesToProcess.length,
+      capped: wasCapped,
+      diagnostics: display.map((d) => ({
+        file: path.relative(absPath, d.file),
+        line: d.line,
+        character: d.character,
+        severity: d.severity,
+        message: d.message,
+        source: d.source,
+        code: d.code
+      })),
+      primaryDiagnosticsCount: primaryDisplay.length,
+      auxiliaryDiagnosticsCount: auxiliaryDisplay.length,
+      totalDiagnostics: total,
+      truncated,
+      cleanFiles: clean,
+      unconfirmedFiles: unconfirmed,
+      timedOutFiles: timedOut > 0 ? timedOut : undefined,
+      fileErrors: fileErrors.length > 0 ? fileErrors : undefined,
+      lspHealthWarnings: lspHealthWarnings.length > 0 ? lspHealthWarnings : undefined,
+      concurrency: options.concurrency,
+      waitMs: options.waitMs
+    }
+  };
+}
+function applySeverityFilter(diags, severity) {
+  if (severity === "all")
+    return diags;
+  const maxLevel = {
+    error: 1,
+    warning: 2,
+    information: 3,
+    hint: 4
+  };
+  const max = maxLevel[severity] ?? 0;
+  if (max === 0)
+    return diags;
+  return diags.filter((d) => (d.severity ?? 3) <= max);
+}
+function formatDisplayDiag(d) {
+  const sevName = SEVERITY_NAMES[d.severity] ?? "unknown";
+  const loc = d.line !== undefined ? `${d.file}:${d.line + 1}:${(d.character ?? 0) + 1}` : d.file;
+  const src = d.source ? `[${d.source}]` : "";
+  const code = d.code ? ` (${d.code})` : "";
+  return `${loc}: ${sevName}${src}${code}: ${d.message}`;
+}
+function formatDiag(diag) {
+  const loc = diag.range?.start?.line !== undefined ? `L${diag.range.start.line + 1}:${(diag.range.start.character ?? 0) + 1}` : "";
+  const src = diag.source ? `[${diag.source}]` : "";
+  const code = diag.code ? ` (${diag.code})` : "";
+  const sevName = SEVERITY_NAMES[diag.severity] ?? "unknown";
+  return `${loc}: ${sevName}${src}${code}: ${diag.message}`;
+}