@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

package/extensions/dm-lens/clients/lsp/service-singleton.js

@@ -0,0 +1,59 @@
+import { getProcessSingleton } from "../process-singletons.js";
+import { clearWorkspaceSweepHoldForSessionStart } from "./workspace-sweep-hold.js";
+const LSP_SERVICE_FAMILY = "lsp.service";
+const LSP_SERVICE_VERSION = 2;
+function state() {
+  return getProcessSingleton(LSP_SERVICE_FAMILY, LSP_SERVICE_VERSION, () => ({
+    service: null,
+    generationHandoff: undefined,
+    lifecycle: undefined
+  }), (value) => {
+    const previous = value;
+    const service = previous.service;
+    if (!service || typeof service.shutdown !== "function")
+      return;
+    Promise.resolve(service.shutdown({
+      fast: true,
+      reason: "process_singleton_reset"
+    })).catch(() => {
+      return;
+    });
+  });
+}
+export function configureLspServiceLifecycle(lifecycle) {
+  state().lifecycle = lifecycle;
+}
+export function getOwnedLspService() {
+  const current = state();
+  if (!current.lifecycle) {
+    throw new Error("LSP service lifecycle is not configured");
+  }
+  if (!current.service) {
+    current.service = current.lifecycle.create(current.generationHandoff);
+  }
+  return current.service;
+}
+export function peekOwnedLspService() {
+  return state().service ?? undefined;
+}
+export function resetOwnedLspService(options = {}) {
+  const current = state();
+  if (options.reason === "session_start") {
+    clearWorkspaceSweepHoldForSessionStart();
+  }
+  current.lifecycle?.beforeReset(options);
+  const retiringService = current.service;
+  current.service = null;
+  if (!retiringService || !current.lifecycle)
+    return;
+  const teardown = current.lifecycle.destroy(retiringService, options);
+  const pending = current.generationHandoff ? [current.generationHandoff, teardown] : [teardown];
+  const handoff = Promise.allSettled(pending).then(() => {
+    return;
+  });
+  current.generationHandoff = handoff;
+  handoff.then(() => {
+    if (current.generationHandoff === handoff)
+      current.generationHandoff = undefined;
+  });
+}

package/extensions/dm-lens/clients/lsp/session-roots.js

@@ -10,7 +10,7 @@ function noteEvictedRoots(evicted) {
     incrementDegradationCount({
       kind: "lsp-session-root-evicted",
       subject: `cap=${SESSION_ROOT_CAP}`,
-      reason: `session root registry at capacity; dropped ${roots[0]} and will load it again on the next session start or tool call naming that root`
+      reason: `session root registry at capacity; will load the dropped root again on the next session start or tool call naming it (dropped: ${roots[0]})`
     });
   }
   return roots;

package/extensions/dm-lens/clients/lsp/wait-policy/classification.js

@@ -1,4 +1,5 @@
 import { getServersForFileWithConfig } from "../config.js";
+import { isAuxiliary } from "../server-traits.js";
 import { getStrategy } from "./strategies.js";
 export function classifyServerWaitTier(serverId, snapshot) {
   if (!snapshot)
@@ -19,7 +20,7 @@ export function classifyServerWaitTier(serverId, snapshot) {
   return "tier3-silent";
 }
 export function resolvePrimaryServerForWaitPolicy(filePath, snapshots) {
-  const servers = getServersForFileWithConfig(filePath).filter((s) => s.role !== "auxiliary");
+  const servers = getServersForFileWithConfig(filePath).filter((s) => !isAuxiliary(s));
   const primary = servers[0];
   if (!primary)
     return;

package/extensions/dm-lens/clients/lsp/wait-policy/strategies.js

@@ -39,11 +39,12 @@ export function resolveAstGrepNativeExe(platform = process.platform, arch = proc
 }
 export const SERVER_DIAGNOSTIC_STRATEGIES = {
   typescript: {
-    seedFirstPush: true,
+    seedFirstPush: false,
     pullRetryBudgetMs: 0,
     debounceMs: 50,
     aggregateWaitMs: 1000,
     expectSemanticSecondPush: false,
+    emptyFirstPublish: "indexing",
     silentOnClean: true
   },
   "rust-analyzer": {
@@ -80,7 +81,8 @@ export const SERVER_DIAGNOSTIC_STRATEGIES = {
     debounceMs: 250,
     aggregateWaitMs: 3500,
     expectSemanticSecondPush: false,
-    reopenOnResync: true
+    reopenOnResync: true,
+    rescansOnSave: true
   },
   "ast-grep": {
     seedFirstPush: false,
@@ -96,7 +98,8 @@ export const SERVER_DIAGNOSTIC_STRATEGIES = {
     debounceMs: 150,
     aggregateWaitMs: 2000,
     expectSemanticSecondPush: false,
-    reopenOnResync: false
+    reopenOnResync: false,
+    rescansOnSave: true
   },
   typos: {
     seedFirstPush: true,
@@ -104,7 +107,8 @@ export const SERVER_DIAGNOSTIC_STRATEGIES = {
     debounceMs: 150,
     aggregateWaitMs: 1500,
     expectSemanticSecondPush: false,
-    reopenOnResync: false
+    reopenOnResync: false,
+    publishesOnClose: true
   },
   marksman: {
     seedFirstPush: false,
@@ -122,8 +126,25 @@ export const SERVER_DIAGNOSTIC_STRATEGIES = {
     debounceMs: 150,
     aggregateWaitMs: 8000,
     expectSemanticSecondPush: false,
+    emptyFirstPublish: "indexing",
+    diagnosticsFence: "reply-first"
+  },
+  terraform: {
+    seedFirstPush: false,
+    pullRetryBudgetMs: 0,
+    debounceMs: 150,
+    aggregateWaitMs: 1500,
+    expectSemanticSecondPush: false,
     emptyFirstPublish: "indexing"
   },
+  yaml: {
+    seedFirstPush: false,
+    pullRetryBudgetMs: 250,
+    debounceMs: 150,
+    aggregateWaitMs: 1500,
+    expectSemanticSecondPush: false,
+    diagnosticsFence: "reply-first"
+  },
   svelte: {
     seedFirstPush: false,
     pullRetryBudgetMs: 0,

package/extensions/dm-lens/clients/lsp/workspace-diagnostics-cache.js

@@ -233,13 +233,12 @@ export function createWorkspaceDiagnosticsCacheContext(cwd) {
         scannedAt: entry.scannedAt
       };
     },
-    record(filePath, scopeKey, diagnostics, mtimeMs, contentHash, sizeBytes) {
-      const scanGeneration = Date.now();
+    record(filePath, scopeKey, diagnostics, mtimeMs, contentHash, sizeBytes, scannedAt = Date.now()) {
       entries[cacheKeyFor(filePath)] = {
         diagnostics,
         count: diagnostics.length,
         mtimeMs,
-        scannedAt: scanGeneration,
+        scannedAt,
         scopeKey,
         depIndexAtScan: hasDepKnowledge(filePath),
         ...contentHash !== undefined && { contentHash },
@@ -247,6 +246,10 @@ export function createWorkspaceDiagnosticsCacheContext(cwd) {
       };
       dirty = true;
     },
+    forget(filePath) {
+      delete entries[cacheKeyFor(filePath)];
+      dirty = true;
+    },
     persist() {
       flushExpiryTelemetry();
       if (!dirty)

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

@@ -4,6 +4,7 @@ import {
 } from "./instance-registry.js";
 import { realIsPidAlive, STALE_HEARTBEAT_MS } from "./instance-reaper.js";
 import { logLatency } from "./latency-logger.js";
+import { isInPidNamespace, ownPidNamespace } from "./process-snapshot.js";
 export const DEFAULT_LSP_BUDGET_CEILING = 16;
 export const DEFAULT_LSP_BUDGET_IDLE_TIMEOUT_MS = 60000;
 export function isCrossProcessBudgetEnabled() {
@@ -21,12 +22,15 @@ export function getLspBudgetIdleTimeoutMs() {
   const raw = Number(process.env.DM_LENS_LSP_BUDGET_IDLE_TIMEOUT_MS);
   return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_LSP_BUDGET_IDLE_TIMEOUT_MS;
 }
-export function decideLspBudget(registry, isPidAlive, ceiling, rssCeilingBytes, now = Date.now()) {
-  const liveInstances = registry.filter((instance) => isPidAlive(instance.pid));
+export function decideLspBudget(registry, isPidAlive, ceiling, rssCeilingBytes, now = Date.now(), ownNamespace) {
+  const hasFreshHeartbeat = (instance) => {
+    const heartbeatMs = Date.parse(instance.heartbeatAt);
+    return Number.isFinite(heartbeatMs) && now - heartbeatMs <= STALE_HEARTBEAT_MS;
+  };
+  const liveInstances = registry.filter((instance) => isInPidNamespace(instance, ownNamespace) ? isPidAlive(instance.pid) : hasFreshHeartbeat(instance));
   const totalLiveLspServers = liveInstances.reduce((sum, instance) => sum + instance.lspChildren.length, 0);
   const hasCompleteFreshSamples = rssCeilingBytes !== undefined && liveInstances.length > 0 && liveInstances.every((instance) => {
-    const heartbeatMs = Date.parse(instance.heartbeatAt);
-    return Number.isFinite(heartbeatMs) && now - heartbeatMs <= STALE_HEARTBEAT_MS && Number.isFinite(instance.rssBytes) && instance.lspChildren.every((child) => Number.isFinite(child.rssBytes));
+    return hasFreshHeartbeat(instance) && Number.isFinite(instance.rssBytes) && instance.lspChildren.every((child) => Number.isFinite(child.rssBytes));
   });
   const totalRssBytes = hasCompleteFreshSamples ? liveInstances.reduce((sum, instance) => sum + instance.rssBytes + instance.lspChildren.reduce((childSum, child) => childSum + (child.rssBytes ?? 0), 0), 0) : undefined;
   const rssPressure = totalRssBytes !== undefined && rssCeilingBytes !== undefined && totalRssBytes >= rssCeilingBytes;
@@ -64,7 +68,7 @@ export async function checkCrossProcessLspBudget(testOverrides = {}) {
     if (registry.length === 0)
       return;
     const ceiling = getLspBudgetCeiling();
-    const decision = decideLspBudget(registry, testOverrides.isPidAlive ?? realIsPidAlive, ceiling, getLspBudgetRssCeilingBytes());
+    const decision = decideLspBudget(registry, testOverrides.isPidAlive ?? realIsPidAlive, ceiling, getLspBudgetRssCeilingBytes(), Date.now(), ownPidNamespace());
     cachedDecision = decision;
     if (decision.overBudget) {
       logLatency({

package/extensions/dm-lens/clients/lsp-document-symbols.js

@@ -1,4 +1,4 @@
-import { getLSPService } from "./lsp/index.js";
+import { getLSPService } from "./lsp/capabilities.js";
 const LSP_DOCUMENT_SYMBOL_TIMEOUT_MS = 150;
 export const SYMBOL_KIND_NAMES = {
   1: "file",

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

@@ -1,5 +1,5 @@
 import { createLazyImport } from "./lazy-import.js";
-const lazyLsp = createLazyImport(() => import("./lsp/index.js"));
+const lazyLsp = createLazyImport(() => import("./lsp/capabilities.js"));
 export function warmLspService() {
   return lazyLsp.get();
 }

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

@@ -80,7 +80,10 @@ function uniqueDetails(files, fileDetails) {
     const key = keyFor(detail.filePath);
     const previous = byPath.get(key);
     if (!previous) {
-      byPath.set(key, detail);
+      byPath.set(key, {
+        ...detail,
+        ranges: detail.ranges ?? (detail.range ? [detail.range] : undefined)
+      });
       continue;
     }
     byPath.set(key, {
@@ -89,12 +92,18 @@ function uniqueDetails(files, fileDetails) {
         start: Math.min(previous.range.start, detail.range.start),
         end: Math.max(previous.range.end, detail.range.end)
       } : previous.range ?? detail.range,
+      ranges: [
+        ...previous.ranges ?? (previous.range ? [previous.range] : []),
+        ...detail.ranges ?? (detail.range ? [detail.range] : [])
+      ],
+      authorshipUnknown: previous.authorshipUnknown === true || detail.authorshipUnknown === true,
       importsChanged: previous.importsChanged || detail.importsChanged
     });
   }
   return files.map((filePath) => byPath.get(keyFor(filePath)) ?? {
     filePath,
     range: { start: 1, end: 1 },
+    authorshipUnknown: true,
     importsChanged: true
   });
 }
@@ -103,13 +112,25 @@ function bookkeepLspMutation(context, files, fileDetails) {
   const useBridgeFallback = !context.runtime || !context.cacheManager;
   for (const detail of details) {
     const filePath = path.resolve(detail.filePath);
+    const sessionLive = !context.session || context.session.guardedWrite(filePath, () => true) !== undefined;
     if (context.isRecordable && !context.isRecordable(filePath)) {
       context.dbg?.(`lsp mutation not recordable, skipping ${filePath}`);
       continue;
     }
-    if (context.readGuard) {
+    if (sessionLive && context.readGuard) {
       try {
-        context.readGuard.recordWritten(filePath);
+        context.readGuard.recordWritten(filePath, {
+          stampFileTime: false,
+          advanceAuthorship: true,
+          ...detail.authorshipUnknown !== true && detail.ranges !== undefined && {
+            authorship: "partial",
+            authoredRanges: detail.ranges.map(({ start, end }) => [start, end])
+          },
+          ...detail.authorshipUnknown === true && { authorship: "unknown" },
+          ...context.toolCallId !== undefined && {
+            toolCallId: context.toolCallId
+          }
+        });
       } catch (err) {
         context.dbg?.(`lsp mutation read-guard stamp failed for ${filePath}: ${err}`);
       }
@@ -128,13 +149,28 @@ function bookkeepLspMutation(context, files, fileDetails) {
         }
       } else {
         try {
+          const editRanges = detail.ranges && detail.authorshipUnknown !== true ? detail.ranges.map(({ start, end }) => [start, end]) : detail.range && detail.authorshipUnknown !== true ? [[detail.range.start, detail.range.end]] : undefined;
           const recorded = bridge.recordMutation({
             filePath,
             kind: "edit",
-            editRanges: detail.range ? [[detail.range.start, detail.range.end]] : undefined,
+            ...detail.range !== undefined && {
+              touchedLines: [detail.range.start, detail.range.end]
+            },
+            ...detail.authorshipUnknown === true && {
+              authorshipUnknown: true
+            },
+            ...editRanges !== undefined ? { editRanges } : {},
+            ...context.sessionId !== undefined && {
+              sessionId: context.sessionId
+            },
             consumer: context.tool,
+            provenance: "observed",
             importsChanged: detail.importsChanged ?? true,
-            deferAutofix: false
+            deferAutofix: false,
+            ...context.session && { lineage: context.session },
+            ...context.toolCallId !== undefined && {
+              toolCallId: context.toolCallId
+            }
           });
           if (!recorded) {
             context.dbg?.(`lsp mutation bridge dropped ${filePath} (recordMutation() ` + "returned false — see the mutation_bridge debug output " + "for the reason: malformed entry, out-of-scope path, or " + "a bookkeeping error)");
@@ -152,16 +188,16 @@ function bookkeepLspMutation(context, files, fileDetails) {
         changedRange: detail.range,
         onAppendError: (err) => context.dbg?.(`lsp mutation project change append failed for ${filePath}: ${err}`)
       });
-      if (context.cacheManager) {
+      if (sessionLive && context.cacheManager) {
         try {
-          context.cacheManager.addModifiedRange(filePath, detail.range ?? { start: 1, end: 1 }, detail.importsChanged ?? true, context.cwd, runtime?.telemetrySessionId, undefined, runtime?.projectRoot ?? context.cwd);
+          context.cacheManager.addModifiedRange(filePath, detail.range ?? { start: 1, end: 1 }, detail.importsChanged ?? true, context.cwd, context.sessionId ?? runtime?.telemetrySessionId, undefined, runtime?.projectRoot ?? context.cwd);
         } catch (err) {
           context.dbg?.(`lsp mutation modified-range tracking failed for ${filePath}: ${err}`);
         }
       }
       noteMutationHandled(filePath);
     }
-    if (context.recordAutofix && context.source === "autofix") {
+    if (sessionLive && context.recordAutofix && context.source === "autofix") {
       const key = normalizeMapKey(filePath);
       const seen = context.autofixRecordedPaths ?? new BoundedSet(MAX_SAMPLES);
       context.autofixRecordedPaths = seen;

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

@@ -1,13 +1,11 @@
 import { getFileKindsForExtension } from "./file-kinds.js";
-import { LSP_SERVERS } from "./lsp/server.js";
-function serverById(id) {
-  return LSP_SERVERS.find((s) => s.id === id);
-}
+import { getServerById, LSP_SERVERS } from "./lsp/server.js";
+import { isAuxiliary } from "./lsp/server-traits.js";
 export function selectLspStatus(aliveServerIds, failedServerIds, sessionKinds) {
   const aliveSet = new Set(aliveServerIds);
   const aliveLangExts = new Set;
   for (const s of LSP_SERVERS) {
-    if (s.role === "auxiliary" || !aliveSet.has(s.id))
+    if (isAuxiliary(s) || !aliveSet.has(s.id))
       continue;
     for (const ext of s.extensions)
       aliveLangExts.add(ext.toLowerCase());
@@ -19,8 +17,8 @@ export function selectLspStatus(aliveServerIds, failedServerIds, sessionKinds) {
     if (seen.has(id))
       continue;
     seen.add(id);
-    const server = serverById(id);
-    if (!server || server.role === "auxiliary")
+    const server = getServerById(id);
+    if (!server || isAuxiliary(server))
       continue;
     const exts = server.extensions.map((e) => e.toLowerCase());
     if (exts.some((e) => aliveLangExts.has(e)))

package/extensions/dm-lens/clients/mcp/analyze.js

@@ -1,15 +1,15 @@
+import { resolveAnalysisRoot } from "../analysis-root.js";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { CacheManager, MCP_TURN_STATE_OWNER_ID } from "../cache-manager.js";
 import {
   CASCADE_GRAPH_KINDS,
-  dispatchLintWithResult,
-  getLatencyReports
+  dispatchLintWithResult
 } from "../dispatch/integration.js";
 import { FactStore } from "../dispatch/fact-store.js";
 import { detectFileKind } from "../file-kinds.js";
 import { getDiagnosticTracker } from "../diagnostic-tracker.js";
-import { getLSPService } from "../lsp/index.js";
+import { getLSPService } from "../lsp/capabilities.js";
 import { PathKeyedMap } from "../path-keyed-map.js";
 import { normalizeMapKey } from "../path-utils.js";
 import { loadProjectSnapshot } from "../project-snapshot.js";
@@ -133,6 +133,13 @@ export function summarizeWarningTiers(warnings) {
   }
   return { warnings: warnings.length - advisories, advisories };
 }
+function listDiagnosticsForCounts(result) {
+  const listedIds = new Set(result.diagnostics.map((d) => d.id));
+  return [
+    ...result.diagnostics,
+    ...result.warnings.filter((w) => !listedIds.has(w.id))
+  ];
+}
 function toMcpDiagnostic(diagnostic) {
   return {
     line: diagnostic.line,
@@ -173,17 +180,19 @@ async function warmLspForFile(absPath, host) {
 export async function analyzeFile(filePath, cwd, options = {}) {
   const absPath = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
   const host = createMcpHost({ "no-delta": true, ...options.flags }, cwd);
+  const observedAt = Date.now();
   if (options.warmLsp !== false) {
     await warmLspForFile(absPath, host);
   }
-  const reportsBefore = getLatencyReports().length;
   const start = Date.now();
   const result = await dispatchLintWithResult(absPath, cwd, host, undefined, undefined, {
-    blockingOnly: options.blockingOnly ?? false
+    blockingOnly: options.blockingOnly ?? false,
+    analysisRootMode: resolveAnalysisRoot(absPath, cwd),
+    dedupeCoverageNotice: false
   });
   const durationMs = Date.now() - start;
   if (options.record !== false) {
-    recordDiagnostics(normalizeMapKey(absPath), result.diagnostics);
+    recordDiagnostics(normalizeMapKey(absPath), result.diagnostics, undefined, observedAt);
     if (result.diagnostics.length > 0) {
       getDiagnosticTracker().trackShown(result.diagnostics);
     }
@@ -224,12 +233,15 @@ export async function analyzeFile(filePath, cwd, options = {}) {
       warmLease.release();
     }
   }
-  const newReports = getLatencyReports().slice(reportsBefore);
-  const latencyReport = newReports.find((report) => path.resolve(report.filePath) === absPath) ?? newReports[newReports.length - 1];
+  const latencyReport = result.latencyReport;
+  const listedDiagnostics = listDiagnosticsForCounts(result);
   const lspRunner = latencyReport?.runners.find((runner) => runner.runnerId === "lsp");
   const lsp = lspRunner ? {
     ran: lspRunner.status !== "skipped" && lspRunner.status !== "when_skipped" && lspRunner.status !== "test_file_skipped",
     status: lspRunner.status,
+    ...lspRunner.failureKind !== undefined && {
+      failureKind: lspRunner.failureKind
+    },
     diagnosticCount: lspRunner.diagnosticCount,
     durationMs: lspRunner.durationMs
   } : undefined;
@@ -240,13 +252,13 @@ export async function analyzeFile(filePath, cwd, options = {}) {
     durationMs,
     hasBlockers: result.hasBlockers,
     counts: {
-      diagnostics: result.diagnostics.length,
+      diagnostics: listedDiagnostics.length,
       blockers: result.blockers.length,
       ...summarizeWarningTiers(result.warnings),
       fixed: result.fixed.length
     },
     lsp,
-    diagnostics: result.diagnostics.map(toMcpDiagnostic),
+    diagnostics: listedDiagnostics.map(toMcpDiagnostic),
     latency: latencyReport ? {
       totalDurationMs: latencyReport.totalDurationMs,
       stoppedEarly: latencyReport.stoppedEarly,
@@ -254,7 +266,8 @@ export async function analyzeFile(filePath, cwd, options = {}) {
         runnerId: runner.runnerId,
         durationMs: runner.durationMs,
         status: runner.status,
-        diagnosticCount: runner.diagnosticCount
+        diagnosticCount: runner.diagnosticCount,
+        failureKind: runner.failureKind
       }))
     } : undefined
   };

package/extensions/dm-lens/clients/mcp/ipc.js

@@ -153,9 +153,13 @@ export function readTurnEndStatus(cwd, platform = process.platform) {
     return {
       ran: typeof parsed.ran === "number" ? parsed.ran : 0,
       skipped: typeof parsed.skipped === "number" ? parsed.skipped : 0,
+      failed: typeof parsed.failed === "number" ? parsed.failed : 0,
       lastSkipReason: parsed.lastSkipReason,
       lastRunAt: parsed.lastRunAt,
-      lastSkipAt: parsed.lastSkipAt
+      lastSkipAt: parsed.lastSkipAt,
+      lastFailureOperation: parsed.lastFailureOperation,
+      lastFailureReason: parsed.lastFailureReason,
+      lastFailureAt: parsed.lastFailureAt
     };
   } catch {
     return;
@@ -164,13 +168,28 @@ export function readTurnEndStatus(cwd, platform = process.platform) {
 export function recordTurnEndOutcome(cwd, outcome, platform = process.platform) {
   try {
     const now = new Date().toISOString();
-    const previous = readTurnEndStatus(cwd, platform) ?? { ran: 0, skipped: 0 };
-    const next = outcome.ran ? { ...previous, ran: previous.ran + 1, lastRunAt: now } : {
-      ...previous,
-      skipped: previous.skipped + 1,
-      lastSkipReason: outcome.reason,
-      lastSkipAt: now
+    const previous = readTurnEndStatus(cwd, platform) ?? {
+      ran: 0,
+      skipped: 0,
+      failed: 0
     };
+    let next;
+    if ("failed" in outcome) {
+      next = {
+        ...previous,
+        failed: previous.failed + 1,
+        lastFailureOperation: outcome.operation,
+        lastFailureReason: outcome.reason,
+        lastFailureAt: now
+      };
+    } else {
+      next = outcome.ran ? { ...previous, ran: previous.ran + 1, lastRunAt: now } : {
+        ...previous,
+        skipped: previous.skipped + 1,
+        lastSkipReason: outcome.reason,
+        lastSkipAt: now
+      };
+    }
     writeFileAtomic(turnEndStatusPathForCwd(cwd, platform), `${JSON.stringify(next)}
 `);
   } catch {}

package/extensions/dm-lens/clients/mcp/session.js

@@ -12,7 +12,7 @@ import {
 } from "../cache-manager.js";
 import { resetDispatchBaselines } from "../dispatch/integration.js";
 import { resetFormatService } from "../format-service.js";
-import { getLSPService, resetLSPService } from "../lsp/index.js";
+import { getLSPService, resetLSPService } from "../lsp/capabilities.js";
 import {
   acknowledgeTestFindings,
   acknowledgeTurnEndFindings,

package/extensions/dm-lens/clients/memory-sampler.js

@@ -1,12 +1,40 @@
+import { PerformanceObserver, constants, performance } from "node:perf_hooks";
+import { getWordIndexWireBytes } from "./word-index.js";
 import {
   countPostingEntries,
   estimateWordIndexStoreBytes
 } from "./word-index-store.js";
 import { getSharedTreeSitterClient } from "./tree-sitter-shared.js";
-import { getReviewGraphWorkspaceCacheSnapshot } from "./review-graph/builder.js";
+import {
+  getReviewGraphPersistWorkerHeapStatistics,
+  getReviewGraphWorkspaceCacheSnapshot,
+  refreshReviewGraphPersistWorkerHeapStatistics
+} from "./review-graph/builder.js";
+import {
+  getProjectSnapshotPersistWorkerHeapStatistics,
+  refreshProjectSnapshotPersistWorkerHeapStatistics
+} from "./project-snapshot.js";
 import { getDispatchCascadeCacheStats } from "./dispatch/integration.js";
 import { getLspDocumentTextRetentionSnapshot } from "./lsp/client.js";
 export const MEMORY_SAMPLE_TURN_INTERVAL = 10;
+const MAJOR_GC_KIND = constants.NODE_PERFORMANCE_GC_MAJOR;
+let settledHeapUsedBytes = null;
+let majorGcCount = 0;
+function recordMajorGc() {
+  settledHeapUsedBytes = process.memoryUsage().heapUsed;
+  majorGcCount += 1;
+}
+try {
+  const gcObserver = new PerformanceObserver((list) => {
+    for (const entry of list.getEntries()) {
+      const detail = entry.detail;
+      if (detail?.kind === MAJOR_GC_KIND) {
+        recordMajorGc();
+      }
+    }
+  });
+  gcObserver.observe({ entryTypes: ["gc"] });
+} catch {}
 export function shouldEmitMemorySample(turnIndex) {
   return turnIndex > 0 && turnIndex % MEMORY_SAMPLE_TURN_INTERVAL === 0;
 }
@@ -39,6 +67,9 @@ export function toMemoryProcessUsage(mem, resourceUsage) {
     heapTotalBytes: mem.heapTotal,
     externalBytes: mem.external,
     arrayBuffersBytes: mem.arrayBuffers,
+    heapSettledBytes: settledHeapUsedBytes,
+    heapSettledMajorGcCount: majorGcCount,
+    externalNonBufferBytes: Math.max(0, mem.external - mem.arrayBuffers),
     peakWorkingSetBytes: typeof maxKb === "number" && Number.isFinite(maxKb) && maxKb > 0 ? maxKb * 1024 : null
   };
 }
@@ -46,7 +77,11 @@ export function estimateDispatchCacheBytes(stats) {
   return stats.recentlyCleanNeighborCacheSize * 320 + stats.sessionFactEntries * 440;
 }
 export function collectMemorySampleSubsystems(wordIndex) {
+  refreshReviewGraphPersistWorkerHeapStatistics();
+  refreshProjectSnapshotPersistWorkerHeapStatistics();
   const reviewGraph = getReviewGraphWorkspaceCacheSnapshot();
+  const reviewGraphWorker = getReviewGraphPersistWorkerHeapStatistics();
+  const projectSnapshotWorker = getProjectSnapshotPersistWorkerHeapStatistics();
   const treeSitterClient = getSharedTreeSitterClient();
   const treeSitter = treeSitterClient ? (() => {
     const runtimeStats = treeSitterClient.getRuntimeStats();
@@ -70,13 +105,18 @@ export function collectMemorySampleSubsystems(wordIndex) {
       };
     })(),
     reviewGraph,
+    persistWorkers: {
+      reviewGraph: reviewGraphWorker,
+      projectSnapshot: projectSnapshotWorker
+    },
     wordIndex: wordIndex ? {
       docs: wordIndex.docLengths.size,
       fileTable: wordIndex.fileTable.size,
       postings: wordIndex.postings.size,
       postingEntries: countPostingEntries(wordIndex),
       residentBytes: estimateWordIndexStoreBytes(wordIndex),
-      forwardEntries: wordIndex.forward?.size ?? 0
+      forwardEntries: wordIndex.forward?.size ?? 0,
+      wireBytes: getWordIndexWireBytes(wordIndex)
     } : null,
     treeSitter,
     dispatchCaches: {
@@ -86,6 +126,7 @@ export function collectMemorySampleSubsystems(wordIndex) {
   };
 }
 export function buildMemorySample(wordIndex, mem = process.memoryUsage(), resourceUsage, session) {
+  const startedAt = performance.now();
   let resolvedResourceUsage = resourceUsage;
   if (!resolvedResourceUsage) {
     try {
@@ -94,11 +135,15 @@ export function buildMemorySample(wordIndex, mem = process.memoryUsage(), resour
       resolvedResourceUsage = undefined;
     }
   }
-  return {
+  const sample = {
     process: toMemoryProcessUsage(mem, resolvedResourceUsage),
     subsystems: collectMemorySampleSubsystems(wordIndex),
     session
   };
+  return {
+    ...sample,
+    samplerDurationMs: Math.max(0, performance.now() - startedAt)
+  };
 }
 const toMb = (bytes) => Math.round(bytes / (1024 * 1024));
 export function formatMemoryHealthLine(sample) {

package/extensions/dm-lens/clients/module-report-lsp.js

@@ -82,7 +82,7 @@ async function enrichModuleReportWithLspNow(absPath, lines, targets, maxRefs, bu
   let getLSPService;
   try {
     ({ getServersForFileWithConfig } = await import("./lsp/config.js"));
-    ({ getLSPService } = await import("./lsp/index.js"));
+    ({ getLSPService } = await import("./lsp/capabilities.js"));
   } catch {
     return NO_LSP;
   }