@duckmind/dm-linux-x64 0.65.5 → 0.65.7

package/extensions/dm-lens/dist/clients/test-runner-client.js

@@ -0,0 +1,1504 @@
+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 { detectFileKind } from "./file-kinds.js";
+import { detectFileRole } from "./file-role.js";
+import { resolveLanguageRootForFile } from "./language-profile.js";
+import { findGlobalBinary } from "./package-manager.js";
+import { PathKeyedMap } from "./path-keyed-map.js";
+import { augmentPythonEnvironment, detectPythonEnvironment } from "./python-environment.js";
+import { isUnderDir, normalizeEphemeralMapKey, normalizeMapKey, toPosix } from "./path-utils.js";
+import { findNearestDirWithAnyBasename } from "./workspace-topology.js";
+import { isMeasuredDuration, toMeasuredDurationMs } from "./run-duration.js";
+import { safeSpawn, safeSpawnAsync } from "./safe-spawn.js";
+import { stripAnsi } from "./sanitize.js";
+import { resolveToolCwd } from "./tool-cwd.js";
+export function isRunnerErrorResult(result) {
+  return result.failed === 0 && !!result.error;
+}
+export const SOURCE_TO_TEST_PATTERNS = [
+  {
+    ext: ".ts",
+    testExts: [".test.ts", ".spec.ts"],
+    dirs: ["__tests__", "tests", ".", "__tests__"]
+  },
+  {
+    ext: ".tsx",
+    testExts: [".test.tsx", ".spec.tsx"],
+    dirs: ["__tests__", "tests", ".", "__tests__"]
+  },
+  {
+    ext: ".js",
+    testExts: [".test.js", ".spec.js"],
+    dirs: ["__tests__", "tests", ".", "__tests__"]
+  },
+  {
+    ext: ".jsx",
+    testExts: [".test.jsx", ".spec.jsx"],
+    dirs: ["__tests__", "tests", ".", "__tests__"]
+  },
+  {
+    ext: ".py",
+    testExts: ["test_*.py", "*_test.py"],
+    dirs: ["tests", "test", ".", "."]
+  },
+  { ext: ".go", testExts: ["_test.go"], dirs: [".", ".", ".", "."] },
+  { ext: ".rs", testExts: [".rs"], dirs: ["tests", "tests", "src", "."] },
+  { ext: ".php", testExts: ["Test.php"], dirs: ["tests"] },
+  { ext: ".ex", testExts: ["_test.exs"], dirs: ["test"] }
+];
+function findHoistedNodeModulesPackage(cwd, packageName) {
+  return findNearestDirWithAnyBasename(path.resolve(cwd), [
+    `node_modules/${packageName}`
+  ]);
+}
+const MAX_PYTEST_RECURSE_DEPTH = 3;
+export const TURN_END_EXCLUDED_TEST_GLOBS = [
+  "**/integration/**",
+  "**/e2e/**",
+  "**/*.integration.*",
+  "**/*.e2e.*"
+];
+export function isExcludedTestTarget(testFilePath, cwd) {
+  const rel = toPosix(path.relative(cwd, path.resolve(cwd, testFilePath)));
+  if (rel === "" || rel === ".." || rel.startsWith("../") || path.isAbsolute(rel))
+    return true;
+  return TURN_END_EXCLUDED_TEST_GLOBS.some((glob) => minimatch(rel, glob, { dot: true, nocase: true }));
+}
+export const RUNNERS = {
+  vitest: {
+    kinds: ["jsts"],
+    configFiles: ["vitest.config.ts", "vitest.config.js", "vitest.config.mjs"],
+    command: "npx",
+    binName: "vitest",
+    args: (testFile, _cwd) => [
+      "vitest",
+      "run",
+      testFile,
+      "--reporter=json",
+      "--passWithNoTests"
+    ],
+    parseJson: true
+  },
+  jest: {
+    kinds: ["jsts"],
+    configFiles: [
+      "jest.config.ts",
+      "jest.config.js",
+      "jest.config.json",
+      ".jestrc.js"
+    ],
+    command: "npx",
+    binName: "jest",
+    args: (testFile, _cwd) => [
+      "jest",
+      testFile,
+      "--json",
+      "--passWithNoTests",
+      "--forceExit"
+    ],
+    parseJson: true
+  },
+  pytest: {
+    kinds: ["python"],
+    configFiles: ["pytest.ini", "pyproject.toml", "setup.cfg", "tox.ini"],
+    spawnCwdMarkers: ["pytest.ini", "tox.ini", "setup.cfg"],
+    command: "python",
+    args: (testFile, _cwd) => ["-m", "pytest", testFile, "--tb=short", "-q"],
+    parseJson: false
+  },
+  go: {
+    kinds: ["go"],
+    configFiles: ["go.mod"],
+    command: "go",
+    args: (testFile, cwd) => {
+      const relPath = path.relative(cwd, testFile);
+      const pkgDir = path.dirname(relPath);
+      return ["test", `-run`, ".", `./${pkgDir === "." ? "." : pkgDir}`];
+    },
+    parseJson: false
+  },
+  cargo: {
+    kinds: ["rust"],
+    configFiles: ["Cargo.toml"],
+    command: "cargo",
+    args: (_testFile, _cwd) => ["test", "--no-fail-fast"],
+    parseJson: false
+  },
+  dotnet: {
+    kinds: ["csharp", "fsharp"],
+    configFiles: ["*.csproj", "*.sln"],
+    command: "dotnet",
+    args: (_testFile, _cwd) => ["test", "--no-build"],
+    parseJson: false
+  },
+  gradle: {
+    kinds: ["java", "kotlin"],
+    configFiles: [
+      "build.gradle",
+      "build.gradle.kts",
+      "settings.gradle",
+      "settings.gradle.kts"
+    ],
+    command: process.platform === "win32" ? "gradlew.bat" : "./gradlew",
+    spawnCwdMarkers: ["gradlew", "gradlew.bat"],
+    args: (_testFile, _cwd) => ["test", "--no-daemon"],
+    parseJson: false
+  },
+  maven: {
+    kinds: ["java", "kotlin"],
+    configFiles: ["pom.xml"],
+    command: "mvn",
+    args: (_testFile, _cwd) => ["test", "-q"],
+    parseJson: false
+  },
+  rspec: {
+    kinds: ["ruby"],
+    configFiles: [".rspec", "spec/spec_helper.rb"],
+    command: "bundle",
+    binName: "bundle",
+    args: (testFile, _cwd) => ["exec", "rspec", testFile],
+    parseJson: false
+  },
+  minitest: {
+    kinds: ["ruby"],
+    configFiles: ["Gemfile"],
+    command: "ruby",
+    args: (testFile, _cwd) => ["-Itest", testFile],
+    parseJson: false
+  },
+  phpunit: {
+    kinds: ["php"],
+    configFiles: ["phpunit.xml", "phpunit.xml.dist", "composer.json"],
+    spawnCwdMarkers: ["phpunit.xml", "phpunit.xml.dist"],
+    command: "phpunit",
+    args: (testFile, _cwd) => [testFile],
+    parseJson: false
+  },
+  mix: {
+    kinds: ["elixir"],
+    configFiles: ["mix.exs"],
+    command: "mix",
+    args: (testFile, _cwd) => ["test", testFile],
+    parseJson: false
+  }
+};
+export function stripWrapperArgs(binName, args) {
+  if (args[0] === binName)
+    return args.slice(1);
+  if (args[0] === "-m" && args[1] === binName)
+    return args.slice(2);
+  return args;
+}
+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;
+}
+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");
+function parsePytestSummary(output) {
+  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);
+  const duration = durationMatch ? Math.round(Number.parseFloat(durationMatch[1]) * 1000) : undefined;
+  return { passed, failed, skipped, duration };
+}
+
+export class TestRunnerClient {
+  log;
+  canonicalRootMemo = new BoundedFifoMap(MAX_CANONICAL_ROOT_MEMO_ENTRIES);
+  availableRunners = new PathKeyedMap(normalizeEphemeralMapKey);
+  failedTestsByRunner = new Map;
+  failedTargetSequence = 0;
+  statFailedTarget;
+  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;
+  }
+  _getCanonicalProjectRootForTests(cwd) {
+    return this.getCanonicalProjectRoot(cwd);
+  }
+  getRunnerAvailability(byRunner, runner) {
+    const cached = byRunner?.get(runner);
+    if (!cached)
+      return;
+    if (cached.available && cached.evidencePath !== undefined && !fs.existsSync(cached.evidencePath)) {
+      byRunner?.delete(runner);
+      return;
+    }
+    return cached.available;
+  }
+  setRunnerAvailability(byRunner, runner, available, evidencePath) {
+    if (!available)
+      return;
+    byRunner.set(runner, { available, evidencePath });
+  }
+  resolveDetectionScope(cwd, sourceFilePath) {
+    if (sourceFilePath === undefined)
+      return { root: cwd, eligible: null };
+    const absoluteFile = path.resolve(sourceFilePath);
+    if (!isUnderDir(absoluteFile, path.resolve(cwd))) {
+      return { root: cwd, eligible: null };
+    }
+    const kind = detectFileKind(absoluteFile);
+    if (!kind)
+      return null;
+    const eligible = new Set(Object.entries(RUNNERS).filter(([, config]) => config.kinds.includes(kind)).map(([name]) => name));
+    if (eligible.size === 0)
+      return null;
+    return {
+      root: resolveLanguageRootForFile(absoluteFile, cwd),
+      eligible
+    };
+  }
+  detectRunner(dispatchRoot, sourceFilePath) {
+    const scope = this.resolveDetectionScope(dispatchRoot, sourceFilePath);
+    if (!scope)
+      return null;
+    const { root, eligible } = scope;
+    const anchored = this.probeRunnersAt(root, eligible);
+    if (anchored)
+      return anchored;
+    const dispatch = path.resolve(dispatchRoot);
+    if (path.resolve(root) !== dispatch) {
+      const atDispatch = this.probeRunnersAt(dispatch, eligible);
+      if (atDispatch)
+        return atDispatch;
+    }
+    const isPythonSource = typeof sourceFilePath === "string" && sourceFilePath.endsWith(".py");
+    if (!isPythonSource)
+      return null;
+    try {
+      const whichCmd = process.platform === "win32" ? "where" : "which";
+      const result = safeSpawn(whichCmd, ["pytest"], {
+        timeout: 2000
+      });
+      if (result.status === 0) {
+        this.log("Detected pytest globally");
+        return { runner: "pytest", config: RUNNERS.pytest };
+      }
+    } catch (err) {}
+    return null;
+  }
+  probeRunnersAt(cwd, eligible) {
+    const rootKey = this.getCanonicalProjectRoot(cwd);
+    let byRunner = this.availableRunners.get(rootKey);
+    if (!byRunner) {
+      byRunner = new Map;
+      this.availableRunners.set(rootKey, byRunner);
+    }
+    for (const [name, config] of Object.entries(RUNNERS)) {
+      if (eligible && !eligible.has(name))
+        continue;
+      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);
+          if (!fs.existsSync(pyprojectPath))
+            return false;
+          try {
+            const pyproject = fs.readFileSync(pyprojectPath, "utf-8");
+            const matches = pyproject.includes("[tool.pytest.ini_options]");
+            if (matches)
+              configEvidencePath = pyprojectPath;
+            return matches;
+          } catch {
+            return false;
+          }
+        }
+        if (name === "phpunit" && cf === "composer.json") {
+          const composerPath = path.join(cwd, cf);
+          if (!fs.existsSync(composerPath))
+            return false;
+          try {
+            const composer = JSON.parse(fs.readFileSync(composerPath, "utf-8"));
+            const allDeps = {
+              ...composer.require,
+              ...composer["require-dev"]
+            };
+            const matches = Boolean(allDeps["phpunit/phpunit"]);
+            if (matches)
+              configEvidencePath = composerPath;
+            return matches;
+          } catch {
+            return false;
+          }
+        }
+        const candidate = path.join(cwd, cf);
+        const matches = fs.existsSync(candidate);
+        if (matches)
+          configEvidencePath = candidate;
+        return matches;
+      });
+      this.setRunnerAvailability(byRunner, name, found, configEvidencePath);
+      if (found) {
+        this.log(`Detected runner via config: ${name}`);
+        return { runner: name, config };
+      }
+    }
+    const packageJsonPath = path.join(cwd, "package.json");
+    try {
+      const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+      const allDeps = {
+        ...pkg.dependencies,
+        ...pkg.devDependencies
+      };
+      if (allDeps.vitest && (!eligible || eligible.has("vitest"))) {
+        this.log("Detected vitest in package.json");
+        this.setRunnerAvailability(byRunner, "vitest", true, packageJsonPath);
+        return { runner: "vitest", config: RUNNERS.vitest };
+      }
+      if (allDeps.jest && (!eligible || eligible.has("jest"))) {
+        this.log("Detected jest in package.json");
+        this.setRunnerAvailability(byRunner, "jest", true, packageJsonPath);
+        return { runner: "jest", config: RUNNERS.jest };
+      }
+      if ((allDeps.pytest || allDeps["pytest-cov"]) && (!eligible || eligible.has("pytest"))) {
+        this.log("Detected pytest in package.json (unusual)");
+        this.setRunnerAvailability(byRunner, "pytest", true, packageJsonPath);
+        return { runner: "pytest", config: RUNNERS.pytest };
+      }
+    } catch (err) {}
+    for (const name of ["vitest", "jest"]) {
+      if (eligible && !eligible.has(name))
+        continue;
+      const hoisted = findHoistedNodeModulesPackage(cwd, name);
+      if (hoisted) {
+        this.log(`Detected ${name} in node_modules (${hoisted})`);
+        return { runner: name, config: RUNNERS[name] };
+      }
+    }
+    for (const name of ["go", "cargo", "dotnet", "gradle", "maven"]) {
+      if (eligible && !eligible.has(name))
+        continue;
+      const config = RUNNERS[name];
+      const found = config.configFiles.some((cf) => {
+        if (cf.includes("*")) {
+          try {
+            const files = fs.readdirSync(cwd);
+            return files.some((f) => new RegExp(cf.replace(/\*/g, ".*")).test(f));
+          } catch {
+            return false;
+          }
+        }
+        return fs.existsSync(path.join(cwd, cf));
+      });
+      if (found) {
+        this.log(`Detected ${name} from config file`);
+        return { runner: name, config };
+      }
+    }
+    return null;
+  }
+  findPytestMatchRecursive(rootDir, pattern, basename, maxDepth) {
+    const queue = [
+      { dir: rootDir, depth: 0 }
+    ];
+    while (queue.length > 0) {
+      const next = queue.shift();
+      if (!next)
+        break;
+      const { dir, depth } = next;
+      let entries;
+      try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isFile()) {
+          if (entry.name === pattern || entry.name.startsWith("test_") && entry.name.endsWith(".py") && entry.name.includes(basename)) {
+            return fullPath;
+          }
+        } else if (entry.isDirectory() && depth < maxDepth) {
+          if (entry.name === "__pycache__" || entry.name.startsWith("."))
+            continue;
+          queue.push({ dir: fullPath, depth: depth + 1 });
+        }
+      }
+    }
+    return null;
+  }
+  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)) {
+      return null;
+    }
+    return relDir;
+  }
+  parseVitestTestGlobs(cwd) {
+    const rootKey = this.getCanonicalProjectRoot(cwd);
+    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(candidatePath, "utf-8");
+        foundPath = candidatePath;
+        break;
+      } catch {
+        continue;
+      }
+    }
+    let result = null;
+    if (content !== null) {
+      const include = this.extractGlobArrayLiteral(content, "include");
+      const exclude = this.extractGlobArrayLiteral(content, "exclude");
+      if (include || exclude) {
+        result = {};
+        if (include)
+          result.include = include;
+        if (exclude)
+          result.exclude = exclude;
+      }
+    }
+    this.vitestTestGlobsCache.set(rootKey, { result, evidencePath: foundPath });
+    return result;
+  }
+  extractGlobArrayLiteral(content, key) {
+    const arrayMatch = content.match(new RegExp(`\\b${key}\\s*:\\s*\\[([^\\]]*)\\]`));
+    if (!arrayMatch)
+      return;
+    const body = arrayMatch[1];
+    const literalPattern = /'([^'\\]*)'|"([^"\\]*)"|`([^`\\]*)`/g;
+    const literals = [];
+    let lastEnd = 0;
+    let match;
+    while ((match = literalPattern.exec(body)) !== null) {
+      const between = body.slice(lastEnd, match.index).trim();
+      if (between !== "" && !/^,$/.test(between))
+        return;
+      literals.push(match[1] ?? match[2] ?? match[3] ?? "");
+      lastEnd = literalPattern.lastIndex;
+    }
+    const trailing = body.slice(lastEnd).trim();
+    if (trailing !== "" && trailing !== ",")
+      return;
+    return literals.length > 0 ? literals : undefined;
+  }
+  isTestFile(sourceFilePath, cwd, runner) {
+    let result = detectFileRole(sourceFilePath) === "test";
+    if (runner === "vitest") {
+      const globs = this.parseVitestTestGlobs(cwd);
+      if (globs) {
+        const rel = path.relative(cwd, path.resolve(cwd, sourceFilePath)).replace(/\\/g, "/");
+        const matches = (globs_, filter) => !!globs_?.some((g) => (!filter || filter(g)) && minimatch(rel, g, { dot: true }));
+        if (matches(globs.exclude)) {
+          result = false;
+        } else if (!result && matches(globs.include, (g) => this.isNarrowTestGlob(g))) {
+          result = true;
+        }
+      }
+    }
+    return result;
+  }
+  isNarrowTestGlob(glob) {
+    const testDirPattern = /^(tests?|specs?|__tests__)$/i;
+    for (const segment of glob.split("/")) {
+      if (segment.includes("*") || segment.includes("?"))
+        break;
+      if (testDirPattern.test(segment))
+        return true;
+    }
+    const lastWildcard = Math.max(glob.lastIndexOf("*"), glob.lastIndexOf("?"));
+    const suffix = lastWildcard >= 0 ? glob.slice(lastWildcard + 1) : glob;
+    const dotSegments = suffix.split(".").filter(Boolean);
+    return dotSegments.length >= 2;
+  }
+  findTestFile(sourceFilePath, cwd, runnerOverride) {
+    const ext = path.extname(sourceFilePath);
+    const basename = path.basename(sourceFilePath, ext);
+    const dir = path.dirname(sourceFilePath);
+    const patterns = SOURCE_TO_TEST_PATTERNS.find((p) => p.ext === ext);
+    if (!patterns)
+      return null;
+    const detected = runnerOverride ? { runner: runnerOverride, config: RUNNERS[runnerOverride] } : this.detectRunner(cwd, sourceFilePath);
+    if (!detected)
+      return null;
+    const relDir = this.relativeSourceDir(sourceFilePath, cwd);
+    for (let i = 0;i < patterns.testExts.length; i++) {
+      const testExt = patterns.testExts[i];
+      const testDir = patterns.dirs[i];
+      if (testExt.includes("*")) {
+        const pattern = testExt.replace(/\*/g, basename);
+        const searchDirs = testDir === "." ? [dir] : relDir ? [path.join(cwd, testDir, relDir), path.join(cwd, testDir)] : [path.join(cwd, testDir)];
+        for (const searchDir of searchDirs) {
+          let files;
+          try {
+            files = fs.readdirSync(searchDir);
+          } catch (err) {
+            continue;
+          }
+          const match = files.find((f) => f === pattern || f.startsWith("test_") && f.endsWith(".py") && f.includes(basename));
+          if (match) {
+            const testPath = path.join(searchDir, match);
+            this.log(`Found test file: ${testPath}`);
+            return { testFile: testPath, runner: detected.runner };
+          }
+        }
+        if (testDir !== ".") {
+          const recursiveMatch = this.findPytestMatchRecursive(path.join(cwd, testDir), pattern, basename, MAX_PYTEST_RECURSE_DEPTH);
+          if (recursiveMatch) {
+            this.log(`Found test file (recursive): ${recursiveMatch}`);
+            return { testFile: recursiveMatch, runner: detected.runner };
+          }
+        }
+      } else {
+        const testFilename = basename + testExt;
+        const searchPaths = [
+          path.join(dir, testFilename),
+          path.join(dir, "__tests__", testFilename),
+          ...relDir ? [
+            path.join(cwd, "tests", relDir, testFilename),
+            path.join(cwd, "__tests__", relDir, testFilename)
+          ] : [],
+          path.join(cwd, "tests", testFilename),
+          path.join(cwd, "__tests__", testFilename),
+          ...this.sourceRootMirroredCandidates(dir, cwd, testDir, testFilename)
+        ];
+        for (const testPath of searchPaths) {
+          if (fs.existsSync(testPath)) {
+            this.log(`Found test file: ${testPath}`);
+            return { testFile: testPath, runner: detected.runner };
+          }
+        }
+      }
+    }
+    const importMatch = this.findTestFileByImport(sourceFilePath, cwd);
+    if (importMatch) {
+      return { testFile: importMatch, runner: detected.runner };
+    }
+    return null;
+  }
+  getTestRunTarget(sourceFilePath, cwd, turnIndex) {
+    const detected = this.detectRunner(cwd, sourceFilePath);
+    if (!detected)
+      return null;
+    const failedSet = this.getFailedTargets(cwd, detected.runner);
+    const selfIsTest = this.isTestFile(sourceFilePath, cwd, detected.runner);
+    const related = selfIsTest ? null : this.findTestFile(sourceFilePath, cwd, detected.runner);
+    if (failedSet && failedSet.size > 0) {
+      const failedFirst = this.retireMissingFailedTargets({
+        cwd,
+        runner: detected.runner,
+        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 {
+        testFile: path.resolve(sourceFilePath),
+        runner: detected.runner,
+        config: detected.config,
+        strategy: "self"
+      };
+    }
+    if (!related)
+      return null;
+    return {
+      testFile: path.resolve(related.testFile),
+      runner: detected.runner,
+      config: detected.config,
+      strategy: "related"
+    };
+  }
+  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 spawnCwd = resolveToolCwd("runner", runner, absoluteTestFile, {
+        cwd: path.resolve(cwd),
+        rootMarkers: config.spawnCwdMarkers ?? config.configFiles
+      }).cwd;
+      const { command, args, env } = await this.resolveExec(runner, config, absoluteTestFile, cwd, spawnCwd);
+      this.log(`Running (async): ${command} ${args.join(" ")} (cwd ${spawnCwd})`);
+      const result = await safeSpawnAsync(command, args, {
+        cwd: spawnCwd,
+        timeout: 60000,
+        env,
+        signal
+      });
+      const stdout = result.stdout || "";
+      const stderr = result.stderr || "";
+      if (result.error) {
+        this.log(`Runner error: ${result.error.message}`);
+        return this.emptyResult(absoluteTestFile, "", runner, `Runner error: ${result.error.message}`);
+      }
+      let parsed;
+      switch (runner) {
+        case "vitest":
+          parsed = this.parseVitestOutput(stdout, stderr, absoluteTestFile, cwd, runner);
+          break;
+        case "jest":
+          parsed = this.parseJestOutput(stdout, stderr, absoluteTestFile, cwd, runner);
+          break;
+        case "pytest":
+          parsed = this.parsePytestOutput(stdout, stderr, result.status ?? 0, absoluteTestFile, cwd, runner);
+          break;
+        case "phpunit":
+          parsed = this.parsePhpunitOutput(stdout, stderr, result.status ?? 0, absoluteTestFile, runner);
+          break;
+        case "mix":
+          parsed = this.parseMixTestOutput(stdout, stderr, result.status ?? 0, absoluteTestFile, runner);
+          break;
+        default:
+          parsed = this.parseGenericRunnerOutput(stdout, stderr, result.status ?? 0, absoluteTestFile, runner);
+          break;
+      }
+      this.recordResult({
+        cwd,
+        runner,
+        testFile: absoluteTestFile,
+        result: parsed,
+        turnIndex
+      });
+      return parsed;
+    } catch (err) {
+      this.log(`Run error: ${err.message}`);
+      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;
+    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;
+    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;
+    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("\x00").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
+      }
+    });
+  }
+  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;
+      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;
+      }
+      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;
+  }
+  hasTestFile(sourceFilePath, cwd) {
+    return this.findTestFile(sourceFilePath, cwd) !== null;
+  }
+  suggestTestFiles(sourceFiles, cwd) {
+    const seen = new Set;
+    const results = [];
+    for (const sourceFile of sourceFiles) {
+      const found = this.findTestFile(sourceFile, cwd);
+      if (!found)
+        continue;
+      const abs = path.resolve(found.testFile);
+      if (seen.has(abs))
+        continue;
+      seen.add(abs);
+      results.push({ testFile: abs, sourceFile, runner: found.runner });
+    }
+    return results;
+  }
+  parseJsonTestOutput(stdout, stderr, testFile, cwd, runner) {
+    try {
+      const json = JSON.parse(stdout);
+      const failures = [];
+      for (const suite of json.testResults || []) {
+        if (suite.status === "failed" && suite.assertionResults) {
+          for (const test of suite.assertionResults) {
+            if (test.status === "failed") {
+              failures.push({
+                name: test.title,
+                message: test.failureMessages?.[0] || suite.message || "Test failed",
+                location: test.location ? `${path.relative(cwd, testFile)}:${test.location.line}` : undefined,
+                stack: this.truncateStack(test.failureMessages?.join(`
+`))
+              });
+            }
+          }
+        }
+      }
+      return {
+        file: testFile,
+        sourceFile: "",
+        runner,
+        passed: json.numPassedTests || 0,
+        failed: json.numFailedTests || 0,
+        skipped: Math.max(json.numSkippedTests ?? 0, (json.numPendingTests || 0) + (json.numTodoTests || 0)),
+        failures,
+        duration: this.jsonRunDurationMs(json.testResults)
+      };
+    } catch (err) {
+      const failed = stdout.includes("FAIL") || stderr.includes("FAIL");
+      return this.emptyResult(testFile, "", runner, failed ? "Tests failed (could not parse output)" : undefined);
+    }
+  }
+  jsonRunDurationMs(suites) {
+    let minStart = Number.POSITIVE_INFINITY;
+    let maxEnd = Number.NEGATIVE_INFINITY;
+    let assertionTotal = 0;
+    for (const suite of suites || []) {
+      if (typeof suite.startTime === "number" && Number.isFinite(suite.startTime) && typeof suite.endTime === "number" && Number.isFinite(suite.endTime)) {
+        minStart = Math.min(minStart, suite.startTime);
+        maxEnd = Math.max(maxEnd, suite.endTime);
+      }
+      for (const assertion of suite.assertionResults || []) {
+        if (typeof assertion.duration === "number" && Number.isFinite(assertion.duration) && assertion.duration > 0) {
+          assertionTotal += assertion.duration;
+        }
+      }
+    }
+    const span = maxEnd - minStart;
+    if (Number.isFinite(span) && span > 0)
+      return Math.round(span);
+    if (assertionTotal > 0)
+      return Math.round(assertionTotal);
+    if (Number.isFinite(span) && span === 0)
+      return 0;
+    return;
+  }
+  parseVitestOutput(stdout, stderr, testFile, cwd, runner) {
+    return this.parseJsonTestOutput(stdout, stderr, testFile, cwd, runner);
+  }
+  parseJestOutput(stdout, stderr, testFile, cwd, runner) {
+    return this.parseJsonTestOutput(stdout, stderr, testFile, cwd, runner);
+  }
+  parsePytestOutput(stdout, stderr, exitCode, testFile, _cwd, runner) {
+    const failures = [];
+    const output = `${stdout}
+${stderr}`;
+    const { passed, failed, skipped, duration } = parsePytestSummary(output);
+    const failureRegex = /FAILED\s+(\S+::\S+)\s*-\s*(.+?)(?:\n|$)/g;
+    let match;
+    while ((match = failureRegex.exec(output)) !== null) {
+      failures.push({
+        name: match[1],
+        message: match[2].trim().slice(0, 500),
+        location: match[1].replace("::", ":")
+      });
+    }
+    const tracebackRegex = /_{10,}\s*\n\s*(\w+Error:\s*.+?)(?:\n|$)/gs;
+    while ((match = tracebackRegex.exec(output)) !== null) {
+      if (failures.length > 0 && !failures[failures.length - 1].stack) {
+        failures[failures.length - 1].stack = match[1].trim().slice(0, 1000);
+      }
+    }
+    return {
+      file: testFile,
+      sourceFile: "",
+      runner,
+      passed,
+      failed,
+      skipped,
+      failures,
+      duration,
+      error: exitCode === 4 ? "Pytest configuration error" : exitCode === 2 ? "Pytest interrupted" : undefined
+    };
+  }
+  parsePhpunitOutput(stdout, stderr, exitCode, testFile, runner) {
+    const output = `${stdout}
+${stderr}`;
+    let passed = 0;
+    let failed = 0;
+    let skipped = 0;
+    const okMatch = output.match(/OK\s*\((\d+)\s+tests?,\s*\d+\s+assertions?\)/i);
+    if (okMatch) {
+      passed = Number.parseInt(okMatch[1], 10);
+    } else {
+      const testsMatch = output.match(/Tests:\s*(\d+)/i);
+      const failuresMatch = output.match(/Failures:\s*(\d+)/i);
+      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 errors = errorsMatch ? Number.parseInt(errorsMatch[1], 10) : 0;
+      skipped = skippedMatch ? Number.parseInt(skippedMatch[1], 10) : 0;
+      failed = failures + errors;
+      passed = Math.max(0, total - failed - skipped);
+    }
+    const failures = [];
+    const failureRegex = /^\d+\)\s+(\S+)/gm;
+    let match;
+    while ((match = failureRegex.exec(output)) !== null) {
+      failures.push({ name: match[1], message: match[1] });
+    }
+    let duration;
+    const clockMatch = output.match(/^Time:\s*(?:(\d+):)?(\d{1,2}):(\d{2})(?:\.(\d{1,3}))?/im);
+    if (clockMatch) {
+      const hours = clockMatch[1] ? Number.parseInt(clockMatch[1], 10) : 0;
+      const minutes = Number.parseInt(clockMatch[2], 10);
+      const seconds = Number.parseInt(clockMatch[3], 10);
+      const millis = clockMatch[4] ? Number.parseInt(clockMatch[4].padEnd(3, "0"), 10) : 0;
+      duration = ((hours * 60 + minutes) * 60 + seconds) * 1000 + millis;
+    } else {
+      const legacyMatch = output.match(/^Time:\s*([\d.]+)\s*(seconds?|s|ms|milliseconds?|minutes?)\b/im);
+      if (legacyMatch) {
+        const value = Number.parseFloat(legacyMatch[1]);
+        const unit = legacyMatch[2].toLowerCase();
+        const scale = unit.startsWith("ms") || unit.startsWith("milli") ? 1 : unit.startsWith("min") ? 60000 : 1000;
+        if (Number.isFinite(value) && value > 0) {
+          duration = Math.round(value * scale);
+        }
+      }
+    }
+    return {
+      file: testFile,
+      sourceFile: "",
+      runner,
+      passed,
+      failed,
+      skipped,
+      failures,
+      duration,
+      error: exitCode !== 0 && passed === 0 && failed === 0 ? "PHPUnit runner error" : undefined
+    };
+  }
+  parseMixTestOutput(stdout, stderr, exitCode, testFile, runner) {
+    const output = `${stdout}
+${stderr}`;
+    let passed = 0;
+    let failed = 0;
+    let skipped = 0;
+    let duration;
+    const summaryMatch = output.match(/(\d+)\s+tests?,\s*(\d+)\s+failures?(?:,\s*(\d+)\s+excluded)?(?:,\s*(\d+)\s+skipped)?/i);
+    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 skippedCount = summaryMatch[4] ? Number.parseInt(summaryMatch[4], 10) : 0;
+      skipped = excluded + skippedCount;
+      passed = Math.max(0, total - failed - skipped);
+    }
+    const durationMatch = output.match(/Finished in\s+([\d.]+)\s+seconds?/i);
+    if (durationMatch) {
+      duration = Math.round(Number.parseFloat(durationMatch[1]) * 1000);
+    }
+    const failures = [];
+    const failureRegex = /^\s*\d+\)\s+(.+?)\s*\(([^)]+)\)\s*$/gm;
+    let match;
+    while ((match = failureRegex.exec(output)) !== null) {
+      failures.push({
+        name: match[1].trim(),
+        message: match[1].trim(),
+        location: match[2].trim()
+      });
+    }
+    return {
+      file: testFile,
+      sourceFile: "",
+      runner,
+      passed,
+      failed,
+      skipped,
+      failures,
+      duration,
+      error: exitCode !== 0 && passed === 0 && failed === 0 ? "mix test runner error" : undefined
+    };
+  }
+  parseGenericRunnerDuration(output, runner) {
+    switch (runner) {
+      case "go":
+        return this.parseGoDuration(output);
+      case "cargo":
+        return this.parseCargoDuration(output);
+      case "dotnet":
+        return this.parseDotnetDuration(output);
+      case "maven":
+        return this.parseMavenDuration(output);
+      case "rspec":
+        return this.parseRspecDuration(output);
+      case "minitest":
+        return this.parseMinitestDuration(output);
+      default:
+        return;
+    }
+  }
+  parseGoDuration(output) {
+    const goSummary = output.match(/ok\s+\S+\s+([\d.]+)s/m);
+    if (!goSummary)
+      return;
+    return toMeasuredDurationMs(Number.parseFloat(goSummary[1]) * 1000);
+  }
+  parseCargoDuration(output) {
+    const cargoTime = output.match(/^test result:.*?;\s*finished in\s+([\d.]+)\s*s\b/im);
+    if (!cargoTime)
+      return;
+    return toMeasuredDurationMs(Number.parseFloat(cargoTime[1]) * 1000);
+  }
+  parseDotnetDuration(output) {
+    const dotnetTime = output.match(/Failed:\s*\d+,\s*Passed:\s*\d+,\s*Skipped:\s*\d+,\s*Total:\s*\d+,\s*Duration:\s*([^\r\n-]+)/i);
+    if (!dotnetTime)
+      return;
+    if (/^\s*</.test(dotnetTime[1]))
+      return 0;
+    let total = 0;
+    let tokens = 0;
+    const units = {
+      ms: 1,
+      s: 1000,
+      m: 60000,
+      h: 3600000
+    };
+    for (const token of dotnetTime[1].matchAll(/([\d.]+)\s*(ms|h|m|s)\b/gi)) {
+      total += Number.parseFloat(token[1]) * units[token[2].toLowerCase()];
+      tokens++;
+    }
+    if (tokens === 0)
+      return;
+    return toMeasuredDurationMs(total);
+  }
+  parseMavenDuration(output) {
+    let surefireTotal = 0;
+    let matched = false;
+    for (const line of output.matchAll(/^.*Tests run:\s*\d+,.*?Time elapsed:\s*([\d.]+)\s*(?:s|sec|secs|seconds)\b.*$/gim)) {
+      const seconds = Number.parseFloat(line[1]);
+      if (!Number.isFinite(seconds) || seconds < 0)
+        continue;
+      surefireTotal += seconds;
+      matched = true;
+    }
+    if (!matched)
+      return;
+    return toMeasuredDurationMs(surefireTotal * 1000);
+  }
+  parseRspecDuration(output) {
+    const rspecTime = output.match(/^Finished in\s+(?:([\d.]+)\s+minutes?\s+)?([\d.]+)\s+seconds?/im);
+    if (!rspecTime)
+      return;
+    const minutes = rspecTime[1] ? Number.parseFloat(rspecTime[1]) : 0;
+    return toMeasuredDurationMs(minutes * 60000 + Number.parseFloat(rspecTime[2]) * 1000);
+  }
+  parseMinitestDuration(output) {
+    const minitestTime = output.match(/^Finished in\s+([\d.]+)s\s*,/im);
+    if (!minitestTime)
+      return;
+    return toMeasuredDurationMs(Number.parseFloat(minitestTime[1]) * 1000);
+  }
+  parseGenericRunnerOutput(stdout, stderr, exitCode, testFile, runner) {
+    const output = `${stdout}
+${stderr}`;
+    const lower = output.toLowerCase();
+    let passed = 0;
+    let failed = 0;
+    let skipped = 0;
+    let matched = false;
+    const duration = this.parseGenericRunnerDuration(output, runner);
+    const cargoSummary = output.match(/test result:\s+\w+\.\s+(\d+)\s+passed;\s+(\d+)\s+failed;\s+(\d+)\s+ignored;/i);
+    if (cargoSummary) {
+      passed = Number.parseInt(cargoSummary[1], 10);
+      failed = Number.parseInt(cargoSummary[2], 10);
+      skipped = Number.parseInt(cargoSummary[3], 10);
+      matched = true;
+    }
+    const dotnetSummary = output.match(/Failed:\s*(\d+),\s*Passed:\s*(\d+),\s*Skipped:\s*(\d+)/i);
+    if (dotnetSummary) {
+      failed = Number.parseInt(dotnetSummary[1], 10);
+      passed = Number.parseInt(dotnetSummary[2], 10);
+      skipped = Number.parseInt(dotnetSummary[3], 10);
+      matched = true;
+    }
+    const mavenLines = [
+      ...output.matchAll(/^.*?Tests run:\s*(\d+),\s*Failures:\s*(\d+),\s*Errors:\s*(\d+),\s*Skipped:\s*(\d+).*$/gim)
+    ];
+    const mavenAggregates = mavenLines.filter((line) => !/Time elapsed:/i.test(line[0]));
+    const mavenScored = mavenAggregates.length > 0 ? mavenAggregates : mavenLines;
+    if (mavenScored.length > 0) {
+      let total = 0;
+      let mavenFailed = 0;
+      let mavenSkipped = 0;
+      for (const line of mavenScored) {
+        total += Number.parseInt(line[1], 10);
+        mavenFailed += Number.parseInt(line[2], 10) + Number.parseInt(line[3], 10);
+        mavenSkipped += Number.parseInt(line[4], 10);
+      }
+      failed = mavenFailed;
+      skipped = mavenSkipped;
+      passed = Math.max(0, total - failed - skipped);
+      matched = true;
+    }
+    const rspecSummary = output.match(/(\d+)\s+examples?,\s+(\d+)\s+failures?/i);
+    if (rspecSummary) {
+      const total = Number.parseInt(rspecSummary[1], 10);
+      failed = Number.parseInt(rspecSummary[2], 10);
+      passed = Math.max(0, total - failed);
+      matched = true;
+    }
+    const minitestSummary = output.match(/(\d+)\s+runs?,\s+\d+\s+assertions?,\s+(\d+)\s+failures?,\s+(\d+)\s+errors?/i);
+    if (minitestSummary) {
+      const total = Number.parseInt(minitestSummary[1], 10);
+      const failures = Number.parseInt(minitestSummary[2], 10);
+      const errors = Number.parseInt(minitestSummary[3], 10);
+      failed = failures + errors;
+      passed = Math.max(0, total - failed);
+      matched = true;
+    }
+    const gradleSummary = output.match(/(\d+)\s+tests? completed,\s+(\d+)\s+failed/i);
+    if (gradleSummary) {
+      const total = Number.parseInt(gradleSummary[1], 10);
+      failed = Number.parseInt(gradleSummary[2], 10);
+      passed = Math.max(0, total - failed);
+      matched = true;
+    }
+    const goFailNames = [...output.matchAll(/--- FAIL:[^\S\n]+([^\s(]+)/g)];
+    const goFailNameSet = new Set(goFailNames.map((m) => m[1].trim()));
+    const goTopLevelFailCount = goFailNames.filter((m) => {
+      const name = m[1].trim();
+      const slash = name.indexOf("/");
+      return slash === -1 || !goFailNameSet.has(name.slice(0, slash));
+    }).length;
+    let goInfraVerdict = false;
+    if (runner === "go") {
+      goInfraVerdict = /^FAIL[^\S\n]+\S+[^\S\n]+\[setup failed\]/m.test(output);
+      const goFailPackage = /^FAIL(?![^\n]*\[(?:build|setup) failed\])[^\S\n]+\S+/m.test(output);
+      const goOkPackages = [
+        ...output.matchAll(/^ok[^\S\n]+\S+[^\S\n]+[\d.]+s/gm)
+      ];
+      if (goFailNames.length > 0 || goFailPackage) {
+        failed = Math.max(failed, goTopLevelFailCount || 1);
+        matched = true;
+      }
+      if (goOkPackages.length > 0) {
+        passed = Math.max(passed, goOkPackages.length);
+        matched = true;
+      }
+    }
+    const failures = [];
+    for (const m of goFailNames.slice(0, 5)) {
+      failures.push({ name: m[1].trim(), message: m[1].trim() });
+    }
+    const otherNames = [
+      ...output.matchAll(/^[^\S\n]*FAILED[^\S\n]+(\S.*)$/gm),
+      ...output.matchAll(/^[^\S\n]*Failure:[^\S\n]+(\S.*)$/gm)
+    ];
+    for (const m of otherNames) {
+      if (failures.length >= 5)
+        break;
+      failures.push({ name: m[1].trim(), message: m[1].trim() });
+    }
+    const runnerError = exitCode !== 0 && !matched && goFailNames.length === 0 && (lower.includes("error") || goInfraVerdict) ? `Runner ${runner} exited with ${exitCode}` : undefined;
+    if (runnerError) {
+      failures.length = 0;
+    }
+    if (exitCode !== 0 && failed === 0 && !runnerError) {
+      failed = 1;
+    }
+    if (passed === 0 && failed === 0 && skipped === 0 && exitCode === 0) {
+      passed = 1;
+    }
+    if (failures.length === 0 && failed > 0) {
+      const firstLine = output.split(`
+`).find((l) => /fail|error|exception/i.test(l))?.trim().slice(0, 300) || `Tests failed for runner ${runner}`;
+      failures.push({ name: `${runner} failure`, message: firstLine });
+    }
+    this.log(runnerError ? `Generic runner ${runner}: never started (${runnerError})` : `Generic runner ${runner}: ran (matched=${matched}, passed=${passed}, failed=${failed}, failures=${failures.length})`);
+    return {
+      file: testFile,
+      sourceFile: "",
+      runner,
+      passed,
+      failed,
+      skipped,
+      failures,
+      duration,
+      error: runnerError
+    };
+  }
+  formatResult(result) {
+    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) {
+      return "";
+    }
+    const durationStr = isMeasuredDuration(result.duration) && result.duration > 0 ? ` (${(result.duration / 1000).toFixed(2)}s)` : "";
+    if (result.failed === 0) {
+      return `[Tests] ✓ ${result.passed}/${total} passed${durationStr} — ${result.runner}`;
+    }
+    let output = `[Tests] ✗ ${result.failed}/${total} failed, ${result.passed} passed${durationStr} — ${result.runner}
+`;
+    for (const failure of result.failures.slice(0, 5)) {
+      output += `  ✗ ${failure.name}
+`;
+      const msg = failure.message.split(`
+`)[0].slice(0, 200);
+      output += `    ${msg}
+`;
+      if (failure.location) {
+        output += `    at ${failure.location}
+`;
+      }
+    }
+    if (result.failures.length > 5) {
+      output += `  ... and ${result.failures.length - 5} more failure(s)
+`;
+    }
+    output += `  → Fix failing tests before proceeding
+`;
+    return output.trimEnd();
+  }
+  sourceRootMirroredCandidates(dir, cwd, testDir, testFilename) {
+    const knownSourceRoots = new Set(["src", "lib", "app"]);
+    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 [];
+  }
+  findTestFileByImport(sourceFilePath, cwd) {
+    const ext = path.extname(sourceFilePath);
+    const basename = path.basename(sourceFilePath, ext);
+    const testPattern = /\.(test|spec)\.(ts|tsx|js|jsx|mjs)$/;
+    const searchDirs = [
+      path.join(cwd, "tests"),
+      path.join(cwd, "__tests__"),
+      path.dirname(sourceFilePath)
+    ];
+    for (const dir of searchDirs) {
+      let entries;
+      try {
+        entries = fs.readdirSync(dir);
+      } catch {
+        continue;
+      }
+      for (const entry of entries) {
+        if (!testPattern.test(entry))
+          continue;
+        const testPath = path.join(dir, entry);
+        let content;
+        try {
+          content = fs.readFileSync(testPath, "utf-8");
+        } catch {
+          continue;
+        }
+        if (content.includes(`/${basename}"`) || content.includes(`/${basename}'`) || content.includes(`/${basename}.`) || content.includes(`"${basename}"`) || content.includes(`'${basename}'`)) {
+          this.log(`Found test file via import scan: ${testPath}`);
+          return testPath;
+        }
+      }
+    }
+    return null;
+  }
+  async resolveExec(runner, config, testFile, cwd, spawnCwd = cwd) {
+    if (runner === "pytest") {
+      const pythonEnvironment = await detectPythonEnvironment(cwd);
+      if (pythonEnvironment) {
+        return {
+          command: pythonEnvironment.pythonPath,
+          args: config.args(testFile, spawnCwd),
+          env: augmentPythonEnvironment(process.env, pythonEnvironment)
+        };
+      }
+    }
+    if (runner === "phpunit") {
+      const suffix = process.platform === "win32" ? ".bat" : "";
+      const vendorBin = path.join(cwd, "vendor", "bin", `phpunit${suffix}`);
+      if (fs.existsSync(vendorBin)) {
+        return { command: vendorBin, args: config.args(testFile, spawnCwd) };
+      }
+      return { command: "phpunit", args: config.args(testFile, spawnCwd) };
+    }
+    const binName = config.binName ?? runner;
+    const suffix = process.platform === "win32" ? ".cmd" : "";
+    const localBin = path.join(cwd, "node_modules", ".bin", binName + suffix);
+    if (fs.existsSync(localBin)) {
+      return {
+        command: localBin,
+        args: stripWrapperArgs(binName, config.args(testFile, spawnCwd))
+      };
+    }
+    const globalBin = await findGlobalBinary(binName);
+    if (globalBin) {
+      return {
+        command: globalBin,
+        args: stripWrapperArgs(binName, config.args(testFile, spawnCwd))
+      };
+    }
+    return { command: config.command, args: config.args(testFile, spawnCwd) };
+  }
+  emptyResult(testFile, sourceFile, runner, error) {
+    return {
+      file: testFile,
+      sourceFile,
+      runner,
+      passed: 0,
+      failed: 0,
+      skipped: 0,
+      failures: [],
+      error
+    };
+  }
+  truncateStack(stack) {
+    if (!stack)
+      return;
+    const lines = stack.split(`
+`).slice(0, 3);
+    return lines.join(`
+`).slice(0, 500);
+  }
+  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) {
+      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
+          });
+        }
+        failedTargets = this.getFailedTargets(cwd, runner, true);
+        if (!failedTargets)
+          return;
+      }
+      failedTargets.set(target, {
+        displayPath: targetPath,
+        sequence: ++this.failedTargetSequence
+      });
+      return;
+    }
+    if (failedTargets.delete(target) && failedTargets.size === 0) {
+      this.deleteFailedRoot(cwd, runner);
+    }
+  }
+}