@duckmind/dm-linux-x64 0.65.8 → 0.66.2

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

@@ -1,1504 +0,0 @@
-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);
-    }
-  }
-}