@duckmind/dm-linux-x64 0.65.5 → 0.65.6

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

@@ -1,6 +1,5 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { Type } from "../clients/deps/typebox.js";
 import {
   getProjectIgnoreMatcher,
   isExcludedDirName
@@ -18,6 +17,7 @@ import {
   getServersForFileWithConfig,
   primaryServerId
 } from "../clients/lsp/config.js";
+import { mapWithConcurrency } from "../clients/map-with-concurrency.js";
 import {
   combineAbortSignals,
   withDeadline
@@ -26,6 +26,13 @@ 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,
@@ -36,12 +43,13 @@ 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 { baseName, compactRenderResult } from "./render-compact.js";
-import { makeProgressReporter, scanningSummaryLine } from "./scan-progress.js";
+import { makeProgressReporter } from "./scan-progress.js";
 import {
   isWarmAttached,
   tryWarmAttachedDiagnostics
@@ -50,18 +58,46 @@ import {
   extensionsForLanguage,
   SCAN_LANGUAGE_PRIORITY
 } from "../clients/language-registry.js";
+import { exceedsLspSyncLimits } from "../clients/lsp/content-limits.js";
 const MAX_FILES = 100;
-const MAX_BATCH_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;
-const SEVERITY_NAMES = {
+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;
@@ -81,38 +117,6 @@ function boundedPositiveInt(value, fallback, min, max) {
     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);
@@ -151,69 +155,8 @@ async function collectFiles(dir, extensions, maxFiles, isIgnored = () => false)
   await walk(dir);
   return files;
 }
-export function createLspDiagnosticsTool(nextWriteIndex, onConfirmedNoBlockers) {
+export function createLspDiagnosticsTool(nextWriteIndex, onConfirmedNoBlockers, getService = getLSPService) {
   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");
@@ -223,7 +166,7 @@ export function createLspDiagnosticsTool(nextWriteIndex, onConfirmedNoBlockers)
       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();
+      const lspService = getService();
       if (!lspService) {
         return {
           content: [
@@ -259,7 +202,7 @@ export function createLspDiagnosticsTool(nextWriteIndex, onConfirmedNoBlockers)
             details: { mode: "batch", filesChecked: 0 }
           };
         }
-        const absPaths = rawPaths.map((entry) => path.normalize(path.isAbsolute(entry) ? entry : path.resolve(cwd, entry)));
+        const absPaths = rawPaths.map((entry) => normalizeMapKey(path.resolve(cwd, entry)));
         return runBatchFileDiagnostics(absPaths, severity, lspService, {
           concurrency,
           waitMs,
@@ -284,7 +227,7 @@ export function createLspDiagnosticsTool(nextWriteIndex, onConfirmedNoBlockers)
           details: {}
         };
       }
-      const absPath = path.isAbsolute(rawPath) ? rawPath : path.resolve(cwd, rawPath);
+      const absPath = normalizeMapKey(path.resolve(cwd, rawPath));
       let stat;
       try {
         stat = fs.statSync(absPath);
@@ -313,57 +256,75 @@ export function createLspDiagnosticsTool(nextWriteIndex, onConfirmedNoBlockers)
     }
   };
 }
-async function collectDiagnosticsForFile(absPath, lspService, waitMs, serverScope = "all") {
+async function collectDiagnosticsForFile(absPath, lspService, scanRoot, waitMs, serverScope = "all") {
   let timedOut = false;
   let content;
   let touched;
-  let usedTouch = false;
   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.source === primaryServerId(absPath)) : attached.response.diagnostics;
-        const filtered = applyAuxiliarySuppressions(scopedDiagnostics, content, { fileRole: detectFileRole(absPath, content) });
+        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
         };
       }
     }
-    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
-      });
-    }
+    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 = usedTouch && touched !== undefined ? touched.diags : await lspService.getDiagnostics(absPath, waitMs !== undefined ? "document" : "full");
+  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)
+    fileRole: detectFileRole(absPath, content),
+    filePath: absPath,
+    scanRoot
   }) : diagnostics;
-  const binding = usedTouch ? touched?.binding : undefined;
-  const confirmedByTouch = usedTouch && touchCompletedConfirmationPolicy(touched);
+  const binding = touched?.binding;
+  const confirmedByTouch = touchCompletedConfirmationPolicy(touched);
   return {
     diagnostics: filtered,
     timedOut,
     skipReason: touched?.skipReason,
     confirmedByTouch,
-    unconfirmedServerIds: usedTouch ? touchCoverageGap(touched) : [],
+    unconfirmedServerIds: touchCoverageGap(touched),
+    diagnosticsUnsupportedServerIds: touched?.diagnosticsUnsupportedServerIds ?? [],
     content,
     binding
   };
@@ -376,6 +337,7 @@ function diagnosticsToFileDiags(file, diagnostics) {
     severity: d.severity,
     message: d.message,
     source: d.source,
+    serverId: d.serverId,
     code: d.code
   }));
 }
@@ -433,6 +395,51 @@ function demoteInferredForFile(file, diagnostics, cwd, lspService) {
     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)
@@ -442,7 +449,9 @@ function reconcileWidgetFromLspResult(file, rawDiags, confirmation, writeIndex,
       scanOrigin: "lsp_diagnostics"
     });
     const retagged = retagAuxiliaryDiagnostics(diagnostics, rawDiags, content ?? "", { cwd, fileRole: detectFileRole(file, content) });
-    reconcileScanDiagnostics(file, retagged, true, writeIndex, observedAt);
+    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 };
@@ -463,14 +472,19 @@ async function collectFileDiagnosticResult(file, severity, lspService, waitMs, n
     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 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)
+        primaryServerId: primaryServerId(file),
+        ...cachedPolicy.suppressed > 0 && {
+          dispositionSuppressed: cachedPolicy.suppressed
+        }
       };
     }
   }
@@ -479,14 +493,21 @@ async function collectFileDiagnosticResult(file, severity, lspService, waitMs, n
     timedOut,
     confirmedByTouch,
     unconfirmedServerIds,
+    diagnosticsUnsupportedServerIds,
     content: collectedContent,
     binding,
+    tooLargeReason,
     skipReason
-  } = await collectDiagnosticsForFile(file, lspService, waitMs, serverScope);
+  } = 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 (skipReason !== undefined) {
+  if (diagnosticsUnsupportedServerIds.length > 0) {
+    confirmation = undefined;
+  } else if (skipReason !== undefined) {
     confirmation = "unconfirmed";
   } else if (timedOut) {
     if (applySeverityFilter(rawDiags, severity).length === 0) {
@@ -510,6 +531,8 @@ async function collectFileDiagnosticResult(file, severity, lspService, waitMs, n
     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);
   if (verdict.confirmed && !verdict.blocking) {
@@ -520,8 +543,8 @@ async function collectFileDiagnosticResult(file, severity, lspService, waitMs, n
       cwd
     });
   }
-  if (cacheCtx && scopeKey !== undefined && confirmation !== "unconfirmed" && unconfirmedServerIds.length === 0) {
-    cacheCtx.record(file, scopeKey, effectiveRawDiags, stat.mtimeMs, collectedContent !== undefined ? hashDiagnosticContent(collectedContent) : undefined, stat.size);
+  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);
   }
   return {
     file,
@@ -530,7 +553,11 @@ async function collectFileDiagnosticResult(file, severity, lspService, waitMs, n
     confirmation,
     timedOut: confirmation === "unconfirmed" ? timedOut : undefined,
     ...skipReason !== undefined && { skipReason },
-    primaryServerId: primaryServerId(file)
+    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) {
@@ -540,15 +567,34 @@ async function runFileDiagnostics(absPath, severity, lspService, waitMs, nextWri
     timedOut,
     confirmedByTouch,
     unconfirmedServerIds,
+    diagnosticsUnsupportedServerIds,
     content: collectedContent,
     binding,
+    tooLargeReason,
     skipReason
-  } = await collectDiagnosticsForFile(absPath, lspService, waitMs, serverScope);
+  } = 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 (skipReason !== undefined) {
+  if (diagnosticsUnsupportedServerIds.length > 0) {
+    confirmation = undefined;
+  } else if (skipReason !== undefined) {
     confirmation = "unconfirmed";
   } else if (timedOut) {
     if (applySeverityFilter(rawDiags, severity).length === 0) {
@@ -572,6 +618,8 @@ async function runFileDiagnostics(absPath, severity, lspService, waitMs, nextWri
   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;
@@ -587,9 +635,12 @@ async function runFileDiagnostics(absPath, severity, lspService, waitMs, nextWri
     });
   }
   const primaryId = primaryServerId(absPath);
-  const primaryDiags = limited.filter((d) => d.source === primaryId);
-  const auxiliaryDiags = limited.filter((d) => d.source !== primaryId);
+  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.";
     }
@@ -601,14 +652,16 @@ async function runFileDiagnostics(absPath, severity, lspService, waitMs, nextWri
     }
     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;
+  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] : []
+      ...coverageLine ? [coverageLine] : [],
+      ...suppressedLine ? [suppressedLine] : []
     ].join(`
 `);
   } else {
@@ -622,6 +675,8 @@ async function runFileDiagnostics(absPath, severity, lspService, waitMs, nextWri
     }
     if (coverageLine)
       lines.push("", coverageLine);
+    if (suppressedLine)
+      lines.push("", suppressedLine);
     if (unavailable)
       lines.unshift(unavailable, "");
     if (truncated) {
@@ -637,6 +692,7 @@ async function runFileDiagnostics(absPath, severity, lspService, waitMs, nextWri
       mode: "file",
       severity,
       serverScope,
+      ...unavailable ? { unavailable } : {},
       primaryServerId: primaryId,
       primaryDiagnosticsCount: primaryDiags.length,
       auxiliaryDiagnosticsCount: auxiliaryDiags.length,
@@ -649,9 +705,13 @@ async function runFileDiagnostics(absPath, severity, lspService, waitMs, nextWri
         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 },
       ...unconfirmedServerIds.length > 0 && {
         unconfirmedServerIds: [...unconfirmedServerIds]
@@ -665,7 +725,17 @@ function tallyConfirmation(results) {
   let clean = 0;
   let unconfirmed = 0;
   let timedOut = 0;
+  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") {
@@ -676,11 +746,15 @@ function tallyConfirmation(results) {
       clean += 1;
     }
   }
-  return { clean, unconfirmed, timedOut };
+  return { clean, unconfirmed, timedOut, 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";
   }
@@ -717,27 +791,54 @@ 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);
+  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] : []);
@@ -755,14 +856,15 @@ async function collectBatchDiagnostics(files, severity, lspService, options) {
     "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.source === primaryIdByFile.get(d.file));
-  const auxiliaryDisplay = display.filter((d) => d.source !== primaryIdByFile.get(d.file));
+  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,
@@ -802,6 +904,8 @@ async function runBatchFileDiagnostics(absPaths, severity, lspService, options)
     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}`,
     `Total diagnostics: ${total}`,
@@ -810,7 +914,7 @@ async function runBatchFileDiagnostics(absPaths, severity, lspService, options)
   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;
+  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).`);
   }
@@ -819,6 +923,15 @@ async function runBatchFileDiagnostics(absPaths, severity, lspService, options)
   }
   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));
   }
@@ -826,7 +939,7 @@ async function runBatchFileDiagnostics(absPaths, severity, lspService, options)
     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) {
+    if (unconfirmed === 0 && outcomeCounts.clean === results.length) {
       lines.push("", "No diagnostics found.");
     }
   } else {
@@ -842,6 +955,9 @@ async function runBatchFileDiagnostics(absPaths, severity, lspService, options)
       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(`
 `) }],
@@ -856,16 +972,18 @@ async function runBatchFileDiagnostics(absPaths, severity, lspService, options)
       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.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
+        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,
@@ -909,6 +1027,7 @@ async function runDirectoryDiagnostics(absPath, severity, lspService, options) {
   const wasCapped = collectedFiles.length > MAX_FILES;
   const filesToProcess = collectedFiles.slice(0, MAX_FILES);
   const {
+    results,
     fileErrors,
     lspHealthWarnings,
     total,
@@ -918,8 +1037,18 @@ async function runDirectoryDiagnostics(absPath, severity, lspService, options) {
     auxiliaryDisplay,
     clean,
     unconfirmed,
-    timedOut
+    timedOut,
+    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)} NOT the same as 0 diagnostics.` : "No diagnostics found.";
@@ -929,7 +1058,9 @@ async function runDirectoryDiagnostics(absPath, severity, lspService, options) {
       ...lspHealthWarnings.length > 0 ? [
         "LSP unavailable for one or more files:",
         ...lspHealthWarnings.slice(0, 10)
-      ] : [cleanLine]
+      ] : unconfirmed > 0 || outcomeCounts.clean === filesToProcess.length ? [cleanLine] : [],
+      ...tooLargeLines.length > 0 ? ["", "Files too large for LSP diagnostics:", ...tooLargeLines] : [],
+      ...suppressedLine ? ["", suppressedLine] : []
     ].join(`
 `);
   } else {
@@ -961,6 +1092,11 @@ async function runDirectoryDiagnostics(absPath, severity, lspService, options) {
     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(`
 `);
   }
@@ -985,9 +1121,13 @@ async function runDirectoryDiagnostics(absPath, severity, lspService, options) {
       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,
@@ -996,6 +1136,11 @@ async function runDirectoryDiagnostics(absPath, severity, lspService, options) {
     }
   };
 }
+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;