@duckmind/dm-darwin-x64 0.66.5 → 0.66.7

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

@@ -0,0 +1,1518 @@
+import { promises as fs } from "node:fs";
+import * as fsSync from "node:fs";
+import * as path from "node:path";
+import { BoundedLruCache } from "../clients/bounded-cache.js";
+import { Type } from "../clients/deps/typebox.js";
+import { anchorsForDiagnostic, applyDispositions, applyWeakDispositions, hasAnyDispositionMarks, hasStrictDispositionMarks, getDisposition } from "../clients/diagnostic-dispositions.js";
+import { DEPENDENCY_DRIFT_MAX_DELIVERIES } from "../clients/blocker-freshness.js";
+import { freshnessFromMtime } from "../clients/freshness.js";
+import { applyFindingPolicy, loadProjectRulePolicyMap } from "../clients/dispatch/finding-policy.js";
+import { gateFindingsByPathFreshness, parseScannedAtMs } from "../clients/advisory-provenance.js";
+import { formatCacheAgeLabel, markUnreconciledFindings } from "../clients/finding-delivery-gate.js";
+import { normalizeRuleId } from "../clients/dispatch/rule-id-normalize.js";
+import { applyRulePolicy } from "../clients/dispatch/rule-policy.js";
+import { compactRenderResult } from "./render-compact.js";
+import { combineAbortSignals } from "../clients/deadline-utils.js";
+import { getProjectIgnoreMatcher } from "../clients/file-utils.js";
+import { isAtOrAboveHomeDir, normalizeEphemeralMapKey, normalizeFilePath, normalizeMapKey, realpathOrResolve } from "../clients/path-utils.js";
+import { getLSPService } from "../clients/lsp/capabilities.js";
+import { retireInlineBlockerAndResyncGuard } from "../clients/git-guard.js";
+import { primaryServerId, resolveLspCwdForFile } from "../clients/lsp/config.js";
+import { getFullScanWallClockMs } from "../clients/lsp/workspace-sweep-hold.js";
+import { demoteInferredProjectSweepResults } from "../clients/lsp/inferred-project.js";
+import { hashDiagnosticContent } from "../clients/lsp/diagnostic-binding.js";
+import { loadProjectDiagnosticsDeltaReport, loadProjectDiagnosticsSnapshot, PROJECT_DIAGNOSTICS_CACHE_VERSION, reconcileProjectDiagnosticsSnapshot } from "../clients/project-diagnostics/cache.js";
+import { formatCacheAgeOld, formatNotRunEntry } from "../clients/project-diagnostics/extractors.js";
+import { ANALYZER_IDS, fetchFreshProjectDiagnostics } from "../clients/project-diagnostics/fresh-fetch.js";
+import { loadBootstrapClients } from "../clients/bootstrap.js";
+import { resolveLensToolName } from "../clients/tool-config.js";
+import { generatedSkipNotice, scanTruncationNotice } from "../clients/lens-engine.js";
+import { scanProjectDiagnostics } from "../clients/project-diagnostics/scanner.js";
+import { classifyDiagnosticTier, getFileDiagnosticSummaries, reconcileCorrelatedScanDiagnostics, reconcileScanDiagnostics, reconcileStaleWidgetDependencyBlockers, reconcileStaleWidgetFiles, widgetDiagnosticUri } from "../clients/widget-state.js";
+import { claimPhaseOncePerSession, logLatency } from "../clients/latency-logger.js";
+import { logExtension } from "../clients/extension-log.js";
+import { recordDegradationOnce } from "../clients/degradation-ledger.js";
+import { convertLspDiagnostics } from "../clients/dispatch/utils/lsp-diagnostics.js";
+import { findAuxiliaryProfileForSource, retagAuxiliaryDiagnostics } from "../clients/dispatch/auxiliary-lsp.js";
+import { detectFileRole } from "../clients/file-role.js";
+import { STALE_LINE_MARKER } from "../clients/stale-marker.js";
+import { makeProgressReporter, scanningSummaryLine } from "./scan-progress.js";
+import { createLspDiagnosticsTool, LSP_SEVERITY_FILTERS, MAX_BATCH_FILES, renderBatchOutcomeLines } from "./lsp-diagnostics.js";
+import { demotePastEofDiagnostics, PAST_EOF_STALE_MARKER, resyncDocumentOnPastEof } from "../clients/diagnostic-line-freshness.js";
+const MAX_DIAGNOSTICS_PER_FILE = 50;
+const MAX_PATHS_ENTRIES = MAX_BATCH_FILES;
+function notRequestedReason(host) {
+  return "refreshRunners not requested this call (quick mode) — pass " + `refreshRunners=cheap/all/cached to ${resolveLensToolName("lens_diagnostics", host) ?? "diagnostics"} mode=full to run it`;
+}
+const FULL_SCAN_WALL_CLOCK_MS = getFullScanWallClockMs();
+const FULL_SCAN_BINDING_YIELD_EVERY = 16;
+async function findFullScanBindingMismatches(results) {
+  const mismatched = new WeakSet;
+  let sinceYield = 0;
+  for (const result of results) {
+    if (result.boundToCurrentDisk === false) {
+      mismatched.add(result);
+    } else if (result.boundToCurrentDisk !== true && result.contentHash !== undefined) {
+      try {
+        const content = await fs.readFile(result.filePath, "utf-8");
+        if (hashDiagnosticContent(content) !== result.contentHash) {
+          mismatched.add(result);
+        }
+      } catch {}
+    }
+    sinceYield += 1;
+    if (sinceYield >= FULL_SCAN_BINDING_YIELD_EVERY) {
+      sinceYield = 0;
+      await new Promise((resolve) => setImmediate(resolve));
+    }
+  }
+  return mismatched;
+}
+export function createLensDiagnosticsTool(cacheManager, getCwd, getLspService = getLSPService, flushPending = async () => {}, nextWriteIndex, captureLspStatusRepaint, getRuntime, isLensGuardEnabled = () => true) {
+  const lspProbe = createLspDiagnosticsTool(nextWriteIndex, (info) => {
+    const runtime = getRuntime?.();
+    if (!runtime)
+      return;
+    const retired = retireInlineBlockerAndResyncGuard({
+      runtime,
+      cacheManager,
+      cwd: info.cwd,
+      filePath: info.filePath,
+      ...info.writeIndex === undefined ? {} : { writeIndex: info.writeIndex },
+      coveredSources: info.coveredSources,
+      lensGuardEnabled: isLensGuardEnabled()
+    });
+    if (retired) {
+      logExtension({
+        subsystem: "git-guard",
+        level: "debug",
+        message: `inline_blocker: retired for ${info.filePath}`
+      });
+    }
+  }, getLspService);
+  return {
+    name: "lens_diagnostics",
+    label: "Project Diagnostics",
+    description: 'Query dm-lens diagnostics from the session cache or an active LSP probe, at paths or workspace scope. Empty cache is not proof of clean; probe changed paths when findings are absent or stale. Example: `{source: "lsp", scope: "paths", paths: ["src/app.ts"]}`.',
+    promptSnippet: "lens_diagnostics source=session reads the session cache and an empty cache is not proof of a clean file; use source=lsp scope=paths for changed files when cached findings are absent or stale",
+    renderResult: compactRenderResult(({ details, args, isError, text }) => {
+      if (details?.source === "lsp") {
+        const count = details.totalDiagnostics ?? 0;
+        const files = details.filesChecked ?? details.filesScanned ?? 0;
+        const noun = count === 1 ? "diagnostic" : "diagnostics";
+        const filePath = typeof details?.filePath === "string" ? details.filePath : Array.isArray(args?.paths) && args.paths.length === 1 && typeof args.paths[0] === "string" ? args.paths[0] : undefined;
+        const singleFile = (details?.mode === "file" || files === 1) && typeof filePath === "string" ? ` ${path.basename(filePath)}` : "";
+        const scope = files > 1 ? ` across ${files} files` : singleFile;
+        if (isError)
+          return `lens_diagnostics lsp — ${text.split(`
+`)[0] ?? "error"}`;
+        if ((details.navigationOnlyFiles ?? 0) > 0)
+          return `lens_diagnostics${scope} — ${count} ${noun} · ${details.cleanFiles ?? 0} clean · ${details.navigationOnlyFiles} navigation-only`;
+        if ((details.unconfirmedFiles ?? 0) > 0)
+          return `lens_diagnostics${scope} — ${count} ${noun} · ${details.cleanFiles ?? 0} clean · ${details.unconfirmedFiles} unconfirmed${details.timedOutFiles ? ` (${details.timedOutFiles} timed out)` : ""}`;
+        const outcomeCounts = details.outcomeCounts;
+        const tooLargeLines = renderBatchOutcomeLines(details.outcomes ?? []);
+        if (tooLargeLines.length > 0)
+          return `lens_diagnostics${scope} — too large: ${tooLargeLines.join("; ")}`;
+        const notConfirmed = outcomeCounts ? (outcomeCounts.inconclusive ?? 0) + (outcomeCounts.unavailable ?? 0) + (outcomeCounts.unsupported ?? 0) + (outcomeCounts.failed ?? 0) + (outcomeCounts.too_large ?? 0) : 0;
+        if (notConfirmed > 0)
+          return `lens_diagnostics${scope} — ${count} ${noun} · ${notConfirmed} checks not confirmed`;
+        if ((details.incompleteFiles ?? 0) > 0)
+          return `lens_diagnostics${scope} — incomplete (${details.incompleteFiles} files not confirmed)`;
+        if (count === 0 && details.unconfirmed)
+          return details.timedOut ? `lens_diagnostics${scope} — timed out (result may be incomplete)` : `lens_diagnostics${scope} — unconfirmed (server cannot confirm clean)`;
+        return `lens_diagnostics${scope} — ${count} ${noun}`;
+      }
+      const scanning = scanningSummaryLine(details, text);
+      if (scanning)
+        return scanning;
+      const mode = details?.mode ?? (typeof args.mode === "string" ? args.mode : "delta");
+      if (isError) {
+        return `lens_diagnostics ${mode} — ${text.split(`
+`)[0] ?? "error"}`;
+      }
+      const coldSuffix = details?.coldRunners && details.coldRunners.length > 0 ? ` (${details.coldRunners.length} cold: ${details.coldRunners.join(", ")})` : "";
+      const failedSuffix = details?.failedAnalyzers && details.failedAnalyzers.length > 0 ? ` (${details.failedAnalyzers.length} failed: ${details.failedAnalyzers.map((item) => item.id).join(", ")})` : "";
+      if (mode === "delta") {
+        const aw = details?.actionableWarnings ?? 0;
+        const cq = details?.qualityIssues ?? 0;
+        const pd = details?.projectDiagnostics ?? 0;
+        if (aw + cq + pd === 0)
+          return `lens_diagnostics delta — clean${coldSuffix}${failedSuffix}`;
+        return `lens_diagnostics delta — ${aw} actionable · ${cq} quality · ${pd} project${coldSuffix}${failedSuffix}`;
+      }
+      const b = details?.totalBlocking ?? 0;
+      const e = details?.totalErrors ?? 0;
+      const w = details?.totalWarnings ?? 0;
+      const adv = details?.totalAdvisories ?? 0;
+      const files = details?.filesWithIssues ?? details?.filesChecked ?? 0;
+      if (b + e + w === 0) {
+        const advisorySuffix = adv > 0 ? `, ${adv} hint${adv === 1 ? "" : "s"}` : "";
+        return `lens_diagnostics ${mode} — clean${advisorySuffix} (${files} files)${coldSuffix}${failedSuffix}`;
+      }
+      const parts = [`${b} blocking`];
+      if (b === 0 && e > 0)
+        parts.push(`${e} errors`);
+      parts.push(`${w} warnings`);
+      return `lens_diagnostics ${mode} — ${parts.join(" · ")} (${files} files)${coldSuffix}${failedSuffix}`;
+    }),
+    parameters: Type.Object({
+      source: Type.Optional(Type.String({
+        enum: ["session", "lsp"],
+        description: "Evidence source: session cache (empty cache is not proof of a " + "clean file — use source=lsp for changed files) or an active LSP probe."
+      })),
+      scope: Type.Optional(Type.String({
+        enum: ["paths", "workspace"],
+        description: "Coverage scope: explicit paths, or workspace (default: current turn's delta for source=session)."
+      })),
+      mode: Type.Optional(Type.String({
+        enum: ["delta", "all", "full"],
+        description: "delta = current turn; all = cache-only; full = active LSP scan of paths. Empty cache is not proof of clean."
+      })),
+      path: Type.Optional(Type.String({
+        description: "One file or directory for source=lsp checks."
+      })),
+      concurrency: Type.Optional(Type.Number({
+        description: "Source=lsp batch concurrency (maximum 16)."
+      })),
+      waitMs: Type.Optional(Type.Number({
+        description: "Source=lsp per-file wait budget in milliseconds."
+      })),
+      serverScope: Type.Optional(Type.String({
+        enum: ["primary", "all"],
+        description: "Source=lsp server coverage: primary or all."
+      })),
+      refreshRunners: Type.Optional(Type.Union([
+        Type.Boolean(),
+        Type.String({ enum: ["cached", "cheap", "all", "none"] })
+      ], {
+        description: "Analyzer refresh mode for full view."
+      })),
+      maxProjectFiles: Type.Optional(Type.Number({
+        description: "Project-file limit for cheap runners."
+      })),
+      maxLspFiles: Type.Optional(Type.Number({
+        description: "File limit for the LSP sweep."
+      })),
+      includeGenerated: Type.Optional(Type.Boolean({
+        description: "Include generated-name paths in full scans."
+      })),
+      analysisRoot: Type.Optional(Type.String({
+        description: "Explicit project directory for heavyweight analyzers; it must exist and resolve strictly below the home directory."
+      })),
+      severity: Type.Optional(Type.String({
+        enum: [...LSP_SEVERITY_FILTERS],
+        description: "Filter by severity threshold (default: all): error shows errors; warning includes errors and warnings; information includes errors, warnings, and information; hint and all show every known tier."
+      })),
+      paths: Type.Optional(Type.Array(Type.String(), {
+        maxItems: MAX_PATHS_ENTRIES,
+        description: "Files or directories to filter."
+      }))
+    }),
+    async execute(_toolCallId, params, signal, onUpdate, ctx) {
+      const requestedSource = params.source;
+      const requestedScope = params.scope;
+      const legacyMode = params.mode;
+      const source = requestedSource ?? "session";
+      const scope = requestedScope ?? (legacyMode === "delta" || legacyMode === undefined ? source === "lsp" ? "paths" : "delta" : "workspace");
+      const cwd = ctx.cwd ?? getCwd();
+      if (source === "lsp") {
+        const lspParams = { ...params };
+        delete lspParams.source;
+        delete lspParams.scope;
+        const hasExplicitPath = typeof lspParams.path === "string" && lspParams.path.length > 0;
+        const hasExplicitPaths = Array.isArray(lspParams.paths) && lspParams.paths.length > 0;
+        if (scope === "workspace" && !hasExplicitPath && !hasExplicitPaths) {
+          lspParams.path = cwd;
+        }
+        const lspStart = Date.now();
+        const result = await lspProbe.execute(_toolCallId, lspParams, signal, onUpdate, ctx.signal ? { cwd, signal: ctx.signal } : { cwd });
+        logLatency({
+          type: "phase",
+          toolName: "lens_diagnostics",
+          filePath: cwd,
+          phase: "lens_diagnostics_lsp_route",
+          durationMs: Date.now() - lspStart,
+          metadata: {
+            scope,
+            isError: result.isError === true,
+            totalDiagnostics: result.details?.totalDiagnostics ?? 0,
+            cleanFiles: result.details?.cleanFiles ?? 0,
+            unconfirmedFiles: result.details?.unconfirmedFiles ?? 0,
+            timedOutFiles: result.details?.timedOutFiles ?? 0
+          }
+        });
+        return {
+          ...result,
+          isError: result.isError === true,
+          details: { ...result.details, source, scope }
+        };
+      }
+      if (requestedSource !== undefined) {
+        const effectiveMode = legacyMode ?? (scope === "workspace" ? "all" : scope === "paths" ? "all" : "delta");
+        params = { ...params, mode: effectiveMode };
+      }
+      const repaintLspStatus = captureLspStatusRepaint?.(ctx);
+      const mode = params.mode ?? "delta";
+      const severity = params.severity ?? "all";
+      const refreshRunners = params.refreshRunners;
+      const parsePositiveInt = (value) => typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : undefined;
+      const maxProjectFiles = parsePositiveInt(params.maxProjectFiles);
+      const maxLspFiles = parsePositiveInt(params.maxLspFiles);
+      const includeGenerated = params.includeGenerated === true;
+      let pathsScope;
+      try {
+        pathsScope = resolvePathsScope(cwd, params.paths);
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: err instanceof Error ? err.message : String(err)
+            }
+          ],
+          isError: true,
+          details: { mode, pathsError: true }
+        };
+      }
+      const abortSignal = combineAbortSignals(signal, ctx.signal);
+      await flushPending();
+      const staleDropped = await reconcileStaleWidgetFiles();
+      if (mode === "all") {
+        const dependencyGateStart = Date.now();
+        const { demoted: dependencyDemoted, truncatedImports } = await reconcileStaleWidgetDependencyBlockers(cwd, getRuntime?.()?.turnIndex);
+        logLatency({
+          type: "phase",
+          toolName: "lens_diagnostics",
+          filePath: cwd,
+          phase: "blocker_freshness_widget_gate",
+          durationMs: Date.now() - dependencyGateStart,
+          metadata: {
+            demoted: dependencyDemoted,
+            truncatedImports,
+            surface: "mode=all"
+          }
+        });
+        return formatAllMode(cwd, severity, undefined, undefined, staleDropped, pathsScope, dependencyDemoted);
+      }
+      if (mode === "full") {
+        const ceiling = AbortSignal.timeout(FULL_SCAN_WALL_CLOCK_MS);
+        const fullSignal = combineAbortSignals(abortSignal, ceiling);
+        const onProgress = makeProgressReporter(onUpdate);
+        return formatFullMode(cwd, severity, getLspService(), cacheManager, {
+          refreshRunners,
+          maxProjectFiles,
+          maxLspFiles,
+          includeGenerated,
+          signal: fullSignal,
+          wallClockMs: FULL_SCAN_WALL_CLOCK_MS,
+          onProgress,
+          onServerReady: repaintLspStatus,
+          pathsScope,
+          nextWriteIndex,
+          runtime: getRuntime?.(),
+          analysisRoot: typeof params.analysisRoot === "string" ? params.analysisRoot : undefined,
+          host: ctx.host ?? "pi"
+        });
+      }
+      return formatDeltaMode(cacheManager, cwd, severity, pathsScope);
+    }
+  };
+}
+function formatProjectDeltaDiagnostic(diagnostic, stale) {
+  const marker = stale ? "○" : diagnostic.semantic === "blocking" || diagnostic.severity === "error" ? "\uD83D\uDD34" : "ℹ";
+  const rule = diagnostic.rule ?? diagnostic.code ?? diagnostic.runner;
+  const where = stale ? STALE_LINE_MARKER : `L${diagnostic.line ?? "?"}`;
+  return `  ${marker} ${where}  ${rule}  ${diagnostic.message}`;
+}
+function appendProjectDiagnosticsDeltaLines(groups, cwd, report, severity, includeFile) {
+  const scoped = (report?.diagnostics ?? []).filter((diagnostic) => includeFile(diagnostic.filePath) && matchesSeverity(projectDiagnosticToWidget(diagnostic, diagnostic.filePath), severity));
+  const { "lens-diagnostics-delta-project": gated } = gateFindingsByPathFreshness({
+    cwd,
+    sources: {
+      "lens-diagnostics-delta-project": {
+        findings: scoped,
+        scannedAt: report?.generatedAt,
+        citedPath: (d) => d.filePath,
+        onMissing: "drop"
+      }
+    }
+  });
+  const staleSet = new Set(gated.stale);
+  const diagnostics = [...gated.live, ...gated.stale];
+  const byFile = new Map;
+  for (const diagnostic of diagnostics) {
+    const filePath = path.resolve(diagnostic.filePath);
+    const bucket = byFile.get(filePath) ?? [];
+    bucket.push(diagnostic);
+    byFile.set(filePath, bucket);
+  }
+  for (const [filePath, fileDiagnostics] of byFile) {
+    const group = getDeltaFileGroup(groups, cwd, filePath);
+    for (const diagnostic of fileDiagnostics) {
+      group.projectLines.push(formatProjectDeltaDiagnostic(diagnostic, staleSet.has(diagnostic)));
+    }
+  }
+  return diagnostics.length;
+}
+export const CACHED_CONTENT_MEMO_CAP = 64;
+const cachedContentMemo = new BoundedLruCache(CACHED_CONTENT_MEMO_CAP);
+function readContentForAnchors(filePath, stat) {
+  const key = normalizeEphemeralMapKey(filePath);
+  const hit = cachedContentMemo.get(key);
+  if (hit && hit.mtimeMs === stat.mtimeMs && hit.size === stat.size) {
+    return hit.content;
+  }
+  let content;
+  try {
+    content = fsSync.readFileSync(filePath, "utf-8");
+  } catch {
+    return;
+  }
+  cachedContentMemo.set(key, {
+    mtimeMs: stat.mtimeMs,
+    size: stat.size,
+    content
+  });
+  return content;
+}
+export function _readContentForAnchorsForTests(filePath, stat) {
+  return readContentForAnchors(filePath, stat);
+}
+function applyCachedDispositions(cachedDiagnostics, cwd, filePath) {
+  if (!hasAnyDispositionMarks(cwd))
+    return cachedDiagnostics;
+  if (!hasStrictDispositionMarks(cwd)) {
+    return applyWeakDispositions(cachedDiagnostics, cwd, filePath);
+  }
+  let stat;
+  try {
+    stat = fsSync.statSync(filePath);
+  } catch {
+    return applyWeakDispositions(cachedDiagnostics, cwd, filePath);
+  }
+  const referenceMs = cachedDiagnostics.reduce((latest, d) => Math.max(latest, d.observedAt ?? 0), 0);
+  if (referenceMs > 0 && freshnessFromMtime({ mtimeMs: stat.mtimeMs, referenceMs }).verdict === "stale") {
+    return applyWeakDispositions(cachedDiagnostics, cwd, filePath);
+  }
+  const content = readContentForAnchors(filePath, stat);
+  if (content === undefined) {
+    return applyWeakDispositions(cachedDiagnostics, cwd, filePath);
+  }
+  return applyDispositions(cachedDiagnostics, cwd, filePath, content);
+}
+function filterDeltaReportDispositions(report, cwd, policyMap) {
+  if (!report?.diagnostics.length)
+    return report;
+  const kept = report.diagnostics.filter((d) => applyCachedDispositions([projectDiagnosticToWidget(d, d.filePath)], cwd, d.filePath).length === 1);
+  const policyKept = applyRulePolicy(kept, policyMap, {
+    root: cwd,
+    filePath: cwd
+  });
+  if (policyKept.length === report.diagnostics.length)
+    return report;
+  return { ...report, diagnostics: policyKept };
+}
+function applyDeltaFreshnessGate(files, cwd, generatedAt) {
+  const stamps = new Set(files.map((file) => file.generatedAt ?? generatedAt ?? ""));
+  if (stamps.size > 1) {
+    const gatedByPath = new Map;
+    for (const stamp of stamps) {
+      const group = files.filter((file) => (file.generatedAt ?? generatedAt ?? "") === stamp);
+      for (const gated of applyDeltaFreshnessGate(group.map((file) => ({
+        filePath: file.filePath,
+        warnings: file.warnings
+      })), cwd, stamp === "" ? undefined : stamp)) {
+        gatedByPath.set(gated.filePath, gated);
+      }
+    }
+    return files.map((file) => gatedByPath.get(file.filePath)).filter((entry) => entry !== undefined);
+  }
+  const stampedAt = [...stamps][0];
+  const effectiveAt = stampedAt !== undefined && stampedAt !== "" ? stampedAt : generatedAt;
+  if (!effectiveAt)
+    return files;
+  const flat = [];
+  for (const file of files) {
+    for (const warning of file.warnings)
+      flat.push({ filePath: file.filePath, warning });
+  }
+  if (flat.length === 0)
+    return files;
+  const { "lens-diagnostics-delta": gated } = gateFindingsByPathFreshness({
+    cwd,
+    sources: {
+      "lens-diagnostics-delta": {
+        findings: flat,
+        scannedAt: effectiveAt,
+        citedPath: (f) => f.filePath,
+        onMissing: "drop"
+      }
+    }
+  });
+  const byFile = new Map;
+  for (const f of gated.live) {
+    const arr = byFile.get(f.filePath) ?? [];
+    arr.push(f.warning);
+    byFile.set(f.filePath, arr);
+  }
+  for (const f of gated.stale) {
+    const arr = byFile.get(f.filePath) ?? [];
+    arr.push({
+      ...f.warning,
+      stale: true,
+      line: undefined,
+      staleAsOf: effectiveAt
+    });
+    byFile.set(f.filePath, arr);
+  }
+  return files.map((file) => ({
+    filePath: file.filePath,
+    warnings: byFile.get(file.filePath) ?? []
+  })).filter((file) => file.warnings.length > 0);
+}
+function getDeltaFileGroup(groups, cwd, filePath) {
+  const rel = path.relative(cwd, filePath);
+  let group = groups.get(rel);
+  if (!group) {
+    group = {
+      rel,
+      actionableLines: [],
+      qualityLines: [],
+      projectLines: [],
+      incomplete: false
+    };
+    groups.set(rel, group);
+  }
+  return group;
+}
+function formatDeltaMode(cacheManager, cwd, severity, pathsScope) {
+  const actionableEntry = cacheManager.readCache("actionable-warnings", cwd);
+  const qualityEntry = cacheManager.readCache("code-quality-warnings", cwd);
+  const reverifyIncompletePaths = new Set((actionableEntry?.data?.files ?? []).filter((file) => file.reVerifyIncomplete).map((file) => normalizeMapKey(file.filePath)));
+  const actionable = actionableEntry?.data;
+  const quality = qualityEntry?.data;
+  const policyMap = loadProjectRulePolicyMap(cwd);
+  const projectDelta = filterDeltaReportDispositions(loadProjectDiagnosticsDeltaReport(cwd), cwd, policyMap);
+  const includeFile = createScopedFileFilter(cwd, pathsScope);
+  const visibleWarningFiles = (files) => (files ?? []).filter((file) => includeFile(file.filePath)).map((file) => ({
+    filePath: file.filePath,
+    generatedAt: file.generatedAt,
+    warnings: applyRulePolicy(applyCachedDispositions(file.warnings ?? [], cwd, file.filePath), policyMap, { root: cwd, filePath: file.filePath })
+  })).filter((file) => file.warnings.length > 0);
+  const actionableFiles = applyDeltaFreshnessGate(visibleWarningFiles(actionable?.files), cwd, actionable?.generatedAt);
+  const qualityFiles = applyDeltaFreshnessGate(visibleWarningFiles(quality?.files), cwd, quality?.generatedAt);
+  const matchingWarnings = (warnings) => warnings.filter((warning) => matchesRecordSeverity(warning.severity, severity));
+  const filteredActionableFiles = actionableFiles.map((file) => ({
+    ...file,
+    warnings: matchingWarnings(file.warnings)
+  })).filter((file) => file.warnings.length > 0);
+  const filteredQualityFiles = qualityFiles.map((file) => ({
+    ...file,
+    warnings: matchingWarnings(file.warnings)
+  })).filter((file) => file.warnings.length > 0);
+  const groups = new Map;
+  if (filteredActionableFiles.length > 0) {
+    for (const file of filteredActionableFiles) {
+      const group = getDeltaFileGroup(groups, cwd, file.filePath);
+      for (const w of file.warnings) {
+        const where = w.stale ? STALE_LINE_MARKER : `L${w.line ?? "?"}`;
+        group.actionableLines.push(`  ⚠ ${where}  ${w.rule ?? w.code ?? w.tool}  ${w.message}`);
+      }
+      const key = normalizeMapKey(file.filePath);
+      if (reverifyIncompletePaths.has(key))
+        group.incomplete = true;
+      if (!group.staleRow) {
+        const staleWarning = file.warnings.find((w) => w.stale);
+        if (staleWarning)
+          group.staleRow = { staleAsOf: staleWarning.staleAsOf };
+      }
+    }
+  }
+  if (filteredQualityFiles.length > 0) {
+    for (const file of filteredQualityFiles) {
+      const group = getDeltaFileGroup(groups, cwd, file.filePath);
+      for (const w of file.warnings) {
+        const where = w.stale ? STALE_LINE_MARKER : `L${w.line ?? "?"}`;
+        group.qualityLines.push(`  ℹ ${where}  ${w.rule ?? w.code ?? w.tool}  ${w.message}`);
+      }
+      const key = normalizeMapKey(file.filePath);
+      if (reverifyIncompletePaths.has(key))
+        group.incomplete = true;
+      if (!group.staleRow) {
+        const staleWarning = file.warnings.find((w) => w.stale);
+        if (staleWarning)
+          group.staleRow = { staleAsOf: staleWarning.staleAsOf };
+      }
+    }
+  }
+  const projectDeltaCount = appendProjectDiagnosticsDeltaLines(groups, cwd, projectDelta, severity, includeFile);
+  const lines = [];
+  for (const group of groups.values()) {
+    lines.push(group.rel);
+    lines.push(...group.actionableLines);
+    lines.push(...group.qualityLines);
+    lines.push(...group.projectLines);
+    if (group.staleRow) {
+      lines.push(`  (${formatCacheAgeLabel(group.staleRow.staleAsOf)})`);
+    }
+    if (group.incomplete)
+      lines.push("  (re-verify incomplete)");
+  }
+  const selectedActionableFiles = filteredActionableFiles;
+  const selectedQualityFiles = filteredQualityFiles;
+  const aw = selectedActionableFiles.reduce((count, file) => count + file.warnings.length, 0);
+  const cq = selectedQualityFiles.reduce((count, file) => count + file.warnings.length, 0);
+  if (lines.length === 0) {
+    let text = `No ${severity === "all" ? "" : severity + " "}issues in the current turn delta.`;
+    const carried = getFileDiagnosticSummaries().filter((f) => includeFile(f.filePath)).map((f) => ({
+      ...f,
+      diagnostics: applyRulePolicy(applyCachedDispositions(f.diagnostics, cwd, f.filePath), policyMap, { root: cwd, filePath: f.filePath })
+    })).filter((f) => f.diagnostics.length > 0);
+    const carriedIssues = carried.reduce((n, f) => n + f.diagnostics.length, 0);
+    if (carried.length > 0) {
+      text += ` ${carriedIssues} finding${carriedIssues === 1 ? "" : "s"} across ${carried.length} file${carried.length === 1 ? "" : "s"} carried over from earlier this session — use mode=all to see them.`;
+    }
+    text += pathsScopeCacheOnlyNote(pathsScope);
+    return {
+      content: [{ type: "text", text }],
+      details: { mode: "delta", warnings: 0, carriedOverFiles: carried.length }
+    };
+  }
+  const summary = `
+Summary (turn delta): ${aw} actionable warning${aw === 1 ? "" : "s"} · ${cq} quality issue${cq === 1 ? "" : "s"} · ${projectDeltaCount} project diagnostic${projectDeltaCount === 1 ? "" : "s"}`;
+  return {
+    content: [{ type: "text", text: lines.join(`
+`) + summary }],
+    details: {
+      mode: "delta",
+      actionableWarnings: aw,
+      qualityIssues: cq,
+      projectDiagnostics: projectDeltaCount
+    }
+  };
+}
+function createCurrentIgnoreFilter(cwd) {
+  try {
+    const matcher = getProjectIgnoreMatcher(cwd);
+    return (filePath) => !matcher.isIgnored(path.resolve(filePath), false);
+  } catch {
+    return () => true;
+  }
+}
+function resolvePathsScope(cwd, rawPaths) {
+  if (!Array.isArray(rawPaths) || rawPaths.length === 0)
+    return;
+  if (rawPaths.length > MAX_PATHS_ENTRIES) {
+    throw new Error(`paths has ${rawPaths.length} entries, over the ${MAX_PATHS_ENTRIES} cap. ` + "Narrow the list or omit paths to scan without a restriction.");
+  }
+  const entries = rawPaths.filter((entry) => typeof entry === "string" && entry.trim().length > 0).map((entry) => path.resolve(path.isAbsolute(entry) ? entry : path.resolve(cwd, entry)));
+  const missing = [];
+  const fileEntries = [];
+  const existingEntries = [];
+  const dirEntries = [];
+  for (const entry of entries) {
+    let stat;
+    try {
+      stat = fsSync.statSync(entry);
+    } catch {
+      missing.push(entry);
+      fileEntries.push(entry);
+      continue;
+    }
+    if (stat.isDirectory()) {
+      dirEntries.push(entry);
+    } else {
+      fileEntries.push(entry);
+      existingEntries.push(entry);
+    }
+  }
+  const fileKeys = new Set(fileEntries.map((f) => normalizeFilePath(f)));
+  const dirPrefixes = dirEntries.map((d) => normalizeFilePath(d));
+  const includeExplicitFile = (filePath) => fileKeys.has(normalizeFilePath(path.resolve(filePath)));
+  const includeFile = (filePath) => {
+    const key = normalizeFilePath(path.resolve(filePath));
+    if (fileKeys.has(key))
+      return true;
+    return dirPrefixes.some((prefix) => key === prefix || key.startsWith(`${prefix}/`));
+  };
+  return {
+    includeFile,
+    includeExplicitFile,
+    missing,
+    existingEntries,
+    hasDirectoryEntries: dirEntries.length > 0
+  };
+}
+function pathsScopeCacheOnlyNote(scope) {
+  if (!scope)
+    return "";
+  return `
+
+Note: paths restricts this to cached findings for files dm-lens has ` + "already dispatched this session — mode=delta/all can't see files it " + "hasn't touched. Use mode=full to actively scan exactly these paths.";
+}
+function pathsScopeMissingNote(scope) {
+  if (!scope || scope.missing.length === 0)
+    return "";
+  const shown = scope.missing.slice(0, 10).map((p) => path.basename(p));
+  const more = scope.missing.length > shown.length ? ` (+${scope.missing.length - shown.length} more)` : "";
+  return `
+
+⚠ Skipped ${scope.missing.length} path(s) not found on disk: ${shown.join(", ")}${more}`;
+}
+function createScopedFileFilter(cwd, pathsScope) {
+  const ignoreFile = createCurrentIgnoreFilter(cwd);
+  return (filePath) => {
+    if (!pathsScope)
+      return ignoreFile(filePath);
+    if (!pathsScope.includeFile(filePath))
+      return false;
+    return pathsScope.includeExplicitFile(filePath) || ignoreFile(filePath);
+  };
+}
+function filterProjectDiagnosticsSnapshot(snapshot, includeFile) {
+  if (!snapshot)
+    return;
+  return {
+    ...snapshot,
+    diagnostics: snapshot.diagnostics.filter((d) => includeFile(d.filePath))
+  };
+}
+function filterProjectDiagnosticsDeltaReport(report, includeFile) {
+  if (!report)
+    return;
+  return {
+    ...report,
+    diagnostics: report.diagnostics.filter((d) => includeFile(d.filePath))
+  };
+}
+function applyProjectRulePolicy(value, policyMap, root) {
+  if (!value)
+    return;
+  return {
+    ...value,
+    diagnostics: applyRulePolicy(value.diagnostics, policyMap, {
+      root,
+      filePath: value.diagnostics[0]?.filePath ?? root
+    })
+  };
+}
+function isErrorLike(d) {
+  if (d.stale)
+    return false;
+  return d.semantic === "blocking" || d.severity === "error";
+}
+function matchesSeverity(d, severity) {
+  return matchesRecordSeverity(isErrorLike(d) ? "error" : d.severity, severity);
+}
+function matchesRecordSeverity(recordSeverity, requested) {
+  if (requested === "all")
+    return true;
+  if (requested === "error")
+    return recordSeverity === "error";
+  if (requested === "warning")
+    return recordSeverity === "error" || recordSeverity === "warning";
+  if (requested === "information")
+    return recordSeverity === "error" || recordSeverity === "warning" || recordSeverity === "info" || recordSeverity === "note" || recordSeverity === "help";
+  if (requested === "hint")
+    return recordSeverity === "error" || recordSeverity === "warning" || recordSeverity === "info" || recordSeverity === "note" || recordSeverity === "help" || recordSeverity === "hint";
+  return true;
+}
+function severityRank(d) {
+  if (d.semantic === "blocking")
+    return 0;
+  if (d.severity === "error")
+    return 1;
+  if (d.severity === "warning")
+    return 2;
+  return 3;
+}
+function bySeverityThenLine(a, b) {
+  return severityRank(a) - severityRank(b) || (a.line ?? 0) - (b.line ?? 0);
+}
+function lspSeverityName(severity) {
+  if (severity === 1)
+    return "error";
+  if (severity === 2)
+    return "warning";
+  if (severity === 3)
+    return "info";
+  return "hint";
+}
+function lspRuleId(diagnostic) {
+  const code = diagnostic.code === undefined ? undefined : String(diagnostic.code);
+  if (diagnostic.source && code)
+    return `${diagnostic.source}:${code}`;
+  return diagnostic.source ?? code ?? "lsp";
+}
+function lspDiagnosticToWidget(diagnostic) {
+  const severity = lspSeverityName(diagnostic.severity);
+  const rule = lspRuleId(diagnostic);
+  return {
+    severity,
+    semantic: diagnostic.severity === 1 ? "blocking" : "warning",
+    message: diagnostic.message,
+    line: diagnostic.range.start.line + 1,
+    col: diagnostic.range.start.character + 1,
+    rule,
+    tool: findAuxiliaryProfileForSource(diagnostic.source)?.tool ?? "lsp"
+  };
+}
+function projectDiagnosticToWidget(diagnostic, filePath) {
+  return {
+    severity: diagnostic.severity,
+    semantic: diagnostic.semantic,
+    message: diagnostic.message,
+    line: diagnostic.line,
+    col: diagnostic.column,
+    rule: diagnostic.rule ?? diagnostic.code,
+    tool: diagnostic.runner || diagnostic.tool,
+    uri: widgetDiagnosticUri(filePath, diagnostic.line, diagnostic.column),
+    ...diagnostic.observedAt !== undefined && {
+      observedAt: diagnostic.observedAt
+    }
+  };
+}
+function diagnosticDedupKey(filePath, diagnostic) {
+  const ruleId = normalizeRuleId(diagnostic.rule ?? diagnostic.tool ?? "");
+  return [path.resolve(filePath), diagnostic.line ?? "?", ruleId].join(":");
+}
+function runnerIdOf(diagnostic) {
+  return diagnostic.tool ?? diagnostic.rule?.split(":", 1)[0] ?? "";
+}
+export function runnerRetirementDecision(diagnostic, filePath, authoritativeRunnerIds, authoritativeCoverage) {
+  const runnerId = runnerIdOf(diagnostic);
+  const coverage = (authoritativeCoverage ?? []).filter((entry) => entry.runnerId === runnerId);
+  if (coverage.length === 0) {
+    return authoritativeRunnerIds?.has(runnerId) ? "retire" : "keep";
+  }
+  const realFilePath = realpathOrResolve(filePath);
+  for (const entry of coverage) {
+    const root = entry.root;
+    const relative = path.relative(root, realFilePath);
+    const underRoot = relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+    if (!underRoot)
+      continue;
+    if (entry.files.has(realFilePath)) {
+      return "retire";
+    }
+  }
+  return "keep";
+}
+function summarizeDiagnostics(filePath, diagnostics, hasFinalSnapshot) {
+  let blocking = 0;
+  let errors = 0;
+  let warnings = 0;
+  let advisories = 0;
+  for (const diagnostic of diagnostics) {
+    if (diagnostic.stale)
+      continue;
+    if (diagnostic.semantic === "blocking")
+      blocking++;
+    const tier = classifyDiagnosticTier(diagnostic);
+    if (tier === "error")
+      errors++;
+    else if (tier === "warning")
+      warnings++;
+    else if (tier === "advisory")
+      advisories++;
+  }
+  return {
+    filePath,
+    blocking,
+    errors,
+    warnings,
+    advisories,
+    hasFinalSnapshot,
+    diagnostics
+  };
+}
+const UNCONFIRMED_REASON_SENTENCE = {
+  budget: "check didn't complete within budget",
+  inconclusive: "check was inconclusive (notify-write or diagnostics wait timed out)",
+  coverage_gap: "an auxiliary scanner coverage gap",
+  service_destroyed: "the LSP service was reset mid-sweep",
+  error: "check errored",
+  binding_mismatch: "the file changed on disk since this result was computed",
+  outside_project_root: "the file is outside every initialized session project root, so no language server was asked"
+};
+const UNCONFIRMED_REASON_COUNT_LABEL = {
+  budget: "timed out",
+  inconclusive: "inconclusive",
+  coverage_gap: "coverage gap",
+  service_destroyed: "service reset mid-sweep",
+  error: "errored",
+  binding_mismatch: "stale binding",
+  outside_project_root: "outside project root"
+};
+function classifyUnconfirmedReason(result, mismatched) {
+  if (mismatched.has(result))
+    return "binding_mismatch";
+  return result.unconfirmedReason ?? (result.error ? "error" : "budget");
+}
+function tallyUnconfirmedReasons(results, mismatched) {
+  const tally = new Map;
+  for (const result of results) {
+    const reason = classifyUnconfirmedReason(result, mismatched);
+    tally.set(reason, (tally.get(reason) ?? 0) + 1);
+  }
+  return tally;
+}
+function formatUnconfirmedReasonClause(tally) {
+  const entries = [...tally.entries()].filter(([, count]) => count > 0);
+  if (entries.length === 0)
+    return "";
+  if (entries.length === 1) {
+    return UNCONFIRMED_REASON_SENTENCE[entries[0][0]];
+  }
+  return entries.map(([reason, count]) => `${count} ${UNCONFIRMED_REASON_COUNT_LABEL[reason]}`).join(", ");
+}
+function tallyLspByPrimaryServer(confirmed, unconfirmed) {
+  const byServer = new Map;
+  const bump = (filePath, wasConfirmed) => {
+    const id = primaryServerId(filePath) ?? "unknown";
+    const entry = byServer.get(id) ?? { confirmed: 0, total: 0 };
+    entry.total += 1;
+    if (wasConfirmed)
+      entry.confirmed += 1;
+    byServer.set(id, entry);
+  };
+  for (const result of confirmed)
+    bump(result.filePath, true);
+  for (const result of unconfirmed)
+    bump(result.filePath, false);
+  return byServer;
+}
+function formatLspServerBreakdown(byServer) {
+  return [...byServer.entries()].sort((a, b) => {
+    const rateA = a[1].confirmed / a[1].total;
+    const rateB = b[1].confirmed / b[1].total;
+    return rateA - rateB;
+  }).map(([id, { confirmed, total }]) => `${id}: ${confirmed}/${total}`).join(", ");
+}
+function tallyLspPrimaryVsAuxiliary(results) {
+  let primary = 0;
+  let auxiliary = 0;
+  for (const result of results) {
+    const primaryId = primaryServerId(result.filePath);
+    for (const diagnostic of result.diagnostics ?? []) {
+      if (diagnostic.serverId === primaryId)
+        primary += 1;
+      else
+        auxiliary += 1;
+    }
+  }
+  return { primary, auxiliary };
+}
+function mergeDiagnosticsWithWidgetSummaries(widgetSummaries, lspResults, projectSnapshot, projectDelta, authoritativeLspFiles, authoritativeRunnerIds, authoritativeRunnerCoverage) {
+  const byFile = new Map;
+  const seen = new Set;
+  for (const summary of widgetSummaries) {
+    const filePath = path.resolve(summary.filePath);
+    if (authoritativeLspFiles?.has(filePath))
+      continue;
+    const retained = summary.diagnostics ?? [];
+    const diagnostics = retained.filter((diagnostic) => runnerRetirementDecision(diagnostic, filePath, authoritativeRunnerIds, authoritativeRunnerCoverage) !== "retire").map((d) => ({ ...d }));
+    byFile.set(filePath, diagnostics.length === retained.length ? { ...summary, filePath, diagnostics } : summarizeDiagnostics(filePath, diagnostics, summary.hasFinalSnapshot ?? true));
+    for (const diagnostic of diagnostics) {
+      seen.add(diagnosticDedupKey(filePath, diagnostic));
+    }
+  }
+  const addDiagnostic = (filePath, widgetDiagnostic) => {
+    const existing = byFile.get(filePath);
+    const diagnostics = existing ? [...existing.diagnostics] : [];
+    const key = diagnosticDedupKey(filePath, widgetDiagnostic);
+    if (seen.has(key))
+      return;
+    seen.add(key);
+    diagnostics.push(widgetDiagnostic);
+    byFile.set(filePath, summarizeDiagnostics(filePath, diagnostics, existing?.hasFinalSnapshot ?? true));
+  };
+  for (const result of lspResults) {
+    const filePath = path.resolve(result.filePath);
+    for (const diagnostic of result.diagnostics ?? []) {
+      addDiagnostic(filePath, {
+        ...lspDiagnosticToWidget(diagnostic),
+        ...result.observedAt !== undefined && {
+          observedAt: result.observedAt
+        }
+      });
+    }
+  }
+  const deltaDiagnostics = projectDelta?.diagnostics ?? [];
+  const deltaObservedAt = parseScannedAtMs(projectDelta?.generatedAt);
+  if (deltaDiagnostics.length > 0 && deltaObservedAt === undefined) {
+    recordDegradationOnce({
+      kind: "project-delta-generatedat-unparseable",
+      subject: String(projectDelta?.generatedAt),
+      reason: "projectDelta rows fell back to the fold time because generatedAt could not be parsed"
+    });
+  }
+  for (const diagnostic of projectSnapshot?.diagnostics ?? []) {
+    addDiagnostic(path.resolve(diagnostic.filePath), projectDiagnosticToWidget(diagnostic, diagnostic.filePath));
+  }
+  for (const diagnostic of deltaDiagnostics) {
+    const widget = projectDiagnosticToWidget(diagnostic, diagnostic.filePath);
+    const observedAt = widget.observedAt ?? deltaObservedAt;
+    addDiagnostic(path.resolve(diagnostic.filePath), {
+      ...widget,
+      ...observedAt !== undefined && { observedAt }
+    });
+  }
+  return [...byFile.values()];
+}
+async function applyInlineSuppressionsToSummaries(summaries, cwd, policyMap) {
+  return Promise.all(summaries.map(async (summary) => {
+    if (!summary.diagnostics.length)
+      return summary;
+    let content;
+    try {
+      content = await fs.readFile(summary.filePath, "utf8");
+    } catch {
+      const policyKept = applyRulePolicy(summary.diagnostics, policyMap, {
+        root: cwd,
+        filePath: summary.filePath
+      });
+      return policyKept.length === summary.diagnostics.length ? summary : summarizeDiagnostics(summary.filePath, policyKept, summary.hasFinalSnapshot);
+    }
+    const { kept: policyKept } = applyFindingPolicy(summary.diagnostics, {
+      cwd,
+      filePath: summary.filePath,
+      content,
+      policyMap
+    });
+    for (const d of policyKept) {
+      const { weak } = anchorsForDiagnostic(cwd, summary.filePath, d, content);
+      if (getDisposition(cwd, weak)?.disposition === "flagged") {
+        d.flagged = true;
+      }
+    }
+    if (policyKept.length === summary.diagnostics.length)
+      return summary;
+    return summarizeDiagnostics(summary.filePath, policyKept, summary.hasFinalSnapshot);
+  }));
+}
+function shouldUseCachedProjectDiagnostics(value) {
+  return value === "cached";
+}
+function shouldRefreshProjectDiagnostics(value) {
+  return value === "cheap" || value === "all";
+}
+function shouldIncludeProjectRunners(value) {
+  return shouldRefreshProjectDiagnostics(value) || value === "cached";
+}
+function foldExtraDiagnosticsIntoSnapshot(snapshot, extra, runners, cwd) {
+  if (extra.length === 0)
+    return snapshot;
+  if (snapshot) {
+    const merged = new Set([...snapshot.runners, ...runners]);
+    return {
+      ...snapshot,
+      diagnostics: [...snapshot.diagnostics, ...extra],
+      runners: [...merged]
+    };
+  }
+  return {
+    version: PROJECT_DIAGNOSTICS_CACHE_VERSION,
+    cwd,
+    tier: "all",
+    scannedAt: new Date().toISOString(),
+    diagnostics: extra,
+    filesScanned: 0,
+    runners
+  };
+}
+async function getProjectDiagnosticsSnapshotForFullMode(cwd, options) {
+  let loaded;
+  if (shouldRefreshProjectDiagnostics(options.refreshRunners)) {
+    loaded = await scanProjectDiagnostics({
+      cwd,
+      tier: "cheap",
+      maxFiles: options.maxProjectFiles,
+      signal: options.signal,
+      files: options.files,
+      includeGenerated: options.includeGenerated
+    });
+  } else if (shouldUseCachedProjectDiagnostics(options.refreshRunners)) {
+    loaded = loadProjectDiagnosticsSnapshot(cwd);
+  }
+  if (!loaded)
+    return;
+  const reconciled = reconcileProjectDiagnosticsSnapshot(loaded);
+  if (reconciled.staleDropped > 0) {
+    logLatency({
+      type: "phase",
+      toolName: "lens_diagnostics",
+      filePath: cwd,
+      phase: "project_snapshot_rows_retired",
+      durationMs: 0,
+      metadata: {
+        files: reconciled.staleDropped,
+        rows: loaded.diagnostics.length - reconciled.snapshot.diagnostics.length,
+        scannedAt: loaded.scannedAt,
+        arm: shouldRefreshProjectDiagnostics(options.refreshRunners) ? "fresh" : "cached"
+      }
+    });
+  }
+  return reconciled.snapshot;
+}
+async function formatFullMode(cwd, severity, lspService, cacheManager, options = {}) {
+  const runWorkspaceDiagnostics = lspService.runWorkspaceDiagnostics;
+  if (typeof runWorkspaceDiagnostics !== "function") {
+    return {
+      content: [
+        {
+          type: "text",
+          text: "LSP service does not support project-wide workspace diagnostics."
+        }
+      ],
+      details: { mode: "full", filesChecked: 0, lspUnavailable: true }
+    };
+  }
+  const { signal, pathsScope, nextWriteIndex } = options;
+  const host = options.host ?? "pi";
+  const includeFile = createScopedFileFilter(cwd, pathsScope);
+  const explicitFiles = pathsScope && !pathsScope.hasDirectoryEntries ? pathsScope.existingEntries : undefined;
+  const projectRunnersRequested = shouldIncludeProjectRunners(options.refreshRunners);
+  const analyzersPromise = projectRunnersRequested ? loadBootstrapClients().then((clients) => fetchFreshProjectDiagnostics(cacheManager, cwd, clients, signal, {
+    runtime: options.runtime,
+    analysisRoot: options.analysisRoot
+  })) : Promise.resolve({
+    diagnostics: [],
+    runners: [],
+    analyzed: [],
+    authoritativeCoverage: [],
+    cold: [...ANALYZER_IDS],
+    coldReasons: Object.fromEntries(ANALYZER_IDS.map((id) => [id, notRequestedReason(host)])),
+    failed: [],
+    timings: {}
+  });
+  const [rawLspResults, rawProjectSnapshot, extracted] = await Promise.all([
+    runWorkspaceDiagnostics.call(lspService, cwd, {
+      maxFiles: options.maxLspFiles,
+      signal,
+      onProgress: options.onProgress,
+      onServerReady: options.onServerReady,
+      nextWriteIndex: options.nextWriteIndex,
+      files: explicitFiles
+    }),
+    getProjectDiagnosticsSnapshotForFullMode(cwd, {
+      ...options,
+      files: explicitFiles
+    }),
+    analyzersPromise
+  ]);
+  if (extracted.analysisRootError) {
+    return {
+      content: [{ type: "text", text: extracted.analysisRootError }],
+      isError: true,
+      details: {
+        mode: "full",
+        analysisRootError: extracted.analysisRootError,
+        analysisRootValidation: extracted.analysisRootValidation
+      }
+    };
+  }
+  const aborted = signal?.aborted ?? false;
+  const lspResults = await demoteInferredProjectSweepResults(rawLspResults.filter((result) => includeFile(result.filePath)), cwd, lspService, signal);
+  const mismatchedLspResults = await findFullScanBindingMismatches(lspResults);
+  const confirmedLspResults = lspResults.filter((result) => !result.timedOut && !result.error && !mismatchedLspResults.has(result));
+  const fullyCoveredLspResults = confirmedLspResults.filter((result) => (result.unconfirmedServerIds?.length ?? 0) === 0);
+  const partiallyCoveredLspResults = confirmedLspResults.filter((result) => (result.unconfirmedServerIds?.length ?? 0) > 0);
+  const unconfirmedLspResults = lspResults.filter((result) => result.timedOut || result.error || mismatchedLspResults.has(result));
+  const authoritativeLspFiles = new Set;
+  const unreconciledFiles = new Set;
+  for (const result of fullyCoveredLspResults) {
+    try {
+      const diagnostics = convertLspDiagnostics(result.diagnostics, result.filePath, { scanOrigin: "lens_diagnostics_full" });
+      const retagged = retagAuxiliaryDiagnostics(diagnostics, result.diagnostics, "", { cwd, fileRole: detectFileRole(result.filePath) });
+      const retired = reconcileScanDiagnostics(result.filePath, retagged, true, result.writeIndex ?? nextWriteIndex?.(), result.observedAt);
+      if (retired === true) {
+        authoritativeLspFiles.add(path.resolve(result.filePath));
+      } else {
+        unreconciledFiles.add(path.resolve(result.filePath));
+        recordDegradationOnce({
+          kind: "diagnostic-retained-unreconciled",
+          subject: `${path.resolve(result.filePath)}:lsp`,
+          reason: "confirmed diagnostic result could not replace retained widget state"
+        });
+      }
+    } catch {
+      unreconciledFiles.add(path.resolve(result.filePath));
+      recordDegradationOnce({
+        kind: "diagnostic-retained-unreconciled",
+        subject: `${path.resolve(result.filePath)}:lsp`,
+        reason: "confirmed diagnostic result failed during widget reconciliation"
+      });
+    }
+  }
+  const policyMap = loadProjectRulePolicyMap(cwd);
+  const scannedSnapshot = filterProjectDiagnosticsSnapshot(rawProjectSnapshot, includeFile);
+  const authoritativeRunnerIds = new Set(extracted.analyzed ?? []);
+  const authoritativeRunnerCoverage = extracted.authoritativeCoverage ?? [];
+  const foldedProjectSnapshot = foldExtraDiagnosticsIntoSnapshot(scannedSnapshot, extracted.diagnostics.filter((d) => includeFile(d.filePath)), extracted.runners, cwd);
+  const projectSnapshot = applyProjectRulePolicy(foldedProjectSnapshot, policyMap, cwd);
+  const projectDelta = applyProjectRulePolicy(filterProjectDiagnosticsDeltaReport(loadProjectDiagnosticsDeltaReport(cwd), includeFile), policyMap, cwd);
+  const authoritativeRetiredCount = getFileDiagnosticSummaries().filter((summary) => includeFile(summary.filePath) && authoritativeLspFiles.has(path.resolve(summary.filePath)) && (summary.diagnostics?.length ?? 0) > 0).length;
+  if (authoritativeRetiredCount > 0) {
+    logLatency({
+      type: "phase",
+      phase: "lsp_authoritative_widget_retire",
+      filePath: "",
+      durationMs: 0,
+      metadata: { files: authoritativeRetiredCount }
+    });
+  }
+  const retiredRunnerCounts = new Map;
+  const runnerRetiredRows = getFileDiagnosticSummaries().filter((summary) => includeFile(summary.filePath)).reduce((total, summary) => total + (summary.diagnostics ?? []).filter((diagnostic) => {
+    const retired = runnerRetirementDecision(diagnostic, summary.filePath, authoritativeRunnerIds, authoritativeRunnerCoverage) === "retire";
+    if (retired) {
+      const runnerId = runnerIdOf(diagnostic);
+      retiredRunnerCounts.set(runnerId, (retiredRunnerCounts.get(runnerId) ?? 0) + 1);
+    }
+    return retired;
+  }).length, 0);
+  if (runnerRetiredRows > 0) {
+    logLatency({
+      type: "phase",
+      phase: "runner_authoritative_widget_retire",
+      filePath: "",
+      durationMs: 0,
+      metadata: {
+        rows: runnerRetiredRows,
+        runners: [...retiredRunnerCounts.keys()].join(","),
+        coverage: authoritativeRunnerCoverage.map((entry) => ({
+          runnerId: entry.runnerId,
+          root: entry.root,
+          files: entry.files.size
+        }))
+      }
+    });
+  }
+  for (const entry of authoritativeRunnerCoverage) {
+    if (entry.files.size === 0)
+      continue;
+    if (!claimPhaseOncePerSession("runner_coverage_retired", entry.runnerId)) {
+      continue;
+    }
+    logLatency({
+      type: "phase",
+      phase: "runner_coverage_retired",
+      filePath: "",
+      durationMs: 0,
+      metadata: {
+        runnerId: entry.runnerId,
+        count: retiredRunnerCounts.get(entry.runnerId) ?? 0
+      }
+    });
+  }
+  let summaries = await applyInlineSuppressionsToSummaries(mergeDiagnosticsWithWidgetSummaries(getFileDiagnosticSummaries().filter((summary) => includeFile(summary.filePath)), confirmedLspResults, projectSnapshot, projectDelta, authoritativeLspFiles, authoritativeRunnerIds, authoritativeRunnerCoverage), cwd, policyMap);
+  if (unreconciledFiles.size > 0) {
+    summaries = summaries.map((summary) => unreconciledFiles.has(path.resolve(summary.filePath)) ? summarizeDiagnostics(summary.filePath, markUnreconciledFindings(summary.diagnostics), summary.hasFinalSnapshot) : summary);
+  }
+  const parsedProjectScanObservedAt = projectSnapshot?.scannedAt ? Date.parse(projectSnapshot.scannedAt) : undefined;
+  const projectScanObservedAt = parsedProjectScanObservedAt !== undefined && Number.isFinite(parsedProjectScanObservedAt) ? parsedProjectScanObservedAt : undefined;
+  for (const summary of summaries) {
+    reconcileCorrelatedScanDiagnostics(summary.filePath, summary.diagnostics, nextWriteIndex?.(), projectScanObservedAt);
+  }
+  const result = await formatAllMode(cwd, severity, summaries, {
+    mode: "full",
+    lspFilesChecked: rawLspResults.length,
+    partial: aborted,
+    projectDiagnostics: projectSnapshot === undefined ? undefined : {
+      tier: projectSnapshot.tier,
+      filesScanned: projectSnapshot.filesScanned,
+      diagnostics: projectSnapshot.diagnostics.length,
+      runners: projectSnapshot.runners
+    },
+    projectDiagnosticsDelta: projectDelta === undefined ? undefined : {
+      diagnostics: projectDelta.diagnostics.length,
+      sources: projectDelta.sources,
+      turnIndex: projectDelta.turnIndex
+    }
+  }, 0, pathsScope);
+  const missingNote = pathsScopeMissingNote(pathsScope);
+  const unconfirmedByReason = tallyUnconfirmedReasons(unconfirmedLspResults, mismatchedLspResults);
+  const lspServerBreakdown = tallyLspByPrimaryServer(confirmedLspResults, unconfirmedLspResults);
+  const serverBreakdownClause = lspServerBreakdown.size > 1 ? ` — by server: ${formatLspServerBreakdown(lspServerBreakdown)}.` : "";
+  const unconfirmedLspNote = unconfirmedLspResults.length > 0 ? `
+
+⚠ LSP sweep: ${confirmedLspResults.length} file(s) confirmed via LSP, ` + `${unconfirmedLspResults.length} unconfirmed (${formatUnconfirmedReasonClause(unconfirmedByReason)})${serverBreakdownClause} — NOT the same as 0 diagnostics for: ${unconfirmedLspResults.slice(0, 20).map((result) => result.filePath).join(", ")}${unconfirmedLspResults.length > 20 ? ", …" : ""}. These files' LSP contribution is excluded from this result; re-run mode=full to retry them (they may still show findings above from cached/project-runner state).` : "";
+  const uncoveredScannerIds = [
+    ...new Set(partiallyCoveredLspResults.flatMap((result) => result.unconfirmedServerIds ?? []))
+  ].sort((a, b) => Number(a > b) - Number(a < b));
+  const auxiliaryCoverageNote = uncoveredScannerIds.length > 0 ? `
+
+⚠ Auxiliary coverage incomplete: ${uncoveredScannerIds.join(", ")} did not answer for ${partiallyCoveredLspResults.length} file(s). Findings from answering servers are included; this is not a clean verdict for the named scanner lane(s).` : "";
+  const lspPrimaryVsAuxiliary = tallyLspPrimaryVsAuxiliary(confirmedLspResults);
+  logExtension({
+    subsystem: "lsp-diagnostics",
+    message: "lens_diagnostics verdict",
+    metadata: {
+      server: [
+        ...new Set(confirmedLspResults.map((result) => primaryServerId(result.filePath) ?? "unknown"))
+      ].join(","),
+      primary: lspPrimaryVsAuxiliary.primary,
+      auxiliary: lspPrimaryVsAuxiliary.auxiliary,
+      total: lspPrimaryVsAuxiliary.primary + lspPrimaryVsAuxiliary.auxiliary,
+      sources: [
+        ...new Set(confirmedLspResults.flatMap((result) => (result.diagnostics ?? []).map((diagnostic) => diagnostic.source ?? "unknown")))
+      ].slice(0, 5)
+    }
+  });
+  const lspPrimaryVsAuxiliaryNote = lspPrimaryVsAuxiliary.primary + lspPrimaryVsAuxiliary.auxiliary > 0 ? `
+
+LSP sweep findings: ${lspPrimaryVsAuxiliary.primary} primary (language server), ` + `${lspPrimaryVsAuxiliary.auxiliary} auxiliary (ast-grep/opengrep/zizmor/typos/marksman/...).` : "";
+  const abortedIds = new Set(extracted.abortedIds ?? []);
+  const genuinelyColdIds = extracted.cold.filter((id) => !abortedIds.has(id));
+  const partialIds = extracted.partial ?? [];
+  const coldNote = extracted.unsafeRoot ? `
+
+heavyweight analyzers skipped: the analysis root resolves at or above the home directory, so a fresh knip/jscpd/madge/gitleaks/govulncheck/trivy/dead-code scan would walk every unrelated tree under it. Supply a project directory below the home ceiling. Absence of their findings is NOT a clean verdict.` : extracted.analysisRootError ? `
+
+heavyweight analyzers skipped: ${extracted.analysisRootError}. Supply an existing project directory below the home ceiling. Absence of their findings is NOT a clean verdict.` : !projectRunnersRequested && genuinelyColdIds.length > 0 ? `
+
+not run this call (quick mode): ${genuinelyColdIds.join(", ")}. ${notRequestedReason(host)}. Absence of their findings is NOT a clean verdict.` : genuinelyColdIds.length > 0 ? `
+
+cold (not applicable / unavailable this run): ${genuinelyColdIds.map((id) => formatNotRunEntry(id, extracted.coldReasons)).join(", ")}. These analyzers have not contributed to this result — absence of their findings is NOT a clean verdict.` : "";
+  const partialNote = partialIds.length > 0 ? `
+
+⚠ partial coverage (findings included): ${partialIds.map((id) => `${id} — ${extracted.partialReasons?.[id] ?? "coverage is incomplete"}`).join(", ")}. Coverage is incomplete, so absence of findings is NOT a clean verdict.` : "";
+  const testRunnerEditScopedNote = extracted.runners.includes("test-runner") ? `
+
+test-runner coverage is edit-scoped, NOT a full-project run: its findings only reflect the test file(s) touched by the most recent edit's turn_end fire, not a fresh whole-project test suite run (mode=full never re-runs the suite — see fresh-fetch.ts). Absence of test-runner findings elsewhere in the project is NOT a clean verdict, and presence here does not mean "just checked" — it may be from several turns ago.` : "";
+  const failedAnalyzers = extracted.failed ?? [];
+  const failedNote = failedAnalyzers.length > 0 ? `
+
+failed (ran, but no trustworthy result): ${failedAnalyzers.map(({ id, summary }) => `${id} — ${summary}`).join(", ")}. These analyzers were not cached and will be retried; absence of their findings is NOT a clean verdict.` : "";
+  const dispositionSuppressedByLaneText = Object.entries(extracted.dispositionSuppressedByLane ?? {}).map(([id, count]) => `${id} ${count}`).join(", ");
+  const dispositionSuppressedNote = (extracted.dispositionSuppressed ?? 0) > 0 ? `
+
+suppressed by disposition: ${extracted.dispositionSuppressed} finding(s) dropped from this result because they're marked false-positive or won't-fix (${dispositionSuppressedByLaneText}). Not a clean verdict for those locations — they were found, then intentionally hidden.` : "";
+  const walkUnsafeRoot = explicitFiles === undefined && isAtOrAboveHomeDir(cwd);
+  const walkUnsafeRootNote = walkUnsafeRoot ? `
+
+project file walk skipped: the working directory resolves at or above the home directory, so the cheap project scan and the LSP workspace sweep would each enumerate every unrelated tree under it. Re-run from inside a project directory. Absence of their findings is NOT a clean verdict.` : "";
+  const scanTruncatedNoticeText = projectSnapshot ? scanTruncationNotice(projectSnapshot) : undefined;
+  const scanTruncatedNote = scanTruncatedNoticeText ? `
+
+${scanTruncatedNoticeText}` : "";
+  const generatedSkipNoticeText = projectSnapshot ? generatedSkipNotice(projectSnapshot, host) : undefined;
+  const generatedSkipNote = generatedSkipNoticeText ? `
+
+${generatedSkipNoticeText}` : "";
+  const cheapScanScannedAtMs = rawProjectSnapshot?.scannedAt ? Date.parse(rawProjectSnapshot.scannedAt) : undefined;
+  const cheapScanStatusNote = !projectRunnersRequested ? `
+
+cheap project scan (tree-sitter/fact-rules/ast-grep): not run this call (${notRequestedReason(host)}).` : options.refreshRunners === "cached" ? cheapScanScannedAtMs !== undefined && Number.isFinite(cheapScanScannedAtMs) ? `
+
+cheap project scan (tree-sitter/fact-rules/ast-grep): served from cache, ${formatCacheAgeOld(Date.now() - cheapScanScannedAtMs)} — not re-run this call.` : `
+
+cheap project scan (tree-sitter/fact-rules/ast-grep): not run (no cached scan; refresh with refreshRunners=cheap/all to populate).` : "";
+  const abortedNote = abortedIds.size > 0 ? `
+
+stopped mid-scan (still running in the background, not reflected in this result): ${[
+    ...abortedIds
+  ].join(", ")}. Not a clean verdict for these — re-run mode=full to pick up their result once it's cached.` : "";
+  const cachedAgeMs = extracted.cachedAgeMs ?? {};
+  const timingEntries = Object.entries(extracted.timings ?? {}).filter(([id]) => !(id in cachedAgeMs));
+  const freshNote = timingEntries.length > 0 ? `
+
+fetched fresh this call: ${timingEntries.map(([id, ms]) => `${id} (${Math.round(ms)}ms)`).join(", ")}.` : "";
+  const cachedAgeEntries = Object.entries(cachedAgeMs);
+  const cachedAgeNote = cachedAgeEntries.length > 0 ? `
+
+served from cache this call (not re-run): ${cachedAgeEntries.map(([id, ms]) => `${id} (${formatCacheAgeOld(ms)})`).join(", ")}.` : "";
+  const resultWithCold = {
+    ...result,
+    details: {
+      ...result.details,
+      coldRunners: extracted.cold,
+      partialRunners: partialIds,
+      coldReasons: extracted.coldReasons ?? {},
+      failedAnalyzers,
+      analyzerTimingsMs: extracted.timings,
+      dispositionSuppressed: extracted.dispositionSuppressed ?? 0,
+      dispositionSuppressedByLane: extracted.dispositionSuppressedByLane ?? {},
+      analyzersCachedAgeMs: cachedAgeMs,
+      analyzersAborted: extracted.aborted ?? false,
+      analyzersAbortedIds: extracted.abortedIds ?? [],
+      analyzersUnsafeRoot: extracted.analysisRootValidation?.state === "unsafe" || extracted.unsafeRoot === true,
+      analysisRootValidation: extracted.analysisRootValidation,
+      projectWalkUnsafeRoot: walkUnsafeRoot,
+      lspFilesConfirmed: confirmedLspResults.length,
+      lspFilesUnconfirmed: unconfirmedLspResults.length,
+      lspFilesPartiallyCovered: partiallyCoveredLspResults.length,
+      unconfirmedLspServerIds: uncoveredScannerIds,
+      unconfirmedLspFiles: unconfirmedLspResults.map((result) => result.filePath),
+      lspServerBreakdown: Object.fromEntries(lspServerBreakdown),
+      lspPrimaryDiagnosticsCount: lspPrimaryVsAuxiliary.primary,
+      lspAuxiliaryDiagnosticsCount: lspPrimaryVsAuxiliary.auxiliary,
+      projectScanTruncated: projectSnapshot?.scanTruncated ?? false,
+      ...projectSnapshot?.generatedFileSkips ? { projectGeneratedFileSkips: projectSnapshot.generatedFileSkips } : {},
+      ...projectSnapshot?.generatedNameOnlySkips ? {
+        projectGeneratedNameOnlySkips: projectSnapshot.generatedNameOnlySkips
+      } : {},
+      ...projectSnapshot?.generatedDirSkips ? { projectGeneratedDirSkips: projectSnapshot.generatedDirSkips } : {}
+    }
+  };
+  if (aborted) {
+    const timedOut = signal?.reason?.name === "TimeoutError";
+    const note = timedOut ? `
+
+⚠ Scan exceeded its ${Math.round((options.wallClockMs ?? 0) / 1000)}s time budget and was stopped — results are partial. ` + "Narrow it with maxLspFiles, or raise DM_LENS_LENS_DIAGNOSTICS_FULL_TIMEOUT_MS." : `
+
+⚠ Scan cancelled before completion — results are partial. ` + "Re-run with a smaller maxLspFiles to finish within budget.";
+    return {
+      content: [
+        {
+          type: "text",
+          text: result.content[0].text + note + unconfirmedLspNote + auxiliaryCoverageNote + lspPrimaryVsAuxiliaryNote + partialNote + coldNote + testRunnerEditScopedNote + failedNote + dispositionSuppressedNote + walkUnsafeRootNote + scanTruncatedNote + generatedSkipNote + abortedNote + freshNote + cachedAgeNote + cheapScanStatusNote + missingNote
+        }
+      ],
+      details: { ...resultWithCold.details, timedOut }
+    };
+  }
+  if (missingNote || coldNote || partialNote || testRunnerEditScopedNote || failedNote || dispositionSuppressedNote || walkUnsafeRootNote || scanTruncatedNote || generatedSkipNote || abortedNote || freshNote || cachedAgeNote || cheapScanStatusNote || unconfirmedLspNote || auxiliaryCoverageNote || lspPrimaryVsAuxiliaryNote) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: result.content[0].text + unconfirmedLspNote + auxiliaryCoverageNote + lspPrimaryVsAuxiliaryNote + partialNote + coldNote + testRunnerEditScopedNote + failedNote + dispositionSuppressedNote + walkUnsafeRootNote + scanTruncatedNote + generatedSkipNote + abortedNote + freshNote + cachedAgeNote + cheapScanStatusNote + missingNote
+        }
+      ],
+      details: resultWithCold.details
+    };
+  }
+  return resultWithCold;
+}
+async function projectResolvedCwd(summary, cwd) {
+  const resolvedCwd = await resolveLspCwdForFile(summary.filePath, cwd);
+  return {
+    ...summary,
+    ...resolvedCwd === undefined ? {} : { resolvedCwd },
+    diagnostics: summary.diagnostics ?? []
+  };
+}
+async function formatAllMode(cwd, severity, summaries = getFileDiagnosticSummaries(), detailOverrides = { mode: "all" }, staleDropped = 0, pathsScope, dependencyDemoted = 0) {
+  const footerCapped = summaries.reduce((n, s) => n + (s.diagnostics ?? []).filter((d) => d.footerRetired === true).length, 0);
+  const staleNote = (staleDropped > 0 ? ` (${staleDropped} changed file${staleDropped === 1 ? "" : "s"} omitted as stale — use mode=full to rescan)` : "") + (dependencyDemoted > 0 ? ` (${dependencyDemoted} blocking finding${dependencyDemoted === 1 ? "" : "s"} demoted to [stale] — an imported file changed since; re-run to confirm)` : "") + (footerCapped > 0 ? ` (${footerCapped} demoted finding${footerCapped === 1 ? "" : "s"} capped after ${DEPENDENCY_DRIFT_MAX_DELIVERIES} unconfirmed deliveries — no longer shown in the dm-lens footer, still listed here; re-run to confirm)` : "");
+  const isFullMode = detailOverrides.mode === "full";
+  const includeFile = createScopedFileFilter(cwd, pathsScope);
+  const policyMap = loadProjectRulePolicyMap(cwd);
+  const dispositioned = isFullMode ? summaries : summaries.map((s) => {
+    const diagnostics = s.diagnostics ?? [];
+    const kept = applyCachedDispositions(diagnostics, cwd, s.filePath);
+    const policyKept = applyRulePolicy(kept, policyMap, {
+      root: cwd,
+      filePath: s.filePath
+    });
+    if (policyKept.length === kept.length && kept.length === diagnostics.length)
+      return s;
+    return summarizeDiagnostics(s.filePath, policyKept, s.hasFinalSnapshot);
+  });
+  const eofGated = dispositioned.map((s) => {
+    const { diagnostics, demotedCount } = demotePastEofDiagnostics({
+      store: "lens_diagnostics",
+      cwd,
+      filePath: s.filePath,
+      diagnostics: s.diagnostics ?? [],
+      resync: resyncDocumentOnPastEof
+    });
+    if (demotedCount === 0)
+      return s;
+    return summarizeDiagnostics(s.filePath, diagnostics, s.hasFinalSnapshot);
+  });
+  const visibleSummaries = eofGated.filter((s) => includeFile(s.filePath));
+  const withIssues = visibleSummaries.filter((s) => {
+    if (severity === "error")
+      return s.blocking > 0 || s.errors > 0;
+    if (severity === "warning")
+      return s.blocking > 0 || s.errors > 0 || s.warnings > 0;
+    return s.blocking > 0 || s.errors > 0 || s.warnings > 0 || s.advisories > 0 || (s.diagnostics ?? []).some((d) => d.stale);
+  });
+  const pathsNote = isFullMode ? "" : pathsScopeCacheOnlyNote(pathsScope);
+  if (withIssues.length === 0) {
+    const text = (visibleSummaries.length === 0 ? "No files diagnosed yet this session." : `No ${severity === "all" ? "" : severity + " "}issues across ${visibleSummaries.length} file${visibleSummaries.length === 1 ? "" : "s"} diagnosed this session. ✓`) + staleNote + pathsNote;
+    return {
+      content: [{ type: "text", text }],
+      details: {
+        ...detailOverrides,
+        filesChecked: visibleSummaries.length,
+        staleDropped
+      }
+    };
+  }
+  const sorted = withIssues.sort((a, b) => b.blocking - a.blocking || b.errors - a.errors || b.warnings - a.warnings);
+  const rendered = await Promise.all(sorted.map((summary) => projectResolvedCwd(summary, cwd)));
+  const lines = [];
+  let totalBlocking = 0;
+  let totalErrors = 0;
+  let totalWarnings = 0;
+  let totalAdvisories = 0;
+  for (const s of rendered) {
+    const rel = path.relative(cwd, s.filePath);
+    const parts = [];
+    if (s.blocking > 0)
+      parts.push(`\uD83D\uDD34 ${s.blocking} blocking`);
+    if (s.errors > 0 && s.blocking === 0)
+      parts.push(`${s.errors}E`);
+    if (s.warnings > 0)
+      parts.push(`${s.warnings}W`);
+    if (s.advisories > 0)
+      parts.push(`${s.advisories} hint${s.advisories === 1 ? "" : "s"}`);
+    if (!s.hasFinalSnapshot)
+      parts.push(`(pending)`);
+    const staleCount = (s.diagnostics ?? []).filter((d) => d.stale).length;
+    if (staleCount > 0) {
+      parts.push(`${staleCount} stale — re-run to confirm`);
+    }
+    if (s.resolvedCwd !== undefined)
+      parts.push(`cwd=${s.resolvedCwd}`);
+    lines.push(`${rel}  ${parts.join("  ")}`);
+    const matching = (s.diagnostics ?? []).filter((d) => matchesSeverity(d, severity)).sort(bySeverityThenLine);
+    const shown = matching.slice(0, MAX_DIAGNOSTICS_PER_FILE);
+    for (const d of shown) {
+      const marker = d.stale ? "" : isErrorLike(d) ? d.semantic === "blocking" ? "\uD83D\uDD34 " : "" : "";
+      const label = d.rule ?? d.tool;
+      const tag = label ? ` [${label}]` : "";
+      const flaggedTag = d.flagged ? " \uD83D\uDCCC flagged-to-fix" : "";
+      const msg = d.message.replace(/\s+/g, " ").trim();
+      const pastEof = d.stale && (d.staleReason ?? "past-eof") === "past-eof";
+      const loc = pastEof ? PAST_EOF_STALE_MARKER : `L${d.line ?? "?"}`;
+      const staleTag = d.stale && !pastEof ? ` ${STALE_LINE_MARKER}` : "";
+      lines.push(`  ${marker}${loc}: ${msg}${tag}${flaggedTag}${staleTag}`);
+    }
+    if (matching.length > shown.length) {
+      lines.push(`  … ${matching.length - shown.length} more in this file (showing ${shown.length} of ${matching.length})`);
+    }
+    totalBlocking += s.blocking;
+    totalErrors += s.errors;
+    totalWarnings += s.warnings;
+    totalAdvisories += s.advisories;
+  }
+  const summary = [
+    `
+Summary (${visibleSummaries.length} files diagnosed this session):`,
+    totalBlocking > 0 ? `  \uD83D\uDD34 ${totalBlocking} blocking error${totalBlocking === 1 ? "" : "s"}` : null,
+    totalBlocking === 0 && totalErrors > 0 ? `  ${totalErrors} error${totalErrors === 1 ? "" : "s"}` : null,
+    totalWarnings > 0 ? `  ${totalWarnings} warning${totalWarnings === 1 ? "" : "s"}` : null,
+    totalAdvisories > 0 ? `  ${totalAdvisories} hint/info (style — not counted as warnings)` : null
+  ].filter(Boolean).join(`
+`);
+  return {
+    content: [
+      { type: "text", text: lines.join(`
+`) + summary + staleNote }
+    ],
+    details: {
+      ...detailOverrides,
+      filesWithIssues: withIssues.length,
+      totalBlocking,
+      totalErrors,
+      totalWarnings,
+      totalAdvisories,
+      staleDropped
+    }
+  };
+}