@herbertgao/pi-extensions 2026.9.0 → 2026.9.2

package/node_modules/pi-lens/dist/clients/review-graph/builder.js

@@ -18,7 +18,7 @@ import { containerNameChain, getOpenDocumentSymbols, lspSymbolKindName, } from "
 import { isAtOrAboveHomeDir, normalizeFilePath, normalizeMapKey, toProjectRelativePath, } from "../path-utils.js";
 import { collectProjectSourceFilesWithBudgetAsync } from "../project-scan-policy.js";
 import { getReviewGraphMaxFilesDerived } from "../project-scale.js";
-import { compareOrdinal } from "../string-utils.js";
+import { compareOrdinal, escapeRegExp } from "../string-utils.js";
 import { BoundedLruCache } from "../bounded-cache.js";
 import { jsTsCandidatePaths, resolveAliasedImport, resolveImportToFiles, resolveProjectReferenceImport, resolveWorkspacePackageImport, } from "./import-resolvers.js";
 import { RUNTIME_CONFIG } from "../runtime-config.js";
@@ -27,7 +27,7 @@ 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 { TreeSitterSymbolExtractor, } from "../tree-sitter-symbol-extractor.js";
+import { symbolExtractionGrammar, TreeSitterSymbolExtractor, } from "../tree-sitter-symbol-extractor.js";
 import { withTreeSitterRoot } from "../tree-sitter-shared.js";
 import { incrementDegradationCount } from "../degradation-ledger.js";
 import { resolveGitIdentity } from "./git-identity.js";
@@ -92,8 +92,6 @@ const MAIN_KINDS = new Set([
 // so a repo heavy in JSON/YAML/Markdown doesn't trip the cap on files the graph
 // would have filtered out anyway (the cap is on the walk, not on noise). #250.
 const MAIN_KIND_EXTENSIONS = Array.from(MAIN_KINDS).flatMap((kind) => KIND_EXTENSIONS[kind] ?? []);
-/** The bounded, source-filtered extension set shared by graph cache readers. */
-export const REVIEW_GRAPH_SOURCE_EXTENSIONS = MAIN_KIND_EXTENSIONS;
 const CHANGED_SYMBOLS_PREFIX = "session.reviewGraph.changedSymbols:";
 const extractorCache = new Map();
 const REVIEW_GRAPH_MAX_WARM_WORKSPACES = 8;
@@ -103,27 +101,20 @@ const REVIEW_GRAPH_MAX_WARM_WORKSPACES = 8;
 // spelling is resolved once; repeated builds reuse the result. The project
 // memo is bounded and workspace-cache clears provide a freshness boundary.
 const REVIEW_GRAPH_SOURCE_PATH_MEMO_ENTRIES = 16_384;
-const _sourcePathMemos = new Map();
+// BoundedLruCache, not BoundedFifoMap: a hit here must refresh the workspace's
+// recency (the hand-rolled version did its own delete+set for exactly that),
+// so a workspace still being built is never the one evicted (#2442).
+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) {
-        // The workspace map is also bounded LRU; a hit must refresh its recency.
-        _sourcePathMemos.delete(key);
-        _sourcePathMemos.set(key, existing);
+    if (existing)
         return existing;
-    }
     const memo = {
         cache: new BoundedLruCache(REVIEW_GRAPH_SOURCE_PATH_MEMO_ENTRIES),
         normalizeCalls: { value: 0 },
     };
     _sourcePathMemos.set(key, memo);
-    while (_sourcePathMemos.size > REVIEW_GRAPH_MAX_WARM_WORKSPACES) {
-        const oldest = _sourcePathMemos.keys().next().value;
-        if (oldest === undefined)
-            break;
-        _sourcePathMemos.delete(oldest);
-    }
     return memo;
 }
 function normalizeGraphSourcePath(memo, raw) {
@@ -414,7 +405,7 @@ export function estimateReviewGraphStoreBytes(totalNodes, totalEdges) {
 // cleared). Bounding only the cache left the full graph resident on the fact, so
 // both sites go through `retainedGraph` below, memoized per graph instance so the
 // two sites share ONE bounded object instead of trimming twice (#2255 review F2).
-export const GRAPH_MAX_IN_MEMORY_BYTES_DEFAULT = 512 * 1024 * 1024;
+const GRAPH_MAX_IN_MEMORY_BYTES_DEFAULT = 512 * 1024 * 1024;
 function graphMaxInMemoryBytes() {
     const raw = Number(process.env.PI_LENS_GRAPH_MAX_IN_MEMORY_BYTES);
     return Number.isFinite(raw) && raw > 0
@@ -528,12 +519,15 @@ function headSliceGraph(graph, cap) {
  * This bounds the VALUE, not the store, and deliberately adds no second bounding
  * mechanism to `FactStore` (#2243 owns the store-level discipline).
  *
- * `sessionFacts` entry COUNT is not fully bounded — `session.baseline.${path}`
- * (`dispatch/dispatcher.ts`) and `session.baseline.cascade.${path}`
- * (`dispatch/integration.ts`) mint one key per file touched and clear only on
- * `clearAll`. That is #2282, a separate #2240 sibling; it is
- * per-file `Diagnostic[]`, not a whole project graph. What this seam fixes is the
- * one fact whose single VALUE is unbounded in project size.
+ * `sessionFacts` entry COUNT (a separate #2240 sibling, #2282) is now bounded
+ * too: `session.baseline.${path}` (`dispatch/dispatcher.ts`),
+ * `session.baseline.cascade.${path}` (`dispatch/integration.ts`), and this
+ * module's own `changedSymbols`/`entitySnapshot` per-file keys all go through
+ * `FactStore.setBoundedSessionFact`/`getBoundedSessionFact`, an LRU-count-cap
+ * sibling of the per-file `fileFacts` bound reusing the SAME discipline
+ * (#2243), not a second mechanism. `session.reviewGraph` itself stays on the
+ * plain, unbounded `sessionFacts` map — its key is a fixed singleton, so the
+ * VALUE bound below is what keeps IT small, not an entry-count cap.
  */
 function setSessionReviewGraphFact(cwd, facts, graph) {
     const retained = retainedGraph(cwd, graph);
@@ -826,9 +820,6 @@ function makeCtx(filePath, cwd, facts) {
         log: () => { },
     };
 }
-function escapeRegExp(string) {
-    return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 function createEmptyGraph() {
     return {
         version: REVIEW_GRAPH_VERSION,
@@ -974,7 +965,7 @@ function diffSignatureMaps(previous, next) {
 // `RUNTIME_CONFIG.reviewGraph.maxFiles` constant as the fallback — the ratio
 // table reproduces that same 1,000-file default at the default base, so this
 // is behavior-neutral when nothing is configured.
-export function getReviewGraphMaxFiles(cwd) {
+function getReviewGraphMaxFiles(cwd) {
     const override = Number.parseInt(process.env.PI_LENS_REVIEW_GRAPH_MAX_FILES ?? "", 10);
     return Number.isFinite(override) && override > 0
         ? override
@@ -1226,13 +1217,15 @@ function indexEdge(graph, edge) {
     graph.edgesByTo.set(edge.to, to);
 }
 /**
- * Drop `edge` from both adjacency buckets (#2074). Costs one scan of the two
- * buckets the edge belongs to, never a scan of `graph.edges`, so removing a
- * changed file's edges stays proportional to that file's fan-in/fan-out.
+ * Drop `edge` from both adjacency buckets. This is kept for the single-edge
+ * dedupe path; multi-file removal uses `unindexEdges` below so a shared hub
+ * bucket is scanned once rather than once per removed edge (#2074).
  */
 function unindexEdge(graph, edge) {
     const from = graph.edgesByFrom.get(edge.from);
     if (from) {
+        // Count the full bucket as the linear `indexOf` scan's bounded work.
+        _rebuildCounters.removeOwnedEdgePositions += from.length;
         const at = from.indexOf(edge);
         if (at >= 0)
             from.splice(at, 1);
@@ -1241,6 +1234,7 @@ function unindexEdge(graph, edge) {
     }
     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);
@@ -1248,6 +1242,49 @@ function unindexEdge(graph, edge) {
             graph.edgesByTo.delete(edge.to);
     }
 }
+/**
+ * Remove a batch of edges from both live adjacency indexes. Each touched
+ * bucket is filtered once, so the work is proportional to the bucket lengths,
+ * not to the product of a hub's fan-in and its removed-edge count (#2074).
+ */
+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);
@@ -2621,9 +2658,16 @@ async function tryResumeFromCheckpoint(cwd, filesToBuild, ignoredIds) {
     }
     const graph = loaded.graph;
     // Evict every stale (content-changed) processed file so its outdated
-    // contribution is replaced by a fresh walk below.
+    // contribution is replaced by a fresh walk below. One shared drop set,
+    // compacted once (#2074) — pruneOrphanNonFileNodes reads graph.edges next,
+    // so the compaction must land before it runs.
+    const removedEdges = new Set();
     for (const file of stale)
-        removeFileOwnedGraphData(graph, file);
+        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));
@@ -2654,7 +2698,7 @@ export function _readReviewGraphCheckpointForTests(cwd) {
 }
 /** Test hook: force any pending debounced persist to write immediately. */
 export function flushReviewGraphPersistsForTests() {
-    for (const key of [..._pendingPersist.keys()]) {
+    for (const key of _pendingPersist.keys()) {
         const pending = _pendingPersist.get(key);
         if (!pending)
             continue;
@@ -2718,7 +2762,7 @@ export function flushReviewGraphPersist(cwd, source = "cli") {
     let pending = _pendingPersist.get(key);
     const removedWorkerRequests = [];
     let selectedWorkerRequest;
-    for (const [id, request] of [..._workerRequests]) {
+    for (const [id, request] of _workerRequests) {
         if (request.key !== key)
             continue;
         _workerRequests.delete(id);
@@ -2883,7 +2927,7 @@ function upsertChangedSymbols(graph, facts, filePath) {
     if (detectFileRole(filePath) === "test")
         return;
     const normalized = normalizeMapKey(filePath);
-    const changed = facts.getSessionFact(`${CHANGED_SYMBOLS_PREFIX}${normalized}`);
+    const changed = facts.getBoundedSessionFact(`${CHANGED_SYMBOLS_PREFIX}${normalized}`);
     if (changed && changed.length > 0) {
         graph.changedSymbolsByFile.set(normalized, [...changed]);
     }
@@ -3158,45 +3202,13 @@ function addJsTsFile(graph, cwd, filePath, facts, ignoredIds) {
         }
     }
 }
-function mapKindToTreeSitterLanguage(kind, filePath) {
-    switch (kind) {
-        case "python":
-            return "python";
-        case "go":
-            return "go";
-        case "rust":
-            return "rust";
-        case "ruby":
-            return "ruby";
-        case "cxx": {
-            const ext = filePath ? path.extname(filePath).toLowerCase() : "";
-            return ext === ".c" || ext === ".h" ? "c" : "cpp";
-        }
-        case "java":
-            return "java";
-        case "kotlin":
-            return "kotlin";
-        case "dart":
-            return "dart";
-        case "elixir":
-            return "elixir";
-        case "csharp":
-            return "csharp";
-        case "php":
-            return "php";
-        case "swift":
-            return "swift";
-        case "lua":
-            return "lua";
-        case "ocaml":
-            return "ocaml";
-        case "zig":
-            return "zig";
-        case "shell":
-            return "bash";
-        default:
-            return undefined;
-    }
+// The review graph's kind -> tree-sitter grammar answer. Delegates to the
+// registry-derived resolver (#2424): this used to be a hand-written switch that
+// re-derived the `.c`/`.h` split inline and drifted from the ext -> grammar
+// authority. Exported for the language-identity golden snapshot
+// (scripts/gen-language-snapshot.mjs).
+export function mapKindToTreeSitterLanguage(kind, filePath) {
+    return symbolExtractionGrammar(kind, filePath);
 }
 async function getExtractor(languageId) {
     if (extractorCache.has(languageId))
@@ -3467,7 +3479,7 @@ function addTreeSitterFile(graph, cwd, filePath, languageId, extracted, ignoredI
  * SymbolInformation results (including native TypeScript 7) recover the same
  * containment through `containerName` when the owner is present in the result.
  */
-export function addLspFallbackSymbols(graph, filePath, languageId, symbols) {
+function addLspFallbackSymbols(graph, filePath, languageId, symbols) {
     const normalized = normalizeMapKey(filePath);
     const fileNodeId = `file:${normalized}`;
     let added = 0;
@@ -3622,46 +3634,55 @@ function addCxxIncludeEdges(graph, cwd, filePath, ignoredIds, contentOverride) {
         });
     }
 }
-function removeFileOwnedGraphData(graph, filePath) {
+/**
+ * Drop the nodes/edges a changed file owns, and index-maintain as it goes.
+ * `removedEdges` accumulates edges to drop from `graph.edges` — the CALLER
+ * compacts the array once for the whole batch (#2074): before this, each call
+ * ran its own `graph.edges.filter()`, so a batch of N changed files scanned
+ * the whole edge array N times (changedFiles x graph, not changedFiles x
+ * fan-in/out).
+ *
+ * `removedIds` is exactly `fileNodes`/`symbolNodesByFile`'s entries for this
+ * file — `file` and `symbol` are the only node kinds that ever set `filePath`
+ * (`module`/`external` placeholders never do) — so no `graph.nodes` scan is
+ * needed either, and the owned edges are read straight off `edgesByFrom` /
+ * `edgesByTo` instead of scanning `graph.edges`.
+ */
+function removeFileOwnedGraphData(graph, filePath, removedEdges) {
     const normalized = normalizeMapKey(filePath);
-    const fileNodeId = `file:${normalized}`;
-    const removedIds = new Set();
-    const removedSymbolIds = new Set();
-    for (const [id, node] of graph.nodes) {
-        if (node.filePath !== normalized)
-            continue;
-        removedIds.add(id);
-        if (node.kind === "symbol")
-            removedSymbolIds.add(id);
-    }
+    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 = [];
-    const droppedEdges = [];
-    graph.edges = graph.edges.filter((edge) => {
+    for (const edge of candidates) {
+        // A cross-edge can be discovered from both changed files' adjacency
+        // buckets. Preserve and remove it only once, matching eager unindexing
+        // while the batch indexes remain live until the end.
+        if (removedEdges.has(edge))
+            continue;
         const fromRemoved = removedIds.has(edge.from);
-        const toRemoved = removedIds.has(edge.to);
-        if (fromRemoved) {
-            droppedEdges.push(edge);
-            return false;
-        }
-        if (removedSymbolIds.has(edge.to)) {
+        // Preserve importer edges to the stable file node id; the node is
+        // re-added below.
+        if (!fromRemoved && edge.to === fileNodeId)
+            continue;
+        if (!fromRemoved && removedSymbolIds.has(edge.to)) {
             preservedIncomingSymbolEdges.push({ ...edge });
-            droppedEdges.push(edge);
-            return false;
         }
-        // Preserve importer edges to the stable file node id; the node is re-added below.
-        if (toRemoved && edge.to === fileNodeId)
-            return true;
-        if (toRemoved)
-            droppedEdges.push(edge);
-        return !toRemoved;
-    });
-    // #2074: keep the adjacency indexes live instead of rebuilding them over the
-    // whole graph afterwards. Only the dropped edges' own buckets are touched.
-    // Unconditional: on an unindexed graph every bucket lookup simply misses.
-    for (const edge of droppedEdges)
-        unindexEdge(graph, edge);
+        removedEdges.add(edge);
+    }
     for (const id of removedIds) {
         const node = graph.nodes.get(id);
         graph.nodes.delete(id);
@@ -3769,18 +3790,30 @@ async function addFileToGraph(graph, cwd, file, facts, ignoredIds, contentOverri
 /**
  * #2074 acceptance instrumentation. `restoreComparisons` counts edge-metadata
  * stringifications inside `restoreValidIncomingEdges`; `importTargetEdgeScans`
- * counts edges visited by `importTargetsForFile`. Before this change both grew
- * with the whole graph on every one-file rebuild. They are the count-based
- * signal the issue asks for, because wall time on this hardware is IO-noisy
- * (#1920).
+ * counts edges visited by `importTargetsForFile`; `removeOwnedEdgeVisits`
+ * counts edges visited while collecting a changed file's owned edges in
+ * `removeFileOwnedGraphData`. Before this change all three grew with the whole
+ * graph on every one-file rebuild, and `removeOwnedEdgeVisits` grew with
+ * changedFiles x graph on a multi-file batch (one full `graph.edges` scan per
+ * file). `removeOwnedEdgePositions` counts adjacency positions examined while
+ * removing edges; batching keeps a high-fan-in bucket linear instead of
+ * rescanning its prefix for every edge. They are the count-based signal the
+ * issue asks for, because wall time on this hardware is IO-noisy (#1920).
  */
-const _rebuildCounters = { restoreComparisons: 0, importTargetEdgeScans: 0 };
+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;
 }
 /**
  * Identity of an edge for dedupe purposes, WITHIN one target bucket: the array
@@ -3893,10 +3926,18 @@ async function updateGraphFiles(graph, cwd, files, facts, ignoredIds) {
         priorTargets: importTargetsForFile(graph, file),
     }));
     const preservedIncoming = [];
+    // #2074: one shared drop set for the whole batch, compacted into graph.edges
+    // exactly once below — not once per file, which made a multi-file rebuild
+    // scan the edge array changedFiles times over.
+    const removedEdges = new Set();
     for (const file of files) {
-        preservedIncoming.push(...removeFileOwnedGraphData(graph, file));
+        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();

package/node_modules/pi-lens/dist/clients/review-graph/import-resolvers.js

@@ -90,7 +90,7 @@ function resolveDart(cwd, filePath, source) {
 // JS/TS extension from the specifier before re-appending candidate extensions
 // lets that universal pattern resolve to the real source file. Exported so
 // builder.ts's warm `localImportToFile` shares the exact same regex (#694).
-export const JS_TS_EXT_RE = /\.(mjs|cjs|mts|cts|jsx?|tsx?)$/i;
+const JS_TS_EXT_RE = /\.(mjs|cjs|mts|cts|jsx?|tsx?)$/i;
 /**
  * Ordered candidate list for resolving a relative JS/TS import specifier
  * (already resolved to an absolute base path) to an on-disk file, with

package/node_modules/pi-lens/dist/clients/review-graph/service.js

@@ -1,3 +1,5 @@
+import { recordDegradationOnce } from "../degradation-ledger.js";
+import { isAbsoluteFilePath, normalizeMapKey } from "../path-utils.js";
 import { computeImpactCascade as computeImpactCascadeImpl, computeTransitiveImpact as computeTransitiveImpactImpl, } from "./query.js";
 import { buildOrUpdateGraph as buildOrUpdateGraphImpl, } from "./builder.js";
 import { formatImpactCascade as formatImpactCascadeImpl } from "./format.js";
@@ -19,7 +21,57 @@ export function computeTransitiveImpact(graph, seedFile, options) {
     return computeTransitiveImpactImpl(graph, seedFile, options);
 }
 export function recordEntitySnapshotDiff(facts, filePath, nextSnapshot) {
-    const prev = facts.getSessionFact(`${ENTITY_SNAPSHOT_PREFIX}${filePath}`) ?? new Map();
+    // #2477 round 2 (reviewer F1/F2): folding `cwd` into this key was REVERTED.
+    // The writer (`clients/dispatch/runners/tree-sitter.ts`) passes `ctx.cwd`,
+    // which `createDispatchContext` (`clients/dispatch/dispatcher.ts:324-326`)
+    // sets to the file's NEAREST LANGUAGE-ROOT (`resolveLanguageRootForFile`),
+    // while the reader (`upsertChangedSymbols`, `clients/review-graph/builder.ts`,
+    // reached via `computeCascadeForFile` → `buildOrUpdateGraph`) keys off the
+    // WORKSPACE cwd. In a monorepo/cargo-workspace/go-module layout those two
+    // cwd values diverge, so a folded `(cwd, path)` key the builder reader can
+    // never hit zeroed `graphChangedSymbolCount` on every build — reproduced:
+    // master returns `["alpha","beta"]`, the folded-key version returns `[]`
+    // — and made the cascade over-fan to every symbol (`query.ts:230-238`
+    // treats an empty `changedSymbols` as "no narrowing").
+    //
+    // The #2477 cross-project collision this was meant to close cannot reach
+    // this function in production: the sole writer always passes `ctx.filePath`,
+    // which `createDispatchContext` sets via `resolveRunnerPath` to an
+    // ALWAYS-ABSOLUTE path (the #2016 invariant, `dispatcher.ts:320,327,346`).
+    // A relative `filePath` here can only happen through a caller regression.
+    // Enforce that instead of re-keying: reject a non-absolute `filePath` with
+    // a visible, bounded ledger record (never silently, per AGENTS.md) and
+    // skip the diff rather than compute one under a key the real reader could
+    // never reach anyway. `recordDegradationOnce` (not a thrown error) is used
+    // because the sole call site's surrounding try/catch
+    // (`tree-sitter.ts` — "entity snapshot / blast-radius enrichment is
+    // best-effort") is a BARE, UNLOGGED catch: a thrown error there vanishes
+    // with no trace, which is strictly worse than a ledger record.
+    if (!isAbsoluteFilePath(filePath)) {
+        recordDegradationOnce({
+            kind: "review-graph-non-absolute-entity-path",
+            subject: filePath,
+            reason: "recordEntitySnapshotDiff requires an absolute filePath (refs #2477)",
+        });
+        return { added: [], removed: [], modified: [] };
+    }
+    // Normalize once at this boundary, then reuse the folded path for both
+    // per-file facts. An unnormalized write is a key the builder reader can never
+    // hit, and an unnormalized snapshot forks a second empty diff (#2355).
+    const normalizedFilePath = normalizeMapKey(filePath);
+    const snapshotKey = `${ENTITY_SNAPSHOT_PREFIX}${normalizedFilePath}`;
+    const changedSymbolsKey = `${CHANGED_SYMBOLS_PREFIX}${normalizedFilePath}`;
+    const stored = facts.getBoundedSessionFact(snapshotKey);
+    // An evicted snapshot is unknown, not empty. Diffing against an empty Map
+    // puts every entity in `added`, which reads downstream as "the whole file
+    // changed" and schedules a blast-radius run for a file that did not change.
+    // Re-seed the snapshot and report no diff instead (#2282 review F1).
+    if (stored === undefined && facts.wasBoundedSessionFactEvicted(snapshotKey)) {
+        facts.setBoundedSessionFact(snapshotKey, new Map(nextSnapshot));
+        facts.setBoundedSessionFact(changedSymbolsKey, []);
+        return { added: [], removed: [], modified: [] };
+    }
+    const prev = stored ?? new Map();
     const added = [];
     const removed = [];
     const modified = [];
@@ -38,7 +90,7 @@ export function recordEntitySnapshotDiff(facts, filePath, nextSnapshot) {
             .map((key) => key.split(":")[1])
             .filter(Boolean)),
     ];
-    facts.setSessionFact(`${ENTITY_SNAPSHOT_PREFIX}${filePath}`, new Map(nextSnapshot));
-    facts.setSessionFact(`${CHANGED_SYMBOLS_PREFIX}${filePath}`, changedSymbols);
+    facts.setBoundedSessionFact(snapshotKey, new Map(nextSnapshot));
+    facts.setBoundedSessionFact(changedSymbolsKey, changedSymbols);
     return { added, removed, modified };
 }

package/node_modules/pi-lens/dist/clients/review-graph/shared-extraction-ir.js

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { BoundedFifoMap } from "../bounded-cache.js";
 import { normalizeMapKey } from "../path-utils.js";
 /**
  * THE producer/consumer hash contract, in one place (#955 review): scanner
@@ -17,7 +18,10 @@ export function reviewGraphIrContentHash(content) {
 // registry's lifetime is the scan-to-build window, not the process lifetime.
 const MAX_ROOTS = 8;
 const MAX_FILES_PER_ROOT = 20_000;
-const roots = new Map();
+// Both levels are FIFO, matching the hand-rolled blocks these replaced: no
+// read on either map refreshed recency before #2442, and the consume-once
+// contract above means a read is normally a DELETE anyway.
+const roots = new BoundedFifoMap(MAX_ROOTS);
 let accepted = 0;
 let rejected = 0;
 function rootKey(cwd) {
@@ -33,23 +37,11 @@ export function publishReviewGraphFileIr(cwd, entry) {
     const key = rootKey(cwd);
     let files = roots.get(key);
     if (!files) {
-        files = new Map();
+        files = new BoundedFifoMap(MAX_FILES_PER_ROOT);
         roots.set(key, files);
-        while (roots.size > MAX_ROOTS) {
-            const oldest = roots.keys().next().value;
-            if (oldest === undefined)
-                break;
-            roots.delete(oldest);
-        }
     }
     const fileKey = normalizeMapKey(entry.filePath);
-    files.delete(fileKey);
-    while (files.size >= MAX_FILES_PER_ROOT) {
-        const oldest = files.keys().next().value;
-        if (oldest === undefined)
-            break;
-        files.delete(oldest);
-    }
+    files.delete(fileKey); // republish is a refresh: it becomes the newest
     files.set(fileKey, { ...entry, filePath: fileKey });
 }
 /**