@herbertgao/pi-extensions 2026.8.6 → 2026.8.7

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

@@ -53,6 +53,14 @@ export function computeTransitiveImpact(graph, seedFile, options) {
                     continue;
                 if (visited.has(edge.from))
                     continue;
+                if (hits.length >= maxHits) {
+                    return {
+                        seedFile: normalized,
+                        hits,
+                        truncated: true,
+                        maxDepthReached,
+                    };
+                }
                 visited.add(edge.from);
                 const dependent = graph.nodes.get(edge.from);
                 const hitDepth = node.depth + 1;
@@ -63,9 +71,6 @@ export function computeTransitiveImpact(graph, seedFile, options) {
                     depth: hitDepth,
                     relation: edge.kind,
                 });
-                if (hits.length >= maxHits) {
-                    return { seedFile: normalized, hits, truncated: true, maxDepthReached };
-                }
                 next.push({ id: edge.from, depth: hitDepth });
             }
         }
@@ -73,6 +78,44 @@ export function computeTransitiveImpact(graph, seedFile, options) {
     }
     return { seedFile: normalized, hits, truncated: false, maxDepthReached };
 }
+/**
+ * #1550: evidence for a `missing_node` verdict — the node id sought and the
+ * nearest thing the graph actually held. Runs ONLY on the miss path (one pass
+ * over `fileNodes`, which the same call already consulted), so the hot path is
+ * untouched. Keys are compared as the graph keys them (`normalizeMapKey`), so a
+ * key-shape divergence shows up as "nearest is the same path" rather than
+ * hiding behind a bare "missing".
+ */
+function describeMissingNode(graph, normalizedFile) {
+    const lastSlash = normalizedFile.lastIndexOf("/");
+    const dir = lastSlash === -1 ? "" : normalizedFile.slice(0, lastSlash);
+    const base = normalizedFile.slice(lastSlash + 1);
+    const stem = base.replace(/\.[^./]*$/, "");
+    let sameDirFileCount = 0;
+    let sameDirSibling;
+    let sameStemTwin;
+    for (const known of graph.fileNodes.keys()) {
+        const knownLastSlash = known.lastIndexOf("/");
+        const knownDir = knownLastSlash === -1 ? "" : known.slice(0, knownLastSlash);
+        const knownBase = known.slice(knownLastSlash + 1);
+        if (knownDir === dir) {
+            sameDirFileCount += 1;
+            sameDirSibling ??= known;
+            // A same-stem twin in the same directory is the strongest hint —
+            // an extension/compiled-twin resolution miss rather than an absent file.
+            if (sameStemTwin === undefined && knownBase.replace(/\.[^./]*$/, "") === stem) {
+                sameStemTwin = known;
+            }
+        }
+    }
+    return {
+        soughtNodeId: `file:${normalizedFile}`,
+        graphFileCount: graph.fileNodes.size,
+        symbolNodeCount: graph.symbolNodesByFile.get(normalizedFile)?.length ?? 0,
+        sameDirFileCount,
+        nearestFile: sameStemTwin ?? sameDirSibling,
+    };
+}
 export function computeImpactCascade(graph, changedFile, moduleGraph) {
     const normalizedFile = normalizeMapKey(changedFile);
     const fileNodeId = graph.fileNodes.get(normalizedFile);
@@ -111,7 +154,12 @@ export function computeImpactCascade(graph, changedFile, moduleGraph) {
             directCallers: [],
             neighborFiles: [],
             riskFlags: [],
-            indeterminate: { reason: "missing_node" },
+            indeterminate: {
+                reason: "missing_node",
+                // #1550: the reason alone forced a manual re-derivation on every
+                // occurrence. Attach the evidence (log-only — see the type doc).
+                diagnostic: describeMissingNode(graph, normalizedFile),
+            },
         };
     }
     const changedSymbols = graph.changedSymbolsByFile.get(normalizedFile) ?? [];

package/node_modules/pi-lens/dist/clients/runtime-agent-end.js

@@ -5,6 +5,7 @@ import { publishFilesTouched } from "./bus-publish.js";
 import { publishAutofixStart, publishFormatStart, } from "./format-events-publish.js";
 import { logLatency } from "./latency-logger.js";
 import { isPathIgnoredByProject } from "./file-utils.js";
+import { admitBounded, emitBounded } from "./bounded-telemetry.js";
 import { newLspMutationCorrelationId } from "./lsp-mutation.js";
 import { getGlobalActionableWarningMaxFixes, } from "./lens-config.js";
 import { resyncLspFile, runAutofix, runFormatPhase } from "./pipeline.js";
@@ -46,7 +47,7 @@ export async function handleAgentEnd({ ctxCwd, getFlag, getFlagSource, notify, d
     // session (e.g. a concurrent in-process secondary/subagent) stay queued
     // for their owner's own agent_end, unless they've been stale long enough
     // to fall back to "claim as orphaned" (see claimDeferredFormatFiles).
-    const { claimed, staleClaimed, deferredToOwner } = runtime.claimDeferredMutations(currentSessionId, Date.now(), staleAfterMs);
+    const { claimed, staleClaimed, deferredToOwner, droppedOrphans } = runtime.claimDeferredMutations(currentSessionId, Date.now(), staleAfterMs, ctxCwd ?? runtime.projectRoot);
     const records = [...claimed, ...staleClaimed];
     const requeuedKinds = new Set();
     // S2d (gap 4, #1432 review): the aggregate `agent_end_deferred_mutation_drain`
@@ -85,13 +86,84 @@ export async function handleAgentEnd({ ctxCwd, getFlag, getFlagSource, notify, d
         runtime.requeueDeferredMutations(pending);
     };
     const rootActionableAutofixEnabled = !!getFlag("lens-actionable-warning-autofix");
+    // The actionable-warnings cache is only ever written when the
+    // "lens-actionable-warnings" writer flag is on (clients/runtime-turn.ts).
+    // A reader that ignores this gate always misses in a host where the
+    // writer is off and logs "cache missing or expired" at every agent_end,
+    // misdirecting the debug log toward a bogus cache problem instead of the
+    // real cause: the feature that populates the cache is disabled (#1607).
+    const actionableWarningsWriterEnabled = !!getFlag("lens-actionable-warnings");
     // A path-aware source resolver signals that nested configs may re-enable
     // actionable autofix even when the root default is off. Legacy/test hosts
     // without that resolver keep the old fast exit and avoid a cache read.
-    const inspectActionableReport = rootActionableAutofixEnabled && typeof cacheManager.readCache === "function"
-        ? true
-        : getFlagSource !== undefined &&
-            typeof cacheManager.readCache === "function";
+    const inspectActionableReport = actionableWarningsWriterEnabled &&
+        typeof cacheManager.readCache === "function" &&
+        (rootActionableAutofixEnabled || getFlagSource !== undefined);
+    if (droppedOrphans.length > 0) {
+        // #1642 F3: a stale/foreign record whose origin (the cwd/worktree it
+        // was actually queued under) does NOT match this flush's own
+        // workspace/worktree is left queued and NEVER formatted by this
+        // flush — claiming it would be the same worktree→parent
+        // re-attribution the reported incident hit, just via the orphan
+        // fallback instead of tool_result's path resolution. It stays in
+        // `_pendingDeferredMutations` (not deleted) so a flush whose origin
+        // actually matches can still claim it later; a genuinely abandoned
+        // origin will keep surfacing this record on every subsequent
+        // agent_end, which is the deliberately safer trade-off over silently
+        // losing it forever.
+        dbg(`agent_end deferred_format: left ${droppedOrphans.length} orphaned file(s) queued due to a mismatched origin (unclaimed >${staleAfterMs}ms, not formatted by this flush): ${droppedOrphans
+            .map((r) => `${r.filePath} origin=${r.originCwd}`)
+            .join(", ")}`);
+        // #1678 item 1: a genuinely abandoned origin re-surfaces the SAME
+        // record on every subsequent agent_end for as long as the queued
+        // entry lives — by design (see the comment above), but the repo
+        // invariant is that a repeated degradation goes through the ledger's
+        // counting path instead of accumulating as unbounded raw log lines.
+        // The ledger is the single source of truth for whether THIS is a
+        // record's first appearance (its return value): the detailed forensic
+        // record below names only the orphans on that rising edge, with file
+        // identity/origin/age. Every later repeat of
+        // the same record is counted ONLY by the ledger's running count —
+        // no second raw event, no parallel "already logged" latch to
+        // maintain here.
+        // #1743: `admitBounded` IS that ledger call, plus the registry
+        // membership the bounded-telemetry sweep checks. This site admits PER
+        // ORPHAN and then writes ONE batched record naming the admitted ones,
+        // which is why it uses `admitBounded` directly instead of a per-record
+        // `emitBounded` — the per-call form would turn one log line into N.
+        const firstSeenOrphans = [];
+        for (const record of droppedOrphans) {
+            const isFirstOccurrence = admitBounded("agent_end_deferred_format_orphan_origin_mismatch", record.filePath, {
+                ledgerKind: "path-attribution-orphan-unresolved",
+                risingEdgePer: "identity",
+                reason: `origin=${record.originCwd} unclaimed >${staleAfterMs}ms`,
+            });
+            if (isFirstOccurrence)
+                firstSeenOrphans.push(record);
+        }
+        if (firstSeenOrphans.length > 0) {
+            // Already admitted above, one orphan at a time — hence no bounding
+            // options here. The batch's own identity is the origin this flush ran
+            // under; per-file identity rides in `metadata.files`.
+            emitBounded("agent_end_deferred_format_orphan_origin_mismatch", ctxCwd ?? runtime.projectRoot, {
+                type: "phase",
+                toolName: "agent_end",
+                durationMs: 0,
+                metadata: {
+                    fileCount: firstSeenOrphans.length,
+                    staleAfterMs,
+                    currentOriginCwd: ctxCwd ?? runtime.projectRoot,
+                    files: firstSeenOrphans.map((r) => ({
+                        filePath: r.filePath,
+                        originCwd: r.originCwd,
+                        ownerSessionId: r.ownerSessionId,
+                        queuedTurnIndex: r.queuedTurnIndex,
+                        ageMs: Date.now() - r.lastTouchedAt,
+                    })),
+                },
+            });
+        }
+    }
     if (records.length === 0 && !inspectActionableReport)
         return undefined;
     if (deferredToOwner.length > 0) {
@@ -402,9 +474,26 @@ export async function handleAgentEnd({ ctxCwd, getFlag, getFlagSource, notify, d
         await resyncLspFile(changedPath, content, true, false, getFlag, dbg);
     }
     if (inspectActionableReport) {
-        const actionReport = cacheManager.readCache("actionable-warnings", ctxCwd ?? runtime.projectRoot, 10 * 60_000);
+        const actionCwd = ctxCwd ?? runtime.projectRoot;
+        const actionableWarningsMaxAgeMs = 10 * 60_000;
+        const actionReport = cacheManager.readCache("actionable-warnings", actionCwd, actionableWarningsMaxAgeMs);
         if (!actionReport?.data) {
-            dbg("agent_end actionable_warnings_autofix: cache missing or expired, skipping fixes");
+            // Distinguish "no cache file was ever written" from "a cache file
+            // exists but its TTL elapsed" (#1607) — both used to collapse into
+            // one "cache missing or expired" line, which doesn't tell a reader
+            // whether the writer ran and produced a stale file, or never ran.
+            const inspection = typeof cacheManager.inspectCache === "function"
+                ? cacheManager.inspectCache("actionable-warnings", actionCwd, actionableWarningsMaxAgeMs)
+                : undefined;
+            if (inspection === "missing") {
+                dbg("agent_end actionable_warnings_autofix: cache absent, skipping fixes");
+            }
+            else if (inspection === "stale") {
+                dbg("agent_end actionable_warnings_autofix: cache expired, skipping fixes");
+            }
+            else {
+                dbg(`agent_end actionable_warnings_autofix: cache missing or expired${inspection ? ` (${inspection})` : ""}, skipping fixes`);
+            }
         }
         else {
             const enabledFiles = actionReport.data.files.filter((file) => {

package/node_modules/pi-lens/dist/clients/runtime-context.js

@@ -147,7 +147,14 @@ export function consumeSessionStartGuidance(cacheManager, cwd) {
     const guidance = cacheManager.readCache("session-start-guidance", cwd);
     if (!guidance?.data?.content)
         return;
-    cacheManager.writeCache("session-start-guidance", null, cwd);
+    // Consume by writing empty guidance, not by casting `null` into the entry's
+    // own type. `writeCache` infers its type parameter from `data`, so the cast
+    // bought nothing and claimed the file held a `{ content: string }` when it
+    // held JSON `null`. The producer (`runtime-session.ts`) always writes
+    // `{ content }`, and this reader gates on `data?.content` being non-empty,
+    // so an empty string is the same "already consumed" signal with the type
+    // the entry actually has. Same idiom as `acknowledgeTestFindings` above.
+    cacheManager.writeCache("session-start-guidance", { content: "" }, cwd);
     return {
         messages: [
             {