@herbertgao/pi-extensions 2026.8.3 → 2026.8.5

package/node_modules/pi-lens/dist/clients/event-loop-monitor.js

@@ -10,11 +10,50 @@
  * of how late the loop services its own timer, i.e. how long it was blocked —
  * with **no per-event JS overhead**. `max` ≈ the worst synchronous block since
  * the last reset.
+ *
+ * ## System-stall contamination (#1122 / #1123)
+ *
+ * `monitorEventLoopDelay` measures timer lag with the monotonic clock
+ * (`uv_hrtime`, backed by `QueryPerformanceCounter` on Windows). When the whole
+ * process is frozen or descheduled — machine sleep / Modern Standby, or paging
+ * thrash under commit-charge exhaustion — its next timer fires late by the
+ * *entire* wall-clock gap, and the histogram records that gap as a "block".
+ * Two distinct system stalls were confirmed against the Windows System event
+ * log: (1) a 290,179 ms block that lined up exactly with a 14:33:05Z→14:37:55Z
+ * Modern Standby window (Kernel-Power 506/507), reported byte-identical by two
+ * independent pids because the HDR histogram quantizes ~290 s into one bucket;
+ * (2) a later silent host exit with zero sleep events but twelve
+ * Resource-Exhaustion-Detector (id 2004) events at 97% commit charge — the
+ * process was paging, not sleeping. Both are machine artifacts, not pi-lens
+ * work; latency.log also held multi-*hour* "blocks" that can only be overnight
+ * sleep.
+ *
+ * Comparing a wall clock to a monotonic clock does NOT catch these: on Windows
+ * both advance across Modern Standby (the histogram's monotonic delta already
+ * equalled the wall gap). The reliable discriminator is **CPU consumption**: a
+ * genuine synchronous block of D ms burns ≈ D ms of main-thread CPU, so the
+ * window that contains it must have consumed at least ~D ms of CPU. A frozen or
+ * thrashing process consumes ~0 CPU across the gap, so when the worst block
+ * exceeds all the CPU the window could account for, it was a stall, not work.
+ * We window per turn (so the CPU accounting is bounded and each block is
+ * attributable to its turn) and tag system-stall-suspected samples instead of
+ * letting them poison the "worst real block" high-water.
  */
+import { logExtension } from "./extension-log.js";
 import { monitorEventLoopDelay } from "node:perf_hooks";
 const NS_PER_MS = 1e6;
+const US_PER_MS = 1e3;
 let histogram;
 let monitorUnavailable = false;
+// Per-window (per-turn) baselines for CPU-vs-wall accounting. Captured when the
+// monitor starts and re-captured on every reset, so each window's CPU budget is
+// measured against exactly the histogram window it will be compared to.
+let windowStartWallMs = 0;
+let windowStartCpuMs = 0;
+const cpuTotalMs = () => {
+    const c = process.cpuUsage();
+    return (c.user + c.system) / US_PER_MS;
+};
 /**
  * Start the monitor (idempotent). Call once, as early as possible, so startup
  * blocks are captured. Cheap — the sampling is native; nothing runs per event.
@@ -32,26 +71,76 @@ export function startEventLoopMonitor(resolutionMs = 20) {
         const h = monitorEventLoopDelay({ resolution: resolutionMs });
         h.enable();
         histogram = h;
+        windowStartWallMs = Date.now();
+        windowStartCpuMs = cpuTotalMs();
     }
     catch (err) {
         monitorUnavailable = true;
-        console.error(`[pi-lens] event-loop occupancy telemetry disabled (runtime lacks monitorEventLoopDelay): ${err?.message ?? String(err)}`);
+        logExtension({
+            subsystem: "event-loop-monitor",
+            message: `event-loop occupancy telemetry disabled (runtime lacks monitorEventLoopDelay): ${err?.message ?? String(err)}`,
+        });
     }
 }
 const safeMs = (ns) => Number.isFinite(ns) ? Math.round((ns / NS_PER_MS) * 10) / 10 : 0;
+/**
+ * Classify a worst-block sample as genuine CPU work or a suspend/freeze
+ * artifact. Pure so the discrimination is testable without the (vitest-flaky)
+ * native histogram or a real machine sleep.
+ *
+ * A block is system-stall-suspected only when it is both (a) larger than any
+ * plausible synchronous pi-lens stall (`floorMs`, default 20 s — the real tier
+ * observed in latency.log tops out ~15 s) and (b) unaccounted for by the
+ * window's CPU budget (`windowCpuMs + slopMs < maxMs`). The floor keeps a real
+ * multi-second I/O-bound block (low CPU, but genuine) from being mislabeled,
+ * while a frozen or paging process — ~0 CPU across a minutes-to-hours gap —
+ * always trips. Sub-floor blocks are never auto-tagged, but the logged
+ * `windowCpuMs`/`windowWallMs` still expose the CPU-vs-wall ratio so a reviewer
+ * can spot a shorter paging stall by hand.
+ *
+ * KNOWN AMBIGUITY (honest, not fully resolvable from CPU alone): a genuine
+ * pi-lens block that is BLOCKED IN A SYSCALL for >20 s — e.g. a `readdirSync` /
+ * `statSync` stalled on a OneDrive/cloud-backed path fetching a dehydrated file,
+ * or an antivirus-throttled read — also consumes ~0 CPU while wall time
+ * advances, so it is CPU-indistinguishable from a suspend and WILL be tagged
+ * `suspectSystemStall` and excluded from the health high-waters. That is the
+ * conservative choice (a >20 s synchronous FS stall is itself a P0-worthy bug we
+ * do NOT want silently counted as normal), and it is not silenced: such a sample
+ * still re-logs every turn with its `lastPhase` attribution, which is the
+ * forensic breadcrumb for exactly this class. Sharper corroboration (a magnitude
+ * ceiling, a `maxMs`-vs-`windowWallMs` ratio) is tracked as a follow-up note on
+ * #1123, not decided here.
+ */
+export function isSuspendSuspectedBlock(maxMs, windowCpuMs, floorMs = 20000, slopMs = 1000) {
+    if (maxMs < floorMs)
+        return false;
+    return windowCpuMs + slopMs < maxMs;
+}
 /** Current occupancy stats, or undefined if the monitor was never started. */
 export function getEventLoopStats() {
     if (!histogram)
         return undefined;
+    const maxMs = safeMs(histogram.max);
+    const windowWallMs = Math.max(0, Date.now() - windowStartWallMs);
+    const windowCpuMs = Math.max(0, cpuTotalMs() - windowStartCpuMs);
     return {
-        maxMs: safeMs(histogram.max),
+        maxMs,
         p99Ms: safeMs(histogram.percentile(99)),
         meanMs: safeMs(histogram.mean),
+        windowWallMs: Math.round(windowWallMs),
+        windowCpuMs: Math.round(windowCpuMs),
+        suspectSystemStall: isSuspendSuspectedBlock(maxMs, windowCpuMs),
     };
 }
-/** Reset the histogram — e.g. at session/turn boundaries for per-window stats. */
+/**
+ * Reset the histogram and re-baseline the CPU/wall window — called at turn
+ * boundaries so each window's worst block is attributable to that turn and its
+ * CPU budget is measured over the same span (#192 intent, wired in #1122).
+ */
 export function resetEventLoopMonitor() {
     histogram?.reset();
+    windowStartWallMs = Date.now();
+    windowStartCpuMs = cpuTotalMs();
 }
 /**
  * Decide whether a freeze is worth persisting to `latency.log`. Pure so the
@@ -68,4 +157,6 @@ export function _stopEventLoopMonitorForTest() {
     histogram?.disable();
     histogram = undefined;
     monitorUnavailable = false;
+    windowStartWallMs = 0;
+    windowStartCpuMs = 0;
 }

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

@@ -0,0 +1,139 @@
+/**
+ * Terminal-safe diagnostic sink for the in-pi extension path (#1333).
+ *
+ * pi owns the terminal: it runs the TTY in raw mode and repaints with
+ * cursor-addressed diffs, so ANY byte an extension writes to stdout/stderr
+ * lands mid-frame and desyncs pi's model of the screen — the layout stays
+ * broken until a full repaint. `clients/`, `tools/`, `index.ts` and `i18n.ts`
+ * are all reachable from the extension entry, so none of them may call
+ * `console.*` or `process.std*.write`. (`mcp/`, `scripts/` and `bin/` DO own
+ * their stdout contract and keep their writes.)
+ *
+ * This module is the general-purpose replacement sink: one `createNdjsonLogger`
+ * instance over `<global pi-lens dir>/extension.log`, per the single-writer
+ * invariant in AGENTS.md. Subsystems that already own a log (tree-sitter,
+ * review-graph, cascade, latency, sessionstart) route to THAT log instead —
+ * this file is for the areas that had no sink at all.
+ *
+ * Three-channels rule (#482/#484/#485): everything written here is
+ * LOG-audience. A genuinely user-facing degradation must ALSO reach the human
+ * through the host's own render path (`ctx.ui.notify` / a display-only session
+ * entry) — never a raw write.
+ */
+import * as path from "node:path";
+import { isTestMode } from "./env-utils.js";
+import { getGlobalPiLensDir } from "./file-utils.js";
+import { getMaxLogSizeMB } from "./log-cleanup.js";
+import { createNdjsonLogger } from "./ndjson-logger.js";
+export const EXTENSION_LOG_FILE = path.join(getGlobalPiLensDir(), "extension.log");
+const writer = createNdjsonLogger({
+    filePath: EXTENSION_LOG_FILE,
+    maxBytes: getMaxLogSizeMB() * 1024 * 1024,
+});
+export function logExtension(entry) {
+    if (isTestMode())
+        return;
+    writer.log({
+        ts: new Date().toISOString(),
+        pid: process.pid,
+        level: entry.level ?? "error",
+        subsystem: entry.subsystem,
+        message: entry.message,
+        ...(entry.metadata ? { metadata: entry.metadata } : {}),
+    });
+}
+export function createSubsystemLogger(subsystem, defaultLevel = "debug") {
+    const at = (level) => (message, metadata) => {
+        logExtension({ subsystem, message, level, metadata });
+    };
+    const logger = at(defaultLevel);
+    logger.error = at("error");
+    logger.warn = at("warn");
+    logger.debug = at("debug");
+    return logger;
+}
+/** No-op with the `SubsystemLogger` shape, for the verbose-off branch. */
+export function noopSubsystemLogger() {
+    const noop = (() => { });
+    noop.error = () => { };
+    noop.warn = () => { };
+    noop.debug = () => { };
+    return noop;
+}
+export function getExtensionLogPath() {
+    return EXTENSION_LOG_FILE;
+}
+/** Resolve once all enqueued extension-log writes are on disk (tests/shutdown). */
+export function flushExtensionLog() {
+    return writer.flush();
+}
+/** Teardown-only: force queued entries to disk before the process exits. */
+export function flushExtensionLogSync() {
+    writer.flushSync();
+}
+// --- Defense in depth: the console reroute -----------------------------------
+const CONSOLE_METHODS = [
+    "log",
+    "info",
+    "warn",
+    "error",
+    "debug",
+    "trace",
+    "dir",
+];
+let consoleGuardInstalled = false;
+function formatConsoleArgs(args) {
+    return args
+        .map((arg) => {
+        if (typeof arg === "string")
+            return arg;
+        if (arg instanceof Error)
+            return arg.stack ?? arg.message;
+        try {
+            return JSON.stringify(arg) ?? String(arg);
+        }
+        catch {
+            return String(arg);
+        }
+    })
+        .join(" ");
+}
+/**
+ * Patch every console method on the extension entry path so a transitively
+ * loaded dependency cannot write raw bytes into pi's frame — the pi-side
+ * mirror of `mcp/server.ts`'s `console.log = console.error` guard, which
+ * protects the JSON-RPC stdout channel for the same structural reason.
+ *
+ * This is a NET, not the fix: pi-lens's own sites are migrated to real sinks
+ * with real schemas. Idempotent, and inert under test mode (vitest owns the
+ * console) and under `PI_LENS_CONSOLE_GUARD=0`.
+ *
+ * Returns true when the patch was applied by this call.
+ */
+export function installConsoleGuard() {
+    if (consoleGuardInstalled)
+        return false;
+    if (isTestMode())
+        return false;
+    if (process.env.PI_LENS_CONSOLE_GUARD === "0")
+        return false;
+    consoleGuardInstalled = true;
+    const target = console;
+    for (const method of CONSOLE_METHODS) {
+        if (typeof target[method] !== "function")
+            continue;
+        target[method] = (...args) => {
+            logExtension({
+                subsystem: "console",
+                level: method === "warn" ? "warn" : method === "error" ? "error" : "debug",
+                message: formatConsoleArgs(args),
+                metadata: { method },
+            });
+        };
+    }
+    return true;
+}
+/** Test-only: forget that the guard was installed. */
+export function _resetConsoleGuardForTests() {
+    consoleGuardInstalled = false;
+}

package/node_modules/pi-lens/dist/clients/extension-mode.js

@@ -0,0 +1,73 @@
+/**
+ * Host run-mode awareness (#1334 S2).
+ *
+ * pi tells every extension which mode it is running in — verified against the
+ * pinned host types (`@earendil-works/pi-coding-agent/dist/core/extensions/
+ * types.d.ts`):
+ *
+ *   export type ExtensionMode = "tui" | "rpc" | "json" | "print";   // line 208
+ *   interface ExtensionContext { mode: ExtensionMode; hasUI: boolean; … }
+ *                                                       // lines 212-215
+ *
+ * The host's own comment on `mode` is the contract this module encodes:
+ * *"Use `"tui"` to guard terminal-only UI such as custom components."*
+ *
+ * pi-lens previously derived terminal ownership from nothing at all — it
+ * mounted its widget and chattered through `ui.notify` in every mode, including
+ * `print` and `json`, where the process is a one-shot producing machine- or
+ * pipe-consumed output and there is no live TUI to render into.
+ *
+ * Two independent questions, deliberately NOT the same predicate:
+ *
+ *   - *Is there a TUI to mount a custom component into?* Only `"tui"`. `rpc`
+ *     has `hasUI: true` (dialogs work over the protocol) but no terminal
+ *     component surface, so the widget must not mount there either.
+ *   - *Should proactive chatter reach the human?* No in `print` and `json` —
+ *     one-shot/machine output. Yes in `tui` and `rpc`.
+ *
+ * This is complementary to, and independent of, the #1338/#1333 console guard:
+ * that establishes "never write raw to the terminal"; this decides whether the
+ * HOST's own render path should be used at all in a given mode.
+ *
+ * Stateless by design: `mode` lives on the ctx pi hands to every event and
+ * command handler, so each call site reads it from the ctx it already has —
+ * no latched global to go stale across a session replacement.
+ */
+const KNOWN_MODES = new Set(["tui", "rpc", "json", "print"]);
+/**
+ * Feature-detected read of `ctx.mode`.
+ *
+ * Returns `"unknown"` for a host that predates the field, or for any value
+ * outside the four documented modes (a future pi may add one; treating an
+ * unrecognized mode as "unknown" keeps current behavior rather than guessing
+ * a suppression that could hide output).
+ */
+export function readExtensionMode(ctx) {
+    try {
+        const mode = ctx?.mode;
+        if (typeof mode !== "string" || !KNOWN_MODES.has(mode))
+            return "unknown";
+        return mode;
+    }
+    catch {
+        return "unknown";
+    }
+}
+/**
+ * Whether a terminal-only custom component (the pi-lens diagnostics widget) can
+ * be mounted. `"unknown"` mounts — older hosts must behave exactly as before.
+ */
+export function supportsTuiWidget(mode) {
+    return mode === "tui" || mode === "unknown";
+}
+/**
+ * Whether proactive `ui.notify` chatter should be suppressed (logged only).
+ * True only for the two non-interactive one-shot modes.
+ */
+export function suppressesUserNotify(mode) {
+    return mode === "print" || mode === "json";
+}
+/** Short human-readable reason for a suppression, for the ndjson/debug log. */
+export function modeSuppressionNote(mode) {
+    return `suppressed in "${mode}" mode (no interactive TUI)`;
+}

package/node_modules/pi-lens/dist/clients/file-kinds.js

@@ -88,6 +88,9 @@ export const KIND_EXTENSIONS = {
         ".hs",
         ".lhs",
     ],
+    "helm-template": [
+        ".tpl",
+    ],
     html: [
         ".htm",
         ".html",
@@ -169,6 +172,7 @@ export const KIND_EXTENSIONS = {
         ".tf",
         ".tfvars",
     ],
+    terragrunt: [],
     toml: [
         ".toml",
     ],
@@ -181,6 +185,36 @@ export const KIND_EXTENSIONS = {
         ".zon",
     ],
 };
+/** Return whether a path has an extension registered for the given file kind. */
+export function hasKindExtension(filePath, kind) {
+    const extension = extname(filePath).toLowerCase();
+    return KIND_EXTENSIONS[kind].some((candidate) => candidate === extension);
+}
+// Fact providers intentionally stay on the ordinary JS/TS source extensions.
+// Vue/Svelte files are classified as jsts for project-wide discovery, but their
+// embedded-language contents are not valid inputs for these tree-sitter facts.
+// Keep that one policy decision here so the function and import providers agree.
+const JSTS_FACT_EXTENSIONS = new Set(KIND_EXTENSIONS.jsts.filter((extension) => ![".vue", ".svelte"].includes(extension)));
+/** Whether the JS/TS fact providers should parse this path. */
+export function isJstsFactFile(filePath) {
+    return JSTS_FACT_EXTENSIONS.has(extname(filePath).toLowerCase());
+}
+// Bash access tracking also accepts common text/config files which do not have
+// a semantic FileKind. Every source extension is derived from KIND_EXTENSIONS;
+// only this explicit legacy text/config allowlist lives outside that registry.
+const NON_KIND_READABLE_EXTENSIONS = new Set([
+    ".txt",
+    ".env",
+    ".cfg",
+    ".conf",
+    ".ini",
+    ".xml",
+]);
+/** Whether bash file-access parsing should treat a path as source-like. */
+export function isReadableSourceFile(filePath) {
+    const extension = extname(filePath).toLowerCase();
+    return (Object.keys(KIND_EXTENSIONS).some((kind) => hasKindExtension(filePath, kind)) || NON_KIND_READABLE_EXTENSIONS.has(extension));
+}
 // --- Shared Project Root Markers ---
 /**
  * .NET project/solution root-marker globs (refs #895). Single source of truth
@@ -200,6 +234,19 @@ export const DOTNET_FSHARP_ROOT_MARKERS = [
     "*.fsproj",
     "*.sln",
 ];
+/**
+ * Terragrunt's unit/root entrypoint filenames, lowercase. Single source of truth
+ * for every subsystem that has to agree on what counts as a terragrunt file —
+ * SPECIAL_FILENAMES below, tool-policy.ts's linter and formatter policies,
+ * formatters.ts's terragruntHclFormatter, and language-profile.ts's project/root
+ * markers. Same rule as the .NET markers above: never hand-copy this list at a
+ * call site. tests/clients/terragrunt-filenames.test.ts asserts every consumer
+ * honors every name here, so a drifting call site fails CI.
+ */
+export const TERRAGRUNT_FILENAMES = [
+    "terragrunt.hcl",
+    "root.hcl",
+];
 // Reverse map: extension → file kind (for fast lookup)
 const EXT_TO_KIND = new Map();
 for (const [kind, exts] of Object.entries(KIND_EXTENSIONS)) {
@@ -218,6 +265,10 @@ const SPECIAL_FILENAMES = [
     { pattern: /^CMakeLists\.txt$/i, kind: "cmake" },
     { pattern: /^Makefile$/i, kind: "shell" },
     { pattern: /^Dockerfile(\.\w+)?$/i, kind: "docker" },
+    ...TERRAGRUNT_FILENAMES.map((name) => ({
+        pattern: new RegExp(`^${name.replaceAll(".", "\\.")}$`, "i"),
+        kind: "terragrunt",
+    })),
 ];
 // --- Detection Functions ---
 /**
@@ -294,6 +345,7 @@ export const CODE_KINDS = new Set([
     "gleam",
     "go",
     "haskell",
+    "helm-template",
     "java",
     "jsts",
     "kotlin",
@@ -310,6 +362,7 @@ export const CODE_KINDS = new Set([
     "sql",
     "swift",
     "terraform",
+    "terragrunt",
     "zig",
 ]);
 /** Data/doc/markup/config kinds — still enumerated (that's #894's point), but
@@ -376,11 +429,13 @@ export function getFileKindLabel(kind) {
         lua: "Lua",
         zig: "Zig",
         haskell: "Haskell",
+        "helm-template": "Helm template",
         elixir: "Elixir",
         gleam: "Gleam",
         ocaml: "OCaml",
         clojure: "Clojure",
         terraform: "Terraform",
+        terragrunt: "Terragrunt",
         nix: "Nix",
         toml: "TOML",
     };
@@ -444,11 +499,13 @@ export function getLanguageId(kind) {
         lua: "lua",
         zig: "zig",
         haskell: "haskell",
+        "helm-template": "helm",
         elixir: "elixir",
         gleam: "gleam",
         ocaml: "ocaml",
         clojure: "clojure",
         terraform: "terraform",
+        terragrunt: "terragrunt",
         nix: "nix",
         toml: "toml",
     };

package/node_modules/pi-lens/dist/clients/file-role.js

@@ -5,8 +5,9 @@
  * can skip checks that don't apply (e.g. no complexity checks on generated
  * files, no logic-density checks on re-export barrels).
  */
-import { basename, dirname } from "node:path";
+import { basename, dirname, win32 } from "node:path";
 import { isGeneratedOrArtifact } from "./generated-artifacts.js";
+import { isWindowsPath } from "./path-utils.js";
 // --- Detection ---
 const RE_EXPORT_LINE = /^export\s+(type\s+)?\*\s+from\s+|^export\s*\{[^}]*\}\s+from\s+/;
 function isReExportBarrel(content) {
@@ -36,10 +37,24 @@ function isTypeStub(content) {
 /**
  * Classify the structural role of a file. Pass `content` for higher
  * accuracy (enables generated-code detection, barrel detection, etc.).
+ *
+ * `detectFileRole` is platform-native by design — normal same-OS paths
+ * (POSIX on Linux, win32 on Windows) go through the module-default
+ * `basename`/`dirname`, unchanged from before. But a WINDOWS-SHAPED path
+ * (drive letter or UNC prefix, per `isWindowsPath`) is parsed with
+ * `path.win32.basename`/`dirname` regardless of the running OS (refs #1152,
+ * the #1150 class): on Linux the module-default `dirname` finds no `/` in a
+ * `C:\...` path, collapses to `"."`, and the dir-based branches below
+ * (`/tests/`, `/spec/`, …) silently misclassify. On win32 this branch is a
+ * no-op — `win32.basename`/`dirname` already equal the module default there
+ * — so native Windows classification is unchanged.
  */
 export function detectFileRole(filePath, content) {
-    const base = basename(filePath).toLowerCase();
-    const dir = dirname(filePath).replace(/\\/g, "/").toLowerCase();
+    const windowsShaped = isWindowsPath(filePath);
+    const base = (windowsShaped ? win32.basename(filePath) : basename(filePath)).toLowerCase();
+    const dir = (windowsShaped ? win32.dirname(filePath) : dirname(filePath))
+        .replace(/\\/g, "/")
+        .toLowerCase();
     // --- Test ---
     if (base.includes(".test.") ||
         base.includes(".spec.") ||

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

@@ -265,11 +265,19 @@ function buildProjectIgnoreMatcher(resolvedRoot, patterns) {
     const patternsForDir = (dir) => {
         if (dir === resolvedRoot)
             return patterns;
-        const gitignoreMtime = gitignoreMtimeMs(dir);
-        const pilensMtime = findPiLensConfigInDir(dir)?.mtimeMs ?? -1;
+        const gitignoreSig = gitignoreSignature(dir);
+        // #1105: gate on size too. `findPiLensConfigInDir` returns `size` alongside
+        // `mtimeMs` (both from one stat), and `gitignoreSignature` reads both for
+        // the nested `.gitignore`, so an mtime-preserving, length-changing edit to
+        // EITHER nested source can no longer replay stale patterns for this subtree.
+        const pilensInfo = findPiLensConfigInDir(dir);
+        const pilensMtime = pilensInfo?.mtimeMs ?? -1;
+        const pilensSize = pilensInfo?.size ?? -1;
         const cached = nestedCache.get(dir);
-        if (cached?.gitignoreMtimeMs === gitignoreMtime &&
-            cached?.pilensMtimeMs === pilensMtime) {
+        if (cached?.gitignoreMtimeMs === gitignoreSig.mtimeMs &&
+            cached?.gitignoreSize === gitignoreSig.size &&
+            cached?.pilensMtimeMs === pilensMtime &&
+            cached?.pilensSize === pilensSize) {
             return cached.patterns;
         }
         const nestedConfig = loadPiLensConfigInDir(dir);
@@ -278,15 +286,17 @@ function buildProjectIgnoreMatcher(resolvedRoot, patterns) {
             ...parseGitignoreContent(nestedConfig.ignore.join("\n"), "pilens"),
         ];
         nestedCache.set(dir, {
-            gitignoreMtimeMs: gitignoreMtime,
+            gitignoreMtimeMs: gitignoreSig.mtimeMs,
+            gitignoreSize: gitignoreSig.size,
             pilensMtimeMs: pilensMtime,
+            pilensSize: pilensSize,
             patterns: nextPatterns,
         });
         return nextPatterns;
     };
     // Per-matcher path → pattern-verdict memo. The matcher itself is cached by
-    // `getProjectIgnoreMatcher` keyed on `.gitignore` mtime, so this Map's
-    // lifetime is bounded to a single set of ignore rules — when any
+    // `getProjectIgnoreMatcher` keyed on `.gitignore` size+mtime (#1105), so this
+    // Map's lifetime is bounded to a single set of ignore rules — when any
     // `.gitignore` changes, the matcher is rebuilt and the memo is dropped
     // with it. Without this memo, every background scan (comment scan, knip,
     // jscpd, call-graph, source-filter, pipeline) recomputes O(ancestorDirs ×
@@ -402,26 +412,20 @@ export function createProjectIgnoreMatcher(rootDir, extraPatterns = [], globalPa
     return buildProjectIgnoreMatcher(resolvedRoot, patterns);
 }
 const projectIgnoreMatcherCache = new Map();
-/**
- * mtime of the global `~/.pi-lens/config.json` (or the PI_LENS_CONFIG_PATH
- * override). Part of the ignore-matcher cache key so editing global ignore
- * patterns takes effect without a restart (#252). -1 when absent.
- */
-function globalConfigMtimeMs() {
+function fileFreshnessSignature(filePath) {
     try {
-        return fs.statSync(getPiLensGlobalConfigPath()).mtimeMs;
+        const stat = fs.statSync(filePath);
+        return { mtimeMs: stat.mtimeMs, size: stat.size };
     }
     catch {
-        return -1;
+        return { mtimeMs: -1, size: -1 };
     }
 }
-function gitignoreMtimeMs(rootDir) {
-    try {
-        return fs.statSync(path.join(rootDir, ".gitignore")).mtimeMs;
-    }
-    catch {
-        return -1;
-    }
+function globalConfigSignature() {
+    return fileFreshnessSignature(getPiLensGlobalConfigPath());
+}
+function gitignoreSignature(rootDir) {
+    return fileFreshnessSignature(path.join(rootDir, ".gitignore"));
 }
 /**
  * The project config file found by the same upward walk as the loader. Cache
@@ -432,32 +436,39 @@ function gitignoreMtimeMs(rootDir) {
 function lensConfigInfo(rootDir) {
     const info = findPiLensProjectConfig(rootDir);
     return info
-        ? { info, path: info.path, mtimeMs: info.mtimeMs }
-        : { info, path: undefined, mtimeMs: -1 };
+        ? { info, path: info.path, mtimeMs: info.mtimeMs, size: info.size }
+        : { info, path: undefined, mtimeMs: -1, size: -1 };
 }
 export function getProjectIgnoreMatcher(rootDir) {
     const resolvedRoot = resolveGitIgnoreRoot(rootDir);
-    const gitignoreMtime = gitignoreMtimeMs(resolvedRoot);
+    const gitignoreSig = gitignoreSignature(resolvedRoot);
     const lensConfig = lensConfigInfo(resolvedRoot);
-    const globalMtime = globalConfigMtimeMs();
+    const globalSig = globalConfigSignature();
     const cached = projectIgnoreMatcherCache.get(resolvedRoot);
-    if (cached?.gitignoreMtimeMs === gitignoreMtime &&
+    if (cached?.gitignoreMtimeMs === gitignoreSig.mtimeMs &&
+        cached?.gitignoreSize === gitignoreSig.size &&
         cached?.lensConfigPath === lensConfig.path &&
         cached?.lensConfigMtimeMs === lensConfig.mtimeMs &&
-        cached?.globalConfigMtimeMs === globalMtime) {
+        cached?.lensConfigSize === lensConfig.size &&
+        cached?.globalConfigMtimeMs === globalSig.mtimeMs &&
+        cached?.globalConfigSize === globalSig.size) {
         return cached.matcher;
     }
     // Load both configs fresh on cache miss. On a cache HIT (the common case)
-    // none of this runs — the only per-call cost is the mtime stats above. The
-    // project loader is itself mtime-cached; the global loader re-parses, but
-    // only here on miss (when some tracked mtime changed).
+    // none of this runs — the only per-call cost is the size:mtimeMs stats above
+    // (size is free from the same stat). The project loader is itself
+    // size:mtimeMs-cached; the global loader re-parses, but only here on miss
+    // (when some tracked signature changed).
     const projectConfig = loadPiLensProjectConfig(resolvedRoot, lensConfig.info);
     const matcher = createProjectIgnoreMatcher(resolvedRoot, projectConfig.ignore, getGlobalIgnorePatterns());
     projectIgnoreMatcherCache.set(resolvedRoot, {
-        gitignoreMtimeMs: gitignoreMtime,
+        gitignoreMtimeMs: gitignoreSig.mtimeMs,
+        gitignoreSize: gitignoreSig.size,
         lensConfigPath: lensConfig.path,
         lensConfigMtimeMs: lensConfig.mtimeMs,
-        globalConfigMtimeMs: globalMtime,
+        lensConfigSize: lensConfig.size,
+        globalConfigMtimeMs: globalSig.mtimeMs,
+        globalConfigSize: globalSig.size,
         matcher,
     });
     return matcher;
@@ -465,10 +476,21 @@ export function getProjectIgnoreMatcher(rootDir) {
 export function isPathIgnoredByProject(filePath, rootDir, isDirectory = false) {
     return getProjectIgnoreMatcher(rootDir).isIgnored(filePath, isDirectory);
 }
+const projectIgnoreGlobsCache = new Map();
 export function getProjectIgnoreGlobs(rootDir) {
-    return readGitignorePatterns(rootDir)
+    const resolvedRoot = path.resolve(rootDir);
+    const signature = gitignoreSignature(resolvedRoot);
+    const cached = projectIgnoreGlobsCache.get(resolvedRoot);
+    if (cached &&
+        cached.mtimeMs === signature.mtimeMs &&
+        cached.size === signature.size) {
+        return cached.globs;
+    }
+    const globs = readGitignorePatterns(resolvedRoot)
         .filter((pattern) => !pattern.negated)
         .flatMap((pattern) => expandGitignorePattern(pattern));
+    projectIgnoreGlobsCache.set(resolvedRoot, { ...signature, globs });
+    return globs;
 }
 /**
  * Read simple directory-name entries from a root .gitignore.