@herbertgao/pi-extensions 2026.8.13 → 2026.8.15

package/node_modules/pi-lens/dist/clients/test-runner-client.js

@@ -10,12 +10,17 @@
  * Design: File-level targeted testing — only runs tests for the
  * specific file being edited, not the entire suite.
  */
-import { createSubsystemLogger } from "./extension-log.js";
+import { createHash } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { emitBounded } from "./bounded-telemetry.js";
+import { LEDGER_FIELD_MAX } from "./degradation-ledger.js";
 import { minimatch } from "./deps/minimatch.js";
+import { createSubsystemLogger } from "./extension-log.js";
 import { detectFileRole } from "./file-role.js";
 import { findGlobalBinary } from "./package-manager.js";
+import { PathKeyedMap } from "./path-keyed-map.js";
+import { normalizeEphemeralMapKey, normalizeMapKey } from "./path-utils.js";
 import { isMeasuredDuration, toMeasuredDurationMs } from "./run-duration.js";
 import { safeSpawn, safeSpawnAsync } from "./safe-spawn.js";
 // Source file → test file patterns (reverse lookup)
@@ -194,21 +199,115 @@ export function stripWrapperArgs(binName, args) {
     return args;
 }
 // --- Client ---
+const MAX_FAILED_TARGETS_PER_RUNNER = 32;
+const MAX_FAILED_TARGET_CHECKS_PER_SELECTION = 8;
+const FAILED_TARGET_DETAIL_CAP_PER_TURN = 8;
+function canonicalFailedPath(filePath) {
+    const absolute = path.resolve(filePath);
+    try {
+        return normalizeMapKey(fs.realpathSync.native(absolute));
+    }
+    catch {
+        return normalizeMapKey(absolute);
+    }
+}
+function canonicalProjectRoot(cwd) {
+    const absolute = path.resolve(cwd);
+    try {
+        return {
+            key: normalizeEphemeralMapKey(fs.realpathSync.native(absolute)),
+            resolved: true,
+        };
+    }
+    catch {
+        return { key: normalizeEphemeralMapKey(absolute), resolved: false };
+    }
+}
+const MAX_CANONICAL_ROOT_MEMO_ENTRIES = 512;
+function filesystemErrorCode(error) {
+    if (error !== null &&
+        typeof error === "object" &&
+        "code" in error &&
+        typeof error.code === "string") {
+        return error.code;
+    }
+    return undefined;
+}
 export class TestRunnerClient {
     log;
-    availableRunners = new Map();
+    // This is an instance-lifetime memo of RESOLVED spellings only, which leaves
+    // two temporal edges. A symlink retargeted mid-session keeps its old
+    // resolution until a new client instance — acceptable because round 2's
+    // evidence re-validation already handles verdict-level staleness (positive
+    // verdicts re-stat their config file). A spelling that did NOT resolve is
+    // never memoized (#2077): the fallback key is a guess about a path that does
+    // not exist yet, so memoizing it would pin an alias probed before its
+    // symlink was created to a stale verdict for the instance's life. Re-probing
+    // costs one failing realpath per call, and only for a cwd that does not
+    // resolve — a state where `detectRunner` already walks node_modules on every
+    // call. Keep the memo bounded so pathological spelling churn cannot grow it
+    // without limit.
+    canonicalRootMemo = new Map();
+    availableRunners = new PathKeyedMap(normalizeEphemeralMapKey);
     failedTestsByRunner = new Map();
+    failedTargetSequence = 0;
+    statFailedTarget;
     // Best-effort vitest config `test.include`/`test.exclude` globs, scraped as
     // plain text (never executed) and cached per cwd so the config file is
     // only read/parsed once, not on every edit. `null` means "no config found
     // or it couldn't be parsed in the simple shape we look for" — callers
     // treat that as "no additional signal" and fall back to naming-convention
     // detection only.
-    vitestTestGlobsCache = new Map();
-    constructor(verbose = false) {
-        this.log = verbose
-            ? createSubsystemLogger("test-runner")
-            : () => { };
+    vitestTestGlobsCache = new PathKeyedMap(normalizeEphemeralMapKey);
+    constructor(verbose = false, options = {}) {
+        this.log = verbose ? createSubsystemLogger("test-runner") : () => { };
+        this.statFailedTarget =
+            options.statFailedTarget ?? ((filePath) => void fs.statSync(filePath));
+    }
+    getCanonicalProjectRoot(cwd) {
+        const cached = this.canonicalRootMemo.get(cwd);
+        if (cached !== undefined)
+            return cached;
+        const { key, resolved } = canonicalProjectRoot(cwd);
+        if (!resolved)
+            return key;
+        if (this.canonicalRootMemo.size >= MAX_CANONICAL_ROOT_MEMO_ENTRIES) {
+            const oldest = this.canonicalRootMemo.keys().next().value;
+            if (oldest !== undefined)
+                this.canonicalRootMemo.delete(oldest);
+        }
+        this.canonicalRootMemo.set(cwd, key);
+        return key;
+    }
+    getRunnerAvailability(byRunner, runner) {
+        const cached = byRunner?.get(runner);
+        if (!cached)
+            return undefined;
+        if (cached.available &&
+            cached.evidencePath !== undefined &&
+            !fs.existsSync(cached.evidencePath)) {
+            byRunner?.delete(runner);
+            return undefined;
+        }
+        return cached.available;
+    }
+    /**
+     * #2252: only a POSITIVE verdict is memoized. A negative one has no
+     * `evidencePath` to re-stat, so `getRunnerAvailability` had no way to tell
+     * "still absent" from "a config file just appeared" and served the first
+     * miss for the client's whole process lifetime — measured live: probe an
+     * empty directory, add `vitest.config.ts`, and the SAME client kept
+     * answering "no runner". Same precedent as #2242's alias-canonicalization
+     * fix (`clients/test-runner-client.ts`'s `getCanonicalProjectRoot`): drop
+     * the memo write on the failure branch rather than adding a TTL or a
+     * re-arm signal. The cost is bounded and already paid today — a cache miss
+     * re-runs the exact same `configFiles.some(fs.existsSync)` walk this
+     * method's caller already does on every FIRST probe of a runner.
+     */
+    setRunnerAvailability(byRunner, runner, available, evidencePath) {
+        if (!available)
+            return;
+        byRunner.set(runner, { available, evidencePath });
     }
     /**
      * Check if a test runner is available in the project
@@ -218,15 +317,22 @@ export class TestRunnerClient {
      * 3. node_modules presence
      */
     detectRunner(cwd, sourceFilePath) {
+        const rootKey = this.getCanonicalProjectRoot(cwd);
+        let byRunner = this.availableRunners.get(rootKey);
+        if (!byRunner) {
+            byRunner = new Map();
+            this.availableRunners.set(rootKey, byRunner);
+        }
         // Priority 1: Config files
         for (const [name, config] of Object.entries(RUNNERS)) {
-            const cacheKey = `${cwd}:${name}:config`;
-            if (this.availableRunners.has(cacheKey)) {
-                if (this.availableRunners.get(cacheKey)) {
+            const cached = this.getRunnerAvailability(byRunner, name);
+            if (cached !== undefined) {
+                if (cached) {
                     return { runner: name, config };
                 }
                 continue;
             }
+            let configEvidencePath;
             const found = config.configFiles.some((cf) => {
                 if (name === "pytest" && cf === "pyproject.toml") {
                     const pyprojectPath = path.join(cwd, cf);
@@ -234,7 +340,10 @@ export class TestRunnerClient {
                         return false;
                     try {
                         const pyproject = fs.readFileSync(pyprojectPath, "utf-8");
-                        return pyproject.includes("[tool.pytest.ini_options]");
+                        const matches = pyproject.includes("[tool.pytest.ini_options]");
+                        if (matches)
+                            configEvidencePath = pyprojectPath;
+                        return matches;
                     }
                     catch {
                         return false;
@@ -250,15 +359,22 @@ export class TestRunnerClient {
                             ...composer.require,
                             ...composer["require-dev"],
                         };
-                        return Boolean(allDeps["phpunit/phpunit"]);
+                        const matches = Boolean(allDeps["phpunit/phpunit"]);
+                        if (matches)
+                            configEvidencePath = composerPath;
+                        return matches;
                     }
                     catch {
                         return false;
                     }
                 }
-                return fs.existsSync(path.join(cwd, cf));
+                const candidate = path.join(cwd, cf);
+                const matches = fs.existsSync(candidate);
+                if (matches)
+                    configEvidencePath = candidate;
+                return matches;
             });
-            this.availableRunners.set(cacheKey, found);
+            this.setRunnerAvailability(byRunner, name, found, configEvidencePath);
             if (found) {
                 this.log(`Detected runner via config: ${name}`);
                 return { runner: name, config };
@@ -274,17 +390,17 @@ export class TestRunnerClient {
             // Check for vitest first (more specific than jest)
             if (allDeps.vitest) {
                 this.log("Detected vitest in package.json");
-                this.availableRunners.set(`${cwd}:vitest:config`, true);
+                this.setRunnerAvailability(byRunner, "vitest", true, packageJsonPath);
                 return { runner: "vitest", config: RUNNERS.vitest };
             }
             if (allDeps.jest) {
                 this.log("Detected jest in package.json");
-                this.availableRunners.set(`${cwd}:jest:config`, true);
+                this.setRunnerAvailability(byRunner, "jest", true, packageJsonPath);
                 return { runner: "jest", config: RUNNERS.jest };
             }
             if (allDeps.pytest || allDeps["pytest-cov"]) {
                 this.log("Detected pytest in package.json (unusual)");
-                this.availableRunners.set(`${cwd}:pytest:config`, true);
+                this.setRunnerAvailability(byRunner, "pytest", true, packageJsonPath);
                 return { runner: "pytest", config: RUNNERS.pytest };
             }
         }
@@ -428,7 +544,10 @@ export class TestRunnerClient {
     relativeSourceDir(sourceFilePath, cwd) {
         const dir = path.dirname(sourceFilePath);
         const relDir = path.relative(cwd, path.resolve(cwd, dir));
-        if (!relDir || relDir === "." || relDir.startsWith("..") || path.isAbsolute(relDir)) {
+        if (!relDir ||
+            relDir === "." ||
+            relDir.startsWith("..") ||
+            path.isAbsolute(relDir)) {
             return null;
         }
         return relDir;
@@ -447,21 +566,40 @@ export class TestRunnerClient {
      * template expression) — anything more dynamic than that is out of
      * scope for this heuristic.
      *
-     * Cached per `cwd` so the file is only read/parsed once per project,
-     * not on every edit.
+     * Cached per `cwd`, including a `null` result — #2252 F2: a project with
+     * no vitest config, or one this heuristic can't scrape, is a COMMON shape
+     * (every non-vitest project pays this on every edit otherwise; measured
+     * ~1500x — 0.4µs cached vs. 598.7µs re-reading the candidate list every
+     * call). The cache entry is revalidated on every read, the same shape
+     * `getRunnerAvailability` uses for a positive verdict: bounded
+     * `fs.existsSync` checks against the config file the result was derived
+     * from (or, when none existed, against the candidate list itself), never
+     * a full re-read/re-parse on a cache hit. So a config file appearing (or
+     * a broken one being fixed) still converges — only the FULL parse is
+     * paid once, not the existence check.
      */
     parseVitestTestGlobs(cwd) {
-        if (this.vitestTestGlobsCache.has(cwd)) {
-            return this.vitestTestGlobsCache.get(cwd) ?? null;
-        }
+        const rootKey = this.getCanonicalProjectRoot(cwd);
         // .mts isn't in RUNNERS.vitest.configFiles (that list drives runner
         // *detection* priority) but is a legal vitest config extension, so it's
         // included here for the scrape even though detectRunner doesn't check it.
         const candidates = [...RUNNERS.vitest.configFiles, "vitest.config.mts"];
+        const cached = this.vitestTestGlobsCache.get(rootKey);
+        if (cached !== undefined) {
+            const stillValid = cached.evidencePath !== undefined
+                ? fs.existsSync(cached.evidencePath)
+                : !candidates.some((cf) => fs.existsSync(path.join(cwd, cf)));
+            if (stillValid)
+                return cached.result;
+            this.vitestTestGlobsCache.delete(rootKey);
+        }
         let content = null;
+        let foundPath;
         for (const cf of candidates) {
+            const candidatePath = path.join(cwd, cf);
             try {
-                content = fs.readFileSync(path.join(cwd, cf), "utf-8");
+                content = fs.readFileSync(candidatePath, "utf-8");
+                foundPath = candidatePath;
                 break;
             }
             catch {
@@ -480,7 +618,7 @@ export class TestRunnerClient {
                     result.exclude = exclude;
             }
         }
-        this.vitestTestGlobsCache.set(cwd, result);
+        this.vitestTestGlobsCache.set(rootKey, { result, evidencePath: foundPath });
         return result;
     }
     /**
@@ -706,12 +844,11 @@ export class TestRunnerClient {
      * 1) If there are known failing tests, rerun those first (fast feedback loop).
      * 2) Otherwise run related tests for the edited file.
      */
-    getTestRunTarget(sourceFilePath, cwd) {
+    getTestRunTarget(sourceFilePath, cwd, turnIndex) {
         const detected = this.detectRunner(cwd, sourceFilePath);
         if (!detected)
             return null;
-        const key = this.failedKey(cwd, detected.runner);
-        const failedSet = this.failedTestsByRunner.get(key);
+        const failedSet = this.getFailedTargets(cwd, detected.runner);
         // If the edited file is itself a test file, there's no "related test"
         // to discover — running findTestFile on it would strip its own
         // extension and search for nonsense like foo.test.test.ts. Skip
@@ -721,34 +858,22 @@ export class TestRunnerClient {
             ? null
             : this.findTestFile(sourceFilePath, cwd, detected.runner);
         if (failedSet && failedSet.size > 0) {
-            if (related) {
-                const relatedAbs = path.resolve(related.testFile);
-                if (failedSet.has(relatedAbs)) {
-                    return {
-                        testFile: relatedAbs,
-                        runner: detected.runner,
-                        config: detected.config,
-                        strategy: "failed-first",
-                    };
-                }
-            }
-            if (selfIsTest) {
-                const selfAbs = path.resolve(sourceFilePath);
-                if (failedSet.has(selfAbs)) {
-                    return {
-                        testFile: selfAbs,
-                        runner: detected.runner,
-                        config: detected.config,
-                        strategy: "failed-first",
-                    };
-                }
-            }
-            return {
-                testFile: [...failedSet][0],
+            const failedFirst = this.retireMissingFailedTargets({
+                cwd,
                 runner: detected.runner,
-                config: detected.config,
-                strategy: "failed-first",
-            };
+                failedTargets: failedSet,
+                relatedAbs: related ? path.resolve(related.testFile) : undefined,
+                selfAbs: selfIsTest ? path.resolve(sourceFilePath) : undefined,
+                turnIndex,
+            });
+            if (failedFirst) {
+                return {
+                    testFile: failedFirst,
+                    runner: detected.runner,
+                    config: detected.config,
+                    strategy: "failed-first",
+                };
+            }
         }
         if (selfIsTest) {
             return {
@@ -767,13 +892,19 @@ export class TestRunnerClient {
             strategy: "related",
         };
     }
-    /**
-     * Run tests for a specific file without blocking the event loop, so LSP
-     * messages, other file writes, and all async operations continue while
-     * tests run.
-     */
-    async runTestFileAsync(testFile, cwd, runner, config) {
+    async runTestFileAsync(testFile, cwd, runnerOrRequest, legacyConfig) {
         const absoluteTestFile = path.resolve(testFile);
+        let request;
+        if (typeof runnerOrRequest === "string") {
+            if (!legacyConfig) {
+                return this.emptyResult(absoluteTestFile, "", runnerOrRequest, "Runner configuration missing");
+            }
+            request = { runner: runnerOrRequest, config: legacyConfig };
+        }
+        else {
+            request = runnerOrRequest;
+        }
+        const { runner, config, turnIndex } = request;
         if (!fs.existsSync(absoluteTestFile)) {
             return this.emptyResult(absoluteTestFile, "", runner, "Test file not found");
         }
@@ -811,7 +942,13 @@ export class TestRunnerClient {
                     parsed = this.parseGenericRunnerOutput(stdout, stderr, result.status ?? 0, absoluteTestFile, runner);
                     break;
             }
-            this.recordResult(cwd, runner, absoluteTestFile, parsed);
+            this.recordResult({
+                cwd,
+                runner,
+                testFile: absoluteTestFile,
+                result: parsed,
+                turnIndex,
+            });
             return parsed;
         }
         catch (err) {
@@ -819,6 +956,172 @@ export class TestRunnerClient {
             return this.emptyResult(absoluteTestFile, "", runner, err.message);
         }
     }
+    getFailedTargets(cwd, runner, create = false) {
+        let roots = this.failedTestsByRunner.get(runner);
+        if (!roots && create) {
+            roots = new PathKeyedMap(canonicalFailedPath);
+            this.failedTestsByRunner.set(runner, roots);
+        }
+        if (!roots)
+            return undefined;
+        const root = canonicalFailedPath(cwd);
+        let targets = roots.get(root);
+        if (!targets && create) {
+            targets = new PathKeyedMap(canonicalFailedPath);
+            roots.set(root, targets);
+        }
+        return targets;
+    }
+    deleteFailedRoot(cwd, runner) {
+        const roots = this.failedTestsByRunner.get(runner);
+        if (!roots)
+            return;
+        roots.delete(canonicalFailedPath(cwd));
+        if (roots.size === 0)
+            this.failedTestsByRunner.delete(runner);
+    }
+    failedTargetCount(runner) {
+        const roots = this.failedTestsByRunner.get(runner);
+        if (!roots)
+            return 0;
+        let count = 0;
+        for (const targets of roots.values())
+            count += targets.size;
+        return count;
+    }
+    evictOldestFailedTarget(runner) {
+        const roots = this.failedTestsByRunner.get(runner);
+        if (!roots)
+            return undefined;
+        let oldest;
+        for (const [root, targets] of roots) {
+            for (const [identity, entry] of targets) {
+                if (!oldest || entry.sequence < oldest.entry.sequence) {
+                    oldest = { root, identity, entry };
+                }
+            }
+        }
+        if (!oldest)
+            return undefined;
+        const targets = roots.get(oldest.root);
+        targets?.delete(oldest.identity);
+        if (targets?.size === 0)
+            roots.delete(oldest.root);
+        if (roots.size === 0)
+            this.failedTestsByRunner.delete(runner);
+        return oldest.entry.displayPath;
+    }
+    classifyFailedTarget(candidate) {
+        try {
+            this.statFailedTarget(candidate);
+            return { status: "present" };
+        }
+        catch (error) {
+            const errorCode = filesystemErrorCode(error);
+            if (errorCode === "ENOENT" || errorCode === "ENOTDIR") {
+                return { status: "missing", errorCode };
+            }
+            return { status: "indeterminate", errorCode };
+        }
+    }
+    recordFailedTargetState(record) {
+        const { outcome, runner, candidate, errorCode, turnIndex } = record;
+        const boundedTarget = candidate.length <= LEDGER_FIELD_MAX
+            ? candidate
+            : `…${candidate.slice(1 - LEDGER_FIELD_MAX)}`;
+        const targetIdentity = createHash("sha256")
+            .update(runner)
+            .update("\0")
+            .update(candidate)
+            .digest("hex");
+        const identity = `${outcome}:${targetIdentity}`;
+        const payload = {
+            durationMs: 0,
+            filePath: boundedTarget,
+            metadata: {
+                outcome,
+                runner,
+                errorCode: errorCode ?? "unknown",
+            },
+        };
+        const options = {
+            ledgerKind: "test-runner-failed-target-state",
+            risingEdgePer: "identity",
+            reason: `${outcome}: ${boundedTarget}`,
+        };
+        emitBounded("test_runner_failed_target_state", identity, payload, turnIndex === undefined
+            ? options
+            : {
+                ...options,
+                capPerTurn: {
+                    limit: FAILED_TARGET_DETAIL_CAP_PER_TURN,
+                    turnIndex,
+                },
+            });
+    }
+    /**
+     * Retire only confirmed-missing failed-first paths, then return one usable
+     * target. A bounded prefix is checked per selection; remaining candidates
+     * carry over to the next selection instead of adding unbounded synchronous
+     * filesystem work to turn_end. Related/self targets keep priority.
+     */
+    retireMissingFailedTargets(selection) {
+        const { cwd, runner, failedTargets, relatedAbs, selfAbs, turnIndex } = selection;
+        let checked = 0;
+        const inspected = new Set();
+        const inspect = (identity, entry) => {
+            if (checked >= MAX_FAILED_TARGET_CHECKS_PER_SELECTION)
+                return undefined;
+            checked += 1;
+            inspected.add(identity);
+            const candidate = entry.displayPath;
+            const verdict = this.classifyFailedTarget(candidate);
+            if (verdict.status === "missing") {
+                failedTargets.delete(identity);
+                this.recordFailedTargetState({
+                    outcome: "retired-missing",
+                    runner,
+                    candidate,
+                    errorCode: verdict.errorCode,
+                    turnIndex,
+                });
+                return undefined;
+            }
+            if (verdict.status === "indeterminate") {
+                this.recordFailedTargetState({
+                    outcome: "retained-indeterminate",
+                    runner,
+                    candidate,
+                    errorCode: verdict.errorCode,
+                    turnIndex,
+                });
+            }
+            return candidate;
+        };
+        for (const preferred of [relatedAbs, selfAbs]) {
+            if (!preferred)
+                continue;
+            const identity = canonicalFailedPath(preferred);
+            const entry = failedTargets.get(identity);
+            if (!entry)
+                continue;
+            const selected = inspect(identity, entry);
+            if (selected)
+                return selected;
+        }
+        for (const [identity, entry] of failedTargets) {
+            if (inspected.has(identity))
+                continue;
+            if (checked >= MAX_FAILED_TARGET_CHECKS_PER_SELECTION)
+                break;
+            const selected = inspect(identity, entry);
+            if (selected)
+                return selected;
+        }
+        if (failedTargets.size === 0)
+            this.deleteFailedRoot(cwd, runner);
+        return undefined;
+    }
     /**
      * Check if a source file has corresponding tests (without running them)
      */
@@ -1043,7 +1346,9 @@ export class TestRunnerClient {
             const errorsMatch = output.match(/Errors:\s*(\d+)/i);
             const skippedMatch = output.match(/Skipped:\s*(\d+)/i);
             const total = testsMatch ? Number.parseInt(testsMatch[1], 10) : 0;
-            const failures = failuresMatch ? Number.parseInt(failuresMatch[1], 10) : 0;
+            const failures = failuresMatch
+                ? Number.parseInt(failuresMatch[1], 10)
+                : 0;
             const errors = errorsMatch ? Number.parseInt(errorsMatch[1], 10) : 0;
             skipped = skippedMatch ? Number.parseInt(skippedMatch[1], 10) : 0;
             failed = failures + errors;
@@ -1123,7 +1428,9 @@ export class TestRunnerClient {
         if (summaryMatch) {
             const total = Number.parseInt(summaryMatch[1], 10);
             failed = Number.parseInt(summaryMatch[2], 10);
-            const excluded = summaryMatch[3] ? Number.parseInt(summaryMatch[3], 10) : 0;
+            const excluded = summaryMatch[3]
+                ? Number.parseInt(summaryMatch[3], 10)
+                : 0;
             const skippedCount = summaryMatch[4]
                 ? Number.parseInt(summaryMatch[4], 10)
                 : 0;
@@ -1499,9 +1806,7 @@ export class TestRunnerClient {
         // Package-line counts, like the go duration probe above, take the
         // FIRST package summary only — the same known limit already
         // documented on `parseGenericRunnerDuration`.
-        const goFailNames = [
-            ...output.matchAll(/--- FAIL:[^\S\n]+([^\s(]+)/g),
-        ];
+        const goFailNames = [...output.matchAll(/--- FAIL:[^\S\n]+([^\s(]+)/g)];
         // #1524-r4: only COUNT unparented failures. go prints a `--- FAIL:`
         // line for every level of a failing subtest tree — `TestA` AND
         // `TestA/sub` each get their own line for what is really one
@@ -1595,7 +1900,10 @@ export class TestRunnerClient {
         // runner error they actually are). They still label a name onto
         // `failures` above when `matched` or `goFailNames` already settled
         // the question some other way, but they no longer settle it alone.
-        const runnerError = exitCode !== 0 && !matched && goFailNames.length === 0 && lower.includes("error")
+        const runnerError = exitCode !== 0 &&
+            !matched &&
+            goFailNames.length === 0 &&
+            lower.includes("error")
             ? `Runner ${runner} exited with ${exitCode}`
             : undefined;
         // #1524-r4 (tidy): a runner-error result reports through
@@ -1720,9 +2028,7 @@ export class TestRunnerClient {
         const relDir = path.relative(cwd, dir);
         const segments = relDir.split(path.sep).filter(Boolean);
         if (segments.length > 1 && knownSourceRoots.has(segments[0])) {
-            return [
-                path.join(cwd, testDir, ...segments.slice(1), testFilename),
-            ];
+            return [path.join(cwd, testDir, ...segments.slice(1), testFilename)];
         }
         return [];
     }
@@ -1806,12 +2112,18 @@ export class TestRunnerClient {
         // itself, so the leading wrapper-name arg(s) that named it (e.g. "vitest",
         // or "-m pytest") are stripped from args() — see stripWrapperArgs.
         if (fs.existsSync(localBin)) {
-            return { command: localBin, args: stripWrapperArgs(binName, config.args(testFile, cwd)) };
+            return {
+                command: localBin,
+                args: stripWrapperArgs(binName, config.args(testFile, cwd)),
+            };
         }
         // Any package manager's global bin dir (npm/pnpm/yarn/bun) before npx (#375).
         const globalBin = await findGlobalBinary(binName);
         if (globalBin) {
-            return { command: globalBin, args: stripWrapperArgs(binName, config.args(testFile, cwd)) };
+            return {
+                command: globalBin,
+                args: stripWrapperArgs(binName, config.args(testFile, cwd)),
+            };
         }
         return { command: config.command, args: config.args(testFile, cwd) };
     }
@@ -1836,24 +2148,43 @@ export class TestRunnerClient {
         const lines = stack.split("\n").slice(0, 3);
         return lines.join("\n").slice(0, 500);
     }
-    failedKey(cwd, runner) {
-        return `${path.resolve(cwd)}:${runner}`;
-    }
-    recordResult(cwd, runner, testFile, result) {
-        const key = this.failedKey(cwd, runner);
-        const abs = path.resolve(testFile);
-        const set = this.failedTestsByRunner.get(key) ?? new Set();
+    recordResult(record) {
+        const { cwd, runner, testFile, result, turnIndex } = record;
+        const targetPath = path.resolve(testFile);
+        const target = canonicalFailedPath(targetPath);
+        let failedTargets = this.getFailedTargets(cwd, runner, result.failed > 0);
+        if (!failedTargets)
+            return;
         if (result.failed > 0) {
-            set.add(abs);
-            this.failedTestsByRunner.set(key, set);
+            const alreadyRecorded = failedTargets.has(target);
+            if (!alreadyRecorded &&
+                this.failedTargetCount(runner) >= MAX_FAILED_TARGETS_PER_RUNNER) {
+                const evicted = this.evictOldestFailedTarget(runner);
+                if (evicted) {
+                    this.recordFailedTargetState({
+                        outcome: "capacity-evicted",
+                        runner,
+                        candidate: evicted,
+                        turnIndex,
+                    });
+                }
+                // Eviction can remove this root's final prior target. Reacquire the
+                // root map before inserting so the newest failure never lands in a
+                // detached PathKeyedMap.
+                failedTargets = this.getFailedTargets(cwd, runner, true);
+                if (!failedTargets)
+                    return;
+            }
+            // Sequence is global across roots, so a refreshed target becomes the
+            // newest failure without relying on one root map's insertion order.
+            failedTargets.set(target, {
+                displayPath: targetPath,
+                sequence: ++this.failedTargetSequence,
+            });
             return;
         }
-        if (set.has(abs)) {
-            set.delete(abs);
-            if (set.size === 0)
-                this.failedTestsByRunner.delete(key);
-            else
-                this.failedTestsByRunner.set(key, set);
+        if (failedTargets.delete(target) && failedTargets.size === 0) {
+            this.deleteFailedRoot(cwd, runner);
         }
     }
 }