@herbertgao/pi-extensions 2026.8.13 → 2026.8.15

package/node_modules/pi-lens/dist/clients/lsp/workspace-diagnostics-cache.js

@@ -8,6 +8,7 @@ import { normalizeMapKey } from "../path-utils.js";
 import { loadReverseDependencyIndexFromSnapshot } from "../reverse-deps.js";
 import { freshnessFromMtime } from "../freshness.js";
 import { logLatency } from "../latency-logger.js";
+import { compareOrdinal } from "../string-utils.js";
 import { workspaceDiagnosticsCacheSessionStart } from "./workspace-diagnostics-session.js";
 import { createDiskBindingCache, } from "./diagnostic-binding.js";
 /**
@@ -281,7 +282,11 @@ export function classifyWorkspaceDiagnosticsCacheExpiry(entry, now, sessionStart
  * Two invalidation layers:
  * 1. The file's OWN mtime must be unchanged since it was scanned (exact
  *    match against `entry.mtimeMs`) — any drift, or a stat failure
- *    (deleted/unreadable), invalidates.
+ *    (deleted/unreadable), invalidates. #2300: when the entry also carries a
+ *    `sizeBytes`, the current size must match too — an external rewrite that
+ *    lands in the same mtime bucket with a different length is otherwise
+ *    invisible to mtime alone. A pre-#2300 entry without `sizeBytes` fails
+ *    OPEN to the mtime-only check (see the field's doc comment).
  * 2. When a reverse-dependency index is available (`getImports` returns an
  *    array rather than `undefined`), every file THIS file imports must not
  *    have changed after `entry.scannedAt` either — this is the fix for the
@@ -326,15 +331,19 @@ export function classifyWorkspaceDiagnosticsCacheExpiry(entry, now, sessionStart
  * (#1491/#1498) rather than just a redundant re-touch.
  */
 export function isEntryFresh(filePath, entry, getImports) {
-    let ownMtime;
+    let ownStat;
     try {
-        ownMtime = fs.statSync(filePath).mtimeMs;
+        ownStat = fs.statSync(filePath);
     }
     catch {
         return false; // deleted / unreadable
     }
-    if (ownMtime !== entry.mtimeMs)
+    if (ownStat.mtimeMs !== entry.mtimeMs)
         return false;
+    // #2300: same axis reused from the stat above — no extra syscall.
+    if (entry.sizeBytes !== undefined && ownStat.size !== entry.sizeBytes) {
+        return false;
+    }
     const imports = getImports(filePath);
     if (imports === undefined) {
         // #1793: an entry recorded WITH dependency knowledge must not fall
@@ -376,7 +385,7 @@ export function cacheKeyFor(filePath) {
  */
 export function buildScopeKey(clientScope, excludeServerIds) {
     const excluded = excludeServerIds
-        ? [...excludeServerIds].sort((a, b) => a.localeCompare(b))
+        ? [...excludeServerIds].sort(compareOrdinal)
         : [];
     return `${clientScope}|${excluded.join(",")}`;
 }
@@ -542,7 +551,7 @@ export function createWorkspaceDiagnosticsCacheContext(cwd) {
                 scannedAt: entry.scannedAt,
             };
         },
-        record(filePath, scopeKey, diagnostics, mtimeMs, contentHash) {
+        record(filePath, scopeKey, diagnostics, mtimeMs, contentHash, sizeBytes) {
             entries[cacheKeyFor(filePath)] = {
                 diagnostics,
                 count: diagnostics.length,
@@ -556,6 +565,7 @@ export function createWorkspaceDiagnosticsCacheContext(cwd) {
                 // weaker mtime-only path only when that refusal is warranted.
                 depIndexAtScan: hasDepKnowledge(filePath),
                 ...(contentHash !== undefined && { contentHash }),
+                ...(sizeBytes !== undefined && { sizeBytes }),
             };
             dirty = true;
         },

package/node_modules/pi-lens/dist/clients/lsp/workspace-sweep-hold.js

@@ -40,22 +40,26 @@
  * apart again (#1618 acceptance criterion 6).
  */
 import { logLatency } from "../latency-logger.js";
+import { getProcessSingleton } from "../process-singletons.js";
 /** Extra headroom beyond the sweep's own wall-clock ceiling before an
  *  idle-reset delay (or the max-hold-age failsafe) trusts that a real sweep
  *  must be done. Single source for both derivations below AND for every
  *  idle-reset path `clients/runtime-turn.ts` derives (base, subagent, and
  *  budget-shortened) — never a second independently-tunable literal. */
 export const SWEEP_IDLE_SAFETY_MARGIN_MS = 60_000;
-let holds = new Map(); // holdId -> acquiredAt (Date.now())
-let nextHoldId = 1;
-let idleWaiters = [];
+const WORKSPACE_SWEEP_HOLD_FAMILY = "lsp.workspace-sweep-hold";
+const WORKSPACE_SWEEP_HOLD_VERSION = 1;
+function state() {
+    return getProcessSingleton(WORKSPACE_SWEEP_HOLD_FAMILY, WORKSPACE_SWEEP_HOLD_VERSION, () => ({ holds: new Map(), nextHoldId: 1, idleWaiters: [] }));
+}
 function flushIdleWaitersIfEmpty() {
-    if (holds.size > 0)
+    const current = state();
+    if (current.holds.size > 0)
         return;
-    if (idleWaiters.length === 0)
+    if (current.idleWaiters.length === 0)
         return;
-    const waiters = idleWaiters;
-    idleWaiters = [];
+    const waiters = current.idleWaiters;
+    current.idleWaiters = [];
     for (const waiter of waiters) {
         try {
             waiter();
@@ -77,15 +81,16 @@ export function getWorkspaceSweepMaxHoldAgeMs() {
     return getFullScanWallClockMs() + SWEEP_IDLE_SAFETY_MARGIN_MS;
 }
 function reapStaleHolds() {
-    if (holds.size === 0)
+    const current = state();
+    if (current.holds.size === 0)
         return;
     const maxAgeMs = getWorkspaceSweepMaxHoldAgeMs();
     const now = Date.now();
-    for (const [holdId, acquiredAt] of holds) {
+    for (const [holdId, acquiredAt] of current.holds) {
         const ageMs = now - acquiredAt;
         if (ageMs <= maxAgeMs)
             continue;
-        holds.delete(holdId);
+        current.holds.delete(holdId);
         logLatency({
             type: "phase",
             phase: "lsp_workspace_sweep_hold_force_released",
@@ -104,10 +109,11 @@ function reapStaleHolds() {
  * force-released (session reset / max-age reap), is a no-op.
  */
 export function acquireWorkspaceSweepHold() {
-    const holdId = nextHoldId++;
-    holds.set(holdId, Date.now());
+    const current = state();
+    const holdId = current.nextHoldId++;
+    current.holds.set(holdId, Date.now());
     return () => {
-        if (!holds.delete(holdId))
+        if (!state().holds.delete(holdId))
             return;
         flushIdleWaitersIfEmpty();
     };
@@ -117,7 +123,7 @@ export function acquireWorkspaceSweepHold() {
  *  "active" past its own max age. */
 export function isWorkspaceSweepActive() {
     reapStaleHolds();
-    return holds.size > 0;
+    return state().holds.size > 0;
 }
 /**
  * Run `cb` once the hold count next returns to zero. Runs synchronously and
@@ -126,11 +132,12 @@ export function isWorkspaceSweepActive() {
  */
 export function runWhenWorkspaceSweepIdle(cb) {
     reapStaleHolds();
-    if (holds.size === 0) {
+    const current = state();
+    if (current.holds.size === 0) {
         cb();
         return;
     }
-    idleWaiters.push(cb);
+    current.idleWaiters.push(cb);
 }
 /**
  * `resetLSPService({reason: "session_start"})` calls this: a session
@@ -142,23 +149,25 @@ export function runWhenWorkspaceSweepIdle(cb) {
  * silent.
  */
 export function clearWorkspaceSweepHoldForSessionStart() {
-    if (holds.size === 0)
+    const current = state();
+    if (current.holds.size === 0)
         return;
     logLatency({
         type: "phase",
         phase: "lsp_workspace_sweep_hold_session_reset",
         filePath: "",
         durationMs: 0,
-        metadata: { clearedHolds: holds.size },
+        metadata: { clearedHolds: current.holds.size },
     });
-    holds.clear();
+    current.holds.clear();
     flushIdleWaitersIfEmpty();
 }
-/** Test-only: reset the module-scope hold state between tests. */
+/** Test-only: reset the process-singleton hold state between tests. */
 export function _resetWorkspaceSweepHoldForTests() {
-    holds = new Map();
-    idleWaiters = [];
-    nextHoldId = 1;
+    const current = state();
+    current.holds.clear();
+    current.idleWaiters = [];
+    current.nextHoldId = 1;
 }
 /**
  * Wall-clock ceiling for one `lens_diagnostics mode=full` scan

package/node_modules/pi-lens/dist/clients/lsp-mutation.js

@@ -52,8 +52,22 @@ function combineResults(results) {
 }
 function uniqueDetails(files, fileDetails) {
     const byPath = new Map();
+    // #2016: `files` and `fileDetails` name the same paths, so without this the
+    // map-build loop and the lookup below each pay `realpathSync.native` for the
+    // same path (~200 microseconds per call on Windows; POSIX short-circuits, so
+    // CI cannot see it). The memo lives for one call, so it has no staleness
+    // window at all and needs no freshness design.
+    const keyMemo = new Map();
+    const keyFor = (filePath) => {
+        let key = keyMemo.get(filePath);
+        if (key === undefined) {
+            key = normalizeMapKey(path.resolve(filePath));
+            keyMemo.set(filePath, key);
+        }
+        return key;
+    };
     for (const detail of fileDetails) {
-        const key = normalizeMapKey(path.resolve(detail.filePath));
+        const key = keyFor(detail.filePath);
         const previous = byPath.get(key);
         if (!previous) {
             byPath.set(key, detail);
@@ -70,7 +84,7 @@ function uniqueDetails(files, fileDetails) {
             importsChanged: previous.importsChanged || detail.importsChanged,
         });
     }
-    return files.map((filePath) => byPath.get(normalizeMapKey(path.resolve(filePath))) ?? {
+    return files.map((filePath) => byPath.get(keyFor(filePath)) ?? {
         filePath,
         // Resource operations have no already-computed text range. A small
         // range is still enough to invalidate the touched-file turn state;

package/node_modules/pi-lens/dist/clients/mcp/analyze.js

@@ -24,7 +24,7 @@ import { normalizeMapKey } from "../path-utils.js";
 import { loadProjectSnapshot } from "../project-snapshot.js";
 import { buildOrUpdateGraph } from "../review-graph/service.js";
 import { recordDiagnostics } from "../widget-state.js";
-import { deserializeWordIndex, removeWordIndexDocument, scheduleWordIndexPersist, updateWordIndexDocument, WORD_INDEX_MAX_BYTES, } from "../word-index.js";
+import { deserializeWordIndex, removeWordIndexDocumentAsync, scheduleWordIndexPersist, updateWordIndexDocumentForEdit, WORD_INDEX_MAX_BYTES, } from "../word-index.js";
 import { logWordIndex } from "../word-index-logger.js";
 import { createMcpHost } from "./host-shim.js";
 // #536: module-scoped FactStore for the warm-analyze graph seam, mirroring the
@@ -33,7 +33,9 @@ import { createMcpHost } from "./host-shim.js";
 // tiers key off a stable FactStore instance across calls, so a fresh FactStore
 // per call would defeat that reuse. Scoped separately from integration.ts's
 // singleton since this file has no dependency on that module's internal state.
-const warmGraphFacts = new FactStore();
+// Subject labels this store's capacity-eviction telemetry distinctly from
+// the other five production FactStore instances (#2243 review round 3, F1).
+const warmGraphFacts = new FactStore("mcp-analyze");
 // #536 rider (issue body: "when #348 phase 2 lands, the word-index per-edit
 // update should ride the SAME seam so both indexes stay warm together"):
 // MCP has no RuntimeCoordinator/`runtime.wordIndex` to hold a live index the
@@ -295,8 +297,9 @@ export async function analyzeFile(filePath, cwd, options = {}) {
         // index with no `forward` map (or none loaded) ⇒ no-op (no incremental
         // primitive available — the eventual full rebuild covers it); an
         // oversized file is REMOVED, never partially indexed; the update is
-        // synchronous (no interleaving hazard — MCP is single-process, same as
-        // pi); a successful update schedules the SAME debounced persist
+        // cooperative and serialized through the index's own operation queue
+        // (#2067 AC4), so this seam no longer holds the event loop for a whole
+        // replacement either; a successful update schedules the SAME debounced persist
         // (`scheduleWordIndexPersist`, `PI_LENS_WORD_INDEX_PERSIST_DEBOUNCE_MS`)
         // pi's path uses — no second persist mechanism.
         //
@@ -313,10 +316,13 @@ export async function analyzeFile(filePath, cwd, options = {}) {
                     const content = fs.readFileSync(absPath, "utf8");
                     const byteLength = Buffer.byteLength(content, "utf-8");
                     if (byteLength > WORD_INDEX_MAX_BYTES) {
-                        removeWordIndexDocument(warmIndex, absPath);
+                        await removeWordIndexDocumentAsync(warmIndex, absPath);
                     }
                     else {
-                        updateWordIndexDocument(warmIndex, { path: absPath, content });
+                        await updateWordIndexDocumentForEdit(warmIndex, {
+                            path: absPath,
+                            content,
+                        });
                     }
                     scheduleWordIndexPersist(cwd, warmIndex);
                 }

package/node_modules/pi-lens/dist/clients/mcp/session.js

@@ -309,8 +309,13 @@ export function runTurnEndForIpc(cwd) {
     const inFlight = inFlightIpcTurnEnds.get(cwd);
     if (inFlight)
         return inFlight;
+    // Identity-guarded release (#1968's pattern): delete only if THIS run is
+    // still the registered one. A bare delete-by-key lets a late-settling run
+    // evict a live successor a second writer registered under the same cwd
+    // mid-flight, after which the next caller starts a duplicate Stop-hook pass.
     const run = runTurnEndForIpcNow(cwd).finally(() => {
-        inFlightIpcTurnEnds.delete(cwd);
+        if (inFlightIpcTurnEnds.get(cwd) === run)
+            inFlightIpcTurnEnds.delete(cwd);
     });
     inFlightIpcTurnEnds.set(cwd, run);
     return run;
@@ -374,3 +379,11 @@ export function _resetTurnEndChain() {
     pendingTurnEndDeliveries.clear();
     inFlightIpcTurnEnds.clear();
 }
+/**
+ * Test hook — read the `runTurnEndForIpc` in-flight map directly (#1968's
+ * ABA regression: a second writer replacing an entry mid-flight, then a
+ * late-settling first run evicting it with a bare delete-by-key).
+ */
+export function _peekInFlightIpcTurnEnds() {
+    return inFlightIpcTurnEnds;
+}

package/node_modules/pi-lens/dist/clients/memory-sampler.js

@@ -29,9 +29,11 @@
  * `arrayBuffers` is used as the process-wide proxy instead — WASM linear
  * memory backs an ArrayBuffer, so it is already included there.
  */
+import { countPostingEntries, estimateWordIndexStoreBytes, } from "./word-index-store.js";
 import { getSharedTreeSitterClient } from "./tree-sitter-shared.js";
 import { getReviewGraphWorkspaceCacheSnapshot } from "./review-graph/builder.js";
 import { getDispatchCascadeCacheStats } from "./dispatch/integration.js";
+import { getLspDocumentTextRetentionSnapshot } from "./lsp/client.js";
 /** Every N turns, emit one `memory_sample` latency.log line (#1123 item 2). */
 export const MEMORY_SAMPLE_TURN_INTERVAL = 10;
 /** True on turn 10, 20, 30, ... — never on turn 0 (nothing meaningful is
@@ -121,16 +123,36 @@ export function collectMemorySampleSubsystems(wordIndex) {
         : null;
     const dispatchCaches = getDispatchCascadeCacheStats();
     return {
+        lsp: (() => {
+            const retention = getLspDocumentTextRetentionSnapshot();
+            return {
+                clients: retention.clients,
+                clientRoots: retention.roots,
+                incrementalTextEntries: retention.entries,
+                incrementalTextBytes: retention.bytes,
+            };
+        })(),
         reviewGraph,
         wordIndex: wordIndex
             ? {
                 docs: wordIndex.docLengths.size,
+                fileTable: wordIndex.fileTable.size,
                 postings: wordIndex.postings.size,
+                // O(distinct tokens), reading only `.length`/`.byteLength` per
+                // list — no posting ELEMENT is touched, so this stays inside the
+                // module docstring’s bounded-read constraint.
+                postingEntries: countPostingEntries(wordIndex),
+                residentBytes: estimateWordIndexStoreBytes(wordIndex),
                 forwardEntries: wordIndex.forward?.size ?? 0,
             }
             : null,
         treeSitter,
-        dispatchCaches,
+        dispatchCaches: {
+            ...dispatchCaches,
+            // Three isolated-store runs measured 320 bytes per production entry.
+            // Keep this O(1); the cache key and Map bookkeeping are included.
+            estimatedBytes: dispatchCaches.recentlyCleanNeighborCacheSize * 320,
+        },
     };
 }
 /** Assemble one full sample. `mem` is injectable for tests; defaults to a

package/node_modules/pi-lens/dist/clients/message-end-attribution.js

@@ -0,0 +1,30 @@
+/** Session-local attribution captured before a stale message_end can drain. */
+let lastStableSessionId;
+let previousSessionId;
+/** Remember the stable id used by a live message_end's own cache row. */
+export function noteLiveMessageEndSessionId(sessionId) {
+    lastStableSessionId = sessionId;
+}
+/** Return the newest usable id for a stale message_end attribution. */
+export function getLastLiveMessageEndSessionId() {
+    return lastStableSessionId ?? previousSessionId;
+}
+/**
+ * Rotate the attribution anchor at the real session boundary. A queued stale
+ * message_end from the session being replaced may drain after this boundary,
+ * so retain exactly one prior anchor while making room for the replacement.
+ */
+export function rotateMessageEndAttribution() {
+    // Keep the prior anchor when no live message_end arrived this session:
+    // two back-to-back boundaries (reload/resume re-announcing) must not
+    // erase the only id a still-queued stale drain can use (#1956 R10).
+    if (lastStableSessionId !== undefined) {
+        previousSessionId = lastStableSessionId;
+    }
+    lastStableSessionId = undefined;
+}
+/** Full reset seam used by the session-state registry and test isolation. */
+export function resetMessageEndAttribution() {
+    lastStableSessionId = undefined;
+    previousSessionId = undefined;
+}

package/node_modules/pi-lens/dist/clients/metrics-history.js

@@ -34,14 +34,31 @@ function isInsideGitRepo(startDir) {
 /**
  * Get current git commit hash (short)
  */
-function getCurrentCommit() {
-    if (!isInsideGitRepo(process.cwd())) {
+function getCurrentCommit(startDir) {
+    const repoStartDir = path.resolve(startDir);
+    if (!isInsideGitRepo(repoStartDir)) {
         return "unknown";
     }
+    let spawnDir = repoStartDir;
+    while (!fs.existsSync(spawnDir)) {
+        const parent = path.dirname(spawnDir);
+        if (parent === spawnDir)
+            return "unknown";
+        spawnDir = parent;
+    }
     try {
+        // #2095: execSync inherits the child's stderr to THIS process by
+        // default (only stdout is captured for the return value), so a
+        // failing `git rev-parse` prints its raw "fatal: ..." line straight
+        // into the pi TUI — the catch below only ever sees the thrown
+        // non-zero-exit error, never the already-inherited stream. The
+        // explicit stdio array pipes stderr instead, so a failure is fully
+        // contained: silent here, same as the "unknown" fallback it feeds.
         return execSync("git rev-parse --short HEAD", {
             encoding: "utf-8",
             timeout: 5000,
+            stdio: ["ignore", "pipe", "ignore"],
+            cwd: spawnDir,
         }).trim();
     }
     catch {
@@ -99,7 +116,7 @@ export function captureSnapshot(filePath, metrics) {
         pendingHistory = loadHistory();
     }
     const relativePath = path.relative(process.cwd(), filePath);
-    const commit = getCurrentCommit();
+    const commit = getCurrentCommit(path.dirname(filePath));
     const snapshot = {
         commit,
         timestamp: new Date().toISOString(),
@@ -152,7 +169,7 @@ export function captureSnapshots(files) {
     const history = loadHistory();
     for (const file of files) {
         const relativePath = path.relative(process.cwd(), file.filePath);
-        const commit = getCurrentCommit();
+        const commit = getCurrentCommit(path.dirname(file.filePath));
         const snapshot = {
             commit,
             timestamp: new Date().toISOString(),