@duckmind/dm-darwin-x64 0.66.5 → 0.66.7

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

@@ -0,0 +1,1198 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getProjectIgnoreMatcher, isExcludedDirName } from "../clients/file-utils.js";
+import { getLSPService, groupFilesByPrimaryServer, runPerServerGroups } from "../clients/lsp/capabilities.js";
+import { buildScopeKey, createWorkspaceDiagnosticsCacheContext } from "../clients/lsp/workspace-diagnostics-cache.js";
+import { getServersForFileWithConfig, primaryServerId, resolveLspCwdForFile } from "../clients/lsp/config.js";
+import { describeRootFallback } from "../clients/lsp/server.js";
+import { isAuxiliary } from "../clients/lsp/server-traits.js";
+import { mapWithConcurrency } from "../clients/map-with-concurrency.js";
+import { combineAbortSignals, withDeadline } from "../clients/deadline-utils.js";
+import { applyAuxiliarySuppressions, retagAuxiliaryDiagnostics } from "../clients/dispatch/auxiliary-lsp.js";
+import { applyLspFindingPolicy, loadProjectRulePolicyMap } from "../clients/dispatch/finding-policy.js";
+import { hasStrictDispositionMarks } from "../clients/diagnostic-dispositions.js";
+import { recordDegradationOnce } from "../clients/degradation-ledger.js";
+import { logLatency } from "../clients/latency-logger.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 { normalizeMapKey } from "../clients/path-utils.js";
+import { countRetainedSuppressedRows, isBlocking, reconcileScanDiagnostics } from "../clients/widget-state.js";
+import { makeProgressReporter } from "./scan-progress.js";
+import { isWarmAttached, tryWarmAttachedDiagnostics } from "../clients/warm-attach.js";
+import { extensionsForLanguage, SCAN_LANGUAGE_PRIORITY } from "../clients/language-registry.js";
+import { exceedsLspSyncLimits } from "../clients/lsp/content-limits.js";
+const MAX_FILES = 100;
+export 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;
+export const SEVERITY_NAMES = {
+  1: "error",
+  2: "warning",
+  3: "information",
+  4: "hint"
+};
+export const LSP_SEVERITY_FILTERS = [
+  ...Object.values(SEVERITY_NAMES),
+  "all"
+];
+function assertNeverBatchFileOutcome(value) {
+  throw new Error(`Unhandled batch file outcome: ${String(value)}`);
+}
+export function renderBatchOutcomeLines(outcomes, formatFile = (file) => file) {
+  const lines = [];
+  for (const outcome of outcomes) {
+    switch (outcome.outcome) {
+      case "too_large":
+        lines.push(`${formatFile(outcome.file)}: ${outcome.reason ?? "file too large for LSP diagnostics"}`);
+        break;
+      case "clean":
+      case "findings":
+      case "unsupported":
+      case "unavailable":
+      case "failed":
+      case "inconclusive":
+        break;
+      default:
+        assertNeverBatchFileOutcome(outcome.outcome);
+    }
+  }
+  return lines;
+}
+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));
+}
+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, getService = getLSPService) {
+  return {
+    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 = getService();
+      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 expanded = await expandPathsToFiles(cwd, rawPaths);
+        if (expanded.files.length === 0) {
+          const { listed, text } = describeDirectoriesWithoutFiles(expanded.directoriesWithoutFiles);
+          return {
+            content: [{ type: "text", text }],
+            details: {
+              mode: "batch",
+              severity,
+              filesChecked: 0,
+              directoriesWithoutFiles: listed
+            }
+          };
+        }
+        return runBatchFileDiagnostics(expanded.files, severity, lspService, {
+          concurrency,
+          waitMs,
+          signal,
+          onProgress,
+          nextWriteIndex,
+          serverScope,
+          cwd,
+          onConfirmedNoBlockers
+        }, expanded);
+      }
+      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 = normalizeMapKey(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, scanRoot, waitMs, serverScope = "all") {
+  let timedOut = false;
+  let content;
+  let touched;
+  try {
+    content = fs.readFileSync(absPath, "utf-8");
+    const contentLimit = exceedsLspSyncLimits(content);
+    if (contentLimit.tooLarge) {
+      const reason = `file too large for LSP diagnostics (${contentLimit.reason})`;
+      recordDegradationOnce({
+        kind: "lsp-diagnostics-file-too-large",
+        subject: absPath,
+        reason
+      });
+      return {
+        diagnostics: [],
+        timedOut: false,
+        confirmedByTouch: false,
+        unconfirmedServerIds: [],
+        diagnosticsUnsupportedServerIds: [],
+        content,
+        tooLargeReason: reason
+      };
+    }
+    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.serverId === primaryServerId(absPath)) : attached.response.diagnostics;
+        const filtered = applyAuxiliarySuppressions(scopedDiagnostics, content, {
+          fileRole: detectFileRole(absPath, content),
+          filePath: absPath,
+          scanRoot
+        });
+        return {
+          diagnostics: filtered,
+          timedOut: false,
+          confirmedByTouch: attached.response.confirmation !== undefined && primaryServerId(absPath) !== "typescript",
+          unconfirmedServerIds: attached.response.unconfirmedServerIds ?? [],
+          diagnosticsUnsupportedServerIds: [],
+          content
+        };
+      }
+    }
+    touched = await lspService.touchFile(absPath, content, {
+      diagnostics: "document",
+      collectDiagnostics: true,
+      maxClientWaitMs: waitMs,
+      source: "lsp_diagnostics",
+      clientScope: serverScope,
+      saved: true
+    });
+    timedOut = touched?.inconclusive === true;
+  } catch {}
+  const diagnostics = touched !== undefined ? touched.diags : await lspService.getDiagnostics(absPath, waitMs !== undefined ? "document" : "full");
+  const filtered = content !== undefined ? applyAuxiliarySuppressions(diagnostics, content, {
+    fileRole: detectFileRole(absPath, content),
+    filePath: absPath,
+    scanRoot
+  }) : diagnostics;
+  const binding = touched?.binding;
+  const confirmedByTouch = touchCompletedConfirmationPolicy(touched);
+  return {
+    diagnostics: filtered,
+    timedOut,
+    skipReason: touched?.skipReason,
+    confirmedByTouch,
+    unconfirmedServerIds: touchCoverageGap(touched),
+    diagnosticsUnsupportedServerIds: touched?.diagnosticsUnsupportedServerIds ?? [],
+    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,
+    serverId: d.serverId,
+    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 primaryRootFallback(file, cwd) {
+  const seen = [];
+  await resolveLspCwdForFile(file, cwd, (fallback) => seen.push(fallback));
+  return seen.find((fallback) => fallback.requiresProjectRoot);
+}
+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 = isAuxiliary(server);
+    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 applyProbeFindingPolicy(file, diagnostics, cwd, content, severity) {
+  const started = Date.now();
+  try {
+    const result = applyLspFindingPolicy(diagnostics, {
+      cwd,
+      filePath: file,
+      content,
+      policyMap: loadProjectRulePolicyMap(cwd),
+      fileRole: detectFileRole(file, content)
+    });
+    const inScopeBefore = applySeverityFilter(diagnostics, severity).length;
+    const suppressed = inScopeBefore - applySeverityFilter(result.kept, severity).length;
+    if (suppressed > 0) {
+      logLatency({
+        type: "phase",
+        toolName: "lsp_diagnostics",
+        filePath: file,
+        phase: "lsp_probe_disposition_filter",
+        durationMs: Date.now() - started,
+        metadata: {
+          suppressed,
+          total: inScopeBefore,
+          retainedSuppressed: countRetainedSuppressedRows(file)
+        }
+      });
+    }
+    return { kept: result.kept, inlineKept: result.inlineKept, suppressed };
+  } catch (err) {
+    recordDegradationOnce({
+      kind: "lsp-probe-finding-policy",
+      subject: cwd,
+      reason: err instanceof Error ? err.message : String(err)
+    });
+    return { kept: diagnostics, inlineKept: diagnostics, suppressed: 0 };
+  }
+}
+function replayContentForStrictMarks(file, cwd) {
+  if (!hasStrictDispositionMarks(cwd))
+    return;
+  try {
+    return fs.readFileSync(file, "utf-8");
+  } catch {
+    return;
+  }
+}
+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) });
+    const reconciled = reconcileScanDiagnostics(file, retagged, true, writeIndex, observedAt);
+    if (!reconciled)
+      return { confirmed: false, blocking: true };
+    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?.();
+  const scannedAt = Date.now();
+  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 demotedCached = await demoteInferredForFile(file, cached.diagnostics, cwd, lspService);
+      const cachedPolicy = applyProbeFindingPolicy(file, demotedCached, cwd, replayContentForStrictMarks(file, cwd), severity);
+      const cachedDiags = cachedPolicy.kept;
+      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),
+        ...cachedPolicy.suppressed > 0 && {
+          dispositionSuppressed: cachedPolicy.suppressed
+        }
+      };
+    }
+  }
+  const { diagnostics: rawDiags, timedOut, confirmedByTouch, unconfirmedServerIds, diagnosticsUnsupportedServerIds, content: collectedContent, binding, tooLargeReason, skipReason } = await collectDiagnosticsForFile(file, lspService, cwd, waitMs, serverScope);
+  if (tooLargeReason !== undefined) {
+    return { file, diagnostics: [], outcome: "too_large", tooLargeReason };
+  }
+  const health = lspService.getDiagnosticsHealth?.(file);
+  let effectiveRawDiags = rawDiags;
+  let confirmation;
+  if (diagnosticsUnsupportedServerIds.length > 0) {
+    confirmation = undefined;
+  } else 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";
+  const rootFallback = confirmation === "clean" ? await primaryRootFallback(file, cwd) : undefined;
+  if (rootFallback)
+    confirmation = "unconfirmed";
+  if (unconfirmedServerIds.length > 0 && confirmation === "clean") {
+    confirmation = "unconfirmed";
+  }
+  effectiveRawDiags = await demoteInferredForFile(file, effectiveRawDiags, cwd, lspService);
+  const policy = applyProbeFindingPolicy(file, effectiveRawDiags, cwd, collectedContent, severity);
+  effectiveRawDiags = policy.kept;
+  const filteredDiags = applySeverityFilter(effectiveRawDiags, severity);
+  const verdict = reconcileWidgetFromLspResult(file, effectiveRawDiags, confirmation, writeIndex, cwd, collectedContent, boundMismatch, scannedAt);
+  if (verdict.confirmed && !verdict.blocking) {
+    onConfirmedNoBlockers?.({
+      filePath: file,
+      writeIndex,
+      coveredSources: coveredSourcesForCheck(file, serverScope, unconfirmedServerIds),
+      cwd
+    });
+  }
+  if (cacheCtx && scopeKey !== undefined && confirmation !== "unconfirmed" && diagnosticsUnsupportedServerIds.length === 0 && unconfirmedServerIds.length === 0) {
+    cacheCtx.record(file, scopeKey, policy.inlineKept, stat.mtimeMs, collectedContent !== undefined ? hashDiagnosticContent(collectedContent) : undefined, stat.size, scannedAt);
+  }
+  return {
+    file,
+    diagnostics: diagnosticsToFileDiags(file, filteredDiags),
+    unavailable: lspUnavailableMessage(file, health),
+    confirmation,
+    timedOut: confirmation === "unconfirmed" ? timedOut : undefined,
+    ...rootFallback && { rootFallback },
+    ...skipReason !== undefined && { skipReason },
+    primaryServerId: primaryServerId(file),
+    diagnosticsUnsupported: diagnosticsUnsupportedServerIds.length > 0,
+    ...policy.suppressed > 0 && {
+      dispositionSuppressed: policy.suppressed
+    }
+  };
+}
+async function runFileDiagnostics(absPath, severity, lspService, waitMs, nextWriteIndex, serverScope = "all", cwd = process.cwd(), onConfirmedNoBlockers) {
+  const writeIndex = nextWriteIndex?.();
+  const observedAt = Date.now();
+  const { diagnostics: rawDiags, timedOut, confirmedByTouch, unconfirmedServerIds, diagnosticsUnsupportedServerIds, content: collectedContent, binding, tooLargeReason, skipReason } = await collectDiagnosticsForFile(absPath, lspService, cwd, waitMs, serverScope);
+  if (tooLargeReason !== undefined) {
+    return {
+      content: [{ type: "text", text: tooLargeReason }],
+      details: {
+        filePath: absPath,
+        mode: "file",
+        severity,
+        serverScope,
+        outcome: "too_large",
+        tooLargeReason,
+        diagnostics: [],
+        totalDiagnostics: 0
+      }
+    };
+  }
+  const lspHealth = lspService.getDiagnosticsHealth?.(absPath);
+  const unavailable = lspUnavailableMessage(absPath, lspHealth);
+  let effectiveRawDiags = rawDiags;
+  let confirmation;
+  if (diagnosticsUnsupportedServerIds.length > 0) {
+    confirmation = undefined;
+  } else 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 rootFallback = confirmation === "clean" ? await primaryRootFallback(absPath, cwd) : undefined;
+  if (rootFallback)
+    confirmation = "unconfirmed";
+  const primaryCoverageGapOnly = unconfirmedServerIds.length > 0 && confirmation === "clean";
+  if (primaryCoverageGapOnly)
+    confirmation = "unconfirmed";
+  effectiveRawDiags = await demoteInferredForFile(absPath, effectiveRawDiags, cwd, lspService);
+  const policy = applyProbeFindingPolicy(absPath, effectiveRawDiags, cwd, collectedContent, severity);
+  effectiveRawDiags = policy.kept;
+  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, observedAt);
+  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.serverId === primaryId);
+  const auxiliaryDiags = limited.filter((d) => d.serverId !== primaryId);
+  const primaryLine = (() => {
+    if (diagnosticsUnsupportedServerIds.length > 0) {
+      return `Primary LSP${primaryId ? ` (${primaryId})` : ""}: navigation-only — diagnostics unsupported (no pull provider or publish evidence).`;
+    }
+    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 (rootFallback) {
+      return `Primary LSP${primaryId ? ` (${primaryId})` : ""}: unconfirmed — ` + `${describeRootFallback(rootFallback)}. NOT the same as 0 diagnostics; ` + "check the file from inside its project and re-run.";
+    }
+    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. waitMs can extend an ordinary wait, but it cannot override a session-demoted scanner.` : undefined;
+  const suppressedLine = dispositionSuppressedLine(policy.suppressed);
+  let text;
+  if (total === 0) {
+    text = [
+      primaryLine,
+      "",
+      unavailable ?? "No auxiliary findings.",
+      ...coverageLine ? [coverageLine] : [],
+      ...suppressedLine ? [suppressedLine] : []
+    ].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 (suppressedLine)
+      lines.push("", suppressedLine);
+    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,
+      ...unavailable ? { unavailable } : {},
+      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,
+      ...policy.suppressed > 0 && {
+        dispositionSuppressed: policy.suppressed
+      },
+      truncated,
+      unconfirmed,
+      timedOut: unconfirmed ? timedOut : undefined,
+      navigationOnlyFiles: diagnosticsUnsupportedServerIds.length > 0 ? 1 : undefined,
+      ...skipReason !== undefined && { skipReason },
+      ...rootFallback && {
+        rootFallbackReason: describeRootFallback(rootFallback)
+      },
+      ...unconfirmedServerIds.length > 0 && {
+        unconfirmedServerIds: [...unconfirmedServerIds]
+      },
+      lspHealth,
+      waitMs
+    }
+  };
+}
+function tallyConfirmation(results) {
+  let clean = 0;
+  let unconfirmed = 0;
+  let timedOut = 0;
+  const rootFallbackReasons = new Set;
+  let navigationOnly = 0;
+  let tooLarge = 0;
+  for (const result of results) {
+    if (result.tooLargeReason) {
+      tooLarge += 1;
+      continue;
+    }
+    if (result.diagnosticsUnsupported) {
+      navigationOnly += 1;
+      continue;
+    }
+    if (result.diagnostics.length > 0)
+      continue;
+    if (result.confirmation === "unconfirmed") {
+      unconfirmed += 1;
+      if (result.timedOut)
+        timedOut += 1;
+      if (result.rootFallback) {
+        rootFallbackReasons.add(describeRootFallback(result.rootFallback));
+      }
+    } else if (classifyBatchFileOutcome(result) === "clean") {
+      clean += 1;
+    }
+  }
+  return {
+    clean,
+    unconfirmed,
+    timedOut,
+    rootFallbackReasons: [...rootFallbackReasons],
+    navigationOnly,
+    tooLarge
+  };
+}
+function classifyBatchFileOutcome(result) {
+  if (result.error)
+    return "failed";
+  if (result.tooLargeReason)
+    return "too_large";
+  if (result.diagnosticsUnsupported)
+    return "unsupported";
+  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, rootFallbackReasons = []) {
+  if (rootFallbackReasons.length > 0) {
+    return `${rootFallbackReasons.join("; ")} (${unconfirmed} unconfirmed in all).`;
+  }
+  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 resultsByIndex = new Map;
+  let completed = 0;
+  const pendingIndices = new Map;
+  files.forEach((file, index) => {
+    const queue = pendingIndices.get(file);
+    if (queue)
+      queue.push(index);
+    else
+      pendingIndices.set(file, [index]);
+  });
+  const groups = groupFilesByPrimaryServer(files);
+  await runPerServerGroups(groups, options.concurrency, async (group) => {
+    if (options.signal?.aborted)
+      return;
+    const first = group.files[0];
+    if (first && lspService && !isWarmAttached() && typeof lspService.ensureWarmForSweep === "function") {
+      await lspService.ensureWarmForSweep(first, {
+        signal: options.signal
+      });
+      if (options.signal?.aborted)
+        return;
+    }
+    await mapWithConcurrency(group.files, 1, async (file) => {
+      const index = pendingIndices.get(file).shift();
+      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;
+      resultsByIndex.set(index, result ?? inconclusiveBatchResult(file, options.signal?.aborted ? "Batch aborted before this file completed." : `File check exceeded ${batchFileDeadlineMs()}ms.`));
+      completed += 1;
+      options.onProgress?.(completed, files.length);
+    }, options.signal);
+  }, options.signal);
+  const results = [...resultsByIndex.entries()].sort(([left], [right]) => left - right).map(([, result]) => result);
+  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, rootFallbackReasons } = tallyConfirmation(results);
+  for (const result of results) {
+    result.outcome = classifyBatchFileOutcome(result);
+  }
+  const outcomeCounts = Object.fromEntries([
+    "clean",
+    "findings",
+    "unsupported",
+    "unavailable",
+    "failed",
+    "too_large",
+    "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.serverId === primaryIdByFile.get(d.file));
+  const auxiliaryDisplay = display.filter((d) => d.serverId !== primaryIdByFile.get(d.file));
+  return {
+    results,
+    fileErrors,
+    lspHealthWarnings,
+    total,
+    truncated,
+    display,
+    primaryDisplay,
+    auxiliaryDisplay,
+    clean,
+    unconfirmed,
+    timedOut,
+    rootFallbackReasons,
+    outcomeCounts,
+    incompleteFiles: Math.max(0, files.length - results.length)
+  };
+}
+async function expandPathsToFiles(cwd, rawPaths) {
+  const explicitFiles = [];
+  const directories = [];
+  const seenFileKeys = new Set;
+  for (const entry of rawPaths) {
+    const abs = normalizeMapKey(path.resolve(cwd, entry));
+    let stat;
+    try {
+      stat = fs.statSync(abs);
+    } catch {}
+    if (stat?.isDirectory()) {
+      directories.push(abs);
+    } else {
+      explicitFiles.push(abs);
+      seenFileKeys.add(abs);
+    }
+  }
+  const files = [...explicitFiles];
+  const directoriesWithoutFiles = [];
+  let capped = false;
+  for (const directory of directories) {
+    const collected = await collectDirectoryScanFiles(directory, MAX_FILES - files.length, seenFileKeys);
+    capped ||= collected.capped;
+    if (collected.eligible === 0)
+      directoriesWithoutFiles.push(directory);
+    for (const file of collected.files) {
+      const key = normalizeMapKey(file);
+      seenFileKeys.add(key);
+      files.push(key);
+    }
+  }
+  if (capped) {
+    recordDegradationOnce({
+      kind: "lsp-diagnostics-paths-cap",
+      subject: cwd,
+      reason: `paths directory expansion reached the ${MAX_FILES}-file cap; later entries were not checked`
+    });
+  }
+  return { files, directoriesWithoutFiles, capped };
+}
+async function runBatchFileDiagnostics(absPaths, severity, lspService, options, scan = { capped: false, directoriesWithoutFiles: [] }) {
+  const { capped, directoriesWithoutFiles } = scan;
+  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, rootFallbackReasons, outcomeCounts, incompleteFiles } = await collectBatchDiagnostics(absPaths, severity, lspService, options);
+  const navigationOnly = results.filter((result) => result.diagnosticsUnsupported).length;
+  const dispositionSuppressed = results.reduce((sum, result) => sum + (result.dispositionSuppressed ?? 0), 0);
+  const lines = [
+    `Files checked: ${results.length}${capped ? ` (capped at ${MAX_FILES})` : ""}`,
+    `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 { listed: emptyListed, text: emptyText } = describeDirectoriesWithoutFiles(directoriesWithoutFiles);
+  if (directoriesWithoutFiles.length > 0)
+    lines.push("", emptyText);
+  const notConfirmed = outcomeCounts.inconclusive + outcomeCounts.unavailable + outcomeCounts.unsupported + outcomeCounts.failed + outcomeCounts.too_large + 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);
+  const outcomeDetails = results.map((result) => ({
+    file: result.file,
+    outcome: result.outcome,
+    reason: result.tooLargeReason ?? result.inconclusiveReason ?? result.error ?? result.unavailable
+  }));
+  const tooLargeLines = renderBatchOutcomeLines(outcomeDetails);
+  if (tooLargeLines.length > 0) {
+    lines.push("", "Files too large for LSP diagnostics:", ...tooLargeLines);
+  }
+  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, rootFallbackReasons)} NOT the same as 0 diagnostics.`);
+  }
+  if (display.length === 0) {
+    if (unconfirmed === 0 && outcomeCounts.clean === results.length) {
+      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)`);
+    }
+  }
+  const suppressedLine = dispositionSuppressedLine(dispositionSuppressed);
+  if (suppressedLine)
+    lines.push("", suppressedLine);
+  return {
+    content: [{ type: "text", text: lines.join(`
+`) }],
+    details: {
+      mode: "batch",
+      severity,
+      serverScope: options.serverScope ?? "all",
+      filesChecked: results.length,
+      ...capped ? { capped: true } : {},
+      ...directoriesWithoutFiles.length > 0 ? { directoriesWithoutFiles: emptyListed } : {},
+      concurrency: options.concurrency,
+      waitMs: options.waitMs,
+      diagnostics: display,
+      primaryDiagnosticsCount: primaryDisplay.length,
+      auxiliaryDiagnosticsCount: auxiliaryDisplay.length,
+      totalDiagnostics: total,
+      ...dispositionSuppressed > 0 && { dispositionSuppressed },
+      truncated,
+      cleanFiles: clean,
+      unconfirmedFiles: unconfirmed,
+      navigationOnlyFiles: navigationOnly > 0 ? navigationOnly : undefined,
+      timedOutFiles: timedOut > 0 ? timedOut : undefined,
+      outcomes: results.map((result) => ({
+        file: result.file,
+        outcome: result.outcome,
+        reason: result.tooLargeReason ?? result.inconclusiveReason ?? result.error ?? result.unavailable,
+        primaryDiagnosticsCount: result.diagnostics.filter((diagnostic) => diagnostic.serverId === result.primaryServerId).length,
+        auxiliaryDiagnosticsCount: result.diagnostics.filter((diagnostic) => diagnostic.serverId !== 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 collectDirectoryScanFiles(absPath, maxFiles, seen = new Set) {
+  const isIgnored = projectIgnorePredicate(absPath);
+  let collectedFiles = [];
+  await resolveDirectoryScanExtensions(async (exts) => {
+    collectedFiles = await collectFiles(absPath, [...exts], maxFiles + seen.size + 1, isIgnored);
+    return collectedFiles.length > 0;
+  });
+  const fresh = collectedFiles.flatMap((file) => seen.has(normalizeMapKey(file)) ? [] : [file]);
+  return {
+    files: fresh.slice(0, maxFiles),
+    capped: fresh.length > maxFiles,
+    eligible: collectedFiles.length
+  };
+}
+function describeDirectoriesWithoutFiles(directories) {
+  const listed = directories.slice(0, 5);
+  const more = directories.length - listed.length;
+  return {
+    listed,
+    text: `No supported source files found in: ${listed.join(", ")}${more > 0 ? ` (+${more} more)` : ""}`
+  };
+}
+async function runDirectoryDiagnostics(absPath, severity, lspService, options) {
+  const { files: filesToProcess, capped: wasCapped } = await collectDirectoryScanFiles(absPath, MAX_FILES);
+  if (filesToProcess.length === 0) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: describeDirectoriesWithoutFiles([absPath]).text
+        }
+      ],
+      details: {
+        filePath: absPath,
+        mode: "directory",
+        severity,
+        filesScanned: 0
+      }
+    };
+  }
+  const { results, fileErrors, lspHealthWarnings, total, truncated, display, primaryDisplay, auxiliaryDisplay, clean, unconfirmed, timedOut, rootFallbackReasons, outcomeCounts } = await collectBatchDiagnostics(filesToProcess, severity, lspService, options);
+  const navigationOnly = results.filter((result) => result.diagnosticsUnsupported).length;
+  const dispositionSuppressed = results.reduce((sum, result) => sum + (result.dispositionSuppressed ?? 0), 0);
+  const suppressedLine = dispositionSuppressedLine(dispositionSuppressed);
+  const outcomeDetails = results.map((result) => ({
+    file: result.file,
+    outcome: result.outcome,
+    reason: result.tooLargeReason ?? result.inconclusiveReason ?? result.error ?? result.unavailable
+  }));
+  const tooLargeLines = renderBatchOutcomeLines(outcomeDetails, (file) => path.relative(absPath, file));
+  let text;
+  if (total === 0) {
+    const cleanLine = unconfirmed > 0 ? `${clean} clean · ${unconfirmed} unconfirmed: ` + `${unconfirmedReasonClause(unconfirmed, timedOut, rootFallbackReasons)} 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)
+      ] : unconfirmed > 0 || outcomeCounts.clean === filesToProcess.length ? [cleanLine] : [],
+      ...tooLargeLines.length > 0 ? ["", "Files too large for LSP diagnostics:", ...tooLargeLines] : [],
+      ...suppressedLine ? ["", suppressedLine] : []
+    ].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, rootFallbackReasons)
+      ] : [],
+      ""
+    ];
+    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)`);
+    }
+    if (suppressedLine)
+      lines.push("", suppressedLine);
+    if (tooLargeLines.length > 0) {
+      lines.push("", "Files too large for LSP diagnostics:", ...tooLargeLines);
+    }
+    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,
+      ...dispositionSuppressed > 0 && { dispositionSuppressed },
+      truncated,
+      cleanFiles: clean,
+      unconfirmedFiles: unconfirmed,
+      outcomes: outcomeDetails,
+      outcomeCounts,
+      navigationOnlyFiles: navigationOnly > 0 ? navigationOnly : undefined,
+      timedOutFiles: timedOut > 0 ? timedOut : undefined,
+      fileErrors: fileErrors.length > 0 ? fileErrors : undefined,
+      lspHealthWarnings: lspHealthWarnings.length > 0 ? lspHealthWarnings : undefined,
+      concurrency: options.concurrency,
+      waitMs: options.waitMs
+    }
+  };
+}
+function dispositionSuppressedLine(suppressed) {
+  if (suppressed <= 0)
+    return;
+  return `suppressed by disposition: ${suppressed} finding(s) dropped from this ` + "result because they're marked false-positive/won't-fix, disabled by " + "`.dm-lens.json` rule policy, or suppressed by an inline `dm-lens-ignore` " + "comment. Not a clean verdict for those locations — they were found, " + "then intentionally hidden.";
+}
+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}`;
+}