pi-lens 4.1.2 → 4.1.4

package/dist/clients/test-runner-client.js

@@ -10,14 +10,57 @@
  * 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 { BoundedFifoMap } from "./bounded-cache.js";
+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 { augmentPythonEnvironment, detectPythonEnvironment, } from "./python-environment.js";
+import { normalizeEphemeralMapKey, normalizeMapKey, toPosix, } from "./path-utils.js";
 import { isMeasuredDuration, toMeasuredDurationMs } from "./run-duration.js";
 import { safeSpawn, safeSpawnAsync } from "./safe-spawn.js";
+import { stripAnsi } from "./sanitize.js";
+/**
+ * #2532: the ONE classification seam for "this `TestResult` carries NO
+ * counted failure the agent needs to fix, even though the runner also
+ * reported an `error`" — i.e. `failed === 0 && !!error`. This is NOT "the
+ * suite never started": a runner can report BOTH counted failures and an
+ * error (pytest exit 2 "Interrupted" after `2 failed, 1 passed` already
+ * printed — `parsePytestOutput` sets `error` from the exit code
+ * independently of the parsed counts, review round 1 S2). The rule is
+ * exactly `failed === 0`, nothing about `error`'s presence or cause: a
+ * result with counted failures stays blocking even when `error` is also
+ * set (`testResultToProjectDiagnostics`/`formatResult` still mention the
+ * error in that case, they just don't let it downgrade the verdict).
+ *
+ * `hasRealFailure`/`runnerErrorOnly` (`runtime-turn.ts`, #2522) key off the
+ * exact same fact for the turn-end delivery framing — a batch made
+ * entirely of `isRunnerErrorResult` results is advisory, one containing
+ * even one counted failure keeps "fix before continuing". Three more
+ * surfaces route through this SAME predicate instead of re-deriving it
+ * (review round 1 S1's class sweep), so the identical `TestResult` cannot
+ * classify differently across them: `testResultToProjectDiagnostics`
+ * (`lens_diagnostics mode=full`), the `--lens-guard` merge call in
+ * `handleTurnEnd`, and `TestRunnerClient.formatResult`/the turn-end dbg
+ * summary (both in this file / `runtime-turn.ts`).
+ *
+ * Two call sites intentionally test the COMPLEMENT (a truly clean result,
+ * no counted failure AND no error) rather than this predicate, and are not
+ * a missed fourth spelling: `runtime-turn.ts`'s `cleanFiles` filter
+ * (`--lens-guard`'s clear-blocker list) and `testResultToProjectDiagnostics`'s
+ * own early "nothing to report" return. Both need "genuinely clean", which
+ * `!isRunnerErrorResult(result)` cannot express (it is also true for a
+ * counted failure).
+ */
+export function isRunnerErrorResult(result) {
+    return result.failed === 0 && !!result.error;
+}
 // Source file → test file patterns (reverse lookup)
 const SOURCE_TO_TEST_PATTERNS = [
     {
@@ -65,6 +108,57 @@ const MAX_NODE_MODULES_WALK_UP = 5;
 // test type rather than mirroring source layout) — capped depth, never an
 // unbounded walk of the whole tests tree.
 const MAX_PYTEST_RECURSE_DEPTH = 3;
+/**
+ * #2522: built-in exclusion list for the turn-end auto-fired test selection.
+ *
+ * `getTestRunTarget`'s three strategies (failed-first / related / self) will
+ * happily resolve to ANY test file on disk, including integration/e2e suites
+ * that spawn external processes. A plegma dogfooding turn resolved
+ * `tests/integration/opencode-delegate.test.ts` this way — it spawns
+ * `opencode` and needs a configured provider, so on a box without one it took
+ * 17s to fail and was reported to the agent as "3/3 failed, fix before
+ * proceeding" on an unrelated model-switch turn (#2522, refs #2504/#2509).
+ *
+ * One hard-coded list, no per-project config knob (maintainer decision
+ * 2026-09-03) — this is a safety bound on what turn_end may auto-fire, not a
+ * project preference. Documented in AGENTS.md and docs/. Matched against the
+ * resolved test file's project-relative, POSIX-folded path so it applies
+ * uniformly to whichever strategy produced the target.
+ */
+export const TURN_END_EXCLUDED_TEST_GLOBS = [
+    "**/integration/**",
+    "**/e2e/**",
+    "**/*.integration.*",
+    "**/*.e2e.*",
+];
+/**
+ * Whether a resolved test target falls under the built-in turn-end
+ * exclusion list (#2522). `testFilePath` may be absolute or relative, and
+ * may use either path-separator form — folded through `toPosix` after being
+ * made cwd-relative so `\`- and `/`-separated inputs match identically
+ * (AGENTS.md cross-form-path screen).
+ */
+export function isExcludedTestTarget(testFilePath, cwd) {
+    const rel = toPosix(path.relative(cwd, path.resolve(cwd, testFilePath)));
+    // #2522 review round 2, F6: a target that resolves OUTSIDE the project root
+    // yields a `..`-leading relative path (or, across Windows drives, a still
+    // absolute one), which matches none of the globs — so the bare `some()`
+    // below reported it as "not excluded" and turn_end would have auto-spawned a
+    // runner against a file outside the project the turn is running in. An
+    // out-of-tree target, and the project root itself, fail CLOSED.
+    if (rel === "" ||
+        rel === ".." ||
+        rel.startsWith("../") ||
+        path.isAbsolute(rel))
+        return true;
+    // #2522 review round 2, F5: case-INSENSITIVE. `tests/Integration/`,
+    // `tests/E2E/` and `foo.E2E.test.ts` are the same hazard as their lowercase
+    // spellings, and on the case-insensitive filesystems Windows and macOS ship
+    // by default they are literally the same files — so a case-sensitive match
+    // made the SAME repo excluded on one box and unbounded on another. A safety
+    // bound a capital letter defeats is not a bound.
+    return TURN_END_EXCLUDED_TEST_GLOBS.some((glob) => minimatch(rel, glob, { dot: true, nocase: true }));
+}
 // --- Runner Detection ---
 export const RUNNERS = {
     vitest: {
@@ -194,21 +288,158 @@ 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 };
+    }
+}
+export 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;
+}
+const PYTEST_SUMMARY_OUTCOME = "(?:passed|failed|skipped|reruns?|errors?|warnings?|deselected|xfailed|xpassed)";
+const PYTEST_SUMMARY_LINE = new RegExp(`^\\s*(?:=+\\s*)?\\d+\\s+${PYTEST_SUMMARY_OUTCOME}` +
+    `(?:\\s*,\\s*\\d+\\s+${PYTEST_SUMMARY_OUTCOME})*` +
+    `\\s+in\\s+[\\d.]+s(?:\\s*=+)?\\s*$`, "i");
+/** Extract aggregate values from pytest's final outcome line only. */
+function parsePytestSummary(output) {
+    // Pytest may color the whole summary or individual tokens. Strip ANSI before
+    // selecting and extracting so formatting cannot turn the first count into 0.
+    const normalizedOutput = stripAnsi(output);
+    const summaryLine = normalizedOutput
+        .split(/\r?\n/)
+        .reverse()
+        .find((line) => PYTEST_SUMMARY_LINE.test(line));
+    let passed = 0;
+    let failed = 0;
+    let skipped = 0;
+    if (!summaryLine)
+        return { passed, failed, skipped };
+    const summaryBody = summaryLine.replace(/^=+\s*|\s*=+\s*$/g, "");
+    for (const field of summaryBody.split(",")) {
+        const [countText, outcome] = field.trim().split(/\s+/, 2);
+        const count = Number.parseInt(countText, 10);
+        if (!Number.isFinite(count))
+            continue;
+        switch (outcome) {
+            case "passed":
+                passed = count;
+                break;
+            case "failed":
+                failed = count;
+                break;
+            case "skipped":
+                skipped = count;
+                break;
+        }
+    }
+    const durationMatch = /in\s+([\d.]+)s/.exec(summaryLine);
+    // Rounded, like `jsonRunDurationMs` and PHPUnit's legacy path:
+    // `in 2.01s` is 2009.9999999999998 in binary floating point.
+    const duration = durationMatch
+        ? Math.round(Number.parseFloat(durationMatch[1]) * 1000)
+        : undefined;
+    return { passed, failed, skipped, duration };
+}
 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 BoundedFifoMap(MAX_CANONICAL_ROOT_MEMO_ENTRIES);
+    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;
+        this.canonicalRootMemo.set(cwd, key);
+        return key;
+    }
+    /** #2442 test-only: exercise canonicalRootMemo's bounded eviction directly. */
+    _getCanonicalProjectRootForTests(cwd) {
+        return this.getCanonicalProjectRoot(cwd);
+    }
+    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 +449,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 +472,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 +491,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 +522,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 +676,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 +698,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 +750,7 @@ export class TestRunnerClient {
                     result.exclude = exclude;
             }
         }
-        this.vitestTestGlobsCache.set(cwd, result);
+        this.vitestTestGlobsCache.set(rootKey, { result, evidencePath: foundPath });
         return result;
     }
     /**
@@ -706,12 +976,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 +990,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,22 +1024,32 @@ 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, signal } = request;
         if (!fs.existsSync(absoluteTestFile)) {
             return this.emptyResult(absoluteTestFile, "", runner, "Test file not found");
         }
         try {
-            const { command, args } = await this.resolveExec(runner, config, absoluteTestFile, cwd);
+            const { command, args, env } = await this.resolveExec(runner, config, absoluteTestFile, cwd);
             this.log(`Running (async): ${command} ${args.join(" ")}`);
             const result = await safeSpawnAsync(command, args, {
                 cwd,
                 timeout: 60000,
+                env,
+                // #2522 R2 F1. `safeSpawnAsync` resolves `options.signal ?? ambient`,
+                // so an absent batch signal keeps the pre-#2522 ambient behaviour.
+                signal,
             });
             const stdout = result.stdout || "";
             const stderr = result.stderr || "";
@@ -811,7 +1078,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 +1092,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)
      */
@@ -970,31 +1409,9 @@ export class TestRunnerClient {
     parsePytestOutput(stdout, stderr, exitCode, testFile, _cwd, runner) {
         const failures = [];
         const output = `${stdout}\n${stderr}`;
-        // Parse summary line: "5 passed, 2 failed, 1 skipped in 0.23s"
-        const summaryMatch = output.match(/(\d+)\s+passed?.*?(\d+)\s+failed.*?in\s+([\d.]+)s/i) ||
-            output.match(/(\d+)\s+passed.*?in\s+([\d.]+)s/i);
-        let passed = 0;
-        let failed = 0;
-        let skipped = 0;
-        // #1479: undefined until pytest's own `in N.NNs` is read. `in 0.00s` is
-        // a real pytest summary, so 0 has to stay available as a measurement.
-        let duration;
-        if (summaryMatch) {
-            // Extract numbers from various patterns
-            const passedMatch = output.match(/(\d+)\s+passed/);
-            const failedMatch = output.match(/(\d+)\s+failed/);
-            const skippedMatch = output.match(/(\d+)\s+skipped/);
-            const durationMatch = output.match(/in\s+([\d.]+)s/);
-            passed = passedMatch ? parseInt(passedMatch[1], 10) : 0;
-            failed = failedMatch ? parseInt(failedMatch[1], 10) : 0;
-            skipped = skippedMatch ? parseInt(skippedMatch[1], 10) : 0;
-            // Rounded, like `jsonRunDurationMs` and PHPUnit's legacy path:
-            // `in 2.01s` is 2009.9999999999998 in binary floating point, and
-            // the turn-end log prints the number as it stands.
-            // (Routing this through `toMeasuredDurationMs` is #1484, not this.)
-            if (durationMatch)
-                duration = Math.round(parseFloat(durationMatch[1]) * 1000);
-        }
+        // #1479: `duration` stays undefined unless pytest emits its own `in N.NNs`
+        // summary. A measured `in 0.00s` remains a real zero.
+        const { passed, failed, skipped, duration } = parsePytestSummary(output);
         // Parse individual failures: "FAILED tests/test_foo.py::test_something - AssertionError: ..."
         const failureRegex = /FAILED\s+(\S+::\S+)\s*-\s*(.+?)(?:\n|$)/g;
         let match;
@@ -1022,7 +1439,11 @@ export class TestRunnerClient {
             skipped,
             failures,
             duration,
-            error: exitCode === 2 ? "Pytest configuration error" : undefined,
+            error: exitCode === 4
+                ? "Pytest configuration error"
+                : exitCode === 2
+                    ? "Pytest interrupted"
+                    : undefined,
         };
     }
     // --- PHPUnit Parser (text-based, default CLI output) ---
@@ -1043,7 +1464,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 +1546,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 +1924,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 +2018,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
@@ -1653,9 +2079,15 @@ export class TestRunnerClient {
      * Format test result for LLM consumption
      */
     formatResult(result) {
-        if (result.error && result.passed === 0 && result.failed === 0) {
-            // Runner error, not test failure
-            return `[Tests] ⚠ Could not run tests: ${result.error}`;
+        // #2532 review S1: folded onto `isRunnerErrorResult` instead of the old
+        // local `error && passed === 0 && failed === 0` spelling — that missed a
+        // runner error reported alongside partial passes (pytest `Interrupted`
+        // after some tests already ran clean), which fell through to the normal
+        // "N/N passed" branch below and silently dropped the interruption.
+        if (isRunnerErrorResult(result)) {
+            return result.passed > 0
+                ? `[Tests] ⚠ Could not complete tests: ${result.error} (${result.passed} passed before)`
+                : `[Tests] ⚠ Could not run tests: ${result.error}`;
         }
         const total = result.passed + result.failed + result.skipped;
         if (total === 0) {
@@ -1720,9 +2152,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 [];
     }
@@ -1788,6 +2218,19 @@ export class TestRunnerClient {
      * runners like vitest/jest/pytest).
      */
     async resolveExec(runner, config, testFile, cwd) {
+        // Run pytest through the project interpreter itself, not a generic `python`
+        // resolved from the host PATH. The child-only environment also keeps tools
+        // spawned by tests inside the same project environment.
+        if (runner === "pytest") {
+            const pythonEnvironment = await detectPythonEnvironment(cwd);
+            if (pythonEnvironment) {
+                return {
+                    command: pythonEnvironment.pythonPath,
+                    args: config.args(testFile, cwd),
+                    env: augmentPythonEnvironment(process.env, pythonEnvironment),
+                };
+            }
+        }
         // PHPUnit has no npx-style automatic local-binary resolution — Composer's
         // standard local-install location is vendor/bin/phpunit, so check that
         // explicitly before falling back to a global `phpunit` on PATH.
@@ -1806,12 +2249,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 +2285,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);
         }
     }
 }