@herbertgao/pi-extensions 2026.8.4 → 2026.8.6

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

@@ -156,6 +156,22 @@ 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",
+    },
+    {
+        name: "no-lazy-tools",
+        description: "Keep all pi-lens tools active to avoid tool-list cache changes. Also via tools.lazy=false in ~/.pi-lens/config.json.",
+        configKey: "tools.lazy",
+        negated: true,
+        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,73 @@
+import { recordDegradation } from "./degradation-ledger.js";
+import { probeCtxActive } from "./session-lifecycle.js";
+import { logBusEvent, } from "./bus-events-logger.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;
+        },
+        resolve() {
+            // Invoke the getter for every delivery so session_start rewiring can
+            // replace a captured pre-await activation with the current primary. When
+            // the current target is nevertheless confirmed stale, never invoke it.
+            const target = getter?.() ?? emit;
+            if (!target)
+                return { outcome: "unwired", ctxSource: "unwired" };
+            if (typeof target === "function") {
+                return { outcome: "ready", emit: target, ctxSource: "global-fallback" };
+            }
+            // Object targets are always "own"-sourced (only `wire(fn)`'s bare
+            // function arm is "global-fallback", and it never reaches this
+            // branch) — compute it once so the ready/stale-session outcomes
+            // below both carry the same value instead of restating the
+            // literal independently.
+            const ctxSource = "own";
+            if (probeCtxActive(target.ctx) === false) {
+                return { outcome: "stale-session", ctxSource };
+            }
+            return { outcome: "ready", emit: target.emit, ctxSource };
+        },
+        reset() {
+            emit = undefined;
+            getter = undefined;
+        },
+    };
+}
+/**
+ * Resolve through the shared stale-session guard and record a declined
+ * target.
+ *
+ * `entry` is a THUNK, not a value (M1, #1415 review): building the log entry
+ * (every producer's version normalizes `cwd` via `normalizeFilePath`, a sync
+ * `realpathSync.native` call on Windows) is real per-publish cost that used
+ * to be paid on EVERY call regardless of outcome, even though it is only
+ * consumed on the `stale-session` branch. Invoking the thunk only there means
+ * the common `ready` path pays nothing for it.
+ */
+export function resolveLiveBusEmitter(liveEmitter, entry) {
+    const resolution = liveEmitter.resolve();
+    if (resolution.outcome === "stale-session") {
+        logBusEvent({
+            ...entry(),
+            outcome: "skipped_stale_session",
+            level: "info",
+            ctxSource: resolution.ctxSource,
+        });
+    }
+    return resolution;
+}

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/aggregation.js

@@ -26,9 +26,12 @@
  *   receive `options.auxGraceMs` before the race finalises. Aux results within
  *   that window are included; later arrivals are dropped. When no descriptors
  *   carry `role:"auxiliary"` the aux-grace path is never entered.
- * @param options.auxGraceMs - Grace period given to auxiliary promises after all
- *   primary promises have settled. Only relevant when at least one descriptor
- *   carries `role:"auxiliary"`. Defaults to 500ms.
+ * @param options.auxGraceMs - Ceiling on the grace period given to auxiliary
+ *   promises after all primary promises have settled. Only relevant when at
+ *   least one descriptor carries `role:"auxiliary"`. Defaults to 500ms. When a
+ *   still-pending auxiliary's descriptor carries `budgetMs`, the actual window
+ *   is `min(auxGraceMs, max(budgetMs of still-pending auxiliaries))` — see
+ *   `PromiseDescriptor.budgetMs`.
  */
 export async function raceToCompletion(promises, shouldComplete, options = { timeoutMs: 1500 }) {
     const results = new Array(promises.length).fill(undefined);
@@ -76,7 +79,30 @@ export async function raceToCompletion(promises, shouldComplete, options = { tim
             if (auxGraceStarted || completed)
                 return;
             auxGraceStarted = true;
-            const graceMs = options.auxGraceMs ?? 500;
+            const ceilingMs = options.auxGraceMs ?? 500;
+            // #1458 S2: cap the grace window by the still-pending auxiliaries' own
+            // declared budgets, not just the flat ceiling — mirrors touchFile's
+            // per-server `min(declared, ceiling)`.
+            //
+            // This is ONE shared timer, not a deadline per promise, so it grants
+            // every pending auxiliary the window of its slowest pending sibling.
+            // That is safe here only because of an invariant the caller upholds,
+            // not because of anything this function enforces: every promise
+            // `getDiagnostics` passes in is already self-bounded by the same
+            // `strategy.aggregateWaitMs` it declares as `budgetMs`, so a fast
+            // auxiliary resolves on its own deadline long before a slow sibling's
+            // window expires. A caller that passes a promise NOT self-bounded by
+            // its descriptor's `budgetMs` — or one that outlives it, the way
+            // `expectSemanticSecondPush` extends a primary — would get a window
+            // wider than it declared. `PromiseDescriptor` is public, so treat that
+            // as a real constraint on new callers rather than a theoretical one.
+            const pendingAuxBudgets = [...auxIndices]
+                .filter((i) => results[i] === undefined)
+                .map((i) => descriptors[i]?.budgetMs)
+                .filter((b) => typeof b === "number" && b >= 0);
+            const graceMs = pendingAuxBudgets.length > 0
+                ? Math.min(ceilingMs, Math.max(...pendingAuxBudgets))
+                : ceilingMs;
             if (graceMs <= 0) {
                 finalize();
                 return;

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

@@ -26,12 +26,18 @@
  * 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
  * always "wait like before".
  *
+ * Native TS7 is the cascade-only exception. It is not silent on clean, but
+ * its publication does not settle inside the cold-snapshot budget. Cascade
+ * classifies it as `collect-later`, sends the same no-wait touch, and
+ * reconciles its later per-file push or pull publication. The shared server
+ * policy remains `waits`, so main-lane behavior does not change.
+ *
  * #524/#529/#541/#558: a server id can now be backed by more than one actual
  * binary — "typescript" is classic typescript-language-server OR TS7's
  * native `tsc --lsp --stdio` (PR #526). PR #526 originally routed the
@@ -46,9 +52,11 @@
  * confirmed still silent (`cleanPubs=0(v:0)`) in the same run. This is
  * therefore an EVIDENCE-BASED revert, not the original unverified caution:
  * native-ts7's clean-signal behavior IS known, and it is "publishes, not
- * silent". The snapshot's `launchVariant` marker again routes a native-ts7
- * snapshot through "waits" while the shared `silentOnClean` flag stays
- * `true` for classic. `scripts/probe-clean-signal.mjs`'s drift check no
+ * silent". The shared classifier still routes a native-ts7 snapshot through
+ * `waits`. The cascade-only wrapper routes it through `collect-later` because
+ * the measured publication arrives after the in-lane budget. The shared
+ * `silentOnClean` flag stays `true` for classic.
+ * `scripts/probe-clean-signal.mjs`'s drift check no
  * longer compares native-ts7 rows against the shared marker (it now expects
  * `false` for them explicitly) — see that file's header for the regression
  * watch this sets up for a future TS7 build that becomes silent again.
@@ -57,7 +65,32 @@ import { logCascade } from "../cascade-logger.js";
 import { logLatency } from "../latency-logger.js";
 import { normalizeMapKey } from "../path-utils.js";
 import { registerQuietWindowTask } from "../quiet-window.js";
-export { classifyCascadeWaitTier, classifyServerWaitTier, } from "./wait-policy/classification.js";
+import { classifyCascadeWaitTier as classifySharedCascadeWaitTier, classifyServerWaitTier, resolvePrimaryServerForWaitPolicy, } from "./wait-policy/classification.js";
+export { classifyServerWaitTier };
+/**
+ * The cascade lane's wait tier for `filePath`. DELEGATES to the shared
+ * `wait-policy/classification.ts` rule — this wrapper adds exactly one
+ * cascade-only override on top of it (native TS7's push-only snapshot →
+ * `collect-later`) and never re-implements the classification itself.
+ *
+ * #1444 coverage tradeoff: the no-wait touch this tier selects is
+ * `clientScope: "primary"`, and the tier itself is decided from the PRIMARY
+ * (non-auxiliary) server alone. That tradeoff already existed for
+ * `tier3-silent`; the override enlarges the population it applies to — every
+ * native-TS7 TypeScript neighbour now takes the no-wait path too, so an
+ * auxiliary server configured for those files no longer gets touched in-lane
+ * for them (its findings arrive via the next per-edit dispatch, as they
+ * already did for classic tier-3 files).
+ */
+export function classifyCascadeWaitTier(lspService, filePath, snapshots) {
+    const primary = resolvePrimaryServerForWaitPolicy(filePath, snapshots);
+    if (primary?.serverId === "typescript" &&
+        primary.snapshot?.launchVariant === "native-ts7" &&
+        primary.snapshot.workspaceDiagnosticsSupport?.mode === "push-only") {
+        return "collect-later";
+    }
+    return classifySharedCascadeWaitTier(lspService, filePath, snapshots);
+}
 // --- Kill switch (lazy, memoized — house style per clients/runtime-config.ts /
 // clients/quiet-window.ts's isQuietWindowEnabled) ---
 let _enabledCache;
@@ -158,6 +191,7 @@ export async function reconcileOutstandingCascadeTouches(lspService) {
                 outcome: found ? "resolved-found" : "resolved-clean",
                 ageMs,
                 diagnosticCount: entry.diags.length,
+                publishedAt: entry.ts,
                 // #1023: carry the diagnostics so the task can re-surface them.
                 ...(found && { diagnostics: entry.diags }),
             });
@@ -199,17 +233,28 @@ export function registerCascadeTierReconcileTask(getLspService, options = {}) {
         if (outcomes.length === 0)
             return;
         // #1023: re-inject each resolved-found neighbor error so it reaches the
-        // agent (previously logs-only). Isolated per-outcome — a throwing callback
-        // must not drop the log line or the sibling re-injections.
+        // agent (previously logs-only). #1444: hand each resolved-CLEAN outcome to
+        // the footer reconcile for the mirror-image case. Isolated per-outcome — a
+        // throwing callback must not drop the log line or the sibling deliveries.
         for (const o of outcomes) {
-            if (o.outcome !== "resolved-found" || !o.diagnostics?.length)
-                continue;
             try {
-                options.onResolvedFound?.({
-                    filePath: o.filePath,
-                    serverId: o.serverId,
-                    diagnostics: o.diagnostics,
-                });
+                if (o.outcome === "resolved-found" && o.diagnostics?.length) {
+                    options.onResolvedFound?.({
+                        filePath: o.filePath,
+                        serverId: o.serverId,
+                        diagnostics: o.diagnostics,
+                    });
+                }
+                else if (o.outcome === "resolved-clean" && o.publishedAt != null) {
+                    // #1444: the stale-footer half of the same honesty problem — the
+                    // neighbour proved clean, but only after the in-lane wait was
+                    // skipped, so nothing has cleared its earlier error entries.
+                    options.onResolvedClean?.({
+                        filePath: o.filePath,
+                        serverId: o.serverId,
+                        publishedAt: o.publishedAt,
+                    });
+                }
             }
             catch {
                 // best-effort surfacing; the log below is the durable record.