@herbertgao/pi-extensions 2026.8.6 → 2026.8.7

package/node_modules/pi-lens/dist/clients/project-diagnostics/fresh-fetch.js

@@ -82,11 +82,14 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { applyDispositionsMultiFile } from "../diagnostic-dispositions.js";
 import { getKnipIgnorePatterns } from "../file-utils.js";
 import { isAtOrAboveHomeDir } from "../path-utils.js";
 import { GitleaksClient } from "../gitleaks-client.js";
 import { GovulncheckClient } from "../govulncheck-client.js";
+import { isToolInstallAllowedByTrust, projectTrustDenialReason, } from "../project-trust.js";
 import { TrivyClient } from "../trivy-client.js";
+import { reasonFromAvailabilityVerdict } from "./extractors.js";
 import { deadCodeResultToProjectDiagnostics } from "./runner-adapters/dead-code.js";
 import { gitleaksResultToProjectDiagnostics } from "./runner-adapters/gitleaks.js";
 import { govulncheckResultToProjectDiagnostics } from "./runner-adapters/govulncheck.js";
@@ -141,11 +144,13 @@ export async function fetchFreshProjectDiagnostics(cacheManager, cwd, clients, s
     // / review-graph's buildOrUpdateGraph; like the latter, there is no safe
     // substitute root to fall back to — the caller's `paths` scope only filters
     // REPORTED results, it never narrows what these analyzers walk.
+    const unsafeRootReason = "the working directory resolves at or above the home directory; heavyweight analyzers refuse to walk from there (#747)";
     if (isAtOrAboveHomeDir(analysisRoot, options.homeDir)) {
         return {
             diagnostics: [],
             runners: [],
             cold: [...ANALYZER_IDS],
+            coldReasons: Object.fromEntries(ANALYZER_IDS.map((id) => [id, unsafeRootReason])),
             failed: [],
             timings: {},
             unsafeRoot: true,
@@ -154,13 +159,46 @@ export async function fetchFreshProjectDiagnostics(cacheManager, cwd, clients, s
     const diagnostics = [];
     const runners = [];
     const cold = [];
+    // #1623: the specific reason each `cold` id was skipped, captured at the
+    // gate that decided it — see FreshProjectDiagnosticsResult.coldReasons.
+    const coldReasons = {};
     const failed = [];
     const timings = {};
+    // #1623: ms-old each id's data was when this call read it, for lanes that
+    // are cache-reads by design (currently only test-runner — see its task
+    // below) rather than a fresh execution this call. Absent for every other
+    // key: this module's other lanes always trigger-or-join a genuine run
+    // when attempted (see the module header), so there is nothing to date.
+    const cachedAgeMs = {};
     const settledIds = new Set();
+    let dispositionSuppressed = 0;
+    const dispositionSuppressedByLane = {};
+    // #1617: this is the ONE choke point every analyzer's findings pass
+    // through on the way into `diagnostics`, so applying the agent/user
+    // disposition filter HERE covers the whole mode=full class (knip/jscpd/
+    // madge/gitleaks/govulncheck/opengrep/trivy/dead-code) in one place — the
+    // same anchor derivation `dispatcher.ts:924` uses, via
+    // `applyDispositionsMultiFile` (`diagnostic-dispositions.ts`), not a
+    // second cloned filter. Unlike the dispatch path's one-file-at-a-time
+    // shape, a project-wide scan's findings span many files, so this groups by
+    // each diagnostic's own `filePath` and reads each file's current content
+    // once — see that function's doc for the fail-open contract when a file
+    // can't be read.
+    function markCold(id, reason) {
+        pushUnique(cold, id);
+        coldReasons[id] = reason;
+    }
     function record(id, adapted, elapsedMs) {
         timings[id] = (timings[id] ?? 0) + elapsedMs;
-        if (adapted.length > 0) {
-            diagnostics.push(...adapted);
+        const kept = applyDispositionsMultiFile(adapted, analysisRoot, (d) => d.filePath);
+        const suppressedHere = adapted.length - kept.length;
+        dispositionSuppressed += suppressedHere;
+        if (suppressedHere > 0) {
+            dispositionSuppressedByLane[id] =
+                (dispositionSuppressedByLane[id] ?? 0) + suppressedHere;
+        }
+        if (kept.length > 0) {
+            diagnostics.push(...kept);
             pushUnique(runners, id);
         }
     }
@@ -194,7 +232,7 @@ export async function fetchFreshProjectDiagnostics(cacheManager, cwd, clients, s
         // detection, exactly mirroring session_start's own logic.
         task("jscpd", async () => {
             if (!(await clients.jscpdClient.ensureAvailable())) {
-                cold.push("jscpd");
+                markCold("jscpd", reasonFromAvailabilityVerdict("jscpd", clients.jscpdClient.getAvailabilityVerdict?.()));
                 return;
             }
             const isTsProject = fs.existsSync(path.join(analysisRoot, "tsconfig.json"));
@@ -213,7 +251,7 @@ export async function fetchFreshProjectDiagnostics(cacheManager, cwd, clients, s
         // madge — circular-dependency detection.
         task("madge", async () => {
             if (!(await clients.depChecker.ensureAvailable())) {
-                cold.push("madge");
+                markCold("madge", reasonFromAvailabilityVerdict("madge", clients.depChecker.getAvailabilityVerdict?.()));
                 return;
             }
             const startMs = Date.now();
@@ -234,11 +272,11 @@ export async function fetchFreshProjectDiagnostics(cacheManager, cwd, clients, s
         // "cold" on a project with no explicit gitleaks config.
         task("gitleaks", async () => {
             if (!GitleaksClient.hasGitRepo(analysisRoot)) {
-                cold.push("gitleaks");
+                markCold("gitleaks", "not a git repository (no .git found)");
                 return;
             }
             if (!(await clients.gitleaksClient.ensureAvailable())) {
-                cold.push("gitleaks");
+                markCold("gitleaks", reasonFromAvailabilityVerdict("gitleaks", clients.gitleaksClient.getAvailabilityVerdict?.()));
                 return;
             }
             const startMs = Date.now();
@@ -257,11 +295,22 @@ export async function fetchFreshProjectDiagnostics(cacheManager, cwd, clients, s
         // govulncheck — Go module CVE detection. Go-module-gated per #132.
         task("govulncheck", async () => {
             if (!GovulncheckClient.hasGoModule(analysisRoot)) {
-                cold.push("govulncheck");
+                markCold("govulncheck", "no go.mod found (not a Go module)");
                 return;
             }
             if (!(await clients.govulncheckClient.ensureAvailable())) {
-                cold.push("govulncheck");
+                // #1623 fix-round F1: `GovulncheckClient.doEnsureAvailable` has a
+                // branch (`assertInstallAllowed`, govulncheck-client.ts) that returns
+                // false WITHOUT ever touching its availability latch — a
+                // project-trust install denial, deliberately not latched so a later
+                // trust grant can retry (see that file's own comment). The latch's
+                // verdict is genuinely absent in that case, not merely unread, so
+                // check trust denial FIRST via the same taxonomy project-trust.ts
+                // already exposes, and only fall back to the probe-based verdict
+                // (a real timeout/absence) when trust isn't the reason.
+                markCold("govulncheck", isToolInstallAllowedByTrust()
+                    ? reasonFromAvailabilityVerdict("govulncheck", clients.govulncheckClient.getAvailabilityVerdict?.())
+                    : (projectTrustDenialReason() ?? "govulncheck binary unavailable"));
                 return;
             }
             const startMs = Date.now();
@@ -291,7 +340,7 @@ export async function fetchFreshProjectDiagnostics(cacheManager, cwd, clients, s
         // `lens_diagnostics mode=full` — the honesty gap (#533) this task closes.
         task("opengrep", async () => {
             if (!(await clients.opengrepClient.ensureAvailable())) {
-                cold.push("opengrep");
+                markCold("opengrep", reasonFromAvailabilityVerdict("opengrep", clients.opengrepClient.getAvailabilityVerdict?.()));
                 return;
             }
             const startMs = Date.now();
@@ -308,11 +357,11 @@ export async function fetchFreshProjectDiagnostics(cacheManager, cwd, clients, s
         // trivy — dependency CVE detection. Explicit opt-in per #131.
         task("trivy", async () => {
             if (!TrivyClient.shouldScan(analysisRoot)) {
-                cold.push("trivy");
+                markCold("trivy", "not opted in (.pi-lens.json trivy.enabled) or no dependency manifest found");
                 return;
             }
             if (!(await clients.trivyClient.ensureAvailable())) {
-                cold.push("trivy");
+                markCold("trivy", reasonFromAvailabilityVerdict("trivy", clients.trivyClient.getAvailabilityVerdict?.()));
                 return;
             }
             const startMs = Date.now();
@@ -332,7 +381,7 @@ export async function fetchFreshProjectDiagnostics(cacheManager, cwd, clients, s
         task("dead-code", async () => {
             const applicable = clients.deadCodeClients.filter((c) => c.detect(analysisRoot));
             if (applicable.length === 0) {
-                cold.push("dead-code");
+                markCold("dead-code", "no dead-code client detected an applicable language for this project");
                 return;
             }
             await Promise.all(applicable.map(async (client) => {
@@ -380,9 +429,16 @@ export async function fetchFreshProjectDiagnostics(cacheManager, cwd, clients, s
             const startMs = Date.now();
             const cached = cacheManager.readCache("test-runner-findings", analysisRoot);
             if (!cached?.data) {
-                cold.push("test-runner");
+                markCold("test-runner", "no turn_end test-runner cache entry yet this session");
                 return;
             }
+            // #1623: unlike every other lane in this module, test-runner is a
+            // cache-read BY DESIGN (see the task's own header comment above) — it
+            // never performs a fresh run this call, so its age must be surfaced
+            // the same way a genuinely-stale cache read would be, rather than
+            // looking indistinguishable from a lane that just executed.
+            cachedAgeMs["test-runner"] =
+                Date.now() - new Date(cached.meta.timestamp).getTime();
             record("test-runner", testRunnerFindingsToProjectDiagnostics(cached.data, analysisRoot, options.runtime), Date.now() - startMs);
         }),
     ];
@@ -414,11 +470,25 @@ export async function fetchFreshProjectDiagnostics(cacheManager, cwd, clients, s
             diagnostics,
             runners,
             cold,
+            coldReasons,
             failed,
             timings,
+            cachedAgeMs,
             aborted: true,
             abortedIds,
+            dispositionSuppressed,
+            dispositionSuppressedByLane,
         };
     }
-    return { diagnostics, runners, cold, failed, timings };
+    return {
+        diagnostics,
+        runners,
+        cold,
+        coldReasons,
+        failed,
+        timings,
+        cachedAgeMs,
+        dispositionSuppressed,
+        dispositionSuppressedByLane,
+    };
 }

package/node_modules/pi-lens/dist/clients/project-diagnostics/runner-adapters/gitleaks.js

@@ -2,19 +2,31 @@ import * as path from "node:path";
 /**
  * A gitleaks finding is a leaked secret at a concrete `file:startLine`. Secrets
  * are treated as **blocking** — a committed credential is not a style nit.
+ *
+ * Exception: `pathStatus: "scratch"` (#1562 review-round F2) — a finding
+ * `classifyAndFilterFindings` demoted rather than dropped, so the observability
+ * criterion ("record carries tracked/ignored/scratch status") stays honest
+ * about a fourth REACHABLE value instead of silently deleting it. Demoted to
+ * `severity: "info"`/`semantic: "none"` so it can never read as a blocking
+ * "leaked secret" alarm, while remaining visible for an audit read.
  */
 export function gitleaksFindingToProjectDiagnostic(cwd, finding) {
+    // #1562 observability criterion: surface the git status right in the
+    // finding's message so a triage is a read, not a re-derivation. Omitted
+    // when git itself degraded (`pathStatus` undefined) rather than guessed.
+    const statusSuffix = finding.pathStatus ? ` [git: ${finding.pathStatus}]` : "";
+    const isScratch = finding.pathStatus === "scratch";
     return {
         filePath: path.isAbsolute(finding.file)
             ? finding.file
             : path.resolve(cwd, finding.file),
         line: finding.startLine,
-        severity: "error",
-        semantic: "blocking",
+        severity: isScratch ? "info" : "error",
+        semantic: isScratch ? "none" : "blocking",
         tool: "gitleaks",
         runner: "gitleaks",
         rule: `gitleaks:${finding.ruleId}`,
-        message: `Potential secret: ${finding.description || finding.ruleId}`,
+        message: `Potential secret: ${finding.description || finding.ruleId}${statusSuffix}`,
         source: "project-scan",
     };
 }

package/node_modules/pi-lens/dist/clients/project-diagnostics/runner-adapters/trivy.js

@@ -24,8 +24,56 @@ export function trivyFindingToProjectDiagnostic(cwd, finding) {
         source: "project-scan",
     };
 }
+/**
+ * A trivy *secret* finding (`TrivyResult.secrets`) is a leaked credential at a
+ * concrete `file:line` — the trivy-scanned sibling of
+ * `gitleaksFindingToProjectDiagnostic`, and treated the same way: **blocking**,
+ * since a committed credential is not a style nit.
+ *
+ * Rule id is namespaced `trivy-secret:<ruleId>`, deliberately distinct from the
+ * CVE lane's `trivy:<vulnerabilityId>` (#1628) — trivy's own rule-id spaces for
+ * secrets and CVEs are independent, so without this prefix a secret rule id
+ * could collide with a vulnerability id and silently share (or steal) that
+ * finding's disposition anchor.
+ */
+export function trivySecretFindingToProjectDiagnostic(cwd, finding) {
+    return {
+        filePath: path.isAbsolute(finding.file)
+            ? finding.file
+            : path.resolve(cwd, finding.file),
+        line: finding.line,
+        severity: "error",
+        semantic: "blocking",
+        tool: "trivy",
+        runner: "trivy",
+        rule: `trivy-secret:${finding.ruleId}`,
+        message: `Potential secret: ${finding.title || finding.ruleId}`,
+        source: "project-scan",
+    };
+}
+function trivySecretsToProjectDiagnostics(cwd, secrets) {
+    return secrets.map((finding) => trivySecretFindingToProjectDiagnostic(cwd, finding));
+}
+/**
+ * Adapts BOTH of trivy's finding kinds from one scan pass — CVEs (`findings`)
+ * and secrets (`secrets`, #1628) — into the single `ProjectDiagnostic[]`
+ * `lens_diagnostics mode=full` surfaces. Before #1628, `secrets` was silently
+ * unread here: a trivy-only secret (no gitleaks/ast-grep corroboration) had no
+ * `lens_diagnostics`-visible identity at all for an agent to anchor a mark
+ * against, even though `runtime-turn.ts`'s turn_end gate already blocked on it.
+ */
 export function trivyResultToProjectDiagnostics(cwd, result) {
-    if (!result.success || result.findings.length === 0)
+    if (!result.success)
         return [];
-    return result.findings.map((finding) => trivyFindingToProjectDiagnostic(cwd, finding));
+    return [
+        ...(result.findings ?? []).map((finding) => trivyFindingToProjectDiagnostic(cwd, finding)),
+        // `secrets` defaults to `[]` here rather than assuming the field is
+        // always present: `fetchFreshProjectDiagnostics` swallows a task
+        // rejection into a silent "completed" outcome (its
+        // `.catch(() => "completed")`), so an unguarded `.map` on a missing
+        // field here would drop this lane's CVE diagnostics too, not just the
+        // secrets — a caller-visible regression for a field this adapter
+        // doesn't itself require.
+        ...trivySecretsToProjectDiagnostics(cwd, result.secrets ?? []),
+    ];
 }

package/node_modules/pi-lens/dist/clients/project-diagnostics/scanner.js

@@ -89,6 +89,11 @@ function fromDispatchDiagnostic(diagnostic, runner) {
  */
 async function scanFileMajorRules(cwd, files, signal) {
     const client = getSharedTreeSitterClient();
+    // #1715: grow the tree cache to span this scan's working set BEFORE
+    // parsing starts, so a project bigger than the interactive default (50
+    // entries) still gets cross-scan reuse instead of every file re-parsing
+    // on every scan.
+    client?.ensureTreeCacheCapacity(files.length);
     const treeSitterReady = !!client && client.isAvailable() && (await client.init());
     // Same singleton the dispatch runner uses (tree-sitter.ts:444) — memoized
     // per root, so repeated scans stop re-reading the ~180 query YAMLs.

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

@@ -84,6 +84,9 @@ const PROJECT_OWN_CONFIG_KEYS = [
     "maxProjectFiles",
     "reviewGraph",
     "trivy",
+    // `helm.renderValidation.enabled` — the opt-in for rendered-manifest
+    // validation, read via `.raw` in the helm-render runner (#1283).
+    "helm",
 ];
 /** Clamp bounds for `reviewGraph.maxFiles` — see the field's doc comment above. */
 const REVIEW_GRAPH_MAX_FILES_MIN = 100;

package/node_modules/pi-lens/dist/clients/project-snapshot.js

@@ -278,6 +278,257 @@ function readSnapshotBody(bodyPath, gz) {
         return { snapshot: null, rawBytes: 0 };
     }
 }
+/**
+ * Scan a JSON value starting at `start` (skipping any leading whitespace)
+ * and return the index one past its end. Handles strings, objects, arrays,
+ * and bare scalars (numbers/`true`/`false`/`null`) — correctly skipping
+ * nested strings/braces/brackets (respecting `\"` escapes) WITHOUT ever
+ * constructing a JS value for them. This is the primitive
+ * `stripTopLevelJsonKeys` (#1785 F5) is built on: `JSON.parse` has no way to
+ * skip a subtree's construction cost — a reviver only prunes the
+ * already-built result — so avoiding a field's parse cost requires never
+ * handing its text to `JSON.parse` in the first place.
+ */
+function skipJsonValue(text, start) {
+    let i = start;
+    while (i < text.length && /\s/.test(text[i]))
+        i++;
+    const ch = text[i];
+    if (ch === '"') {
+        i++;
+        while (i < text.length) {
+            if (text[i] === "\\") {
+                i += 2;
+                continue;
+            }
+            if (text[i] === '"') {
+                i++;
+                break;
+            }
+            i++;
+        }
+        return i;
+    }
+    if (ch === "{" || ch === "[") {
+        const open = ch;
+        const close = open === "{" ? "}" : "]";
+        let depth = 0;
+        let inString = false;
+        for (; i < text.length; i++) {
+            const c = text[i];
+            if (inString) {
+                if (c === "\\") {
+                    i++;
+                    continue;
+                }
+                if (c === '"')
+                    inString = false;
+                continue;
+            }
+            if (c === '"') {
+                inString = true;
+                continue;
+            }
+            if (c === open)
+                depth++;
+            else if (c === close) {
+                depth--;
+                if (depth === 0) {
+                    i++;
+                    break;
+                }
+            }
+        }
+        return i;
+    }
+    // A bare scalar (number/true/false/null): scan to the next structural
+    // character. Every snapshot value is one of the five JSON kinds above, so
+    // this branch only ever fires for those scalars.
+    while (i < text.length && !",}]".includes(text[i]))
+        i++;
+    return i;
+}
+/**
+ * Reconstruct a JSON object literal with the given top-level keys removed,
+ * without ever materializing their values as JS objects (#1785 F5). Used to
+ * excise the expensive fields — `wordIndex`'s postings graph above all,
+ * `files`/`symbols`/`reverseDeps` too — before `JSON.parse` ever sees them,
+ * so a caller that only needs a few small top-level fields (`seq`,
+ * `cachedExports`, `projectRulesScan`, …) doesn't pay to construct the
+ * fields it's about to discard. Correctness relies only on the writer
+ * (`JSON.stringify(snapshot)`, `clients/gzip-stage-write.ts`) never emitting
+ * pretty-printed/indented output — compact `JSON.stringify` output is what
+ * every persist path in this file produces.
+ */
+function stripTopLevelJsonKeys(text, keysToStrip) {
+    const objStart = text.indexOf("{");
+    if (objStart === -1)
+        return text;
+    let out = text.slice(0, objStart + 1);
+    let i = objStart + 1;
+    let wroteField = false;
+    while (i < text.length) {
+        while (i < text.length && /\s/.test(text[i]))
+            i++;
+        if (text[i] === "}" || i >= text.length) {
+            out += text.slice(i);
+            break;
+        }
+        if (text[i] === ",") {
+            i++;
+            continue;
+        }
+        const keyStart = i;
+        const keyTextEnd = skipJsonValue(text, keyStart);
+        let key;
+        try {
+            key = JSON.parse(text.slice(keyStart, keyTextEnd));
+        }
+        catch {
+            // Malformed key text — bail out to the untouched original rather
+            // than risk producing invalid JSON; the caller's own JSON.parse
+            // on the result will then fail loudly instead of silently.
+            return text;
+        }
+        let j = keyTextEnd;
+        while (j < text.length && /\s/.test(text[j]))
+            j++;
+        // text[j] is ':' for a well-formed object.
+        const valueStart = j + 1;
+        const valueEnd = skipJsonValue(text, valueStart);
+        if (!keysToStrip.has(key)) {
+            out += (wroteField ? "," : "") + text.slice(keyStart, valueEnd);
+            wroteField = true;
+        }
+        i = valueEnd;
+    }
+    return out;
+}
+/**
+ * Test-only direct access to the raw-text stripper (#1785 F5). Unlike
+ * asserting on `loadProjectSnapshotExportsAndRules`'s RETURN shape — which
+ * only proves the output omits the heavy fields, not that their parse cost
+ * was ever avoided (the function could strip nothing and still hand-pick 4
+ * fields out of a fully-parsed object) — this lets a test inspect the
+ * INTERMEDIATE text `JSON.parse` actually receives, which is the only way to
+ * prove the expensive fields' text never reached `JSON.parse` at all.
+ */
+export function _stripTopLevelJsonKeysForTests(text, keysToStrip) {
+    return stripTopLevelJsonKeys(text, new Set(keysToStrip));
+}
+// A fixed, 4-entry, import-time constant — not per-session accumulating
+// state, so it needs no session_start reset (counted in
+// tests/support/session-state-registry.ts's SESSION_STATE_SYMBOL_COUNTS
+// pin for "project-snapshot.ts", alongside the bounded digest hook below).
+//
+// Adding a key here? Add it to `NARROW_DIGEST_HEAVY_KEY_LITERALS` too (~40
+// lines down) — it's a DELIBERATELY separate, independent list (#1785 F7: a
+// digest that reads its own containsHeavyKey answer off THIS set can't
+// detect this set failing/emptying, so it must not).
+const HEAVY_SNAPSHOT_KEYS = new Set([
+    "wordIndex",
+    "files",
+    "symbols",
+    "reverseDeps",
+]);
+// #1785 F7 (review round 5): a FIXED LITERAL list, independent of
+// `HEAVY_SNAPSHOT_KEYS` — the digest below exists to detect a broken/emptied
+// `HEAVY_SNAPSHOT_KEYS`, so deriving `containsHeavyKey` from that same
+// constant makes the check vacuous by construction: empty the set and the
+// stripper strips nothing AND `[...HEAVY_SNAPSHOT_KEYS].some(...)` iterates
+// zero entries and reports `false` — the exact failure mode this hook exists
+// to catch, silently passing. Verified: with the shared-constant version,
+// emptying `HEAVY_SNAPSHOT_KEYS` left 38 tests green instead of red.
+const NARROW_DIGEST_HEAVY_KEY_LITERALS = [
+    "wordIndex",
+    "files",
+    "symbols",
+    "reverseDeps",
+];
+let _lastNarrowParseDigestForTests;
+export function getLastNarrowParseDigestForTests() {
+    return _lastNarrowParseDigestForTests;
+}
+export function resetLastNarrowParseDigestForTests() {
+    _lastNarrowParseDigestForTests = undefined;
+}
+function parseExportsAndRulesOnly(json) {
+    const narrowed = stripTopLevelJsonKeys(json, HEAVY_SNAPSHOT_KEYS);
+    _lastNarrowParseDigestForTests = {
+        length: narrowed.length,
+        containsHeavyKey: NARROW_DIGEST_HEAVY_KEY_LITERALS.some((key) => narrowed.includes(`"${key}":`)),
+    };
+    const parsed = JSON.parse(narrowed);
+    if (parsed.version !== PROJECT_SNAPSHOT_VERSION)
+        return null;
+    if (typeof parsed.seq !== "number")
+        return null;
+    if (!Array.isArray(parsed.cachedExports))
+        return null;
+    return {
+        version: PROJECT_SNAPSHOT_VERSION,
+        seq: parsed.seq,
+        cachedExports: parsed.cachedExports.filter((entry) => Array.isArray(entry) &&
+            typeof entry[0] === "string" &&
+            typeof entry[1] === "string"),
+        projectRulesScan: parsed.projectRulesScan,
+    };
+}
+function readSnapshotExportsAndRulesBody(bodyPath, gz) {
+    try {
+        const json = gz
+            ? gunzipSync(fs.readFileSync(bodyPath)).toString("utf-8")
+            : fs.readFileSync(bodyPath, "utf-8");
+        return parseExportsAndRulesOnly(json);
+    }
+    catch (err) {
+        logLatency({
+            type: "phase",
+            phase: "project_snapshot_body_corrupt",
+            filePath: bodyPath,
+            durationMs: 0,
+            metadata: {
+                error: err instanceof Error ? err.message : String(err),
+                narrow: true,
+            },
+        });
+        return null;
+    }
+}
+/**
+ * #1785 F5: a narrow counterpart to `loadProjectSnapshot` for callers that
+ * only need `seq`/`version`/`cachedExports`/`projectRulesScan` — critically,
+ * NOT `wordIndex`, `files`, `symbols`, or `reverseDeps`. The full
+ * `loadProjectSnapshot` (even `loadProjectSnapshotWithoutWordIndex`, which
+ * only strips the RETAINED copy AFTER a full parse) pays `gunzip` +
+ * `JSON.parse` for the ENTIRE body regardless — dominated by `wordIndex`'s
+ * postings graph (measured: +200ms warm / +700ms cold on a 29MB body,
+ * 209-278ms on this repo's own 16.7MB snapshot). This function excises the
+ * heavy fields from the raw text BEFORE parsing (`stripTopLevelJsonKeys`),
+ * so their construction cost is never paid at all; the remaining cost is
+ * dominated by `cachedExports` (typically a small array), not the postings.
+ *
+ * Consults the same in-process authoritative-write cache
+ * `loadProjectSnapshotInternal` does, for the same read-your-own-write
+ * reason — a save's in-memory object is cheap to narrow (no parse needed at
+ * all) and must win over a possibly-stale on-disk body exactly like the full
+ * loader.
+ */
+export function loadProjectSnapshotExportsAndRules(cwd) {
+    const key = normalizeMapKey(cwd);
+    const body = resolveSnapshotBodyPath(cwd);
+    const authoritative = authoritativeSnapshots.get(key);
+    if (authoritative) {
+        const diskMtime = body ? body.mtimeMs : Number.NEGATIVE_INFINITY;
+        if (diskMtime <= authoritative.knownMtime) {
+            const { version, seq, cachedExports, projectRulesScan } = authoritative.snapshot;
+            return { version, seq, cachedExports, projectRulesScan };
+        }
+    }
+    if (!body)
+        return null;
+    return readSnapshotExportsAndRulesBody(body.path, body.gz);
+}
 function loadProjectSnapshotInternal(cwd, requireWordIndex) {
     const key = normalizeMapKey(cwd);
     const body = resolveSnapshotBodyPath(cwd);
@@ -851,6 +1102,54 @@ export function hydrateRuntimeFromProjectSnapshot(runtime, snapshot) {
     }
     runtime.wordIndex = deserializeWordIndex(snapshot.wordIndex);
 }
+/**
+ * #1785 F2/F3: additive counterpart to `hydrateRuntimeFromProjectSnapshot`
+ * for a LATE/retroactive hydration attempt — one that runs after other work
+ * may already have populated the runtime for real (e.g. quick mode's
+ * background warmup building a genuine `wordIndex`, docCount > 0). The
+ * unconditional version above is only safe for the FIRST hydration attempt,
+ * made before anything else has run: clearing `cachedExports` is correct
+ * there because there is nothing yet to destroy.
+ *
+ * A late call cannot make that assumption, and `cachedExports` and
+ * `projectRulesScan` are populated by INDEPENDENT tasks from whatever else is
+ * running (nothing else in quick mode touches either), so this guards each
+ * field on its OWN "nothing computed since" check rather than one
+ * all-or-nothing bail-out — the field a concurrent task actually populated is
+ * protected without needlessly withholding the other, still-idle field the
+ * snapshot could still supply. Returns whether it hydrated ANY field, so the
+ * caller can log honestly instead of claiming success when nothing changed.
+ *
+ * #1785 F5: takes ONLY the narrow `{ cachedExports, projectRulesScan }`
+ * shape (see `ProjectSnapshotExportsAndRules`) — deliberately no `wordIndex`
+ * parameter at all, not even an optional one. The retroactive path's
+ * captured/reloaded snapshot always comes from
+ * `loadProjectSnapshotExportsAndRules`, which never parses `wordIndex` in
+ * the first place (avoiding its dominant share of a full body parse's cost —
+ * see that function's doc comment for the measured numbers). This is also
+ * the right behavior, not just a performance shortcut: quick mode's warmup
+ * is the only thing that ever builds a `wordIndex` in this window, and F2's
+ * hazard was this exact late-hydration path nulling that live index from a
+ * disk copy that predated it — removing the parameter removes the hazard by
+ * construction instead of merely guarding against it at runtime.
+ */
+export function hydrateRuntimeFromProjectSnapshotIfIdle(runtime, snapshot) {
+    let hydratedAnything = false;
+    if (runtime.cachedExports.size === 0 && snapshot.cachedExports.length > 0) {
+        runtime.cachedExports.clear();
+        for (const [name, filePath] of snapshot.cachedExports) {
+            runtime.cachedExports.set(name, filePath);
+        }
+        hydratedAnything = true;
+    }
+    if (!runtime.projectRulesScan.hasCustomRules &&
+        runtime.projectRulesScan.rules.length === 0 &&
+        snapshot.projectRulesScan) {
+        runtime.projectRulesScan = snapshot.projectRulesScan;
+        hydratedAnything = true;
+    }
+    return hydratedAnything;
+}
 export function saveRuntimeProjectSnapshot(args) {
     try {
         if (typeof args.runtime.projectSeq !== "number")