@herbertgao/pi-extensions 2026.8.13 → 2026.8.15

package/node_modules/pi-lens/dist/clients/runtime-turn.js

@@ -6,6 +6,7 @@ import { clearGitGuardTestFailure, mergeGitGuardTestFailure, writeGitGuardRecord
 import { cascadeSettleWaitMs } from "./cascade-budget.js";
 import { logCascade } from "./cascade-logger.js";
 import { normalizeMapKey } from "./path-utils.js";
+import { compareOrdinal } from "./string-utils.js";
 import { resolveRunnerPath, toRunnerDisplayPath, } from "./dispatch/runner-context.js";
 import { getKnipIgnorePatterns } from "./file-utils.js";
 import { formatCacheAgeLabel } from "./finding-delivery-gate.js";
@@ -29,19 +30,21 @@ import { RUNTIME_CONFIG } from "./runtime-config.js";
 import { isSubagentSession } from "./subagent-mode.js";
 import { formatRunDurationMs } from "./run-duration.js";
 import { MAX_ADVISORY_AFFECTED_FILES, gateFindingsByPathFreshness, snapshotAdvisoryProvenance, } from "./advisory-provenance.js";
-import { sweepInlineBlockerFreshness } from "./blocker-freshness.js";
+import { DEPENDENCY_DRIFT_MAX_DELIVERIES, sweepInlineBlockerFreshness, } from "./blocker-freshness.js";
 import { sweepInlineBlockerPastEof } from "./blocker-past-eof.js";
 // #2001/#2002: collect-later delivery for slow auxiliary LSP servers.
 import { getLSPService } from "./lsp/index.js";
-import { drainPendingAuxiliaryCoverage, isPendingAuxiliaryPastRearmTtl, markPendingAuxiliaryCoverage, } from "./lsp/pending-aux-coverage.js";
+import { drainPendingAuxCapEvictedCount, drainPendingAuxiliaryCoverage, isPendingAuxiliaryPastRearmTtl, rearmPendingAuxiliaryCoverage, MAX_LATE_AUX_REARMS, pendingAuxiliaryCoverageSize, } from "./lsp/pending-aux-coverage.js";
 import { convertLspDiagnostics } from "./dispatch/utils/lsp-diagnostics.js";
+import { drainPendingRunnerFindings, dropStaleRunnerFindings, pendingRunnerFindingsSize, } from "./dispatch/pending-runner-findings.js";
 // #1631 review V2: moved to its own leaf module so a low-level store
 // (widget-state.ts) can use the marker without importing this orchestrator —
 // see clients/stale-marker.ts's doc comment.
 import { incrementDegradationCount } from "./degradation-ledger.js";
-import { degradeDemotedFindingBody, formatRetirementNote, } from "./demoted-finding-render.js";
+import { degradeDemotedFindingBody, formatDeliveryCapNote, formatRetirementNote, } from "./demoted-finding-render.js";
 import { STALE_LINE_MARKER } from "./stale-marker.js";
-import { getWidgetBlockingFilesForSweep, markWidgetFileBlockersStale, } from "./widget-state.js";
+import { getActiveSessionId } from "./session-lifecycle.js";
+import { getWidgetBlockingFilesForSweep, markWidgetFileBlockersStale, recordRunner, } from "./widget-state.js";
 /**
  * #1617: turn_end reads gitleaks/govulncheck/trivy straight from their
  * session-scan caches and formats them into advisory/blocker text — a
@@ -152,6 +155,9 @@ function scheduleLSPIdleReset(resetFn, delayMs, options = {}) {
             if (options.isCurrentSession && !options.isCurrentSession()) {
                 return;
             }
+            if (options.isPrimarySession && !options.isPrimarySession()) {
+                return;
+            }
             resetFn();
         }
         catch (err) {
@@ -286,6 +292,11 @@ export async function handleTurnEnd(deps) {
     // instead of dying unrendered. `hasCascadeRuns()` is a cheap peek (no
     // pending work almost every turn), so the common read-only turn still
     // takes the early return below.
+    // A foreign live owner must not deliver another session's pending findings.
+    // A no-file turn falls through when this process has pending runner work so
+    // the ordinary freshness gate and delivery cache can run. Max-cycle cleanup
+    // below intentionally remains a terminal reset; its pending work stays in
+    // the bounded handoff store for the next eligible turn.
     if (files.length === 0 && !runtime.hasCascadeRuns()) {
         // A genuinely clean session must invalidate the persisted guard record.
         // Blocker records are retained only while the runtime still reports one.
@@ -310,11 +321,20 @@ export async function handleTurnEnd(deps) {
             const sessionGeneration = runtime.sessionGeneration;
             scheduleLSPIdleReset(resetLSPService, idleResetMs, {
                 isCurrentSession: () => runtime.isCurrentSession(sessionGeneration),
+                // #2157 fix round 2: a secondary (subagent) evaluation's own timer
+                // must not release the primary's shared fleet — see the option's
+                // doc comment on `scheduleLSPIdleReset`.
+                isPrimarySession: () => {
+                    const activePrimarySessionId = getActiveSessionId();
+                    return (activePrimarySessionId === undefined ||
+                        activePrimarySessionId === runtime.telemetrySessionId);
+                },
                 onError: (err) => dbg(`lsp idle reset failed: ${err}`),
             });
         }
         resetFormatService();
-        return;
+        if (pendingRunnerFindingsSize() === 0)
+            return;
     }
     // Cancel any pending idle reset since we're actively working. #1618: also
     // checks `pendingSweepRearm` — a timer deferred behind an in-flight
@@ -323,7 +343,7 @@ export async function handleTurnEnd(deps) {
     // read "nothing pending" and skip the cancel while a rearm was still
     // queued to fire the instant the sweep released its hold — resurrecting
     // idle reset on a session that had since gone back to active editing.
-    if (lspIdleResetTimeout || pendingSweepRearm) {
+    if (files.length > 0 && (lspIdleResetTimeout || pendingSweepRearm)) {
         cancelLSPIdleReset();
         dbg("turn_end: cancelled pending LSP idle reset (active editing)");
     }
@@ -404,9 +424,20 @@ export async function handleTurnEnd(deps) {
     // Re-surface inline blockers from this turn that the agent didn't fix.
     // These were shown inline during write/edit but the agent moved on without resolving them.
     const unresolvedBlockers = runtime.getInlineBlockersSnapshot();
-    /** #1944: past-EOF demotions retired after their single degraded delivery. */
+    /** #1944/#1950: demotions retired after their delivery limit. */
     let demotedFindingsRetired = 0;
-    for (const { filePath: bPath, summary, stale } of unresolvedBlockers) {
+    /**
+     * #1950 fix-round F1: dependency-drift delivery-count commits, deferred
+     * until this turn's content is confirmed NOT suppressed by the
+     * `turn-end-findings-last` signature dedupe further down. That dedupe
+     * silences a turn whose rendered content is byte-identical to the last
+     * one actually delivered — the agent never sees a suppressed turn, so
+     * committing the counter for it would count a delivery that didn't
+     * happen. Each entry here is invoked only from the "not suppressed"
+     * branch below.
+     */
+    const pendingDependencyDriftDeliveries = [];
+    for (const { filePath: bPath, summary, stale, staleReason, } of unresolvedBlockers) {
         const displayPath = toRunnerDisplayPath(cwd, bPath);
         if (stale) {
             // #1631: demoted — out of the authoritative blocker channel and into the
@@ -423,6 +454,7 @@ export async function handleTurnEnd(deps) {
             const deadLines = blockerPastEof.deadLinesByPath.get(bPath) ?? [];
             const degraded = degradeDemotedFindingBody(summary, { deadLines });
             const retired = runtime.retireDemotedPastEofBlocker(bPath, deadLines);
+            let retirementNote;
             if (retired) {
                 demotedFindingsRetired += 1;
                 // Bounded by the ledger's own per-kind/subject tally, and the subject
@@ -432,10 +464,43 @@ export async function handleTurnEnd(deps) {
                     subject: `inline-blocker:${displayPath}`,
                     reason: `file shrank past cited line(s) ${deadLines.join(", ")}; retired after one degraded delivery`,
                 });
+                retirementNote = formatRetirementNote(deadLines);
+            }
+            else if (staleReason === "dependency-drift") {
+                // #1950: a dependency-drift demotion is recoverable (its coordinates
+                // are still in bounds), so it does NOT retire after one delivery like
+                // the past-EOF case above — but nothing capped how many times the
+                // SAME demoted-but-unconfirmed record re-serves, and incident data
+                // showed repeat deliveries carrying near-zero information after the
+                // first. Cap it at DEPENDENCY_DRIFT_MAX_DELIVERIES instead.
+                //
+                // The count driving THIS render is a peek (fix-round F1): the actual
+                // increment is deferred to `pendingDependencyDriftDeliveries` below,
+                // committed only once this turn's content is known to reach the
+                // agent, so a suppressed turn's tentative render never advances the
+                // stored count.
+                const tentativeCount = runtime.peekInlineBlockerStaleDeliveryCount(bPath) + 1;
+                if (tentativeCount >= DEPENDENCY_DRIFT_MAX_DELIVERIES) {
+                    retirementNote = formatDeliveryCapNote(tentativeCount);
+                }
+                pendingDependencyDriftDeliveries.push(() => {
+                    const deliveryCount = runtime.incrementInlineBlockerStaleDelivery(bPath);
+                    if (deliveryCount >= DEPENDENCY_DRIFT_MAX_DELIVERIES) {
+                        const capRetired = runtime.retireDemotedDependencyDriftBlocker(bPath);
+                        if (capRetired) {
+                            demotedFindingsRetired += 1;
+                            incrementDegradationCount({
+                                kind: "demoted-finding-retired",
+                                subject: `inline-blocker:${displayPath}`,
+                                reason: `capped after ${deliveryCount} deliveries with no re-run; re-run can still confirm`,
+                            });
+                        }
+                    }
+                });
             }
             // @delivery-surface: runtime-turn:unresolved-inline-blocker
             advisoryParts.push(`${STALE_LINE_MARKER} ${displayPath}:\n${degraded.body}` +
-                (retired ? `\n${formatRetirementNote(deadLines)}` : ""));
+                (retirementNote ? `\n${retirementNote}` : ""));
         }
         else {
             // @delivery-surface: runtime-turn:unresolved-inline-blocker
@@ -1427,7 +1492,7 @@ export async function handleTurnEnd(deps) {
             }
         }
         for (const { display, abs, isNeighbor } of candidates) {
-            const target = testRunnerClient.getTestRunTarget(abs, cwd);
+            const target = testRunnerClient.getTestRunTarget(abs, cwd, runtime.turnIndex);
             if (target && !seen.has(target.testFile)) {
                 seen.add(target.testFile);
                 targets.push(target);
@@ -1460,7 +1525,11 @@ export async function handleTurnEnd(deps) {
                 files: provenanceFiles,
             });
             cacheManager.writeCache("test-runner-findings", { ...(priorTestCache ?? { content: "" }), testRunGeneration }, cwd);
-            Promise.allSettled(targets.map((t) => testRunnerClient.runTestFileAsync(t.testFile, cwd, t.runner, t.config)))
+            Promise.allSettled(targets.map((t) => testRunnerClient.runTestFileAsync(t.testFile, cwd, {
+                runner: t.runner,
+                config: t.config,
+                turnIndex: firedAtTurn,
+            })))
                 .then((results) => {
                 const publishedAgainst = snapshotAdvisoryProvenance({
                     cwd,
@@ -1809,6 +1878,78 @@ export async function handleTurnEnd(deps) {
         });
     }
     cacheManager.incrementTurnCycle(cwd, currentOwner);
+    // Collect-later CLI runners continue off the write path. Their completed
+    // diagnostics use the same freshness gate as late auxiliary findings and
+    // enter the ordinary turn-end advisory delivery channel.
+    const runnerFindingsStart = Date.now();
+    // Turn-end delivery is deliberately non-blocking. Collect already-settled
+    // results and requeue the rest; the edit path already paid the deferral
+    // decision, so another 2s wait would charge every turn while a runner is
+    // still in flight (#2122 F5).
+    const pendingRunnerFindings = await drainPendingRunnerFindings(0);
+    let runnerFindingsDelivered = 0;
+    let runnerFindingsStale = 0;
+    let runnerFindingsFailed = 0;
+    let runnerFindingsDropped = 0;
+    const runnerFindingsDeliveredIds = [];
+    for (const pending of pendingRunnerFindings) {
+        const result = pending.result;
+        if (!result)
+            continue;
+        recordRunner(pending.filePath, pending.runnerId, result.status, result.diagnostics.length, Date.now() - pending.markedAtMs, pending.writeIndex);
+        if (result.status === "failed") {
+            runnerFindingsFailed += 1;
+            const detail = result.failureMessage ? `: ${result.failureMessage}` : "";
+            // @delivery-surface: runtime-turn:late-runner-findings
+            advisoryParts.push(`❌ Deferred runner ${pending.runnerId} failed (${result.failureKind ?? "unknown"})${detail}`);
+            continue;
+        }
+        const findings = result.diagnostics;
+        if (findings.length === 0)
+            continue;
+        const gate = gateFindingsByPathFreshness({
+            store: "late-runner-findings",
+            findings,
+            cwd,
+            scannedAt: pending.markedAtMs,
+            citedPath: (finding) => finding.filePath,
+        });
+        runnerFindingsStale += gate.stale.length;
+        if (gate.stale.length > 0) {
+            // The runner answered for bytes older than the latest edit. Do not
+            // re-arm this completed answer: only a new runner query can restore
+            // coverage for the refreshed bytes.
+            dropStaleRunnerFindings(pending);
+            runnerFindingsDropped += 1;
+        }
+        if (gate.live.length === 0)
+            continue;
+        const displayPath = toRunnerDisplayPath(cwd, pending.filePath);
+        const lines = gate.live.map((finding) => `  ${displayPath}:${finding.line ?? 1}:${finding.column ?? 1} [${finding.rule ?? finding.id}] ${finding.message}`);
+        runnerFindingsDelivered += gate.live.length;
+        for (const finding of gate.live) {
+            if (runnerFindingsDeliveredIds.length < 50) {
+                runnerFindingsDeliveredIds.push(finding.id);
+            }
+        }
+        // @delivery-surface: runtime-turn:late-runner-findings
+        advisoryParts.push(`⏱️ Late runner diagnostics (${pending.runnerId} completed after the edit):\n${lines.join("\n")}`);
+    }
+    logLatency({
+        type: "phase",
+        toolName: "turn_end",
+        filePath: cwd,
+        phase: "late_runner_findings",
+        durationMs: Date.now() - runnerFindingsStart,
+        metadata: {
+            pending: pendingRunnerFindings.length,
+            delivered: runnerFindingsDelivered,
+            stale: runnerFindingsStale,
+            failed: runnerFindingsFailed,
+            dropped: runnerFindingsDropped,
+            deliveredIds: runnerFindingsDeliveredIds,
+        },
+    });
     // #2001/#2002: collect-later delivery for auxiliary LSP servers whose
     // aux-grace window expired without a publication (opengrep on Windows:
     // ~8s per scan against a 2s grace — the scanner's eventual findings sat
@@ -1820,12 +1961,21 @@ export async function handleTurnEnd(deps) {
     // client drops silently.
     const lateAuxStart = Date.now();
     const drainedPairs = drainPendingAuxiliaryCoverage();
+    // #2168: cap evictions retire a pair before any drain can observe it — read
+    // and reset that count here so it folds into this turn's reconciliation
+    // sum instead of the pair vanishing uncounted.
+    const lateAuxCapEvicted = drainPendingAuxCapEvictedCount();
     let lateAuxDelivered = 0;
     let lateAuxStale = 0;
     let lateAuxMissing = 0;
     let lateAuxRearmed = 0;
     let lateAuxClientGone = 0;
     let lateAuxProbeFailed = 0;
+    let lateAuxCleanConfirmed = 0;
+    let lateAuxExpired = 0;
+    let lateAuxCeilingExhausted = 0;
+    let lateAuxAnswered = 0;
+    const lateAuxStuckPairs = [];
     if (drainedPairs.length > 0) {
         const byFile = new Map();
         for (const pair of drainedPairs) {
@@ -1843,23 +1993,42 @@ export async function handleTurnEnd(deps) {
                     cached = await service.readCachedDiagnosticsForServers(lateAuxPath, new Set(pairs.map((p) => p.serverId)));
                 }
                 catch {
-                    // #2027 round-1 P3-2: count dropped pairs — never silent.
+                    // #2027 round-1 P3-2 / #2167 R2-2: a transient probe rejection
+                    // tells us nothing about the pair's content, so treat it like the
+                    // "still scanning" branch below — re-arm under the SAME
+                    // ceiling/TTL bound rather than dropping the coverage outright.
+                    // `probeFailed` stays an honest per-turn failure count; it is
+                    // informational (like `stale`/`missing`), not a terminal bucket,
+                    // since the pair itself still resolves through rearmed/
+                    // ceilingExhausted/expired below.
                     lateAuxProbeFailed += pairs.length;
                     for (const pair of pairs) {
-                        markPendingAuxiliaryCoverage(pair.filePath, [pair.serverId], Date.now());
+                        if (!isPendingAuxiliaryPastRearmTtl(pair) &&
+                            (pair.rearmCount ?? 0) < MAX_LATE_AUX_REARMS) {
+                            rearmPendingAuxiliaryCoverage(pair);
+                            lateAuxRearmed += 1;
+                        }
+                        else if (isPendingAuxiliaryPastRearmTtl(pair)) {
+                            lateAuxExpired += 1;
+                        }
+                        else {
+                            lateAuxCeilingExhausted += 1;
+                        }
                     }
                     continue;
                 }
                 const displayLateAuxPath = toRunnerDisplayPath(cwd, lateAuxPath);
                 for (const pair of pairs) {
-                    const rawDiags = cached.get(pair.serverId);
-                    if (rawDiags === undefined) {
+                    const cachedEntry = cached.get(pair.serverId);
+                    if (cachedEntry === undefined) {
                         // No live client for this server any more — best-effort probe,
                         // drop the pair silently.
                         lateAuxClientGone += 1;
                         continue;
                     }
-                    if (rawDiags.length === 0) {
+                    const rawDiags = cachedEntry.diags;
+                    if (cachedEntry.publishedAt === undefined ||
+                        cachedEntry.publishedAt <= pair.markedAtMs) {
                         // Still scanning (or published nothing yet) — keep waiting
                         // so a scan finishing before the NEXT turn end still
                         // delivers. Two clocks, deliberately decoupled: the
@@ -1867,17 +2036,36 @@ export async function handleTurnEnd(deps) {
                         // the delivery gate stats against — while the re-arm TTL is
                         // anchored on `lastRearmedAtMs`, advanced by every successful
                         // empty probe: the scanner is demonstrably alive, just slow.
-                        if (!isPendingAuxiliaryPastRearmTtl(pair)) {
-                            markPendingAuxiliaryCoverage(lateAuxPath, [pair.serverId], pair.markedAtMs, Date.now());
+                        if (!isPendingAuxiliaryPastRearmTtl(pair) &&
+                            (pair.rearmCount ?? 0) < MAX_LATE_AUX_REARMS) {
+                            rearmPendingAuxiliaryCoverage(pair);
                             lateAuxRearmed += 1;
+                            if (lateAuxStuckPairs.length < 20)
+                                lateAuxStuckPairs.push({
+                                    filePath: pair.filePath,
+                                    serverId: pair.serverId,
+                                });
+                        }
+                        else {
+                            if (isPendingAuxiliaryPastRearmTtl(pair))
+                                lateAuxExpired += 1;
+                            else
+                                lateAuxCeilingExhausted += 1;
                         }
                         continue;
                     }
+                    if (rawDiags.length === 0) {
+                        lateAuxCleanConfirmed += 1;
+                        continue;
+                    }
                     const converted = convertLspDiagnostics(rawDiags, lateAuxPath, {
                         tool: "lsp",
                     });
-                    if (converted.length === 0)
+                    if (converted.length === 0) {
+                        lateAuxMissing += rawDiags.length;
+                        lateAuxAnswered += 1;
                         continue;
+                    }
                     // Freshness kernel (#1634 gated surface): stat the cited file
                     // against the mark timestamp. Missing → drop (no remediation for
                     // a deleted file); mtime drifted past the mark → drop too, NOT
@@ -1897,16 +2085,30 @@ export async function handleTurnEnd(deps) {
                     lateAuxStale += gate.stale.length;
                     lateAuxMissing +=
                         converted.length - gate.live.length - gate.stale.length;
-                    if (gate.stale.length > 0) {
-                        // Stale findings mean the scan predates the last edit.
-                        // Re-arm with a REFRESHED baseline so the next turn probes
-                        // the newer revision (#2027 round-1 P2-1).
-                        markPendingAuxiliaryCoverage(lateAuxPath, [pair.serverId], Date.now());
-                    }
-                    if (gate.live.length === 0)
+                    if (gate.live.length === 0) {
+                        if (gate.stale.length > 0) {
+                            // Stale findings mean the scan predates the last edit. Re-arm
+                            // with a refreshed baseline and carry the ceiling count.
+                            if (!isPendingAuxiliaryPastRearmTtl(pair) &&
+                                (pair.rearmCount ?? 0) < MAX_LATE_AUX_REARMS) {
+                                rearmPendingAuxiliaryCoverage(pair, Date.now(), true);
+                                lateAuxRearmed += 1;
+                            }
+                            else if (isPendingAuxiliaryPastRearmTtl(pair)) {
+                                lateAuxExpired += 1;
+                            }
+                            else {
+                                lateAuxCeilingExhausted += 1;
+                            }
+                        }
+                        else {
+                            lateAuxAnswered += 1;
+                        }
                         continue;
+                    }
                     const lines = gate.live.map((f) => `  ${displayLateAuxPath}:${f.line}:${f.column} [${f.rule}] ${f.message}`);
                     lateAuxDelivered += gate.live.length;
+                    lateAuxAnswered += 1;
                     // @delivery-surface: runtime-turn:late-auxiliary-findings
                     advisoryParts.push(`🕐 Late auxiliary diagnostics (${pair.serverId} answered after its grace window):\n${lines.join("\n")}`);
                 }
@@ -1923,12 +2125,20 @@ export async function handleTurnEnd(deps) {
             durationMs: Date.now() - lateAuxStart,
             metadata: {
                 pending: drainedPairs.length,
+                pairCreated: drainedPairs.length + lateAuxCapEvicted,
+                pendingAfter: pendingAuxiliaryCoverageSize(),
                 delivered: lateAuxDelivered,
                 stale: lateAuxStale,
                 missing: lateAuxMissing,
                 rearmed: lateAuxRearmed,
                 clientGone: lateAuxClientGone,
                 probeFailed: lateAuxProbeFailed,
+                cleanConfirmed: lateAuxCleanConfirmed,
+                expired: lateAuxExpired,
+                ceilingExhausted: lateAuxCeilingExhausted,
+                answered: lateAuxAnswered,
+                capEvicted: lateAuxCapEvicted,
+                stuckPairs: lateAuxStuckPairs,
             },
         });
     }
@@ -1945,7 +2155,7 @@ export async function handleTurnEnd(deps) {
         const content = capTurnEndMessage(findingParts.join("\n\n"));
         const signature = `${files
             .slice()
-            .sort((a, b) => a.localeCompare(b))
+            .sort((a, b) => compareOrdinal(a, b))
             .join("|")}::${content}`;
         const last = cacheManager.readCache("turn-end-findings-last", cwd);
         if (last?.data?.signature === signature &&
@@ -1980,6 +2190,11 @@ export async function handleTurnEnd(deps) {
             resetFormatService();
             return;
         }
+        // #1950 fix-round F1: this turn's content is confirmed NOT suppressed —
+        // it is about to reach the agent — so NOW commit the delivery-count
+        // increments the per-blocker loop above only tentatively computed.
+        for (const commit of pendingDependencyDriftDeliveries)
+            commit();
         const fileSeqByPath = {};
         for (const [filePath, seq] of runtime.getFileSeqEntries()) {
             fileSeqByPath[normalizeMapKey(path.resolve(filePath))] = seq;