@duckmind/dm-linux-x64 0.65.8 → 0.66.2

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

@@ -1,1088 +0,0 @@
-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/index.js";
-import { buildScopeKey, createWorkspaceDiagnosticsCacheContext } from "../clients/lsp/workspace-diagnostics-cache.js";
-import { getServersForFileWithConfig, primaryServerId } from "../clients/lsp/config.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 absPaths = rawPaths.map((entry) => normalizeMapKey(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 = 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 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 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?.();
-  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";
-  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);
-  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);
-  }
-  return {
-    file,
-    diagnostics: diagnosticsToFileDiags(file, filteredDiags),
-    unavailable: lspUnavailableMessage(file, health),
-    confirmation,
-    timedOut: confirmation === "unconfirmed" ? timedOut : undefined,
-    ...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 { 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 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);
-  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 (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 },
-      ...unconfirmedServerIds.length > 0 && {
-        unconfirmedServerIds: [...unconfirmedServerIds]
-      },
-      lspHealth,
-      waitMs
-    }
-  };
-}
-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") {
-      unconfirmed += 1;
-      if (result.timedOut)
-        timedOut += 1;
-    } else {
-      clean += 1;
-    }
-  }
-  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";
-  }
-  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 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 } = 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,
-    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 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}`,
-    `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 + 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)} 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,
-      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 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 { results, fileErrors, lspHealthWarnings, total, truncated, display, primaryDisplay, auxiliaryDisplay, clean, unconfirmed, 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.";
-    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)
-      ] : [],
-      ""
-    ];
-    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}`;
-}