@duckmind/dm-linux-x64 0.65.5 → 0.65.7

package/extensions/dm-lens/clients/read-guard-logger.js

@@ -3,6 +3,7 @@ import { isTestMode } from "./env-utils.js";
 import { getGlobalDmLensLogDir } from "./probe-home-state.js";
 import { createNdjsonLogger } from "./ndjson-logger.js";
 import { normalizeFilePath } from "./path-utils.js";
+import { getTurnId } from "./turn-context.js";
 const READ_GUARD_LOG_DIR = getGlobalDmLensLogDir();
 const READ_GUARD_LOG_FILE = path.join(READ_GUARD_LOG_DIR, "read-guard.log");
 const READ_GUARD_LOG_BACKUP_FILE = path.join(READ_GUARD_LOG_DIR, "read-guard.log.1");
@@ -16,7 +17,7 @@ const VERBOSE_READ_GUARD_LOG = process.env.DM_LENS_READ_GUARD_VERBOSE === "1" ||
 const LOG_ALLOWED_EDITS = process.env.DM_LENS_READ_GUARD_LOG_ALLOWS === "1";
 const SNAPSHOT_LOG_SETTING = (process.env.DM_LENS_READ_GUARD_LOG_SNAPSHOTS ?? "1").toLowerCase();
 const LOG_SNAPSHOT_VALIDATION = !["0", "false", "off"].includes(SNAPSHOT_LOG_SETTING);
-export const MAX_EDIT_BATCH_ITEMS = 100;
+const MAX_EDIT_BATCH_ITEMS = 100;
 let generatedCorrelationCounter = 0;
 export function sanitizeCorrelationId(value) {
   if (typeof value !== "string" && typeof value !== "number")
@@ -164,6 +165,7 @@ export function logReadGuardEvent(entry) {
   writer.log({
     ts: new Date().toISOString(),
     ...logEntry,
+    turnId: getTurnId(),
     filePath: normalizeFilePath(logEntry.filePath),
     metadata
   });

package/extensions/dm-lens/clients/read-guard.js

@@ -203,6 +203,7 @@ export class ReadGuard {
   exemptions = new Set;
   pendingCreations = new Map;
   writtenThisSession = new Set;
+  unchangedThisSession = new Set;
   knownPathIndex = new Map;
   trimAccumulators = new Map;
   sessionId;
@@ -284,8 +285,15 @@ export class ReadGuard {
       this.evictFile(victim, "file-cap-unconsumed");
     }
   }
-  recordRead(record) {
+  recordRead(record, opts) {
     const filePath = this.key(record.filePath);
+    if (opts?.supersedes) {
+      const records = this.reads.get(filePath);
+      const provisionalSource = `native-read:${opts.supersedes.toolCallId}:provisional`;
+      const provisionalIndex = records?.findIndex((candidate) => candidate.source === provisionalSource);
+      if (provisionalIndex !== undefined && provisionalIndex >= 0)
+        records.splice(provisionalIndex, 1);
+    }
     this.knownPathIndex.set(normalizeEphemeralMapKey(record.filePath), filePath);
     const storedRecord = {
       ...record,
@@ -593,10 +601,14 @@ Re-read the relevant section, then retry the edit using the current line range/c
     this.evictFile(stored ?? this.key(filePath), "external-delete");
   }
   noteCreatedFile(filePath, turnIndex, writeIndex) {
-    this.pendingCreations.set(this.key(filePath), { turnIndex, writeIndex });
+    this.pendingCreations.set(normalizeEphemeralMapKey(filePath), {
+      turnIndex,
+      writeIndex
+    });
   }
   recordWritten(rawFilePath) {
     const filePath = this.key(rawFilePath);
+    this.unchangedThisSession.delete(filePath);
     this.knownPathIndex.set(normalizeEphemeralMapKey(rawFilePath), filePath);
     this.fileTime.read(filePath);
     this.writtenThisSession.add(filePath);
@@ -604,12 +616,18 @@ Re-read the relevant section, then retry the edit using the current line range/c
       this.consumedReadFiles.add(filePath);
     this.touchFile(filePath);
     this.enforceFileCap();
-    const creation = this.pendingCreations.get(filePath);
+    const creationKey = normalizeEphemeralMapKey(rawFilePath);
+    const creation = this.pendingCreations.get(creationKey);
     if (creation) {
-      this.pendingCreations.delete(filePath);
+      this.pendingCreations.delete(creationKey);
       this.injectCreationRead(filePath, creation.turnIndex, creation.writeIndex);
     }
   }
+  recordUnchanged(rawFilePath) {
+    const filePath = this.key(rawFilePath);
+    if (!this.writtenThisSession.has(filePath))
+      this.unchangedThisSession.add(filePath);
+  }
   addExemption(filePath) {
     this.exemptions.add(this.key(filePath));
     logReadGuardEvent({
@@ -733,6 +751,8 @@ Re-read the relevant section, then retry the edit using the current line range/c
     });
   }
   wasWrittenThisSession(filePath) {
+    if (this.unchangedThisSession.has(filePath))
+      return false;
     if (this.writtenThisSession.has(filePath))
       return true;
     try {
@@ -940,6 +960,8 @@ Re-read the relevant section, then retry the edit using the current line range/c
     const [editStart, editEnd] = touchedLines;
     const reads = this.reads.get(filePath) ?? [];
     for (const read of reads) {
+      if (read.provisional === true)
+        continue;
       const readStart = Math.max(1, read.effectiveOffset - this.config.contextLines);
       const readEnd = read.effectiveOffset + read.effectiveLimit - 1 + this.config.contextLines;
       if (editStart >= readStart && editEnd <= readEnd) {
@@ -953,7 +975,7 @@ Re-read the relevant section, then retry the edit using the current line range/c
         }
       }
     }
-    const intervals = reads.map((read) => [
+    const intervals = reads.filter((read) => read.provisional !== true).map((read) => [
       Math.max(1, read.effectiveOffset - this.config.contextLines),
       read.effectiveOffset + read.effectiveLimit - 1 + this.config.contextLines
     ]);
@@ -987,7 +1009,8 @@ Re-read the relevant section, then retry the edit using the current line range/c
       return filePath.endsWith(suffix);
     }
     if (pattern.includes("*")) {
-      const regex = new RegExp(`^${pattern.replace(/\\/g, "\\\\").replace(/\./g, "\\.").replace(/\*/g, ".*")}$`);
+      const collapsedPattern = pattern.replace(/\*+/g, "*");
+      const regex = new RegExp(`^${collapsedPattern.replace(/\\/g, "\\\\").replace(/\./g, "\\.").replace(/\*/g, ".*")}$`);
       return regex.test(filePath);
     }
     return filePath === pattern;

package/extensions/dm-lens/clients/recent-touches.js

@@ -4,12 +4,12 @@ import { writeFileAtomicAsync } from "./atomic-write.js";
 import { getProjectDataDir } from "./file-utils.js";
 import { normalizeFilePath } from "./path-utils.js";
 export const RECENT_TOUCHES_MAX_ENTRIES = 50;
-export const RECENT_TOUCHES_FRESHNESS_MS = 15 * 60 * 1000;
+const RECENT_TOUCHES_FRESHNESS_MS = 15 * 60 * 1000;
 function recentTouchesPath(cwd) {
   return path.join(getProjectDataDir(cwd), "recent-touches.json");
 }
 let _enabledCache;
-export function isRecentTouchesEnabled() {
+function isRecentTouchesEnabled() {
   if (_enabledCache === undefined) {
     _enabledCache = process.env.DM_LENS_AGENT_NUDGE !== "0";
   }

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

@@ -1,8 +1,12 @@
 import pidusage from "./deps/pidusage.js";
-import { recordDegradationOnce } from "./degradation-ledger.js";
+import {
+  incrementDegradationCount,
+  recordDegradationOnce
+} from "./degradation-ledger.js";
 import { terminateScannerChild } from "./instance-reaper.js";
 import { queryProcessTable } from "./process-snapshot.js";
 export const RESOURCE_SAMPLE_QUERY_TIMEOUT_MS = 2000;
+const SPAWN_SAMPLER_LEDGER_SUBJECT = "spawn-usage-sampler";
 function recordQueryFailure(subject, status, exitCode) {
   const exitReason = status === "exit-error" ? ` (exit code ${exitCode ?? "unknown"})` : "";
   recordDegradationOnce({
@@ -244,20 +248,27 @@ export async function sampleProcessTreeCpuPercent(pid, windowMs = 1200, floorPer
   if (first === null || second === null || !first.measured || !second.measured) {
     return { busy: false, measured: false, cpuPercent: null };
   }
-  const observed = Math.max(first.cpuPercent, second.cpuPercent);
+  const observed = second.cpuPercent;
   return {
     busy: observed > floorPercent,
     measured: true,
     cpuPercent: observed
   };
 }
-export function startSpawnUsageSampler(pid, intervalMs = 750) {
+const SPAWN_SAMPLE_INTERVAL_MS = 750;
+const SPAWN_SAMPLE_FULL_RATE_TICKS = 8;
+const SPAWN_SAMPLE_MAX_INTERVAL_MULTIPLIER = 16;
+export function startSpawnUsageSampler(pid, intervalMs = SPAWN_SAMPLE_INTERVAL_MS, lifetimeCapMs) {
   if (!Number.isFinite(pid) || pid <= 0) {
     return { stop: () => null };
   }
   const targetPid = pid;
   const accumulator = new UsageAccumulator;
+  const startedAt = Date.now();
   let stopped = false;
+  let inFlight = false;
+  let tickCount = 0;
+  let timer;
   const tick = async () => {
     if (stopped)
       return;
@@ -280,17 +291,56 @@ export function startSpawnUsageSampler(pid, intervalMs = 750) {
       accumulator.addSample({ rssBytes, cpuPercent });
     } catch {}
   };
-  tick();
-  const timer = setInterval(() => {
-    tick();
-  }, intervalMs);
-  timer.unref?.();
+  const releaseInFlight = () => {
+    inFlight = false;
+  };
+  const nextDelayMs = () => {
+    if (tickCount <= SPAWN_SAMPLE_FULL_RATE_TICKS)
+      return intervalMs;
+    const grown = intervalMs * 2 ** (tickCount - SPAWN_SAMPLE_FULL_RATE_TICKS);
+    return Math.min(grown, intervalMs * SPAWN_SAMPLE_MAX_INTERVAL_MULTIPLIER);
+  };
+  const arm = (delayMs) => {
+    timer = setTimeout(runTick, delayMs);
+    timer.unref?.();
+  };
+  function runTick() {
+    timer = undefined;
+    if (stopped)
+      return;
+    if (Date.now() - startedAt >= lifetimeCapMs) {
+      incrementDegradationCount({
+        kind: "resource-sampler-lifetime-capped",
+        subject: SPAWN_SAMPLER_LEDGER_SUBJECT,
+        reason: `spawn sampler stopped polling at its ${lifetimeCapMs}ms lifetime cap; the child was still running`
+      });
+      return;
+    }
+    tickCount++;
+    if (inFlight) {
+      incrementDegradationCount({
+        kind: "resource-sampler-tick-overlapped",
+        subject: SPAWN_SAMPLER_LEDGER_SUBJECT,
+        reason: `spawn sampler skipped a poll tick: the previous sample was still in flight after ${intervalMs}ms`
+      });
+    } else {
+      inFlight = true;
+      tick().then(releaseInFlight, releaseInFlight);
+    }
+    arm(nextDelayMs());
+  }
+  tickCount = 1;
+  inFlight = true;
+  tick().then(releaseInFlight, releaseInFlight);
+  arm(nextDelayMs());
   return {
     stop() {
       if (stopped)
         return accumulator.summarize();
       stopped = true;
-      clearInterval(timer);
+      if (timer !== undefined)
+        clearTimeout(timer);
+      timer = undefined;
       return accumulator.summarize();
     }
   };

package/extensions/dm-lens/clients/review-graph/builder.js

@@ -27,7 +27,7 @@ import {
 } from "../path-utils.js";
 import { collectProjectSourceFilesWithBudgetAsync } from "../project-scan-policy.js";
 import { getReviewGraphMaxFilesDerived } from "../project-scale.js";
-import { compareOrdinal } from "../string-utils.js";
+import { compareOrdinal, escapeRegExp } from "../string-utils.js";
 import { BoundedLruCache } from "../bounded-cache.js";
 import {
   jsTsCandidatePaths,
@@ -55,7 +55,10 @@ import {
 } from "../tree-sitter-symbol-extractor.js";
 import { withTreeSitterRoot } from "../tree-sitter-shared.js";
 import { incrementDegradationCount } from "../degradation-ledger.js";
-import { resolveGitIdentity } from "./git-identity.js";
+import {
+  createGitIdentityResolver,
+  resolveGitIdentity
+} from "./git-identity.js";
 import {
   formatReviewGraphRevisionDriftNote
 } from "./revision-drift.js";
@@ -86,7 +89,6 @@ const MAIN_KINDS = new Set([
   "shell"
 ]);
 const MAIN_KIND_EXTENSIONS = Array.from(MAIN_KINDS).flatMap((kind) => KIND_EXTENSIONS[kind] ?? []);
-export const REVIEW_GRAPH_SOURCE_EXTENSIONS = MAIN_KIND_EXTENSIONS;
 const CHANGED_SYMBOLS_PREFIX = "session.reviewGraph.changedSymbols:";
 const extractorCache = new Map;
 const REVIEW_GRAPH_MAX_WARM_WORKSPACES = 8;
@@ -271,7 +273,7 @@ const REVIEW_GRAPH_EDGE_RESIDENT_BYTES = 243;
 export function estimateReviewGraphStoreBytes(totalNodes, totalEdges) {
   return totalNodes * REVIEW_GRAPH_NODE_RESIDENT_BYTES + totalEdges * REVIEW_GRAPH_EDGE_RESIDENT_BYTES;
 }
-export const GRAPH_MAX_IN_MEMORY_BYTES_DEFAULT = 512 * 1024 * 1024;
+const GRAPH_MAX_IN_MEMORY_BYTES_DEFAULT = 512 * 1024 * 1024;
 function graphMaxInMemoryBytes() {
   const raw = Number(process.env.DM_LENS_GRAPH_MAX_IN_MEMORY_BYTES);
   return Number.isFinite(raw) && raw > 0 ? raw : GRAPH_MAX_IN_MEMORY_BYTES_DEFAULT;
@@ -426,12 +428,12 @@ const _cwdWorktreeCheckedCwds = new Set;
 export function _resetCwdWorktreeMismatchLogForTests() {
   _cwdWorktreeCheckedCwds.clear();
 }
-function logCwdWorktreeMismatchOnce(cwd) {
+function logCwdWorktreeMismatchOnce(cwd, resolveIdentity = resolveGitIdentity) {
   const key = normalizeMapKey(cwd);
   if (_cwdWorktreeCheckedCwds.has(key))
     return;
   _cwdWorktreeCheckedCwds.add(key);
-  const identity = resolveGitIdentity(cwd);
+  const identity = resolveIdentity(cwd);
   if (!identity)
     return;
   if (identity.worktreeRoot === normalizeFilePath(path.resolve(cwd)))
@@ -510,9 +512,6 @@ function makeCtx(filePath, cwd, facts) {
     log: () => {}
   };
 }
-function escapeRegExp(string) {
-  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 function createEmptyGraph() {
   return {
     version: REVIEW_GRAPH_VERSION,
@@ -609,7 +608,7 @@ function diffSignatureMaps(previous, next) {
   }
   return { added, removed, changed };
 }
-export function getReviewGraphMaxFiles(cwd) {
+function getReviewGraphMaxFiles(cwd) {
   const override = Number.parseInt(process.env.DM_LENS_REVIEW_GRAPH_MAX_FILES ?? "", 10);
   return Number.isFinite(override) && override > 0 ? override : getReviewGraphMaxFilesDerived(cwd);
 }
@@ -878,7 +877,7 @@ function logSnapshotReadVerdict(cwd, phase, reason) {
     return;
   logReviewGraph({ cwd, phase, reason });
 }
-function loadPersistedGraph(cwd, opts) {
+function loadPersistedGraph(cwd, opts, resolveIdentity = resolveGitIdentity) {
   const cacheDir = path.join(getProjectDataDir(cwd), "cache");
   const cachePath = path.join(cacheDir, GRAPH_CACHE_FILENAME);
   const legacyPath = path.join(cacheDir, LEGACY_GRAPH_CACHE_FILENAME);
@@ -891,7 +890,7 @@ function loadPersistedGraph(cwd, opts) {
       return null;
     let stampedHead;
     if (opts?.verifyWorktreeIdentity && data.gitStamp) {
-      const current = resolveGitIdentity(cwd);
+      const current = resolveIdentity(cwd);
       if (current && current.worktreeRoot !== data.gitStamp.worktreeRoot) {
         logSnapshotReadVerdict(cwd, "snapshot_read_dropped", "worktree_mismatch");
         return null;
@@ -1508,7 +1507,7 @@ function persistGraph(cwd, signature, fileSignatures, fileHashes, graph, options
   const cacheDir = path.join(getProjectDataDir(cwd), "cache");
   const cachePath = path.join(cacheDir, GRAPH_CACHE_FILENAME);
   sweepStaleStageFiles(cacheDir);
-  const gitStamp = resolveGitIdentity(cwd);
+  const gitStamp = (options.resolveIdentity ?? resolveGitIdentity)(cwd);
   const key = normalizeMapKey(cwd);
   const priorGeneration = _persistGenerations.get(key);
   const existingPending = _pendingPersist.get(key);
@@ -1619,7 +1618,7 @@ function hashIgnoredIds(ignoredIds) {
   const joined = [...ignoredIds].sort((a, b) => compareOrdinal(a, b)).join("\x00");
   return createHash("sha256").update(joined).digest("hex");
 }
-function buildReviewGraphCheckpointData(cwd, graph, processedHashes, targetFileCount, ignoredIds) {
+function buildReviewGraphCheckpointData(cwd, graph, processedHashes, targetFileCount, ignoredIds, resolveIdentity = resolveGitIdentity) {
   return {
     version: REVIEW_GRAPH_VERSION,
     builtAt: new Date().toISOString(),
@@ -1629,15 +1628,15 @@ function buildReviewGraphCheckpointData(cwd, graph, processedHashes, targetFileC
     ignoredIdsHash: hashIgnoredIds(ignoredIds),
     nodes: Array.from(graph.nodes.entries()),
     edges: graph.edges,
-    gitStamp: resolveGitIdentity(cwd)
+    gitStamp: resolveIdentity(cwd)
   };
 }
-function writeReviewGraphCheckpoint(cwd, graph, processedHashes, targetFileCount, ignoredIds) {
+function writeReviewGraphCheckpoint(cwd, graph, processedHashes, targetFileCount, ignoredIds, resolveIdentity = resolveGitIdentity) {
   const generation = (_checkpointGenerations.get(cwd) ?? 0) + 1;
   _checkpointGenerations.set(cwd, generation);
   let data;
   try {
-    data = buildReviewGraphCheckpointData(cwd, graph, processedHashes, targetFileCount, ignoredIds);
+    data = buildReviewGraphCheckpointData(cwd, graph, processedHashes, targetFileCount, ignoredIds, resolveIdentity);
   } catch {
     return;
   }
@@ -1718,7 +1717,7 @@ function deleteReviewGraphCheckpoint(cwd) {
   _checkpointGenerations.set(cwd, (_checkpointGenerations.get(cwd) ?? 0) + 1);
   fs.rm(reviewGraphCheckpointPath(cwd), { force: true }, () => {});
 }
-function loadReviewGraphCheckpoint(cwd) {
+function loadReviewGraphCheckpoint(cwd, resolveIdentity = resolveGitIdentity) {
   const checkpointPath = reviewGraphCheckpointPath(cwd);
   let data;
   try {
@@ -1740,7 +1739,7 @@ function loadReviewGraphCheckpoint(cwd) {
     return null;
   }
   if (data.gitStamp) {
-    const current = resolveGitIdentity(cwd);
+    const current = resolveIdentity(cwd);
     if (current && current.worktreeRoot !== data.gitStamp.worktreeRoot) {
       logReviewGraph({
         cwd,
@@ -1797,8 +1796,8 @@ function pruneOrphanNonFileNodes(graph) {
       graph.nodes.delete(id);
   }
 }
-async function tryResumeFromCheckpoint(cwd, filesToBuild, ignoredIds) {
-  const loaded = loadReviewGraphCheckpoint(cwd);
+async function tryResumeFromCheckpoint(cwd, filesToBuild, ignoredIds, resolveIdentity = resolveGitIdentity) {
+  const loaded = loadReviewGraphCheckpoint(cwd, resolveIdentity);
   if (!loaded)
     return null;
   if (loaded.ignoredIdsHash !== hashIgnoredIds(ignoredIds)) {
@@ -2495,7 +2494,7 @@ function addTreeSitterFile(graph, cwd, filePath, languageId, extracted, ignoredI
     });
   }
 }
-export function addLspFallbackSymbols(graph, filePath, languageId, symbols) {
+function addLspFallbackSymbols(graph, filePath, languageId, symbols) {
   const normalized = normalizeMapKey(filePath);
   const fileNodeId = `file:${normalized}`;
   let added = 0;
@@ -2993,7 +2992,8 @@ async function tryIncrementalFromCache(cached, ctx) {
     buildId: ctx.buildId,
     projectSeq: ctx.seqAtBuildStart,
     seqHint: ctx.seqHint,
-    mode: ctx.mode
+    mode: ctx.mode,
+    resolveIdentity: ctx.resolveIdentity
   });
   setGraphBuildInfo(graph, {
     reused: true,
@@ -3012,7 +3012,7 @@ function hasGraphKindExtension(file) {
   const kind = detectFileKind(file);
   return !!kind && MAIN_KINDS.has(kind) && detectFileRole(file) !== "test";
 }
-async function trySeqFastpath(cwd, buildId, normalizedCwd, normalizedChanged, facts, seqHint, seqAtBuildStart, ignoredIds, cacheEpoch) {
+async function trySeqFastpath(cwd, buildId, normalizedCwd, normalizedChanged, facts, seqHint, seqAtBuildStart, ignoredIds, cacheEpoch, resolveIdentity) {
   const cached = _workspaceGraphCache.get(normalizedCwd);
   const cachedCoverage = cached?.graph.persistCoverage;
   if (cachedCoverage?.partial && cachedCoverage.capTrimmed !== true) {
@@ -3113,7 +3113,8 @@ async function trySeqFastpath(cwd, buildId, normalizedCwd, normalizedChanged, fa
     buildId,
     projectSeq: seqAtBuildStart,
     seqHint: true,
-    mode: "seq-fastpath"
+    mode: "seq-fastpath",
+    resolveIdentity
   });
   setGraphBuildInfo(graph, {
     reused: true,
@@ -3129,13 +3130,14 @@ async function trySeqFastpath(cwd, buildId, normalizedCwd, normalizedChanged, fa
   return { graph };
 }
 async function _doBuildGraph(cwd, changedFiles, facts, seqHint, buildId) {
+  const resolveIdentity = createGitIdentityResolver();
   const normalizedCwd = normalizeMapKey(cwd);
   const cacheEpoch = workspaceCacheEpoch(normalizedCwd);
   if (_reviewGraphBuildGateForTests)
     await _reviewGraphBuildGateForTests();
   const normalizedChanged = changedFiles.map((file) => normalizeMapKey(file));
   const normalizedChangedSet = new Set(normalizedChanged);
-  logCwdWorktreeMismatchOnce(cwd);
+  logCwdWorktreeMismatchOnce(cwd, resolveIdentity);
   if (isAtOrAboveHomeDir(path.resolve(cwd))) {
     const graph = createEmptyGraph();
     for (const file of normalizedChanged) {
@@ -3154,7 +3156,7 @@ async function _doBuildGraph(cwd, changedFiles, facts, seqHint, buildId) {
   const ignoredIdsPromise = collectUntrackedIgnoredIds(cwd);
   let seqFastpathFallback;
   if (seqHint && seqAtBuildStart !== undefined && seqFastpathEnabled()) {
-    const fast = await trySeqFastpath(cwd, buildId, normalizedCwd, normalizedChanged, facts, seqHint, seqAtBuildStart, await ignoredIdsPromise, cacheEpoch);
+    const fast = await trySeqFastpath(cwd, buildId, normalizedCwd, normalizedChanged, facts, seqHint, seqAtBuildStart, await ignoredIdsPromise, cacheEpoch, resolveIdentity);
     if ("graph" in fast)
       return fast.graph;
     seqFastpathFallback = fast.fallback;
@@ -3258,14 +3260,15 @@ async function _doBuildGraph(cwd, changedFiles, facts, seqHint, buildId) {
       facts,
       seqAtBuildStart,
       ignoredIds,
-      cacheEpoch
+      cacheEpoch,
+      resolveIdentity
     });
     if (incremental) {
       updateGraphBuildInfo(incremental, { seqFastpathFallback });
       return incremental;
     }
   }
-  const diskCached = sourceFilesTruncated ? null : loadPersistedGraph(cwd);
+  const diskCached = sourceFilesTruncated ? null : loadPersistedGraph(cwd, undefined, resolveIdentity);
   if (diskCached?.signature === signature) {
     const graph = cloneGraph(diskCached.graph);
     rebuildIndexes(graph);
@@ -3309,14 +3312,15 @@ async function _doBuildGraph(cwd, changedFiles, facts, seqHint, buildId) {
       signature,
       facts,
       seqAtBuildStart,
-      ignoredIds
+      ignoredIds,
+      resolveIdentity
     });
     if (incremental) {
       updateGraphBuildInfo(incremental, { seqFastpathFallback });
       return incremental;
     }
   }
-  const resumed = sourceFilesTruncated ? null : await tryResumeFromCheckpoint(cwd, filesToBuild, ignoredIds);
+  const resumed = sourceFilesTruncated ? null : await tryResumeFromCheckpoint(cwd, filesToBuild, ignoredIds, resolveIdentity);
   const graph = resumed?.graph ?? createEmptyGraph();
   const filesToExtract = resumed?.remaining ?? filesToBuild;
   const treeSitterClient = getSharedTreeSitterClient();
@@ -3347,7 +3351,7 @@ async function _doBuildGraph(cwd, changedFiles, facts, seqHint, buildId) {
       extractedCount++;
       filesSinceCheckpoint++;
       if (Number.isFinite(testStopAfter) && testStopAfter > 0 && extractedCount >= testStopAfter) {
-        writeReviewGraphCheckpointSync(cwd, buildReviewGraphCheckpointData(cwd, graph, fileHashes, filesToBuild.length, ignoredIds), {
+        writeReviewGraphCheckpointSync(cwd, buildReviewGraphCheckpointData(cwd, graph, fileHashes, filesToBuild.length, ignoredIds, resolveIdentity), {
           nodes: graph.nodes.size,
           edges: graph.edges.length,
           processed: fileHashes.size,
@@ -3357,7 +3361,7 @@ async function _doBuildGraph(cwd, changedFiles, facts, seqHint, buildId) {
       }
       const remainingAfter = filesToExtract.length - extractedCount;
       if (filesSinceCheckpoint >= checkpointEvery && remainingAfter >= checkpointEvery && Date.now() - lastCheckpointMs >= checkpointMinIntervalMs) {
-        writeReviewGraphCheckpoint(cwd, graph, fileHashes, filesToBuild.length, ignoredIds);
+        writeReviewGraphCheckpoint(cwd, graph, fileHashes, filesToBuild.length, ignoredIds, resolveIdentity);
         filesSinceCheckpoint = 0;
         lastCheckpointMs = Date.now();
       }
@@ -3417,7 +3421,8 @@ async function _doBuildGraph(cwd, changedFiles, facts, seqHint, buildId) {
     seqHint: seqHint !== undefined,
     mode: "full",
     sourceFileCount,
-    sourceFilesTruncated
+    sourceFilesTruncated,
+    resolveIdentity
   });
   setGraphBuildInfo(graph, {
     reused: false,

package/extensions/dm-lens/clients/review-graph/git-identity.js

@@ -1,10 +1,18 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { BoundedLruCache } from "../bounded-cache.js";
 import { normalizeFilePath, walkUpDirs } from "../path-utils.js";
-const _gitDirCache = new BoundedLruCache(32);
+export function createGitIdentityResolver() {
+  const memo = new Map;
+  return (cwd) => {
+    if (memo.has(cwd))
+      return memo.get(cwd);
+    const identity = resolveGitIdentity(cwd);
+    memo.set(cwd, identity);
+    return identity;
+  };
+}
 export function _resetGitIdentityCacheForTests() {
-  _gitDirCache.clear();
+  return;
 }
 function readCommonDir(gitDir) {
   try {
@@ -55,16 +63,12 @@ function resolveGitDir(cwd) {
   return null;
 }
 function getResolvedGitDir(cwd) {
-  const key = normalizeFilePath(path.resolve(cwd));
-  if (_gitDirCache.has(key))
-    return _gitDirCache.get(key) ?? null;
   let resolved;
   try {
     resolved = resolveGitDir(cwd);
   } catch {
     resolved = null;
   }
-  _gitDirCache.set(key, resolved);
   return resolved;
 }
 function resolveRefToSha(commonDir, ref) {

package/extensions/dm-lens/clients/review-graph/import-resolvers.js

@@ -50,7 +50,7 @@ function resolveDart(cwd, filePath, source) {
     return [];
   return resolveRelative(cwd, filePath, source, [".dart"]);
 }
-export const JS_TS_EXT_RE = /\.(mjs|cjs|mts|cts|jsx?|tsx?)$/i;
+const JS_TS_EXT_RE = /\.(mjs|cjs|mts|cts|jsx?|tsx?)$/i;
 function jsTsExtensionCandidates(base, strippedBase, ext) {
   const candidates = [];
   if (ext === ".mjs")

package/extensions/dm-lens/clients/review-graph-logger.js

@@ -4,6 +4,7 @@ import { getGlobalDmLensLogDir } from "./probe-home-state.js";
 import { getMaxLogSizeMB } from "./log-cleanup.js";
 import { createNdjsonLogger } from "./ndjson-logger.js";
 import { normalizeFilePath } from "./path-utils.js";
+import { getTurnId } from "./turn-context.js";
 const REVIEW_GRAPH_LOG_DIR = getGlobalDmLensLogDir();
 const REVIEW_GRAPH_LOG_FILE = path.join(REVIEW_GRAPH_LOG_DIR, "review-graph.log");
 const writer = createNdjsonLogger({
@@ -35,7 +36,8 @@ export function logReviewGraph(entry) {
     ts: new Date().toISOString(),
     ...entry,
     cwd: normalizeFilePath(entry.cwd),
-    pid: process.pid
+    pid: process.pid,
+    turnId: getTurnId()
   });
 }
 export function getReviewGraphLogPath() {

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

@@ -6,7 +6,9 @@ import {
   resolveAvailableOrInstall
 } from "./dispatch/runners/utils/runner-helpers.js";
 import { isFileKind } from "./file-kinds.js";
+import { pathsEqual } from "./path-utils.js";
 import { safeSpawnAsync } from "./safe-spawn.js";
+import { resolveToolCwd } from "./tool-cwd.js";
 import { ruffConfigArgs } from "./tool-policy.js";
 const ruffAvailability = createAvailabilityChecker("ruff", ".exe");
 
@@ -46,11 +48,10 @@ export class RuffClient {
     }
     try {
       const before = await fs.promises.readFile(absolutePath, "utf-8");
-      const configArgs = ruffConfigArgs(cwd ?? path.dirname(absolutePath));
-      const spawnOpts = {
-        timeout: 1e4,
-        cwd: cwd ?? path.dirname(absolutePath)
-      };
+      const ruffCwd = resolveToolCwd("runner", "ruff", absolutePath, {
+        ...cwd !== undefined && { cwd }
+      }).cwd;
+      const configArgs = ruffConfigArgs(ruffCwd);
       const pre = await safeSpawnAsync(this.ruffCommand, [
         "check",
         "--output-format",
@@ -59,10 +60,10 @@ export class RuffClient {
         "py310",
         ...configArgs,
         absolutePath
-      ], spawnOpts);
-      const beforeDiags = pre.stdout?.trim() ? this.parseOutput(pre.stdout, absolutePath) : [];
+      ], { timeout: 1e4, cwd: ruffCwd });
+      const beforeDiags = pre.stdout?.trim() ? this.parseOutput(pre.stdout, ruffCwd, absolutePath) : [];
       const fixableCount = beforeDiags.filter((d) => d.fixable).length;
-      const fix = await safeSpawnAsync(this.ruffCommand, ["check", "--fix", ...configArgs, absolutePath], { timeout: 15000, cwd: cwd ?? path.dirname(absolutePath) });
+      const fix = await safeSpawnAsync(this.ruffCommand, ["check", "--fix", ...configArgs, absolutePath], { timeout: 15000, cwd: ruffCwd });
       if (fix.error) {
         return {
           success: false,
@@ -81,14 +82,14 @@ export class RuffClient {
       return { success: false, changed: false, fixed: 0, error: err.message };
     }
   }
-  parseOutput(output, filterFile) {
+  parseOutput(output, cwd, filterFile) {
     if (!output.trim())
       return [];
     try {
       const items = JSON.parse(output);
       const diagnostics = [];
       for (const item of items) {
-        if (filterFile && path.resolve(item.filename) !== filterFile)
+        if (filterFile && !pathsEqual(path.resolve(cwd, item.filename), filterFile))
           continue;
         diagnostics.push({
           line: item.location.row - 1,