@duckmind/dm-darwin-x64 0.66.5 → 0.66.7

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

@@ -8,15 +8,20 @@ import {
   getLSPService,
   groupFilesByPrimaryServer,
   runPerServerGroups
-} from "../clients/lsp/index.js";
+} from "../clients/lsp/capabilities.js";
 import {
   buildScopeKey,
   createWorkspaceDiagnosticsCacheContext
 } from "../clients/lsp/workspace-diagnostics-cache.js";
 import {
   getServersForFileWithConfig,
-  primaryServerId
+  primaryServerId,
+  resolveLspCwdForFile
 } from "../clients/lsp/config.js";
+import {
+  describeRootFallback
+} from "../clients/lsp/server.js";
+import { isAuxiliary } from "../clients/lsp/server-traits.js";
 import { mapWithConcurrency } from "../clients/map-with-concurrency.js";
 import {
   combineAbortSignals,
@@ -202,8 +207,20 @@ export function createLspDiagnosticsTool(nextWriteIndex, onConfirmedNoBlockers,
             details: { mode: "batch", filesChecked: 0 }
           };
         }
-        const absPaths = rawPaths.map((entry) => normalizeMapKey(path.resolve(cwd, entry)));
-        return runBatchFileDiagnostics(absPaths, severity, lspService, {
+        const expanded = await expandPathsToFiles(cwd, rawPaths);
+        if (expanded.files.length === 0) {
+          const { listed, text } = describeDirectoriesWithoutFiles(expanded.directoriesWithoutFiles);
+          return {
+            content: [{ type: "text", text }],
+            details: {
+              mode: "batch",
+              severity,
+              filesChecked: 0,
+              directoriesWithoutFiles: listed
+            }
+          };
+        }
+        return runBatchFileDiagnostics(expanded.files, severity, lspService, {
           concurrency,
           waitMs,
           signal,
@@ -212,7 +229,7 @@ export function createLspDiagnosticsTool(nextWriteIndex, onConfirmedNoBlockers,
           serverScope,
           cwd,
           onConfirmedNoBlockers
-        });
+        }, expanded);
       }
       const rawPath = typedParams.path;
       if (!rawPath || rawPath.trim().length === 0) {
@@ -350,6 +367,11 @@ async function classifyEmptyResult(file, lspService) {
     return "clean";
   }
 }
+async function primaryRootFallback(file, cwd) {
+  const seen = [];
+  await resolveLspCwdForFile(file, cwd, (fallback) => seen.push(fallback));
+  return seen.find((fallback) => fallback.requiresProjectRoot);
+}
 async function resolveEmptyResult(file, lspService) {
   try {
     const snapshots = await lspService.getCapabilitySnapshots(file);
@@ -379,7 +401,7 @@ function coveredSourcesForCheck(file, serverScope, unconfirmedServerIds) {
     return [];
   }
   for (const server of servers) {
-    const auxiliary = server.role === "auxiliary";
+    const auxiliary = isAuxiliary(server);
     if (auxiliary && serverScope === "primary")
       continue;
     if (unconfirmed.has(server.id))
@@ -459,6 +481,7 @@ function reconcileWidgetFromLspResult(file, rawDiags, confirmation, writeIndex,
 }
 async function collectFileDiagnosticResult(file, severity, lspService, waitMs, nextWriteIndex, serverScope = "all", cacheCtx, scopeKey, cwd = process.cwd(), onConfirmedNoBlockers) {
   const writeIndex = nextWriteIndex?.();
+  const scannedAt = Date.now();
   let stat;
   try {
     stat = fs.statSync(file);
@@ -527,6 +550,9 @@ async function collectFileDiagnosticResult(file, severity, lspService, waitMs, n
   const boundMismatch = binding?.boundToCurrentDisk === false;
   if (boundMismatch)
     confirmation = "unconfirmed";
+  const rootFallback = confirmation === "clean" ? await primaryRootFallback(file, cwd) : undefined;
+  if (rootFallback)
+    confirmation = "unconfirmed";
   if (unconfirmedServerIds.length > 0 && confirmation === "clean") {
     confirmation = "unconfirmed";
   }
@@ -534,7 +560,7 @@ async function collectFileDiagnosticResult(file, severity, lspService, waitMs, n
   const policy = applyProbeFindingPolicy(file, effectiveRawDiags, cwd, collectedContent, severity);
   effectiveRawDiags = policy.kept;
   const filteredDiags = applySeverityFilter(effectiveRawDiags, severity);
-  const verdict = reconcileWidgetFromLspResult(file, effectiveRawDiags, confirmation, writeIndex, cwd, collectedContent, boundMismatch);
+  const verdict = reconcileWidgetFromLspResult(file, effectiveRawDiags, confirmation, writeIndex, cwd, collectedContent, boundMismatch, scannedAt);
   if (verdict.confirmed && !verdict.blocking) {
     onConfirmedNoBlockers?.({
       filePath: file,
@@ -544,7 +570,7 @@ async function collectFileDiagnosticResult(file, severity, lspService, waitMs, n
     });
   }
   if (cacheCtx && scopeKey !== undefined && confirmation !== "unconfirmed" && diagnosticsUnsupportedServerIds.length === 0 && unconfirmedServerIds.length === 0) {
-    cacheCtx.record(file, scopeKey, policy.inlineKept, stat.mtimeMs, collectedContent !== undefined ? hashDiagnosticContent(collectedContent) : undefined, stat.size);
+    cacheCtx.record(file, scopeKey, policy.inlineKept, stat.mtimeMs, collectedContent !== undefined ? hashDiagnosticContent(collectedContent) : undefined, stat.size, scannedAt);
   }
   return {
     file,
@@ -552,6 +578,7 @@ async function collectFileDiagnosticResult(file, severity, lspService, waitMs, n
     unavailable: lspUnavailableMessage(file, health),
     confirmation,
     timedOut: confirmation === "unconfirmed" ? timedOut : undefined,
+    ...rootFallback && { rootFallback },
     ...skipReason !== undefined && { skipReason },
     primaryServerId: primaryServerId(file),
     diagnosticsUnsupported: diagnosticsUnsupportedServerIds.length > 0,
@@ -562,6 +589,7 @@ async function collectFileDiagnosticResult(file, severity, lspService, waitMs, n
 }
 async function runFileDiagnostics(absPath, severity, lspService, waitMs, nextWriteIndex, serverScope = "all", cwd = process.cwd(), onConfirmedNoBlockers) {
   const writeIndex = nextWriteIndex?.();
+  const observedAt = Date.now();
   const {
     diagnostics: rawDiags,
     timedOut,
@@ -614,6 +642,9 @@ async function runFileDiagnostics(absPath, severity, lspService, waitMs, nextWri
   const boundMismatch = binding?.boundToCurrentDisk === false;
   if (boundMismatch)
     confirmation = "unconfirmed";
+  const rootFallback = confirmation === "clean" ? await primaryRootFallback(absPath, cwd) : undefined;
+  if (rootFallback)
+    confirmation = "unconfirmed";
   const primaryCoverageGapOnly = unconfirmedServerIds.length > 0 && confirmation === "clean";
   if (primaryCoverageGapOnly)
     confirmation = "unconfirmed";
@@ -625,7 +656,7 @@ async function runFileDiagnostics(absPath, severity, lspService, waitMs, nextWri
   const truncated = total > MAX_DIAGNOSTICS;
   const limited = truncated ? filtered.slice(0, MAX_DIAGNOSTICS) : filtered;
   const unconfirmed = confirmation === "unconfirmed";
-  const verdict = reconcileWidgetFromLspResult(absPath, effectiveRawDiags, confirmation, writeIndex, cwd, collectedContent, boundMismatch);
+  const verdict = reconcileWidgetFromLspResult(absPath, effectiveRawDiags, confirmation, writeIndex, cwd, collectedContent, boundMismatch, observedAt);
   if (verdict.confirmed && !verdict.blocking) {
     onConfirmedNoBlockers?.({
       filePath: absPath,
@@ -644,6 +675,9 @@ async function runFileDiagnostics(absPath, severity, lspService, waitMs, nextWri
     if (timedOut) {
       return "Primary LSP: check timed out — NOT the same as 0 diagnostics; the " + "file may still have errors that just hadn't been reported yet. " + "Re-check after the server settles, or increase waitMs.";
     }
+    if (rootFallback) {
+      return `Primary LSP${primaryId ? ` (${primaryId})` : ""}: unconfirmed — ` + `${describeRootFallback(rootFallback)}. NOT the same as 0 diagnostics; ` + "check the file from inside its project and re-run.";
+    }
     if (unconfirmed && !primaryCoverageGapOnly) {
       return `Primary LSP${primaryId ? ` (${primaryId})` : ""}: unconfirmed — ` + "cannot confirm clean (push-only, silent-on-clean, e.g. classic " + "typescript-language-server never publishes on a clean re-check). " + "NOT the same as 0 diagnostics; re-check after an edit, or use " + "waitMs to wait longer.";
     }
@@ -713,6 +747,9 @@ async function runFileDiagnostics(absPath, severity, lspService, waitMs, nextWri
       timedOut: unconfirmed ? timedOut : undefined,
       navigationOnlyFiles: diagnosticsUnsupportedServerIds.length > 0 ? 1 : undefined,
       ...skipReason !== undefined && { skipReason },
+      ...rootFallback && {
+        rootFallbackReason: describeRootFallback(rootFallback)
+      },
       ...unconfirmedServerIds.length > 0 && {
         unconfirmedServerIds: [...unconfirmedServerIds]
       },
@@ -725,6 +762,7 @@ function tallyConfirmation(results) {
   let clean = 0;
   let unconfirmed = 0;
   let timedOut = 0;
+  const rootFallbackReasons = new Set;
   let navigationOnly = 0;
   let tooLarge = 0;
   for (const result of results) {
@@ -742,11 +780,21 @@ function tallyConfirmation(results) {
       unconfirmed += 1;
       if (result.timedOut)
         timedOut += 1;
-    } else {
+      if (result.rootFallback) {
+        rootFallbackReasons.add(describeRootFallback(result.rootFallback));
+      }
+    } else if (classifyBatchFileOutcome(result) === "clean") {
       clean += 1;
     }
   }
-  return { clean, unconfirmed, timedOut, navigationOnly, tooLarge };
+  return {
+    clean,
+    unconfirmed,
+    timedOut,
+    rootFallbackReasons: [...rootFallbackReasons],
+    navigationOnly,
+    tooLarge
+  };
 }
 function classifyBatchFileOutcome(result) {
   if (result.error)
@@ -777,7 +825,10 @@ function inconclusiveBatchResult(file, reason) {
     inconclusiveReason: reason
   };
 }
-function unconfirmedReasonClause(unconfirmed, timedOut) {
+function unconfirmedReasonClause(unconfirmed, timedOut, rootFallbackReasons = []) {
+  if (rootFallbackReasons.length > 0) {
+    return `${rootFallbackReasons.join("; ")} (${unconfirmed} unconfirmed in all).`;
+  }
   const silent = unconfirmed - timedOut;
   if (timedOut > 0 && silent > 0) {
     return `${timedOut} timed out (check didn't complete within budget) and ` + `${silent} from a server that cannot confirm clean (push-only, ` + "silent-on-clean).";
@@ -846,7 +897,7 @@ async function collectBatchDiagnostics(files, severity, lspService, options) {
   const total = allDiags.length;
   const truncated = total > MAX_DIAGNOSTICS;
   const display = truncated ? allDiags.slice(0, MAX_DIAGNOSTICS) : allDiags;
-  const { clean, unconfirmed, timedOut } = tallyConfirmation(results);
+  const { clean, unconfirmed, timedOut, rootFallbackReasons } = tallyConfirmation(results);
   for (const result of results) {
     result.outcome = classifyBatchFileOutcome(result);
   }
@@ -877,11 +928,53 @@ async function collectBatchDiagnostics(files, severity, lspService, options) {
     clean,
     unconfirmed,
     timedOut,
+    rootFallbackReasons,
     outcomeCounts,
     incompleteFiles: Math.max(0, files.length - results.length)
   };
 }
-async function runBatchFileDiagnostics(absPaths, severity, lspService, options) {
+async function expandPathsToFiles(cwd, rawPaths) {
+  const explicitFiles = [];
+  const directories = [];
+  const seenFileKeys = new Set;
+  for (const entry of rawPaths) {
+    const abs = normalizeMapKey(path.resolve(cwd, entry));
+    let stat;
+    try {
+      stat = fs.statSync(abs);
+    } catch {}
+    if (stat?.isDirectory()) {
+      directories.push(abs);
+    } else {
+      explicitFiles.push(abs);
+      seenFileKeys.add(abs);
+    }
+  }
+  const files = [...explicitFiles];
+  const directoriesWithoutFiles = [];
+  let capped = false;
+  for (const directory of directories) {
+    const collected = await collectDirectoryScanFiles(directory, MAX_FILES - files.length, seenFileKeys);
+    capped ||= collected.capped;
+    if (collected.eligible === 0)
+      directoriesWithoutFiles.push(directory);
+    for (const file of collected.files) {
+      const key = normalizeMapKey(file);
+      seenFileKeys.add(key);
+      files.push(key);
+    }
+  }
+  if (capped) {
+    recordDegradationOnce({
+      kind: "lsp-diagnostics-paths-cap",
+      subject: cwd,
+      reason: `paths directory expansion reached the ${MAX_FILES}-file cap; later entries were not checked`
+    });
+  }
+  return { files, directoriesWithoutFiles, capped };
+}
+async function runBatchFileDiagnostics(absPaths, severity, lspService, options, scan = { capped: false, directoriesWithoutFiles: [] }) {
+  const { capped, directoriesWithoutFiles } = scan;
   if (absPaths.length === 0) {
     return {
       content: [{ type: "text", text: "No file paths provided." }],
@@ -901,19 +994,23 @@ async function runBatchFileDiagnostics(absPaths, severity, lspService, options)
     clean,
     unconfirmed,
     timedOut,
+    rootFallbackReasons,
     outcomeCounts,
     incompleteFiles
   } = await collectBatchDiagnostics(absPaths, severity, lspService, options);
   const navigationOnly = results.filter((result) => result.diagnosticsUnsupported).length;
   const dispositionSuppressed = results.reduce((sum, result) => sum + (result.dispositionSuppressed ?? 0), 0);
   const lines = [
-    `Files checked: ${results.length}`,
+    `Files checked: ${results.length}${capped ? ` (capped at ${MAX_FILES})` : ""}`,
     `Total diagnostics: ${total}`,
     `Concurrency: ${options.concurrency}`
   ];
   if (options.waitMs !== undefined)
     lines.push(`Wait budget: ${options.waitMs}ms`);
   lines.push(`Outcomes: ${Object.entries(outcomeCounts).map(([outcome, count]) => `${outcome}=${count}`).join(", ")}`);
+  const { listed: emptyListed, text: emptyText } = describeDirectoriesWithoutFiles(directoriesWithoutFiles);
+  if (directoriesWithoutFiles.length > 0)
+    lines.push("", emptyText);
   const notConfirmed = outcomeCounts.inconclusive + outcomeCounts.unavailable + outcomeCounts.unsupported + outcomeCounts.failed + outcomeCounts.too_large + incompleteFiles;
   if (notConfirmed > 0) {
     lines.push("", `Checks not confirmed: ${notConfirmed} (inconclusive/unavailable/unsupported/failed or not started).`);
@@ -936,7 +1033,7 @@ async function runBatchFileDiagnostics(absPaths, severity, lspService, options)
     lines.push("", "LSP health warnings:", ...lspHealthWarnings.slice(0, 10));
   }
   if (unconfirmed > 0) {
-    lines.push("", `${clean} file${clean === 1 ? "" : "s"} confirmed clean, ${unconfirmed} unconfirmed: ` + `${unconfirmedReasonClause(unconfirmed, timedOut)} NOT the same as 0 diagnostics.`);
+    lines.push("", `${clean} file${clean === 1 ? "" : "s"} confirmed clean, ${unconfirmed} unconfirmed: ` + `${unconfirmedReasonClause(unconfirmed, timedOut, rootFallbackReasons)} NOT the same as 0 diagnostics.`);
   }
   if (display.length === 0) {
     if (unconfirmed === 0 && outcomeCounts.clean === results.length) {
@@ -966,6 +1063,8 @@ async function runBatchFileDiagnostics(absPaths, severity, lspService, options)
       severity,
       serverScope: options.serverScope ?? "all",
       filesChecked: results.length,
+      ...capped ? { capped: true } : {},
+      ...directoriesWithoutFiles.length > 0 ? { directoriesWithoutFiles: emptyListed } : {},
       concurrency: options.concurrency,
       waitMs: options.waitMs,
       diagnostics: display,
@@ -1001,19 +1100,36 @@ export async function resolveDirectoryScanExtensions(hasMatch) {
   }
   return;
 }
-async function runDirectoryDiagnostics(absPath, severity, lspService, options) {
-  let collectedFiles = [];
+async function collectDirectoryScanFiles(absPath, maxFiles, seen = new Set) {
   const isIgnored = projectIgnorePredicate(absPath);
+  let collectedFiles = [];
   await resolveDirectoryScanExtensions(async (exts) => {
-    collectedFiles = await collectFiles(absPath, [...exts], MAX_FILES + 1, isIgnored);
+    collectedFiles = await collectFiles(absPath, [...exts], maxFiles + seen.size + 1, isIgnored);
     return collectedFiles.length > 0;
   });
-  if (collectedFiles.length === 0) {
+  const fresh = collectedFiles.flatMap((file) => seen.has(normalizeMapKey(file)) ? [] : [file]);
+  return {
+    files: fresh.slice(0, maxFiles),
+    capped: fresh.length > maxFiles,
+    eligible: collectedFiles.length
+  };
+}
+function describeDirectoriesWithoutFiles(directories) {
+  const listed = directories.slice(0, 5);
+  const more = directories.length - listed.length;
+  return {
+    listed,
+    text: `No supported source files found in: ${listed.join(", ")}${more > 0 ? ` (+${more} more)` : ""}`
+  };
+}
+async function runDirectoryDiagnostics(absPath, severity, lspService, options) {
+  const { files: filesToProcess, capped: wasCapped } = await collectDirectoryScanFiles(absPath, MAX_FILES);
+  if (filesToProcess.length === 0) {
     return {
       content: [
         {
           type: "text",
-          text: `No supported source files found in: ${absPath}`
+          text: describeDirectoriesWithoutFiles([absPath]).text
         }
       ],
       details: {
@@ -1024,8 +1140,6 @@ async function runDirectoryDiagnostics(absPath, severity, lspService, options) {
       }
     };
   }
-  const wasCapped = collectedFiles.length > MAX_FILES;
-  const filesToProcess = collectedFiles.slice(0, MAX_FILES);
   const {
     results,
     fileErrors,
@@ -1038,6 +1152,7 @@ async function runDirectoryDiagnostics(absPath, severity, lspService, options) {
     clean,
     unconfirmed,
     timedOut,
+    rootFallbackReasons,
     outcomeCounts
   } = await collectBatchDiagnostics(filesToProcess, severity, lspService, options);
   const navigationOnly = results.filter((result) => result.diagnosticsUnsupported).length;
@@ -1051,7 +1166,7 @@ async function runDirectoryDiagnostics(absPath, severity, lspService, options) {
   const tooLargeLines = renderBatchOutcomeLines(outcomeDetails, (file) => path.relative(absPath, file));
   let text;
   if (total === 0) {
-    const cleanLine = unconfirmed > 0 ? `${clean} clean · ${unconfirmed} unconfirmed: ` + `${unconfirmedReasonClause(unconfirmed, timedOut)} NOT the same as 0 diagnostics.` : "No diagnostics found.";
+    const cleanLine = unconfirmed > 0 ? `${clean} clean · ${unconfirmed} unconfirmed: ` + `${unconfirmedReasonClause(unconfirmed, timedOut, rootFallbackReasons)} NOT the same as 0 diagnostics.` : "No diagnostics found.";
     text = [
       `Directory: ${absPath}`,
       `Files scanned: ${filesToProcess.length}${wasCapped ? ` (capped at ${MAX_FILES})` : ""}`,
@@ -1072,7 +1187,7 @@ async function runDirectoryDiagnostics(absPath, severity, lspService, options) {
       ...lspHealthWarnings.length > 0 ? ["", "LSP health warnings:", ...lspHealthWarnings.slice(0, 10)] : [],
       ...unconfirmed > 0 ? [
         "",
-        `${clean} other file${clean === 1 ? "" : "s"} confirmed clean, ${unconfirmed} unconfirmed: ` + unconfirmedReasonClause(unconfirmed, timedOut)
+        `${clean} other file${clean === 1 ? "" : "s"} confirmed clean, ${unconfirmed} unconfirmed: ` + unconfirmedReasonClause(unconfirmed, timedOut, rootFallbackReasons)
       ] : [],
       ""
     ];

package/extensions/dm-lens/tools/lsp-navigation.js

@@ -13,11 +13,14 @@ import { isRecordableProjectPath } from "../clients/file-utils.js";
 import { compactRenderResult } from "./render-compact.js";
 import {
   applyWorkspaceEdit,
-  summarizeWorkspaceEdit
+  refuseStaleWorkspaceEdit,
+  summarizeWorkspaceEdit,
+  workspaceEditTextPaths
 } from "../clients/lsp/edits.js";
+import { hashDiagnosticContent } from "../clients/lsp/diagnostic-binding.js";
 import {
   getLSPService
-} from "../clients/lsp/index.js";
+} from "../clients/lsp/capabilities.js";
 import { buildLspNavigationEnvelope } from "./lsp-structured-output.js";
 import { SYMBOL_KIND_NAMES } from "../clients/lsp-document-symbols.js";
 const VALID_OPERATIONS = [
@@ -504,8 +507,8 @@ async function openFileBestEffort(lspService, filePath, waitForDiagnostics = fal
   } catch {
     return;
   }
-  if (!fileContent)
-    return;
+  if (fileContent === "")
+    return "";
   try {
     await lspService.touchFile(filePath, fileContent, {
       diagnostics: waitForDiagnostics ? "document" : "none",
@@ -513,6 +516,52 @@ async function openFileBestEffort(lspService, filePath, waitForDiagnostics = fal
       clientScope: waitForDiagnostics ? "all" : "primary"
     });
   } catch {}
+  return fileContent;
+}
+const RENAME_MTIME_MARGIN_MS = 2000;
+function captureRenameExpectedContent(lspService, edit, cwd, targetFilePath, targetContent, requestedAtMs) {
+  const expected = new Map;
+  let targetRealPath;
+  if (targetContent !== undefined) {
+    try {
+      targetRealPath = nodeFs.realpathSync.native(targetFilePath);
+    } catch {
+      targetRealPath = undefined;
+    }
+  }
+  for (const diskPath of workspaceEditTextPaths(edit)) {
+    let realPath;
+    let content;
+    let mtimeMs;
+    try {
+      realPath = nodeFs.realpathSync.native(diskPath);
+      content = nodeFs.readFileSync(realPath, "utf-8");
+      mtimeMs = nodeFs.statSync(realPath).mtimeMs;
+    } catch {
+      continue;
+    }
+    if (targetContent !== undefined && realPath === targetRealPath) {
+      expected.set(realPath, targetContent);
+      continue;
+    }
+    const tracked = lspService.getTrackedContent(diskPath, cwd);
+    const firstOpenedAfterRequest = tracked !== undefined && (tracked.openedAtMs ?? 0) >= requestedAtMs;
+    const quietSinceClientStart = tracked?.clientStartedAtMs !== undefined && mtimeMs < tracked.clientStartedAtMs - RENAME_MTIME_MARGIN_MS;
+    const sent = firstOpenedAfterRequest && quietSinceClientStart ? undefined : tracked;
+    if (sent !== undefined) {
+      if (sent.hash !== hashDiagnosticContent(content) || (sent.changedAtMs ?? requestedAtMs) >= requestedAtMs) {
+        refuseStaleWorkspaceEdit(diskPath, "it changed after the language server computed the rename from it");
+      }
+    } else if (tracked !== undefined && (tracked.hash !== hashDiagnosticContent(content) || tracked.openedHash !== tracked.hash)) {
+      refuseStaleWorkspaceEdit(diskPath, "it changed after the language client first opened it, after the rename was requested");
+    } else if (mtimeMs >= requestedAtMs) {
+      refuseStaleWorkspaceEdit(diskPath, "it was written after the rename was requested and the language server has no open copy, so it may not have read these bytes");
+    } else if (mtimeMs >= requestedAtMs - RENAME_MTIME_MARGIN_MS) {
+      refuseStaleWorkspaceEdit(diskPath, `it was modified within ${RENAME_MTIME_MARGIN_MS / 1000} s of the rename request; retry`);
+    }
+    expected.set(realPath, content);
+  }
+  return expected;
 }
 export function createLspNavigationTool(getFlag, mutationDeps) {
   return {
@@ -611,10 +660,13 @@ export function createLspNavigationTool(getFlag, mutationDeps) {
       }, {}))
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const session = mutationDeps?.runtime?.captureSessionGeneration?.();
       const startedAt = Date.now();
       let supported = null;
       let diagnosticsMode = "unknown";
       let columnResolution;
+      let openedFileContent;
+      let renameRequestedAtMs = 0;
       let mutationContext;
       let requestedApply = false;
       const workspaceScopeAttribution = {};
@@ -727,10 +779,13 @@ export function createLspNavigationTool(getFlag, mutationDeps) {
         const mutationSource = operation === "executeCommand" ? "lsp-execute-command" : "lsp-rename";
         mutationContext = {
           cwd,
+          sessionId: ctx.sessionManager?.getSessionId?.(),
           correlationId: newLspMutationCorrelationId(_toolCallId),
+          toolCallId: _toolCallId,
           tool: `lsp_navigation:${operation}`,
           source: mutationSource,
           ...mutationDeps,
+          session,
           readGuard: getFlag("no-read-guard", cwd) ? undefined : mutationDeps?.readGuard,
           isRecordable: (filePath) => {
             return isRecordableProjectPath(filePath, mutationDeps?.runtime?.projectRoot ?? cwd);
@@ -921,7 +976,7 @@ ${JSON.stringify(result)}`
             }
           }, { operation, filePath, failureKind: "unsupported", resultCount: 0 });
         }
-        await openFileBestEffort(lspService, filePath);
+        openedFileContent = await openFileBestEffort(lspService, filePath);
       }
       const lspLine = (line ?? 1) - 1;
       const needsPosition = [
@@ -1008,6 +1063,7 @@ ${JSON.stringify(result)}`
             if (!newName || newName.trim().length === 0) {
               throw new Error("__BADINPUT__ newName parameter required for rename");
             }
+            renameRequestedAtMs = Date.now();
             const edit = await lspService.rename(filePath, lspLine, lspChar, newName);
             if (!edit)
               return null;
@@ -1019,7 +1075,8 @@ ${JSON.stringify(result)}`
               };
             }
             const applied = await applyWorkspaceEdit(edit, ctx.cwd || ".", {
-              mutationContext
+              mutationContext,
+              expectedContent: captureRenameExpectedContent(lspService, edit, ctx.cwd || ".", filePath, openedFileContent, renameRequestedAtMs)
             });
             for (const touchedFile of applied.files) {
               try {
@@ -1113,7 +1170,7 @@ ${JSON.stringify(result)}`
           "implementation"
         ].includes(operation);
         if (shouldRetryOnEmpty) {
-          await openFileBestEffort(lspService, filePath, true);
+          openedFileContent = await openFileBestEffort(lspService, filePath, true);
           result = await runOperation();
         }
         const stillEmpty = !result || Array.isArray(result) && result.length === 0;

package/extensions/dm-lens/tools/module-report.js

@@ -104,7 +104,7 @@ export function createModuleReportTool(getProjectRoot) {
     }
   };
 }
-function recordReadCoverage(recordSymbolRead, result, phase) {
+function recordReadCoverage(recordSymbolRead, result, phase, toolCallId) {
   if (!result.name || !result.kind || typeof result.startLine !== "number" || typeof result.endLine !== "number") {
     return false;
   }
@@ -114,7 +114,7 @@ function recordReadCoverage(recordSymbolRead, result, phase) {
       kind: result.kind,
       startLine: result.startLine,
       endLine: result.endLine
-    });
+    }, toolCallId);
     return true;
   } catch (err) {
     logLatency({
@@ -153,7 +153,7 @@ export function createReadSymbolTool(getProjectRoot, recordSymbolRead) {
         description: "Optional kind filter (e.g. function, interface, class) to disambiguate when multiple same-file symbols share the requested name. Omitting it returns the first match, same as today."
       }))
     }),
-    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+    async execute(toolCallId, params, _signal, _onUpdate, ctx) {
       const absFile = resolveFile(params.path, ctx.cwd);
       const cwd = getProjectRoot() || ctx.cwd || ".";
       let result;
@@ -188,7 +188,7 @@ export function createReadSymbolTool(getProjectRoot, recordSymbolRead) {
           }
         };
       }
-      const readRecorded = recordReadCoverage(recordSymbolRead, result, "read_symbol_guard_error");
+      const readRecorded = recordReadCoverage(recordSymbolRead, result, "read_symbol_guard_error", toolCallId);
       const ambiguityNote = result.ambiguous ? ` (${result.ambiguous.count} matches — returned the ${result.kind}; pass \`kind\` to disambiguate: ${result.ambiguous.kinds.join(", ")})` : "";
       const header = `${result.kind} ${result.name}${ambiguityNote}  ${path.basename(result.path)}:${result.startLine}-${result.endLine}`;
       const guardWarning = readRecorded ? "" : `
@@ -252,7 +252,7 @@ export function createReadEnclosingTool(getProjectRoot, recordSymbolRead) {
         description: "Maximum lines for onOversize=slice; defaults to maxLines, then 80."
       }))
     }),
-    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+    async execute(toolCallId, params, _signal, _onUpdate, ctx) {
       const absFile = resolveFile(params.path, ctx.cwd);
       const cwd = getProjectRoot() || ctx.cwd || ".";
       let result;
@@ -301,7 +301,7 @@ ${JSON.stringify(result.outline)}` : "";
           }
         };
       }
-      const readRecorded = recordReadCoverage(recordSymbolRead, result, "read_enclosing_guard_error");
+      const readRecorded = recordReadCoverage(recordSymbolRead, result, "read_enclosing_guard_error", toolCallId);
       const range = result.partial ? `${result.startLine}-${result.endLine} (partial of ${result.enclosingStartLine}-${result.enclosingEndLine})` : `${result.startLine}-${result.endLine}`;
       const header = `${result.kind} ${result.name}  ${path.basename(result.path)}:${range}`;
       const guardWarning = readRecorded ? "" : `

package/extensions/dm-lens/tools/shared.js

@@ -1,3 +1,9 @@
+import { resolveHostToolPath } from "../clients/path-utils.js";
+export function resolveAstGrepPaths(paths, cwd) {
+  const base = cwd || ".";
+  const requested = paths?.length ? paths : [base];
+  return requested.map((p) => resolveHostToolPath(p, base));
+}
 export const LANGUAGES = [
   "bash",
   "c",

package/extensions/dm-mcp-adapter/THIRD_PARTY_NOTICES.md

@@ -1,4 +1,4 @@
 # Third-party notice
 
-This managed extension is adapted from `nicobailon/pi-mcp-adapter` at `7bf2332932b652416ea717e154352baed7420b66` (upstream tag `v2.37.0`) under MIT.
+This managed extension is adapted from `nicobailon/pi-mcp-adapter` at `4b08a153da1e8bd557b549e17cc01196639a25b0` under MIT.
 The upstream package name and repository are retained solely as technical provenance.