@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

package/extensions/dm-lens/clients/dispatch/dispatcher.js

@@ -47,11 +47,27 @@ import {
   observeRunnerLatency
 } from "./collect-later-tier.js";
 import { deferRunnerFindings } from "./pending-runner-findings.js";
-import { applyRulePolicy, rulePolicyMapFromConfig } from "./rule-policy.js";
+import {
+  ADOPTED_ROOT_RUNNER_ALLOWLIST,
+  filterGroupsForAdoptedRoot
+} from "./adopted-root-runners.js";
+import {
+  applyRulePolicy,
+  resolvedRulePolicyMap,
+  rulePolicyMapFromConfig
+} from "./rule-policy.js";
 import { getToolProfile } from "./tool-profile.js";
-import { isRunnerSkipReason } from "./types.js";
+import {
+  hasUsableResult,
+  isRunnerClaimSource,
+  isRunnerSkipReason
+} from "./types.js";
 const dispatcherProbeFlights = createAvailabilityProbeFlight({ generation: () => getDispatchAvailabilityGeneration() });
-import { formatDiagnostics } from "./utils/format-utils.js";
+import {
+  DELTA_UNUSED_PROMOTION_NOTE,
+  formatDiagnostics
+} from "./utils/format-utils.js";
+import { registerRunnerId } from "./known-runner-ids.js";
 
 export class RunnerRegistry {
   runners = new Map;
@@ -59,6 +75,7 @@ export class RunnerRegistry {
     if (this.runners.has(runner.id))
       return;
     this.runners.set(runner.id, runner);
+    registerRunnerId(runner.id);
   }
   get(id) {
     return this.runners.get(id);
@@ -193,7 +210,7 @@ function readFilePrefix(filePath, maxBytes = 4096) {
     }
   }
 }
-export function createDispatchContext(filePath, cwd, pi, facts, blockingOnly, modifiedRanges, projectRoot, writeIndex, telemetryModel, telemetryProvider) {
+export function createDispatchContext(filePath, cwd, pi, facts, blockingOnly, modifiedRanges, projectRoot, writeIndex, telemetryModel, telemetryProvider, sessionGeneration, sessionId, analysisRootMode) {
   const absoluteFilePath = resolveRunnerPath(cwd, filePath);
   const normalizedProjectRoot = normalizeMapKey(path.resolve(projectRoot ?? cwd));
   const normalizedCwd = normalizeMapKey(resolveLanguageRootForFile(absoluteFilePath, cwd));
@@ -207,12 +224,14 @@ export function createDispatchContext(filePath, cwd, pi, facts, blockingOnly, mo
     includeDeclarations: false
   }) : undefined;
   const projectConfig = loadDmLensProjectConfig(normalizedCwd);
+  const rulePolicy = resolvedRulePolicyMap(normalizedProjectRoot);
   return {
     filePath: normalizedFilePath,
     projectRoot: normalizedProjectRoot,
     cwd: normalizedCwd,
     kind,
     fileRole,
+    analysisRootMode,
     generatedEvidence: generatedDetail?.evidence,
     generatedLineShapeMean: generatedDetail?.lineShapeMean,
     pi,
@@ -220,9 +239,12 @@ export function createDispatchContext(filePath, cwd, pi, facts, blockingOnly, mo
     deltaMode: !pi.getFlag("no-delta"),
     facts,
     projectConfig,
+    rulePolicy,
     blockingOnly,
     modifiedRanges,
     writeIndex,
+    sessionGeneration,
+    sessionId,
     telemetryModel,
     telemetryProvider,
     toolCwdMemo: {},
@@ -348,11 +370,12 @@ function promoteDeltaUnusedToBlockers(diagnostics) {
       ...d,
       severity: "error",
       semantic: "blocking",
+      promotionNote: DELTA_UNUSED_PROMOTION_NOTE,
       fixSuggestion: d.fixSuggestion ?? "Remove the unused declaration or rename with '_' prefix if intentionally unused."
     };
   });
 }
-function buildCoverageNotice(ctx, runnerLatencies) {
+function buildCoverageNotice(ctx, runnerLatencies, dedupe) {
   if (!ctx.kind)
     return;
   const lspEnabled = !ctx.pi.getFlag("no-lsp");
@@ -376,9 +399,11 @@ function buildCoverageNotice(ctx, runnerLatencies) {
     const silentServerIds = unconfirmedServerIds.filter((id) => !deferredIds.has(id));
     const dedupeSet = (ids) => [...new Set(ids)].map(normalizeEphemeralMapKey).sort((a, b) => Number(a > b) - Number(a < b)).join(",");
     const onceKey = `${ctx.kind}:${ctx.filePath}:${dedupeSet(silentServerIds)}|${dedupeSet(deferredServerIds)}`;
-    if (coverageNoticeSeen.has(onceKey))
-      return;
-    coverageNoticeSeen.add(onceKey);
+    if (dedupe) {
+      if (coverageNoticeSeen.has(onceKey))
+        return;
+      coverageNoticeSeen.add(onceKey);
+    }
     const coverageParts = [];
     if (deferredServerIds.length > 0) {
       coverageParts.push(`coverage: ${markerFor(deferredServerIds)} deferred — diagnostics are incomplete; findings arrive at turn end if the scan lands.`);
@@ -396,11 +421,11 @@ function buildCoverageNotice(ctx, runnerLatencies) {
       tool: "dm-lens"
     };
   }
-  const primaryHasCoverage = relevant.some((r) => r.status === "succeeded" || r.status === "failed");
+  const primaryHasCoverage = relevant.some(hasUsableResult);
   if (primaryHasCoverage)
     return;
-  const allPrimarySkipped = relevant.every((r) => r.status === "skipped" || r.status === "when_skipped" || r.status === "test_file_skipped");
-  if (!allPrimarySkipped)
+  const primaryStillInFlight = relevant.some((r) => r.status === "pending" || r.status === "deferred");
+  if (primaryStillInFlight)
     return;
   const plan = getToolPlan(ctx.kind);
   const fallbackRunnerIds = new Set((plan?.groups ?? []).filter((group) => !group.runnerIds.every((runnerId) => primary.runnerIds.includes(runnerId))).flatMap((group) => group.runnerIds).filter((runnerId) => !primary.runnerIds.includes(runnerId)));
@@ -411,16 +436,19 @@ function buildCoverageNotice(ctx, runnerLatencies) {
     "fact-rules",
     "opengrep"
   ]);
-  const anyLinterHasCoverage = runnerLatencies.some((r) => fallbackRunnerIds.has(r.runnerId) && !STRUCTURAL_RUNNERS.has(r.runnerId) && (r.status === "succeeded" || r.status === "failed"));
-  if (anyLinterHasCoverage)
+  const TYPE_CAPABLE_FALLBACK_RUNNERS = new Set(["mypy"]);
+  const anyFallbackHasCoverage = runnerLatencies.some((r) => fallbackRunnerIds.has(r.runnerId) && !STRUCTURAL_RUNNERS.has(r.runnerId) && hasUsableResult(r) && (!plan?.capabilities.includes("types") || TYPE_CAPABLE_FALLBACK_RUNNERS.has(r.runnerId)));
+  if (anyFallbackHasCoverage)
     return;
   const onceKey = `${ctx.kind}:${ctx.filePath}`;
-  if (coverageNoticeSeen.has(onceKey))
-    return;
-  coverageNoticeSeen.add(onceKey);
+  if (dedupe) {
+    if (coverageNoticeSeen.has(onceKey))
+      return;
+    coverageNoticeSeen.add(onceKey);
+  }
   return {
     id: `coverage-unavailable:${ctx.kind}:${path.basename(ctx.filePath)}`,
-    message: `DM-lens ${ctx.kind} analysis unavailable — language tools are missing or the LSP server isn't ready yet, so this file was not fully checked (not a clean result).`,
+    message: `DM-lens ${ctx.kind} analysis unavailable — a language tool is missing, timed out, or failed to run, or the LSP server isn't ready yet, so this file was not fully checked (not a clean result).`,
     filePath: ctx.filePath,
     severity: "warning",
     semantic: "warning",
@@ -625,7 +653,11 @@ async function runGroup(ctx, group, registry, onRunnerResult) {
           status: result.status,
           diagnosticCount: result.diagnostics.length,
           semantic: result.semantic ?? semantic,
-          metadata: { tier: "collect-later", delivered: "turn_end" }
+          metadata: {
+            tier: "collect-later",
+            delivered: "turn_end",
+            ...failureRowMetadata(result)
+          }
         });
         return result;
       });
@@ -636,7 +668,9 @@ async function runGroup(ctx, group, registry, onRunnerResult) {
         runnerId: runner.id,
         markedAtMs,
         writeIndex: ctx.writeIndex,
-        promise: deferred
+        promise: deferred,
+        session: ctx.sessionGeneration,
+        sessionId: ctx.sessionId
       });
       latencies.push({
         runnerId: runner.id,
@@ -692,6 +726,7 @@ async function runGroup(ctx, group, registry, onRunnerResult) {
       });
     }
     const skipReason = result.status === "skipped" && isRunnerSkipReason(result.skipReason) ? result.skipReason : undefined;
+    const claimSource = result.status === "skipped" && isRunnerClaimSource(result.claimSource) ? result.claimSource : undefined;
     latencies.push({
       runnerId,
       startTime: runnerStart,
@@ -700,9 +735,15 @@ async function runGroup(ctx, group, registry, onRunnerResult) {
       status: result.status,
       diagnosticCount: result.diagnostics.length,
       semantic: result.semantic ?? semantic,
+      ...result.failureKind !== undefined && {
+        failureKind: result.failureKind
+      },
       ...skipReason !== undefined && {
         skipReason
       },
+      ...claimSource !== undefined && {
+        claimSource
+      },
       ...result.unconfirmedServerIds !== undefined && {
         unconfirmedServerIds: result.unconfirmedServerIds
       },
@@ -725,10 +766,7 @@ async function runGroup(ctx, group, registry, onRunnerResult) {
         line: d.line,
         semantic: d.semantic
       })) : undefined,
-      metadata: result.status === "failed" && result.failureKind ? {
-        failureKind: result.failureKind,
-        failureMessage: result.failureMessage
-      } : skipReason ? { skipReason } : undefined
+      metadata: failureRowMetadata(result) ?? (skipReason ? { skipReason, ...claimSource !== undefined && { claimSource } } : undefined)
     });
     recordRunner(ctx.filePath, runnerId, result.status, result.diagnostics.length, duration, ctx.writeIndex);
     diagnostics.push(...result.diagnostics);
@@ -742,8 +780,38 @@ async function runGroup(ctx, group, registry, onRunnerResult) {
   }
   return { diagnostics, latencies, hadBlocker };
 }
-export async function dispatchForFile(ctx, groups, registry, onRunnerResult) {
+export async function dispatchForFile(ctx, groups, registry, onRunnerResult, options) {
   const _overallStart = Date.now();
+  if (ctx.analysisRootMode === "adopted") {
+    const planned = groups.flatMap((g) => g.runnerIds);
+    groups = filterGroupsForAdoptedRoot(groups);
+    const admitted = new Set(groups.flatMap((g) => g.runnerIds));
+    logLatency({
+      type: "phase",
+      filePath: ctx.filePath,
+      phase: "dispatch_adopted_root_allowlist",
+      durationMs: 0,
+      metadata: {
+        admissionList: ADOPTED_ROOT_RUNNER_ALLOWLIST.join(","),
+        admitted: groups.flatMap((g) => g.runnerIds).join(","),
+        refused: planned.flatMap((id) => admitted.has(id) ? [] : [id]).join(","),
+        noAdmittedRunner: groups.length === 0
+      }
+    });
+    if (groups.length === 0) {
+      return {
+        diagnostics: [],
+        blockers: [],
+        warnings: [],
+        baselineWarningCount: 0,
+        fixed: [],
+        resolvedCount: 0,
+        output: "",
+        blockerOutput: "",
+        hasBlockers: false
+      };
+    }
+  }
   if (ctx.fileRole === "generated") {
     const evidence = ctx.generatedEvidence;
     const lineShapeMean = ctx.generatedLineShapeMean;
@@ -812,13 +880,16 @@ export async function dispatchForFile(ctx, groups, registry, onRunnerResult) {
   }
   const dedupedDiagnostics = dedupeOverlappingDiagnostics(allDiagnostics);
   const fileContent = ctx.facts.getFileFact(ctx.filePath, "file.content") ?? "";
-  const rulePolicy = rulePolicyMapFromConfig(loadDmLensProjectConfig(ctx.projectRoot ?? ctx.cwd).rules);
+  const rulePolicy = ctx.rulePolicy ?? rulePolicyMapFromConfig(loadDmLensProjectConfig(ctx.projectRoot ?? ctx.cwd).rules);
   const applyOutputFilters = (diags) => {
     const dockerOverlap = suppressTrivyConfigDockerOverlap(diags);
     const overlap = suppressLintOverlapsWithLsp(dockerOverlap);
     const inline = applyInlineSuppressions(overlap, fileContent);
     const disposition = applyDispositions(inline, ctx.projectRoot ?? ctx.cwd, ctx.filePath, fileContent);
-    return applyRulePolicy(disposition, rulePolicy);
+    return applyRulePolicy(disposition, rulePolicy, {
+      root: ctx.projectRoot ?? ctx.cwd,
+      filePath: ctx.filePath
+    });
   };
   let visibleDiagnostics = applyOutputFilters(dedupedDiagnostics);
   let resolvedCount = 0;
@@ -850,7 +921,7 @@ export async function dispatchForFile(ctx, groups, registry, onRunnerResult) {
   }
   const inlineBlockers = blockers;
   const inlineFixed = fixedItems;
-  const coverageNotice = buildCoverageNotice(ctx, runnerLatencies);
+  const coverageNotice = buildCoverageNotice(ctx, runnerLatencies, options?.dedupeCoverageNotice ?? true);
   const blockerOutput = formatDiagnostics(inlineBlockers, "blocking");
   let output = blockerOutput;
   output += formatDiagnostics(inlineFixed, "fixed");
@@ -905,6 +976,7 @@ export async function dispatchForFile(ctx, groups, registry, onRunnerResult) {
     }
   });
   return {
+    latencyReport,
     diagnostics: visibleDiagnostics,
     blockers,
     warnings,
@@ -942,6 +1014,12 @@ function normalizeDiagnosticFilePath(ctx, rawPath) {
   }
   return resolveRunnerPath(ctx.cwd, rawPath || ctx.filePath);
 }
+function failureRowMetadata(result) {
+  return result.status === "failed" && result.failureKind ? {
+    failureKind: result.failureKind,
+    failureMessage: result.failureMessage
+  } : undefined;
+}
 async function runRunner(ctx, runner, defaultSemantic) {
   const timeoutMs = Math.max(runner.timeoutMs ?? RUNNER_TIMEOUT_MS, getRunnerTimeoutFloorMs());
   let timer;

package/extensions/dm-lens/clients/dispatch/facts/comment-facts.js

@@ -7,11 +7,14 @@ export const commentFactProvider = {
     return /\.tsx?$/.test(ctx.filePath);
   },
   async run(ctx, store) {
-    await extractFactsFromTree(ctx, store, { "file.comments": [] }, (root) => {
+    await extractFactsFromTree(ctx, store, commentFactProvider.id, { "file.comments": [] }, (root) => {
       const comments = [];
       walk(root, (node) => {
         if (node.type === "comment") {
-          comments.push({ line: node.startPosition.row + 1, text: node.text });
+          comments.push({
+            line: node.startPosition.row + 1,
+            text: node.text
+          });
         }
       });
       return { "file.comments": comments };

package/extensions/dm-lens/clients/dispatch/facts/function-facts.js

@@ -224,7 +224,7 @@ export const functionFactProvider = {
     return isJstsFactFile(ctx.filePath);
   },
   async run(ctx, store) {
-    await extractFactsFromTree(ctx, store, { "file.functionSummaries": [] }, (root) => {
+    await extractFactsFromTree(ctx, store, functionFactProvider.id, { "file.functionSummaries": [] }, (root) => {
       const summaries = [];
       const containers = [];
       const addSummary = (node) => {

package/extensions/dm-lens/clients/dispatch/facts/import-facts.js

@@ -90,7 +90,7 @@ export const importFactProvider = {
           hasEsm = true;
           importNodes.push(child);
         } else if (child.type === "export_statement") {
-          const isReExport = Boolean(firstChildOfType(child, "string"));
+          const isReExport = Boolean(firstChildOfType(child, "from"));
           if (isReExport || firstChildOfType(child, "export_clause")) {
             hasEsm = true;
           }
@@ -165,7 +165,7 @@ export const importFactProvider = {
           }
         });
       }
-    });
+    }, importFactProvider.id);
     if (!parsed.parsed)
       setEmpty();
     else

package/extensions/dm-lens/clients/dispatch/facts/tree-sitter-facts.js

@@ -7,7 +7,7 @@ import {
 
 export { childrenOfType, firstChildOfType, walk };
 export const withFactTree = withTreeSitterRoot;
-export async function extractFactsFromTree(ctx, store, defaults, extract, coverageFact) {
+export async function extractFactsFromTree(ctx, store, caller, defaults, extract, coverageFact) {
   const writeAll = (facts, complete) => {
     for (const key of Object.keys(defaults)) {
       store.setFileFact(ctx.filePath, key, facts[key] ?? defaults[key]);
@@ -19,6 +19,6 @@ export async function extractFactsFromTree(ctx, store, defaults, extract, covera
   const content = store.getFileFact(ctx.filePath, "file.content");
   if (content == null)
     return writeAll(defaults, false);
-  const parsed = await withFactTree(ctx.filePath, content, (root) => extract(root, content));
+  const parsed = await withFactTree(ctx.filePath, content, (root) => extract(root, content), caller);
   writeAll(parsed.parsed ? parsed.value : defaults, parsed.parsed);
 }

package/extensions/dm-lens/clients/dispatch/facts/try-catch-facts.js

@@ -50,7 +50,7 @@ export const tryCatchFactProvider = {
     return /\.tsx?$/.test(ctx.filePath);
   },
   async run(ctx, store) {
-    await extractFactsFromTree(ctx, store, { "file.tryCatchSummaries": [] }, (root) => {
+    await extractFactsFromTree(ctx, store, tryCatchFactProvider.id, { "file.tryCatchSummaries": [] }, (root) => {
       const summaries = [];
       walk(root, (node) => {
         if (node.type !== "try_statement")

package/extensions/dm-lens/clients/dispatch/finding-policy.js

@@ -3,18 +3,26 @@ import {
   applyDispositionsMultiFile,
   hasAnyDispositionMarks
 } from "../diagnostic-dispositions.js";
-import { loadDmLensProjectConfig } from "../project-lens-config.js";
 import { retagAuxiliaryDiagnostics } from "./auxiliary-lsp.js";
 import { applyInlineSuppressions } from "./inline-suppressions.js";
-import { applyRulePolicy, rulePolicyMapFromConfig } from "./rule-policy.js";
+import {
+  applyRulePolicy,
+  resolvedRulePolicyMap
+} from "./rule-policy.js";
 import { convertLspDiagnostics } from "./utils/lsp-diagnostics.js";
 export function applyFindingPolicy(diagnostics, options) {
   const inlineKept = applyInlineSuppressions(diagnostics, options.content);
   const disposed = filterDisposed(inlineKept, options);
-  return { kept: applyRulePolicy(disposed, options.policyMap), inlineKept };
+  return {
+    kept: applyRulePolicy(disposed, options.policyMap, {
+      root: options.cwd,
+      filePath: options.filePath
+    }),
+    inlineKept
+  };
 }
 export function loadProjectRulePolicyMap(cwd) {
-  return rulePolicyMapFromConfig(loadDmLensProjectConfig(cwd).rules);
+  return resolvedRulePolicyMap(cwd);
 }
 function filterDisposed(diagnostics, options) {
   const identities = options.identities;

package/extensions/dm-lens/clients/dispatch/integration.js

@@ -46,20 +46,24 @@ import {
   touchCoverageGap
 } from "../lsp/diagnostic-binding.js";
 import { getServersForFileWithConfig } from "../lsp/config.js";
-import { getLSPService } from "../lsp/index.js";
+import { getLSPService } from "../lsp/capabilities.js";
 import { isExternalOrVendorFile, normalizeMapKey } from "../path-utils.js";
 import { getProjectIgnoreMatcher } from "../file-utils.js";
 import {
   resetAstGrepNapiLoadState,
   resetAstGrepUnsupportedLanguageLog
 } from "./runners/ast-grep-napi.js";
-import { resetTreeSitterClientLoadState } from "../tree-sitter-shared.js";
+import {
+  isTreeSitterWasmAborted,
+  resetTreeSitterClientLoadState
+} from "../tree-sitter-shared.js";
 import { isTestRoleCollateral } from "../collateral-test-role.js";
 import {
   clearReviewGraphWorkspaceCache,
   getGraphBuildInfoForGraph,
   getGraphImportChanges,
-  graphBuildInfoIsTrustworthy
+  graphBuildInfoIsTrustworthy,
+  graphWasmTrapDetail
 } from "../review-graph/builder.js";
 import {
   buildReverseDependencyIndexFromGraph,
@@ -86,6 +90,7 @@ import {
   WORD_INDEX_MAX_BYTES
 } from "../word-index.js";
 import { reconcileCascadeNeighborLspErrors } from "../widget-state.js";
+import { writeOrderToken } from "../write-ordering-guard.js";
 import { findAuxiliaryProfileForSource } from "./auxiliary-lsp.js";
 import { registerProvider, runProviders } from "./fact-runner.js";
 import { commentFactProvider } from "./facts/comment-facts.js";
@@ -509,14 +514,17 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
       hasBlockers = false,
       dbg,
       turnSeq = 0,
+      orderTurn,
       writeSeq,
       projectRoot,
       seqState,
       turnEndCascadeSettleStart,
       fileContent,
       wordIndex,
-      onWordIndexUpdated
+      onWordIndexUpdated,
+      sessionGeneration
     } = options;
+    const widgetOrder = writeOrderToken(orderTurn, writeSeq);
     ensureCascadeTurnScope(turnSeq);
     if (hasBlockers) {
       logCascade({
@@ -678,11 +686,11 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
         }
       });
       impact = computeImpactCascade(graph, normalizedFile, cwd);
-      if ((graphBuildInfo.mode === "skipped" || graph.persistCoverage?.partial === true || !graphBuildInfoTrustworthy) && !impact.indeterminate) {
+      if ((graphBuildInfo.mode === "skipped" || graph.persistCoverage?.partial === true || (graphBuildInfo.wasmTrappedFiles ?? 0) > 0 || isTreeSitterWasmAborted() || !graphBuildInfoTrustworthy) && !impact.indeterminate) {
         const coverage = graph.persistCoverage;
         impact.indeterminate = {
           reason: "graph_degraded",
-          detail: !graphBuildInfoTrustworthy ? "review graph coverage unknown — build state unavailable for this graph" : graphBuildInfo.mode === "skipped" ? graphBuildInfo.skipReason === "too_many_files" ? graphBuildInfo.sourceFileCountTruncated ? `review graph disabled — more than ${graphBuildInfo.maxFileCount ?? "?"} files (cap ${graphBuildInfo.maxFileCount ?? "?"})` : `review graph disabled — ${graphBuildInfo.sourceFileCount ?? "?"} files over the ${graphBuildInfo.maxFileCount ?? "?"} cap` : graphBuildInfo.skipReason === "unsafe_root" ? "review graph skipped — workspace root is at/above home dir" : `review graph unavailable (${graphBuildInfo.skipReason ?? "skipped"})` : coverage?.sourceFilesTruncated ? "review graph partial — source walk stopped at its visited-entry budget" : "review graph partial — persisted graph coverage is incomplete",
+          detail: !graphBuildInfoTrustworthy ? "review graph coverage unknown — build state unavailable for this graph" : graphBuildInfo.mode === "skipped" ? graphBuildInfo.skipReason === "too_many_files" ? graphBuildInfo.sourceFileCountTruncated ? `review graph disabled — more than ${graphBuildInfo.maxFileCount ?? "?"} files (cap ${graphBuildInfo.maxFileCount ?? "?"})` : `review graph disabled — ${graphBuildInfo.sourceFileCount ?? "?"} files over the ${graphBuildInfo.maxFileCount ?? "?"} cap` : graphBuildInfo.skipReason === "unsafe_root" ? "review graph skipped — workspace root is at/above home dir" : `review graph unavailable (${graphBuildInfo.skipReason ?? "skipped"})` : isTreeSitterWasmAborted() ? "review graph degraded — tree-sitter is disabled for this process until restart" : graphBuildInfo.wasmTrappedFiles ? graphWasmTrapDetail(graphBuildInfo.wasmTrappedFiles) : coverage?.sourceFilesTruncated ? "review graph partial — source walk stopped at its visited-entry budget" : "review graph partial — persisted graph coverage is incomplete",
           sourceFileCount: graphBuildInfo.sourceFileCount,
           maxFileCount: graphBuildInfo.maxFileCount
         };
@@ -964,7 +972,7 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
           snapshotMissing: false,
           snapshotAgeSec
         });
-        reconcileCascadeNeighborLspErrors(neighborPath, cascadeReconcilableLspErrors(entry.diags, neighborPath), writeSeq, entry.ts);
+        reconcileCascadeNeighborLspErrors(neighborPath, cascadeReconcilableLspErrors(entry.diags, neighborPath), widgetOrder, entry.ts);
         neighbors.push({
           filePath: neighborPath,
           reason: neighborReason(importerSet, callerSet, neighborPath),
@@ -1018,6 +1026,8 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
           });
           return;
         }
+        const readStamp = performance.now();
+        const readAtMs = Date.now();
         const content = await nodeFs.promises.readFile(neighborPath, "utf8");
         if (isTierAwareCascadeEnabled()) {
           try {
@@ -1032,7 +1042,8 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
                   collectDiagnostics: false,
                   silent: true,
                   source: "cascade",
-                  clientScope: "primary"
+                  clientScope: "primary",
+                  readStamp
                 });
                 if (tier === "diagnostics-unsupported") {
                   logCascade({
@@ -1049,11 +1060,15 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
                   });
                   return;
                 }
-                recordOutstandingCascadeTouch({
+                const recordTouch = () => recordOutstandingCascadeTouch({
                   filePath: neighborPath,
                   serverId: spawnedForTouch.client.serverId,
                   touchedAt
                 });
+                if (sessionGeneration)
+                  sessionGeneration.guardedWrite(neighborPath, recordTouch);
+                else
+                  recordTouch();
                 const durationMs = Date.now() - neighborStart;
                 if (tier === "collect-later")
                   collectLaterSkipped++;
@@ -1084,10 +1099,36 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
           maxClientWaitMs: isColdSnapshot ? 1000 : 2000,
           silent: true,
           source: "cascade",
-          clientScope: "primary"
+          clientScope: "primary",
+          readStamp
         });
-        if (!rawDiags)
-          return;
+        if (!rawDiags) {
+          if (!lspService.checkDestroyed())
+            return;
+          const durationMs = Date.now() - neighborStart;
+          logCascade({
+            phase: "neighbor_touch",
+            filePath,
+            neighborFile: neighborPath,
+            diagnosticCount: 0,
+            durationMs,
+            lspTouched: true,
+            lspServerCount: configuredServerCount,
+            coldSnapshot: isColdSnapshot,
+            metadata: {
+              inconclusive: true,
+              inconclusiveReason: "service-destroyed"
+            }
+          });
+          return {
+            filePath: neighborPath,
+            reason: neighborReason(importerSet, callerSet, neighborPath),
+            diagnostics: [],
+            lspTouched: true,
+            inconclusive: true,
+            durationMs
+          };
+        }
         const confirmed = isConfirmedTouch(rawDiags);
         const bindingRejected = readBoundToCurrentDisk(rawDiags) === false;
         const inconclusive = readInconclusive(rawDiags);
@@ -1126,7 +1167,7 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
           }
         });
         if (confirmed) {
-          reconcileCascadeNeighborLspErrors(neighborPath, cascadeReconcilableLspErrors(rawDiags.diags, neighborPath), writeSeq);
+          reconcileCascadeNeighborLspErrors(neighborPath, cascadeReconcilableLspErrors(rawDiags.diags, neighborPath), widgetOrder, readAtMs);
         }
         return {
           filePath: neighborPath,
@@ -1438,7 +1479,7 @@ export async function dispatchLint(filePath, cwd, pi, modifiedRanges, projectRoo
   }
 }
 export async function dispatchLintWithResult(filePath, cwd, pi, modifiedRanges, logContext, options) {
-  const ctx = createDispatchContext(filePath, cwd, pi, sessionFacts, options?.blockingOnly ?? true, modifiedRanges, options?.projectRoot, options?.writeIndex, options?.telemetryModel, options?.telemetryProvider);
+  const ctx = createDispatchContext(filePath, cwd, pi, sessionFacts, options?.blockingOnly ?? true, modifiedRanges, options?.projectRoot, options?.writeIndex, options?.telemetryModel, options?.telemetryProvider, options?.sessionGeneration, options?.sessionId, options?.analysisRootMode);
   sessionFacts.clearFileFactsFor(ctx.filePath);
   try {
     const kind = ctx.kind;
@@ -1470,7 +1511,11 @@ export async function dispatchLintWithResult(filePath, cwd, pi, modifiedRanges,
       };
     }
     await runProviders(ctx);
-    const result = await dispatchForFile(ctx, groups, sessionRunnerRegistry);
+    const result = await dispatchForFile(ctx, groups, sessionRunnerRegistry, undefined, {
+      ...options?.dedupeCoverageNotice !== undefined && {
+        dedupeCoverageNotice: options.dedupeCoverageNotice
+      }
+    });
     trackSessionSlopStats(ctx, result.diagnostics);
     if (kind === "jsts" && logContext) {
       scheduleAstGrepWarningScan(filePath, cwd, pi, logContext);

package/extensions/dm-lens/clients/dispatch/known-runner-ids.js

@@ -0,0 +1,13 @@
+let knownRunnerIds = new Set;
+export function registerRunnerId(id) {
+  knownRunnerIds.add(id);
+}
+export function runnerIdentityPopulated() {
+  return knownRunnerIds.size > 0;
+}
+export function isKnownRunnerId(id) {
+  return knownRunnerIds.has(id);
+}
+export function resetRunnerIdentityForTests() {
+  knownRunnerIds = new Set;
+}