@duckmind/dm-linux-x64 0.65.8 → 0.66.2

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

@@ -1,1484 +0,0 @@
-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 } 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/index.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);
-  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)
-  })).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)
-    })).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) {
-  if (!value)
-    return;
-  return {
-    ...value,
-    diagnostics: applyRulePolicy(value.diagnostics, policyMap)
-  };
-}
-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)
-  };
-}
-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));
-    }
-  }
-  for (const diagnostic of projectSnapshot?.diagnostics ?? []) {
-    addDiagnostic(path.resolve(diagnostic.filePath), projectDiagnosticToWidget(diagnostic, diagnostic.filePath));
-  }
-  for (const diagnostic of projectDelta?.diagnostics ?? []) {
-    addDiagnostic(path.resolve(diagnostic.filePath), projectDiagnosticToWidget(diagnostic, diagnostic.filePath));
-  }
-  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);
-      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) {
-  if (shouldRefreshProjectDiagnostics(options.refreshRunners)) {
-    return scanProjectDiagnostics({
-      cwd,
-      tier: "cheap",
-      maxFiles: options.maxProjectFiles,
-      signal: options.signal,
-      files: options.files,
-      includeGenerated: options.includeGenerated
-    });
-  }
-  if (shouldUseCachedProjectDiagnostics(options.refreshRunners)) {
-    const cached = loadProjectDiagnosticsSnapshot(cwd);
-    if (!cached)
-      return;
-    const reconciled = reconcileProjectDiagnosticsSnapshot(cached);
-    if (reconciled.staleDropped > 0) {
-      logLatency({
-        type: "phase",
-        toolName: "lens_diagnostics",
-        filePath: cwd,
-        phase: "project_snapshot_rows_retired",
-        durationMs: 0,
-        metadata: {
-          files: reconciled.staleDropped,
-          rows: cached.diagnostics.length - reconciled.snapshot.diagnostics.length,
-          scannedAt: cached.scannedAt
-        }
-      });
-    }
-    return reconciled.snapshot;
-  }
-  return;
-}
-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);
-  const projectDelta = applyProjectRulePolicy(filterProjectDiagnosticsDeltaReport(loadProjectDiagnosticsDeltaReport(cwd), includeFile), policyMap);
-  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);
-    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
-    }
-  };
-}