@herbertgao/pi-extensions 2026.8.4 → 2026.8.5

package/node_modules/pi-lens/dist/clients/language-policy.js

@@ -56,11 +56,13 @@ export const LANGUAGE_POLICY = {
     lua: { lspCapable: true },
     zig: { lspCapable: true },
     haskell: { lspCapable: true },
+    "helm-template": { lspCapable: false },
     elixir: { lspCapable: true },
     gleam: { lspCapable: true },
     ocaml: { lspCapable: true },
     clojure: { lspCapable: true },
     terraform: { lspCapable: true },
+    terragrunt: { lspCapable: false },
     nix: { lspCapable: true },
     toml: { lspCapable: true, startup: { defaults: ["taplo"] } },
 };
@@ -117,7 +119,7 @@ const PRIMARY_DISPATCH_GROUPS = {
     },
     yaml: {
         mode: "all",
-        runnerIds: ["lsp", "yamllint", "trivy-config"],
+        runnerIds: ["lsp", "yamllint", "trivy-config", "helm-lint"],
         filterKinds: ["yaml"],
     },
     sql: {
@@ -179,6 +181,11 @@ const PRIMARY_DISPATCH_GROUPS = {
     lua: { mode: "fallback", runnerIds: ["lsp"], filterKinds: ["lua"] },
     zig: { mode: "all", runnerIds: ["lsp", "zig-check"], filterKinds: ["zig"] },
     haskell: { mode: "fallback", runnerIds: ["lsp"], filterKinds: ["haskell"] },
+    "helm-template": {
+        mode: "all",
+        runnerIds: ["helm-lint"],
+        filterKinds: ["helm-template"],
+    },
     elixir: {
         mode: "all",
         runnerIds: ["lsp", "elixir-check", "credo"],
@@ -193,9 +200,14 @@ const PRIMARY_DISPATCH_GROUPS = {
     clojure: { mode: "fallback", runnerIds: ["lsp"], filterKinds: ["clojure"] },
     terraform: {
         mode: "all",
-        runnerIds: ["lsp", "tflint"],
+        runnerIds: ["lsp", "tflint", "trivy-config"],
         filterKinds: ["terraform"],
     },
+    terragrunt: {
+        mode: "all",
+        runnerIds: ["terragrunt"],
+        filterKinds: ["terragrunt"],
+    },
     nix: { mode: "fallback", runnerIds: ["lsp"], filterKinds: ["nix"] },
     toml: {
         mode: "all",

package/node_modules/pi-lens/dist/clients/language-profile.js

@@ -1,12 +1,13 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { CODE_KINDS, detectFileKind, DOTNET_CSHARP_ROOT_MARKERS, DOTNET_FSHARP_ROOT_MARKERS, KIND_EXTENSIONS, } from "./file-kinds.js";
+import { CODE_KINDS, detectFileKind, DOTNET_CSHARP_ROOT_MARKERS, DOTNET_FSHARP_ROOT_MARKERS, KIND_EXTENSIONS, TERRAGRUNT_FILENAMES, } from "./file-kinds.js";
 import { getProjectIgnoreMatcher } from "./file-utils.js";
-import { direntsHaveMarkerGlobMatch } from "./path-utils.js";
+import { direntsHaveMarkerGlobMatch, normalizeMapKey } from "./path-utils.js";
 import { LANGUAGE_POLICY, } from "./language-policy.js";
 import { getSourceFiles } from "./scan-utils.js";
 import { readDirEntriesSafe, shouldRecurseIntoDir } from "./source-walker.js";
 import { findNearestDirWithAnyBasename } from "./workspace-topology.js";
+import { BoundedLruCache } from "./bounded-cache.js";
 /** Every registered kind participates in project-language detection (#894). */
 export const SUPPORTED_FILE_KINDS = Object.keys(KIND_EXTENSIONS);
 const PROJECT_MARKERS_BY_KIND = {
@@ -36,6 +37,7 @@ const PROJECT_MARKERS_BY_KIND = {
     elixir: ["mix.exs"],
     gleam: ["gleam.toml"],
     terraform: [".terraform.lock.hcl"],
+    terragrunt: TERRAGRUNT_FILENAMES,
     nix: ["flake.nix"],
     toml: ["pyproject.toml", "Cargo.toml", "taplo.toml"],
     csharp: DOTNET_CSHARP_ROOT_MARKERS,
@@ -80,6 +82,7 @@ const ROOT_MARKERS_BY_KIND = {
     elixir: ["mix.exs"],
     gleam: ["gleam.toml"],
     terraform: [".terraform.lock.hcl"],
+    terragrunt: TERRAGRUNT_FILENAMES,
     nix: ["flake.nix"],
     toml: ["pyproject.toml", "Cargo.toml", "taplo.toml"],
     csharp: DOTNET_CSHARP_ROOT_MARKERS,
@@ -101,16 +104,16 @@ function hasProjectMarker(projectRoot, marker) {
 // must not pollute the no-arg cache. The synchronous getSourceFiles() call
 // inside this function does the same expensive ignoreMatcher-driven walk
 // as resolveStartupScanContext, so the same memo strategy applies.
-const languageProfileCache = new Map();
+const languageProfileCache = new BoundedLruCache(32);
 export function detectProjectLanguageProfile(projectRoot, sourceFiles) {
     if (sourceFiles === undefined) {
-        const cached = languageProfileCache.get(projectRoot);
+        const cached = languageProfileCache.get(normalizeMapKey(projectRoot));
         if (cached)
             return cached;
     }
     const result = computeProjectLanguageProfile(projectRoot, sourceFiles);
     if (sourceFiles === undefined) {
-        languageProfileCache.set(projectRoot, result);
+        languageProfileCache.set(normalizeMapKey(projectRoot), result);
     }
     return result;
 }
@@ -297,6 +300,9 @@ export async function collectSourceFilesForWarmup(rootDir, maxFiles = MAX_WARMUP
                     break walk;
                 }
             }
+            // Each iteration performs only bounded dirent/ext/ignore checks. Keep the
+            // count cadence: the cost does not scale with the corpus item size, and
+            // this walk's existing matched-file ceiling bounds the total work.
             if (++processedSinceYield % yieldEvery === 0) {
                 // See countSourceFilesWithinLimitAsync for why setImmediate.
                 await new Promise((resolve) => setImmediate(resolve));
@@ -306,7 +312,7 @@ export async function collectSourceFilesForWarmup(rootDir, maxFiles = MAX_WARMUP
     return [...codeOut, ...nonCodeOut];
 }
 export async function detectProjectLanguageProfileAsync(projectRoot) {
-    const cached = languageProfileCache.get(projectRoot);
+    const cached = languageProfileCache.get(normalizeMapKey(projectRoot));
     if (cached)
         return cached;
     const files = await collectSourceFilesForWarmup(projectRoot);
@@ -315,6 +321,6 @@ export async function detectProjectLanguageProfileAsync(projectRoot) {
     // probe (`existsSync` for package.json / pyproject.toml / etc.) which
     // is constant-time and cheap.
     const result = detectProjectLanguageProfile(projectRoot, files);
-    languageProfileCache.set(projectRoot, result);
+    languageProfileCache.set(normalizeMapKey(projectRoot), result);
     return result;
 }

package/node_modules/pi-lens/dist/clients/latency-logger.js

@@ -9,11 +9,33 @@ const writer = createNdjsonLogger({
     filePath: LATENCY_LOG_FILE,
     maxBytes: getMaxLogSizeMB() * 1024 * 1024,
 });
+/**
+ * Most recent non-`loop_block` phase seen by `logLatency`, for cheap block
+ * attribution (#1122 / #1123 item 1): the event-loop-block probe fires at
+ * turn_end and cannot see *what* stalled the loop, so it stamps the last phase
+ * that ran as a starting point for root-causing a genuine block. Tracked before
+ * the test-mode guard so it is deterministic and unit-testable.
+ */
+let lastPhase;
+/**
+ * The last non-`loop_block` phase logged, or undefined if none yet. Carries its
+ * own `ts` so a consumer can gauge staleness: it is intentionally NOT cleared at
+ * turn/window boundaries, so on a turn that logged no phase of its own it may
+ * point at a prior turn's phase — compare `ts` against the block time before
+ * trusting it as the cause (it is a breadcrumb, not proof).
+ */
+export function getLastLoggedPhase() {
+    return lastPhase;
+}
 export function logLatency(entry) {
+    const ts = new Date().toISOString();
+    if (entry.type === "phase" && entry.phase && entry.phase !== "loop_block") {
+        lastPhase = { phase: entry.phase, ts };
+    }
     if (isTestMode()) {
         return;
     }
-    writer.log({ ...entry, ts: new Date().toISOString(), pid: process.pid });
+    writer.log({ ...entry, ts, pid: process.pid });
 }
 export function getLatencyLogPath() {
     return LATENCY_LOG_FILE;

package/node_modules/pi-lens/dist/clients/lens-config.js

@@ -1,3 +1,5 @@
+import { logExtension } from "./extension-log.js";
+import { notifyUserDegradation } from "./user-notify.js";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
@@ -20,7 +22,16 @@ function warnInvalidGlobalConfigOnce(configPath, reason) {
     if (warnedInvalidGlobalConfigs.has(key))
         return;
     warnedInvalidGlobalConfigs.add(key);
-    console.error(`[pi-lens] ignoring invalid global config ${configPath}: ${reason}`);
+    const message = `ignoring invalid global config ${configPath}: ${reason}`;
+    logExtension({
+        subsystem: "lens-config",
+        level: "warn",
+        message,
+        metadata: { configPath, reason },
+    });
+    // HUMAN-audience too: a config the user wrote is being ignored. Routed
+    // through the host's own render path (#1333), never a raw write.
+    notifyUserDegradation(`pi-lens: ${message}`);
 }
 /** For tests that need to force the warn-once cache to reset between cases. */
 export function resetGlobalConfigWarnCache() {

package/node_modules/pi-lens/dist/clients/lens-engine.js

@@ -13,27 +13,28 @@
  * adds thin wrappers over the remaining internal reach-ins (latency, project
  * scan, LSP status, diagnostic stats, LSP config).
  */
+import * as path from "node:path";
+import { minimatch } from "./deps/minimatch.js";
 import { getDiagnosticTracker } from "./diagnostic-tracker.js";
 import { getLatencyReports, } from "./dispatch/integration.js";
 import { getResourceFootprint as getResourceFootprintSnapshot, } from "./instance-registry.js";
 import { initLSPConfig } from "./lsp/config.js";
 import { getLSPService } from "./lsp/index.js";
-import { getOrLoadWarmWordIndex } from "./mcp/analyze.js";
+import { acquireWarmWordIndex } from "./mcp/analyze.js";
+import { normalizeMapKey } from "./path-utils.js";
 import { scanProjectDiagnostics } from "./project-diagnostics/scanner.js";
+import { loadProjectSnapshotWithoutWordIndex } from "./project-snapshot.js";
 import { getTreeSitterRuntimeStatus, } from "./tree-sitter-shared.js";
-import * as path from "node:path";
-import { minimatch } from "./deps/minimatch.js";
-import { normalizeMapKey } from "./path-utils.js";
-import { loadProjectSnapshot } from "./project-snapshot.js";
-import { centralityFromReverseDeps, deserializeWordIndex, getWordIndexBuildStatus, searchWordIndex, triggerBackgroundWordIndexBuild, } from "./word-index.js";
+import { centralityFromReverseDeps, getWordIndexBuildStatus, searchWordIndex, triggerBackgroundWordIndexBuild, } from "./word-index.js";
 // --- Facades (re-exported so adapters import only this module) ---------------
 export { analyzeFile, } from "./mcp/analyze.js";
 export { createMcpHost } from "./mcp/host-shim.js";
-export { ipcPathForCwd, requestWarmAnalyze, } from "./mcp/ipc.js";
+export { createWarmIpcLineReader, createWarmIpcRequestQueue, ipcPathForCwd, readTurnEndStatus, requestWarmAnalyze, WARM_TURN_END_SCHEMA_VERSION, } from "./mcp/ipc.js";
 export { analyzeFileFresh, canRebuildPiLens, REBUILD_UNAVAILABLE_MESSAGE, resolveRebuildScript, runRebuild, summarizeScan, } from "./mcp/review.js";
-export { runSessionStart, runTurnEnd, } from "./mcp/session.js";
+export { acknowledgeTurnEnd, runSessionStart, runTurnEnd, runTurnEndForIpc, } from "./mcp/session.js";
 export { moduleReport, readEnclosing, readSymbol, renderCompactModuleReport, } from "./module-report.js";
 export { projectReport, renderCompactProjectReport, } from "./project-report.js";
+export { createDefaultHostPorts, } from "./host-ports.js";
 // --- Query wrappers (own the remaining internal reach-ins) -------------------
 /** Recent dispatch latency reports (latency.log schema), newest first. */
 export function recentLatency(limit = 5, fileFilter) {
@@ -44,9 +45,21 @@ export function recentLatency(limit = 5, fileFilter) {
     }
     return reports.slice(-limit).reverse();
 }
-/** Cheap project-wide scan (tree-sitter + fact rules). */
-export function projectScan(cwd, maxFiles) {
-    return scanProjectDiagnostics({ cwd, tier: "cheap", maxFiles });
+/**
+ * Cheap project-wide scan (tree-sitter + fact rules).
+ *
+ * `includeGenerated` (#1107 phase 2 review): scan WITHOUT the generated/
+ * artifact NAME-heuristic filter — the actionable opt-out
+ * `generatedSkipNotice` below points a user at. Default `false` (existing
+ * filtering behavior unchanged).
+ */
+export function projectScan(cwd, maxFiles, includeGenerated) {
+    return scanProjectDiagnostics({
+        cwd,
+        tier: "cheap",
+        maxFiles,
+        includeGenerated,
+    });
 }
 /**
  * #784: `scanTruncated` (#760) reaches this seam intact but, until now, no
@@ -66,6 +79,53 @@ export function scanTruncationNotice(snapshot) {
     return (`⚠ Scan truncated at ${snapshot.filesScanned} file(s) — results are partial; ` +
         "raise maxProjectFiles in .pi-lens.json to scan fully.");
 }
+/**
+ * #1107 phase 2: `generatedNameOnlySkips`/`generatedDirSkips` reach this seam
+ * via `ProjectDiagnosticsSnapshot` but need explicit rendering, same pattern
+ * as `scanTruncationNotice` above — otherwise a user has no way to learn the
+ * generated-name heuristic silently excluded files/directories short of
+ * reading `latency.log`'s `source_walk_skip_summary` line directly.
+ *
+ * #1107 phase 2 review round 2 (P1, empirically proven): this deliberately
+ * keys off `generatedNameOnlySkips`, NOT the raw `generatedFileSkips` total.
+ * `generatedFileSkips` counts every file the generated/artifact heuristic
+ * skipped, including STRONG evidence (lockfiles, declaration files, minified/
+ * bundle/chunk output — expected on nearly every real repo) and
+ * content-CONFIRMED WEAK matches (the escape hatch checked and a genuine
+ * generated-code header was present). Keying the notice off that total meant
+ * a repo with nothing more unusual than a `package-lock.json` and an ambient
+ * `.d.ts` showed "2 file(s) excluded" on literally every scan forever — the
+ * signal drowned itself on day one. `generatedNameOnlySkips` is the narrower,
+ * genuinely at-risk residual: a WEAK name match trusted with NO corroborating
+ * evidence check at all (only reachable when a caller opts out of the header
+ * probe — source-filter.ts's default project-walk path always enables it).
+ * Post-escape-hatch, this should be rare-to-zero on the default path, which
+ * is exactly what makes the notice meaningful again when it DOES fire.
+ * `generatedDirSkips` stays in the trigger condition unchanged: directory-
+ * level pruning has no escape hatch at all (the walk never enumerates a
+ * pruned directory's contents to check them), so it is always a genuine
+ * "real files may be hiding in here, unverified" signal, not a
+ * false-positive-prone one — see `generatedDirSkips`'s doc on
+ * `SourceCollectionResult`.
+ *
+ * Returns `undefined` when neither counter is set (nothing to append).
+ */
+export function generatedSkipNotice(snapshot) {
+    const files = snapshot.generatedNameOnlySkips ?? 0;
+    const dirs = snapshot.generatedDirSkips ?? 0;
+    if (files === 0 && dirs === 0)
+        return undefined;
+    const parts = [];
+    if (files > 0)
+        parts.push(`${files} file(s)`);
+    if (dirs > 0)
+        parts.push(`${dirs} director${dirs === 1 ? "y" : "ies"}`);
+    return (`ℹ ${parts.join(" and ")} excluded by generated-name heuristics with no ` +
+        "confirming evidence — a real hand-written file/directory whose name " +
+        "looks generated (e.g. `gen.ts`, `generated/`) can be excluded too; " +
+        "pass includeGenerated: true to pilens_project_scan / lens_diagnostics " +
+        "to scan without this filter if you suspect a false skip.");
+}
 /** Process-wide tree-sitter health for host status surfaces. */
 export function treeSitterRuntimeStatus() {
     return getTreeSitterRuntimeStatus();
@@ -213,7 +273,7 @@ function toSymbolSearchHit(result) {
  * cwd, never blocking this call) so a retry shortly after succeeds (#348
  * decision 3).
  *
- * #536 rider: prefers the warm in-memory index (`getOrLoadWarmWordIndex`,
+ * #536 rider: prefers the warm in-memory index (`acquireWarmWordIndex`,
  * clients/mcp/analyze.ts) over a fresh disk read when one exists for this
  * cwd — a warm `pilens_analyze` call updates that live copy synchronously but
  * persists it to disk on a debounce (default 1500ms), so without this a query
@@ -239,9 +299,11 @@ function toSymbolSearchHit(result) {
  * nothing on this hot path.
  */
 export async function symbolSearch(query, cwd, limit = 20, options = {}) {
-    const snapshot = loadProjectSnapshot(cwd);
-    const index = getOrLoadWarmWordIndex(cwd) ?? deserializeWordIndex(snapshot?.wordIndex);
+    const warmLease = acquireWarmWordIndex(cwd);
+    const snapshot = loadProjectSnapshotWithoutWordIndex(cwd);
+    const index = warmLease.index;
     if (!index) {
+        warmLease.release();
         const priorStatus = getWordIndexBuildStatus(cwd);
         const status = priorStatus?.state === "refused"
             ? priorStatus
@@ -266,9 +328,16 @@ export async function symbolSearch(query, cwd, limit = 20, options = {}) {
     }
     // Boost well-connected files using the snapshot's reverse-dependency
     // (importedBy) counts; snapshot keys are normalized, index keys are raw.
-    const centrality = centralityFromReverseDeps(index, snapshot?.reverseDeps, (file) => normalizeMapKey(path.resolve(file)));
-    const fileFilter = buildSymbolSearchFileFilter(cwd, options);
-    const results = searchWordIndex(index, query, { limit, centrality, fileFilter });
+    let centrality;
+    let results;
+    try {
+        centrality = centralityFromReverseDeps(index, snapshot?.reverseDeps, (file) => normalizeMapKey(path.resolve(file)));
+        const fileFilter = buildSymbolSearchFileFilter(cwd, options);
+        results = searchWordIndex(index, query, { limit, centrality, fileFilter });
+    }
+    finally {
+        warmLease.release();
+    }
     const hits = results.map(toSymbolSearchHit);
     const { getCachedReviewGraph } = await import("./review-graph/builder.js");
     const graph = getCachedReviewGraph(cwd);

package/node_modules/pi-lens/dist/clients/lens-events.js

@@ -1,3 +1,4 @@
+import { logExtension } from "./extension-log.js";
 export const LENS_EVENT_VERSION = 1;
 export const LENS_EVENT_NAMES = {
     analysisComplete: "pi-lens/analysis-complete",
@@ -5,8 +6,15 @@ export const LENS_EVENT_NAMES = {
     turnFindings: "pi-lens/turn-findings",
 };
 let lensEventBus;
+let lensEventBusGetter;
 export function initLensEvents(pi) {
     lensEventBus = pi.events;
+    lensEventBusGetter = undefined;
+}
+/** Keep deferred deliveries on the live extension activation. */
+export function initLensEventsGetter(getter) {
+    lensEventBusGetter = getter;
+    lensEventBus = undefined;
 }
 function truncateText(value, maxChars) {
     if (value === undefined)
@@ -26,13 +34,28 @@ function normalizeDiagnostic(diagnostic) {
 function normalizeDiagnostics(diagnostics) {
     return diagnostics.map(normalizeDiagnostic);
 }
+// Dropped-emit observability (#1128 review): drops are legitimate (no bus
+// during startup/replacement windows) but must not be invisible. One line per
+// process — enough to notice a permanently-missing bus without spamming.
+let _droppedEmitLogged = false;
 function emitLensEvent(eventName, payload) {
-    const emit = lensEventBus?.emit;
-    if (!emit)
-        return;
     setImmediate(() => {
         try {
-            emit.call(lensEventBus, eventName, payload);
+            const bus = lensEventBusGetter?.() ?? lensEventBus;
+            const emit = bus?.emit;
+            if (!emit) {
+                if (!_droppedEmitLogged) {
+                    _droppedEmitLogged = true;
+                    logExtension({
+                        subsystem: "lens-events",
+                        level: "warn",
+                        message: `lens event dropped (no live bus): ${eventName} — further drops logged once per process`,
+                        metadata: { eventName },
+                    });
+                }
+                return;
+            }
+            emit.call(bus, eventName, payload);
         }
         catch {
             // Inter-extension events are observational. A listener must never break

package/node_modules/pi-lens/dist/clients/lens-flag-registry.js

@@ -156,6 +156,14 @@ export const LENS_FLAGS = [
         default: false,
         scope: "global",
     },
+    {
+        name: "lens-compact-tool-line",
+        description: "Opt-in (#1327): collapse a pi-lens tool's call+result rows into ONE theme-aware line (status glyph + name + summary) instead of two. Preserves expand-to-view-full-output. Default off. Also via ui.compactToolLine=true in ~/.pi-lens/config.json.",
+        configKey: "ui.compactToolLine",
+        negated: false,
+        default: false,
+        scope: "global",
+    },
 ];
 const byName = new Map(LENS_FLAGS.map((spec) => [spec.name, spec]));
 export function getLensFlagSpec(name) {

package/node_modules/pi-lens/dist/clients/lens-map.js

@@ -21,6 +21,7 @@ import { FactStore } from "./dispatch/fact-store.js";
 import { getProjectDataDir } from "./file-utils.js";
 import { collectUntrackedIgnoredIds } from "./git-tracked-ignore.js";
 import { normalizeMapKey, toProjectRelativePath } from "./path-utils.js";
+import { canonicalSourceTwin } from "./source-filter.js";
 import { buildOrUpdateGraph } from "./review-graph/service.js";
 import { detectFileRole } from "./file-role.js";
 export const DEFAULT_MAX_MAP_NODES = 500;
@@ -92,11 +93,10 @@ export function aggregateGraphToFiles(graph, options) {
     // import edges). Deterministic sibling families: .js → .ts (preferred)
     // then .tsx; .mjs → .mts; .cjs → .cts. A compiled-looking file with no
     // source twin (vendored deps, pure-JS projects) is untouched.
-    const COMPILED_TWIN_SOURCES = [
-        [".js", [".ts", ".tsx"]],
-        [".mjs", [".mts"]],
-        [".cjs", [".cts"]],
-    ];
+    // Keep this pure aggregation layer on the shared source-filter policy. It
+    // cannot call findSourceSibling because synthetic graph fixtures and cached
+    // nodes are not required to exist on disk.
+    const compiledExtensions = new Set([".js", ".jsx", ".mjs", ".cjs"]);
     // Interplay with the untracked-gitignored exclusion (`excludeIds`):
     // twin canonicalization takes PRECEDENCE over exclusion. An excluded
     // compiled file whose source twin survives is merged onto that twin
@@ -109,19 +109,11 @@ export function aggregateGraphToFiles(graph, options) {
     const excludeIds = options?.excludeIds;
     const canonicalOf = new Map();
     for (const id of allFileIds) {
-        for (const [compiledExt, sourceExts] of COMPILED_TWIN_SOURCES) {
-            if (!id.endsWith(compiledExt))
-                continue;
-            const stem = id.slice(0, id.length - compiledExt.length);
-            for (const sourceExt of sourceExts) {
-                const candidate = stem + sourceExt;
-                if (allFileIds.has(candidate) && !excludeIds?.has(candidate)) {
-                    canonicalOf.set(id, candidate);
-                    break;
-                }
-            }
-            break;
-        }
+        if (!compiledExtensions.has(path.extname(id).toLowerCase()))
+            continue;
+        const canonical = canonicalSourceTwin(id, allFileIds, excludeIds);
+        if (canonical !== id)
+            canonicalOf.set(id, canonical);
     }
     const compiledTwinCount = canonicalOf.size;
     // Excluded ids that actually drop: in the graph, untracked-gitignored,
@@ -137,6 +129,77 @@ export function aggregateGraphToFiles(graph, options) {
         }
     }
     const ignoredFileCount = droppedIgnoredIds.size;
+    // Build logical symbol identities before counting symbols or edges. A compiled
+    // twin can carry the same declaration and edge evidence as its source; those
+    // are one logical observation after canonicalization. Match source declarations
+    // in stable insertion order so overloads with the same name/kind stay distinct.
+    const logicalSymbolByNode = new Map();
+    const sourceSymbolsByFile = new Map();
+    // A symbol kind is not stable across extractor surfaces: a declaration can
+    // be a `function` in a JS/TS fact and a `variable` in a compiled twin's
+    // syntax extraction. Keep a name-only index for the safe case where there is
+    // exactly one source declaration with that name; this prevents equivalent
+    // twins from inflating the preferred source while preserving overloads and
+    // genuinely ambiguous same-name declarations.
+    const sourceSymbolsByName = new Map();
+    for (const node of graph.nodes.values()) {
+        if (node.kind !== "symbol" || !node.filePath || !node.symbolName)
+            continue;
+        const raw = normalizeMapKey(node.filePath);
+        const canonical = canonicalOf.get(raw) ?? raw;
+        if (raw !== canonical)
+            continue;
+        const key = `${node.symbolName}\u0000${node.symbolKind ?? ""}`;
+        const byName = sourceSymbolsByFile.get(canonical) ?? new Map();
+        const ids = byName.get(key) ?? [];
+        ids.push(node.id);
+        byName.set(key, ids);
+        sourceSymbolsByFile.set(canonical, byName);
+        const bySymbolName = sourceSymbolsByName.get(canonical) ?? new Map();
+        const nameIds = bySymbolName.get(node.symbolName) ?? [];
+        nameIds.push(node.id);
+        bySymbolName.set(node.symbolName, nameIds);
+        sourceSymbolsByName.set(canonical, bySymbolName);
+        logicalSymbolByNode.set(node.id, node.id);
+    }
+    // Assign each twin's declarations by occurrence within THAT twin file, not
+    // through one process-wide "used" set. A source can have several compiled
+    // siblings (`x.ts`, `x.js`, `x.mjs`, ...); every sibling's first `run` must
+    // map to the source's first `run`, while overloads with the same name/kind
+    // remain distinct by occurrence.
+    const twinOccurrencesByFile = new Map();
+    for (const node of graph.nodes.values()) {
+        if (node.kind !== "symbol" || !node.filePath || !node.symbolName)
+            continue;
+        const raw = normalizeMapKey(node.filePath);
+        const canonical = canonicalOf.get(raw) ?? raw;
+        if (raw === canonical)
+            continue;
+        const key = `${node.symbolName}\u0000${node.symbolKind ?? ""}`;
+        const exactSourceIds = sourceSymbolsByFile.get(canonical)?.get(key) ?? [];
+        const nameSourceIds = sourceSymbolsByName.get(canonical)?.get(node.symbolName) ?? [];
+        // Prefer the kind-qualified mapping. Fall back only when the source name
+        // is unique; never guess among overloads or same-name declarations.
+        const sourceIds = exactSourceIds.length > 0
+            ? exactSourceIds
+            : nameSourceIds.length === 1
+                ? nameSourceIds
+                : [];
+        const occurrenceKey = exactSourceIds.length > 0 ? key : node.symbolName;
+        const occurrences = twinOccurrencesByFile.get(raw) ?? new Map();
+        const occurrence = occurrences.get(occurrenceKey) ?? 0;
+        occurrences.set(occurrenceKey, occurrence + 1);
+        twinOccurrencesByFile.set(raw, occurrences);
+        const logical = sourceIds[occurrence];
+        if (logical) {
+            logicalSymbolByNode.set(node.id, logical);
+        }
+        else {
+            // A compiled-only declaration remains real evidence.
+            logicalSymbolByNode.set(node.id, node.id);
+        }
+    }
+    const countedLogicalSymbols = new Set();
     // ── Pass 3: aggregate nodes under their canonical file identity ─────────
     for (const node of graph.nodes.values()) {
         if (node.kind === "external")
@@ -173,9 +236,13 @@ export function aggregateGraphToFiles(graph, options) {
                 continue;
             const id = canonicalOf.get(raw) ?? raw;
             nodeToFile.set(node.id, id);
+            const logicalId = logicalSymbolByNode.get(node.id) ?? node.id;
             const existing = files.get(id);
             if (existing) {
-                existing.symbolCount += 1;
+                if (!countedLogicalSymbols.has(logicalId)) {
+                    existing.symbolCount += 1;
+                    countedLogicalSymbols.add(logicalId);
+                }
             }
             else {
                 files.set(id, {
@@ -184,6 +251,7 @@ export function aggregateGraphToFiles(graph, options) {
                     language: node.language || "",
                     symbolCount: 1,
                 });
+                countedLogicalSymbols.add(logicalId);
             }
             continue;
         }
@@ -197,11 +265,18 @@ export function aggregateGraphToFiles(graph, options) {
     // becomes self-referential only AFTER canonicalization (e.g. x.js → x.ts)
     // collapses through the same fromFile === toFile check.
     const edgeWeights = new Map();
+    const seenLogicalEdges = new Set();
     for (const edge of graph.edges) {
         const fromFile = nodeToFile.get(edge.from);
         const toFile = nodeToFile.get(edge.to);
         if (!fromFile || !toFile || fromFile === toFile)
             continue;
+        const logicalFrom = logicalSymbolByNode.get(edge.from) ?? fromFile;
+        const logicalTo = logicalSymbolByNode.get(edge.to) ?? toFile;
+        const logicalEdgeKey = `${logicalFrom}\u0000${logicalTo}\u0000${edge.kind}`;
+        if (seenLogicalEdges.has(logicalEdgeKey))
+            continue;
+        seenLogicalEdges.add(logicalEdgeKey);
         // NUL separator (same idiom as review-graph/builder.ts): the one byte
         // that can never appear in a file path, written as an escape sequence so
         // this source file stays text for grep (a literal NUL makes ripgrep

package/node_modules/pi-lens/dist/clients/live-bus-emitter.js

@@ -0,0 +1,30 @@
+import { recordDegradation } from "./degradation-ledger.js";
+const STALE_CTX_MESSAGE = "This extension ctx is stale after session replacement";
+/** Ledger a dead activation once, at the publisher's occurrence-window guard. */
+export function recordStaleBusFailure(subject, error) {
+    const reason = String(error);
+    if (!reason.includes(STALE_CTX_MESSAGE))
+        return;
+    recordDegradation({ kind: "bus-stale", subject, reason });
+}
+export function createLiveBusEmitter() {
+    let emit;
+    let getter;
+    return {
+        wire(next) {
+            emit = next;
+            getter = undefined;
+        },
+        wireGetter(next) {
+            getter = next;
+            emit = undefined;
+        },
+        get() {
+            return getter?.() ?? emit;
+        },
+        reset() {
+            emit = undefined;
+            getter = undefined;
+        },
+    };
+}

package/node_modules/pi-lens/dist/clients/log-cleanup.js

@@ -24,6 +24,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { getGlobalPiLensDir } from "./file-utils.js";
 import { getRegisteredLogFiles } from "./ndjson-logger.js";
+import { pathsEqual } from "./path-utils.js";
 const LOG_DIR = getGlobalPiLensDir();
 const LOGS_SUBDIR = path.join(LOG_DIR, "logs");
 /**
@@ -52,7 +53,7 @@ const LOGS_SUBDIR = path.join(LOG_DIR, "logs");
 export function getManagedLogFiles(dir = LOG_DIR) {
     const names = new Set();
     for (const absPath of getRegisteredLogFiles()) {
-        if (path.dirname(absPath) === dir) {
+        if (pathsEqual(path.dirname(absPath), dir)) {
             names.add(path.basename(absPath));
         }
     }

package/node_modules/pi-lens/dist/clients/lsp/cascade-tier.js

@@ -26,7 +26,7 @@
  * snapshot's `workspaceDiagnosticsSupport.mode` (from
  * `detectWorkspaceDiagnosticsSupport`, cached at `initialize`) and combines it
  * with the `silentOnClean` marker on that server's `DiagnosticStrategy`
- * (`server-strategies.ts`) — the same per-server behavioral-knowledge table
+ * (`wait-policy/strategies.ts`) — the same per-server behavioral-knowledge table
  * the rest of the LSP layer already uses. A server with no live snapshot yet,
  * or whose mode isn't `push-only`, or that isn't marked `silentOnClean`, is
  * NOT tier-3 — the caller keeps today's full in-lane wait. Fail-safe is