@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

package/extensions/dm-lens/clients/knip-client.js

@@ -3,7 +3,16 @@ import { incrementDegradationCount } from "./degradation-ledger.js";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { getProjectDataDir } from "./file-utils.js";
-import { findNearestMarkerRoot } from "./path-utils.js";
+import { HardFailureStamps } from "./hard-failure-summary.js";
+import {
+  findNearestMarkerRoot,
+  normalizeEphemeralMapKey,
+  normalizeFilePath
+} from "./path-utils.js";
+import {
+  canonicalDirectory,
+  listNestedLinkedWorktreeRoots
+} from "./review-graph/git-identity.js";
 import { safeSpawnAsync } from "./safe-spawn.js";
 import {
   createAvailabilityChecker,
@@ -17,7 +26,7 @@ import {
 } from "./dispatch/runners/utils/availability-policy.js";
 import { spawnFailedWithNoOutput } from "./dispatch/runners/utils/spawn-outcome.js";
 import { formatToolFailure } from "./dispatch/runners/utils/tool-failure.js";
-import { findLocalBinUpwards } from "./package-manager.js";
+import { findLocalBinUpwards, localBinPath } from "./package-manager.js";
 import { logSessionStart } from "./sessionstart-logger.js";
 const EMPTY_RESULT = {
   success: false,
@@ -75,7 +84,7 @@ export function resolveProjectKnipConfig(targetDir) {
   return null;
 }
 export function resolveProjectKnipBinary(targetDir) {
-  return findLocalBinUpwards("knip", targetDir) ?? null;
+  return localBinPath(findLocalBinUpwards("knip", targetDir)) ?? null;
 }
 export function classifyKnipBinary(binary, targetDir) {
   if (binary === null)
@@ -97,6 +106,28 @@ function readKnipShimVersion(binary) {
     return null;
   }
 }
+const NO_NESTED_WORKTREES = {
+  count: 0,
+  contains: () => false
+};
+function nestedWorktreeScope(targetDir) {
+  const prefixes = [];
+  for (const root of listNestedLinkedWorktreeRoots(targetDir)) {
+    prefixes.push(`${normalizeEphemeralMapKey(normalizeFilePath(root))}/`);
+  }
+  if (prefixes.length === 0)
+    return NO_NESTED_WORKTREES;
+  const base = normalizeFilePath(canonicalDirectory(targetDir));
+  return {
+    count: prefixes.length,
+    contains: (file) => {
+      if (!file)
+        return false;
+      const key = normalizeEphemeralMapKey(`${base}/${file}`);
+      return prefixes.some((prefix) => key.startsWith(prefix));
+    }
+  };
+}
 const MAX_RECORDED_TOOLCHAINS = 32;
 
 export class KnipClient {
@@ -110,6 +141,8 @@ export class KnipClient {
   ensureInFlight = null;
   log;
   inFlight = new Map;
+  hardFailures = new HardFailureStamps;
+  scanDurations = new Map;
   completedByProject = new Map;
   recordedToolchains = new Set;
   constructor(verbose = false) {
@@ -117,6 +150,8 @@ export class KnipClient {
   }
   resetSessionState() {
     this.completedByProject.clear();
+    this.hardFailures.clear();
+    this.scanDurations.clear();
   }
   resolveProjectRoot(startDir, homeDirOverride) {
     return findNearestMarkerRoot(startDir, [
@@ -169,6 +204,19 @@ export class KnipClient {
       })
     };
   }
+  recentHardFailure(cwd) {
+    const key = this.resolveProjectRoot(cwd);
+    if (!key)
+      return null;
+    return this.hardFailures.recent(key);
+  }
+  scanFloorMs(cwd) {
+    const samples = this.scanDurations.get(this.resolveProjectRoot(cwd) ?? cwd);
+    return samples?.length === 2 ? Math.min(...samples) : undefined;
+  }
+  nestedWorktrees(cwd) {
+    return nestedWorktreeScope(this.resolveProjectRoot(cwd) ?? cwd).count;
+  }
   async analyze(cwd, _ignore, options = {}) {
     const targetDir = this.resolveProjectRoot(cwd || process.cwd());
     if (!targetDir) {
@@ -193,7 +241,15 @@ export class KnipClient {
       this.log(`Analysis already in flight for ${key}; sharing result`);
       return existing;
     }
+    const startedAt = Date.now();
     const promise = this.runAnalyze(key).then((result) => {
+      this.hardFailures.settle(key, result);
+      if (result.success) {
+        this.scanDurations.set(key, [
+          ...(this.scanDurations.get(key) ?? []).slice(-1),
+          Date.now() - startedAt
+        ]);
+      }
       const executed = { ...result, execution: "executed" };
       if (result.success && options.projectSeq !== undefined) {
         this.completedByProject.set(key, {
@@ -234,6 +290,7 @@ export class KnipClient {
     return JSON.stringify(current.packageJson) === JSON.stringify(signal.packageJson) && JSON.stringify(current.config) === JSON.stringify(signal.config);
   }
   async runAnalyze(targetDir) {
+    const scannedAt = new Date().toISOString();
     const cacheLocation = path.join(getProjectDataDir(targetDir), "cache", "knip");
     try {
       fs.mkdirSync(cacheLocation, { recursive: true });
@@ -298,7 +355,10 @@ export class KnipClient {
         summary: "No issues found"
       };
     }
-    return this.dropOverridePinnedDeps(this.parseOutput(output), targetDir);
+    return {
+      ...this.dropOverridePinnedDeps(this.parseOutput(output, nestedWorktreeScope(targetDir)), targetDir),
+      scannedAt
+    };
   }
   recordToolchain(targetDir, command, source) {
     const config = resolveProjectKnipConfig(targetDir);
@@ -349,7 +409,7 @@ export class KnipClient {
   formatResult(result, maxItems = 20) {
     return formatKnipResult(result, maxItems);
   }
-  parseOutput(output) {
+  parseOutput(output, nested = NO_NESTED_WORKTREES) {
     try {
       const data = JSON.parse(output);
       const issues = [];
@@ -357,7 +417,12 @@ export class KnipClient {
       const unusedFiles = [];
       const unusedDeps = [];
       const unlistedDeps = [];
+      const droppedFiles = new Set;
       const addIssue = (issue) => {
+        if (nested.contains(issue.file)) {
+          droppedFiles.add(issue.file ?? "");
+          return;
+        }
         issues.push(issue);
         if (issue.type === "export" || issue.type === "enumMember") {
           unusedExports.push(issue);
@@ -417,7 +482,11 @@ export class KnipClient {
         unusedFiles,
         unusedDeps,
         unlistedDeps,
-        summary: `Found ${issues.length} issues`
+        summary: `Found ${issues.length} issues`,
+        ...nested.count > 0 && {
+          nestedWorktrees: nested.count,
+          nestedFilesDropped: droppedFiles.size
+        }
       };
     } catch (err) {
       this.log("Failed to parse knip JSON output");

package/extensions/dm-lens/clients/knip-scan-roots.js

@@ -0,0 +1,29 @@
+import { resolve } from "node:path";
+import { pathsEqual } from "./path-utils.js";
+import {
+  resolveGitCheckout,
+  resolveLinkedWorktreeOwner
+} from "./review-graph/git-identity.js";
+export const MAX_KNIP_ROOTS_PER_TURN = 3;
+export function resolveKnipScanRoots(sessionCwd, modifiedFiles) {
+  const session = resolveGitCheckout(sessionCwd);
+  if (!session || modifiedFiles.length === 0) {
+    return { roots: [sessionCwd], overCap: [] };
+  }
+  let sessionOwnsEdit = false;
+  const linked = [];
+  for (const file of modifiedFiles) {
+    const owner = resolveLinkedWorktreeOwner(session, resolve(sessionCwd, file));
+    if (owner === null) {
+      sessionOwnsEdit = true;
+    } else if (!linked.some((known) => pathsEqual(known.root, owner.root))) {
+      linked.push(owner);
+    }
+  }
+  const linkedRoots = linked.map((checkout) => checkout.spelledRoot);
+  const roots = sessionOwnsEdit ? [sessionCwd, ...linkedRoots] : linkedRoots;
+  return {
+    roots: roots.slice(0, MAX_KNIP_ROOTS_PER_TURN),
+    overCap: roots.slice(MAX_KNIP_ROOTS_PER_TURN)
+  };
+}

package/extensions/dm-lens/clients/language-policy.js

@@ -51,6 +51,7 @@ export const LANGUAGE_POLICY = {
   fsharp: { lspCapable: true },
   java: { lspCapable: true },
   kotlin: { lspCapable: true, startup: { defaults: ["ktlint"] } },
+  lean: { lspCapable: true },
   swift: { lspCapable: true },
   dart: { lspCapable: true },
   lua: { lspCapable: true },
@@ -167,6 +168,7 @@ const PRIMARY_DISPATCH_GROUPS = {
     runnerIds: ["lsp", "ktlint"],
     filterKinds: ["kotlin"]
   },
+  lean: { mode: "fallback", runnerIds: ["lsp"], filterKinds: ["lean"] },
   swift: {
     mode: "all",
     runnerIds: ["lsp", "swiftlint"],

package/extensions/dm-lens/clients/language-profile.js

@@ -6,6 +6,7 @@ import {
   DOTNET_CSHARP_ROOT_MARKERS,
   DOTNET_FSHARP_ROOT_MARKERS,
   KIND_EXTENSIONS,
+  LEAN_ROOT_MARKERS,
   TERRAGRUNT_FILENAMES
 } from "./file-kinds.js";
 import { getProjectIgnoreMatcher } from "./file-utils.js";
@@ -43,6 +44,7 @@ const PROJECT_MARKERS_BY_KIND = {
   prisma: ["schema.prisma", "prisma/schema.prisma"],
   java: ["pom.xml", "build.gradle", "build.gradle.kts", ".classpath"],
   kotlin: ["build.gradle.kts", "build.gradle", "pom.xml"],
+  lean: LEAN_ROOT_MARKERS,
   swift: ["Package.swift"],
   dart: ["pubspec.yaml"],
   elixir: ["mix.exs"],
@@ -91,6 +93,7 @@ const ROOT_MARKERS_BY_KIND = {
   prisma: ["prisma/schema.prisma", "schema.prisma"],
   java: ["pom.xml", "build.gradle", "build.gradle.kts", ".classpath"],
   kotlin: ["build.gradle.kts", "build.gradle", "pom.xml"],
+  lean: LEAN_ROOT_MARKERS,
   swift: ["Package.swift"],
   dart: ["pubspec.yaml"],
   elixir: ["mix.exs"],
@@ -214,7 +217,7 @@ export function resolveLanguageRootForFile(filePath, workspaceRoot) {
 }
 export const WARMUP_SOURCE_EXTS = new Set(SUPPORTED_FILE_KINDS.flatMap((kind) => KIND_EXTENSIONS[kind]));
 const WARMUP_CODE_EXTS = new Set(SUPPORTED_FILE_KINDS.filter((kind) => CODE_KINDS.has(kind)).flatMap((kind) => KIND_EXTENSIONS[kind]));
-const MAX_WARMUP_SOURCE_FILES = 2000;
+const MAX_WARMUP_SOURCE_FILES = 2500;
 const MATCHED_FILES_CEILING_FACTOR = 10;
 export async function collectSourceFilesForWarmup(rootDir, maxFiles = MAX_WARMUP_SOURCE_FILES, yieldEvery = 100) {
   const root = path.resolve(rootDir);

package/extensions/dm-lens/clients/language-registry.js

@@ -31,6 +31,7 @@ export const PINNED_LANGUAGE_IDS = [
   "jsonc",
   "julia",
   "kotlin",
+  "lean",
   "less",
   "lua",
   "markdown",
@@ -198,6 +199,7 @@ export const LANGUAGES = [
     extensions: [".kt", ".kts"],
     grammar: "kotlin"
   },
+  { id: "lean", kind: "lean", extensions: [".lean"] },
   { id: "less", kind: "css", extensions: [".less"] },
   { id: "lua", kind: "lua", extensions: [".lua"], grammar: "lua" },
   { id: "markdown", kind: "markdown", extensions: [".md", ".mdx"] },
@@ -420,5 +422,6 @@ export const SCAN_LANGUAGE_PRIORITY = [
   ["json", "jsonc"],
   ["yaml"],
   ["toml"],
-  ["prisma"]
+  ["prisma"],
+  ["lean"]
 ];

package/extensions/dm-lens/clients/latency-logger.js

@@ -23,6 +23,7 @@ const LAST_PHASE_EXCLUDED = new Set([
   "session_end_bus_rollup",
   "cache_usage_summary",
   "test_runner_failed_target_state",
+  "turn_end_test_selection",
   "lsp_aux_wait_outcome",
   "tool_set_mutation",
   "availability_decision",
@@ -37,7 +38,16 @@ const LAST_PHASE_EXCLUDED = new Set([
   "path_attribution_verified_rollup",
   "concurrent_session_bind_rollup",
   "auxiliary_readiness",
-  "lsp_empty_first_publish_held"
+  "lsp_empty_first_publish_held",
+  "lsp_diagnostics_fence",
+  "lsp_rules_refreshed",
+  "read_guard_conversation_read",
+  "read_widening_note",
+  "session_handoff_slot",
+  "session_handoff_adopt",
+  "session_store_action",
+  "session_end_fence_rollup",
+  "format_late_resync_chained"
 ]);
 export function getLastLoggedPhase() {
   return recentPhases[0];

package/extensions/dm-lens/clients/lens-config.js

@@ -69,7 +69,7 @@ function reportGlobalConfigProbeRetention() {
   recordDegradationOnce({
     kind: "config-location-probe-failed",
     subject: resolution.path,
-    reason: `existence probe for ${resolution.existsProbeFailed?.path} failed (${resolution.existsProbeFailed?.errorClassName}); the location is retained as the config source and its read failures report through PILENS_CFG_0001`,
+    reason: `existence probe failed (${resolution.existsProbeFailed?.errorClassName}); the location is retained as the config source and its read failures report through PILENS_CFG_0001`,
     metadata: { subsystem: "lens-config", configPath: resolution.path }
   });
 }
@@ -182,6 +182,15 @@ export function loadDmLensGlobalConfig(configPath) {
         warnInvalid("actionableWarnings.autoFix.maxFixes must be a non-negative finite number");
       }
     }
+    const contextInjection = asConfigObject(raw.contextInjection);
+    if (contextInjection && "requirePreExistingFixes" in contextInjection) {
+      if (typeof contextInjection.requirePreExistingFixes === "boolean") {
+        config.contextInjection ??= {};
+        config.contextInjection.requirePreExistingFixes = contextInjection.requirePreExistingFixes;
+      } else {
+        warnInvalid("contextInjection.requirePreExistingFixes must be a boolean");
+      }
+    }
     const widget = asConfigObject(raw.widget);
     if (widget) {
       if (typeof widget.visible === "boolean") {

package/extensions/dm-lens/clients/lens-engine.js

@@ -9,7 +9,7 @@ import {
 } from "./instance-registry.js";
 import { extensionsForLanguageToken } from "./language-registry.js";
 import { initLSPConfig } from "./lsp/config.js";
-import { getLSPService } from "./lsp/index.js";
+import { getLSPService } from "./lsp/capabilities.js";
 import { acquireWarmWordIndex } from "./mcp/analyze.js";
 import { normalizeMapKey } from "./path-utils.js";
 import { scanProjectDiagnostics } from "./project-diagnostics/scanner.js";

package/extensions/dm-lens/clients/lens-flag-registry.js

@@ -1,4 +1,14 @@
 import { DEPRECATED_CONFIG_SURFACES } from "./config-diagnostic-codes.js";
+function globalOptInFlag(name, description, configKey) {
+  return {
+    name,
+    description,
+    configKey,
+    negated: false,
+    default: false,
+    scope: "global"
+  };
+}
 export const LENS_FLAGS = [
   {
     name: "no-lens",
@@ -146,30 +156,10 @@ export const LENS_FLAGS = [
     default: false,
     scope: "global"
   },
-  {
-    name: "lens-compact-tool-line",
-    description: "Opt-in (#1327): collapse a dm-lens tool's call+result rows into ONE theme-aware line (status glyph + name + summary) instead of two. Preserves expand-to-view-full-output. Default off. Also via ui.compactToolLine=true in ~/.dm-lens/config.json.",
-    configKey: "ui.compactToolLine",
-    negated: false,
-    default: false,
-    scope: "global"
-  },
-  {
-    name: "lens-compact-lsp-status",
-    description: "Opt-in (#3099): collapse the footer LSP status to one state glyph per group (LSP ✓ green, LSP ✗ red, dim LSP ✗ when nothing is warm) instead of listing the active server names. Default off. Also via ui.compactLspStatus=true in ~/.dm-lens/config.json.",
-    configKey: "ui.compactLspStatus",
-    negated: false,
-    default: false,
-    scope: "global"
-  },
-  {
-    name: "lens-hide-lsp-status",
-    description: "Opt-in (#3099): publish no dm-lens-lsp footer status at all, so a host that renders extension statuses stops showing the key. Outranks lens-compact-lsp-status when both are set. Default off. Also via ui.hideLspStatus=true in ~/.dm-lens/config.json.",
-    configKey: "ui.hideLspStatus",
-    negated: false,
-    default: false,
-    scope: "global"
-  },
+  globalOptInFlag("lens-compact-tool-line", "Opt-in (#1327): collapse a dm-lens tool's call+result rows into ONE theme-aware line (status glyph + name + summary) instead of two. Preserves expand-to-view-full-output. Default off. Also via ui.compactToolLine=true in ~/.dm-lens/config.json.", "ui.compactToolLine"),
+  globalOptInFlag("lens-compact-lsp-status", "Opt-in (#3099): collapse the footer LSP status to one state glyph per group (LSP ✓ green, LSP ✗ red, dim LSP ✗ when nothing is warm) instead of listing the active server names. Default off. Also via ui.compactLspStatus=true in ~/.dm-lens/config.json.", "ui.compactLspStatus"),
+  globalOptInFlag("lens-hide-lsp-status", "Opt-in (#3099): publish no dm-lens-lsp footer status at all, so a host that renders extension statuses stops showing the key. Outranks lens-compact-lsp-status when both are set. Default off. Also via ui.hideLspStatus=true in ~/.dm-lens/config.json.", "ui.hideLspStatus"),
+  globalOptInFlag("lens-compact-widget", "Opt-in (#3959): render the dm-lens widget as ONE summary line (languages + error/warning totals) instead of also stacking file rows, the suppressed count and blocker details below it. Default off. Also via ui.compactWidget=true in ~/.dm-lens/config.json.", "ui.compactWidget"),
   {
     name: "no-lazy-tools",
     description: "Keep all dm-lens tools active to avoid tool-list cache changes. Also via tools.lazy=false in ~/.dm-lens/config.json.",

package/extensions/dm-lens/clients/lsp/aggregation.js

@@ -1,3 +1,4 @@
+import { isAuxiliary } from "./server-traits.js";
 export async function raceToCompletion(promises, shouldComplete, options = { timeoutMs: 1500 }) {
   const results = [];
   results.length = promises.length;
@@ -7,10 +8,10 @@ export async function raceToCompletion(promises, shouldComplete, options = { tim
   let completed = false;
   let remaining = promises.length;
   const descriptors = options.descriptors ?? [];
-  const hasAuxiliaries = descriptors.some((d) => d.role === "auxiliary");
-  const auxIndices = hasAuxiliaries ? new Set(descriptors.map((d, i) => d.role === "auxiliary" ? i : -1).filter((i) => i >= 0)) : new Set;
-  const primaryCount = promises.length - auxIndices.size;
-  let primaryRemaining = primaryCount;
+  const hasAuxiliaries = descriptors.some((d) => isAuxiliary(d));
+  const auxIndices = hasAuxiliaries ? new Set(descriptors.map((d, i) => isAuxiliary(d) ? i : -1).filter((i) => i >= 0)) : new Set;
+  const languageCount = promises.length - auxIndices.size;
+  let languageRemaining = languageCount;
   let auxGraceStarted = false;
   return new Promise((resolve) => {
     const timeout = setTimeout(() => {
@@ -52,14 +53,14 @@ export async function raceToCompletion(promises, shouldComplete, options = { tim
         finalize();
         return;
       }
-      if (hasAuxiliaries && primaryRemaining === 0 && !auxGraceStarted) {
+      if (hasAuxiliaries && languageRemaining === 0 && !auxGraceStarted) {
         startAuxGrace();
       }
       const collected = results.filter((r) => r !== undefined);
       if (shouldComplete(collected)) {
         if (options.graceMs !== undefined && options.graceMs > 0 && !graceTimer) {
           graceTimer = setTimeout(() => finalize(), options.graceMs);
-        } else if (auxGraceStarted) {} else if (!hasAuxiliaries || primaryRemaining === 0) {
+        } else if (auxGraceStarted) {} else if (!hasAuxiliaries || languageRemaining === 0) {
           finalize();
         }
       }
@@ -72,14 +73,14 @@ export async function raceToCompletion(promises, shouldComplete, options = { tim
           results[index] = result;
           remaining--;
           if (!isAux)
-            primaryRemaining--;
+            languageRemaining--;
           check();
         }
       }).catch(() => {
         if (!completed) {
           remaining--;
           if (!isAux)
-            primaryRemaining--;
+            languageRemaining--;
           check();
         }
       });

package/extensions/dm-lens/clients/lsp/auxiliary-lifecycle.js

@@ -0,0 +1,23 @@
+import { getSuccessfulLspSpawnDurationMs } from "./spawn-history.js";
+export function readEnvAuxGraceMs() {
+  const raw = process.env.DM_LENS_AUX_GRACE_MS;
+  if (raw === undefined)
+    return;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed < 0)
+    return;
+  return parsed;
+}
+export const DEFAULT_AUX_GRACE_CEILING_MS = 2000;
+export const MAX_ADAPTIVE_AUX_GRACE_CEILING_MS = 8000;
+export const ADAPTIVE_AUX_GRACE_MARGIN_MS = 500;
+export function auxWaitBudgetMs(serverId, isCold, configuredCeilingMs, declaredWaitMs) {
+  if (configuredCeilingMs !== undefined || !isCold) {
+    return Math.min(declaredWaitMs, configuredCeilingMs ?? DEFAULT_AUX_GRACE_CEILING_MS);
+  }
+  const observedSpawnMs = getSuccessfulLspSpawnDurationMs(serverId);
+  if (observedSpawnMs === undefined || observedSpawnMs <= 0) {
+    return Math.min(declaredWaitMs, DEFAULT_AUX_GRACE_CEILING_MS);
+  }
+  return Math.min(MAX_ADAPTIVE_AUX_GRACE_CEILING_MS, Math.max(declaredWaitMs, observedSpawnMs + ADAPTIVE_AUX_GRACE_MARGIN_MS));
+}

package/extensions/dm-lens/clients/lsp/capabilities.js

@@ -0,0 +1,98 @@
+import"./index.js";
+import {
+  getOwnedLspService,
+  peekOwnedLspService,
+  resetOwnedLspService
+} from "./service-singleton.js";
+import { groupFilesByPrimaryServer, runPerServerGroups } from "./grouping.js";
+const adaptedServices = new WeakMap;
+function bindGroup(service, keys) {
+  return new Proxy({}, {
+    get(_target, key) {
+      if (!keys.includes(key))
+        return;
+      const value = service[key];
+      return typeof value === "function" ? value.bind(service) : value;
+    }
+  });
+}
+export function adaptLspService(service) {
+  const existing = adaptedServices.get(service);
+  if (existing)
+    return existing;
+  const groups = {
+    clients: bindGroup(service, [
+      "checkDestroyed",
+      "getAliveClientCount",
+      "getAliveServerIds",
+      "getBrokenStatus",
+      "getStatus",
+      "isSpawnInFlight",
+      "shutdown"
+    ]),
+    documents: bindGroup(service, [
+      "getOpenDocumentPaths",
+      "openFile",
+      "touchFile"
+    ]),
+    diagnostics: bindGroup(service, [
+      "getAllDiagnostics",
+      "getDiagnostics",
+      "getDiagnosticsHealth",
+      "getLastKnownDiagnostics",
+      "readCachedDiagnosticsForServers",
+      "runWorkspaceDiagnostics"
+    ]),
+    navigation: bindGroup(service, [
+      "codeAction",
+      "documentSymbol",
+      "definition",
+      "hover",
+      "implementation",
+      "incomingCalls",
+      "outgoingCalls",
+      "prepareCallHierarchy",
+      "references",
+      "rename",
+      "typeDefinition"
+    ]),
+    workspace: bindGroup(service, [
+      "getAdvertisedCommands",
+      "getCapabilitySnapshots",
+      "getClientForFile",
+      "getOperationSupport",
+      "getWarmClientForFile",
+      "hasServerPublishedForFileRoot",
+      "supportsLSP"
+    ])
+  };
+  const adapted = new Proxy(service, {
+    get(target, key, receiver) {
+      if (key in groups)
+        return groups[key];
+      const value = Reflect.get(target, key, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+  adaptedServices.set(service, adapted);
+  return adapted;
+}
+export function getLSPService() {
+  return adaptLspService(getOwnedLspService());
+}
+export function peekLSPService() {
+  const service = peekOwnedLspService();
+  return service ? adaptLspService(service) : undefined;
+}
+export const resetLSPService = (options = {}) => resetOwnedLspService(options);
+export async function notifyExternalFileChange(filePath, type) {
+  return getLSPService().notifyExternalFileChange(filePath, type);
+}
+export async function resyncGitChangedFiles(changedPaths) {
+  return getLSPService().resyncGitChangedFiles(changedPaths);
+}
+export async function hasAuxiliaryLspPublishedForRoot(serverId, filePath) {
+  return getLSPService().hasServerPublishedForFileRoot(serverId, filePath);
+}
+
+export { groupFilesByPrimaryServer, runPerServerGroups };

package/extensions/dm-lens/clients/lsp/cascade-tier.js

@@ -141,19 +141,24 @@ export function registerCascadeTierReconcileTask(getLspService, options = {}) {
   if (_reconcileTaskRegistered)
     return;
   _reconcileTaskRegistered = true;
-  registerQuietWindowTask("cascade_tier3_reconcile", async () => {
+  registerQuietWindowTask("cascade_tier3_reconcile", async (context) => {
     if (!isTierAwareCascadeEnabled())
       return;
     const outcomes = await reconcileOutstandingCascadeTouches(getLspService());
     for (const o of outcomes) {
       try {
         if (o.outcome === "resolved-found" && o.diagnostics?.length) {
-          options.onResolvedFound?.({
+          const neighbor = {
             filePath: o.filePath,
             serverId: o.serverId,
             diagnostics: o.diagnostics,
             ...o.publishedAt !== undefined ? { publishedAt: o.publishedAt } : {}
-          });
+          };
+          const deliver = () => options.onResolvedFound?.(neighbor);
+          if (context)
+            context.sessionGeneration.guardedWrite(o.filePath, deliver);
+          else
+            deliver();
         } else if (o.outcome === "resolved-clean" && o.publishedAt != null) {
           options.onResolvedClean?.({
             filePath: o.filePath,