@herbertgao/pi-extensions 2026.8.10 → 2026.8.12

package/node_modules/pi-lens/dist/clients/call-graph.js

@@ -38,7 +38,9 @@ function severityForDepth(depth) {
 export function impact(graph, startKey, maxDepth = 3, minWeight = 0.1) {
     const results = [];
     const visited = new Set([startKey]);
-    const queue = [{ key: startKey, depth: 0 }];
+    const queue = [
+        { key: startKey, depth: 0 },
+    ];
     // Build a weight lookup from edges for filtering
     const edgeWeightMap = new Map();
     for (const edge of graph.edges) {
@@ -63,7 +65,11 @@ export function impact(graph, startKey, maxDepth = 3, minWeight = 0.1) {
                 continue;
             visited.add(callerKey);
             const depth = item.depth + 1;
-            results.push({ symbolKey: callerKey, depth, severity: severityForDepth(depth) });
+            results.push({
+                symbolKey: callerKey,
+                depth,
+                severity: severityForDepth(depth),
+            });
             queue.push({ key: callerKey, depth });
         }
     }
@@ -101,10 +107,16 @@ export function formatImpact(results, projectRoot) {
         return file ? `${name} (${file})` : name;
     };
     if (willBreak.length > 0) {
-        parts.push(willBreak.slice(0, 3).map((r) => `${label(r)} ⚠ WillBreak`).join(", "));
+        parts.push(willBreak
+            .slice(0, 3)
+            .map((r) => `${label(r)} ⚠ WillBreak`)
+            .join(", "));
     }
     if (mayBreak.length > 0) {
-        parts.push(mayBreak.slice(0, 2).map((r) => `${label(r)} MayBreak`).join(", "));
+        parts.push(mayBreak
+            .slice(0, 2)
+            .map((r) => `${label(r)} MayBreak`)
+            .join(", "));
     }
     if (review.length > 0) {
         parts.push(`${review.length} Review caller${review.length === 1 ? "" : "s"}`);
@@ -118,25 +130,106 @@ export function formatImpact(results, projectRoot) {
  */
 const STDLIB_NAMES = new Set([
     // JS/TS
-    "console", "Math", "Object", "Array", "String", "Number", "Boolean",
-    "Promise", "Error", "Map", "Set", "WeakMap", "WeakSet", "JSON", "Date",
-    "RegExp", "Symbol", "BigInt", "parseInt", "parseFloat", "isNaN",
-    "isFinite", "setTimeout", "clearTimeout", "setInterval", "clearInterval",
-    "fetch", "URL", "URLSearchParams", "Buffer", "process", "require",
+    "console",
+    "Math",
+    "Object",
+    "Array",
+    "String",
+    "Number",
+    "Boolean",
+    "Promise",
+    "Error",
+    "Map",
+    "Set",
+    "WeakMap",
+    "WeakSet",
+    "JSON",
+    "Date",
+    "RegExp",
+    "Symbol",
+    "BigInt",
+    "parseInt",
+    "parseFloat",
+    "isNaN",
+    "isFinite",
+    "setTimeout",
+    "clearTimeout",
+    "setInterval",
+    "clearInterval",
+    "fetch",
+    "URL",
+    "URLSearchParams",
+    "Buffer",
+    "process",
+    "require",
     // Python
-    "print", "len", "range", "list", "dict", "str", "int", "float", "bool",
-    "open", "isinstance", "issubclass", "type", "super", "hasattr", "getattr",
-    "setattr", "enumerate", "zip", "map", "filter", "sorted", "reversed",
+    "print",
+    "len",
+    "range",
+    "list",
+    "dict",
+    "str",
+    "int",
+    "float",
+    "bool",
+    "open",
+    "isinstance",
+    "issubclass",
+    "type",
+    "super",
+    "hasattr",
+    "getattr",
+    "setattr",
+    "enumerate",
+    "zip",
+    "map",
+    "filter",
+    "sorted",
+    "reversed",
     // Go
-    "fmt", "log", "os", "io", "err", "make", "append", "cap", "copy",
-    "close", "delete", "panic", "recover", "new",
+    "fmt",
+    "log",
+    "os",
+    "io",
+    "err",
+    "make",
+    "append",
+    "cap",
+    "copy",
+    "close",
+    "delete",
+    "panic",
+    "recover",
+    "new",
     // Rust
-    "eprintln", "eprint", "vec", "Some", "None", "Ok", "Err",
-    "Box", "Rc", "Arc", "Vec", "HashMap", "HashSet", "format",
+    "eprintln",
+    "eprint",
+    "vec",
+    "Some",
+    "None",
+    "Ok",
+    "Err",
+    "Box",
+    "Rc",
+    "Arc",
+    "Vec",
+    "HashMap",
+    "HashSet",
+    "format",
     // Java/Kotlin
-    "System", "toString", "equals", "hashCode", "Objects",
+    "System",
+    "toString",
+    "equals",
+    "hashCode",
+    "Objects",
     // Generic
-    "this", "self", "nil", "null", "undefined", "true", "false",
+    "this",
+    "self",
+    "nil",
+    "null",
+    "undefined",
+    "true",
+    "false",
 ]);
 // ── Core resolution ────────────────────────────────────────────────────────────
 /**
@@ -253,7 +346,9 @@ allRefs, inputCoverage) {
                 // Canonical graph identity is authoritative. Never recover a name by
                 // splitting an id: symbol ids contain kind and line components.
                 const callee = defIndex.byId.get(ref.targetId);
-                if (!callee || ref.resolution === "name-only" || ref.resolution === "unresolved") {
+                if (!callee ||
+                    ref.resolution === "name-only" ||
+                    ref.resolution === "unresolved") {
                     if (!hasInputCoverage) {
                         unresolvedRefs++;
                         coverage.unresolvedEvidence++;
@@ -271,7 +366,9 @@ allRefs, inputCoverage) {
                 // There is no typed/import evidence to select one definition, so retain
                 // every cross-file candidate and discount each edge. Picking [0] made
                 // graph iteration order decide which caller was reported.
-                const refName = ref.symbolName ?? parseSymbolKey(ref.symbolId, callerFile).symbolName ?? "";
+                const refName = ref.symbolName ??
+                    parseSymbolKey(ref.symbolId, callerFile).symbolName ??
+                    "";
                 if (STDLIB_NAMES.has(refName) || !refName) {
                     if (!hasInputCoverage)
                         coverage.unsupportedEvidence++;
@@ -287,7 +384,8 @@ allRefs, inputCoverage) {
                 }
                 const crossFileDefs = defs
                     .map((id) => defIndex.byId.get(id))
-                    .filter((candidate) => candidate !== undefined && normalizeMapKey(candidate.filePath) !== callerFileKey);
+                    .filter((candidate) => candidate !== undefined &&
+                    normalizeMapKey(candidate.filePath) !== callerFileKey);
                 if (crossFileDefs.length === 0) {
                     if (!hasInputCoverage)
                         coverage.unsupportedEvidence++;
@@ -295,10 +393,15 @@ allRefs, inputCoverage) {
                 }
                 const resolution = crossFileDefs.length === 1 ? "exact" : "name-only";
                 for (const callee of crossFileDefs) {
-                    candidates.push({ callee, resolution, candidateCount: crossFileDefs.length });
+                    candidates.push({
+                        callee,
+                        resolution,
+                        candidateCount: crossFileDefs.length,
+                    });
                 }
             }
-            if (ref.evidenceKind && candidates.some(({ resolution }) => resolution === "name-only")) {
+            if (ref.evidenceKind &&
+                candidates.some(({ resolution }) => resolution === "name-only")) {
                 if (!hasInputCoverage) {
                     unresolvedRefs++;
                     coverage.unresolvedEvidence++;
@@ -331,9 +434,10 @@ allRefs, inputCoverage) {
                 const existing = edgeByPair.get(pairKey);
                 if (existing) {
                     existing.evidenceCount = (existing.evidenceCount ?? 1) + 1;
-                    existing.evidenceKind = existing.evidenceKind === ref.evidenceKind
-                        ? existing.evidenceKind
-                        : "mixed";
+                    existing.evidenceKind =
+                        existing.evidenceKind === ref.evidenceKind
+                            ? existing.evidenceKind
+                            : "mixed";
                     // Duplicate evidence is a property of the logical pair, not of
                     // whether the producer happened to tag the record. Keep the edge,
                     // coverage, and centrality views consistent for legacy refs too.
@@ -388,15 +492,20 @@ allRefs, inputCoverage) {
     if (hasInputCoverage)
         totalRefs = coverage.totalEvidence;
     const languagesKnownComplete = Object.values(coverage.languages ?? {}).every((status) => status === "complete");
-    coverage.complete = coverage.complete && hasInputCoverage &&
-        coverage.unsupportedEvidence === 0 && languagesKnownComplete &&
-        (allSymbols.size > 0 || coverage.totalEvidence > 0);
+    coverage.complete =
+        coverage.complete &&
+            hasInputCoverage &&
+            coverage.unsupportedEvidence === 0 &&
+            languagesKnownComplete &&
+            (allSymbols.size > 0 || coverage.totalEvidence > 0);
     return {
         callees,
         callers,
         inDegree,
         edges: [...edgeByPair.values()],
-        unresolvedRefs: hasInputCoverage ? coverage.unresolvedEvidence : unresolvedRefs,
+        unresolvedRefs: hasInputCoverage
+            ? coverage.unresolvedEvidence
+            : unresolvedRefs,
         totalRefs,
         coverage,
         builtAt: new Date().toISOString(),
@@ -433,7 +542,10 @@ export function saveCallGraph(cwd, graph, identity) {
             coverage: graph.coverage,
         };
         writeFileAtomic(cacheFile, JSON.stringify(persisted));
-        writeFileAtomic(metaFile, JSON.stringify({ savedAt: new Date().toISOString(), edgeCount: graph.edges.length }));
+        writeFileAtomic(metaFile, JSON.stringify({
+            savedAt: new Date().toISOString(),
+            edgeCount: graph.edges.length,
+        }));
     }
     catch {
         // Non-fatal — next session rebuilds from scratch.
@@ -485,21 +597,36 @@ function finiteCount(value) {
     return typeof value === "number" && Number.isInteger(value) && value >= 0;
 }
 function countsMatch(left, right) {
-    return Math.abs(left - right) <= 1e-9 * Math.max(1, Math.abs(left), Math.abs(right));
+    return (Math.abs(left - right) <=
+        1e-9 * Math.max(1, Math.abs(left), Math.abs(right)));
 }
 function validatePersistedCallGraph(raw, coverage) {
     const nonEmptyString = (value) => typeof value === "string" && value.trim().length > 0;
     const enumValue = (value, values) => typeof value === "string" && values.includes(value);
     const edgeKinds = ["calls", "references", "mixed"];
-    const resolutions = ["exact", "import", "receiver-type", "name-only", "unresolved"];
-    if (!raw || raw.version !== CALL_GRAPH_CACHE_VERSION || !nonEmptyString(raw.builtAt))
+    const resolutions = [
+        "exact",
+        "import",
+        "receiver-type",
+        "name-only",
+        "unresolved",
+    ];
+    if (!raw ||
+        raw.version !== CALL_GRAPH_CACHE_VERSION ||
+        !nonEmptyString(raw.builtAt))
         return false;
-    if (!nonEmptyString(raw.reviewGraphVersion) || !nonEmptyString(raw.reviewGraphSignature))
+    if (!nonEmptyString(raw.reviewGraphVersion) ||
+        !nonEmptyString(raw.reviewGraphSignature))
         return false;
     if (raw.coverage !== undefined &&
-        (!raw.coverage || typeof raw.coverage !== "object" || Array.isArray(raw.coverage)))
+        (!raw.coverage ||
+            typeof raw.coverage !== "object" ||
+            Array.isArray(raw.coverage)))
         return false;
-    if (!Array.isArray(raw.edges) || !Array.isArray(raw.callees) || !Array.isArray(raw.callers) || !Array.isArray(raw.inDegree))
+    if (!Array.isArray(raw.edges) ||
+        !Array.isArray(raw.callees) ||
+        !Array.isArray(raw.callers) ||
+        !Array.isArray(raw.inDegree))
         return false;
     const coverageValues = [
         coverage.totalEvidence,
@@ -513,23 +640,34 @@ function validatePersistedCallGraph(raw, coverage) {
         coverage.sameFileEvidence,
         coverage.duplicateEvidence,
     ];
-    if (typeof coverage.complete !== "boolean" || coverageValues.some((value) => !finiteCount(value)))
+    if (typeof coverage.complete !== "boolean" ||
+        coverageValues.some((value) => !finiteCount(value)))
         return false;
     if (coverage.languages !== undefined &&
-        (!coverage.languages || typeof coverage.languages !== "object" || Array.isArray(coverage.languages) ||
-            Object.entries(coverage.languages).some(([language, status]) => !nonEmptyString(language) || !enumValue(status, ["complete", "partial", "unavailable"]))))
+        (!coverage.languages ||
+            typeof coverage.languages !== "object" ||
+            Array.isArray(coverage.languages) ||
+            Object.entries(coverage.languages).some(([language, status]) => !nonEmptyString(language) ||
+                !enumValue(status, ["complete", "partial", "unavailable"]))))
         return false;
-    if (coverage.callsEvidence + coverage.referencesEvidence !== coverage.totalEvidence)
+    if (coverage.callsEvidence + coverage.referencesEvidence !==
+        coverage.totalEvidence)
         return false;
     if (coverage.resolvedEvidence > coverage.eligibleEvidence)
         return false;
     if (coverage.eligibleEvidence !== coverage.resolvedEvidence)
         return false;
-    if (coverage.resolvedEvidence + coverage.unresolvedEvidence + coverage.typeOnlyEvidence + coverage.unsupportedEvidence + coverage.sameFileEvidence !== coverage.totalEvidence)
+    if (coverage.resolvedEvidence +
+        coverage.unresolvedEvidence +
+        coverage.typeOnlyEvidence +
+        coverage.unsupportedEvidence +
+        coverage.sameFileEvidence !==
+        coverage.totalEvidence)
         return false;
     if (coverage.complete && coverage.unsupportedEvidence > 0)
         return false;
-    if (coverage.complete && Object.values(coverage.languages ?? {}).some((status) => status !== "complete"))
+    if (coverage.complete &&
+        Object.values(coverage.languages ?? {}).some((status) => status !== "complete"))
         return false;
     const expectedCallees = new Map();
     const expectedCallers = new Map();
@@ -538,9 +676,17 @@ function validatePersistedCallGraph(raw, coverage) {
     let weightedEdgeEvidence = 0;
     let weightedDuplicateEvidence = 0;
     for (const edge of raw.edges) {
-        if (!edge || typeof edge !== "object" || !nonEmptyString(edge.callerKey) || !nonEmptyString(edge.calleeKey) ||
-            !nonEmptyString(edge.callerFile) || !nonEmptyString(edge.calleeFile) ||
-            !nonEmptyString(edge.calleeSymbol) || typeof edge.weight !== "number" || !Number.isFinite(edge.weight) || edge.weight <= 0 || edge.weight > 1)
+        if (!edge ||
+            typeof edge !== "object" ||
+            !nonEmptyString(edge.callerKey) ||
+            !nonEmptyString(edge.calleeKey) ||
+            !nonEmptyString(edge.callerFile) ||
+            !nonEmptyString(edge.calleeFile) ||
+            !nonEmptyString(edge.calleeSymbol) ||
+            typeof edge.weight !== "number" ||
+            !Number.isFinite(edge.weight) ||
+            edge.weight <= 0 ||
+            edge.weight > 1)
             return false;
         if (edge.callerSymbol !== undefined && !nonEmptyString(edge.callerSymbol))
             return false;
@@ -548,19 +694,27 @@ function validatePersistedCallGraph(raw, coverage) {
             return false;
         if (edge.calleeKind !== undefined && !nonEmptyString(edge.calleeKind))
             return false;
-        if (edge.evidenceKind !== undefined && !enumValue(edge.evidenceKind, edgeKinds))
+        if (edge.evidenceKind !== undefined &&
+            !enumValue(edge.evidenceKind, edgeKinds))
             return false;
-        if (edge.resolution !== undefined && !enumValue(edge.resolution, resolutions))
+        if (edge.resolution !== undefined &&
+            !enumValue(edge.resolution, resolutions))
             return false;
-        if (edge.evidenceCount !== undefined && (!finiteCount(edge.evidenceCount) || edge.evidenceCount < 1))
+        if (edge.evidenceCount !== undefined &&
+            (!finiteCount(edge.evidenceCount) || edge.evidenceCount < 1))
             return false;
         const evidenceCount = edge.evidenceCount ?? 1;
         const callerIdentity = parseCanonicalSymbolKey(edge.callerKey, edge.callerFile);
         const calleeIdentity = parseCanonicalSymbolKey(edge.calleeKey, edge.calleeFile);
-        if (normalizeMapKey(callerIdentity.filePath) !== normalizeMapKey(edge.callerFile) ||
-            normalizeMapKey(calleeIdentity.filePath) !== normalizeMapKey(edge.calleeFile) ||
-            (calleeIdentity.symbolName !== undefined && calleeIdentity.symbolName !== edge.calleeSymbol) ||
-            (callerIdentity.symbolName !== undefined && edge.callerSymbol !== undefined && callerIdentity.symbolName !== edge.callerSymbol))
+        if (normalizeMapKey(callerIdentity.filePath) !==
+            normalizeMapKey(edge.callerFile) ||
+            normalizeMapKey(calleeIdentity.filePath) !==
+                normalizeMapKey(edge.calleeFile) ||
+            (calleeIdentity.symbolName !== undefined &&
+                calleeIdentity.symbolName !== edge.calleeSymbol) ||
+            (callerIdentity.symbolName !== undefined &&
+                edge.callerSymbol !== undefined &&
+                callerIdentity.symbolName !== edge.callerSymbol))
             return false;
         const pair = `${edge.callerKey}\u0000${edge.calleeKey}`;
         if (pairKeys.has(pair))
@@ -583,7 +737,11 @@ function validatePersistedCallGraph(raw, coverage) {
         return false;
     if (!countsMatch(weightedDuplicateEvidence, coverage.duplicateEvidence))
         return false;
-    if (!countsMatch(coverage.totalEvidence, weightedEdgeEvidence + coverage.unresolvedEvidence + coverage.typeOnlyEvidence + coverage.unsupportedEvidence + coverage.sameFileEvidence))
+    if (!countsMatch(coverage.totalEvidence, weightedEdgeEvidence +
+        coverage.unresolvedEvidence +
+        coverage.typeOnlyEvidence +
+        coverage.unsupportedEvidence +
+        coverage.sameFileEvidence))
         return false;
     if (raw.totalRefs !== undefined && !finiteCount(raw.totalRefs))
         return false;
@@ -591,14 +749,18 @@ function validatePersistedCallGraph(raw, coverage) {
         return false;
     if (raw.totalRefs !== undefined && raw.totalRefs !== coverage.totalEvidence)
         return false;
-    if (raw.unresolvedRefs !== undefined && raw.unresolvedRefs !== coverage.unresolvedEvidence)
+    if (raw.unresolvedRefs !== undefined &&
+        raw.unresolvedRefs !== coverage.unresolvedEvidence)
         return false;
     const readAdjacency = (entries) => {
         const result = new Map();
         if (!Array.isArray(entries))
             return undefined;
         for (const entry of entries) {
-            if (!Array.isArray(entry) || !nonEmptyString(entry[0]) || !Array.isArray(entry[1]) || entry[1].some((key) => !nonEmptyString(key)))
+            if (!Array.isArray(entry) ||
+                !nonEmptyString(entry[0]) ||
+                !Array.isArray(entry[1]) ||
+                entry[1].some((key) => !nonEmptyString(key)))
                 return undefined;
             const keys = entry[1];
             if (new Set(keys).size !== keys.length || result.has(entry[0]))
@@ -609,21 +771,32 @@ function validatePersistedCallGraph(raw, coverage) {
     };
     const actualCallees = readAdjacency(raw.callees);
     const actualCallers = readAdjacency(raw.callers);
-    if (!actualCallees || !actualCallers || actualCallees.size !== expectedCallees.size || actualCallers.size !== expectedCallers.size)
+    if (!actualCallees ||
+        !actualCallers ||
+        actualCallees.size !== expectedCallees.size ||
+        actualCallers.size !== expectedCallers.size)
         return false;
     const sameSets = (actual, expected) => {
         for (const [key, values] of expected) {
             const got = actual.get(key);
-            if (!got || got.size !== values.size || [...values].some((value) => !got.has(value)))
+            if (!got ||
+                got.size !== values.size ||
+                [...values].some((value) => !got.has(value)))
                 return false;
         }
         return true;
     };
-    if (!sameSets(actualCallees, expectedCallees) || !sameSets(actualCallers, expectedCallers))
+    if (!sameSets(actualCallees, expectedCallees) ||
+        !sameSets(actualCallers, expectedCallers))
         return false;
     const actualInDegree = new Map();
     for (const entry of raw.inDegree) {
-        if (!Array.isArray(entry) || !nonEmptyString(entry[0]) || typeof entry[1] !== "number" || !Number.isFinite(entry[1]) || entry[1] < 0 || actualInDegree.has(entry[0]))
+        if (!Array.isArray(entry) ||
+            !nonEmptyString(entry[0]) ||
+            typeof entry[1] !== "number" ||
+            !Number.isFinite(entry[1]) ||
+            entry[1] < 0 ||
+            actualInDegree.has(entry[0]))
             return false;
         actualInDegree.set(entry[0], entry[1]);
     }
@@ -645,14 +818,16 @@ export function loadCallGraph(cwd, expectedIdentity) {
         const raw = JSON.parse(fs.readFileSync(cacheFile, "utf-8"));
         if (raw.version !== CALL_GRAPH_CACHE_VERSION)
             return undefined;
-        if (typeof raw.reviewGraphVersion !== "string" || typeof raw.reviewGraphSignature !== "string")
+        if (typeof raw.reviewGraphVersion !== "string" ||
+            typeof raw.reviewGraphSignature !== "string")
             return undefined;
         const identity = {
             reviewGraphVersion: raw.reviewGraphVersion,
             reviewGraphSignature: raw.reviewGraphSignature,
         };
-        if (expectedIdentity && (identity.reviewGraphVersion !== expectedIdentity.reviewGraphVersion ||
-            identity.reviewGraphSignature !== expectedIdentity.reviewGraphSignature))
+        if (expectedIdentity &&
+            (identity.reviewGraphVersion !== expectedIdentity.reviewGraphVersion ||
+                identity.reviewGraphSignature !== expectedIdentity.reviewGraphSignature))
             return undefined;
         const coverage = loadCoverage(raw.coverage, raw.edges);
         if (!validatePersistedCallGraph(raw, coverage))

package/node_modules/pi-lens/dist/clients/codebase-model.js

@@ -79,8 +79,10 @@ export function buildCodebaseModel(graph, cwd, budget = DEFAULT_CODEBASE_MODEL_T
         // carries that graph's identity rather than inventing a second freshness
         // policy.
         const fileRole = detectFileRole(filePath);
-        if (fileRole === "test" || fileRole === "generated" ||
-            isExternalOrVendorFile(filePath, cwd) || isBuildArtifact(filePath)) {
+        if (fileRole === "test" ||
+            fileRole === "generated" ||
+            isExternalOrVendorFile(filePath, cwd) ||
+            isBuildArtifact(filePath)) {
             continue;
         }
         // Deduplicate by name when the same function appears in multiple files
@@ -138,7 +140,11 @@ export function saveCodebaseModel(cwd, model) {
     try {
         fs.mkdirSync(path.dirname(cacheFile), { recursive: true });
         writeFileAtomic(cacheFile, JSON.stringify(model));
-        writeFileAtomic(metaFilePath(cwd), JSON.stringify({ savedAt: new Date().toISOString(), entryCount: model.entries.length, totalTokens: model.totalTokens }));
+        writeFileAtomic(metaFilePath(cwd), JSON.stringify({
+            savedAt: new Date().toISOString(),
+            entryCount: model.entries.length,
+            totalTokens: model.totalTokens,
+        }));
     }
     catch {
         // Non-fatal — next session rebuilds.
@@ -149,8 +155,10 @@ export function loadCodebaseModel(cwd, expectedIdentity) {
     try {
         const raw = JSON.parse(fs.readFileSync(cacheFilePath(cwd), "utf-8"));
         if (raw.version !== CODEBASE_MODEL_VERSION ||
-            typeof raw.reviewGraphVersion !== "string" || raw.reviewGraphVersion.length === 0 ||
-            typeof raw.reviewGraphSignature !== "string" || raw.reviewGraphSignature.length === 0 ||
+            typeof raw.reviewGraphVersion !== "string" ||
+            raw.reviewGraphVersion.length === 0 ||
+            typeof raw.reviewGraphSignature !== "string" ||
+            raw.reviewGraphSignature.length === 0 ||
             typeof raw.generatedAt !== "string" ||
             !Array.isArray(raw.entries))
             return undefined;

package/node_modules/pi-lens/dist/clients/complexity-client.js

@@ -371,9 +371,7 @@ function countSingleUseFunctions(functions) {
 export class ComplexityClient {
     log;
     constructor(verbose = false) {
-        this.log = verbose
-            ? createSubsystemLogger("complexity")
-            : () => { };
+        this.log = verbose ? createSubsystemLogger("complexity") : () => { };
     }
     /** True if the file's grammar has a complexity node mapping. */
     isSupportedFile(filePath) {

package/node_modules/pi-lens/dist/clients/dead-code-client.js

@@ -119,9 +119,7 @@ export class PythonDeadCodeClient {
     inFlight = new Map();
     log;
     constructor(verbose = false) {
-        this.log = verbose
-            ? createSubsystemLogger("dead-code:python")
-            : () => { };
+        this.log = verbose ? createSubsystemLogger("dead-code:python") : () => { };
     }
     get minConfidence() {
         const raw = Number.parseInt(process.env.PI_LENS_VULTURE_MIN_CONFIDENCE ?? "60", 10);
@@ -181,7 +179,10 @@ export class PythonDeadCodeClient {
                 path.join(".venv", "Scripts", "vulture.exe"),
                 path.join("venv", "Scripts", "vulture.exe"),
             ]
-            : [path.join(".venv", "bin", "vulture"), path.join("venv", "bin", "vulture")];
+            : [
+                path.join(".venv", "bin", "vulture"),
+                path.join("venv", "bin", "vulture"),
+            ];
         return relPaths
             .map((rel) => path.join(root, rel))
             .filter((full) => fs.existsSync(full))
@@ -312,9 +313,17 @@ export class PythonDeadCodeClient {
         const existing = this.inFlight.get(key);
         if (existing)
             return existing;
-        const promise = this.runAnalyze(key).finally(() => this.inFlight.delete(key));
-        this.inFlight.set(key, promise);
-        return promise;
+        const promise = this.runAnalyze(key);
+        const wrapped = promise.finally(() => {
+            // Identity-guarded release (#1968, #1967's pattern): delete only if
+            // THIS build is still the registered one. A bare delete-by-key lets
+            // a late-settling build A evict a live build B that replaced the
+            // entry mid-flight, and the next caller starts a duplicate.
+            if (this.inFlight.get(key) === wrapped)
+                this.inFlight.delete(key);
+        });
+        this.inFlight.set(key, wrapped);
+        return wrapped;
     }
     /**
      * True when `<root>/pyproject.toml` carries a `[tool.vulture]` table.
@@ -392,7 +401,9 @@ export class PythonDeadCodeClient {
                 });
                 return {
                     ...emptyResult(this.language),
-                    summary: stderr ? `vulture error: ${firstOutputLine(stderr)}` : reason,
+                    summary: stderr
+                        ? `vulture error: ${firstOutputLine(stderr)}`
+                        : reason,
                     durationMs,
                 };
             }

package/node_modules/pi-lens/dist/clients/dead-code-logger.js

@@ -12,8 +12,7 @@ import { createNdjsonLogger } from "./ndjson-logger.js";
 const LOG_DIR = getGlobalPiLensDir();
 const LOG_FILE = path.join(LOG_DIR, "dead-code.log");
 const LOG_BACKUP_FILE = path.join(LOG_DIR, "dead-code.log.1");
-const MAX_LOG_BYTES = Math.max(128 * 1024, Number.parseInt(process.env.PI_LENS_DEAD_CODE_LOG_MAX_BYTES ?? "1048576", 10) ||
-    1048576);
+const MAX_LOG_BYTES = Math.max(128 * 1024, Number.parseInt(process.env.PI_LENS_DEAD_CODE_LOG_MAX_BYTES ?? "1048576", 10) || 1048576);
 const writer = createNdjsonLogger({
     filePath: LOG_FILE,
     maxBytes: MAX_LOG_BYTES,

package/node_modules/pi-lens/dist/clients/deadline-utils.js

@@ -29,7 +29,9 @@ export function combineAbortSignals(...signals) {
             controller.abort(s.reason);
             break;
         }
-        s.addEventListener("abort", () => controller.abort(s.reason), { once: true });
+        s.addEventListener("abort", () => controller.abort(s.reason), {
+            once: true,
+        });
     }
     return controller.signal;
 }

package/node_modules/pi-lens/dist/clients/debug-heap.js

@@ -162,6 +162,13 @@ export function writeHeapSnapshotNow(label) {
     }
     const durationMs = Date.now() - start;
     pruneOldSnapshots(dir);
-    writer?.log({ ts, label, path: written, pid: process.pid, rssBytes, durationMs });
+    writer?.log({
+        ts,
+        label,
+        path: written,
+        pid: process.pid,
+        rssBytes,
+        durationMs,
+    });
     return { path: written, rssBytes, durationMs };
 }

package/node_modules/pi-lens/dist/clients/degradation-ledger.js

@@ -2,7 +2,7 @@
 import { logExtension } from "./extension-log.js";
 import { LEDGER_FIELD_MAX, truncateForLedger } from "./ledger-bounds.js";
 import { logLatency } from "./latency-logger.js";
-import { getSinkWriteFailures, resetSinkWriteFailures } from "./ndjson-logger.js";
+import { getSinkWriteFailures, resetSinkWriteFailures, } from "./ndjson-logger.js";
 // Re-exported so existing importers keep one name for the ledger's bound.
 export { LEDGER_FIELD_MAX, truncateForLedger };
 const ENTRIES_PER_KIND = 20;