@herbertgao/pi-extensions 2026.8.5 → 2026.8.6

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.
  *
@@ -158,7 +159,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 +322,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 +345,13 @@ 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;
     }
     /**
      * Check if a file is part of a circular dependency (from cache)

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

@@ -278,7 +278,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 +290,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 +319,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);
@@ -327,7 +329,7 @@ export function markDisposition(cwd, target, disposition, reason) {
     const existing = readState(cwd).dispositions?.[anchor];
     if (disposition === "defer") {
         deferredThisSession.add(anchor);
-        emitMarkTelemetry(cwd, target, disposition, anchor, reason, existing);
+        emitMarkTelemetry(cwd, target, disposition, anchor, reason, existing, identity);
         return anchor;
     }
     const now = new Date().toISOString();
@@ -344,7 +346,7 @@ 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) {

package/node_modules/pi-lens/dist/clients/diagnostics-publish.js

@@ -61,7 +61,7 @@
  */
 import { logBusEvent } from "./bus-events-logger.js";
 import { normalizeFilePath } from "./path-utils.js";
-import { createLiveBusEmitter, recordStaleBusFailure, } from "./live-bus-emitter.js";
+import { createLiveBusEmitter, recordStaleBusFailure, resolveLiveBusEmitter, } from "./live-bus-emitter.js";
 import { isBusPublishEnabled } from "./bus-publish.js";
 export const BUS_DIAGNOSTICS_EVENT = "pilens:diagnostics";
 export const BUS_DIAGNOSTICS_VERSION = 1;
@@ -149,8 +149,13 @@ export function publishDiagnostics(args) {
         }
         return;
     }
-    const busEmit = liveEmitter.get();
-    if (!busEmit) {
+    const resolution = resolveLiveBusEmitter(liveEmitter, () => ({
+        event: BUS_DIAGNOSTICS_EVENT,
+        cwd: normalizeFilePath(args.cwd),
+    }));
+    if (resolution.outcome === "stale-session")
+        return;
+    if (resolution.outcome === "unwired") {
         if (!hasLoggedUnwired) {
             hasLoggedUnwired = true;
             logBusEvent({
@@ -161,6 +166,7 @@ export function publishDiagnostics(args) {
         }
         return;
     }
+    const busEmit = resolution.emit;
     try {
         const fileEntries = args.files.map((f) => {
             const normPath = normalizeFilePath(f.path);
@@ -204,6 +210,7 @@ export function publishDiagnostics(args) {
             outcome: "emit_failed",
             cwd: normalizeFilePath(args.cwd),
             error: String(err),
+            ctxSource: resolution.ctxSource,
         });
         if (!hasLoggedFailure) {
             hasLoggedFailure = true;

package/node_modules/pi-lens/dist/clients/dispatch/dispatcher.js

@@ -29,6 +29,7 @@ import { loadPiLensProjectConfig } from "../project-lens-config.js";
 import { RUNTIME_CONFIG, getRunnerTimeoutFloorMs } from "../runtime-config.js";
 import { safeSpawnAsync } from "../safe-spawn.js";
 import { classifyDiagnostic } from "./diagnostic-taxonomy.js";
+import { classifyProbeFailure, logAvailabilityDecision, startHostStallSampler, transientRetryDelayMs, } from "./runners/utils/availability-policy.js";
 import { applyDispositions } from "../diagnostic-dispositions.js";
 import { applyInlineSuppressions } from "./inline-suppressions.js";
 import { getToolPlan } from "./plan.js";
@@ -76,12 +77,49 @@ export function normalizeCacheKey(cmd) {
     const normalized = cmd.replace(/\.(cmd|exe)$/i, "").toLowerCase();
     return `session.toolCache.${normalized}`;
 }
-async function checkToolAvailability(command, facts) {
+/** Probe budget for the generic `hasTool` availability check, ms. */
+const TOOL_PROBE_TIMEOUT_MS = 5000;
+/**
+ * Session fact holding the epoch ms after which a TRANSIENT verdict for a
+ * command may be re-probed. Kept beside the boolean fact so both share the
+ * session's lifetime — no second global to reset (#1476).
+ */
+function transientRetryKey(command) {
+    return `${normalizeCacheKey(command)}.retryAt`;
+}
+/**
+ * Consecutive transient verdicts for a command, so the cooldown ESCALATES the
+ * way the policy documents (30 s, 60 s, 120 s … capped at 5 min) instead of
+ * sitting flat at 30 s.
+ *
+ * This is the highest-traffic availability consumer in the product. A flat
+ * cooldown here means a permanently sick host is re-probed every 30 s per
+ * command for the whole session — ten times the storm the policy claims to
+ * bound, and the one place the bound matters most. `createAvailabilityChecker`
+ * tracks the same counter; this keeps the two seams telling one story.
+ */
+function transientAttemptsKey(command) {
+    return `${normalizeCacheKey(command)}.transientAttempts`;
+}
+/**
+ * Is `command` usable right now? Cached per session.
+ *
+ * Latch policy (#1467/#1476): a `false` from a genuine absence is durable and
+ * is remembered for the session. A `false` from a TIMED-OUT probe is not — this
+ * is the highest-traffic availability consumer in the codebase, and caching a
+ * host stall here silently disabled a healthy tool for every later dispatch in
+ * the session. A transient verdict instead holds only for a bounded cooldown,
+ * which also stops a sick host from being re-probed on every dispatch.
+ */
+export async function checkToolAvailability(command, facts) {
     const key = normalizeCacheKey(command);
     const cached = facts.getSessionFact(key);
     if (cached !== undefined) {
         return cached;
     }
+    const retryAt = facts.getSessionFact(transientRetryKey(command));
+    if (retryAt !== undefined && Date.now() < retryAt)
+        return false;
     // A command that isn't even on disk can't pass a --version probe; the ~μs
     // stat/PATH walk saves a guaranteed-to-fail spawn round-trip per cold tool.
     if (!(await isSpawnableCommand(command))) {
@@ -89,12 +127,68 @@ async function checkToolAvailability(command, facts) {
         return false;
     }
     try {
-        const result = await safeSpawnAsync(command, ["--version"], {
-            timeout: 5000,
+        // The budget is enforced by a HOST-side timer, so measure the loop stall
+        // that overlapped the window and let the shared classifier read it.
+        const sampler = startHostStallSampler();
+        const startedAt = Date.now();
+        let result;
+        let hostStallMs;
+        try {
+            result = await safeSpawnAsync(command, ["--version"], {
+                timeout: TOOL_PROBE_TIMEOUT_MS,
+            });
+        }
+        finally {
+            hostStallMs = sampler.stop();
+        }
+        const elapsedMs = Date.now() - startedAt;
+        if (result.status === 0) {
+            facts.setSessionFact(key, true);
+            // The tool answered: retire the cooldown facts rather than leaving a
+            // stale retry deadline behind a `true`.
+            facts.setSessionFact(transientRetryKey(command), 0);
+            facts.setSessionFact(transientAttemptsKey(command), 0);
+            logAvailabilityDecision({
+                tool: command,
+                verdict: "available",
+                outcome: "success",
+                cause: "ok",
+                elapsedMs,
+                latched: true,
+                hostStallMs,
+                budgetMs: TOOL_PROBE_TIMEOUT_MS,
+            });
+            return true;
+        }
+        // `missing` for anything unclassified preserves the pre-#1476 meaning of
+        // a non-zero exit: durable, cached for the session.
+        const { outcome, cause } = classifyProbeFailure(result, {
+            hostStallMs,
+            unclassifiedFailureOutcome: "missing",
         });
-        const available = result.status === 0;
-        facts.setSessionFact(key, available);
-        return available;
+        let retryAfterMs;
+        if (outcome === "transient") {
+            const attempts = (facts.getSessionFact(transientAttemptsKey(command)) ?? 0) + 1;
+            facts.setSessionFact(transientAttemptsKey(command), attempts);
+            retryAfterMs = transientRetryDelayMs(attempts, cause);
+            facts.setSessionFact(transientRetryKey(command), Date.now() + retryAfterMs);
+        }
+        else {
+            facts.setSessionFact(key, false);
+            facts.setSessionFact(transientAttemptsKey(command), 0);
+        }
+        logAvailabilityDecision({
+            tool: command,
+            verdict: "unavailable",
+            outcome,
+            cause,
+            elapsedMs,
+            latched: outcome !== "transient",
+            hostStallMs,
+            ...(retryAfterMs !== undefined && { retryAfterMs }),
+            budgetMs: TOOL_PROBE_TIMEOUT_MS,
+        });
+        return false;
     }
     catch {
         facts.setSessionFact(key, false);
@@ -128,7 +222,10 @@ export function createDispatchContext(filePath, cwd, pi, facts, blockingOnly, mo
 /** Authoritative workspace root; `cwd` may be a nested language root. */
 projectRoot, 
 /** Ordered per-file pipeline token, when this is a post-write dispatch. */
-writeIndex) {
+writeIndex, 
+/** Runtime telemetry identity, when known (#1448) — threaded to the
+ * worklog append; see DispatchContext.telemetryModel's doc. */
+telemetryModel, telemetryProvider) {
     const absoluteFilePath = resolveRunnerPath(cwd, filePath);
     const normalizedProjectRoot = normalizeMapKey(path.resolve(projectRoot ?? cwd));
     const normalizedCwd = normalizeMapKey(resolveLanguageRootForFile(absoluteFilePath, cwd));
@@ -150,6 +247,8 @@ writeIndex) {
         blockingOnly,
         modifiedRanges,
         writeIndex,
+        telemetryModel,
+        telemetryProvider,
         async hasTool(command) {
             return checkToolAvailability(command, facts);
         },
@@ -638,11 +737,16 @@ export async function dispatchForFile(ctx, groups, registry, onRunnerResult) {
     const blockers = visibleDiagnostics.filter((d) => d.semantic === "blocking");
     const warnings = visibleDiagnostics.filter((d) => d.semantic === "warning" || d.semantic === "none");
     const fixedItems = visibleDiagnostics.filter((d) => d.semantic === "fixed");
-    // Append fixed and fixable diagnostics to the persistent worklog
+    // Append fixed and fixable diagnostics to the persistent worklog, attributed
+    // to the runtime's active model/provider when known (#1448).
+    const worklogIdentity = {
+        model: ctx.telemetryModel,
+        provider: ctx.telemetryProvider,
+    };
     if (fixedItems.length > 0) {
         import("../fix-worklog.js")
             .then(({ appendToWorklog }) => {
-            appendToWorklog(ctx.cwd, fixedItems, true);
+            appendToWorklog(ctx.cwd, fixedItems, true, worklogIdentity);
         })
             .catch(() => { });
     }
@@ -650,7 +754,7 @@ export async function dispatchForFile(ctx, groups, registry, onRunnerResult) {
     if (fixableWarnings.length > 0) {
         import("../fix-worklog.js")
             .then(({ appendToWorklog }) => {
-            appendToWorklog(ctx.cwd, fixableWarnings, false);
+            appendToWorklog(ctx.cwd, fixableWarnings, false, worklogIdentity);
         })
             .catch(() => { });
     }

package/node_modules/pi-lens/dist/clients/dispatch/integration.js

@@ -19,9 +19,8 @@ import { fileURLToPath } from "node:url";
 import { formatCascadeNeighborDiagnostics } from "../cascade-format.js";
 import { logCascade } from "../cascade-logger.js";
 import { getDiagnosticTracker } from "../diagnostic-tracker.js";
-import { isTierAwareCascadeEnabled, recordOutstandingCascadeTouch, } from "../lsp/cascade-tier.js";
-import { classifyCascadeWaitTier } from "../lsp/wait-policy/index.js";
-import { bindingStateLabel, } from "../lsp/diagnostic-binding.js";
+import { classifyCascadeWaitTier, isTierAwareCascadeEnabled, recordOutstandingCascadeTouch, } from "../lsp/cascade-tier.js";
+import { bindingStateLabel, touchCoverageGap, } from "../lsp/diagnostic-binding.js";
 import { getServersForFileWithConfig } from "../lsp/config.js";
 import { getLSPService } from "../lsp/index.js";
 import { isExternalOrVendorFile, normalizeMapKey } from "../path-utils.js";
@@ -412,6 +411,11 @@ function readBoundToCurrentDisk(rawDiags) {
  * a future flag cannot be silently missed at just one of the several gate sites:
  *  - `inconclusive` (#1093/#571): the notify/diagnostics wait lapsed its deadline,
  *    so a resolved `[]` is NOT a confirmed clean (the #533 false-clean trap).
+ *  - a COVERAGE GAP (#1470): an auxiliary's push wait was cut off by the aux grace
+ *    timer, so the merged result is missing whatever that scanner would have said.
+ *    Such a touch is deliberately NOT `inconclusive` (the primary answered), which
+ *    is exactly why it needs naming here: reading `!inconclusive` alone would let a
+ *    hung opengrep wipe a live footer finding and seed the recently-clean cache.
  *  - `binding.boundToCurrentDisk === false` (#1095): the diagnostics were computed
  *    against a DIFFERENT disk state than what is on disk now (the server's view
  *    diverged / a pre-fix buffer) — not an observation of current disk. `true` and
@@ -426,7 +430,9 @@ function readInconclusive(rawDiags) {
     return rawDiags?.inconclusive === true;
 }
 function isConfirmedTouch(rawDiags) {
-    return !readInconclusive(rawDiags) && readBoundToCurrentDisk(rawDiags) !== false;
+    return (!readInconclusive(rawDiags) &&
+        touchCoverageGap(rawDiags).length === 0 &&
+        readBoundToCurrentDisk(rawDiags) !== false);
 }
 const reverseDepsIndexCache = new Map();
 const REVERSE_DEPS_MAX_WARM_ROOTS = 8;
@@ -666,6 +672,12 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
         let importerSet = new Set();
         let callerSet = new Set();
         let referenceCount = 0;
+        // #1446 item 4: how many eligible neighbors the flat CASCADE_NEIGHBOUR_BUDGET
+        // cut off, distinct from candidates dropped by the filters above it
+        // (missing on disk, vendor, ignored, already-primary-this-turn) — those are
+        // never actionable regardless of budget, so counting them as "truncated"
+        // would overstate what a larger budget could actually recover.
+        let cascadeBudgetTruncated = 0;
         if (CASCADE_GRAPH_KINDS.has(fileKind)) {
             const graphStart = Date.now();
             const graph = await buildOrUpdateGraph(cwd, [normalizedFile], sessionFacts, seqState);
@@ -1004,7 +1016,7 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
                 ...impact.directCallers,
             ]);
             referenceCount = impact.neighborFiles.filter((n) => !importerOrCallerSet.has(n)).length;
-            sortedNeighbors = [...impact.neighborFiles]
+            const eligibleNeighbors = [...impact.neighborFiles]
                 .filter((n) => nodeFs.existsSync(n))
                 .filter((n) => !isExternalOrVendorFile(n, cwd))
                 // Honour the project's ignore config: a user-ignored neighbour (e.g.
@@ -1016,8 +1028,9 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
                 .sort((a, b) => {
                 const rank = (p) => importerSet.has(p) ? 0 : callerSet.has(p) ? 1 : 2;
                 return rank(a) - rank(b);
-            })
-                .slice(0, CASCADE_NEIGHBOUR_BUDGET);
+            });
+            cascadeBudgetTruncated = Math.max(0, eligibleNeighbors.length - CASCADE_NEIGHBOUR_BUDGET);
+            sortedNeighbors = eligibleNeighbors.slice(0, CASCADE_NEIGHBOUR_BUDGET);
         }
         else {
             logCascade({
@@ -1066,6 +1079,28 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
         // the latter must not collapse into a clean-looking result (#1104 honesty
         // rule, same doctrine as #1023's graph-degraded indeterminate marker).
         let fallbackBindingRejected = false;
+        // #1444: neighbours whose in-lane wait was skipped for the quiet-window
+        // reconcile to answer later. Logged on `cascade_result` so a cascade that
+        // deferred EVERY neighbour is distinguishable from a genuine leaf (both are
+        // `neighborCount: 0` with no output otherwise).
+        let collectLaterSkipped = 0;
+        // #1446 item 5: `recentlyCleanNeighborCache` and `neighborTouchCache` hits
+        // are the whole point of both caches, but neither was ever counted — the
+        // only visible signal was 267s/day of touch wall time with no way to tell
+        // whether the caches were absorbing repeat work or every touch was cold.
+        let recentlyCleanHits = 0;
+        let cacheHits = 0;
+        // F1 (#1446 follow-up): `coldTouches` must be counted at the point each
+        // neighbour's OUTCOME is actually known, not derived from `coldSnapshotPaths`
+        // (finalized earlier, before the cache-hit checks below run against it). Using
+        // the pre-outcome list let a neighbour double-count (cold-snapshot AND cache/
+        // recently-clean hit) or vanish from every bucket (an `activePaths` neighbour —
+        // e.g. Python/Go — that misses both caches). These four counters partition the
+        // touched-neighbour set `[...activePaths, ...coldSnapshotPaths]` exactly once
+        // each: a neighbour with no LSP server configured is the only outcome
+        // deliberately excluded (never attempted, no bucket).
+        let deferredTouches = 0;
+        let coldTouches = 0;
         if (sortedNeighbors.length > 0) {
             const snapshotPaths = sortedNeighbors.filter(shouldReadCascadeFromSnapshot);
             const activePaths = sortedNeighbors.filter((n) => !shouldReadCascadeFromSnapshot(n));
@@ -1186,6 +1221,7 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
                     turnSeq - recentlyClean.turnSeq <= RECENTLY_CLEAN_TTL_TURNS &&
                     !hasFreshPassiveErrors) {
                     producedLspData = true;
+                    recentlyCleanHits++;
                     const durationMs = Date.now() - neighborStart;
                     logCascade({
                         phase: "neighbor_snapshot",
@@ -1213,6 +1249,7 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
                 const cached = writeSeq != null ? neighborTouchCache.get(cacheKey) : undefined;
                 if (cached?.turnSeq === turnSeq && cached?.writeSeq === writeSeq) {
                     producedLspData = true;
+                    cacheHits++;
                     const durationMs = Date.now() - neighborStart;
                     logCascade({
                         phase: "neighbor_snapshot",
@@ -1245,10 +1282,10 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
                 }
                 // A6: async read to avoid blocking event loop on network-mounted drives
                 const content = await nodeFs.promises.readFile(neighborPath, "utf8");
-                // #458: tier-aware cascade-lane wait. A Tier-3 (push-only,
-                // silent-on-clean — typescript is the lone core-set instance today)
-                // primary can never give this in-lane wait an affirmative clean
-                // signal, so the budget is pure cost. Fire the touch (didOpen/
+                // #458/#1444: tier-aware cascade-lane wait. A Tier-3 silent server
+                // cannot give this wait an affirmative clean signal. Native TS7 does
+                // publish, but not inside the cold-snapshot budget. In both cases the
+                // in-lane budget is pure cost. Fire the touch (didOpen/
                 // didChange still happens — the server starts real work) and record
                 // it as outstanding for the agent_settled quiet window to reconcile
                 // instead of waiting here. Ambiguous/missing capability data always
@@ -1261,7 +1298,7 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
                     try {
                         const snapshots = (await lspService.getCapabilitySnapshots?.(neighborPath)) ?? [];
                         const tier = classifyCascadeWaitTier(lspService, neighborPath, snapshots);
-                        if (tier === "tier3-silent") {
+                        if (tier === "tier3-silent" || tier === "collect-later") {
                             const spawnedForTouch = await lspService.getClientForFile(neighborPath);
                             if (spawnedForTouch) {
                                 // Sampled BEFORE the touchFile notify: a publish landing
@@ -1283,6 +1320,14 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
                                     touchedAt,
                                 });
                                 const durationMs = Date.now() - neighborStart;
+                                if (tier === "collect-later")
+                                    collectLaterSkipped++;
+                                // F1: both tier3-silent and collect-later skip the in-lane
+                                // wait and record an outstanding touch for the quiet-window
+                                // reconcile — neither a cache hit nor a genuine completed
+                                // cold touch, so both share this explicit "deferred" bucket
+                                // instead of falling out of the partition uncounted.
+                                deferredTouches++;
                                 logCascade({
                                     phase: "cascade_tier3_skip",
                                     filePath,
@@ -1290,7 +1335,10 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
                                     durationMs,
                                     lspServerCount: configuredServerCount,
                                     coldSnapshot: isColdSnapshot,
-                                    metadata: { serverId: spawnedForTouch.client.serverId },
+                                    metadata: {
+                                        serverId: spawnedForTouch.client.serverId,
+                                        waitTier: tier,
+                                    },
                                 });
                                 // Deliberately NOT cached as clean/diagnosed — the wait was
                                 // skipped, not resolved, so neither neighborTouchCache nor
@@ -1311,6 +1359,14 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
                 // Cold-snapshot neighbors (autoPropagate LSP, server warm) use a tighter
                 // 1000ms budget — they should respond quickly; we'd rather return zero
                 // than block cascade for 2s on a slow open.
+                // F1: this is the ONE remaining outcome after cache hit, recently-clean
+                // hit, and tier-aware deferral have all been ruled out — a genuine
+                // active LSP touch is being issued right now. Count it here (an
+                // attempt, whether it resolves, times out, or the promise rejects
+                // below in the allSettled catch) rather than from `coldSnapshotPaths`,
+                // which is finalized before any of the above checks run and includes
+                // neighbours that resolve via cache/recently-clean instead.
+                coldTouches++;
                 const rawDiags = await lspService.touchFile(neighborPath, content, {
                     diagnostics: "document",
                     collectDiagnostics: true,
@@ -1336,6 +1392,10 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
                 const confirmed = isConfirmedTouch(rawDiags);
                 const bindingRejected = readBoundToCurrentDisk(rawDiags) === false;
                 const inconclusive = readInconclusive(rawDiags);
+                // #1470: the third, independent reason a touch is unconfirmed — an
+                // auxiliary our grace timer cut off. Logged alongside the other two so
+                // cascade.log alone still tells the three apart.
+                const unconfirmedServerIds = touchCoverageGap(rawDiags);
                 // #692: `source: "cascade"` no longer overrides `rule` (see the
                 // doc comment on the sibling call above) — dropped rather than
                 // migrated to `scanOrigin` since cascade output never touches
@@ -1345,8 +1405,9 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
                 // wrapper and are unaffected by this copy (the shape-5 fix).
                 const diags = convertLspDiagnostics(rawDiags.diags.filter((d) => d.severity === 1).slice(0, MAX_PER_FILE), neighborPath);
                 const durationMs = Date.now() - neighborStart;
-                // Update cache for this neighbor at the current write sequence
-                if (writeSeq != null) {
+                // Cache only a confirmed answer. An inconclusive or binding-rejected
+                // result must not become a confirmed cache hit on the next cascade.
+                if (writeSeq != null && confirmed) {
                     neighborTouchCache.set(cacheKey, {
                         turnSeq,
                         writeSeq,
@@ -1386,6 +1447,9 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
                     metadata: {
                         inconclusive,
                         ...(bindingRejected && { bindingState: bindingStateLabel(false) }),
+                        ...(unconfirmedServerIds.length > 0 && {
+                            unconfirmedServerIds: [...unconfirmedServerIds],
+                        }),
                     },
                 });
                 // #1093/#1095: a completed, CONFIRMED active touch is a confirmed
@@ -1411,6 +1475,7 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
                     reason: neighborReason(importerSet, callerSet, neighborPath),
                     diagnostics: diags,
                     lspTouched: true,
+                    ...(inconclusive && { inconclusive: true }),
                     durationMs,
                 };
             }));
@@ -1513,9 +1578,29 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
             metadata: {
                 filesWithErrors,
                 hasOutput: formatted.length > 0,
+                // #1444: >0 means "answers are still outstanding", not "nothing found".
+                collectLaterSkipped,
                 // Log when cascade ran but found nothing — distinguishes "clean" from "no signal"
                 noNeighbors: visibleNeighbors.length === 0,
                 noErrors: visibleNeighbors.length > 0 && filesWithErrors === 0,
+                // #1446 item 5: cache effectiveness as a number instead of an inference
+                // from `coldSnapshot`/`snapshotMissing` flags scattered across
+                // per-neighbor `neighbor_touch`/`neighbor_snapshot` rows.
+                // F1: cacheHits + recentlyCleanHits + deferredTouches + coldTouches
+                // partition `[...activePaths, ...coldSnapshotPaths]` exactly — each
+                // counter increments at the point its neighbour's outcome is actually
+                // decided, not from `coldSnapshotPaths` (a pre-outcome list finalized
+                // before the cache-hit checks run). A neighbour with no LSP server
+                // configured is the one deliberately uncounted outcome (never touched).
+                cacheHits,
+                recentlyCleanHits,
+                deferredTouches,
+                coldTouches,
+                // #1446 item 4: the budget in force and how many eligible candidates
+                // it cut off this run — the correctness half (a truncated run being
+                // silently discarded) is #1443; this is observability only.
+                neighborBudget: CASCADE_NEIGHBOUR_BUDGET,
+                budgetTruncated: cascadeBudgetTruncated,
                 neighbors: visibleNeighbors.slice(0, 10).map((n) => ({
                     file: n.filePath.replace(/\\/g, "/").split("/").slice(-2).join("/"),
                     diagnostics: n.diagnostics.length,
@@ -1742,7 +1827,7 @@ export async function dispatchLintWithResult(filePath, cwd, pi, modifiedRanges,
     // Default true preserves the per-edit fast path (errors only). Callers that
     // want the full picture (warnings + structural smells), e.g. the MCP review
     // facade, pass blockingOnly=false to run every runner.
-    const ctx = createDispatchContext(filePath, cwd, pi, sessionFacts, options?.blockingOnly ?? true, modifiedRanges, options?.projectRoot, options?.writeIndex);
+    const ctx = createDispatchContext(filePath, cwd, pi, sessionFacts, options?.blockingOnly ?? true, modifiedRanges, options?.projectRoot, options?.writeIndex, options?.telemetryModel, options?.telemetryProvider);
     sessionFacts.clearFileFactsFor(ctx.filePath);
     const kind = ctx.kind;
     if (!kind) {

package/node_modules/pi-lens/dist/clients/dispatch/runners/lsp.js

@@ -12,6 +12,7 @@
  * unified runner that delegates to the LSP service.
  */
 import { logExtension } from "../../extension-log.js";
+import { touchCoverageGap } from "../../lsp/diagnostic-binding.js";
 import { getLSPService } from "../../lsp/index.js";
 import { RUNTIME_CONFIG } from "../../runtime-config.js";
 import { PRIORITY } from "../priorities.js";
@@ -111,6 +112,11 @@ const lspRunner = {
         // one spawned server) — an empty `lspDiags` in that case is NOT a
         // confirmed clean result and must not be reported as one (#570).
         let diagnosticsInconclusive = false;
+        // #1470: server ids the touch carries no evidence for — an auxiliary whose
+        // push wait our aux grace timer cut off. The touch is NOT inconclusive (the
+        // primary answered, and its findings below are real), so this is tracked
+        // separately: the only claim it invalidates is "0 diagnostics means clean".
+        let unconfirmedServerIds = [];
         let usedWarmAttach = false;
         let failureReason = "";
         const content = readFileContent(ctx.filePath);
@@ -131,11 +137,23 @@ const lspRunner = {
             usedWarmAttach = attached?.available === true;
             // #1179 (shape-5 structural fix): both branches normalize to the
             // `touchFile` wrapper shape. The warm-attach IPC branch resolves a plain
-            // diagnostics array (the socket cannot carry a side-channel; the IPC client
-            // already rejected any inconclusive answer, so `available` ⟹ confirmed) —
-            // wrap it as `{ diags }`; the incumbent branch already returns the wrapper.
+            // diagnostics array — `available` no longer implies a fully confirmed
+            // answer: a `partial` confirmation (an auxiliary cut off by the grace
+            // timer) is served as `available: true` too (the IPC gate at
+            // `clients/mcp/ipc.ts:248` rejects only `inconclusive`). Carry the
+            // incumbent's `unconfirmedServerIds` onto the wrapper so
+            // `touchCoverageGap` below sees it — dropping it here is the same
+            // false-clean defect already fixed at `clients/lsp/index.ts` (the
+            // workspace sweep wrapper) and `tools/lsp-diagnostics.ts` (the tool
+            // consumer); wrap it as `{ diags }`; the incumbent branch already
+            // returns the wrapper.
             const touched = attached?.available
-                ? { diags: attached.response.diagnostics }
+                ? {
+                    diags: attached.response.diagnostics,
+                    ...(attached.response.unconfirmedServerIds !== undefined && {
+                        unconfirmedServerIds: attached.response.unconfirmedServerIds,
+                    }),
+                }
                 : await lspService.touchFile(ctx.filePath, content, {
                     diagnostics: "document",
                     collectDiagnostics: true,
@@ -151,6 +169,7 @@ const lspRunner = {
             else {
                 lspDiags = touched.diags;
                 diagnosticsInconclusive = touched.inconclusive === true;
+                unconfirmedServerIds = touchCoverageGap(touched);
             }
         }
         catch (err) {
@@ -208,6 +227,20 @@ const lspRunner = {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
         if (lspDiags.length === 0) {
+            if (unconfirmedServerIds.length > 0) {
+                // #1470: an auxiliary was cut off by the aux grace timer, so this empty
+                // merged result is missing whatever that scanner would have said — a
+                // hung opengrep must not read as a clean bill of health on the security
+                // lane. `RunnerResult` has no channel for "clean for these servers,
+                // unknown for those", so the only honest verdict this seam can express
+                // for an EMPTY result is "not checked" — which is what "skipped" means
+                // here, and it lets the coverage notice say so once. Nothing is thrown
+                // away: the primary answered with zero findings, so there is nothing to
+                // report; when it DOES have findings the branches below still report
+                // them (see the non-empty path), which is how a trustworthy primary
+                // stays trustworthy under a cut-off auxiliary.
+                return { status: "skipped", diagnostics: [], semantic: "none" };
+            }
             return {
                 status: "succeeded",
                 diagnostics: [],