@herbertgao/pi-extensions 2026.8.5 → 2026.8.7

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

@@ -38,8 +38,15 @@ export function withDeadline(promise, options) {
     const onReject = options.onReject ?? "propagate";
     const ms = options.ms ??
         (options.deadlineAt !== undefined ? options.deadlineAt - Date.now() : 0);
-    // Past deadline / non-positive budget: settle immediately, no timer.
+    // Past deadline / non-positive budget: settle immediately, no timer. This
+    // branch returns before the race below ever runs, so — same reason as the
+    // loser-leg catch a few lines down — `promise` needs its own no-op catch
+    // here too: without it, a `promise` that eventually rejects (the caller
+    // already invoked it; this function only decides how long to wait on it)
+    // surfaces as an unhandled rejection instead of being silently superseded
+    // by the immediate timeout/undefined settlement.
     if (ms <= 0) {
+        promise.catch(() => { });
         return onTimeout === "undefined"
             ? Promise.resolve(undefined)
             : Promise.reject(new Error(`Timeout after ${Math.max(0, ms)}ms`));

package/node_modules/pi-lens/dist/clients/debug-handles.js

@@ -140,6 +140,11 @@ export function flushDebugHandlesLog() {
 }
 function safeGetActiveResourcesInfo() {
     try {
+        // SAFETY: `process.getActiveResourcesInfo` is a real Node API (>=17.3)
+        // that @types/node does not declare on `Process`. The cast only widens
+        // the type to say the method MIGHT be there; the `typeof fn ===
+        // "function"` guard on the next line is what actually decides, so a
+        // runtime without it returns [] rather than throwing.
         const fn = process.getActiveResourcesInfo;
         return typeof fn === "function" ? fn.call(process) : [];
     }

package/node_modules/pi-lens/dist/clients/degradation-ledger.js

@@ -1,11 +1,27 @@
 /** Bounded, process-local telemetry for behavior degraded during one session. */
 import { logExtension } from "./extension-log.js";
+import { LEDGER_FIELD_MAX, truncateForLedger } from "./ledger-bounds.js";
+import { logLatency } from "./latency-logger.js";
+// Re-exported so existing importers keep one name for the ledger's bound.
+export { LEDGER_FIELD_MAX, truncateForLedger };
 const ENTRIES_PER_KIND = 20;
 const MAX_DISTINCT_KINDS = 32;
 const OVERFLOW_KIND = "other";
 const groups = new Map();
 const onceKeys = new Set();
 const tallies = new Map();
+// Monotonic session-boundary counter (#1536 review F5): callers that keep
+// their OWN once-per-session latch outside the ledger (a per-instance Set
+// the ledger itself doesn't own) can compare this lazily at use time and
+// clear their latch on a mismatch — the same clear-on-transition shape as
+// project-trust.ts's trustGeneration, but keyed to the ledger's own reset
+// (resetDegradationLedger, wired into handleSessionStart) rather than a
+// trust change.
+let ledgerGeneration = 0;
+/** Current session generation. Bump on every `resetDegradationLedger()`. */
+export function getDegradationLedgerGeneration() {
+    return ledgerGeneration;
+}
 export function recordDegradation(record) {
     try {
         const kind = boundedKind(record.kind);
@@ -16,6 +32,7 @@ export function recordDegradation(record) {
             group = { count: 0, entries: [] };
             groups.set(kind, group);
         }
+        const admitted = group.entries.length < ENTRIES_PER_KIND;
         group.count += 1;
         // Bounded at RECORD time (#1366 review): reasons carry arbitrary error
         // text; a 10KB message must never become a 10KB health line or a 10KB
@@ -23,10 +40,12 @@ export function recordDegradation(record) {
         group.entries.push({ subject, reason });
         if (group.entries.length > ENTRIES_PER_KIND)
             group.entries.shift();
+        return admitted;
     }
     catch (error) {
         debugLedgerFailure("record", error);
         // Telemetry must never break the observed path.
+        return false;
     }
 }
 /** Record at most once per kind/subject during the current session. */
@@ -38,7 +57,9 @@ export function recordDegradationOnce(record) {
         if (onceKeys.has(key))
             return;
         onceKeys.add(key);
-        recordDegradation({ kind, subject, reason: record.reason });
+        if (recordDegradation({ kind, subject, reason: record.reason })) {
+            logDurableDegradation(kind, subject, 1);
+        }
     }
     catch (error) {
         debugLedgerFailure("record-once", error);
@@ -48,6 +69,14 @@ export function recordDegradationOnce(record) {
 /**
  * Count a repeated degradation while retaining one latest-reason entry per
  * kind/subject. The group count remains the exact event total.
+ *
+ * Returns `true` when this call is the FIRST occurrence recorded for this
+ * kind/subject pair (the ledger is the single source of truth for that
+ * tally already — via `tallies` — so callers that need a once-per-subject
+ * "rising edge" signal, e.g. to gate a verbose one-time log line before
+ * falling back to the bounded count, read it off this return value instead
+ * of hand-rolling their own parallel `Set`/latch). #1716 reuses this same
+ * signal to gate `navRequest`'s detailed timeout/late-answer log writes.
  */
 export function incrementDegradationCount(record) {
     try {
@@ -62,24 +91,49 @@ export function incrementDegradationCount(record) {
             group = { count: 0, entries: [] };
             groups.set(kind, group);
         }
-        group.count += 1;
-        const entry = { subject, reason: truncateForLedger(`${reason} (count: ${count})`) };
         const existing = group.entries.findIndex((candidate) => candidate.subject === subject);
+        const admitted = existing >= 0 || group.entries.length < ENTRIES_PER_KIND;
+        group.count += 1;
+        // #1816: append the count AFTER truncation, never before. `reason` is
+        // already bounded above, so re-truncating the concatenation pushed the
+        // suffix past LEDGER_FIELD_MAX and silently ate it — a 200-char reason
+        // lost the one field that says how often the degradation fired.
+        const entry = { subject, reason: `${reason} (count: ${count})` };
         if (existing >= 0)
             group.entries.splice(existing, 1);
         group.entries.push(entry);
         if (group.entries.length > ENTRIES_PER_KIND)
             group.entries.shift();
+        // Durable rows use the summary's admission and emit the first event and
+        // power-of-two milestones only, keeping the sink bounded.
+        if (admitted && isPowerOfTwo(count)) {
+            logDurableDegradation(kind, subject, count);
+        }
+        return count === 1;
     }
     catch (error) {
         debugLedgerFailure("increment", error);
         // Telemetry must never break the observed path.
+        return false;
     }
 }
-/** Detached snapshot, grouped in first-seen kind order. */
-const LEDGER_FIELD_MAX = 200;
-function normalizeForLedger(value) {
-    return String(value ?? "unknown");
+/**
+ * Persist the accepted ledger mutation through the existing rotated NDJSON
+ * latency stream. `logLatency` owns the timestamp, PID, serialization, secret
+ * redaction, and write queue. The subject and kind were already bounded by the
+ * ledger before reaching this seam.
+ */
+function logDurableDegradation(kind, subject, count) {
+    logLatency({
+        type: "phase",
+        phase: "degradation_ledger",
+        filePath: subject,
+        durationMs: 0,
+        metadata: { kind, subject, count, ledgerGeneration },
+    });
+}
+function isPowerOfTwo(value) {
+    return value > 0 && (value & (value - 1)) === 0;
 }
 function boundedKind(value) {
     const kind = truncateForLedger(value);
@@ -88,12 +142,6 @@ function boundedKind(value) {
     // Keep one slot available for all kinds beyond the cardinality bound.
     return groups.size < MAX_DISTINCT_KINDS - 1 ? kind : OVERFLOW_KIND;
 }
-function truncateForLedger(value) {
-    const text = normalizeForLedger(value);
-    return text.length > LEDGER_FIELD_MAX
-        ? `${text.slice(0, LEDGER_FIELD_MAX)}…`
-        : text;
-}
 export function getDegradationSummary() {
     return [...groups.entries()].map(([kind, group]) => ({
         kind,
@@ -148,6 +196,7 @@ export function resetDegradationLedger() {
     groups.clear();
     onceKeys.clear();
     tallies.clear();
+    ledgerGeneration++;
 }
 export const DEGRADATION_ENTRIES_PER_KIND = ENTRIES_PER_KIND;
 export const DEGRADATION_MAX_DISTINCT_KINDS = MAX_DISTINCT_KINDS;

package/node_modules/pi-lens/dist/clients/dependency-checker.js

@@ -15,6 +15,7 @@ import { findNodeToolBinary } from "./package-manager.js";
 import { isFullyQualified } from "./path-utils.js";
 import { safeSpawnAsync } from "./safe-spawn.js";
 import { createAvailabilityChecker, discoverManagedTool, getManagedToolEnvironment, resolveAvailableOrInstall, } from "./dispatch/runners/utils/runner-helpers.js";
+import { createAvailabilityLatch, } from "./dispatch/runners/utils/availability-policy.js";
 /**
  * Build madge's argv for a circular-dependency scan.
  *
@@ -135,8 +136,15 @@ async function resolvedCommandIsStale(resolved, spawnableCache) {
     spawnableCache.set(resolved.cmd, spawnable);
     return !spawnable;
 }
-/** Run `mapper` over `items` with at most `concurrency` in flight at once. */
-async function mapWithConcurrency(items, concurrency, mapper) {
+/**
+ * Run `mapper` over `items` with at most `concurrency` in flight at once.
+ * Exported (#1810 review F6) so `clients/dispatch/runners/biome-check.ts`'s
+ * `resolveBiomeFixKinds` can reuse this exact worker-pool shape for its
+ * `biome explain` fan-out instead of carrying a second copy — this file
+ * predates that need but is otherwise unrelated to it; a shared home for
+ * this one helper wasn't worth a whole new module for two call sites.
+ */
+export async function mapWithConcurrency(items, concurrency, mapper) {
     if (items.length === 0)
         return;
     let nextIndex = 0;
@@ -158,7 +166,8 @@ export class DependencyChecker {
         environment: (cwd) => getManagedToolEnvironment("madge", cwd),
         unclassifiedFailureOutcome: "missing",
     });
-    available = null;
+    /** Transient-aware availability memo — see `ensureAvailable` (#1467). */
+    availabilityLatch = createAvailabilityLatch();
     ensureInFlight = null;
     checkInFlight = new Map();
     scanInFlight = new Map();
@@ -320,12 +329,17 @@ export class DependencyChecker {
         this.circularFiles = circularFiles;
     }
     /**
-     * Check if madge is available, auto-install if not
+     * Check if madge is available, auto-install if not.
+     *
+     * Shares knip's latch policy (#1467): only a durable verdict is memoized, so
+     * a probe that timed out — madge's `--version` is ~0.7 s today, but a host
+     * event-loop stall can expire any budget — does not disable madge for the
+     * life of the process.
      */
     async ensureAvailable(cwd = process.cwd()) {
-        // Fast path: already checked
-        if (this.available !== null)
-            return this.available;
+        const memo = this.availabilityLatch.read();
+        if (memo !== null)
+            return memo;
         if (this.ensureInFlight)
             return this.ensureInFlight;
         this.ensureInFlight = this.doEnsureAvailable(cwd);
@@ -338,8 +352,28 @@ export class DependencyChecker {
     }
     async doEnsureAvailable(cwd) {
         const resolved = await resolveAvailableOrInstall(this.madgeAvailability, "madge", cwd);
-        this.available = resolved !== null;
-        return this.available;
+        if (resolved !== null) {
+            this.availabilityLatch.noteAvailable();
+            return true;
+        }
+        const verdict = this.madgeAvailability.getVerdict(cwd);
+        this.availabilityLatch.noteUnavailable(verdict.outcome ?? "missing", verdict.cause ?? "not-found");
+        return false;
+    }
+    /**
+     * #1623: public availability verdict for callers outside the dispatch
+     * graph (mode=full's fresh-fetch) that need to say WHY `ensureAvailable()`
+     * most recently returned false, using the SAME outcome/cause this class
+     * already latched above — not a re-guessed "madge binary unavailable"
+     * that can't tell a transient retry-cooldown probe from a durable
+     * absence.
+     */
+    getAvailabilityVerdict() {
+        return {
+            outcome: this.availabilityLatch.getOutcome(),
+            cause: this.availabilityLatch.getCause(),
+            retryAtMs: this.availabilityLatch.getRetryAtMs(),
+        };
     }
     /**
      * Check if a file is part of a circular dependency (from cache)

package/node_modules/pi-lens/dist/clients/diagnostic-dispositions.js

@@ -53,26 +53,40 @@
  * assumption proves wrong in practice, a surrounding-window hash can be
  * layered on later without changing the store shape.
  */
-import { createHash } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { commitDurableStore } from "./durable-store.js";
 import { logDispositionEvent } from "./disposition-logger.js";
 import { publishDisposition } from "./disposition-publish.js";
 import { getProjectDataDir } from "./file-utils.js";
+import { normalizeMessage as sharedNormalizeMessage, relativeFile as sharedRelativeFile, stableFindingId, } from "./finding-identity.js";
 import { normalizeMapKey } from "./path-utils.js";
 import { lineContentHash } from "./read-guard.js";
 // "defer" is session-ephemeral by design (#690) — held only in memory so it
 // resurfaces for free on the next process run, with no expiry/pruning logic
 // needed. Stores WEAK anchors (see module doc) so a deferred finding stays
 // hidden all session even if the flagged line itself is edited.
+//
+// Review-round F3 (#1625): this Set is process-GLOBAL, but a weak anchor
+// itself only encodes a RELATIVE path (`relativeFile` derives it from
+// `path.relative(cwd, filePath)`, never the cwd's own identity) plus
+// tool/rule/normalizedMessage — two unrelated projects sharing the same
+// relative path/tool/rule/message (e.g. "src/auth.ts" flagged by the same
+// eslint rule in project A and project B) collapse onto the IDENTICAL weak
+// anchor string. A defer in project A therefore silently suppressed the same
+// finding in project B for the rest of the process's life. Every read/write
+// below goes through `deferredKey`, which folds the resolved cwd into the Set
+// key, so the two projects can no longer collide.
 const deferredThisSession = new Set();
+function deferredKey(cwd, anchor) {
+    return `${normalizeMapKey(cwd)}::${anchor}`;
+}
 /** Exported (#802) so lens-diagnostic-mark's cross-check against live widget
  * diagnostics matches a message the same way anchor derivation does — a
- * second, slightly different normalizer would make a real match invisible. */
-export function normalizeMessage(message) {
-    return message.replace(/\s+/g, " ").trim().toLowerCase();
-}
+ * second, slightly different normalizer would make a real match invisible.
+ * Re-exports the shared `finding-identity.js` normalizer (#1816) so this
+ * module keeps its existing public surface. */
+export const normalizeMessage = sharedNormalizeMessage;
 // Anchor derivation chokepoint (#1024, #210 class): the `dd:`/`ddw:` id builders
 // (computeStrictAnchor/computeWeakAnchor) both derive their path component here,
 // so a mark and its later lookup diverge whenever the two callers pass different
@@ -91,34 +105,35 @@ export function normalizeMessage(message) {
 // widget hot path, and the read side already pays exactly this cost. Semantics
 // are unchanged: the `..`-escape fallback still returns the canonical filePath,
 // only now in the same canonical form the non-escape branch uses.
-function relativeFile(filePath, cwd) {
-    const canonicalCwd = normalizeMapKey(cwd);
-    const canonicalFile = normalizeMapKey(filePath);
-    const rel = path.relative(canonicalCwd, canonicalFile).replace(/\\/g, "/");
-    return rel && !rel.startsWith("..") ? rel : canonicalFile;
-}
+//
+// #1816: this used to be a local copy; it is now `finding-identity.js`'s
+// `relativeFile` (identical body — canonicalize both inputs through
+// `normalizeMapKey` before relativizing), re-exported so the rest of this
+// file, and the module doc/comments above referencing `relativeFile`, keep
+// working unchanged.
+const relativeFile = sharedRelativeFile;
 /** Site-specific anchor — see module doc. Used only for false-positive. */
 export function computeStrictAnchor(args) {
     const lines = args.content?.split(/\r?\n/);
     const lineText = args.line !== undefined && lines ? (lines[args.line - 1] ?? "") : "";
-    const parts = [
-        relativeFile(args.filePath, args.cwd),
-        args.tool ?? "",
-        args.rule ?? "",
-        normalizeMessage(args.message),
-        lineContentHash(lineText),
-    ];
-    return `dd:${createHash("sha256").update(parts.join("|")).digest("hex").slice(0, 12)}`;
+    return stableFindingId("dd:", {
+        cwd: args.cwd,
+        filePath: args.filePath,
+        parts: [
+            args.tool ?? "",
+            args.rule ?? "",
+            normalizeMessage(args.message),
+            lineContentHash(lineText),
+        ],
+    });
 }
 /** Intent-level anchor — see module doc. Used for defer/flagged/suppress. */
 export function computeWeakAnchor(args) {
-    const parts = [
-        relativeFile(args.filePath, args.cwd),
-        args.tool ?? "",
-        args.rule ?? "",
-        normalizeMessage(args.message),
-    ];
-    return `ddw:${createHash("sha256").update(parts.join("|")).digest("hex").slice(0, 12)}`;
+    return stableFindingId("ddw:", {
+        cwd: args.cwd,
+        filePath: args.filePath,
+        parts: [args.tool ?? "", args.rule ?? "", normalizeMessage(args.message)],
+    });
 }
 /** Both anchors a stored/filtered diagnostic would compute — the one shared
  * derivation both the dispatch-pipeline filter and lens-diagnostics' flagged
@@ -156,6 +171,15 @@ export function _setBeforeDispositionCacheRefreshForTests(hook) {
 export function _setDispositionStatForTests(statSync) {
     dispositionStatSync = statSync ?? fs.statSync;
 }
+// Test seam for `applyDispositionsMultiFile`'s per-group content read (#1625
+// F2) — Vitest can't `vi.spyOn` a bare ESM `node:fs` named export directly
+// ("Module namespace is not configurable in ESM"), so the F2 regression test
+// (proving the empty-store hoist means zero reads, not just fast ones)
+// swaps this indirection instead, mirroring `dispositionStatSync` above.
+let multiFileReadFileSync = fs.readFileSync;
+export function _setMultiFileReadForTests(readFileSync) {
+    multiFileReadFileSync = readFileSync ?? fs.readFileSync;
+}
 function readState(cwd) {
     const p = statePath(cwd);
     let stat;
@@ -278,7 +302,7 @@ export function _resetStateCacheForTests() {
  * Neither can throw into the mark path; both are already internally
  * fail-safe, but the try/catch keeps a future regression in either from
  * breaking a mark. */
-function emitMarkTelemetry(cwd, target, disposition, anchor, reason, existing) {
+function emitMarkTelemetry(cwd, target, disposition, anchor, reason, existing, identity) {
     try {
         logDispositionEvent({
             event: "mark",
@@ -290,6 +314,8 @@ function emitMarkTelemetry(cwd, target, disposition, anchor, reason, existing) {
             reason,
             anchor,
             previousDisposition: existing?.disposition,
+            model: identity?.model || undefined,
+            provider: identity?.provider || undefined,
         });
         publishDisposition({
             cwd,
@@ -317,7 +343,7 @@ function emitMarkTelemetry(cwd, target, disposition, anchor, reason, existing) {
  * hang off it, so the agent tool and any future UI caller are covered without
  * per-caller wiring.
  */
-export function markDisposition(cwd, target, disposition, reason) {
+export function markDisposition(cwd, target, disposition, reason, identity) {
     const anchor = disposition === "false-positive"
         ? computeStrictAnchor(target)
         : computeWeakAnchor(target);
@@ -326,8 +352,8 @@ export function markDisposition(cwd, target, disposition, reason) {
     // mark) — the log should record what this mark shadowed either way.
     const existing = readState(cwd).dispositions?.[anchor];
     if (disposition === "defer") {
-        deferredThisSession.add(anchor);
-        emitMarkTelemetry(cwd, target, disposition, anchor, reason, existing);
+        deferredThisSession.add(deferredKey(cwd, anchor));
+        emitMarkTelemetry(cwd, target, disposition, anchor, reason, existing, identity);
         return anchor;
     }
     const now = new Date().toISOString();
@@ -344,14 +370,18 @@ export function markDisposition(cwd, target, disposition, reason) {
         lineText,
     };
     commitDisposition(cwd, anchor, entry);
-    emitMarkTelemetry(cwd, target, disposition, anchor, reason, existing);
+    emitMarkTelemetry(cwd, target, disposition, anchor, reason, existing, identity);
     return anchor;
 }
 export function getDisposition(cwd, anchor) {
     return readState(cwd).dispositions?.[anchor];
 }
-export function isDeferredThisSession(anchor) {
-    return deferredThisSession.has(anchor);
+/** #1625 F3: `anchor` alone is ambiguous across projects — a weak anchor
+ * encodes only a RELATIVE path plus tool/rule/message, never the project's
+ * own identity, so `cwd` must be supplied to disambiguate which project's
+ * defer is being checked. */
+export function isDeferredThisSession(cwd, anchor) {
+    return deferredThisSession.has(deferredKey(cwd, anchor));
 }
 /** Test-only escape hatch — defer state is module-level (one process = one
  * session), so tests need to reset it between cases. */
@@ -367,6 +397,14 @@ export function _resetDeferredForTests() {
  * Computes both anchors per diagnostic (cheap — same hash primitive, twice)
  * since false-positive is keyed strict while defer/suppress are keyed weak;
  * see module doc for why each disposition binds the way it does.
+ *
+ * Review-round F1 (#1625): a `d.semantic === "blocking"` diagnostic can be
+ * dropped ONLY by the STRICT (false-positive) branch — never by a WEAK-
+ * anchored suppress or defer. Two distinct secrets sharing the same
+ * rule/message (e.g. two different AWS keys on different lines) collapse
+ * onto the SAME weak anchor, so a weak suppress/defer on one would silently
+ * silence the other too; unacceptable for a STOP-tier finding. `flagged` is
+ * unaffected either way — it never drops anything, blocking or not.
  */
 export function applyDispositions(diagnostics, cwd, filePath, content) {
     if (!diagnostics.length)
@@ -376,16 +414,21 @@ export function applyDispositions(diagnostics, cwd, filePath, content) {
         return diagnostics;
     return diagnostics.filter((d) => {
         const { strict, weak } = anchorsForDiagnostic(cwd, filePath, d, content);
-        if (deferredThisSession.has(weak))
+        const isBlocking = d.semantic === "blocking";
+        if (!isBlocking && deferredThisSession.has(deferredKey(cwd, weak))) {
             return false;
+        }
         if (dispositions?.[strict]?.disposition === "false-positive")
             return false;
         // Belt-and-braces: the inline `pi-lens-ignore` comment is the real
         // suppress enforcement (see suppress-writer.ts) and normally already
         // dropped this finding upstream via applyInlineSuppressions. This is a
-        // harmless second cover for the store-only audit trail case.
-        if (dispositions?.[weak]?.disposition === "suppress")
+        // harmless second cover for the store-only audit trail case — gated
+        // off blocking findings per F1 above (the inline comment, unaffected
+        // by this gate, remains the real suppress mechanism for those too).
+        if (!isBlocking && dispositions?.[weak]?.disposition === "suppress") {
             return false;
+        }
         return true;
     });
 }
@@ -405,6 +448,13 @@ export function applyDispositions(diagnostics, cwd, filePath, content) {
  * content-based filter). suppress/defer, being intent-level and weak-anchored,
  * are the marks that must apply the instant a query re-serves cached findings,
  * and they do so here without any read.
+ *
+ * Review-round F1 (#1625): this filter is ENTIRELY weak-anchored — it has no
+ * strict-anchor branch to fall back to — so a `d.semantic === "blocking"`
+ * diagnostic is never dropped here at all, regardless of any suppress/defer
+ * mark. The full `applyDispositions` (content in hand, at the next per-edit
+ * dispatch or mode=full merge) is the only place a blocking finding can ever
+ * be suppressed, and only via its STRICT branch.
  */
 export function applyWeakDispositions(diagnostics, cwd, filePath) {
     if (!diagnostics.length)
@@ -413,6 +463,8 @@ export function applyWeakDispositions(diagnostics, cwd, filePath) {
     if (!dispositions && deferredThisSession.size === 0)
         return diagnostics;
     return diagnostics.filter((d) => {
+        if (d.semantic === "blocking")
+            return true;
         const weak = computeWeakAnchor({
             cwd,
             filePath,
@@ -421,10 +473,74 @@ export function applyWeakDispositions(diagnostics, cwd, filePath) {
             message: d.message,
             line: d.line,
         });
-        if (deferredThisSession.has(weak))
+        if (deferredThisSession.has(deferredKey(cwd, weak)))
             return false;
         if (dispositions?.[weak]?.disposition === "suppress")
             return false;
         return true;
     });
 }
+/**
+ * Multi-file variant of {@link applyDispositions} for lanes whose findings
+ * span many files in ONE report — gitleaks/trivy/govulncheck/opengrep
+ * project-wide scans (#1617), unlike the dispatch path's one-`ctx.filePath`-
+ * at-a-time shape. Groups by `filePathOf(diagnostic)`, reads each file's
+ * CURRENT content once, then delegates to `applyDispositions` per group —
+ * same anchor derivation, same strict/weak split, no cloned logic (#1617's
+ * single-source-of-truth requirement).
+ *
+ * Content read is best-effort: a file that no longer exists, or that this
+ * process can't read, degrades to `content: ""` for that group rather than
+ * dropping its diagnostics outright. `applyDispositions` already treats a
+ * missing/empty content argument safely — the STRICT (false-positive) anchor
+ * hashes the diagnostic's own line, so an empty content can't collide with a
+ * mark made against the file's real content and the finding simply isn't
+ * matched (fails OPEN — still reported); the WEAK anchor (suppress/defer)
+ * never looks at content at all, so those marks keep applying regardless.
+ * This is a deliberate choice, not an oversight: a security finding must
+ * never silently vanish just because its file went unreadable at filter
+ * time (a security finding staying VISIBLE on a read failure is the safe
+ * default; a stale mark quietly reappearing is recoverable, a leaked secret
+ * quietly disappearing is not).
+ *
+ * Review-round F2 (#1625): the empty-store early return is checked HERE,
+ * before any per-group file read — not left to `applyDispositions` to notice
+ * once already inside the per-group loop. Every mode=full analyzer call
+ * (9 lanes) runs through this on every scan, and the overwhelmingly common
+ * case is zero marks in the project; measured ~270ms of synchronous
+ * `fs.readFileSync` per analyzer per run for that common case before this
+ * hoist (reading every finding's file just to discover there was nothing to
+ * filter), ~0-1ms after.
+ */
+export function applyDispositionsMultiFile(diagnostics, cwd, filePathOf) {
+    if (!diagnostics.length)
+        return diagnostics;
+    const dispositions = readState(cwd).dispositions;
+    if (!dispositions && deferredThisSession.size === 0)
+        return diagnostics;
+    const groups = new Map();
+    for (const d of diagnostics) {
+        const filePath = filePathOf(d);
+        const group = groups.get(filePath);
+        if (group)
+            group.push(d);
+        else
+            groups.set(filePath, [d]);
+    }
+    const kept = new Set();
+    for (const [filePath, group] of groups) {
+        let content = "";
+        try {
+            content = multiFileReadFileSync(filePath, "utf-8");
+        }
+        catch {
+            // Unreadable/missing — fail open, see doc above.
+        }
+        for (const d of applyDispositions(group, cwd, filePath, content)) {
+            kept.add(d);
+        }
+    }
+    // Preserve the caller's original order/dedup by reference rather than the
+    // per-group insertion order above.
+    return diagnostics.filter((d) => kept.has(d));
+}