pi-lens 4.1.1 → 4.1.3

package/dist/clients/actionable-warnings-logger.js

@@ -2,20 +2,36 @@ import * as path from "node:path";
 import { isTestMode } from "./env-utils.js";
 import { getGlobalPiLensDir } from "./file-utils.js";
 import { createNdjsonLogger } from "./ndjson-logger.js";
+import { normalizeFilePath } from "./path-utils.js";
 const AW_LOG_DIR = getGlobalPiLensDir();
 const AW_LOG_FILE = path.join(AW_LOG_DIR, "actionable-warnings.log");
 const AW_LOG_BACKUP_FILE = path.join(AW_LOG_DIR, "actionable-warnings.log.1");
-const MAX_LOG_BYTES = Math.max(128 * 1024, Number.parseInt(process.env.PI_LENS_AW_LOG_MAX_BYTES ?? "1048576", 10) || 1048576);
+const MAX_LOG_BYTES = Math.max(128 * 1024, Number.parseInt(process.env.PI_LENS_AW_LOG_MAX_BYTES ?? "1048576", 10) ||
+    1048576);
 const writer = createNdjsonLogger({
     filePath: AW_LOG_FILE,
     maxBytes: MAX_LOG_BYTES,
     backupPath: AW_LOG_BACKUP_FILE,
 });
+/**
+ * #2219 (the #2141 class): `filePath` reaches here from
+ * `actionable-warnings.ts`'s raw `path.resolve(cwd, file)` — the file
+ * imports `normalizeMapKey` and uses it for map lookups on this same value,
+ * but never normalizes what gets logged. `filePath` is optional (several
+ * events, e.g. `report_started`/`report_complete`, carry none), so only
+ * normalize when present.
+ */
 export function logActionableWarningsEvent(entry) {
     if (isTestMode()) {
         return;
     }
-    writer.log({ ts: new Date().toISOString(), ...entry });
+    writer.log({
+        ts: new Date().toISOString(),
+        ...entry,
+        ...(entry.filePath !== undefined
+            ? { filePath: normalizeFilePath(entry.filePath) }
+            : {}),
+    });
 }
 export function getActionableWarningsLogPath() {
     return AW_LOG_FILE;

package/dist/clients/actionable-warnings.js

@@ -633,7 +633,12 @@ export async function applyConservativeActionableWarningFixes(args) {
                 }
                 const edit = selected.edit;
                 const applied = await applyWorkspaceEdit(edit, args.cwd, args.mutationContext
-                    ? { mutationContext: { ...args.mutationContext, emitSummary: false } }
+                    ? {
+                        mutationContext: {
+                            ...args.mutationContext,
+                            emitSummary: false,
+                        },
+                    }
                     : undefined);
                 appliedResults.push(applied);
                 for (const changedFile of applied.files)
@@ -642,8 +647,7 @@ export async function applyConservativeActionableWarningFixes(args) {
             }
             catch (err) {
                 failedCount++;
-                const partial = err
-                    .appliedWorkspaceEdit;
+                const partial = err.appliedWorkspaceEdit;
                 if (partial) {
                     appliedResults.push(partial);
                     for (const changedFile of partial.files)
@@ -656,13 +660,18 @@ export async function applyConservativeActionableWarningFixes(args) {
         }
     }
     summary.changedFiles = [...changedFiles];
-    if (args.mutationContext && (summary.considered > 0 || appliedResults.length > 0)) {
+    if (args.mutationContext &&
+        (summary.considered > 0 || appliedResults.length > 0)) {
         recordLspMutationBatch(args.mutationContext, {
             results: appliedResults,
             considered: summary.considered,
             completed: summary.applied,
             failedCount,
-            status: failedCount > 0 ? "failed" : appliedResults.length > 0 ? "success" : "skipped",
+            status: failedCount > 0
+                ? "failed"
+                : appliedResults.length > 0
+                    ? "success"
+                    : "skipped",
             bookkeep: false,
         });
     }

package/dist/clients/advisory-provenance.js

@@ -4,7 +4,7 @@ import * as path from "node:path";
 import { logLatency } from "./latency-logger.js";
 import { normalizeMapKey, toProjectRelativePath } from "./path-utils.js";
 import { resolveRunnerPath } from "./dispatch/runner-context.js";
-import { MTIME_DRIFT_TOLERANCE_MS } from "./blocker-freshness.js";
+import { freshnessFromMtime } from "./freshness.js";
 export const MAX_ADVISORY_AFFECTED_FILES = 256;
 export function advisoryPathKey(filePath, cwd) {
     return normalizeMapKey(path.resolve(cwd, filePath));
@@ -68,25 +68,41 @@ function isFiniteNumber(value) {
     return typeof value === "number" && Number.isFinite(value);
 }
 function isCapturedHash(value) {
-    return typeof value === "string" &&
-        (/^[a-f0-9]{64}$/.test(value) || value === "missing" || value.startsWith("unreadable:"));
+    return (typeof value === "string" &&
+        (/^[a-f0-9]{64}$/.test(value) ||
+            value === "missing" ||
+            value.startsWith("unreadable:")));
 }
 function isWellFormed(value) {
     if (!value || typeof value !== "object")
         return false;
     const record = value;
     const revision = record.revision;
-    return !!revision && typeof revision.sessionId === "string" &&
-        isFiniteNumber(revision.projectSeq) && isFiniteNumber(revision.turnIndex) &&
-        isFiniteNumber(revision.generation) && isFiniteNumber(revision.capturedAt) &&
-        Array.isArray(record.files) && record.files.length > 0 && record.files.every((file) => !!file && typeof file.path === "string" &&
-        (file.role === "source" || file.role === "test" || file.role === "affected") &&
-        isFiniteNumber(file.mtimeMs) && isFiniteNumber(file.size) &&
-        isCapturedHash(file.sha256));
+    return (!!revision &&
+        typeof revision.sessionId === "string" &&
+        isFiniteNumber(revision.projectSeq) &&
+        isFiniteNumber(revision.turnIndex) &&
+        isFiniteNumber(revision.generation) &&
+        isFiniteNumber(revision.capturedAt) &&
+        Array.isArray(record.files) &&
+        record.files.length > 0 &&
+        record.files.every((file) => !!file &&
+            typeof file.path === "string" &&
+            (file.role === "source" ||
+                file.role === "test" ||
+                file.role === "affected") &&
+            isFiniteNumber(file.mtimeMs) &&
+            isFiniteNumber(file.size) &&
+            isCapturedHash(file.sha256)));
 }
 export function validateAdvisoryProvenance(record, cwd, runtime) {
     if (!isWellFormed(record.provenance)) {
-        return { status: "unknown", reasons: ["malformed-or-legacy-provenance"], allFilesDeleted: false, changedPathCount: 0 };
+        return {
+            status: "unknown",
+            reasons: ["malformed-or-legacy-provenance"],
+            allFilesDeleted: false,
+            changedPathCount: 0,
+        };
     }
     const provenance = record.provenance;
     const reasons = [];
@@ -149,9 +165,19 @@ export function validateAdvisoryProvenance(record, cwd, runtime) {
     }
     const allFilesDeleted = deletedFiles === provenance.files.length;
     if (unknown)
-        return { status: "unknown", reasons, allFilesDeleted, changedPathCount: changedPaths.size };
+        return {
+            status: "unknown",
+            reasons,
+            allFilesDeleted,
+            changedPathCount: changedPaths.size,
+        };
     return reasons.length > 0
-        ? { status: "superseded", reasons, allFilesDeleted, changedPathCount: changedPaths.size }
+        ? {
+            status: "superseded",
+            reasons,
+            allFilesDeleted,
+            changedPathCount: changedPaths.size,
+        }
         : { status: "current", reasons: [], allFilesDeleted, changedPathCount: 0 };
 }
 // ── Finding-cited path existence (#1461 slice 1) ──────────────────────────────
@@ -224,11 +250,15 @@ const MAX_LOGGED_DEAD_PATHS = 3;
 export function findingPathFreshness(resolvedPath, scannedAtMs) {
     try {
         const stat = fs.statSync(resolvedPath);
-        if (scannedAtMs !== undefined &&
-            stat.mtimeMs > scannedAtMs + MTIME_DRIFT_TOLERANCE_MS) {
-            return "stale";
-        }
-        return "live";
+        // No scan timestamp recorded: the pre-kernel behavior treated the
+        // path as live (no reference to be stale against) - preserved.
+        if (scannedAtMs === undefined)
+            return "live";
+        const verdict = freshnessFromMtime({
+            mtimeMs: stat.mtimeMs,
+            referenceMs: scannedAtMs,
+        });
+        return verdict.verdict === "stale" ? "stale" : "live";
     }
     catch (error) {
         const code = error.code ?? "unknown";

package/dist/clients/ast-grep-client.js

@@ -13,6 +13,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { AstGrepRuleManager } from "./ast-grep-rule-manager.js";
 import { resolvePackagePath } from "./package-root.js";
+import { truncatedByOutputCap } from "./spawn-output-cap.js";
 import { SgRunner, } from "./sg-runner.js";
 // --- Client ---
 function extractDebugAst(raw) {
@@ -113,9 +114,7 @@ export class AstGrepClient {
                 (fs.existsSync(projectRuleDir)
                     ? projectRuleDir
                     : resolvePackagePath(import.meta.url, "rules"));
-        this.log = verbose
-            ? createSubsystemLogger("ast-grep")
-            : () => { };
+        this.log = verbose ? createSubsystemLogger("ast-grep") : () => { };
         this.ruleManager = new AstGrepRuleManager(this.ruleDir, this.log);
         this.runner = new SgRunner(verbose);
     }
@@ -265,6 +264,18 @@ export class AstGrepClient {
             const result = await this.runner.execRaw(args, 10_000, options);
             const stderr = result.stderr.trim();
             const stdout = result.stdout.trim();
+            // FIRST (#2100): hitting `execRaw`'s cap SIGTERMs ast-grep, so a
+            // truncated run also carries the kill's error message. Read after the
+            // two checks below, this guard could only ever describe a run that
+            // exited before the signal reached it. `execRaw` re-spells `failure`
+            // in its own vocabulary but keeps the timeout/aborted spellings, so
+            // those runs still fall through to the error branch below.
+            if (truncatedByOutputCap(result)) {
+                return {
+                    valid: false,
+                    error: "ast-grep validation output was truncated",
+                };
+            }
             if (result.error)
                 return { valid: false, error: result.error };
             if (result.status !== 0 && !(result.status === 1 && !stderr)) {
@@ -274,12 +285,6 @@ export class AstGrepClient {
                         `ast-grep validation failed with exit code ${result.status}`,
                 };
             }
-            if (result.outputTruncated) {
-                return {
-                    valid: false,
-                    error: "ast-grep validation output was truncated",
-                };
-            }
             if (stderrHasError(stderr))
                 return { valid: false, error: stderr };
             const warning = stderr || stdout || undefined;

package/dist/clients/atomic-write-staging.js

@@ -19,7 +19,13 @@ export function stageOwnerPidFromName(name) {
 }
 export async function sweepOwnStagingFiles(directories, options) {
     const uniqueDirectories = [...new Set(directories)].filter(Boolean);
-    const result = { directories: uniqueDirectories.length, scanned: 0, removed: 0, liveSkipped: 0, truncated: false };
+    const result = {
+        directories: uniqueDirectories.length,
+        scanned: 0,
+        removed: 0,
+        liveSkipped: 0,
+        truncated: false,
+    };
     for (const directory of uniqueDirectories) {
         let handle;
         try {
@@ -47,14 +53,20 @@ export async function sweepOwnStagingFiles(directories, options) {
                     continue;
                 }
                 try {
-                    await fs.promises.rm(path.join(directory, entry.name), { force: true });
+                    await fs.promises.rm(path.join(directory, entry.name), {
+                        force: true,
+                    });
                     result.removed++;
                 }
-                catch { /* leave it for the next bounded sweep */ }
+                catch {
+                    /* leave it for the next bounded sweep */
+                }
             }
             result.truncated ||= reachedEntryCap;
         }
-        catch { /* best-effort directory scan */ }
+        catch {
+            /* best-effort directory scan */
+        }
         finally {
             await handle.close().catch(() => { });
         }

package/dist/clients/availability-probe-flight.js

@@ -0,0 +1,12 @@
+import { createSingleFlight } from "./single-flight.js";
+/** Create a flight registry whose lifetime belongs to the caller. */
+export function createAvailabilityProbeFlight(options = {}) {
+    const flights = createSingleFlight(options);
+    return {
+        run(key, probe) {
+            const joined = flights.has(key);
+            return { promise: flights.run(key, probe), joined };
+        },
+        clear: () => flights.clear(),
+    };
+}

package/dist/clients/bash-file-access.js

@@ -634,7 +634,9 @@ function collectGrepCommandFiles(command, cwd) {
     return {
         hasLineNumberGrep,
         files,
-        context: truncated ? { before: 0, after: 0 } : (context ?? { before: 0, after: 0 }),
+        context: truncated
+            ? { before: 0, after: 0 }
+            : (context ?? { before: 0, after: 0 }),
     };
 }
 function dedupePushSearchRead(out, seen, loc) {

package/dist/clients/biome-client.js

@@ -58,9 +58,7 @@ export class BiomeClient {
     ensureFlight = createSingleFlight();
     log;
     constructor(verbose = false) {
-        this.log = verbose
-            ? createSubsystemLogger("biome")
-            : () => { };
+        this.log = verbose ? createSubsystemLogger("biome") : () => { };
     }
     /**
      * Resolve the fastest available biome binary for `cwd`.
@@ -181,6 +179,7 @@ export class BiomeClient {
                 latched: true,
                 hostStallMs,
                 budgetMs: PROBE_TIMEOUT_MS,
+                classifiedBy: "probe",
             });
             return { outcome: "success", value: true };
         }
@@ -227,6 +226,12 @@ export class BiomeClient {
                     latched: true,
                     hostStallMs: this.lastProbeHostStallMs,
                     budgetMs: PROBE_TIMEOUT_MS,
+                    classifiedBy: "caller",
+                    evidence: {
+                        install: "succeeded",
+                        binary: "biome",
+                        source: "managed-dir",
+                    },
                 });
             }
             return true;

package/dist/clients/blocker-freshness.js

@@ -43,12 +43,32 @@
  * runtime condition — that edge is invisible to this gate, so a blocker whose only
  * stale dependency arrives that way survives a replay. This is an honest boundary,
  * not a silently-closed one.
+ *
+ * Delivery cap (#1950). A demoted-but-confirmable entry (`alreadyStale` above)
+ * is deliberately NOT retired after its past-EOF sibling's one-delivery rule
+ * (#1944, `blocker-past-eof.ts`) — its coordinates are still in bounds, so a
+ * fresh dispatch can genuinely confirm or clear it, and retiring on delivery
+ * one would discard a recoverable finding. But nothing capped how many times
+ * the SAME demoted record re-serves: incident data (#1944's lane sweep) showed
+ * 18 `alreadyStale` re-serves in one window, with repeat deliveries carrying
+ * near-zero information after the first. `runtime-turn.ts` counts each
+ * delivery (`InlineBlockerRecord.staleDeliveryCount`) and retires the record
+ * via `RuntimeCoordinator.retireDemotedDependencyDriftBlocker` once it reaches
+ * `DEPENDENCY_DRIFT_MAX_DELIVERIES` — a count, not a TTL or a session
+ * boundary, because "how many times has the agent already been told" is the
+ * quantity that actually went to zero information, not "how much time has
+ * passed". The ledger reason says "capped, re-run can still confirm" so it
+ * reads distinctly from #1944's "retired, unrecoverable" — a capped record
+ * COULD still resolve a fresh dispatch; it just stopped being handed one for
+ * free.
  */
 import * as fs from "node:fs";
 import { normalizeEphemeralMapKey } from "./path-utils.js";
 import { resolveImportToFiles } from "./review-graph/import-resolvers.js";
 import { getSharedTreeSitterClient, resolveTreeSitterLanguage, } from "./tree-sitter-shared.js";
 import { TreeSitterSymbolExtractor } from "./tree-sitter-symbol-extractor.js";
+/** See the module doc's "Delivery cap (#1950)" section above. */
+export const DEPENDENCY_DRIFT_MAX_DELIVERIES = 3;
 /**
  * Upper bound on the number of forward imports stat-checked for a single blocker.
  * Blocking entries are rare, but one file can import many modules; the sweep must
@@ -126,7 +146,11 @@ async function resolveForwardImportsMemoized(cwd, filePath, resolveForwardImport
     catch {
         imports = [];
     }
-    importResolutionMemo.set(filePath, { mtimeMs: sig.mtimeMs, size: sig.size, imports });
+    importResolutionMemo.set(filePath, {
+        mtimeMs: sig.mtimeMs,
+        size: sig.size,
+        imports,
+    });
     return imports;
 }
 /** Test-only: clear the extractor and import-resolution memos. */
@@ -232,17 +256,26 @@ export async function collectForwardImportMtimes(cwd, filePath, resolveForwardIm
  * +50ms). +50ms comfortably clears the measured skew while staying far below the
  * gap between genuinely distinct edits.
  */
-export const MTIME_DRIFT_TOLERANCE_MS = 50;
+// Single implementation lives in the freshness kernel (#1739); this
+// re-export preserves every existing importer's path.
+export { MTIME_DRIFT_TOLERANCE_MS } from "./freshness.js";
+import { freshnessFromMtime } from "./freshness.js";
 async function detectDrift(cwd, filePath, recordedAtMs, resolveForwardImports, turnIndex) {
     const drifted = [];
-    const ownMtimeMs = await statMtimeMs(filePath);
-    if (ownMtimeMs !== undefined && ownMtimeMs > recordedAtMs + MTIME_DRIFT_TOLERANCE_MS) {
+    const ownFreshness = freshnessFromMtime({
+        mtimeMs: await statMtimeMs(filePath),
+        referenceMs: recordedAtMs,
+    });
+    if (ownFreshness.verdict === "stale")
         drifted.push(filePath);
-    }
     const { mtimes, truncated } = await collectForwardImportMtimes(cwd, filePath, resolveForwardImports, turnIndex);
-    for (const { path, mtimeMs } of mtimes) {
-        if (mtimeMs > recordedAtMs + MTIME_DRIFT_TOLERANCE_MS)
-            drifted.push(path);
+    for (const { path: depPath, mtimeMs } of mtimes) {
+        const verdict = freshnessFromMtime({
+            mtimeMs,
+            referenceMs: recordedAtMs,
+        });
+        if (verdict.verdict === "stale")
+            drifted.push(depPath);
     }
     return { drifted, truncated };
 }

package/dist/clients/bounded-cache.js

@@ -13,7 +13,9 @@ export class BoundedLruCache {
         }
         return value;
     }
-    has(key) { return this.entries.has(key); }
+    has(key) {
+        return this.entries.has(key);
+    }
     set(key, value) {
         this.entries.delete(key);
         this.entries.set(key, value);
@@ -24,11 +26,25 @@ export class BoundedLruCache {
             this.entries.delete(oldest);
         }
     }
-    delete(key) { return this.entries.delete(key); }
-    clear() { this.entries.clear(); }
-    get size() { return this.entries.size; }
-    keys() { return this.entries.keys(); }
-    values() { return this.entries.values(); }
-    entriesArray() { return [...this.entries.entries()]; }
-    [Symbol.iterator]() { return this.entries[Symbol.iterator](); }
+    delete(key) {
+        return this.entries.delete(key);
+    }
+    clear() {
+        this.entries.clear();
+    }
+    get size() {
+        return this.entries.size;
+    }
+    keys() {
+        return this.entries.keys();
+    }
+    values() {
+        return this.entries.values();
+    }
+    entriesArray() {
+        return [...this.entries.entries()];
+    }
+    [Symbol.iterator]() {
+        return this.entries[Symbol.iterator]();
+    }
 }

package/dist/clients/bounded-pid-file-lock.js

@@ -35,8 +35,7 @@ async function releaseQuarantineLock(lockPath, token) {
             break;
         }
         catch (error) {
-            if (error.code !== "ENOENT" ||
-                attempt === 2)
+            if (error.code !== "ENOENT" || attempt === 2)
                 return;
             await new Promise((resolve) => setImmediate(resolve));
         }
@@ -111,7 +110,9 @@ async function tryAcquireQuarantineLock(lockPath, staleMs) {
                 await fsp.writeFile(path.join(lockPath, "owner.json"), JSON.stringify(owner), "utf8");
             }
             catch (error) {
-                await fsp.rm(lockPath, { recursive: true, force: true }).catch(() => { });
+                await fsp
+                    .rm(lockPath, { recursive: true, force: true })
+                    .catch(() => { });
                 throw error;
             }
             return () => releaseQuarantineLock(lockPath, owner.token);

package/dist/clients/bounded-telemetry.js

@@ -24,10 +24,9 @@
  *    that must re-arm at `session_start` and will eventually be forgotten
  *    (the #1266–#1625 defect class).
  * 2. **A per-turn cap names its turn.** `capPerTurn` carries the caller's
- *    `turnIndex` in the same object as the limit, so there is no separate
- *    reset to wire and forget: the counters clear when the observed turn
- *    changes. This is the same lazy clear-on-transition shape as
- *    `noteImportResolutionMemoTurn` (`clients/blocker-freshness.ts`).
+ *    `turnIndex` in the same object as the limit. A bounded 64-turn window
+ *    keeps overlapping async turns independent; results older than that window
+ *    fail closed. Session start clears the window when numbering restarts.
  * 3. **Identity always survives.** Every emitted record carries the
  *    discriminating identity in `filePath` and in `metadata.identity`, so
  *    aggregation can still answer "which file, which method, which record is
@@ -85,6 +84,14 @@ export const BOUNDED_TELEMETRY_PHASES = [
      * exact count.
      */
     "lsp_warm_client_missing",
+    /** #2052: a file's nearest LSP root is outside the session ceiling. */
+    "lsp_capability_skip",
+    /**
+     * #2044: failed-first test state was retired after a confirmed missing path,
+     * retained because the filesystem verdict was indeterminate, or evicted at
+     * the state cap. Selection checks and detailed rows are both capped per turn.
+     */
+    "test_runner_failed_target_state",
     /**
      * #1723: an event-loop block at or above the floor. Not a degradation, so
      * no ledger kind; bounded by call cadence (one `turn_end` runs it once per
@@ -97,6 +104,17 @@ export const BOUNDED_TELEMETRY_PHASES = [
      * queue of them, so it is rising-edge per event name.
      */
     "session_event_stale_ctx_skip",
+    /**
+     * #2007: a worktree-mutating git command declined because another live
+     * session shares this dirty checkout. Rising edge per checkout root; the
+     * ledger keeps the exact repeat count.
+     */
+    "shared_checkout_switch_blocked",
+    /**
+     * #2007: `git status` could not report the working-tree state, so the same
+     * command was declined on an UNKNOWN rather than assumed clean.
+     */
+    "shared_checkout_probe_failed",
 ];
 const REGISTERED_PHASES = new Set(BOUNDED_TELEMETRY_PHASES);
 /** Report whether a phase name is in the registry (used by the sweep). */
@@ -104,14 +122,15 @@ export function isBoundedTelemetryPhase(phase) {
     return REGISTERED_PHASES.has(phase);
 }
 /**
- * Per-turn admission counters, keyed by phase. Cleared lazily when a call
- * observes a turn index different from the one the counters were built for,
- * and eagerly by `resetBoundedTelemetry` at `session_start` (a new session
- * restarts turn numbering at 0, so the lazy check alone could carry a stale
- * count across a session boundary that happened to land on the same index).
+ * Per-turn admission counters, keyed by turn and phase. Multiple turns remain
+ * live because async work can finish T1 after T2 has already emitted. The map
+ * retains a bounded recent window; work older than that window fails closed
+ * rather than reopening an exhausted budget. Session start clears all state.
  */
+const MAX_TRACKED_TURN_CAPS = 64;
 let turnCounts = new Map();
-let countedTurnIndex;
+let latestCountedTurnIndex;
+let retiredThroughTurnIndex = Number.NEGATIVE_INFINITY;
 /**
  * Decide whether this occurrence earns a detailed record, and count it in the
  * ledger either way. Returns `true` when the caller should write the record.
@@ -180,14 +199,25 @@ export function emitBounded(phase, identity, payload, options = {}) {
 function admitAgainstTurnCap(phase, cap) {
     if (cap === undefined)
         return true;
-    if (countedTurnIndex !== cap.turnIndex) {
-        turnCounts = new Map();
-        countedTurnIndex = cap.turnIndex;
+    if (cap.turnIndex <= retiredThroughTurnIndex)
+        return false;
+    let counts = turnCounts.get(cap.turnIndex);
+    if (!counts) {
+        if (turnCounts.size >= MAX_TRACKED_TURN_CAPS) {
+            const oldestTrackedTurn = Math.min(...turnCounts.keys());
+            if (cap.turnIndex < oldestTrackedTurn)
+                return false;
+            turnCounts.delete(oldestTrackedTurn);
+            retiredThroughTurnIndex = Math.max(retiredThroughTurnIndex, oldestTrackedTurn);
+        }
+        counts = new Map();
+        turnCounts.set(cap.turnIndex, counts);
     }
-    const used = turnCounts.get(phase) ?? 0;
+    latestCountedTurnIndex = Math.max(latestCountedTurnIndex ?? cap.turnIndex, cap.turnIndex);
+    const used = counts.get(phase) ?? 0;
     if (used >= cap.limit)
         return false;
-    turnCounts.set(phase, used + 1);
+    counts.set(phase, used + 1);
     return true;
 }
 /**
@@ -198,9 +228,16 @@ function admitAgainstTurnCap(phase, cap) {
  */
 export function resetBoundedTelemetry() {
     turnCounts = new Map();
-    countedTurnIndex = undefined;
+    latestCountedTurnIndex = undefined;
+    retiredThroughTurnIndex = Number.NEGATIVE_INFINITY;
+}
+/** Test-only: one turn's live admission count for a phase. */
+export function _boundedTurnCountForTest(phase, turnIndex = latestCountedTurnIndex) {
+    if (turnIndex === undefined)
+        return 0;
+    return turnCounts.get(turnIndex)?.get(phase) ?? 0;
 }
-/** Test-only: the live per-turn admission count for a phase. */
-export function _boundedTurnCountForTest(phase) {
-    return turnCounts.get(phase) ?? 0;
+/** Test-only: number of turn buckets retained by the bounded counter. */
+export function _boundedTrackedTurnsForTest() {
+    return turnCounts.size;
 }