@duckmind/dm-linux-x64 0.65.8 → 0.66.2

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

@@ -1,3635 +0,0 @@
-import { createHash } from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { Worker } from "node:worker_threads";
-import { constants as zlibConstants, gunzipSync, gzipSync } from "node:zlib";
-import { fileURLToPath } from "node:url";
-import { writeFileAtomic } from "../atomic-write.js";
-import { fileContentProvider } from "../dispatch/facts/file-content.js";
-import { lazyEnvNumber } from "../env-utils.js";
-import { featureHintMetadata } from "../feature-hints.js";
-import { detectFileKind, KIND_EXTENSIONS } from "../file-kinds.js";
-import { detectFileRole } from "../file-role.js";
-import { getProjectDataDir } from "../file-utils.js";
-import { collectUntrackedIgnoredIds } from "../git-tracked-ignore.js";
-import { realIsPidAlive } from "../instance-reaper.js";
-import { logLatency } from "../latency-logger.js";
-import { containerNameChain, getOpenDocumentSymbols, lspSymbolKindName } from "../lsp-document-symbols.js";
-import { isAtOrAboveHomeDir, normalizeFilePath, normalizeMapKey, toProjectRelativePath } from "../path-utils.js";
-import { collectProjectSourceFilesWithBudgetAsync } from "../project-scan-policy.js";
-import { getReviewGraphMaxFilesDerived } from "../project-scale.js";
-import { compareOrdinal, escapeRegExp } from "../string-utils.js";
-import { BoundedLruCache } from "../bounded-cache.js";
-import { jsTsCandidatePaths, resolveAliasedImport, resolveImportToFiles, resolveProjectReferenceImport, resolveWorkspacePackageImport } from "./import-resolvers.js";
-import { RUNTIME_CONFIG } from "../runtime-config.js";
-import { buildReverseDependencyIndexFromGraph, rankFilesByReverseDependencyCentrality } from "../reverse-deps.js";
-import { buildQualifiedName, findOwnerName } from "../symbol-containment.js";
-import { logTreeSitterCacheStats } from "../tree-sitter-logger.js";
-import { flushReviewGraphLogSync, logReviewGraph, makeReviewGraphBuildMetadata } from "../review-graph-logger.js";
-import { getSharedTreeSitterClient } from "../tree-sitter-shared.js";
-import { symbolExtractionGrammar, TreeSitterSymbolExtractor } from "../tree-sitter-symbol-extractor.js";
-import { withTreeSitterRoot } from "../tree-sitter-shared.js";
-import { incrementDegradationCount } from "../degradation-ledger.js";
-import { createGitIdentityResolver, resolveGitIdentity } from "./git-identity.js";
-import { formatReviewGraphRevisionDriftNote } from "./revision-drift.js";
-import { buildSymbolId } from "./symbol-id.js";
-import { clearReviewGraphFileIr, getFreshReviewGraphFileIr, reviewGraphIrContentHash } from "./shared-extraction-ir.js";
-export const REVIEW_GRAPH_VERSION = "v8";
-const MAIN_KINDS = new Set([
-  "jsts",
-  "python",
-  "go",
-  "rust",
-  "ruby",
-  "cxx",
-  "java",
-  "kotlin",
-  "dart",
-  "elixir",
-  "csharp",
-  "php",
-  "swift",
-  "lua",
-  "ocaml",
-  "zig",
-  "shell"
-]);
-const MAIN_KIND_EXTENSIONS = Array.from(MAIN_KINDS).flatMap((kind) => KIND_EXTENSIONS[kind] ?? []);
-const CHANGED_SYMBOLS_PREFIX = "session.reviewGraph.changedSymbols:";
-const extractorCache = new Map;
-const REVIEW_GRAPH_MAX_WARM_WORKSPACES = 8;
-const REVIEW_GRAPH_SOURCE_PATH_MEMO_ENTRIES = 16384;
-const _sourcePathMemos = new BoundedLruCache(REVIEW_GRAPH_MAX_WARM_WORKSPACES);
-function sourcePathMemo(cwd) {
-  const key = normalizeMapKey(path.resolve(cwd));
-  const existing = _sourcePathMemos.get(key);
-  if (existing)
-    return existing;
-  const memo = {
-    cache: new BoundedLruCache(REVIEW_GRAPH_SOURCE_PATH_MEMO_ENTRIES),
-    normalizeCalls: { value: 0 }
-  };
-  _sourcePathMemos.set(key, memo);
-  return memo;
-}
-function normalizeGraphSourcePath(memo, raw) {
-  const cached = memo.cache.get(raw);
-  if (cached !== undefined)
-    return cached;
-  const normalized = normalizeMapKey(raw);
-  if (fs.existsSync(raw))
-    memo.cache.set(raw, normalized);
-  memo.normalizeCalls.value++;
-  return normalized;
-}
-export function _resetReviewGraphSourcePathMemoForTests() {
-  _sourcePathMemos.clear();
-}
-const _buildCache = new Map;
-const _workspaceGraphCache = new Map;
-const REVIEW_GRAPH_IDLE_EVICT_MS_DEFAULT = 20 * 60000;
-let _workspaceCacheEpoch = 0;
-const _workspaceCacheEpochs = new Map;
-function workspaceCacheEpoch(key) {
-  return _workspaceCacheEpoch + (_workspaceCacheEpochs.get(key) ?? 0);
-}
-function reviewGraphIdleEvictMs() {
-  const value = Number.parseInt(process.env.DM_LENS_REVIEW_GRAPH_IDLE_EVICT_MS ?? "", 10);
-  return Number.isSafeInteger(value) && value > 0 ? value : REVIEW_GRAPH_IDLE_EVICT_MS_DEFAULT;
-}
-function clearWorkspaceGraphTimer(entry) {
-  if (entry.idleTimer)
-    clearTimeout(entry.idleTimer);
-  entry.idleTimer = undefined;
-}
-function buildCacheWorkspaceKey(cwd) {
-  return normalizeMapKey(path.resolve(cwd));
-}
-function buildCacheKeyWorkspace(buildKey) {
-  const separator = buildKey.indexOf("|");
-  return separator >= 0 ? buildKey.slice(0, separator) : undefined;
-}
-function evictWorkspaceGraph(key, entry) {
-  if (_workspaceGraphCache.get(key) !== entry)
-    return;
-  clearWorkspaceGraphTimer(entry);
-  const buildWorkspace = buildCacheWorkspaceKey(key);
-  for (const buildKey of _buildCache.keys()) {
-    if (buildCacheKeyWorkspace(buildKey) === buildWorkspace) {
-      _buildCache.delete(buildKey);
-    }
-  }
-  _sourcePathMemos.delete(key);
-  _workspaceCacheEpochs.set(key, (_workspaceCacheEpochs.get(key) ?? 0) + 1);
-  _workspaceGraphCache.delete(key);
-}
-function scheduleWorkspaceGraphEviction(key, entry) {
-  clearWorkspaceGraphTimer(entry);
-  const epoch = workspaceCacheEpoch(key);
-  entry.idleTimer = setTimeout(() => {
-    entry.idleTimer = undefined;
-    if (_workspaceGraphCache.get(key) !== entry || workspaceCacheEpoch(key) !== epoch)
-      return;
-    evictWorkspaceGraph(key, entry);
-  }, reviewGraphIdleEvictMs());
-  entry.idleTimer.unref?.();
-}
-function touchWorkspaceGraph(key) {
-  const entry = _workspaceGraphCache.get(key);
-  if (!entry)
-    return;
-  entry.lastUsedAt = Date.now();
-  scheduleWorkspaceGraphEviction(key, entry);
-}
-function setWorkspaceGraph(key, entry, epoch) {
-  if (epoch !== undefined && workspaceCacheEpoch(key) !== epoch)
-    return false;
-  const previous = _workspaceGraphCache.get(key);
-  if (previous)
-    clearWorkspaceGraphTimer(previous);
-  const boundedGraph = retainedGraph(key, entry.graph);
-  const resident = {
-    ...entry,
-    graph: boundedGraph,
-    lastUsedAt: Date.now()
-  };
-  _workspaceGraphCache.set(key, resident);
-  scheduleWorkspaceGraphEviction(key, resident);
-  while (_workspaceGraphCache.size > REVIEW_GRAPH_MAX_WARM_WORKSPACES) {
-    const victim = [..._workspaceGraphCache.entries()].sort(([, a], [, b]) => a.lastUsedAt - b.lastUsedAt)[0];
-    if (!victim)
-      break;
-    evictWorkspaceGraph(victim[0], victim[1]);
-  }
-  return true;
-}
-let _graphGenerationCounter = 0;
-let _buildIdCounter = 0;
-const SEQ_FASTPATH_MAX_CHANGES = 32;
-const SEQ_FASTPATH_REVERIFY_MS = 5 * 60000;
-const SEQ_FASTPATH_REVERIFY_EVERY = 20;
-function graphLogMetadata(graph, options = {}) {
-  return makeReviewGraphBuildMetadata(graph, options);
-}
-function seqFastpathEnabled() {
-  const raw = process.env.DM_LENS_GRAPH_SEQ_FASTPATH;
-  return raw !== "0" && raw !== "false";
-}
-let _lastGraphBuildInfo = {
-  reused: false,
-  mode: "full",
-  graphChanged: true
-};
-const _graphBuildInfoByGraph = new WeakMap;
-let _anyGraphStamped = false;
-function setGraphBuildInfo(graph, info) {
-  _lastGraphBuildInfo = info;
-  _graphBuildInfoByGraph.set(graph, info);
-  _anyGraphStamped = true;
-}
-export function getGraphBuildInfoForGraph(graph) {
-  return _graphBuildInfoByGraph.get(graph) ?? _lastGraphBuildInfo;
-}
-export function graphBuildInfoIsTrustworthy(graph) {
-  return _graphBuildInfoByGraph.has(graph) || !_anyGraphStamped;
-}
-function updateGraphBuildInfo(graph, patch) {
-  const info = { ...getGraphBuildInfoForGraph(graph), ...patch };
-  setGraphBuildInfo(graph, info);
-  return info;
-}
-export function clearGraphCache() {
-  _buildCache.clear();
-}
-export function clearReviewGraphWorkspaceCache(cwd) {
-  if (cwd === undefined) {
-    _buildCache.clear();
-    for (const entry of _workspaceGraphCache.values())
-      clearWorkspaceGraphTimer(entry);
-    _workspaceGraphCache.clear();
-    _sourcePathMemos.clear();
-    _workspaceCacheEpoch++;
-    _sizeSkipVerdicts.clear();
-    _retainedGraphSites.clear();
-  } else {
-    const normalized = normalizeMapKey(cwd);
-    const buildWorkspace = buildCacheWorkspaceKey(cwd);
-    for (const key of _buildCache.keys()) {
-      if (buildCacheKeyWorkspace(key) === buildWorkspace) {
-        _buildCache.delete(key);
-      }
-    }
-    const entry = _workspaceGraphCache.get(normalized);
-    if (entry)
-      clearWorkspaceGraphTimer(entry);
-    _workspaceCacheEpochs.set(normalized, (_workspaceCacheEpochs.get(normalized) ?? 0) + 1);
-    _workspaceGraphCache.delete(normalized);
-    _sourcePathMemos.delete(normalized);
-    _sizeSkipVerdicts.delete(normalized);
-  }
-  _lastGraphBuildInfo = { reused: false, mode: "full", graphChanged: true };
-  _anyGraphStamped = false;
-}
-let _reviewGraphBuildGateForTests;
-export function _setReviewGraphBuildGateForTests(gate) {
-  _reviewGraphBuildGateForTests = gate;
-}
-const REVIEW_GRAPH_NODE_RESIDENT_BYTES = 450.5;
-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;
-}
-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;
-}
-function retainedGraph(cwd, graph) {
-  const nodes = graph.nodes.size;
-  const edges = graph.edges.length;
-  const bytes = estimateReviewGraphStoreBytes(nodes, edges);
-  const budget = graphMaxInMemoryBytes();
-  if (bytes <= budget)
-    return graph;
-  const elementCap = Math.max(1, Math.floor((nodes + edges) * budget / bytes));
-  let capped = capGraphForPersist(cwd, graph, elementCap);
-  if (capped.nodes.size === 0 && nodes > 0) {
-    capped = headSliceGraph(graph, elementCap);
-    incrementDegradationCount({
-      kind: "review-graph-memory-cap-floor",
-      subject: cwd,
-      reason: `centrality selection retained 0 of ${nodes} nodes at cap ${elementCap}; fell back to a ${capped.nodes.size}-node head slice`
-    });
-  }
-  const cappedNodes = capped.nodes.size;
-  const cappedEdges = capped.edges.length;
-  capped.persistCoverage = {
-    ...capped.persistCoverage ?? graphCoverage(capped, elementCap),
-    partial: true,
-    capTrimmed: true
-  };
-  incrementDegradationCount({
-    kind: "review-graph-memory-cap",
-    subject: cwd,
-    reason: `live graph ${nodes}n/${edges}e ~${Math.round(bytes / (1024 * 1024))}MiB over ${Math.round(budget / (1024 * 1024))}MiB budget; trimmed to ${cappedNodes}n/${cappedEdges}e ~${Math.round(estimateReviewGraphStoreBytes(cappedNodes, cappedEdges) / (1024 * 1024))}MiB`
-  });
-  return capped;
-}
-function headSliceGraph(graph, cap) {
-  const nodeBudget = Math.max(1, Math.floor(cap * graph.nodes.size / (graph.nodes.size + graph.edges.length)));
-  const keptIds = new Set;
-  for (const [id] of graph.nodes) {
-    if (keptIds.size >= nodeBudget)
-      break;
-    keptIds.add(id);
-  }
-  const nodes = new Map([...graph.nodes].filter(([id]) => keptIds.has(id)));
-  const edgeBudget = Math.max(0, cap - nodes.size);
-  const edges = graph.edges.filter((edge) => keptIds.has(edge.from) && keptIds.has(edge.to)).slice(0, edgeBudget);
-  const sliced = {
-    ...graph,
-    nodes,
-    edges,
-    edgesByFrom: new Map,
-    edgesByTo: new Map,
-    fileNodes: new Map,
-    symbolNodesByFile: new Map,
-    changedSymbolsByFile: new Map,
-    persistCoverage: undefined
-  };
-  rebuildIndexes(sliced);
-  return sliced;
-}
-function setSessionReviewGraphFact(cwd, facts, graph) {
-  const retained = retainedGraph(cwd, graph);
-  registerRetainedGraph(`fact:${cwd}`, retained);
-  facts.setSessionFact("session.reviewGraph", retained);
-}
-const _retainedGraphSites = new Map;
-function registerRetainedGraph(site, graph) {
-  for (const [key, ref] of _retainedGraphSites) {
-    if (ref.deref() === undefined)
-      _retainedGraphSites.delete(key);
-  }
-  _retainedGraphSites.set(site, new WeakRef(graph));
-}
-export function getReviewGraphWorkspaceCacheSnapshot() {
-  let totalNodes = 0;
-  let totalEdges = 0;
-  const counted = new Set;
-  const count = (graph) => {
-    if (counted.has(graph))
-      return;
-    counted.add(graph);
-    totalNodes += graph.nodes.size;
-    totalEdges += graph.edges.length;
-  };
-  for (const entry of _workspaceGraphCache.values())
-    count(entry.graph);
-  for (const [key, ref] of _retainedGraphSites) {
-    const graph = ref.deref();
-    if (graph === undefined) {
-      _retainedGraphSites.delete(key);
-      continue;
-    }
-    count(graph);
-  }
-  return {
-    cacheEntries: _workspaceGraphCache.size,
-    totalNodes,
-    totalEdges,
-    residentBytes: estimateReviewGraphStoreBytes(totalNodes, totalEdges)
-  };
-}
-export function _getReviewGraphWorkspaceCacheKeysForTests() {
-  return [..._workspaceGraphCache.entries()].sort(([, a], [, b]) => a.lastUsedAt - b.lastUsedAt).map(([key]) => key);
-}
-export function _setReviewGraphWorkspaceEntryForTests(key, graph) {
-  setWorkspaceGraph(key, {
-    signature: "test",
-    fileSignatures: new Map,
-    graph
-  });
-}
-export function _setSessionReviewGraphFactForTests(cwd, facts, graph) {
-  setSessionReviewGraphFact(cwd, facts, graph);
-}
-export function _persistedCoverageForTests(coverage) {
-  return stripProcessLocalCoverage(coverage);
-}
-export function _getReviewGraphWorkspaceGraphForTests(key) {
-  return _workspaceGraphCache.get(key)?.graph;
-}
-export function _getReviewGraphCacheStateForTests(cwd) {
-  const cached = _workspaceGraphCache.get(normalizeMapKey(cwd));
-  if (!cached)
-    return;
-  touchWorkspaceGraph(normalizeMapKey(cwd));
-  return {
-    signature: cached.signature,
-    fileSignatures: new Map(cached.fileSignatures),
-    fileHashes: cached.fileHashes ? new Map(cached.fileHashes) : undefined
-  };
-}
-export function getReviewGraphCacheIdentity(cwd, graph) {
-  const cached = _workspaceGraphCache.get(normalizeMapKey(cwd));
-  if (!cached)
-    return;
-  touchWorkspaceGraph(normalizeMapKey(cwd));
-  if (graph) {
-    if (cached.buildGeneration === undefined && graph.buildGeneration === undefined) {
-      if (cached.graph !== graph)
-        return;
-    } else if (cached.buildGeneration !== graph.buildGeneration) {
-      return;
-    }
-  }
-  const version = graph?.version ?? cached.graph.version;
-  if (typeof version !== "string" || version.length === 0 || typeof cached.signature !== "string") {
-    return;
-  }
-  return { version, signature: cached.signature };
-}
-const _cwdWorktreeCheckedCwds = new Set;
-export function _resetCwdWorktreeMismatchLogForTests() {
-  _cwdWorktreeCheckedCwds.clear();
-}
-function logCwdWorktreeMismatchOnce(cwd, resolveIdentity = resolveGitIdentity) {
-  const key = normalizeMapKey(cwd);
-  if (_cwdWorktreeCheckedCwds.has(key))
-    return;
-  _cwdWorktreeCheckedCwds.add(key);
-  const identity = resolveIdentity(cwd);
-  if (!identity)
-    return;
-  if (identity.worktreeRoot === normalizeFilePath(path.resolve(cwd)))
-    return;
-  logLatency({
-    type: "phase",
-    phase: "review_graph_cwd_worktree_mismatch",
-    filePath: cwd,
-    durationMs: 0,
-    metadata: { cwd, worktreeRoot: identity.worktreeRoot }
-  });
-}
-export function getLastGraphBuildInfo() {
-  return _lastGraphBuildInfo;
-}
-export function _setLastGraphBuildInfoForTests(info) {
-  _lastGraphBuildInfo = info;
-}
-function ensureIndexed(graph) {
-  if (graph.edges.length > 0 && graph.edgesByFrom.size === 0) {
-    rebuildIndexes(graph);
-  }
-}
-export function getCachedReviewGraph(cwd) {
-  const key = normalizeMapKey(cwd);
-  if (getReviewGraphSizeSkipVerdict(cwd))
-    return;
-  const cached = _workspaceGraphCache.get(key);
-  if (cached) {
-    touchWorkspaceGraph(key);
-    ensureIndexed(cached.graph);
-    return cached.graph;
-  }
-  const disk = loadPersistedGraph(cwd, {
-    verifyWorktreeIdentity: true,
-    allowPartial: true
-  });
-  if (!disk)
-    return;
-  setWorkspaceGraph(key, {
-    signature: disk.signature,
-    fileSignatures: disk.fileSignatures,
-    fileHashes: disk.fileHashes,
-    graph: disk.graph,
-    ...disk.stampedHead ? { snapshotStampedHead: disk.stampedHead } : {}
-  });
-  return disk.graph;
-}
-export function getReviewGraphRevisionDrift(cwd) {
-  const entry = _workspaceGraphCache.get(normalizeMapKey(cwd));
-  const stampedHead = entry?.snapshotStampedHead;
-  if (!stampedHead)
-    return;
-  const current = resolveGitIdentity(cwd);
-  if (!current || current.headCommit === stampedHead)
-    return;
-  return { stampedHead, currentHead: current.headCommit };
-}
-
-export { formatReviewGraphRevisionDriftNote };
-function makeCtx(filePath, cwd, facts) {
-  return {
-    filePath,
-    cwd,
-    kind: detectFileKind(filePath),
-    fileRole: detectFileRole(filePath),
-    pi: { getFlag: () => {
-      return;
-    } },
-    autofix: false,
-    deltaMode: false,
-    facts,
-    blockingOnly: false,
-    modifiedRanges: undefined,
-    hasTool: async () => false,
-    log: () => {}
-  };
-}
-function createEmptyGraph() {
-  return {
-    version: REVIEW_GRAPH_VERSION,
-    builtAt: new Date().toISOString(),
-    nodes: new Map,
-    edges: [],
-    edgesByFrom: new Map,
-    edgesByTo: new Map,
-    fileNodes: new Map,
-    symbolNodesByFile: new Map,
-    changedSymbolsByFile: new Map
-  };
-}
-function cloneGraph(graph) {
-  return {
-    version: graph.version,
-    builtAt: graph.builtAt,
-    nodes: new Map(graph.nodes),
-    edges: [...graph.edges],
-    edgesByFrom: new Map,
-    edgesByTo: new Map,
-    fileNodes: new Map,
-    symbolNodesByFile: new Map,
-    changedSymbolsByFile: new Map(graph.changedSymbolsByFile),
-    persistCoverage: graph.persistCoverage
-  };
-}
-function refreshGraphBuiltAt(graph) {
-  graph.builtAt = new Date().toISOString();
-}
-function sourceSignatureEntry(file) {
-  try {
-    const stat = fs.statSync(file);
-    return `${stat.size}:${stat.mtimeMs}`;
-  } catch {
-    return "missing";
-  }
-}
-const STAT_YIELD_EVERY = 100;
-const yieldToLoop = () => new Promise((resolve) => setImmediate(resolve));
-async function sourceSignatureMapAsync(files) {
-  const signatures = new Map;
-  let sinceYield = 0;
-  for (const file of files) {
-    signatures.set(file, sourceSignatureEntry(file));
-    if (++sinceYield >= STAT_YIELD_EVERY) {
-      sinceYield = 0;
-      await yieldToLoop();
-    }
-  }
-  return signatures;
-}
-function sourceSignatureFromMap(signatures) {
-  return [...signatures.entries()].sort(([a], [b]) => compareOrdinal(a, b)).map(([file, signature]) => `${file}:${signature}`).join("|");
-}
-function contentHashEntry(file) {
-  try {
-    return createHash("sha256").update(fs.readFileSync(file)).digest("hex");
-  } catch {
-    return "missing";
-  }
-}
-async function confirmContentChanged(candidates, previousHashes) {
-  const prior = previousHashes ?? new Map;
-  const hashes = new Map(prior);
-  const trulyChanged = [];
-  let sinceYield = 0;
-  for (const file of candidates) {
-    const hash = contentHashEntry(file);
-    hashes.set(file, hash);
-    if (prior.get(file) !== hash)
-      trulyChanged.push(file);
-    if (++sinceYield >= STAT_YIELD_EVERY) {
-      sinceYield = 0;
-      await yieldToLoop();
-    }
-  }
-  return { trulyChanged, hashes };
-}
-function diffSignatureMaps(previous, next) {
-  const added = [];
-  const changed = [];
-  for (const [file, signature] of next) {
-    const oldSignature = previous.get(file);
-    if (oldSignature === undefined)
-      added.push(file);
-    else if (oldSignature !== signature)
-      changed.push(file);
-  }
-  const removed = [];
-  for (const file of previous.keys()) {
-    if (!next.has(file))
-      removed.push(file);
-  }
-  return { added, removed, changed };
-}
-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);
-}
-function getReviewGraphMaxFileBytes() {
-  const override = Number.parseInt(process.env.DM_LENS_REVIEW_GRAPH_MAX_FILE_BYTES ?? "", 10);
-  return Number.isFinite(override) && override > 0 ? override : RUNTIME_CONFIG.reviewGraph.maxFileBytes;
-}
-function isWithinReviewGraphSizeLimit(file) {
-  try {
-    return fs.statSync(file).size <= getReviewGraphMaxFileBytes();
-  } catch {
-    return false;
-  }
-}
-const DEFAULT_REVIEW_GRAPH_SIZE_SKIP_TTL_MS = 15 * 60000;
-const _sizeSkipTtl = lazyEnvNumber("DM_LENS_REVIEW_GRAPH_SIZE_SKIP_TTL_MS", DEFAULT_REVIEW_GRAPH_SIZE_SKIP_TTL_MS);
-export const _resetReviewGraphSizeSkipTtlForTests = _sizeSkipTtl._resetForTests;
-const _buildAttempts = new Map;
-export function getLastReviewGraphBuildAttempt(cwd) {
-  return _buildAttempts.get(normalizeMapKey(cwd));
-}
-export function _resetReviewGraphBuildAttemptsForTests() {
-  _buildAttempts.clear();
-}
-function recordBuildAttempt(cwd, outcome, reason, buildId) {
-  const key = normalizeMapKey(cwd);
-  const prior = _buildAttempts.get(key);
-  if (prior?.buildId !== undefined && (buildId === undefined || buildId < prior.buildId)) {
-    return;
-  }
-  _buildAttempts.set(key, {
-    when: new Date().toISOString(),
-    outcome,
-    ...buildId === undefined ? {} : { buildId },
-    ...reason ? { reason } : {}
-  });
-}
-function recordPersistFailure(cwd, reason, error, pending, workerState) {
-  const prior = _buildAttempts.get(normalizeMapKey(cwd));
-  const pendingBuildId = pending?.graphMetadata.buildId;
-  const belongsToCurrentBuild = pendingBuildId === undefined || prior?.buildId === pendingBuildId;
-  if (belongsToCurrentBuild && (prior === undefined || prior.outcome === "succeeded")) {
-    recordBuildAttempt(cwd, "succeeded", `graph built but persistence failed: ${error}`, pendingBuildId);
-  }
-  logReviewGraph({
-    cwd,
-    phase: "persist_failed",
-    reason,
-    error,
-    ...pending ? {
-      observability: persistObservability(pending, {
-        status: "failed",
-        reason: workerState?.fallbackReason ?? reason,
-        workerStarted: workerState?.started,
-        workerCompleted: workerState?.completed,
-        ...workerState?.fallbackReason ? { workerFallback: true } : {}
-      })
-    } : {}
-  });
-}
-const _sizeSkipVerdicts = new Map;
-export function _resetReviewGraphSizeSkipVerdictsForTests() {
-  _sizeSkipVerdicts.clear();
-}
-function recordReviewGraphSizeSkip(cwd, sourceFileCount, maxFileCount) {
-  _sizeSkipVerdicts.set(normalizeMapKey(cwd), {
-    sourceFileCount,
-    maxFileCount,
-    sourceFileCountTruncated: true,
-    skippedAt: Date.now()
-  });
-}
-function clearReviewGraphSizeSkip(cwd) {
-  _sizeSkipVerdicts.delete(normalizeMapKey(cwd));
-}
-const REVIEW_GRAPH_SIZE_NEAR_MISS_RATIO = 0.05;
-function isReviewGraphSizeNearMiss(sourceFileCount, maxFileCount) {
-  return sourceFileCount > maxFileCount && sourceFileCount <= maxFileCount * (1 + REVIEW_GRAPH_SIZE_NEAR_MISS_RATIO);
-}
-export function getReviewGraphSizeSkipVerdict(cwd, now = Date.now()) {
-  const key = normalizeMapKey(cwd);
-  const verdict = _sizeSkipVerdicts.get(key);
-  if (!verdict)
-    return;
-  if (now - verdict.skippedAt >= _sizeSkipTtl.get()) {
-    _sizeSkipVerdicts.delete(key);
-    return;
-  }
-  return verdict;
-}
-let _reviewGraphEntryBudgetForTests;
-export function _setReviewGraphEntryBudgetForTests(maxScanEntries) {
-  _reviewGraphEntryBudgetForTests = maxScanEntries;
-}
-let _reviewGraphEntryCounterForTests;
-export function _setReviewGraphEntryCounterForTests(counter) {
-  _reviewGraphEntryCounterForTests = counter;
-}
-export async function getGraphSourceFiles(cwd) {
-  const sourceMemo = sourcePathMemo(cwd);
-  const normalizeCallsBefore = sourceMemo.normalizeCalls.value;
-  const maxGraphFiles = getReviewGraphMaxFiles(cwd);
-  const { files: collected, entryBudgetExceeded } = await collectProjectSourceFilesWithBudgetAsync(cwd, {
-    extensions: MAIN_KIND_EXTENSIONS,
-    maxFiles: maxGraphFiles + 1,
-    ..._reviewGraphEntryBudgetForTests === undefined ? {} : { maxScanEntries: _reviewGraphEntryBudgetForTests },
-    ..._reviewGraphEntryCounterForTests === undefined ? {} : { onEntryVisited: _reviewGraphEntryCounterForTests }
-  });
-  if (entryBudgetExceeded) {
-    logLatency({
-      type: "phase",
-      phase: "review_graph_source_walk_entry_budget",
-      filePath: cwd,
-      durationMs: 0,
-      metadata: { cwd, collectedFiles: collected.length }
-    });
-  }
-  if (collected.length > maxGraphFiles) {
-    return {
-      files: collected,
-      pathNormalizeCalls: sourceMemo.normalizeCalls.value - normalizeCallsBefore,
-      sourceFileCount: collected.length,
-      maxFileCount: maxGraphFiles,
-      entryBudgetExceeded
-    };
-  }
-  const result = [];
-  let sinceYield = 0;
-  for (const raw of collected) {
-    const file = normalizeGraphSourcePath(sourceMemo, raw);
-    const kind = detectFileKind(file);
-    if (!!kind && MAIN_KINDS.has(kind) && detectFileRole(file) !== "test" && isWithinReviewGraphSizeLimit(file)) {
-      result.push(file);
-    }
-    if (++sinceYield >= STAT_YIELD_EVERY) {
-      sinceYield = 0;
-      await yieldToLoop();
-    }
-  }
-  return {
-    files: result,
-    pathNormalizeCalls: sourceMemo.normalizeCalls.value - normalizeCallsBefore,
-    sourceFileCount: result.length,
-    maxFileCount: maxGraphFiles,
-    entryBudgetExceeded
-  };
-}
-function addNode(graph, node) {
-  const isNew = !graph.nodes.has(node.id);
-  graph.nodes.set(node.id, node);
-  if (node.kind === "file" && node.filePath) {
-    graph.fileNodes.set(node.filePath, node.id);
-    return;
-  }
-  if (isNew && node.kind === "symbol" && node.filePath) {
-    const ids = graph.symbolNodesByFile.get(node.filePath) ?? [];
-    ids.push(node.id);
-    graph.symbolNodesByFile.set(node.filePath, ids);
-  }
-}
-function indexEdge(graph, edge) {
-  const from = graph.edgesByFrom.get(edge.from) ?? [];
-  from.push(edge);
-  graph.edgesByFrom.set(edge.from, from);
-  const to = graph.edgesByTo.get(edge.to) ?? [];
-  to.push(edge);
-  graph.edgesByTo.set(edge.to, to);
-}
-function unindexEdge(graph, edge) {
-  const from = graph.edgesByFrom.get(edge.from);
-  if (from) {
-    _rebuildCounters.removeOwnedEdgePositions += from.length;
-    const at = from.indexOf(edge);
-    if (at >= 0)
-      from.splice(at, 1);
-    if (from.length === 0)
-      graph.edgesByFrom.delete(edge.from);
-  }
-  const to = graph.edgesByTo.get(edge.to);
-  if (to) {
-    _rebuildCounters.removeOwnedEdgePositions += to.length;
-    const at = to.indexOf(edge);
-    if (at >= 0)
-      to.splice(at, 1);
-    if (to.length === 0)
-      graph.edgesByTo.delete(edge.to);
-  }
-}
-function unindexEdges(graph, removedEdges) {
-  const fromIds = new Set;
-  const toIds = new Set;
-  for (const edge of removedEdges) {
-    fromIds.add(edge.from);
-    toIds.add(edge.to);
-  }
-  for (const fromId of fromIds) {
-    const bucket = graph.edgesByFrom.get(fromId);
-    if (!bucket)
-      continue;
-    const kept = [];
-    for (const edge of bucket) {
-      _rebuildCounters.removeOwnedEdgePositions++;
-      if (!removedEdges.has(edge))
-        kept.push(edge);
-    }
-    if (kept.length === 0)
-      graph.edgesByFrom.delete(fromId);
-    else
-      graph.edgesByFrom.set(fromId, kept);
-  }
-  for (const toId of toIds) {
-    const bucket = graph.edgesByTo.get(toId);
-    if (!bucket)
-      continue;
-    const kept = [];
-    for (const edge of bucket) {
-      _rebuildCounters.removeOwnedEdgePositions++;
-      if (!removedEdges.has(edge))
-        kept.push(edge);
-    }
-    if (kept.length === 0)
-      graph.edgesByTo.delete(toId);
-    else
-      graph.edgesByTo.set(toId, kept);
-  }
-}
-function addEdge(graph, edge) {
-  graph.edges.push(edge);
-  indexEdge(graph, edge);
-}
-function rebuildIndexes(graph) {
-  graph.edgesByFrom = new Map;
-  graph.edgesByTo = new Map;
-  graph.fileNodes = new Map;
-  graph.symbolNodesByFile = new Map;
-  for (const node of graph.nodes.values()) {
-    if (node.kind === "file" && node.filePath) {
-      graph.fileNodes.set(node.filePath, node.id);
-    }
-    if (node.kind === "symbol" && node.filePath) {
-      const ids = graph.symbolNodesByFile.get(node.filePath) ?? [];
-      ids.push(node.id);
-      graph.symbolNodesByFile.set(node.filePath, ids);
-    }
-  }
-  for (const edge of graph.edges) {
-    const from = graph.edgesByFrom.get(edge.from) ?? [];
-    from.push(edge);
-    graph.edgesByFrom.set(edge.from, from);
-    const to = graph.edgesByTo.get(edge.to) ?? [];
-    to.push(edge);
-    graph.edgesByTo.set(edge.to, to);
-  }
-}
-const GRAPH_CACHE_FILENAME = "review-graph.json.gz";
-const LEGACY_GRAPH_CACHE_FILENAME = "review-graph.json";
-const GRAPH_CHECKPOINT_FILENAME = "review-graph.checkpoint.json.gz";
-function logSnapshotReadVerdict(cwd, phase, reason) {
-  const verdict = phase === "snapshot_read_dropped" ? "dropped" : "drifted";
-  const isRisingEdge = incrementDegradationCount({
-    kind: "review-graph-snapshot-read",
-    subject: `${verdict}:${normalizeMapKey(cwd)}`,
-    reason
-  });
-  if (!isRisingEdge)
-    return;
-  logReviewGraph({ cwd, phase, reason });
-}
-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);
-  try {
-    const raw = fs.existsSync(cachePath) ? gunzipSync(fs.readFileSync(cachePath)).toString("utf-8") : fs.readFileSync(legacyPath, "utf-8");
-    const data = JSON.parse(raw);
-    if (data.version !== REVIEW_GRAPH_VERSION || typeof data.signature !== "string" || typeof data.builtAt !== "string" || !Array.isArray(data.nodes) || !Array.isArray(data.edges))
-      return null;
-    if (data.coverage?.partial && !opts?.allowPartial)
-      return null;
-    let stampedHead;
-    if (opts?.verifyWorktreeIdentity && data.gitStamp) {
-      const current = resolveIdentity(cwd);
-      if (current && current.worktreeRoot !== data.gitStamp.worktreeRoot) {
-        logSnapshotReadVerdict(cwd, "snapshot_read_dropped", "worktree_mismatch");
-        return null;
-      }
-      if (current && current.headCommit !== data.gitStamp.headCommit) {
-        stampedHead = data.gitStamp.headCommit;
-        logSnapshotReadVerdict(cwd, "snapshot_read_drifted", "head_moved");
-      }
-    }
-    const graph = {
-      version: data.version,
-      builtAt: data.builtAt,
-      nodes: new Map(data.nodes),
-      edges: data.edges,
-      edgesByFrom: new Map,
-      edgesByTo: new Map,
-      fileNodes: new Map,
-      symbolNodesByFile: new Map,
-      changedSymbolsByFile: new Map,
-      persistCoverage: data.coverage
-    };
-    rebuildIndexes(graph);
-    return {
-      signature: data.signature,
-      fileSignatures: new Map(data.fileSignatures ?? []),
-      fileHashes: new Map(data.fileHashes ?? []),
-      graph,
-      ...stampedHead ? { stampedHead } : {}
-    };
-  } catch {
-    return null;
-  }
-}
-function getPersistedReviewGraphVersion(cwd) {
-  const cacheDir = path.join(getProjectDataDir(cwd), "cache");
-  const cachePath = path.join(cacheDir, GRAPH_CACHE_FILENAME);
-  const legacyPath = path.join(cacheDir, LEGACY_GRAPH_CACHE_FILENAME);
-  if (fs.existsSync(cachePath)) {
-    let fd;
-    try {
-      fd = fs.openSync(cachePath, "r");
-      const compressed = Buffer.alloc(4096);
-      const n = fs.readSync(fd, compressed, 0, compressed.length, 0);
-      const head = gunzipSync(compressed.subarray(0, n), {
-        finishFlush: zlibConstants.Z_SYNC_FLUSH
-      }).toString("utf-8");
-      const match = head.match(/"version"\s*:\s*"([^"]+)"/);
-      return match ? match[1] : null;
-    } catch {
-      return null;
-    } finally {
-      if (fd !== undefined) {
-        try {
-          fs.closeSync(fd);
-        } catch {}
-      }
-    }
-  }
-  let fd;
-  try {
-    fd = fs.openSync(legacyPath, "r");
-    const buf = Buffer.alloc(200);
-    const n = fs.readSync(fd, buf, 0, 200, 0);
-    const match = buf.toString("utf-8", 0, n).match(/"version"\s*:\s*"([^"]+)"/);
-    return match ? match[1] : null;
-  } catch {
-    return null;
-  } finally {
-    if (fd !== undefined) {
-      try {
-        fs.closeSync(fd);
-      } catch {}
-    }
-  }
-}
-export function isReviewGraphMigrationNeeded(cwd) {
-  const version = getPersistedReviewGraphVersion(cwd);
-  return version !== null && version !== REVIEW_GRAPH_VERSION;
-}
-const GRAPH_PERSIST_DEBOUNCE_MS_DEFAULT = 1500;
-export const GRAPH_PERSIST_MAX_ELEMENTS_DEFAULT = 500000;
-function graphPersistDebounceMs() {
-  const raw = Number(process.env.DM_LENS_GRAPH_PERSIST_DEBOUNCE_MS);
-  return Number.isFinite(raw) && raw >= 0 ? raw : GRAPH_PERSIST_DEBOUNCE_MS_DEFAULT;
-}
-function graphPersistMaxElements() {
-  const raw = Number(process.env.DM_LENS_GRAPH_PERSIST_MAX_ELEMENTS);
-  return Number.isFinite(raw) && raw > 0 ? raw : GRAPH_PERSIST_MAX_ELEMENTS_DEFAULT;
-}
-const _pendingPersist = new Map;
-const _persistTimers = new Map;
-const _persistGenerations = new Map;
-const _workerRequests = new Map;
-let _persistWorker;
-let _persistWorkerRequestId = 0;
-let _persistAttemptId = 0;
-let _workerDisabled = false;
-let _persistWorkerUnavailableReason;
-let _lastWorkerFallbackReasonForTests;
-const _checkpointGenerations = new Map;
-const _checkpointWorkerRequests = new Map;
-let _checkpointOffloadCountForTests = 0;
-function persistedData(pending) {
-  return {
-    version: pending.graph.version,
-    builtAt: pending.graph.builtAt,
-    signature: pending.signature,
-    fileSignatures: Array.from(pending.fileSignatures.entries()),
-    fileHashes: pending.fileHashes ? Array.from(pending.fileHashes.entries()) : undefined,
-    nodes: Array.from(pending.graph.nodes.entries()),
-    edges: pending.graph.edges,
-    coverage: stripProcessLocalCoverage(pending.graph.persistCoverage),
-    gitStamp: pending.gitStamp
-  };
-}
-function stripProcessLocalCoverage(coverage) {
-  if (!coverage?.capTrimmed)
-    return coverage;
-  const { capTrimmed: _capTrimmed, ...persisted } = coverage;
-  return persisted;
-}
-function countRetainedSourceFiles(graph, sourceFilePaths) {
-  if (sourceFilePaths === undefined)
-    return graph.fileNodes.size;
-  const sourceKeys = new Set(sourceFilePaths);
-  let retained = 0;
-  for (const filePath of sourceKeys) {
-    if (graph.fileNodes.has(filePath))
-      retained++;
-  }
-  return retained;
-}
-function graphCoverage(graph, cap, sourceFileCount = graph.persistCoverage?.totalFiles ?? graph.fileNodes.size, sourceFilesTruncated = graph.persistCoverage?.sourceFilesTruncated === true, sourceFilePaths) {
-  const inherited = graph.persistCoverage;
-  return {
-    partial: inherited?.partial === true || sourceFilesTruncated,
-    cap,
-    totalNodes: graph.nodes.size,
-    totalEdges: graph.edges.length,
-    persistedNodes: graph.nodes.size,
-    persistedEdges: graph.edges.length,
-    totalFiles: sourceFileCount,
-    persistedFiles: countRetainedSourceFiles(graph, sourceFilePaths),
-    ...sourceFilesTruncated ? { sourceFilesTruncated: true } : {},
-    ...inherited?.inProgress ? { inProgress: true } : {}
-  };
-}
-function capGraphForPersist(cwd, graph, cap, options = {}) {
-  const totalElements = graph.nodes.size + graph.edges.length;
-  const nodeBudget = Math.max(1, Math.floor(cap * graph.nodes.size / totalElements));
-  const reverseDeps = buildReverseDependencyIndexFromGraph({ cwd, graph });
-  const rankedFiles = rankFilesByReverseDependencyCentrality(reverseDeps);
-  const indexNodesByFile = (fold) => {
-    const byFile = new Map;
-    for (const [id, node] of graph.nodes) {
-      if (!node.filePath)
-        continue;
-      const fileKey = fold ? normalizeMapKey(node.filePath) : node.filePath;
-      const ids = byFile.get(fileKey) ?? [];
-      ids.push(id);
-      byFile.set(fileKey, ids);
-    }
-    return byFile;
-  };
-  const reachableNodes = (byFile) => {
-    let reached = 0;
-    for (const filePath of rankedFiles)
-      reached += byFile.get(filePath)?.length ?? 0;
-    return reached;
-  };
-  let placeableNodes = 0;
-  for (const node of graph.nodes.values())
-    if (node.filePath)
-      placeableNodes++;
-  let nodeIdsByFile = indexNodesByFile(false);
-  if (reachableNodes(nodeIdsByFile) < placeableNodes) {
-    const folded = indexNodesByFile(true);
-    if (reachableNodes(folded) > reachableNodes(nodeIdsByFile)) {
-      nodeIdsByFile = folded;
-    }
-  }
-  const keptIds = new Set;
-  for (const filePath of rankedFiles) {
-    const ids = nodeIdsByFile.get(filePath) ?? [];
-    if (ids.length === 0)
-      continue;
-    const effectiveNodeBudget = keptIds.size === 0 ? Math.max(nodeBudget, Math.min(cap, ids.length)) : nodeBudget;
-    if (keptIds.size + ids.length > effectiveNodeBudget)
-      continue;
-    for (const id of ids)
-      keptIds.add(id);
-  }
-  const nodes = new Map([...graph.nodes].filter(([id]) => keptIds.has(id)));
-  const edgeBudget = Math.max(0, cap - nodes.size);
-  const edges = graph.edges.filter((edge) => keptIds.has(edge.from) && keptIds.has(edge.to)).slice(0, edgeBudget);
-  const coverage = {
-    partial: true,
-    cap,
-    totalNodes: graph.nodes.size,
-    totalEdges: graph.edges.length,
-    persistedNodes: nodes.size,
-    persistedEdges: edges.length,
-    totalFiles: options.sourceFileCount ?? graph.persistCoverage?.totalFiles ?? graph.fileNodes.size,
-    persistedFiles: 0,
-    ...options.sourceFilesTruncated || graph.persistCoverage?.sourceFilesTruncated ? { sourceFilesTruncated: true } : {},
-    ...graph.persistCoverage?.inProgress ? { inProgress: true } : {}
-  };
-  const capped = {
-    ...graph,
-    nodes,
-    edges,
-    edgesByFrom: new Map,
-    edgesByTo: new Map,
-    fileNodes: new Map,
-    symbolNodesByFile: new Map,
-    changedSymbolsByFile: new Map,
-    persistCoverage: undefined
-  };
-  rebuildIndexes(capped);
-  coverage.persistedFiles = countRetainedSourceFiles(capped, options.sourceFilePaths);
-  capped.persistCoverage = coverage;
-  return capped;
-}
-function persistObservability(pending, patch) {
-  return {
-    graph: pending.graphMetadata,
-    persistence: { ...pending.persistenceMetadata, ...patch }
-  };
-}
-function logPersistSuccess(key, pending, stats, workerState = { started: false, completed: false }) {
-  logLatency({
-    type: "phase",
-    phase: "review_graph_persist",
-    filePath: pending.cachePath,
-    durationMs: stats.durationMs,
-    metadata: { elements: pending.elementCount, ...stats }
-  });
-  logReviewGraph({
-    cwd: key,
-    phase: "persist_succeeded",
-    elements: pending.elementCount,
-    ...stats,
-    durationMs: stats.durationMs,
-    observability: persistObservability(pending, {
-      status: "succeeded",
-      workerStarted: workerState.started,
-      workerCompleted: workerState.completed,
-      ...workerState.fallback ? { workerFallback: true } : {}
-    })
-  });
-}
-function writePendingOnMainThread(key, pending, reason, workerState = { started: false, completed: false }) {
-  const persistStarted = performance.now();
-  const serializeStarted = performance.now();
-  try {
-    const json = JSON.stringify(persistedData(pending));
-    const serializeMs = performance.now() - serializeStarted;
-    const rawBytes = Buffer.byteLength(json);
-    const writeStarted = performance.now();
-    const gzip = gzipSync(json);
-    fs.mkdirSync(pending.cacheDir, { recursive: true });
-    writeFileAtomic(pending.cachePath, gzip, { bestEffort: false });
-    fs.rmSync(path.join(pending.cacheDir, LEGACY_GRAPH_CACHE_FILENAME), {
-      force: true
-    });
-    logPersistSuccess(key, pending, {
-      rawBytes,
-      gzBytes: gzip.byteLength,
-      serializeMs,
-      writeMs: performance.now() - writeStarted,
-      durationMs: performance.now() - persistStarted,
-      offloaded: false
-    }, {
-      started: workerState.started,
-      completed: workerState.completed,
-      fallback: Boolean(reason)
-    });
-    if (reason) {
-      _lastWorkerFallbackReasonForTests = reason;
-      logReviewGraph({
-        cwd: key,
-        phase: "worker_fallback",
-        reason: "worker_fallback",
-        error: reason,
-        offloaded: false,
-        observability: persistObservability(pending, {
-          status: "fallback",
-          workerStarted: workerState.started,
-          workerCompleted: workerState.completed,
-          workerFallback: true,
-          reason: workerState.fallbackReason ?? "worker_fallback"
-        })
-      });
-    }
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    recordPersistFailure(key, "cache_write_failed", message, pending, workerState);
-  }
-}
-function handleWorkerResult(result) {
-  const checkpoint = _checkpointWorkerRequests.get(result.id);
-  if (checkpoint) {
-    handleCheckpointWorkerResult(checkpoint, result);
-    return;
-  }
-  const request = _workerRequests.get(result.id);
-  if (!request) {
-    fs.rm(result.stagePath, { force: true }, () => {});
-    return;
-  }
-  _workerRequests.delete(result.id);
-  const { key, pending } = request;
-  const currentGeneration = _persistGenerations.get(key);
-  if (currentGeneration !== result.generation) {
-    try {
-      fs.rmSync(result.stagePath, { force: true });
-    } catch (reapErr) {
-      logReviewGraph({
-        cwd: key,
-        phase: "persist_failed",
-        reason: `superseded-stage reap failed: ${String(reapErr)}`
-      });
-    }
-    logReviewGraph({
-      cwd: key,
-      phase: "persist_skipped",
-      reason: "superseded",
-      observability: persistObservability(pending, {
-        status: "superseded",
-        supersededByGeneration: currentGeneration,
-        reason: "newer_generation_scheduled",
-        workerStarted: true,
-        workerCompleted: true
-      })
-    });
-    return;
-  }
-  if (result.error || result.rawBytes === undefined || result.gzBytes === undefined || result.serializeMs === undefined || result.writeMs === undefined || result.durationMs === undefined) {
-    fs.rm(result.stagePath, { force: true }, () => {});
-    writePendingOnMainThread(key, pending, result.error ?? "invalid worker result", {
-      started: true,
-      completed: true,
-      fallbackReason: result.error ? "worker_error" : "invalid_worker_result"
-    });
-    return;
-  }
-  try {
-    fs.renameSync(result.stagePath, pending.cachePath);
-    fs.rmSync(path.join(pending.cacheDir, LEGACY_GRAPH_CACHE_FILENAME), {
-      force: true
-    });
-    logPersistSuccess(key, pending, {
-      rawBytes: result.rawBytes,
-      gzBytes: result.gzBytes,
-      serializeMs: result.serializeMs,
-      writeMs: result.writeMs,
-      durationMs: result.durationMs,
-      offloaded: true
-    }, { started: true, completed: true });
-  } catch (err) {
-    fs.rm(result.stagePath, { force: true }, () => {});
-    writePendingOnMainThread(key, pending, err instanceof Error ? err.message : String(err), {
-      started: true,
-      completed: true,
-      fallbackReason: "promotion_failed"
-    });
-  }
-}
-function handleCheckpointWorkerResult(cp, result) {
-  _checkpointWorkerRequests.delete(result.id);
-  if (result.error || result.gzBytes === undefined) {
-    logReviewGraph({
-      cwd: cp.cwd,
-      phase: "checkpoint_write_failed",
-      reason: "worker_error",
-      error: result.error ?? "worker returned no gz metrics"
-    });
-    fs.rm(result.stagePath, { force: true }, () => {});
-    return;
-  }
-  if (_checkpointGenerations.get(cp.cwd) !== cp.generation) {
-    fs.rm(result.stagePath, { force: true }, () => {});
-    return;
-  }
-  try {
-    fs.renameSync(result.stagePath, cp.checkpointPath);
-    logReviewGraph({
-      cwd: cp.cwd,
-      phase: "checkpoint_written",
-      nodes: cp.nodes,
-      edges: cp.edges,
-      processed: cp.processed,
-      target: cp.target,
-      offloaded: true
-    });
-  } catch (err) {
-    logReviewGraph({
-      cwd: cp.cwd,
-      phase: "checkpoint_write_failed",
-      reason: "promote_failed",
-      error: err instanceof Error ? err.message : String(err)
-    });
-    fs.rm(result.stagePath, { force: true }, () => {});
-  }
-}
-function handleWorkerDeath(reason) {
-  _persistWorkerUnavailableReason = reason;
-  _persistWorker = undefined;
-  _workerDisabled = true;
-  const requests = [..._workerRequests.values()];
-  _workerRequests.clear();
-  for (const { key, pending } of requests) {
-    if (_persistGenerations.get(key) !== pending.generation) {
-      logReviewGraph({
-        cwd: key,
-        phase: "persist_skipped",
-        reason: "superseded",
-        observability: persistObservability(pending, {
-          status: "superseded",
-          supersededByGeneration: _persistGenerations.get(key),
-          reason: "worker_death_after_newer_generation",
-          workerStarted: true,
-          workerCompleted: false
-        })
-      });
-      continue;
-    }
-    writePendingOnMainThread(key, pending, reason, {
-      started: true,
-      completed: false,
-      fallbackReason: "worker_death"
-    });
-  }
-  const checkpoints = [..._checkpointWorkerRequests.values()];
-  _checkpointWorkerRequests.clear();
-  for (const cp of checkpoints) {
-    logReviewGraph({
-      cwd: cp.cwd,
-      phase: "checkpoint_write_failed",
-      reason: "worker_death",
-      error: reason
-    });
-    fs.rm(cp.stagePath, { force: true }, () => {});
-  }
-}
-function resolvePersistWorkerPath() {
-  const candidates = [
-    new URL("./persist-worker.js", import.meta.url),
-    new URL("./clients/review-graph/persist-worker.js", import.meta.url)
-  ];
-  for (const url of candidates) {
-    try {
-      const resolved = fileURLToPath(url);
-      if (fs.existsSync(resolved))
-        return resolved;
-    } catch {}
-  }
-  return;
-}
-function getPersistWorker() {
-  if (_workerDisabled)
-    return;
-  if (_persistWorker)
-    return _persistWorker;
-  try {
-    const workerPath = resolvePersistWorkerPath();
-    if (workerPath === undefined) {
-      handleWorkerDeath("persist worker script not found in any layout");
-      return;
-    }
-    const worker = new Worker(workerPath);
-    worker.on("message", handleWorkerResult);
-    worker.on("error", (err) => handleWorkerDeath(err.message));
-    worker.on("exit", (code) => {
-      if (_persistWorker !== worker)
-        return;
-      const hasPendingRequests = _workerRequests.size > 0 || _checkpointWorkerRequests.size > 0;
-      if (code !== 0 || hasPendingRequests) {
-        handleWorkerDeath(code !== 0 ? `persist worker exited with code ${code}` : "persist worker exited with pending requests");
-      } else {
-        _persistWorker = undefined;
-      }
-    });
-    worker.unref();
-    _persistWorker = worker;
-    return worker;
-  } catch (err) {
-    handleWorkerDeath(err instanceof Error ? err.message : String(err));
-    return;
-  }
-}
-function writePending(key) {
-  const pending = _pendingPersist.get(key);
-  if (!pending)
-    return;
-  _pendingPersist.delete(key);
-  const timer = _persistTimers.get(key);
-  if (timer) {
-    clearTimeout(timer);
-    _persistTimers.delete(key);
-  }
-  const worker = getPersistWorker();
-  if (!worker) {
-    const unavailableReason = _persistWorkerUnavailableReason ?? "persist worker unavailable";
-    writePendingOnMainThread(key, pending, unavailableReason, {
-      started: false,
-      completed: false,
-      fallbackReason: unavailableReason
-    });
-    return;
-  }
-  const id = ++_persistWorkerRequestId;
-  const stagePath = `${pending.cachePath}.stage-${process.pid}-${pending.generation}`;
-  const request = {
-    id,
-    cwd: key,
-    generation: pending.generation,
-    stagePath,
-    data: persistedData(pending),
-    elements: pending.elementCount,
-    testDelayMs: undefined
-  };
-  _workerRequests.set(id, { key, pending });
-  worker.postMessage(request);
-}
-let _persistExitHookInstalled = false;
-function flushPendingReviewGraphPersistsAtExit() {
-  const keys = new Set([
-    ..._pendingPersist.keys(),
-    ...[..._workerRequests.values()].map((request) => request.key)
-  ]);
-  for (const key of keys) {
-    flushReviewGraphPersist(key, "exit_hook");
-  }
-  flushReviewGraphLogSync();
-  _persistWorker?.terminate();
-}
-export function flushReviewGraphPersistsForExitForTests() {
-  flushPendingReviewGraphPersistsAtExit();
-}
-function ensurePersistExitHook() {
-  if (_persistExitHookInstalled)
-    return;
-  _persistExitHookInstalled = true;
-  process.once("exit", flushPendingReviewGraphPersistsAtExit);
-}
-const _sweptStageDirs = new Set;
-const REVIEW_GRAPH_ARTIFACT_PREFIX = "review-graph.";
-const STAGE_PID_PATTERN = /\.stage-(\d+)-/;
-function isStaleReviewGraphStageFile(entry) {
-  if (!entry.startsWith(REVIEW_GRAPH_ARTIFACT_PREFIX))
-    return false;
-  const match = STAGE_PID_PATTERN.exec(entry);
-  if (!match)
-    return false;
-  const pid = Number(match[1]);
-  if (pid === process.pid)
-    return false;
-  return !realIsPidAlive(pid);
-}
-function sweepStaleStageFiles(cacheDir) {
-  if (_sweptStageDirs.has(cacheDir))
-    return;
-  _sweptStageDirs.add(cacheDir);
-  fs.readdir(cacheDir, (err, entries) => {
-    if (err)
-      return;
-    for (const entry of entries) {
-      if (!isStaleReviewGraphStageFile(entry))
-        continue;
-      fs.rm(path.join(cacheDir, entry), { force: true }, () => {});
-    }
-  });
-}
-export function _resetReviewGraphStageSweepForTests() {
-  _sweptStageDirs.clear();
-}
-function persistGraph(cwd, signature, fileSignatures, fileHashes, graph, options = {}) {
-  const totalElementCount = graph.nodes.size + graph.edges.length;
-  const cap = graphPersistMaxElements();
-  const sourceFileCount = options.sourceFileCount ?? fileSignatures.size;
-  const sourceFilePaths = options.sourceFilePaths ?? fileSignatures.keys();
-  const persistedGraph = totalElementCount > cap ? capGraphForPersist(cwd, graph, cap, {
-    sourceFileCount,
-    sourceFilesTruncated: options.sourceFilesTruncated,
-    sourceFilePaths
-  }) : {
-    ...graph,
-    persistCoverage: graphCoverage(graph, cap, sourceFileCount, options.sourceFilesTruncated, sourceFilePaths)
-  };
-  const elementCount = persistedGraph.nodes.size + persistedGraph.edges.length;
-  const sourceWalkPartial = persistedGraph.persistCoverage?.sourceFilesTruncated === true;
-  let persistReason;
-  if (totalElementCount > cap) {
-    const coverage = persistedGraph.persistCoverage;
-    if (!coverage)
-      return;
-    logLatency({
-      type: "phase",
-      phase: "review_graph_persist",
-      filePath: cwd,
-      durationMs: 0,
-      metadata: {
-        partial: true,
-        totalElements: totalElementCount,
-        persistedElements: elementCount,
-        cap
-      }
-    });
-    persistReason = `persisted partial review graph (${elementCount}/${totalElementCount} elements; ` + `${coverage.persistedNodes}/${coverage.totalNodes} nodes, ` + `${coverage.persistedEdges}/${coverage.totalEdges} edges; ${cap} cap)`;
-  } else if (sourceWalkPartial) {
-    persistReason = "persisted partial review graph (source walk entry budget)";
-  }
-  const cacheDir = path.join(getProjectDataDir(cwd), "cache");
-  const cachePath = path.join(cacheDir, GRAPH_CACHE_FILENAME);
-  sweepStaleStageFiles(cacheDir);
-  const gitStamp = (options.resolveIdentity ?? resolveGitIdentity)(cwd);
-  const key = normalizeMapKey(cwd);
-  const priorGeneration = _persistGenerations.get(key);
-  const existingPending = _pendingPersist.get(key);
-  const existingTimer = _persistTimers.get(key);
-  const generation = (priorGeneration ?? 0) + 1;
-  const attemptId = ++_persistAttemptId;
-  const coalesced = Boolean(existingPending || existingTimer);
-  _persistGenerations.set(key, generation);
-  const graphMetadata = graphLogMetadata(persistedGraph, {
-    ...options,
-    sourceFileCount,
-    sourceFileCountTruncated: persistedGraph.persistCoverage?.sourceFilesTruncated === true
-  });
-  const persistenceMetadata = {
-    generation,
-    attemptId,
-    status: "scheduled",
-    ...priorGeneration === undefined ? {} : {
-      supersededGeneration: priorGeneration,
-      coalesced,
-      reason: coalesced ? "debounced_coalescing" : "in_flight_supersession"
-    }
-  };
-  const pending = {
-    cacheDir,
-    cachePath,
-    signature,
-    fileSignatures,
-    fileHashes,
-    graph: persistedGraph,
-    gitStamp,
-    elementCount,
-    generation,
-    attemptId,
-    graphMetadata,
-    persistenceMetadata
-  };
-  if (existingPending) {
-    logReviewGraph({
-      cwd: key,
-      phase: "persist_skipped",
-      reason: "superseded",
-      observability: persistObservability(existingPending, {
-        status: "superseded",
-        supersededByGeneration: generation,
-        reason: "newer_generation_scheduled",
-        workerStarted: false,
-        workerCompleted: false
-      })
-    });
-  }
-  _pendingPersist.set(key, pending);
-  if (totalElementCount > cap || sourceWalkPartial) {
-    logReviewGraph({
-      cwd,
-      phase: "persist_partial",
-      reason: totalElementCount > cap ? "element_cap_exceeded" : "source_walk_entry_budget",
-      elements: totalElementCount,
-      persistedElements: elementCount,
-      cap,
-      observability: {
-        graph: graphMetadata,
-        persistence: persistenceMetadata
-      }
-    });
-  }
-  logReviewGraph({
-    cwd,
-    phase: "persist_scheduled",
-    elements: elementCount,
-    cap,
-    observability: {
-      graph: graphMetadata,
-      persistence: persistenceMetadata
-    }
-  });
-  ensurePersistExitHook();
-  const debounce = graphPersistDebounceMs();
-  const existing = _persistTimers.get(key);
-  if (existing)
-    clearTimeout(existing);
-  if (debounce === 0) {
-    writePending(key);
-    return persistReason;
-  }
-  const timer = setTimeout(() => writePending(key), debounce);
-  if (typeof timer.unref === "function")
-    timer.unref();
-  _persistTimers.set(key, timer);
-  return persistReason;
-}
-const GRAPH_CHECKPOINT_EVERY_FILES_DEFAULT = 250;
-const GRAPH_CHECKPOINT_MIN_INTERVAL_MS_DEFAULT = 5000;
-function graphCheckpointEveryFiles() {
-  const raw = Number(process.env.DM_LENS_GRAPH_CHECKPOINT_EVERY_FILES);
-  return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : GRAPH_CHECKPOINT_EVERY_FILES_DEFAULT;
-}
-function graphCheckpointMinIntervalMs() {
-  const raw = Number(process.env.DM_LENS_GRAPH_CHECKPOINT_MIN_INTERVAL_MS);
-  return Number.isFinite(raw) && raw >= 0 ? raw : GRAPH_CHECKPOINT_MIN_INTERVAL_MS_DEFAULT;
-}
-function reviewGraphCheckpointPath(cwd) {
-  return path.join(getProjectDataDir(cwd), "cache", GRAPH_CHECKPOINT_FILENAME);
-}
-function hashIgnoredIds(ignoredIds) {
-  if (ignoredIds === undefined)
-    return "unavailable";
-  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, resolveIdentity = resolveGitIdentity) {
-  return {
-    version: REVIEW_GRAPH_VERSION,
-    builtAt: new Date().toISOString(),
-    inProgress: true,
-    targetFileCount,
-    processedFiles: Array.from(processedHashes.entries()),
-    ignoredIdsHash: hashIgnoredIds(ignoredIds),
-    nodes: Array.from(graph.nodes.entries()),
-    edges: graph.edges,
-    gitStamp: resolveIdentity(cwd)
-  };
-}
-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, resolveIdentity);
-  } catch {
-    return;
-  }
-  const worker = _workerDisabled ? undefined : getPersistWorker();
-  if (!worker) {
-    writeReviewGraphCheckpointSync(cwd, data, {
-      nodes: graph.nodes.size,
-      edges: graph.edges.length,
-      processed: processedHashes.size,
-      target: targetFileCount
-    });
-    return;
-  }
-  const checkpointPath = reviewGraphCheckpointPath(cwd);
-  const cacheDir = path.dirname(checkpointPath);
-  try {
-    fs.mkdirSync(cacheDir, { recursive: true });
-  } catch (err) {
-    logReviewGraph({
-      cwd,
-      phase: "checkpoint_write_failed",
-      reason: "mkdir_failed",
-      error: err instanceof Error ? err.message : String(err)
-    });
-    return;
-  }
-  sweepStaleStageFiles(cacheDir);
-  ensurePersistExitHook();
-  const id = ++_persistWorkerRequestId;
-  const stagePath = `${checkpointPath}.stage-${process.pid}-${generation}`;
-  _checkpointWorkerRequests.set(id, {
-    cwd,
-    generation,
-    checkpointPath,
-    stagePath,
-    nodes: graph.nodes.size,
-    edges: graph.edges.length,
-    processed: processedHashes.size,
-    target: targetFileCount
-  });
-  const request = {
-    id,
-    cwd,
-    generation,
-    stagePath,
-    data,
-    elements: graph.nodes.size + graph.edges.length,
-    testDelayMs: undefined
-  };
-  worker.postMessage(request);
-  _checkpointOffloadCountForTests++;
-}
-function writeReviewGraphCheckpointSync(cwd, data, counts) {
-  try {
-    const gzip = gzipSync(JSON.stringify(data));
-    fs.mkdirSync(path.dirname(reviewGraphCheckpointPath(cwd)), {
-      recursive: true
-    });
-    writeFileAtomic(reviewGraphCheckpointPath(cwd), gzip, { bestEffort: true });
-    logReviewGraph({
-      cwd,
-      phase: "checkpoint_written",
-      nodes: counts.nodes,
-      edges: counts.edges,
-      processed: counts.processed,
-      target: counts.target
-    });
-  } catch (err) {
-    logReviewGraph({
-      cwd,
-      phase: "checkpoint_write_failed",
-      reason: "sync_write_failed",
-      error: err instanceof Error ? err.message : String(err)
-    });
-  }
-}
-function deleteReviewGraphCheckpoint(cwd) {
-  _checkpointGenerations.set(cwd, (_checkpointGenerations.get(cwd) ?? 0) + 1);
-  fs.rm(reviewGraphCheckpointPath(cwd), { force: true }, () => {});
-}
-function loadReviewGraphCheckpoint(cwd, resolveIdentity = resolveGitIdentity) {
-  const checkpointPath = reviewGraphCheckpointPath(cwd);
-  let data;
-  try {
-    if (!fs.existsSync(checkpointPath))
-      return null;
-    data = JSON.parse(gunzipSync(fs.readFileSync(checkpointPath)).toString("utf-8"));
-  } catch {
-    logReviewGraph({ cwd, phase: "checkpoint_discarded", reason: "corrupt" });
-    deleteReviewGraphCheckpoint(cwd);
-    return null;
-  }
-  if (data.version !== REVIEW_GRAPH_VERSION || data.inProgress !== true) {
-    logReviewGraph({
-      cwd,
-      phase: "checkpoint_discarded",
-      reason: data.version !== REVIEW_GRAPH_VERSION ? "version_mismatch" : "not_in_progress"
-    });
-    deleteReviewGraphCheckpoint(cwd);
-    return null;
-  }
-  if (data.gitStamp) {
-    const current = resolveIdentity(cwd);
-    if (current && current.worktreeRoot !== data.gitStamp.worktreeRoot) {
-      logReviewGraph({
-        cwd,
-        phase: "checkpoint_discarded",
-        reason: "worktree_mismatch"
-      });
-      deleteReviewGraphCheckpoint(cwd);
-      return null;
-    }
-  }
-  const totalNodes = data.nodes.length;
-  const totalEdges = data.edges.length;
-  const graph = {
-    version: data.version,
-    builtAt: data.builtAt,
-    nodes: new Map(data.nodes),
-    edges: data.edges,
-    edgesByFrom: new Map,
-    edgesByTo: new Map,
-    fileNodes: new Map,
-    symbolNodesByFile: new Map,
-    changedSymbolsByFile: new Map,
-    persistCoverage: {
-      partial: true,
-      inProgress: true,
-      cap: 0,
-      totalNodes,
-      totalEdges,
-      persistedNodes: totalNodes,
-      persistedEdges: totalEdges,
-      totalFiles: data.targetFileCount,
-      persistedFiles: 0
-    }
-  };
-  rebuildIndexes(graph);
-  if (graph.persistCoverage) {
-    graph.persistCoverage.persistedFiles = countRetainedSourceFiles(graph, data.processedFiles.map(([filePath]) => filePath));
-  }
-  return {
-    graph,
-    processedHashes: new Map(data.processedFiles),
-    ignoredIdsHash: data.ignoredIdsHash,
-    targetFileCount: data.targetFileCount
-  };
-}
-function pruneOrphanNonFileNodes(graph) {
-  const referenced = new Set;
-  for (const edge of graph.edges) {
-    referenced.add(edge.from);
-    referenced.add(edge.to);
-  }
-  for (const [id, node] of graph.nodes) {
-    if (!node.filePath && !referenced.has(id))
-      graph.nodes.delete(id);
-  }
-}
-async function tryResumeFromCheckpoint(cwd, filesToBuild, ignoredIds, resolveIdentity = resolveGitIdentity) {
-  const loaded = loadReviewGraphCheckpoint(cwd, resolveIdentity);
-  if (!loaded)
-    return null;
-  if (loaded.ignoredIdsHash !== hashIgnoredIds(ignoredIds)) {
-    logReviewGraph({
-      cwd,
-      phase: "checkpoint_discarded",
-      reason: "ignored_ids_mismatch",
-      processed: loaded.processedHashes.size,
-      target: filesToBuild.length
-    });
-    deleteReviewGraphCheckpoint(cwd);
-    return null;
-  }
-  const targetSet = new Set(filesToBuild);
-  for (const file of loaded.processedHashes.keys()) {
-    if (!targetSet.has(file)) {
-      logReviewGraph({
-        cwd,
-        phase: "checkpoint_discarded",
-        reason: "removed_file",
-        processed: loaded.processedHashes.size,
-        target: filesToBuild.length
-      });
-      deleteReviewGraphCheckpoint(cwd);
-      return null;
-    }
-  }
-  const reusableHashes = new Map;
-  const stale = [];
-  let sinceYield = 0;
-  for (const [file, priorHash] of loaded.processedHashes) {
-    const currentHash = contentHashEntry(file);
-    if (currentHash === priorHash)
-      reusableHashes.set(file, currentHash);
-    else
-      stale.push(file);
-    if (++sinceYield >= STAT_YIELD_EVERY) {
-      sinceYield = 0;
-      await yieldToLoop();
-    }
-  }
-  if (reusableHashes.size === 0) {
-    logReviewGraph({
-      cwd,
-      phase: "checkpoint_discarded",
-      reason: "all_stale",
-      stale: stale.length,
-      target: filesToBuild.length
-    });
-    deleteReviewGraphCheckpoint(cwd);
-    return null;
-  }
-  const graph = loaded.graph;
-  const removedEdges = new Set;
-  for (const file of stale)
-    removeFileOwnedGraphData(graph, file, removedEdges);
-  if (removedEdges.size > 0) {
-    unindexEdges(graph, removedEdges);
-    graph.edges = graph.edges.filter((edge) => !removedEdges.has(edge));
-  }
-  pruneOrphanNonFileNodes(graph);
-  graph.changedSymbolsByFile = new Map;
-  const remaining = filesToBuild.filter((file) => !reusableHashes.has(file));
-  logReviewGraph({
-    cwd,
-    phase: "checkpoint_resumed",
-    reused: reusableHashes.size,
-    stale: stale.length,
-    remaining: remaining.length,
-    target: filesToBuild.length
-  });
-  return { graph, fileHashes: reusableHashes, remaining };
-}
-export function _readReviewGraphCheckpointForTests(cwd) {
-  const loaded = loadReviewGraphCheckpoint(cwd);
-  if (!loaded)
-    return null;
-  return {
-    inProgress: loaded.graph.persistCoverage?.inProgress === true,
-    processedFiles: [...loaded.processedHashes.keys()],
-    nodeCount: loaded.graph.nodes.size,
-    edgeCount: loaded.graph.edges.length,
-    persistCoverage: loaded.graph.persistCoverage
-  };
-}
-export function flushReviewGraphPersistsForTests() {
-  for (const key of _pendingPersist.keys()) {
-    const pending = _pendingPersist.get(key);
-    if (!pending)
-      continue;
-    _pendingPersist.delete(key);
-    const timer = _persistTimers.get(key);
-    if (timer)
-      clearTimeout(timer);
-    _persistTimers.delete(key);
-    writePendingOnMainThread(key, pending);
-  }
-}
-export async function waitForReviewGraphPersistsForTests() {
-  for (let attempts = 0;attempts < 200 && (_workerRequests.size > 0 || _checkpointWorkerRequests.size > 0); attempts++) {
-    await new Promise((resolve) => setTimeout(resolve, 10));
-  }
-}
-export async function terminateReviewGraphPersistWorkerForTests() {
-  const worker = _persistWorker;
-  if (worker)
-    await worker.terminate();
-}
-export function resetReviewGraphPersistWorkerForTests() {
-  _workerDisabled = false;
-  _persistWorker = undefined;
-  _persistWorkerUnavailableReason = undefined;
-  _lastWorkerFallbackReasonForTests = undefined;
-  _checkpointWorkerRequests.clear();
-  _checkpointGenerations.clear();
-  _checkpointOffloadCountForTests = 0;
-}
-export function getCheckpointOffloadCountForTests() {
-  return _checkpointOffloadCountForTests;
-}
-export function getReviewGraphWorkerFallbackReasonForTests() {
-  return _lastWorkerFallbackReasonForTests;
-}
-export function reviewGraphCachePath(cwd) {
-  return path.join(getProjectDataDir(cwd), "cache", GRAPH_CACHE_FILENAME);
-}
-export function flushReviewGraphPersist(cwd, source = "cli") {
-  const key = normalizeMapKey(cwd);
-  let pending = _pendingPersist.get(key);
-  const removedWorkerRequests = [];
-  let selectedWorkerRequest;
-  for (const [id, request] of _workerRequests) {
-    if (request.key !== key)
-      continue;
-    _workerRequests.delete(id);
-    removedWorkerRequests.push(request.pending);
-    if (!pending || request.pending.generation > pending.generation) {
-      pending = request.pending;
-      selectedWorkerRequest = request.pending;
-    }
-  }
-  for (const removed of removedWorkerRequests) {
-    if (!pending || removed.generation === pending.generation)
-      continue;
-    logReviewGraph({
-      cwd: key,
-      phase: "persist_skipped",
-      reason: "superseded",
-      observability: persistObservability(removed, {
-        status: "superseded",
-        supersededByGeneration: pending.generation,
-        reason: "forced_flush_newest_generation",
-        workerStarted: true,
-        workerCompleted: false
-      })
-    });
-  }
-  if (!pending) {
-    return {
-      ok: false,
-      reason: "no graph snapshot was queued for persistence"
-    };
-  }
-  _persistGenerations.set(key, Math.max(_persistGenerations.get(key) ?? 0, pending.generation) + 1);
-  _pendingPersist.delete(key);
-  const timer = _persistTimers.get(key);
-  if (timer) {
-    clearTimeout(timer);
-    _persistTimers.delete(key);
-  }
-  const startedAt = performance.now();
-  try {
-    const serializeStarted = performance.now();
-    const json = JSON.stringify(persistedData(pending));
-    const serializeMs = performance.now() - serializeStarted;
-    const rawBytes = Buffer.byteLength(json);
-    const writeStarted = performance.now();
-    const gzip = gzipSync(json);
-    fs.mkdirSync(pending.cacheDir, { recursive: true });
-    writeFileAtomic(pending.cachePath, gzip, { bestEffort: false });
-    fs.rmSync(path.join(pending.cacheDir, LEGACY_GRAPH_CACHE_FILENAME), {
-      force: true
-    });
-    const writeMs = performance.now() - writeStarted;
-    logLatency({
-      type: "phase",
-      phase: "review_graph_persist",
-      filePath: pending.cachePath,
-      durationMs: performance.now() - startedAt,
-      metadata: {
-        elements: pending.elementCount,
-        rawBytes,
-        gzBytes: gzip.byteLength,
-        serializeMs,
-        writeMs,
-        offloaded: false
-      }
-    });
-    logReviewGraph({
-      cwd,
-      phase: "persist_succeeded",
-      durationMs: performance.now() - startedAt,
-      elements: pending.elementCount,
-      rawBytes,
-      gzBytes: gzip.byteLength,
-      serializeMs,
-      writeMs,
-      offloaded: false,
-      observability: persistObservability(pending, {
-        status: "succeeded",
-        reason: source === "exit_hook" ? "exit_flush" : "forced_flush",
-        workerStarted: selectedWorkerRequest !== undefined,
-        workerCompleted: false
-      })
-    });
-    return {
-      ok: true,
-      path: pending.cachePath,
-      bytes: gzip.byteLength,
-      elements: pending.elementCount,
-      coverage: pending.graph.persistCoverage
-    };
-  } catch (err) {
-    const reason = err instanceof Error ? err.message : String(err);
-    recordPersistFailure(cwd, source === "exit_hook" ? "exit_flush_failed" : "forced_flush_failed", reason, pending, selectedWorkerRequest ? {
-      started: true,
-      completed: false,
-      fallbackReason: "forced_flush_write_failed"
-    } : undefined);
-    return { ok: false, reason };
-  }
-}
-function localImportToFile(cwd, filePath, source, ignoredIds) {
-  if (!source.startsWith(".")) {
-    const aliased = resolveAliasedImport(cwd, source, path.dirname(filePath));
-    const referenced = aliased.length ? [] : resolveProjectReferenceImport(cwd, source, path.dirname(filePath));
-    const resolved = aliased.length ? aliased : referenced.length ? referenced : resolveWorkspacePackageImport(cwd, source);
-    for (const normalized of resolved) {
-      if (ignoredIds?.has(normalized))
-        continue;
-      return normalized;
-    }
-    return;
-  }
-  const root = path.resolve(cwd);
-  for (const candidate of jsTsCandidatePaths(filePath, source)) {
-    const relative = path.relative(root, candidate);
-    if (relative.startsWith("..") && (relative.length === 2 || relative.startsWith(`..${path.sep}`)) || path.isAbsolute(relative) || !fs.existsSync(candidate))
-      continue;
-    const normalized = normalizeMapKey(candidate);
-    if (ignoredIds?.has(normalized))
-      continue;
-    return normalized;
-  }
-  return;
-}
-function upsertChangedSymbols(graph, facts, filePath) {
-  if (detectFileRole(filePath) === "test")
-    return;
-  const normalized = normalizeMapKey(filePath);
-  const changed = facts.getBoundedSessionFact(`${CHANGED_SYMBOLS_PREFIX}${normalized}`);
-  if (changed && changed.length > 0) {
-    graph.changedSymbolsByFile.set(normalized, [...changed]);
-  } else {
-    graph.changedSymbolsByFile.delete(normalized);
-  }
-}
-async function ensureReviewGraphFacts(filePath, cwd, facts, contentOverride) {
-  const ctx = makeCtx(filePath, cwd, facts);
-  if (contentOverride === undefined) {
-    await fileContentProvider.run(ctx, facts);
-  } else {
-    facts.setFileFact(filePath, "file.content", contentOverride);
-  }
-  try {
-    const [{ importFactProvider }, { functionFactProvider }] = await Promise.all([
-      import("../dispatch/facts/import-facts.js"),
-      import("../dispatch/facts/function-facts.js")
-    ]);
-    await importFactProvider.run(ctx, facts);
-    await functionFactProvider.run(ctx, facts);
-  } catch (err) {
-    logReviewGraph({
-      cwd,
-      phase: "build_skipped",
-      reason: "structural_facts_disabled",
-      error: err?.message ?? String(err)
-    });
-  }
-}
-function addJsTsFile(graph, cwd, filePath, facts, ignoredIds) {
-  const normalized = normalizeMapKey(filePath);
-  const hintPath = toProjectRelativePath(normalized, cwd);
-  const content = facts.getFileFact(normalized, "file.content") ?? "";
-  const fileNodeId = `file:${normalized}`;
-  const warmCallCoverage = facts.getFileFact(normalized, "file.functionFactsCoverage") ?? "unavailable";
-  const importCoverage = facts.getFileFact(normalized, "file.importFactsCoverage") ?? "unavailable";
-  addNode(graph, {
-    id: fileNodeId,
-    kind: "file",
-    language: "jsts",
-    filePath: normalized,
-    metadata: {
-      lineCount: content.split(`
-`).length,
-      extractionCoverage: {
-        definitions: warmCallCoverage,
-        references: warmCallCoverage,
-        imports: importCoverage,
-        calls: warmCallCoverage
-      },
-      ...featureHintMetadata(hintPath)
-    }
-  });
-  const imports = facts.getFileFact(normalized, "file.imports") ?? [];
-  const functions = facts.getFileFact(normalized, "file.functionSummaries") ?? [];
-  for (const entry of imports) {
-    const localFile = localImportToFile(cwd, normalized, entry.source, ignoredIds);
-    if (localFile) {
-      const targetId = `file:${localFile}`;
-      if (!graph.nodes.has(targetId)) {
-        addNode(graph, {
-          id: targetId,
-          kind: "file",
-          language: detectFileKind(localFile) ?? "jsts",
-          filePath: localFile
-        });
-      }
-      addEdge(graph, { from: fileNodeId, to: targetId, kind: "imports" });
-    } else {
-      const targetId = `${entry.source.startsWith(".") ? "module" : "external"}:${entry.source}`;
-      if (!graph.nodes.has(targetId)) {
-        addNode(graph, {
-          id: targetId,
-          kind: entry.source.startsWith(".") ? "module" : "external",
-          language: "jsts",
-          metadata: { source: entry.source }
-        });
-      }
-      addEdge(graph, { from: fileNodeId, to: targetId, kind: "imports" });
-    }
-  }
-  const importedNameToFile = new Map;
-  for (const entry of imports) {
-    const localFile = localImportToFile(cwd, normalized, entry.source, ignoredIds);
-    if (!localFile)
-      continue;
-    for (const name of entry.names)
-      importedNameToFile.set(name, localFile);
-    if (entry.defaultName)
-      importedNameToFile.set(entry.defaultName, localFile);
-  }
-  const methodsByQualifiedName = new Map;
-  for (const fn of functions) {
-    const symbolId = buildSymbolId(normalized, fn.name, "function", fn.line);
-    const qualifiedName = buildQualifiedName(fn.owner, fn.name);
-    if (qualifiedName) {
-      const existing = methodsByQualifiedName.get(qualifiedName) ?? [];
-      existing.push(symbolId);
-      methodsByQualifiedName.set(qualifiedName, existing);
-    }
-    addNode(graph, {
-      id: symbolId,
-      kind: "symbol",
-      language: "jsts",
-      filePath: normalized,
-      symbolName: fn.name,
-      symbolKind: "function",
-      ...qualifiedName ? { qualifiedName } : {},
-      exported: new RegExp(String.raw`export\s+(?:async\s+)?(?:function|const|let|var)\s+${escapeRegExp(fn.name)}\b`).test(content),
-      metadata: {
-        line: fn.line,
-        endLine: fn.endLine,
-        column: fn.column,
-        cyclomaticComplexity: fn.cyclomaticComplexity,
-        maxNestingDepth: fn.maxNestingDepth,
-        isBoundaryWrapper: fn.isBoundaryWrapper,
-        isPassThroughWrapper: fn.isPassThroughWrapper,
-        ...featureHintMetadata(`${fn.name} ${hintPath}`)
-      }
-    });
-    addEdge(graph, { from: fileNodeId, to: symbolId, kind: "contains" });
-    addEdge(graph, { from: fileNodeId, to: symbolId, kind: "defines" });
-  }
-  for (const fn of functions) {
-    const symbolId = buildSymbolId(normalized, fn.name, "function", fn.line);
-    const memberCallTexts = new Set;
-    for (const site of fn.memberCallSites ?? []) {
-      const callText = `${site.receiver}.${site.method}`;
-      memberCallTexts.add(callText);
-      const receiverClass = fn.receiverTypes?.[site.receiver];
-      const candidates = receiverClass ? methodsByQualifiedName.get(`${receiverClass}.${site.method}`) ?? [] : [];
-      if (candidates.length === 1) {
-        addEdge(graph, {
-          from: symbolId,
-          to: candidates[0],
-          kind: "calls",
-          metadata: {
-            unresolvedName: callText,
-            receiver: site.receiver,
-            receiverType: receiverClass
-          },
-          resolution: "receiver-type"
-        });
-        continue;
-      }
-      if (candidates.length > 1) {
-        const qualifiedPlaceholderId = `symbol-qualified-name:${receiverClass}.${site.method}`;
-        if (!graph.nodes.has(qualifiedPlaceholderId)) {
-          addNode(graph, {
-            id: qualifiedPlaceholderId,
-            kind: "symbol",
-            language: "jsts",
-            symbolName: site.method,
-            qualifiedName: `${receiverClass}.${site.method}`,
-            metadata: {
-              unresolvedName: callText,
-              ambiguousCandidates: candidates.length
-            }
-          });
-        }
-        addEdge(graph, {
-          from: symbolId,
-          to: qualifiedPlaceholderId,
-          kind: "calls",
-          metadata: {
-            unresolvedName: callText,
-            receiver: site.receiver,
-            receiverType: receiverClass
-          },
-          resolution: "name-only"
-        });
-        continue;
-      }
-      const externalId = `external:${callText}`;
-      if (!graph.nodes.has(externalId)) {
-        addNode(graph, {
-          id: externalId,
-          kind: "external",
-          language: "jsts",
-          metadata: { unresolvedName: callText }
-        });
-      }
-      addEdge(graph, {
-        from: symbolId,
-        to: externalId,
-        kind: "calls",
-        metadata: { unresolvedName: callText }
-      });
-    }
-    for (const callee of fn.outgoingCalls) {
-      if (memberCallTexts.has(callee))
-        continue;
-      const targetId = callee.includes(".") ? `external:${callee}` : `symbol-name:${callee}`;
-      if (!graph.nodes.has(targetId)) {
-        addNode(graph, {
-          id: targetId,
-          kind: callee.includes(".") ? "external" : "symbol",
-          language: "jsts",
-          symbolName: callee.includes(".") ? undefined : callee,
-          metadata: { unresolvedName: callee }
-        });
-      }
-      const importHintFile = !callee.includes(".") ? importedNameToFile.get(callee) : undefined;
-      addEdge(graph, {
-        from: symbolId,
-        to: targetId,
-        kind: "calls",
-        metadata: {
-          unresolvedName: callee,
-          ...importHintFile ? { importHintFile } : {}
-        },
-        ...callee.includes(".") ? {} : { resolution: "name-only" }
-      });
-    }
-  }
-}
-export function mapKindToTreeSitterLanguage(kind, filePath) {
-  return symbolExtractionGrammar(kind, filePath);
-}
-async function getExtractor(languageId) {
-  if (extractorCache.has(languageId))
-    return extractorCache.get(languageId);
-  const client = getSharedTreeSitterClient();
-  if (!client)
-    return null;
-  const extractor = new TreeSitterSymbolExtractor(languageId, client);
-  const ok = await extractor.init();
-  if (!ok) {
-    extractorCache.set(languageId, null);
-    return null;
-  }
-  extractorCache.set(languageId, extractor);
-  return extractor;
-}
-async function extractTreeSitterSymbols(filePath, languageId, contentOverride) {
-  const empty = {
-    symbols: [],
-    refs: [],
-    imports: [],
-    coverage: {
-      definitions: "unavailable",
-      references: "unavailable",
-      imports: "unavailable"
-    }
-  };
-  if (contentOverride === null)
-    return empty;
-  const treeSitterClient = getSharedTreeSitterClient();
-  if (!treeSitterClient)
-    return empty;
-  const initialized = await treeSitterClient.init();
-  if (!initialized)
-    return empty;
-  const extractor = await getExtractor(languageId);
-  if (!extractor)
-    return empty;
-  const content = contentOverride ?? fs.readFileSync(filePath, "utf-8");
-  const extracted = await treeSitterClient.withParsedTree(filePath, languageId, content, (tree) => extractor.extract(tree, filePath, content));
-  return extracted.parsed ? extracted.value : empty;
-}
-export async function captureReviewGraphStructuralIr(filePath, cwd, content, facts) {
-  const kind = detectFileKind(filePath);
-  if (!kind || !MAIN_KINDS.has(kind) || detectFileRole(filePath) === "test") {
-    return { complete: true };
-  }
-  if (kind === "jsts") {
-    if (!facts.hasFileFact(filePath, "file.imports") || !facts.hasFileFact(filePath, "file.reexports") || !facts.hasFileFact(filePath, "file.functionSummaries")) {
-      await ensureReviewGraphFacts(filePath, cwd, facts, content);
-    }
-    const parsed = await withTreeSitterRoot(filePath, content, () => true);
-    if (!parsed.parsed)
-      return { complete: false };
-    const functionCoverage = facts.getFileFact(filePath, "file.functionFactsCoverage") ?? "unavailable";
-    const importCoverage = facts.getFileFact(filePath, "file.importFactsCoverage") ?? "unavailable";
-    const coverage = {
-      definitions: functionCoverage,
-      references: functionCoverage,
-      imports: importCoverage,
-      calls: functionCoverage
-    };
-    if (Object.values(coverage).some((status) => status !== "complete")) {
-      return { complete: false };
-    }
-    return {
-      complete: true,
-      structural: {
-        kind: "jsts",
-        imports: facts.getFileFact(filePath, "file.imports") ?? [],
-        reexports: facts.getFileFact(filePath, "file.reexports") ?? [],
-        functionSummaries: facts.getFileFact(filePath, "file.functionSummaries") ?? [],
-        coverage
-      }
-    };
-  }
-  const languageId = mapKindToTreeSitterLanguage(kind, filePath);
-  if (!languageId)
-    return { complete: false };
-  const client = getSharedTreeSitterClient();
-  if (!client || !await client.init())
-    return { complete: false };
-  const extractor = await getExtractor(languageId);
-  if (!extractor)
-    return { complete: false };
-  const result = await client.withParsedTree(filePath, languageId, content, (tree) => extractor.extract(tree, filePath, content));
-  if (!result.parsed)
-    return { complete: false };
-  return {
-    complete: true,
-    structural: {
-      kind: "tree-sitter",
-      languageId,
-      extracted: result.value
-    }
-  };
-}
-const SYMBOL_KIND_SPECIFICITY = {
-  method: 2,
-  property: 2
-};
-function dedupeSamePositionSymbols(symbols) {
-  const bestByKey = new Map;
-  for (const symbol of symbols) {
-    const key = `${symbol.name}0000${symbol.line}0000${symbol.column}`;
-    const existing = bestByKey.get(key);
-    if (!existing) {
-      bestByKey.set(key, symbol);
-      continue;
-    }
-    const existingScore = SYMBOL_KIND_SPECIFICITY[existing.kind] ?? 0;
-    const candidateScore = SYMBOL_KIND_SPECIFICITY[symbol.kind] ?? 0;
-    if (candidateScore > existingScore)
-      bestByKey.set(key, symbol);
-  }
-  return [...bestByKey.values()];
-}
-function addTreeSitterFile(graph, cwd, filePath, languageId, extracted, ignoredIds) {
-  const normalized = normalizeMapKey(filePath);
-  const hintPath = toProjectRelativePath(normalized, cwd);
-  const fileNodeId = `file:${normalized}`;
-  addNode(graph, {
-    id: fileNodeId,
-    kind: "file",
-    language: languageId,
-    filePath: normalized,
-    metadata: {
-      ...featureHintMetadata(hintPath),
-      extractionCoverage: extracted.coverage
-    }
-  });
-  const dedupedSymbols = dedupeSamePositionSymbols(extracted.symbols);
-  const containers = dedupedSymbols.map((s) => ({
-    name: s.name,
-    startLine: s.line,
-    endLine: s.endLine ?? s.line
-  }));
-  for (const symbol of dedupedSymbols) {
-    const symbolId = buildSymbolId(normalized, symbol.name, symbol.kind, symbol.line);
-    const owner = findOwnerName(containers, symbol.line, symbol.endLine ?? symbol.line);
-    const qualifiedName = buildQualifiedName(owner, symbol.name);
-    addNode(graph, {
-      id: symbolId,
-      kind: "symbol",
-      language: languageId,
-      filePath: normalized,
-      symbolName: symbol.name,
-      symbolKind: symbol.kind,
-      ...qualifiedName ? { qualifiedName } : {},
-      exported: symbol.isExported,
-      metadata: {
-        line: symbol.line,
-        endLine: symbol.endLine,
-        column: symbol.column,
-        signature: symbol.signature,
-        ...featureHintMetadata(`${symbol.name} ${hintPath}`)
-      }
-    });
-    addEdge(graph, { from: fileNodeId, to: symbolId, kind: "contains" });
-    addEdge(graph, { from: fileNodeId, to: symbolId, kind: "defines" });
-  }
-  for (const ref of extracted.refs) {
-    const refName = ref.symbolName ?? ref.symbolId;
-    const targetId = `symbol-name:${refName}`;
-    if (!graph.nodes.has(targetId)) {
-      addNode(graph, {
-        id: targetId,
-        kind: "symbol",
-        language: languageId,
-        symbolName: refName,
-        metadata: { unresolvedName: refName }
-      });
-    }
-    addEdge(graph, {
-      from: fileNodeId,
-      to: targetId,
-      kind: "references",
-      metadata: {
-        line: ref.line,
-        column: ref.column,
-        referenceKind: ref.referenceKind ?? "unknown"
-      },
-      resolution: "name-only"
-    });
-  }
-  for (const imp of extracted.imports) {
-    const resolved = resolveImportToFiles(cwd, filePath, languageId, imp.source).filter((target) => !ignoredIds?.has(target));
-    if (resolved.length > 0) {
-      for (const target of resolved) {
-        const toNode = ensureFileNode(graph, target, cwd, mapKindToTreeSitterLanguage(detectFileKind(target), target) ?? languageId);
-        addEdge(graph, {
-          from: fileNodeId,
-          to: toNode,
-          kind: "imports",
-          metadata: { line: imp.line, source: imp.source }
-        });
-      }
-      continue;
-    }
-    const isRelative = imp.source.startsWith(".");
-    const targetId = `${isRelative ? "module" : "external"}:${imp.source}`;
-    if (!graph.nodes.has(targetId)) {
-      addNode(graph, {
-        id: targetId,
-        kind: isRelative ? "module" : "external",
-        language: languageId,
-        metadata: { source: imp.source }
-      });
-    }
-    addEdge(graph, {
-      from: fileNodeId,
-      to: targetId,
-      kind: "imports",
-      metadata: { line: imp.line }
-    });
-  }
-}
-function addLspFallbackSymbols(graph, filePath, languageId, symbols) {
-  const normalized = normalizeMapKey(filePath);
-  const fileNodeId = `file:${normalized}`;
-  let added = 0;
-  const flatOwnerIds = new Map;
-  for (const symbol of symbols) {
-    const range = symbol.range ?? symbol.location?.range;
-    if (!range)
-      continue;
-    const kind = lspSymbolKindName(symbol.kind);
-    const id = buildSymbolId(normalized, symbol.name, kind, range.start.line + 1);
-    flatOwnerIds.set(symbol.name, id);
-    if (symbol.containerName) {
-      flatOwnerIds.set(`${symbol.containerName}.${symbol.name}`, id);
-    }
-  }
-  const visit = (items, parentId, ancestry) => {
-    for (const symbol of items) {
-      const range = symbol.range ?? symbol.location?.range;
-      if (!range)
-        continue;
-      const line = range.start.line + 1;
-      const kind = lspSymbolKindName(symbol.kind);
-      const symbolId = buildSymbolId(normalized, symbol.name, kind, line);
-      const owners = ancestry.length > 0 ? ancestry : containerNameChain(symbol, symbols);
-      const qualifiedName = owners.length > 0 ? [...owners, symbol.name].join(".") : undefined;
-      addNode(graph, {
-        id: symbolId,
-        kind: "symbol",
-        language: languageId,
-        filePath: normalized,
-        symbolName: symbol.name,
-        symbolKind: kind,
-        ...qualifiedName ? { qualifiedName } : {},
-        provenance: "lsp",
-        metadata: {
-          line,
-          column: range.start.character,
-          endLine: range.end.line + 1,
-          ...featureHintMetadata(`${symbol.name} ${normalized}`)
-        }
-      });
-      const resolvedParentId = ancestry.length === 0 && symbol.containerName ? flatOwnerIds.get(symbol.containerName) ?? parentId : parentId;
-      addEdge(graph, {
-        from: resolvedParentId,
-        to: symbolId,
-        kind: "contains"
-      });
-      addEdge(graph, { from: fileNodeId, to: symbolId, kind: "defines" });
-      added++;
-      if (symbol.children) {
-        visit(symbol.children, symbolId, [...owners, symbol.name]);
-      }
-    }
-  };
-  visit(symbols, fileNodeId, []);
-  return added;
-}
-function ensureFileNode(graph, filePath, cwd, languageId) {
-  const normalized = normalizeMapKey(filePath);
-  const hintPath = toProjectRelativePath(normalized, cwd);
-  const existing = graph.fileNodes.get(normalized);
-  if (existing)
-    return existing;
-  const fileNodeId = `file:${normalized}`;
-  addNode(graph, {
-    id: fileNodeId,
-    kind: "file",
-    language: languageId,
-    filePath: normalized,
-    metadata: featureHintMetadata(hintPath)
-  });
-  return fileNodeId;
-}
-function resolveCxxInclude(cwd, filePath, source) {
-  const candidates = [
-    path.resolve(path.dirname(filePath), source),
-    path.resolve(cwd, source),
-    path.resolve(cwd, "include", source),
-    path.resolve(cwd, "src", source)
-  ];
-  const root = path.resolve(cwd);
-  for (const candidate of candidates) {
-    if (!candidate.startsWith(root + path.sep) && candidate !== root)
-      continue;
-    if (fs.existsSync(candidate) && detectFileKind(candidate) === "cxx") {
-      return normalizeMapKey(candidate);
-    }
-  }
-  return;
-}
-function parseLocalCxxInclude(line) {
-  let i = 0;
-  while (i < line.length && (line[i] === " " || line[i] === "\t"))
-    i += 1;
-  if (line[i] !== "#")
-    return;
-  i += 1;
-  while (i < line.length && (line[i] === " " || line[i] === "\t"))
-    i += 1;
-  if (!line.startsWith("include", i))
-    return;
-  i += "include".length;
-  if (i >= line.length || line[i] !== " " && line[i] !== "\t") {
-    return;
-  }
-  while (i < line.length && (line[i] === " " || line[i] === "\t"))
-    i += 1;
-  if (line[i] !== '"')
-    return;
-  i += 1;
-  const start = i;
-  while (i < line.length && line[i] !== '"')
-    i += 1;
-  if (i >= line.length || i === start)
-    return;
-  return line.slice(start, i);
-}
-function addCxxIncludeEdges(graph, cwd, filePath, ignoredIds, contentOverride) {
-  let content = contentOverride;
-  if (content === undefined) {
-    try {
-      content = fs.readFileSync(filePath, "utf-8");
-    } catch {
-      return;
-    }
-  }
-  if (content === null)
-    return;
-  const fromNode = ensureFileNode(graph, filePath, cwd, "cpp");
-  for (const line of content.split(/\r?\n/)) {
-    const source = parseLocalCxxInclude(line);
-    if (!source)
-      continue;
-    const target = resolveCxxInclude(cwd, filePath, source);
-    if (!target || ignoredIds?.has(target))
-      continue;
-    const languageId = mapKindToTreeSitterLanguage("cxx", target) ?? "cpp";
-    const toNode = ensureFileNode(graph, target, cwd, languageId);
-    addEdge(graph, {
-      from: fromNode,
-      to: toNode,
-      kind: "imports",
-      metadata: { source }
-    });
-  }
-}
-function removeFileOwnedGraphData(graph, filePath, removedEdges) {
-  const normalized = normalizeMapKey(filePath);
-  const fileNodeId = graph.fileNodes.get(normalized) ?? `file:${normalized}`;
-  const removedSymbolIds = new Set(graph.symbolNodesByFile.get(normalized));
-  const removedIds = new Set(removedSymbolIds);
-  if (graph.nodes.has(fileNodeId))
-    removedIds.add(fileNodeId);
-  const candidates = new Set;
-  for (const id of removedIds) {
-    for (const edge of graph.edgesByFrom.get(id) ?? []) {
-      _rebuildCounters.removeOwnedEdgeVisits++;
-      candidates.add(edge);
-    }
-    for (const edge of graph.edgesByTo.get(id) ?? []) {
-      _rebuildCounters.removeOwnedEdgeVisits++;
-      candidates.add(edge);
-    }
-  }
-  const preservedIncomingSymbolEdges = [];
-  for (const edge of candidates) {
-    if (removedEdges.has(edge))
-      continue;
-    const fromRemoved = removedIds.has(edge.from);
-    if (!fromRemoved && edge.to === fileNodeId)
-      continue;
-    if (!fromRemoved && removedSymbolIds.has(edge.to)) {
-      preservedIncomingSymbolEdges.push({ ...edge });
-    }
-    removedEdges.add(edge);
-  }
-  for (const id of removedIds) {
-    const node = graph.nodes.get(id);
-    graph.nodes.delete(id);
-    if (!node?.filePath)
-      continue;
-    if (node.kind === "file") {
-      if (graph.fileNodes.get(node.filePath) === id) {
-        graph.fileNodes.delete(node.filePath);
-      }
-    } else if (node.kind === "symbol") {
-      const ids = graph.symbolNodesByFile.get(node.filePath);
-      if (!ids)
-        continue;
-      const at = ids.indexOf(id);
-      if (at >= 0)
-        ids.splice(at, 1);
-      if (ids.length === 0)
-        graph.symbolNodesByFile.delete(node.filePath);
-    }
-  }
-  return preservedIncomingSymbolEdges;
-}
-async function addFileToGraph(graph, cwd, file, facts, ignoredIds, contentOverride) {
-  const kind = detectFileKind(file);
-  if (!kind || !MAIN_KINDS.has(kind))
-    return;
-  if (detectFileRole(file) === "test")
-    return;
-  const contentHash = typeof contentOverride === "string" ? reviewGraphIrContentHash(contentOverride) : undefined;
-  const sharedIr = contentHash ? getFreshReviewGraphFileIr(cwd, file, contentHash)?.structural : undefined;
-  if (kind === "jsts") {
-    const dispatchOwnsContent = facts.getFileFact(file, "file.content") !== undefined && contentOverride == null;
-    try {
-      if (sharedIr?.kind === "jsts") {
-        facts.setFileFact(file, "file.content", contentOverride ?? "");
-        facts.setFileFact(file, "file.imports", sharedIr.imports);
-        facts.setFileFact(file, "file.reexports", sharedIr.reexports);
-        facts.setFileFact(file, "file.functionSummaries", sharedIr.functionSummaries);
-        facts.setFileFact(file, "file.functionFactsCoverage", sharedIr.coverage.calls);
-        facts.setFileFact(file, "file.importFactsCoverage", sharedIr.coverage.imports);
-      } else {
-        await ensureReviewGraphFacts(file, cwd, facts, contentOverride);
-      }
-      addJsTsFile(graph, cwd, file, facts, ignoredIds);
-    } finally {
-      if (!dispatchOwnsContent)
-        facts.deleteFileFact(file, "file.content");
-    }
-    return;
-  }
-  const languageId = mapKindToTreeSitterLanguage(kind, file);
-  if (!languageId)
-    return;
-  const irExtracted = sharedIr?.kind === "tree-sitter" && sharedIr.languageId === languageId ? sharedIr.extracted : undefined;
-  const extracted = irExtracted ?? await extractTreeSitterSymbols(file, languageId, contentOverride);
-  addTreeSitterFile(graph, cwd, file, languageId, extracted, ignoredIds);
-  if (extracted.symbols.length === 0) {
-    const lspSymbols = await getOpenDocumentSymbols(file);
-    const added = lspSymbols ? addLspFallbackSymbols(graph, file, languageId, lspSymbols) : 0;
-    logReviewGraph({
-      phase: "lsp_symbol_fallback",
-      cwd,
-      reason: lspSymbols ? added > 0 ? "added" : "empty-response" : "unavailable-or-failed",
-      nodes: added
-    });
-  }
-  if (kind === "cxx") {
-    addCxxIncludeEdges(graph, cwd, file, ignoredIds, contentOverride);
-  }
-}
-const _rebuildCounters = {
-  restoreComparisons: 0,
-  importTargetEdgeScans: 0,
-  removeOwnedEdgeVisits: 0,
-  removeOwnedEdgePositions: 0
-};
-export function _getReviewGraphRebuildCountersForTests() {
-  return { ..._rebuildCounters };
-}
-export function _resetReviewGraphRebuildCountersForTests() {
-  _rebuildCounters.restoreComparisons = 0;
-  _rebuildCounters.importTargetEdgeScans = 0;
-  _rebuildCounters.removeOwnedEdgeVisits = 0;
-  _rebuildCounters.removeOwnedEdgePositions = 0;
-}
-function edgeIdentityKey(edge) {
-  _rebuildCounters.restoreComparisons++;
-  return JSON.stringify([edge.from, edge.kind, edge.metadata ?? {}]);
-}
-function restoreValidIncomingEdges(graph, edges) {
-  const seenByTarget = new Map;
-  for (const edge of edges) {
-    if (!graph.nodes.has(edge.from) || !graph.nodes.has(edge.to))
-      continue;
-    let seen = seenByTarget.get(edge.to);
-    if (!seen) {
-      seen = new Set;
-      for (const candidate of graph.edgesByTo.get(edge.to) ?? []) {
-        seen.add(edgeIdentityKey(candidate));
-      }
-      seenByTarget.set(edge.to, seen);
-    }
-    const key = edgeIdentityKey(edge);
-    if (seen.has(key))
-      continue;
-    seen.add(key);
-    addEdge(graph, edge);
-  }
-}
-function dedupeResolvedEdges(graph, replacements) {
-  const resolvedEdges = new Set(replacements.map(([, after]) => after));
-  const seenByTarget = new Map;
-  const removed = new Set;
-  for (const [, edge] of replacements) {
-    if (removed.has(edge))
-      continue;
-    let seen = seenByTarget.get(edge.to);
-    if (!seen) {
-      seen = new Set;
-      for (const candidate of graph.edgesByTo.get(edge.to) ?? []) {
-        if (!resolvedEdges.has(candidate)) {
-          seen.add(edgeIdentityKey(candidate));
-        }
-      }
-      seenByTarget.set(edge.to, seen);
-    }
-    const key = edgeIdentityKey(edge);
-    if (seen.has(key)) {
-      removed.add(edge);
-      unindexEdge(graph, edge);
-      continue;
-    }
-    seen.add(key);
-  }
-  if (removed.size > 0) {
-    graph.edges = graph.edges.filter((edge) => !removed.has(edge));
-  }
-}
-const _graphImportChanges = new WeakMap;
-export function getGraphImportChanges(graph) {
-  return _graphImportChanges.get(graph);
-}
-function importTargetsForFile(graph, filePath) {
-  const normalized = normalizeMapKey(filePath);
-  const fileNodeId = graph.fileNodes.get(normalized) ?? `file:${normalized}`;
-  const targets = new Set;
-  for (const edge of graph.edgesByFrom.get(fileNodeId) ?? []) {
-    _rebuildCounters.importTargetEdgeScans++;
-    if (edge.kind !== "imports")
-      continue;
-    const target = graph.nodes.get(edge.to)?.filePath;
-    if (target)
-      targets.add(normalizeMapKey(target));
-  }
-  return [...targets].sort((a, b) => compareOrdinal(a, b));
-}
-async function updateGraphFiles(graph, cwd, files, facts, ignoredIds) {
-  rebuildIndexes(graph);
-  const prior = files.map((file) => ({
-    filePath: normalizeMapKey(file),
-    existedBefore: graph.fileNodes.has(normalizeMapKey(file)),
-    priorTargets: importTargetsForFile(graph, file)
-  }));
-  const preservedIncoming = [];
-  const removedEdges = new Set;
-  for (const file of files) {
-    preservedIncoming.push(...removeFileOwnedGraphData(graph, file, removedEdges));
-    await addFileToGraph(graph, cwd, file, facts, ignoredIds);
-  }
-  if (removedEdges.size > 0) {
-    unindexEdges(graph, removedEdges);
-    graph.edges = graph.edges.filter((edge) => !removedEdges.has(edge));
-  }
-  restoreValidIncomingEdges(graph, preservedIncoming);
-  resolveDeferredSymbolEdges(graph, false);
-  graph.changedSymbolsByFile.clear();
-  for (const file of files) {
-    upsertChangedSymbols(graph, facts, file);
-  }
-  return prior.map(({ filePath, existedBefore, priorTargets }) => ({
-    filePath,
-    existedBefore,
-    existsAfter: graph.fileNodes.has(filePath),
-    priorTargets,
-    newTargets: importTargetsForFile(graph, filePath)
-  }));
-}
-function resolveDeferredSymbolEdges(graph, rebuild = true) {
-  const symbolNameToIds = new Map;
-  for (const node of graph.nodes.values()) {
-    if (node.kind !== "symbol" || !node.symbolName)
-      continue;
-    if (node.metadata?.unresolvedName)
-      continue;
-    const ids = symbolNameToIds.get(node.symbolName) ?? [];
-    ids.push(node.id);
-    symbolNameToIds.set(node.symbolName, ids);
-  }
-  const replacements = [];
-  graph.edges = graph.edges.map((edge) => {
-    const targetNode = graph.nodes.get(edge.to);
-    if (!targetNode?.metadata?.unresolvedName)
-      return edge;
-    const candidates = symbolNameToIds.get(targetNode.symbolName ?? "") ?? [];
-    const importHintFile = edge.metadata?.importHintFile;
-    if (importHintFile) {
-      const scoped = candidates.filter((id) => graph.nodes.get(id)?.filePath === importHintFile);
-      if (scoped.length === 1) {
-        const resolved = {
-          ...edge,
-          to: scoped[0],
-          resolution: "import"
-        };
-        replacements.push([edge, resolved]);
-        return resolved;
-      }
-    }
-    if (candidates.length === 1) {
-      const resolved = {
-        ...edge,
-        to: candidates[0],
-        resolution: "exact"
-      };
-      replacements.push([edge, resolved]);
-      return resolved;
-    }
-    return edge;
-  });
-  if (rebuild) {
-    rebuildIndexes(graph);
-    return;
-  }
-  if (replacements.length === 0)
-    return;
-  const affectedTargets = new Set;
-  for (const [before, after] of replacements) {
-    const fromBucket = graph.edgesByFrom.get(before.from);
-    if (fromBucket) {
-      const at = fromBucket.indexOf(before);
-      if (at >= 0)
-        fromBucket[at] = after;
-    }
-    affectedTargets.add(before.to);
-    affectedTargets.add(after.to);
-  }
-  for (const target of affectedTargets)
-    graph.edgesByTo.set(target, []);
-  for (const edge of graph.edges) {
-    if (affectedTargets.has(edge.to))
-      graph.edgesByTo.get(edge.to)?.push(edge);
-  }
-  for (const target of affectedTargets) {
-    if (graph.edgesByTo.get(target)?.length === 0) {
-      graph.edgesByTo.delete(target);
-    }
-  }
-  dedupeResolvedEdges(graph, replacements);
-}
-function verifiedCacheFields(seqAtBuildStart) {
-  return {
-    builtAtProjectSeq: seqAtBuildStart,
-    lastFullVerifyMs: Date.now(),
-    fastPathSinceVerify: 0
-  };
-}
-async function tryIncrementalFromCache(cached, ctx) {
-  if (cached.fileSignatures.size === 0)
-    return;
-  const { added, removed, changed } = diffSignatureMaps(cached.fileSignatures, ctx.fileSignatures);
-  if (removed.length > 0)
-    return;
-  if (added.length === 0 && changed.length === 0)
-    return;
-  const { trulyChanged, hashes } = await confirmContentChanged(changed, cached.fileHashes);
-  const filesToUpdate = [...added, ...trulyChanged];
-  if (filesToUpdate.length === 0) {
-    const generation = cached.buildGeneration ?? ++_graphGenerationCounter;
-    const graph = cloneGraph(cached.graph);
-    rebuildIndexes(graph);
-    graph.changedSymbolsByFile.clear();
-    for (const file of ctx.normalizedChanged) {
-      upsertChangedSymbols(graph, ctx.facts, file);
-    }
-    setWorkspaceGraph(ctx.normalizedCwd, {
-      signature: ctx.signature,
-      fileSignatures: new Map(ctx.fileSignatures),
-      fileHashes: hashes,
-      graph: cloneGraph(cached.graph),
-      buildGeneration: generation,
-      ...verifiedCacheFields(ctx.seqAtBuildStart)
-    }, ctx.cacheEpoch);
-    setGraphBuildInfo(graph, {
-      reused: true,
-      mode: "cached",
-      graphChanged: false
-    });
-    graph.buildGeneration = generation;
-    setSessionReviewGraphFact(ctx.cwd, ctx.facts, graph);
-    return graph;
-  }
-  for (const file of added) {
-    hashes.set(file, contentHashEntry(file));
-  }
-  const priorGeneration = cached.graph.buildGeneration;
-  const graph = cloneGraph(cached.graph);
-  const importChanges = await updateGraphFiles(graph, ctx.cwd, filesToUpdate, ctx.facts, ctx.ignoredIds);
-  refreshGraphBuiltAt(graph);
-  const generation = ++_graphGenerationCounter;
-  graph.buildGeneration = generation;
-  setWorkspaceGraph(ctx.normalizedCwd, {
-    signature: ctx.signature,
-    fileSignatures: new Map(ctx.fileSignatures),
-    fileHashes: hashes,
-    graph,
-    buildGeneration: generation,
-    ...verifiedCacheFields(ctx.seqAtBuildStart)
-  }, ctx.cacheEpoch);
-  const persistReason = persistGraph(ctx.cwd, ctx.signature, ctx.fileSignatures, hashes, graph, {
-    buildId: ctx.buildId,
-    projectSeq: ctx.seqAtBuildStart,
-    seqHint: ctx.seqHint,
-    mode: ctx.mode,
-    resolveIdentity: ctx.resolveIdentity
-  });
-  setGraphBuildInfo(graph, {
-    reused: true,
-    mode: "incremental",
-    ...persistReason ? { persistReason } : {},
-    graphChanged: true
-  });
-  _graphImportChanges.set(graph, {
-    fromGeneration: priorGeneration,
-    changes: importChanges
-  });
-  setSessionReviewGraphFact(ctx.cwd, ctx.facts, graph);
-  return graph;
-}
-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, resolveIdentity) {
-  const cached = _workspaceGraphCache.get(normalizedCwd);
-  const cachedCoverage = cached?.graph.persistCoverage;
-  if (cachedCoverage?.partial && cachedCoverage.capTrimmed !== true) {
-    return { fallback: "partial-base" };
-  }
-  if (!cached || cached.builtAtProjectSeq === undefined) {
-    return { fallback: "no-seq" };
-  }
-  const now = Date.now();
-  const ageMs = cached.lastFullVerifyMs === undefined ? Number.POSITIVE_INFINITY : now - cached.lastFullVerifyMs;
-  const sinceVerify = cached.fastPathSinceVerify ?? 0;
-  if (ageMs > SEQ_FASTPATH_REVERIFY_MS || sinceVerify >= SEQ_FASTPATH_REVERIFY_EVERY) {
-    return { fallback: "verify-due" };
-  }
-  const changedSet = new Set(seqHint.getFilesChangedSince(cached.builtAtProjectSeq).map((file) => normalizeMapKey(file)));
-  for (const file of normalizedChanged)
-    changedSet.add(file);
-  const changed = [...changedSet];
-  if (changed.length > SEQ_FASTPATH_MAX_CHANGES) {
-    return { fallback: "too-many-changes" };
-  }
-  const candidateFiles = [];
-  for (const file of changed) {
-    const known = cached.fileSignatures.has(file);
-    let existsOnDisk = false;
-    try {
-      existsOnDisk = fs.statSync(file).isFile();
-    } catch {
-      existsOnDisk = false;
-    }
-    if (!existsOnDisk) {
-      if (known) {
-        return { fallback: "removed-file" };
-      }
-      continue;
-    }
-    if (!known) {
-      if (!hasGraphKindExtension(file))
-        continue;
-    }
-    candidateFiles.push(file);
-  }
-  const { trulyChanged, hashes } = await confirmContentChanged(candidateFiles, cached.fileHashes);
-  if (trulyChanged.length === 0) {
-    const graph = cloneGraph(cached.graph);
-    rebuildIndexes(graph);
-    graph.changedSymbolsByFile.clear();
-    for (const file of normalizedChanged) {
-      upsertChangedSymbols(graph, facts, file);
-    }
-    const nextSignatures = new Map(cached.fileSignatures);
-    for (const file of candidateFiles) {
-      nextSignatures.set(file, sourceSignatureEntry(file));
-    }
-    cached.signature = sourceSignatureFromMap(nextSignatures);
-    cached.fileSignatures = nextSignatures;
-    cached.fileHashes = hashes;
-    cached.builtAtProjectSeq = seqAtBuildStart;
-    cached.fastPathSinceVerify = sinceVerify + 1;
-    const generation = cached.buildGeneration ??= ++_graphGenerationCounter;
-    setGraphBuildInfo(graph, {
-      reused: true,
-      mode: "seq-fastpath",
-      graphChanged: false
-    });
-    graph.buildGeneration = generation;
-    setSessionReviewGraphFact(cwd, facts, graph);
-    return { graph };
-  }
-  const filesToUpdate = trulyChanged;
-  const priorGeneration = cached.graph.buildGeneration;
-  const graph = cloneGraph(cached.graph);
-  let importChanges;
-  try {
-    importChanges = await updateGraphFiles(graph, cwd, filesToUpdate, facts, ignoredIds);
-  } catch {
-    return { fallback: "stat-error" };
-  }
-  refreshGraphBuiltAt(graph);
-  const nextSignatures = new Map(cached.fileSignatures);
-  for (const file of candidateFiles) {
-    nextSignatures.set(file, sourceSignatureEntry(file));
-  }
-  const nextSignature = sourceSignatureFromMap(nextSignatures);
-  const generation = ++_graphGenerationCounter;
-  graph.buildGeneration = generation;
-  setWorkspaceGraph(normalizedCwd, {
-    signature: nextSignature,
-    fileSignatures: nextSignatures,
-    fileHashes: hashes,
-    graph,
-    buildGeneration: generation,
-    builtAtProjectSeq: seqAtBuildStart,
-    lastFullVerifyMs: cached.lastFullVerifyMs,
-    fastPathSinceVerify: sinceVerify + 1
-  }, cacheEpoch);
-  const persistReason = persistGraph(cwd, nextSignature, nextSignatures, hashes, graph, {
-    buildId,
-    projectSeq: seqAtBuildStart,
-    seqHint: true,
-    mode: "seq-fastpath",
-    resolveIdentity
-  });
-  setGraphBuildInfo(graph, {
-    reused: true,
-    mode: "seq-fastpath",
-    ...persistReason ? { persistReason } : {},
-    graphChanged: true
-  });
-  _graphImportChanges.set(graph, {
-    fromGeneration: priorGeneration,
-    changes: importChanges
-  });
-  setSessionReviewGraphFact(cwd, facts, graph);
-  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, resolveIdentity);
-  if (isAtOrAboveHomeDir(path.resolve(cwd))) {
-    const graph = createEmptyGraph();
-    for (const file of normalizedChanged) {
-      upsertChangedSymbols(graph, facts, file);
-    }
-    setGraphBuildInfo(graph, {
-      reused: false,
-      mode: "skipped",
-      skipReason: "unsafe_root",
-      graphChanged: true
-    });
-    setSessionReviewGraphFact(cwd, facts, graph);
-    return graph;
-  }
-  const seqAtBuildStart = seqHint?.projectSeq();
-  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, resolveIdentity);
-    if ("graph" in fast)
-      return fast.graph;
-    seqFastpathFallback = fast.fallback;
-  }
-  const sourceCollection = await getGraphSourceFiles(cwd);
-  const filesToBuild = sourceCollection.files;
-  const sourceFileCount = sourceCollection.sourceFileCount;
-  const pathNormalizeCalls = sourceCollection.pathNormalizeCalls;
-  const sourceFilesTruncated = sourceCollection.entryBudgetExceeded;
-  const ignoredIds = await ignoredIdsPromise;
-  const maxGraphFiles = sourceCollection.maxFileCount;
-  if (filesToBuild.length > maxGraphFiles) {
-    const graph = createEmptyGraph();
-    graph.version = REVIEW_GRAPH_VERSION;
-    graph.builtAt = new Date().toISOString();
-    for (const file of normalizedChanged) {
-      upsertChangedSymbols(graph, facts, file);
-    }
-    recordReviewGraphSizeSkip(cwd, sourceFileCount, maxGraphFiles);
-    logLatency({
-      type: "phase",
-      phase: "review_graph_size_skip",
-      filePath: cwd,
-      durationMs: 0,
-      metadata: {
-        cwd,
-        sourceFileCount,
-        maxFileCount: maxGraphFiles,
-        sourceFileCountLabel: `more than ${maxGraphFiles} files`,
-        sourceFileCountTruncated: true
-      }
-    });
-    if (isReviewGraphSizeNearMiss(sourceFileCount, maxGraphFiles)) {
-      logLatency({
-        type: "phase",
-        phase: "review_graph_size_near_miss",
-        filePath: cwd,
-        durationMs: 0,
-        metadata: {
-          cwd,
-          maxFileCount: maxGraphFiles,
-          sourceFileCount,
-          sourceFileCountLabel: `more than ${maxGraphFiles} files`,
-          sourceFileCountTruncated: true
-        }
-      });
-    }
-    setGraphBuildInfo(graph, {
-      reused: false,
-      mode: "skipped",
-      skipReason: "too_many_files",
-      sourceFileCount,
-      sourceFileCountTruncated: sourceFilesTruncated || filesToBuild.length > maxGraphFiles,
-      maxFileCount: maxGraphFiles,
-      pathNormalizeCalls,
-      seqFastpathFallback,
-      graphChanged: true
-    });
-    setSessionReviewGraphFact(cwd, facts, graph);
-    return graph;
-  }
-  if (!sourceFilesTruncated)
-    clearReviewGraphSizeSkip(cwd);
-  const fileSignatures = await sourceSignatureMapAsync(filesToBuild);
-  const signature = sourceSignatureFromMap(fileSignatures);
-  let memCached = sourceFilesTruncated ? undefined : _workspaceGraphCache.get(normalizedCwd);
-  const memCoverage = memCached?.graph.persistCoverage;
-  if (memCoverage?.partial && memCoverage.capTrimmed !== true) {
-    memCached = undefined;
-  }
-  if (memCached?.signature === signature) {
-    touchWorkspaceGraph(normalizedCwd);
-    const graph = cloneGraph(memCached.graph);
-    rebuildIndexes(graph);
-    graph.changedSymbolsByFile.clear();
-    for (const file of normalizedChanged) {
-      upsertChangedSymbols(graph, facts, file);
-    }
-    Object.assign(memCached, verifiedCacheFields(seqAtBuildStart));
-    const generation = memCached.buildGeneration ??= ++_graphGenerationCounter;
-    setGraphBuildInfo(graph, {
-      reused: true,
-      mode: "cached",
-      seqFastpathFallback,
-      graphChanged: false
-    });
-    graph.buildGeneration = generation;
-    setSessionReviewGraphFact(cwd, facts, graph);
-    return graph;
-  }
-  if (memCached) {
-    const incremental = await tryIncrementalFromCache(memCached, {
-      cwd,
-      buildId,
-      seqHint: seqHint !== undefined,
-      mode: "incremental",
-      normalizedCwd,
-      normalizedChanged,
-      fileSignatures,
-      signature,
-      facts,
-      seqAtBuildStart,
-      ignoredIds,
-      cacheEpoch,
-      resolveIdentity
-    });
-    if (incremental) {
-      updateGraphBuildInfo(incremental, { seqFastpathFallback });
-      return incremental;
-    }
-  }
-  const diskCached = sourceFilesTruncated ? null : loadPersistedGraph(cwd, undefined, resolveIdentity);
-  if (diskCached?.signature === signature) {
-    const graph = cloneGraph(diskCached.graph);
-    rebuildIndexes(graph);
-    graph.changedSymbolsByFile.clear();
-    for (const file of normalizedChanged) {
-      upsertChangedSymbols(graph, facts, file);
-    }
-    const generation = ++_graphGenerationCounter;
-    setWorkspaceGraph(normalizedCwd, {
-      signature,
-      fileSignatures: new Map(fileSignatures),
-      fileHashes: diskCached.fileHashes,
-      graph: cloneGraph(diskCached.graph),
-      buildGeneration: generation,
-      ...verifiedCacheFields(seqAtBuildStart)
-    }, cacheEpoch);
-    setGraphBuildInfo(graph, {
-      reused: true,
-      mode: "cached",
-      seqFastpathFallback,
-      graphChanged: false
-    });
-    graph.buildGeneration = generation;
-    setSessionReviewGraphFact(cwd, facts, graph);
-    return graph;
-  }
-  if (diskCached) {
-    const incremental = await tryIncrementalFromCache({
-      signature: diskCached.signature,
-      fileSignatures: diskCached.fileSignatures,
-      fileHashes: diskCached.fileHashes,
-      graph: diskCached.graph
-    }, {
-      cwd,
-      buildId,
-      seqHint: seqHint !== undefined,
-      mode: "incremental",
-      normalizedCwd,
-      normalizedChanged,
-      fileSignatures,
-      signature,
-      facts,
-      seqAtBuildStart,
-      ignoredIds,
-      resolveIdentity
-    });
-    if (incremental) {
-      updateGraphBuildInfo(incremental, { seqFastpathFallback });
-      return incremental;
-    }
-  }
-  const resumed = sourceFilesTruncated ? null : await tryResumeFromCheckpoint(cwd, filesToBuild, ignoredIds, resolveIdentity);
-  const graph = resumed?.graph ?? createEmptyGraph();
-  const filesToExtract = resumed?.remaining ?? filesToBuild;
-  const treeSitterClient = getSharedTreeSitterClient();
-  treeSitterClient?.ensureTreeCacheCapacity(filesToExtract.length);
-  const extractionStartedAt = Date.now();
-  const fileHashes = resumed?.fileHashes ?? new Map;
-  const checkpointEvery = graphCheckpointEveryFiles();
-  const checkpointMinIntervalMs = graphCheckpointMinIntervalMs();
-  const testStopAfter = Number(process.env.DM_LENS_GRAPH_CHECKPOINT_TEST_STOP_AFTER);
-  let filesSinceCheckpoint = 0;
-  let lastCheckpointMs = Date.now();
-  let extractedCount = 0;
-  const extractFiles = async () => {
-    for (const file of filesToExtract) {
-      let content;
-      try {
-        const bytes = fs.readFileSync(file);
-        content = bytes.toString("utf-8");
-        fileHashes.set(file, createHash("sha256").update(bytes).digest("hex"));
-      } catch {
-        content = null;
-        fileHashes.set(file, "missing");
-      }
-      await addFileToGraph(graph, cwd, file, facts, ignoredIds, content);
-      if (normalizedChangedSet.has(file)) {
-        upsertChangedSymbols(graph, facts, file);
-      }
-      extractedCount++;
-      filesSinceCheckpoint++;
-      if (Number.isFinite(testStopAfter) && testStopAfter > 0 && extractedCount >= testStopAfter) {
-        writeReviewGraphCheckpointSync(cwd, buildReviewGraphCheckpointData(cwd, graph, fileHashes, filesToBuild.length, ignoredIds, resolveIdentity), {
-          nodes: graph.nodes.size,
-          edges: graph.edges.length,
-          processed: fileHashes.size,
-          target: filesToBuild.length
-        });
-        throw new Error("__review_graph_checkpoint_test_abort__");
-      }
-      const remainingAfter = filesToExtract.length - extractedCount;
-      if (filesSinceCheckpoint >= checkpointEvery && remainingAfter >= checkpointEvery && Date.now() - lastCheckpointMs >= checkpointMinIntervalMs) {
-        writeReviewGraphCheckpoint(cwd, graph, fileHashes, filesToBuild.length, ignoredIds, resolveIdentity);
-        filesSinceCheckpoint = 0;
-        lastCheckpointMs = Date.now();
-      }
-    }
-  };
-  const extractAndDrainIr = async () => {
-    try {
-      await extractFiles();
-    } finally {
-      clearReviewGraphFileIr(cwd);
-    }
-  };
-  if (treeSitterClient) {
-    await treeSitterClient.withParseCacheMeasurement(extractAndDrainIr, (stats) => {
-      logTreeSitterCacheStats({
-        scope: "review_graph_full",
-        filePath: cwd,
-        fileCount: filesToBuild.length,
-        durationMs: Date.now() - extractionStartedAt,
-        stats,
-        astGrep: { durationMs: 0, fileCount: 0 }
-      });
-    });
-  } else {
-    await extractAndDrainIr();
-  }
-  if (resumed) {
-    for (const file of normalizedChangedSet) {
-      if (resumed.fileHashes.has(file)) {
-        upsertChangedSymbols(graph, facts, file);
-      }
-    }
-  }
-  resolveDeferredSymbolEdges(graph);
-  graph.version = REVIEW_GRAPH_VERSION;
-  graph.builtAt = new Date().toISOString();
-  graph.persistCoverage = sourceFilesTruncated ? graphCoverage(graph, graphPersistMaxElements(), sourceFileCount, true, filesToBuild) : undefined;
-  deleteReviewGraphCheckpoint(cwd);
-  const generation = ++_graphGenerationCounter;
-  const retained = retainedGraph(cwd, graph);
-  const wasCapped = retained !== graph;
-  const graphSnapshot = wasCapped ? retained : cloneGraph(graph);
-  if (!wasCapped)
-    rebuildIndexes(graphSnapshot);
-  graphSnapshot.buildGeneration = generation;
-  setWorkspaceGraph(normalizedCwd, {
-    signature,
-    fileSignatures: new Map(fileSignatures),
-    fileHashes,
-    graph: graphSnapshot,
-    buildGeneration: generation,
-    ...verifiedCacheFields(seqAtBuildStart)
-  }, cacheEpoch);
-  const persistReason = persistGraph(cwd, signature, fileSignatures, fileHashes, graphSnapshot, {
-    buildId,
-    projectSeq: seqAtBuildStart,
-    seqHint: seqHint !== undefined,
-    mode: "full",
-    sourceFileCount,
-    sourceFilesTruncated,
-    resolveIdentity
-  });
-  setGraphBuildInfo(graph, {
-    reused: false,
-    mode: "full",
-    sourceFileCount,
-    sourceFileCountTruncated: sourceFilesTruncated,
-    pathNormalizeCalls,
-    seqFastpathFallback,
-    ...persistReason ? { persistReason } : {},
-    graphChanged: true
-  });
-  graph.buildGeneration = generation;
-  setSessionReviewGraphFact(cwd, facts, graphSnapshot);
-  return graph;
-}
-function buildCacheKey(cwd, changedFiles) {
-  return `${buildCacheWorkspaceKey(cwd)}|${[...changedFiles].sort((a, b) => compareOrdinal(a, b)).join(",")}`;
-}
-export function isGraphBuildInFlight(cwd, changedFiles = []) {
-  return _buildCache.has(buildCacheKey(cwd, changedFiles));
-}
-export function buildOrUpdateGraph(cwd, changedFiles, facts, seqHint) {
-  const cacheKey = buildCacheKey(cwd, changedFiles);
-  const cached = _buildCache.get(cacheKey);
-  if (cached)
-    return cached;
-  const startedAt = Date.now();
-  const buildId = ++_buildIdCounter;
-  recordBuildAttempt(cwd, "running", undefined, buildId);
-  const startedProjectSeq = seqHint?.projectSeq();
-  logReviewGraph({
-    cwd,
-    phase: "build_started",
-    observability: {
-      graph: {
-        buildId,
-        ...startedProjectSeq === undefined ? {} : { projectSeq: startedProjectSeq },
-        ...seqHint === undefined ? {} : { seqHint: true },
-        nodes: 0,
-        edges: 0
-      }
-    }
-  });
-  const promise = _doBuildGraph(cwd, changedFiles, facts, seqHint, buildId).then((graph) => {
-    const buildInfo = getGraphBuildInfoForGraph(graph);
-    if (buildInfo.mode === "skipped") {
-      const reason = buildInfo.skipReason ?? "skipped";
-      recordBuildAttempt(cwd, "skipped", reason, buildId);
-      logReviewGraph({
-        cwd,
-        phase: "build_skipped",
-        reason,
-        durationMs: Date.now() - startedAt,
-        observability: {
-          graph: graphLogMetadata(graph, {
-            buildId,
-            projectSeq: startedProjectSeq,
-            seqHint: seqHint !== undefined,
-            mode: buildInfo.mode,
-            sourceFileCount: buildInfo.sourceFileCount,
-            sourceFileCountTruncated: buildInfo.sourceFileCountTruncated,
-            pathNormalizeCalls: buildInfo.pathNormalizeCalls
-          })
-        }
-      });
-    } else {
-      const reason = buildInfo.persistReason;
-      recordBuildAttempt(cwd, "succeeded", reason, buildId);
-      logReviewGraph({
-        cwd,
-        phase: "build_succeeded",
-        durationMs: Date.now() - startedAt,
-        nodes: graph.nodes.size,
-        edges: graph.edges.length,
-        ...reason ? { reason } : {},
-        observability: {
-          graph: graphLogMetadata(graph, {
-            buildId,
-            projectSeq: startedProjectSeq,
-            seqHint: seqHint !== undefined,
-            mode: buildInfo.mode,
-            sourceFileCount: buildInfo.sourceFileCount,
-            sourceFileCountTruncated: buildInfo.sourceFileCountTruncated,
-            pathNormalizeCalls: buildInfo.pathNormalizeCalls
-          })
-        }
-      });
-    }
-    return graph;
-  }).catch((err) => {
-    const reason = err instanceof Error ? err.message : String(err);
-    recordBuildAttempt(cwd, "failed", reason, buildId);
-    logReviewGraph({
-      cwd,
-      phase: "build_failed",
-      reason,
-      durationMs: Date.now() - startedAt,
-      error: reason,
-      observability: {
-        graph: {
-          buildId,
-          ...seqHint === undefined ? {} : { seqHint: true },
-          nodes: 0,
-          edges: 0
-        }
-      }
-    });
-    throw err;
-  });
-  _buildCache.set(cacheKey, promise);
-  const release = () => {
-    if (_buildCache.get(cacheKey) === promise)
-      _buildCache.delete(cacheKey);
-  };
-  promise.then(release, release);
-  return promise;
-}
-export function extractSymbolsAndRefsFromGraph(graph) {
-  const allSymbols = new Map;
-  const allRefs = new Map;
-  const nodeSymbols = new Map;
-  const coverage = {
-    totalEvidence: 0,
-    callsEvidence: 0,
-    referencesEvidence: 0,
-    eligibleEvidence: 0,
-    resolvedEvidence: 0,
-    unresolvedEvidence: 0,
-    typeOnlyEvidence: 0,
-    unsupportedEvidence: 0,
-    sameFileEvidence: 0,
-    duplicateEvidence: 0,
-    complete: graph.persistCoverage?.partial !== true && graph.persistCoverage?.inProgress !== true,
-    languages: {}
-  };
-  const numberMetadata = (node, key) => {
-    const value = node?.metadata?.[key];
-    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
-  };
-  const symbolKind = (node) => {
-    switch (node.symbolKind) {
-      case "class":
-      case "interface":
-      case "type":
-      case "variable":
-      case "method":
-      case "property":
-      case "function":
-        return node.symbolKind;
-      default:
-        return "function";
-    }
-  };
-  for (const node of graph.nodes.values()) {
-    if (node.kind !== "symbol" || !node.filePath || !node.symbolName)
-      continue;
-    const sym = {
-      id: node.id,
-      name: node.symbolName,
-      kind: symbolKind(node),
-      filePath: node.filePath,
-      line: numberMetadata(node, "line") ?? 1,
-      endLine: numberMetadata(node, "endLine"),
-      column: numberMetadata(node, "column") ?? 1,
-      isExported: node.exported === true
-    };
-    nodeSymbols.set(node.id, sym);
-    const list = allSymbols.get(node.filePath) ?? [];
-    list.push(sym);
-    allSymbols.set(node.filePath, list);
-  }
-  const addRef = (ref) => {
-    const list = allRefs.get(ref.filePath) ?? [];
-    list.push(ref);
-    allRefs.set(ref.filePath, list);
-  };
-  for (const edge of graph.edges) {
-    if (edge.kind !== "calls" && edge.kind !== "references")
-      continue;
-    coverage.totalEvidence++;
-    if (edge.kind === "calls")
-      coverage.callsEvidence++;
-    else
-      coverage.referencesEvidence++;
-    const fromNode = graph.nodes.get(edge.from);
-    const targetNode = graph.nodes.get(edge.to);
-    const callerFile = fromNode?.kind === "symbol" ? fromNode.filePath : fromNode?.kind === "file" ? fromNode.filePath : edge.from.startsWith("file:") ? edge.from.slice("file:".length) : undefined;
-    if (!callerFile) {
-      coverage.unsupportedEvidence++;
-      continue;
-    }
-    const metadata = edge.metadata ?? {};
-    const referenceKind = edge.kind === "calls" ? "call" : metadata.referenceKind === "call" ? "call" : metadata.referenceKind === "type" ? "type" : "unknown";
-    const resolution = edge.resolution ?? (targetNode && !targetNode.metadata?.unresolvedName ? "exact" : "unresolved");
-    const targetSymbol = nodeSymbols.get(edge.to);
-    const targetName = targetNode?.symbolName ?? (edge.to.startsWith("symbol-name:") ? edge.to.slice("symbol-name:".length) : undefined);
-    const line = typeof metadata.line === "number" ? metadata.line : numberMetadata(fromNode, "line") ?? 1;
-    const column = typeof metadata.column === "number" ? metadata.column : numberMetadata(fromNode, "column") ?? 1;
-    addRef({
-      symbolId: targetName ? `${callerFile}:${targetName}` : edge.to,
-      filePath: callerFile,
-      line,
-      column,
-      evidenceKind: edge.kind,
-      referenceKind,
-      targetId: edge.to,
-      callerSymbolId: fromNode?.kind === "symbol" ? fromNode.id : undefined,
-      resolution,
-      targetName,
-      targetKind: targetNode?.symbolKind,
-      targetFilePath: targetNode?.filePath,
-      targetLine: numberMetadata(targetNode, "line"),
-      targetColumn: numberMetadata(targetNode, "column")
-    });
-    if (referenceKind === "type")
-      coverage.typeOnlyEvidence++;
-    else if (referenceKind !== "call")
-      coverage.unsupportedEvidence++;
-    else if (!targetSymbol || resolution === "name-only" || resolution === "unresolved") {
-      coverage.unresolvedEvidence++;
-    } else {
-      coverage.eligibleEvidence++;
-      coverage.resolvedEvidence++;
-    }
-  }
-  let sawRelevantFileNode = false;
-  for (const node of graph.nodes.values()) {
-    if (node.kind !== "file")
-      continue;
-    sawRelevantFileNode = true;
-    const extraction = node.metadata?.extractionCoverage;
-    const statuses = extraction ? Object.values(extraction) : [];
-    const languageStatus = !extraction || statuses.length === 0 || statuses.includes("unavailable") ? "unavailable" : statuses.includes("partial") ? "partial" : "complete";
-    if (languageStatus !== "complete")
-      coverage.complete = false;
-    if (node.language) {
-      const prior = coverage.languages[node.language];
-      coverage.languages[node.language] = prior === "unavailable" || languageStatus === "unavailable" ? "unavailable" : prior === "partial" || languageStatus === "partial" ? "partial" : languageStatus;
-    }
-  }
-  if (!sawRelevantFileNode)
-    coverage.complete = false;
-  return { allSymbols, allRefs, coverage };
-}