@duckmind/dm-linux-x64 0.65.5 → 0.65.6

package/extensions/dm-lens/dist/clients/widget-state.js

@@ -0,0 +1,963 @@
+import { readFileSync } from "node:fs";
+import { stat } from "node:fs/promises";
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+import { BoundedFifoMap } from "./bounded-cache.js";
+import { demotePastEofDiagnostics } from "./diagnostic-line-freshness.js";
+import { visibleWidth } from "./deps/dm-tui-compat.js";
+import { normalizeEphemeralMapKey, normalizeMapKey } from "./path-utils.js";
+import { fitLine } from "./tui-fit.js";
+import { WriteOrderingGuard } from "./write-ordering-guard.js";
+import { collectForwardImportMtimes } from "./blocker-freshness.js";
+import { normalizeMessage } from "./finding-identity.js";
+import { freshnessFromMtime } from "./freshness.js";
+import { PAST_EOF_STALE_MARKER } from "./diagnostic-line-freshness.js";
+import { STALE_LINE_MARKER } from "./stale-marker.js";
+import { anchorsForDiagnostic, applyDispositions, getDisposition, registerWidgetDispositionReconciler, strictAnchorSpan, strictAnchorSpansIn } from "./diagnostic-dispositions.js";
+import { recordDegradationOnce } from "./degradation-ledger.js";
+function fileMapKey(filePath) {
+  return normalizeEphemeralMapKey(filePath);
+}
+export function isBlocking(d) {
+  if (d.disposition)
+    return false;
+  if (d.stale)
+    return false;
+  if (d.semantic === "blocking")
+    return true;
+  if (d.semantic == null && d.severity === "error")
+    return true;
+  return false;
+}
+const files = new Map;
+let sessionLanguages = [];
+let requestRenderFn = null;
+const diagnosticsWriteGuard = new WriteOrderingGuard;
+const runnerWriteGuard = new WriteOrderingGuard;
+const MAX_STORED_DIAGNOSTICS_PER_FILE = 12;
+const MAX_RETAINED_SUPPRESSED_PER_FILE = 12;
+const MAX_INACTIVE_FILE_RECORDS = 1024;
+const ACTIVE_FILE_IDLE_MS = 30 * 60000;
+export const MAX_LSP_SERVER_RECORDS = 128;
+const lspServers = new BoundedFifoMap(MAX_LSP_SERVER_RECORDS);
+let nextInactivePruneSize = MAX_INACTIVE_FILE_RECORDS + 1;
+function pruneInactiveFileRecords(now = Date.now()) {
+  if (files.size <= MAX_INACTIVE_FILE_RECORDS)
+    return;
+  const victims = [...files.entries()].filter(([, rec]) => now - rec.touchedAt > ACTIVE_FILE_IDLE_MS && !hasLiveDiagnostic(rec)).sort(([, a], [, b]) => a.touchedAt - b.touchedAt);
+  for (const [key] of victims) {
+    if (files.size <= MAX_INACTIVE_FILE_RECORDS)
+      break;
+    files.delete(key);
+  }
+}
+function maybePruneInactiveFileRecords() {
+  if (files.size < nextInactivePruneSize)
+    return;
+  pruneInactiveFileRecords();
+  nextInactivePruneSize = Number.POSITIVE_INFINITY;
+}
+export function setRenderCallback(fn) {
+  requestRenderFn = fn;
+}
+export function reconcileWidgetDisposition(cwd, target, _disposition, content) {
+  const current = getFileDiagnostics(target.filePath);
+  if (!current) {
+    recordDegradationOnce({
+      kind: "widget-disposition-reconcile-fallback",
+      subject: target.filePath,
+      reason: "the marked finding's widget record is absent"
+    });
+    return;
+  }
+  let source = content ?? target.content;
+  if (source === undefined) {
+    try {
+      source = readFileSync(target.filePath, "utf8");
+    } catch {
+      recordDegradationOnce({
+        kind: "widget-disposition-reconcile-fallback",
+        subject: target.filePath,
+        reason: "the disposition anchor content could not be read"
+      });
+      source = "";
+    }
+  }
+  const active = new Set(applyDispositions(current, cwd, target.filePath, source));
+  const normalized = current.flatMap((diagnostic) => {
+    const { strict, weak } = anchorsForDiagnostic(cwd, target.filePath, diagnostic, source);
+    const entry = getDisposition(cwd, strict) ?? getDisposition(cwd, weak);
+    if (!active.has(diagnostic) && (entry?.disposition === "false-positive" || entry?.disposition === "suppress")) {
+      const { anchorSpan: _previousSpan, ...base } = diagnostic;
+      const span = entry.disposition === "false-positive" ? strictAnchorSpan(source, diagnostic.line) : undefined;
+      return [
+        {
+          ...base,
+          disposition: entry.disposition,
+          flagged: false,
+          ...span === undefined ? {} : { anchorSpan: span }
+        }
+      ];
+    }
+    if (diagnostic.suppressedRetained)
+      return [];
+    const {
+      disposition: _disposition,
+      flagged: _flagged,
+      anchorSpan: _anchorSpan,
+      ...baseDiagnostic
+    } = diagnostic;
+    return entry?.disposition === "flagged" ? [{ ...baseDiagnostic, flagged: true }] : [baseDiagnostic];
+  });
+  const rec = getOrCreate(target.filePath);
+  const writeIndex = admitWidgetDiagnosticsWrite(target.filePath);
+  if (!diagnosticsWriteGuard.shouldWrite(fileMapKey(target.filePath), writeIndex))
+    return;
+  commitDiagnostics(rec, target.filePath, normalized, Date.now(), fileMapKey(target.filePath), false);
+}
+export function admitWidgetDiagnosticsWrite(filePath, writeIndex) {
+  const key = fileMapKey(filePath);
+  const token = writeIndex ?? diagnosticsWriteGuard.nextToken(key);
+  diagnosticsWriteGuard.shouldWrite(key, token);
+  runnerWriteGuard.shouldWrite(key, token);
+  return token;
+}
+registerWidgetDispositionReconciler((cwd, target, disposition) => reconcileWidgetDisposition(cwd, target, disposition, target.content));
+export function wireWidgetDispositionSubscriber(args) {
+  args.events?.on?.("dmlens:diagnostic:disposition", (data) => {
+    if (!data || typeof data !== "object")
+      return;
+    const payload = data;
+    if (payload.source !== "dm-lens" || typeof payload.cwd !== "string")
+      return;
+    if (typeof payload.filePath !== "string" || typeof payload.disposition !== "string")
+      return;
+    if (typeof payload.message !== "string")
+      return;
+    if (!["false-positive", "suppress", "defer", "flagged"].includes(payload.disposition))
+      return;
+    reconcileWidgetDisposition(payload.cwd, {
+      cwd: payload.cwd,
+      filePath: payload.filePath,
+      message: typeof payload.message === "string" ? payload.message : "",
+      ...typeof payload.tool === "string" ? { tool: payload.tool } : {},
+      ...typeof payload.rule === "string" ? { rule: payload.rule } : {},
+      ...typeof payload.line === "number" ? { line: payload.line } : {}
+    }, payload.disposition);
+  });
+}
+const renderedDependencyDriftFiles = new Set;
+export function clearWidgetState() {
+  files.clear();
+  renderedDependencyDriftFiles.clear();
+  lspServers.clear();
+  sessionLanguages = [];
+  requestRenderFn = null;
+  diagnosticsWriteGuard.clear();
+  runnerWriteGuard.clear();
+  nextInactivePruneSize = MAX_INACTIVE_FILE_RECORDS + 1;
+}
+export const WIDGET_STATE_VERSION = 3;
+export function exportWidgetState() {
+  return {
+    version: WIDGET_STATE_VERSION,
+    sessionLanguages: [...sessionLanguages],
+    files: [...files.values()].map((rec) => ({
+      filePath: rec.filePath,
+      runners: [...rec.runners.entries()],
+      formatters: [...rec.formatters.entries()],
+      diagnostics: rec.diagnostics,
+      allDiagnostics: rec.allDiagnostics,
+      diagnosticCounts: rec.diagnosticCounts,
+      hasFinalDiagnosticsSnapshot: rec.hasFinalDiagnosticsSnapshot,
+      touchedAt: rec.touchedAt
+    }))
+  };
+}
+function migrateEntryStamps(entries, recordTouchedAt) {
+  return (entries ?? []).map((d) => {
+    const { stale: _stale, staleDeliveryCount: _staleDeliveryCount, footerRetired: _footerRetired, staleReason: _staleReason, ...rest } = d;
+    return rest.observedAt == null ? { ...rest, observedAt: recordTouchedAt } : rest;
+  });
+}
+export function importWidgetState(state) {
+  if (!state || typeof state.version !== "number" || state.version < 1 || state.version > WIDGET_STATE_VERSION) {
+    return false;
+  }
+  files.clear();
+  diagnosticsWriteGuard.clear();
+  runnerWriteGuard.clear();
+  for (const f of state.files ?? []) {
+    const recordTouchedAt = f.touchedAt ?? Date.now();
+    const migratedAllDiagnostics = migrateEntryStamps(f.allDiagnostics, recordTouchedAt);
+    files.set(fileMapKey(f.filePath), {
+      filePath: f.filePath,
+      runners: new Map(f.runners ?? []),
+      formatters: new Map((f.formatters ?? []).filter(([, outcome]) => outcome?.success !== false)),
+      diagnostics: migrateEntryStamps(f.diagnostics, recordTouchedAt),
+      allDiagnostics: migratedAllDiagnostics,
+      diagnosticCounts: countDiagnostics(migratedAllDiagnostics),
+      hasFinalDiagnosticsSnapshot: f.hasFinalDiagnosticsSnapshot ?? false,
+      touchedAt: recordTouchedAt
+    });
+  }
+  pruneInactiveFileRecords();
+  sessionLanguages = state.sessionLanguages ?? [];
+  requestRenderFn?.();
+  return true;
+}
+export function setSessionLanguages(langs) {
+  sessionLanguages = langs;
+  requestRender();
+}
+export function getSessionLanguages() {
+  return [...sessionLanguages];
+}
+export function getFailedLspServerIds() {
+  const ids = [];
+  const seen = new Set;
+  for (const rec of lspServers.values()) {
+    if (rec.status !== "failed" || seen.has(rec.serverId))
+      continue;
+    seen.add(rec.serverId);
+    ids.push(rec.serverId);
+  }
+  return ids;
+}
+export function recordFormatter(filePath, formatter, changed, success, outcome) {
+  const rec = getOrCreate(filePath);
+  rec.formatters.set(formatter, { changed, success, outcome });
+  rec.touchedAt = Date.now();
+  files.set(fileMapKey(filePath), rec);
+  requestRender();
+}
+export function recordRunner(filePath, runnerId, status, diagnosticCount, durationMs, writeIndex) {
+  const key = fileMapKey(filePath);
+  if (!runnerWriteGuard.shouldWrite(key, writeIndex))
+    return;
+  diagnosticsWriteGuard.shouldWrite(key, writeIndex);
+  const rec = getOrCreate(filePath);
+  rec.runners.set(runnerId, { status, count: diagnosticCount, durationMs });
+  rec.hasFinalDiagnosticsSnapshot = false;
+  rec.touchedAt = Date.now();
+  files.set(fileMapKey(filePath), rec);
+  requestRender();
+}
+function toSingleLineMessage(message) {
+  return (message ?? "").replace(/\s+/g, " ").trim();
+}
+export function widgetDiagnosticUri(filePath, line, column) {
+  const base = pathToFileURL(filePath).href;
+  return line != null ? `${base}#L${line}${column != null ? `:${column}` : ""}` : base;
+}
+export function recordDiagnostics(filePath, diagnostics, writeIndex, observedAt) {
+  const key = fileMapKey(filePath);
+  if (!diagnosticsWriteGuard.shouldWrite(key, writeIndex))
+    return false;
+  runnerWriteGuard.shouldWrite(key, writeIndex);
+  const observedTs = observedAt ?? Date.now();
+  const rec = getOrCreate(filePath, key);
+  commitDiagnostics(rec, filePath, normalizeDiagnostics(filePath, diagnostics, observedTs), observedTs, key);
+  return true;
+}
+function normalizeDiagnostics(filePath, diagnostics, observedTs) {
+  return diagnostics.map((d) => {
+    const rule = d.rule ?? d.id;
+    return {
+      severity: d.severity ?? "info",
+      semantic: d.semantic,
+      message: toSingleLineMessage(d.message),
+      line: d.line,
+      col: d.column,
+      rule,
+      tool: d.tool,
+      uri: widgetDiagnosticUri(filePath, d.line, d.column),
+      observedAt: observedTs
+    };
+  });
+}
+function retentionIdentity(d) {
+  return JSON.stringify([
+    d.tool ?? "",
+    d.rule ?? "",
+    normalizeMessage(d.message)
+  ]);
+}
+function readContentOrUndefined(filePath) {
+  try {
+    return readFileSync(filePath, "utf8");
+  } catch {
+    recordDegradationOnce({
+      kind: "widget-mark-anchor-unreadable",
+      subject: filePath,
+      reason: "the marked file could not be read, so its suppressed rows fall back to the file-mtime retirement gate and the footer chip may under-count it"
+    });
+    return;
+  }
+}
+function readAnchorSpans(filePath) {
+  const content = readContentOrUndefined(filePath);
+  return content === undefined ? undefined : strictAnchorSpansIn(content);
+}
+function retainSuppressedRows(previous, incoming, filePath) {
+  const tagged = previous.filter((d) => d.disposition !== undefined);
+  if (tagged.length === 0)
+    return incoming;
+  const reported = new Map;
+  for (const d of incoming) {
+    const id = retentionIdentity(d);
+    const bucket = reported.get(id);
+    if (bucket)
+      bucket.push(d);
+    else
+      reported.set(id, [d]);
+  }
+  const content = tagged.some((d) => d.anchorSpan !== undefined && reported.has(retentionIdentity(d))) ? readContentOrUndefined(filePath) : undefined;
+  const spans = content === undefined ? undefined : strictAnchorSpansIn(content);
+  const retained = tagged.filter((d) => {
+    const collisions = reported.get(retentionIdentity(d));
+    if (collisions === undefined)
+      return true;
+    if (d.anchorSpan === undefined || spans === undefined)
+      return false;
+    if (!spans.has(d.anchorSpan))
+      return false;
+    return !collisions.some((i) => strictAnchorSpan(content, i.line) === d.anchorSpan);
+  });
+  if (retained.length > MAX_RETAINED_SUPPRESSED_PER_FILE) {
+    retained.sort((a, b) => (b.observedAt ?? 0) - (a.observedAt ?? 0));
+    recordDegradationOnce({
+      kind: "widget-suppressed-retention-capped",
+      subject: filePath,
+      reason: `${retained.length - MAX_RETAINED_SUPPRESSED_PER_FILE} suppressed row(s) beyond the ${MAX_RETAINED_SUPPRESSED_PER_FILE}-row per-file retention cap are no longer counted by the footer chip`
+    });
+    retained.length = MAX_RETAINED_SUPPRESSED_PER_FILE;
+  }
+  return [
+    ...incoming,
+    ...retained.map((d) => d.suppressedRetained ? d : { ...d, suppressedRetained: true })
+  ];
+}
+function commitDiagnostics(rec, filePath, incoming, observedAt, key = fileMapKey(filePath), retainSuppressed = true) {
+  const normalized = retainSuppressed ? retainSuppressedRows(rec.allDiagnostics, incoming, filePath) : incoming;
+  rec.diagnosticCounts = countDiagnostics(normalized);
+  rec.diagnostics = capStoredDiagnostics(normalized);
+  rec.allDiagnostics = normalized;
+  rec.hasFinalDiagnosticsSnapshot = true;
+  rec.touchedAt = freshestObservation(normalized, observedAt ?? Date.now());
+  files.set(key, rec);
+  requestRender();
+}
+export function classifyDiagnosticTier(d) {
+  if (d.severity === "error")
+    return "error";
+  if (d.severity === "warning")
+    return "warning";
+  if (d.severity === "hint" || d.severity === "info")
+    return "advisory";
+  return;
+}
+function countDiagnostics(diags) {
+  let blocking = 0;
+  let errors = 0;
+  let warnings = 0;
+  for (const diagnostic of diags) {
+    if (diagnostic.disposition)
+      continue;
+    if (isBlocking(diagnostic))
+      blocking++;
+    if (diagnostic.stale && (diagnostic.staleReason ?? "past-eof") === "past-eof")
+      continue;
+    const tier = classifyDiagnosticTier(diagnostic);
+    if (tier === "error")
+      errors++;
+    else if (tier === "warning")
+      warnings++;
+  }
+  return { blocking, errors, warnings };
+}
+function countAdvisories(diags) {
+  let advisories = 0;
+  for (const diagnostic of diags) {
+    if (diagnostic.stale && (diagnostic.staleReason ?? "past-eof") === "past-eof")
+      continue;
+    if (classifyDiagnosticTier(diagnostic) === "advisory")
+      advisories++;
+  }
+  return advisories;
+}
+function applyPastEofGate(rec, lineCountCache) {
+  if (rec.allDiagnostics.length === 0)
+    return;
+  const { diagnostics } = demotePastEofDiagnostics({
+    store: "widget-state",
+    cwd: process.cwd(),
+    filePath: rec.filePath,
+    diagnostics: rec.allDiagnostics,
+    lineCountCache
+  });
+  rec.allDiagnostics = diagnostics;
+  rec.diagnostics = capStoredDiagnostics(diagnostics);
+  rec.diagnosticCounts = countDiagnostics(diagnostics);
+}
+function freshestObservation(diags, fallback) {
+  let newest;
+  for (const d of diags) {
+    if (d.observedAt != null && (newest === undefined || d.observedAt > newest)) {
+      newest = d.observedAt;
+    }
+  }
+  return newest ?? fallback;
+}
+function isLspErrorEntry(d) {
+  return d.tool === "lsp" && (d.semantic === "blocking" || d.severity === "error");
+}
+export function reconcileCascadeNeighborLspErrors(filePath, lspErrorDiagnostics, writeIndex, observedAt) {
+  const key = fileMapKey(filePath);
+  if (!diagnosticsWriteGuard.shouldWrite(key, writeIndex))
+    return;
+  runnerWriteGuard.shouldWrite(key, writeIndex);
+  const observedTs = observedAt ?? Date.now();
+  const rec = getOrCreate(filePath);
+  const incoming = normalizeDiagnostics(filePath, lspErrorDiagnostics, observedTs);
+  const preserved = rec.allDiagnostics.filter((d) => !isLspErrorEntry(d));
+  commitDiagnostics(rec, filePath, [...incoming, ...preserved], observedTs);
+}
+export function reconcileScanDiagnostics(filePath, diagnostics, confirmed, writeIndex, observedAt) {
+  if (!confirmed)
+    return false;
+  return recordDiagnostics(filePath, diagnostics, writeIndex, observedAt);
+}
+export function reconcileCorrelatedScanDiagnostics(filePath, diagnostics, writeIndex, observedAt) {
+  const key = fileMapKey(filePath);
+  if (!diagnosticsWriteGuard.shouldWrite(key, writeIndex))
+    return;
+  runnerWriteGuard.shouldWrite(key, writeIndex);
+  const observedTs = observedAt ?? Date.now();
+  const correlated = diagnostics.map((diagnostic) => ({
+    ...diagnostic,
+    observedAt: diagnostic.observedAt ?? observedTs
+  }));
+  commitDiagnostics(getOrCreate(filePath, key), filePath, correlated, observedTs, key);
+}
+export async function reconcileStaleWidgetFiles() {
+  const entries = [...files.entries()];
+  const verdicts = await Promise.all(entries.map(async ([mapKey, rec]) => {
+    let mtimeMs;
+    try {
+      mtimeMs = (await stat(rec.filePath)).mtimeMs;
+    } catch {
+      return { mapKey, action: "drop" };
+    }
+    if (rec.allDiagnostics.length === 0) {
+      return freshnessFromMtime({ mtimeMs, referenceMs: rec.touchedAt }).verdict === "stale" ? { mapKey, action: "drop" } : { mapKey, action: "keep" };
+    }
+    const mtimeStale = (d) => freshnessFromMtime({
+      mtimeMs,
+      referenceMs: d.observedAt ?? rec.touchedAt
+    }).verdict === "stale";
+    const spans = rec.allDiagnostics.some((d) => d.anchorSpan !== undefined && mtimeStale(d)) ? readAnchorSpans(rec.filePath) : undefined;
+    const survivors = rec.allDiagnostics.filter((d) => d.anchorSpan !== undefined && spans !== undefined ? spans.has(d.anchorSpan) : !mtimeStale(d));
+    if (survivors.length === rec.allDiagnostics.length) {
+      return { mapKey, action: "keep" };
+    }
+    if (survivors.length === 0) {
+      return { mapKey, action: "drop" };
+    }
+    return { mapKey, action: "prune", survivors };
+  }));
+  let dropped = 0;
+  for (const v of verdicts) {
+    if (v.action === "keep")
+      continue;
+    if (v.action === "drop") {
+      files.delete(v.mapKey);
+      dropped += 1;
+      continue;
+    }
+    const rec = files.get(v.mapKey);
+    if (rec) {
+      rec.allDiagnostics = v.survivors;
+      rec.diagnostics = capStoredDiagnostics(v.survivors);
+      rec.diagnosticCounts = countDiagnostics(v.survivors);
+    }
+    dropped += 1;
+  }
+  if (dropped > 0)
+    requestRenderFn?.();
+  return dropped;
+}
+export async function reconcileStaleWidgetDependencyBlockers(cwd, turnIndex) {
+  let demoted = 0;
+  let truncatedImports = 0;
+  for (const [, rec] of files.entries()) {
+    if (!rec.allDiagnostics.some((d) => isBlocking(d) && d.tool === "lsp"))
+      continue;
+    let importMtimes = [];
+    try {
+      const result = await collectForwardImportMtimes(cwd, rec.filePath, undefined, turnIndex);
+      importMtimes = result.mtimes;
+      if (result.truncated)
+        truncatedImports += 1;
+    } catch {
+      importMtimes = [];
+    }
+    if (importMtimes.length === 0)
+      continue;
+    let changed = false;
+    for (const d of rec.allDiagnostics) {
+      if (!isBlocking(d) || d.tool !== "lsp")
+        continue;
+      const baseline = d.observedAt ?? rec.touchedAt;
+      if (importMtimes.some((im) => freshnessFromMtime({
+        mtimeMs: im.mtimeMs,
+        referenceMs: baseline
+      }).verdict === "stale")) {
+        d.stale = true;
+        d.staleReason = "dependency-drift";
+        changed = true;
+        demoted += 1;
+      }
+    }
+    if (changed) {
+      rec.diagnosticCounts = countDiagnostics(rec.allDiagnostics);
+      rec.diagnostics = capStoredDiagnostics(rec.allDiagnostics);
+    }
+  }
+  if (demoted > 0)
+    requestRenderFn?.();
+  return { demoted, truncatedImports };
+}
+export function getWidgetBlockingFilesForSweep() {
+  const out = [];
+  for (const rec of files.values()) {
+    let earliest;
+    for (const d of rec.allDiagnostics) {
+      if (!isBlocking(d) || d.tool !== "lsp")
+        continue;
+      const observedAt = d.observedAt ?? rec.touchedAt;
+      if (earliest === undefined || observedAt < earliest)
+        earliest = observedAt;
+    }
+    if (earliest !== undefined)
+      out.push({ filePath: rec.filePath, recordedAtMs: earliest });
+  }
+  return out;
+}
+export function markWidgetFileBlockersStale(filePath, reason) {
+  const rec = files.get(fileMapKey(filePath));
+  if (!rec)
+    return false;
+  let changed = false;
+  for (const d of rec.allDiagnostics) {
+    if (!isBlocking(d) || d.tool !== "lsp")
+      continue;
+    d.stale = true;
+    d.staleReason = reason;
+    changed = true;
+  }
+  if (changed) {
+    rec.diagnosticCounts = countDiagnostics(rec.allDiagnostics);
+    rec.diagnostics = capStoredDiagnostics(rec.allDiagnostics);
+    requestRenderFn?.();
+  }
+  return changed;
+}
+function isDependencyDriftDemoted(d) {
+  return d.stale === true && d.staleReason === "dependency-drift" && d.footerRetired !== true;
+}
+export function drainRenderedDependencyDriftFilePaths() {
+  const out = [...renderedDependencyDriftFiles];
+  renderedDependencyDriftFiles.clear();
+  return out;
+}
+export function incrementWidgetDependencyDriftDelivery(filePath) {
+  const rec = files.get(fileMapKey(filePath));
+  if (!rec)
+    return 0;
+  let next = 0;
+  for (const d of rec.allDiagnostics) {
+    if (isDependencyDriftDemoted(d)) {
+      next = (d.staleDeliveryCount ?? 0) + 1;
+      d.staleDeliveryCount = next;
+    }
+  }
+  return next;
+}
+export function retireWidgetDependencyDriftBlockers(filePath) {
+  const rec = files.get(fileMapKey(filePath));
+  if (!rec)
+    return false;
+  let changed = false;
+  for (const d of rec.allDiagnostics) {
+    if (isDependencyDriftDemoted(d)) {
+      d.footerRetired = true;
+      changed = true;
+    }
+  }
+  if (!changed)
+    return false;
+  renderedDependencyDriftFiles.delete(rec.filePath);
+  requestRenderFn?.();
+  return true;
+}
+let staleReconcileTimer = null;
+export const STALE_RECONCILE_DEBOUNCE_MS = 1500;
+export function scheduleStaleReconcile() {
+  if (staleReconcileTimer !== null)
+    return;
+  staleReconcileTimer = setTimeout(() => {
+    staleReconcileTimer = null;
+    reconcileStaleWidgetFiles().catch(() => {});
+  }, STALE_RECONCILE_DEBOUNCE_MS);
+  staleReconcileTimer?.unref?.();
+}
+export function getFileDiagnosticSummaries() {
+  return [...files.values()].map((rec) => {
+    applyPastEofGate(rec);
+    const live = rec.allDiagnostics.filter((d) => d.disposition === undefined);
+    return {
+      filePath: rec.filePath,
+      blocking: rec.diagnosticCounts.blocking,
+      errors: rec.diagnosticCounts.errors,
+      warnings: rec.diagnosticCounts.warnings,
+      advisories: countAdvisories(live),
+      hasFinalSnapshot: rec.hasFinalDiagnosticsSnapshot,
+      diagnostics: live.map((d) => ({ ...d }))
+    };
+  });
+}
+export function countRetainedSuppressedRows(filePath) {
+  const rec = files.get(fileMapKey(filePath));
+  if (!rec)
+    return 0;
+  let n = 0;
+  for (const d of rec.allDiagnostics)
+    if (d.suppressedRetained)
+      n += 1;
+  return n;
+}
+export function getFileDiagnostics(filePath) {
+  const rec = files.get(fileMapKey(filePath));
+  if (!rec)
+    return;
+  applyPastEofGate(rec);
+  return rec.allDiagnostics.map((d) => ({ ...d }));
+}
+export const __testing = {
+  getWidgetStateSnapshot() {
+    return {
+      files: [...files.values()].map((rec) => ({
+        filePath: rec.filePath,
+        storedDiagnostics: rec.diagnostics.length,
+        blocking: rec.diagnosticCounts.blocking,
+        errors: rec.diagnosticCounts.errors,
+        warnings: rec.diagnosticCounts.warnings
+      }))
+    };
+  }
+};
+export function recordLsp(serverId, root, status, durationMs) {
+  const normalizedRoot = normalizeMapKey(root);
+  const key = `${serverId}@${normalizedRoot}`;
+  const mapped = status === "spawn_start" ? "spawning" : status === "spawn_success" ? "ready" : "failed";
+  lspServers.set(key, { serverId, root, status: mapped, durationMs });
+  requestRender();
+}
+const HORIZONTAL_MIN_WIDTH = 70;
+export function renderWidget(width, theme) {
+  const dim = (s) => theme.fg("dim", s);
+  const red = (s) => theme.fg("error", s);
+  const yellow = (s) => theme.fg("warning", s);
+  const green = (s) => theme.fg("success", s);
+  const cyan = (s) => theme.fg("accent", s);
+  const w = Math.max(1, width || 80);
+  const useHorizontal = w >= HORIZONTAL_MIN_WIDTH;
+  if (files.size === 0 && lspServers.size === 0)
+    return [];
+  const lines = [];
+  const deduped = dedupeByBasename([...files.values()]);
+  const recencySorted = deduped.filter(shouldRenderFile).slice(0, 5);
+  const langStr = sessionLanguages.slice(0, 6).join(" ");
+  const totalBlocking = countBlockingIn(deduped);
+  const totalErrors = countTotalIn("error", deduped);
+  const totalWarnings = countTotalIn("warning", deduped);
+  const totalSuppressed = countSuppressedIn(deduped);
+  const hasPendingAnalysis = deduped.some(isPendingAnalysis);
+  const errorChunk = totalErrors > 0 ? (totalBlocking > 0 ? red : yellow)(`●${totalErrors}E`) : "";
+  const warningChunk = totalWarnings > 0 ? yellow(`!${totalWarnings}W`) : "";
+  const summary = errorChunk ? errorChunk + (warningChunk ? " " + warningChunk : "") : warningChunk ? warningChunk : files.size > 0 && !hasPendingAnalysis ? green("✓ clean") : "";
+  const spawning = [...lspServers.values()].filter((s) => s.status === "spawning");
+  const lspChip = useHorizontal && spawning.length > 0 ? "  " + dim("LSP↑") : "";
+  const header = ` ${cyan("dm-lens")}${langStr ? "  " + dim(langStr) : ""}${lspChip}${summary ? "  " + summary : ""}`;
+  lines.push(fitLine(header, w));
+  if (totalSuppressed > 0) {
+    lines.push(fitLine(` ${dim(`suppressed: ${totalSuppressed}`)}`, w));
+  }
+  if (useHorizontal) {
+    const displayOrder = sortByTierThenRecency(recencySorted);
+    const rowLine = packHorizontalRow(displayOrder, w, theme);
+    if (rowLine.length > 0)
+      lines.push(rowLine);
+  } else {
+    for (const rec of recencySorted) {
+      lines.push(fitLine(formatFileRowVertical(rec, theme), w));
+    }
+  }
+  const isBlockingOrDemoted = (d) => (isBlocking(d) || d.stale === true) && d.footerRetired !== true;
+  const withBlocking = recencySorted.filter((r) => r.diagnostics.some(isBlockingOrDemoted));
+  if (withBlocking.length > 0) {
+    const rec = withBlocking[0];
+    applyPastEofGate(rec);
+    if (!useHorizontal) {
+      lines.push(fitLine(dim("─".repeat(Math.min(w, 60))), w));
+      lines.push(fitLine(` ${dim(path.basename(rec.filePath))}`, w));
+    }
+    const blockers = rec.diagnostics.filter(isBlockingOrDemoted).slice(0, 5);
+    if (blockers.some(isDependencyDriftDemoted)) {
+      renderedDependencyDriftFiles.add(rec.filePath);
+    }
+    for (const d of blockers) {
+      const pastEof = d.stale && (d.staleReason ?? "past-eof") === "past-eof";
+      const loc = pastEof ? PAST_EOF_STALE_MARKER : d.line != null ? osc8(d.uri ?? "", `L${d.line}`) : "";
+      const rule = d.rule ? dim(` ${d.rule}`) : "";
+      const staleTag = d.stale ? dim(` ${STALE_LINE_MARKER}`) : "";
+      const prefix = `   ${d.stale ? dim("○") : red("●")} ${loc}${rule}  `;
+      const msgWidth = Math.max(1, w - visibleWidth(prefix) - visibleWidth(staleTag));
+      const msg = fitLine(d.message, msgWidth, "…");
+      lines.push(fitLine(`${prefix}${msg}${staleTag}`, w));
+    }
+  }
+  if (!useHorizontal && spawning.length > 0) {
+    const ids = spawning.map((s) => s.serverId).join(" ");
+    lines.push(fitLine(` ${dim(`LSP spawning: ${ids}`)}`, w));
+  }
+  return lines;
+}
+function classifyFileTier(rec) {
+  if (rec.diagnosticCounts.blocking > 0)
+    return "blocking";
+  if (rec.diagnosticCounts.errors > 0 || rec.diagnosticCounts.warnings > 0) {
+    return "warning";
+  }
+  return "clean";
+}
+function sortByTierThenRecency(recs) {
+  const order = {
+    blocking: 0,
+    warning: 1,
+    clean: 2
+  };
+  return [...recs].sort((a, b) => {
+    const ta = order[classifyFileTier(a)];
+    const tb = order[classifyFileTier(b)];
+    if (ta !== tb)
+      return ta - tb;
+    return b.touchedAt - a.touchedAt;
+  });
+}
+function formatFileRowVertical(rec, theme) {
+  const dim = (s) => theme.fg("dim", s);
+  const red = (s) => theme.fg("error", s);
+  const yellow = (s) => theme.fg("warning", s);
+  const green = (s) => theme.fg("success", s);
+  const base = path.basename(rec.filePath);
+  const blocking = rec.diagnosticCounts.blocking;
+  const errors = rec.diagnosticCounts.errors;
+  const warnings = rec.diagnosticCounts.warnings;
+  const formatterFailed = hasFailedFormatter(rec);
+  const dot = blocking > 0 ? red("●") : formatterFailed ? red("x") : warnings > 0 || errors > 0 ? yellow("!") : green("✓");
+  const runnerNames = [...rec.runners.entries()].filter(([, r]) => r.status !== "skipped").map(([id]) => id).join(" ");
+  const counts = errors > 0 ? " " + (blocking > 0 ? red : yellow)(`${errors}E`) + (warnings > 0 ? " " + yellow(`${warnings}W`) : "") : warnings > 0 ? " " + yellow(`${warnings}W`) : " " + dim("clean");
+  const changedFormatters = [...rec.formatters.entries()].filter(([, f]) => f.changed && f.success).map(([name]) => name);
+  const failedFormatters = [...rec.formatters.entries()].filter(([, f]) => !f.success && f.outcome !== "unavailable").map(([name]) => name);
+  const formatMark = (failedFormatters.length > 0 ? red(` fmt-failed:${failedFormatters.join(",")}`) : "") + (changedFormatters.length > 0 ? dim(` fmt:${changedFormatters.join(",")}`) : "");
+  return ` ${dot} ${base}  ${dim(runnerNames)}${formatMark}${counts}`;
+}
+function packHorizontalRow(recs, totalWidth, theme) {
+  if (recs.length === 0)
+    return "";
+  const dim = (s) => theme.fg("dim", s);
+  const indent = "   ";
+  const sep = "  ";
+  const overflowReserve = 4;
+  let used = visibleWidth(indent);
+  const parts = [indent];
+  const addedTokenWidths = [];
+  let droppedAt = -1;
+  for (let i = 0;i < recs.length; i++) {
+    const sepWidth = parts.length > 1 ? visibleWidth(sep) : 0;
+    const willOverflow = i < recs.length - 1;
+    const reserve = willOverflow ? overflowReserve : 0;
+    const remaining = totalWidth - used - sepWidth - reserve;
+    if (remaining < 4) {
+      droppedAt = i;
+      break;
+    }
+    const token = formatFileTokenHorizontal(recs[i], remaining, theme);
+    const tokenWidth = visibleWidth(token);
+    if (token.length === 0 || used + sepWidth + tokenWidth > totalWidth) {
+      droppedAt = i;
+      break;
+    }
+    if (sepWidth > 0) {
+      parts.push(sep);
+      used += sepWidth;
+    }
+    parts.push(token);
+    used += tokenWidth;
+    addedTokenWidths.push(tokenWidth + sepWidth);
+  }
+  if (droppedAt >= 0) {
+    let dropped = recs.length - droppedAt;
+    let overflow = " " + dim(`+${dropped}`);
+    while (used + visibleWidth(overflow) > totalWidth && addedTokenWidths.length > 0) {
+      const lastWidth = addedTokenWidths.pop();
+      used -= lastWidth;
+      parts.pop();
+      if (parts.length > 1)
+        parts.pop();
+      dropped++;
+      overflow = " " + dim(`+${dropped}`);
+    }
+    if (used + visibleWidth(overflow) <= totalWidth) {
+      parts.push(overflow);
+    }
+  }
+  return fitLine(parts.join(""), totalWidth);
+}
+function formatFileTokenHorizontal(rec, remainingWidth, theme) {
+  const dim = (s) => theme.fg("dim", s);
+  const red = (s) => theme.fg("error", s);
+  const yellow = (s) => theme.fg("warning", s);
+  const blocking = rec.diagnosticCounts.blocking;
+  const errors = rec.diagnosticCounts.errors;
+  const warnings = rec.diagnosticCounts.warnings;
+  const formatterChanged = hasChangedFormatter(rec);
+  const formatterFailed = hasFailedFormatter(rec);
+  let dotChar;
+  if (blocking > 0)
+    dotChar = red("●");
+  else if (errors > 0 || warnings > 0)
+    dotChar = yellow("!");
+  else if (formatterChanged)
+    dotChar = dim("✎");
+  else
+    dotChar = dim("·");
+  if (formatterFailed && blocking === 0 && errors === 0 && warnings === 0) {
+    dotChar = red("x");
+  }
+  let countsStyled = "";
+  if (errors > 0 && warnings > 0) {
+    const eColor = blocking > 0 ? red : yellow;
+    countsStyled = " " + eColor(`${errors}E`) + yellow(`${warnings}W`);
+  } else if (errors > 0) {
+    const eColor = blocking > 0 ? red : yellow;
+    countsStyled = " " + eColor(`${errors}E`);
+  } else if (warnings > 0) {
+    countsStyled = " " + yellow(`${warnings}W`);
+  }
+  const fullBasename = path.basename(rec.filePath);
+  const fixedWidth = visibleWidth(dotChar) + 1 + visibleWidth(countsStyled);
+  const basenameBudget = remainingWidth - fixedWidth;
+  if (basenameBudget < 3)
+    return "";
+  const truncated = truncateBasename(fullBasename, basenameBudget);
+  const linked = osc8(pathToFileURL(rec.filePath).href, truncated);
+  return `${dotChar} ${linked}${countsStyled}`;
+}
+function truncateBasename(name, maxWidth) {
+  if (visibleWidth(name) <= maxWidth)
+    return name;
+  if (maxWidth < 2)
+    return "…";
+  const ext = path.extname(name);
+  const stem = name.slice(0, name.length - ext.length);
+  const keep = maxWidth - ext.length - 1;
+  if (keep < 1) {
+    return name.slice(0, maxWidth - 1) + "…";
+  }
+  return stem.slice(0, keep) + "…" + ext;
+}
+function getOrCreate(filePath, key = fileMapKey(filePath)) {
+  maybePruneInactiveFileRecords();
+  return files.get(key) ?? {
+    filePath,
+    runners: new Map,
+    formatters: new Map,
+    diagnostics: [],
+    allDiagnostics: [],
+    diagnosticCounts: { blocking: 0, errors: 0, warnings: 0 },
+    hasFinalDiagnosticsSnapshot: false,
+    touchedAt: Date.now()
+  };
+}
+function hasChangedFormatter(rec) {
+  return [...rec.formatters.values()].some((f) => f.changed && f.success);
+}
+function hasFailedFormatter(rec) {
+  return [...rec.formatters.values()].some((f) => !f.success && f.outcome !== "unavailable");
+}
+function shouldRenderFile(rec) {
+  return rec.hasFinalDiagnosticsSnapshot || hasChangedFormatter(rec) || hasFailedFormatter(rec);
+}
+function hasLiveDiagnostic(rec) {
+  return rec.hasFinalDiagnosticsSnapshot && rec.diagnostics.length > 0;
+}
+function isPendingAnalysis(rec) {
+  return rec.runners.size > 0 && !rec.hasFinalDiagnosticsSnapshot;
+}
+function capStoredDiagnostics(diagnostics) {
+  if (diagnostics.length <= MAX_STORED_DIAGNOSTICS_PER_FILE)
+    return diagnostics;
+  const blockers = diagnostics.filter(isBlocking);
+  if (blockers.length >= MAX_STORED_DIAGNOSTICS_PER_FILE) {
+    return blockers.slice(0, MAX_STORED_DIAGNOSTICS_PER_FILE);
+  }
+  const rest = diagnostics.filter((d) => !isBlocking(d));
+  return [
+    ...blockers,
+    ...rest.slice(0, MAX_STORED_DIAGNOSTICS_PER_FILE - blockers.length)
+  ];
+}
+function countTotalIn(severity, recs) {
+  let n = 0;
+  for (const rec of recs) {
+    if (severity === "error")
+      n += rec.diagnosticCounts.errors;
+    else
+      n += rec.diagnosticCounts.warnings;
+  }
+  return n;
+}
+function countSuppressedIn(recs) {
+  let n = 0;
+  for (const rec of recs) {
+    for (const diagnostic of rec.allDiagnostics) {
+      if (diagnostic.disposition)
+        n++;
+    }
+  }
+  return n;
+}
+function countBlockingIn(recs) {
+  let n = 0;
+  for (const rec of recs)
+    n += rec.diagnosticCounts.blocking;
+  return n;
+}
+function requestRender() {
+  requestRenderFn?.();
+}
+function osc8(uri, label) {
+  if (!uri)
+    return label;
+  return `\x1B]8;;${uri}\x1B\\${label}\x1B]8;;\x1B\\`;
+}
+function dedupeByBasename(recs) {
+  const seen = new Map;
+  for (const r of [...recs].sort((a, b) => a.touchedAt - b.touchedAt)) {
+    seen.set(path.basename(r.filePath), r);
+  }
+  return [...seen.values()].sort((a, b) => b.touchedAt - a.touchedAt);
+}