@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

package/extensions/dm-lens/clients/sgconfig.js

@@ -6,6 +6,11 @@ import { recordDegradationOnce } from "./degradation-ledger.js";
 import { load as loadYaml } from "./deps/js-yaml.js";
 import { resolvePackagePath } from "./package-root.js";
 import { findLocalToolConfig } from "./path-utils.js";
+import {
+  getUserRuleRoot,
+  ruleCorpusFingerprintForCycle,
+  _resetRuleCorpusCycleFingerprintsForTests
+} from "./custom-rule-locations.js";
 const SGCONFIG_NAMES = ["sgconfig.yml", "sgconfig.yaml"];
 export function findLocalSgconfig(startDir) {
   return findLocalToolConfig(startDir, SGCONFIG_NAMES);
@@ -32,6 +37,18 @@ export function getAstGrepRuleSources(projectRoot = process.cwd()) {
       tier: "secondary"
     });
   }
+  const userRoot = getUserRuleRoot();
+  if (canonicalDir(userRoot) !== canonicalDir(root)) {
+    candidates.push({
+      dir: path.join(userRoot, "ast-grep-rules", "rules"),
+      origin: "user",
+      tier: "primary"
+    }, {
+      dir: path.join(userRoot, "ast-grep-rules", "coderabbit", "rules"),
+      origin: "user",
+      tier: "secondary"
+    });
+  }
   candidates.push({
     dir: path.join(packageRoot, "rules", "ast-grep-rules", "rules"),
     origin: "bundled",
@@ -116,7 +133,15 @@ function snapshotRuleSource(source) {
     }
     hash.update(content);
     hash.update("\x00");
-    files.push({ file, relativePath, documents: parseRuleDocuments(content) });
+    const documents = parseRuleDocuments(content);
+    if (source.origin === "user" && documents.some((document) => !document.id)) {
+      recordDegradationOnce({
+        kind: "ast-grep-rule-invalid",
+        subject: file,
+        reason: "user ast-grep rule has no valid rule id"
+      });
+    }
+    files.push({ file, relativePath, documents });
   }
   const snapshot = { ...source, files, digest: hash.digest("hex") };
   if (source.origin === "bundled")
@@ -137,6 +162,10 @@ function sourceFingerprint(sources) {
   }
   return hash.digest("hex");
 }
+export function getAstGrepRuleFingerprint(projectRoot = process.cwd(), options = {}) {
+  const root = path.resolve(projectRoot || process.cwd());
+  return ruleCorpusFingerprintForCycle("ast-grep", root, (fingerprintRoot) => sourceFingerprint(getAstGrepRuleSources(fingerprintRoot).map(snapshotRuleSource)), options.force);
+}
 function materializeMergedRuleDir(sources, mergedDir) {
   fs.rmSync(mergedDir, { recursive: true, force: true });
   fs.mkdirSync(mergedDir, { recursive: true });
@@ -174,14 +203,14 @@ function rootArtifactKey(root) {
 }
 export function resolveBaselineSgconfig(projectRoot = process.cwd()) {
   const root = canonicalDir(path.resolve(projectRoot || process.cwd()));
-  const sources = getAstGrepRuleSources(root).map(snapshotRuleSource);
-  if (sources.length === 0)
-    return;
-  const fingerprint = sourceFingerprint(sources);
+  const fingerprint = getAstGrepRuleFingerprint(root, { force: true });
   const cached = cachedBaselines.get(root);
   if (cached?.fingerprint === fingerprint && fs.existsSync(cached.path) && fs.existsSync(cached.mergedDir)) {
     return cached.path;
   }
+  const sources = getAstGrepRuleSources(root).map(snapshotRuleSource);
+  if (sources.length === 0)
+    return;
   const dir = path.join(os.tmpdir(), "dm-lens-ast-grep");
   fs.mkdirSync(dir, { recursive: true });
   const artifactKey = rootArtifactKey(root);
@@ -277,4 +306,5 @@ function cleanupStaleBaselines(dir, keep) {
 export function _resetBaselineSgconfigForTests() {
   cachedBaselines.clear();
   bundledSnapshots.clear();
+  _resetRuleCorpusCycleFingerprintsForTests();
 }

package/extensions/dm-lens/clients/startup-scan.js

@@ -39,6 +39,10 @@ export function isStartupScanVerdictFresh(verdict, now = Date.now()) {
     return true;
   if (typeof verdict.computedAt !== "number")
     return false;
+  if (verdict.maxProjectFiles !== getStartupScanMaxSourceFilesDerived(verdict.cwd))
+    return false;
+  if (verdict.maxScanEntries !== getStartupScanMaxEntries())
+    return false;
   return now - verdict.computedAt < getStartupScanVerdictTtlMs();
 }
 export function findNearestProjectRoot(startDir) {
@@ -149,7 +153,9 @@ function computeStartupScanContext(cwd, options = {}) {
       projectRoot,
       canWarmCaches: false,
       reason: entryBudgetExceeded ? "too-many-entries" : "too-many-source-files",
-      sourceFileCount
+      sourceFileCount,
+      maxProjectFiles: maxSourceFiles,
+      maxScanEntries
     };
   }
   return {
@@ -213,7 +219,9 @@ export async function resolveStartupScanContextAsync(cwd, options = {}) {
         projectRoot,
         canWarmCaches: false,
         reason: entryBudgetExceeded ? "too-many-entries" : "too-many-source-files",
-        sourceFileCount
+        sourceFileCount,
+        maxProjectFiles: maxSourceFiles,
+        maxScanEntries
       };
     } else {
       result = {

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

@@ -3,28 +3,40 @@ 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 {
+  LEDGER_FIELD_MAX,
+  recordDegradationOnce
+} 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 {
+  findGlobalBinary,
+  findLocalBinAt,
+  localBinPath
+} from "./package-manager.js";
+import { getIsolatedNpxSpawnOptions } from "./tool-probe.js";
 import { PathKeyedMap } from "./path-keyed-map.js";
 import {
   augmentPythonEnvironment,
   detectPythonEnvironment
 } from "./python-environment.js";
 import {
+  findNearestMarkerRootDetailed,
+  isRealGitMarker,
   isUnderDir,
   normalizeEphemeralMapKey,
   normalizeMapKey,
+  pathsEqual,
   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 { resolveGitCheckout } from "./review-graph/git-identity.js";
 import { resolveToolCwd } from "./tool-cwd.js";
 export function isRunnerErrorResult(result) {
   return result.failed === 0 && !!result.error;
@@ -72,10 +84,107 @@ export const TURN_END_EXCLUDED_TEST_GLOBS = [
   "**/*.integration.*",
   "**/*.e2e.*"
 ];
+function recordCheckoutIdentityGap(metadata) {
+  recordDegradationOnce({
+    kind: "test-checkout-identity-unavailable",
+    subject: createHash("sha256").update(JSON.stringify(metadata)).digest("hex"),
+    reason: "cannot establish automatic test checkout identity",
+    metadata
+  });
+}
+function foreignGitRoot(testFilePath, cwd) {
+  let realCwd;
+  let realTarget;
+  try {
+    realCwd = fs.realpathSync.native(path.resolve(cwd));
+    realTarget = fs.realpathSync.native(path.resolve(cwd, toPosix(testFilePath)));
+  } catch (error_) {
+    const errorCode = filesystemErrorCode(error_);
+    if (errorCode === "ENOENT" || errorCode === "ENOTDIR")
+      return null;
+    recordCheckoutIdentityGap({
+      cwd,
+      candidate: testFilePath,
+      lookup: "filesystem",
+      detail: "realpath",
+      errorCode
+    });
+    return null;
+  }
+  const targetWalk = findNearestMarkerRootDetailed(path.dirname(realTarget), [".git"], {
+    markerPredicate: (marker) => isRealGitMarker(marker, true)
+  });
+  if (targetWalk.kind !== "found") {
+    if (targetWalk.kind === "unavailable") {
+      recordCheckoutIdentityGap({
+        cwd,
+        candidate: testFilePath,
+        lookup: "target-root",
+        detail: "marker-error",
+        markerPath: targetWalk.markerPath,
+        errorCode: filesystemErrorCode(targetWalk.cause)
+      });
+    } else if (targetWalk.reason === "depth-limit") {
+      recordCheckoutIdentityGap({
+        cwd,
+        candidate: testFilePath,
+        lookup: "target-root",
+        detail: targetWalk.reason
+      });
+    }
+    return null;
+  }
+  const root = targetWalk.root;
+  if (!isUnderDir(realCwd, root))
+    return root;
+  const dispatchWalk = findNearestMarkerRootDetailed(realCwd, [".git"], {
+    markerPredicate: (marker) => isRealGitMarker(marker, true)
+  });
+  if (dispatchWalk.kind !== "found") {
+    recordCheckoutIdentityGap({
+      cwd,
+      candidate: testFilePath,
+      lookup: "dispatch-root",
+      ...dispatchWalk.kind === "unavailable" ? {
+        detail: "marker-error",
+        markerPath: dispatchWalk.markerPath,
+        errorCode: filesystemErrorCode(dispatchWalk.cause)
+      } : { detail: dispatchWalk.reason }
+    });
+    return null;
+  }
+  return !pathsEqual(root, dispatchWalk.root) ? root : null;
+}
+function sharesCommonDir(cwd, checkoutRoot) {
+  const dispatch = resolveGitCheckout(cwd);
+  const excluded = resolveGitCheckout(checkoutRoot);
+  return dispatch !== null && excluded !== null && pathsEqual(dispatch.commonDir, excluded.commonDir);
+}
 export function isExcludedTestTarget(testFilePath, cwd) {
-  const rel = toPosix(path.relative(cwd, path.resolve(cwd, testFilePath)));
-  if (rel === "" || rel === ".." || rel.startsWith("../") || path.isAbsolute(rel))
+  const absolute = path.resolve(cwd, toPosix(testFilePath));
+  let rel = toPosix(path.relative(cwd, absolute));
+  if (rel === "" || rel === ".." || rel.startsWith("../") || path.isAbsolute(rel)) {
+    const realTarget = canonicalFailedPath(absolute);
+    const realCwd = canonicalFailedPath(cwd);
+    if (pathsEqual(realTarget, realCwd) || !isUnderDir(realTarget, realCwd))
+      return true;
+    rel = toPosix(path.relative(realCwd, realTarget));
+  }
+  const checkoutRoot = foreignGitRoot(testFilePath, cwd);
+  if (checkoutRoot) {
+    recordDegradationOnce({
+      kind: "test-target-foreign-checkout",
+      subject: createHash("sha256").update(JSON.stringify([cwd, testFilePath, checkoutRoot])).digest("hex"),
+      reason: "automatic test target belongs to another Git checkout",
+      metadata: {
+        cwd,
+        candidate: testFilePath,
+        checkoutRoot,
+        sameCommonDir: sharesCommonDir(cwd, checkoutRoot)
+      }
+    });
     return true;
+  }
   return TURN_END_EXCLUDED_TEST_GLOBS.some((glob) => minimatch(rel, glob, { dot: true, nocase: true }));
 }
 export const RUNNERS = {
@@ -153,7 +262,7 @@ export const RUNNERS = {
       "settings.gradle",
       "settings.gradle.kts"
     ],
-    command: process.platform === "win32" ? "gradlew.bat" : "./gradlew",
+    command: process.platform === "win32" ? "./gradlew.bat" : "./gradlew",
     spawnCwdMarkers: ["gradlew", "gradlew.bat"],
     args: (_testFile, _cwd) => ["test", "--no-daemon"],
     parseJson: false
@@ -469,7 +578,7 @@ export class TestRunnerClient {
     }
     return null;
   }
-  findPytestMatchRecursive(rootDir, pattern, basename, maxDepth) {
+  findPytestMatchRecursive(rootDir, pattern, basename, maxDepth, acceptCandidate) {
     const queue = [
       { dir: rootDir, depth: 0 }
     ];
@@ -487,7 +596,7 @@ export class TestRunnerClient {
       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)) {
+          if ((entry.name === pattern || entry.name.startsWith("test_") && entry.name.endsWith(".py") && entry.name.includes(basename)) && acceptCandidate(fullPath)) {
             return fullPath;
           }
         } else if (entry.isDirectory() && depth < maxDepth) {
@@ -594,7 +703,7 @@ export class TestRunnerClient {
     const dotSegments = suffix.split(".").filter(Boolean);
     return dotSegments.length >= 2;
   }
-  findTestFile(sourceFilePath, cwd, runnerOverride) {
+  findTestFile(sourceFilePath, cwd, runnerOverride, acceptCandidate = () => true) {
     const ext = path.extname(sourceFilePath);
     const basename = path.basename(sourceFilePath, ext);
     const dir = path.dirname(sourceFilePath);
@@ -618,7 +727,7 @@ export class TestRunnerClient {
           } catch (err) {
             continue;
           }
-          const match = files.find((f) => f === pattern || f.startsWith("test_") && f.endsWith(".py") && f.includes(basename));
+          const match = files.find((f) => (f === pattern || f.startsWith("test_") && f.endsWith(".py") && f.includes(basename)) && acceptCandidate(path.join(searchDir, f)));
           if (match) {
             const testPath = path.join(searchDir, match);
             this.log(`Found test file: ${testPath}`);
@@ -626,7 +735,7 @@ export class TestRunnerClient {
           }
         }
         if (testDir !== ".") {
-          const recursiveMatch = this.findPytestMatchRecursive(path.join(cwd, testDir), pattern, basename, MAX_PYTEST_RECURSE_DEPTH);
+          const recursiveMatch = this.findPytestMatchRecursive(path.join(cwd, testDir), pattern, basename, MAX_PYTEST_RECURSE_DEPTH, acceptCandidate);
           if (recursiveMatch) {
             this.log(`Found test file (recursive): ${recursiveMatch}`);
             return { testFile: recursiveMatch, runner: detected.runner };
@@ -646,14 +755,14 @@ export class TestRunnerClient {
           ...this.sourceRootMirroredCandidates(dir, cwd, testDir, testFilename)
         ];
         for (const testPath of searchPaths) {
-          if (fs.existsSync(testPath)) {
+          if (fs.existsSync(testPath) && acceptCandidate(testPath)) {
             this.log(`Found test file: ${testPath}`);
             return { testFile: testPath, runner: detected.runner };
           }
         }
       }
     }
-    const importMatch = this.findTestFileByImport(sourceFilePath, cwd);
+    const importMatch = this.findTestFileByImport(sourceFilePath, cwd, acceptCandidate);
     if (importMatch) {
       return { testFile: importMatch, runner: detected.runner };
     }
@@ -665,9 +774,20 @@ export class TestRunnerClient {
       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);
+    const related = selfIsTest ? null : this.findTestFile(sourceFilePath, cwd, detected.runner, (candidate) => {
+      const checkoutRoot = foreignGitRoot(candidate, cwd);
+      if (!checkoutRoot)
+        return true;
+      recordDegradationOnce({
+        kind: "test-discovery-foreign-checkout",
+        subject: createHash("sha256").update(JSON.stringify([cwd, candidate, checkoutRoot])).digest("hex"),
+        reason: "automatic test candidate belongs to another Git checkout",
+        metadata: { cwd, candidate, checkoutRoot, runner: detected.runner }
+      });
+      return false;
+    });
     if (failedSet && failedSet.size > 0) {
-      const failedFirst = this.retireMissingFailedTargets({
+      const failedFirst = this.retireIneligibleFailedTargets({
         cwd,
         runner: detected.runner,
         failedTargets: failedSet,
@@ -712,7 +832,14 @@ export class TestRunnerClient {
     } else {
       request = runnerOrRequest;
     }
-    const { runner, config, turnIndex, signal } = request;
+    const {
+      runner,
+      config,
+      turnIndex,
+      signal,
+      displayRoot,
+      requireOwnInstall
+    } = request;
     if (!fs.existsSync(absoluteTestFile)) {
       return this.emptyResult(absoluteTestFile, "", runner, "Test file not found");
     }
@@ -721,12 +848,19 @@ export class TestRunnerClient {
         cwd: path.resolve(cwd),
         rootMarkers: config.spawnCwdMarkers ?? config.configFiles
       }).cwd;
-      const { command, args, env } = await this.resolveExec(runner, config, absoluteTestFile, cwd, spawnCwd);
+      const { command, args, env, ownInstall } = await this.resolveExec(runner, config, absoluteTestFile, cwd, spawnCwd, requireOwnInstall);
+      if (requireOwnInstall && !ownInstall) {
+        return {
+          ...this.emptyResult(absoluteTestFile, "", runner),
+          notRun: "no-runner-install"
+        };
+      }
       this.log(`Running (async): ${command} ${args.join(" ")} (cwd ${spawnCwd})`);
       const result = await safeSpawnAsync(command, args, {
         cwd: spawnCwd,
         timeout: 60000,
         env,
+        ...command === "npx" || command === "bunx" ? getIsolatedNpxSpawnOptions() : {},
         signal
       });
       const stdout = result.stdout || "";
@@ -738,22 +872,22 @@ export class TestRunnerClient {
       let parsed;
       switch (runner) {
         case "vitest":
-          parsed = this.parseVitestOutput(stdout, stderr, absoluteTestFile, cwd, runner);
+          parsed = this.parseVitestOutput(stdout, stderr, absoluteTestFile, displayRoot ?? cwd, runner);
           break;
         case "jest":
-          parsed = this.parseJestOutput(stdout, stderr, absoluteTestFile, cwd, runner);
+          parsed = this.parseJestOutput(stdout, stderr, absoluteTestFile, displayRoot ?? cwd, runner);
           break;
         case "pytest":
-          parsed = this.parsePytestOutput(stdout, stderr, result.status ?? 0, absoluteTestFile, cwd, runner);
+          parsed = this.parsePytestOutput(stdout, stderr, result.status ?? 0, absoluteTestFile, cwd, runner, displayRoot ?? cwd, spawnCwd);
           break;
         case "phpunit":
-          parsed = this.parsePhpunitOutput(stdout, stderr, result.status ?? 0, absoluteTestFile, runner);
+          parsed = this.parsePhpunitOutput(stdout, stderr, result.status ?? 0, absoluteTestFile, runner, displayRoot ?? cwd, cwd, spawnCwd);
           break;
         case "mix":
-          parsed = this.parseMixTestOutput(stdout, stderr, result.status ?? 0, absoluteTestFile, runner);
+          parsed = this.parseMixTestOutput(stdout, stderr, result.status ?? 0, absoluteTestFile, runner, displayRoot ?? cwd, cwd, spawnCwd);
           break;
         default:
-          parsed = this.parseGenericRunnerOutput(stdout, stderr, result.status ?? 0, absoluteTestFile, runner);
+          parsed = this.parseGenericRunnerOutput(stdout, stderr, result.status ?? 0, absoluteTestFile, runner, displayRoot ?? cwd, cwd, spawnCwd);
           break;
       }
       this.recordResult({
@@ -863,7 +997,7 @@ export class TestRunnerClient {
       }
     });
   }
-  retireMissingFailedTargets(selection) {
+  retireIneligibleFailedTargets(selection) {
     const { cwd, runner, failedTargets, relatedAbs, selfAbs, turnIndex } = selection;
     let checked = 0;
     const inspected = new Set;
@@ -873,6 +1007,16 @@ export class TestRunnerClient {
       checked += 1;
       inspected.add(identity);
       const candidate = entry.displayPath;
+      if (foreignGitRoot(candidate, cwd)) {
+        failedTargets.delete(identity);
+        this.recordFailedTargetState({
+          outcome: "retired-nested-checkout",
+          runner,
+          candidate,
+          turnIndex
+        });
+        return;
+      }
       const verdict = this.classifyFailedTarget(candidate);
       if (verdict.status === "missing") {
         failedTargets.delete(identity);
@@ -1002,7 +1146,18 @@ export class TestRunnerClient {
   parseJestOutput(stdout, stderr, testFile, cwd, runner) {
     return this.parseJsonTestOutput(stdout, stderr, testFile, cwd, runner);
   }
-  parsePytestOutput(stdout, stderr, exitCode, testFile, _cwd, runner) {
+  renderTextLocation(displayRoot, bases, file, line) {
+    if (file === undefined || line === undefined)
+      return;
+    for (const base of bases) {
+      const resolved = path.resolve(base, file);
+      if (fs.existsSync(resolved)) {
+        return `${toPosix(path.relative(displayRoot, resolved))}:${line}`;
+      }
+    }
+    return `${file}:${line}`;
+  }
+  parsePytestOutput(stdout, stderr, exitCode, testFile, cwd, runner, displayRoot = cwd, spawnCwd = cwd) {
     const failures = [];
     const output = `${stdout}
 ${stderr}`;
@@ -1010,13 +1165,15 @@ ${stderr}`;
     const failureRegex = /FAILED\s+(\S+::\S+)\s*-\s*(.+?)(?:\n|$)/g;
     let match;
     while ((match = failureRegex.exec(output)) !== null) {
+      const [file, ...testParts] = match[1].split("::");
+      const location = this.renderTextLocation(displayRoot, [spawnCwd, cwd], file, testParts.join("::"));
       failures.push({
         name: match[1],
         message: match[2].trim().slice(0, 500),
-        location: match[1].replace("::", ":")
+        ...location === undefined ? {} : { location }
       });
     }
-    const tracebackRegex = /_{10,}\s*\n\s*(\w+Error:\s*.+?)(?:\n|$)/gs;
+    const tracebackRegex = /(?<!_)_{10,}[^\S\n]*\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);
@@ -1034,7 +1191,7 @@ ${stderr}`;
       error: exitCode === 4 ? "Pytest configuration error" : exitCode === 2 ? "Pytest interrupted" : undefined
     };
   }
-  parsePhpunitOutput(stdout, stderr, exitCode, testFile, runner) {
+  parsePhpunitOutput(stdout, stderr, exitCode, testFile, runner, displayRoot = path.dirname(testFile), cwd = path.dirname(testFile), spawnCwd = cwd) {
     const output = `${stdout}
 ${stderr}`;
     let passed = 0;
@@ -1059,7 +1216,16 @@ ${stderr}`;
     const failureRegex = /^\d+\)\s+(\S+)/gm;
     let match;
     while ((match = failureRegex.exec(output)) !== null) {
-      failures.push({ name: match[1], message: match[1] });
+      const afterFailure = output.slice(match.index + match[0].length);
+      const nextFailure = afterFailure.search(/(?:^|\n)[^\S\n]*\d+\)\s/);
+      const failureBlock = nextFailure === -1 ? afterFailure : afterFailure.slice(0, nextFailure);
+      const locationMatch = /(?:^|\n)[^\S\n]*([^\s:]+\.php):(\d+)/.exec(failureBlock);
+      const location = this.renderTextLocation(displayRoot, [spawnCwd, cwd], locationMatch?.[1], locationMatch?.[2]);
+      failures.push({
+        name: match[1],
+        message: match[1],
+        ...location === undefined ? {} : { location }
+      });
     }
     let duration;
     const clockMatch = output.match(/^Time:\s*(?:(\d+):)?(\d{1,2}):(\d{2})(?:\.(\d{1,3}))?/im);
@@ -1092,7 +1258,7 @@ ${stderr}`;
       error: exitCode !== 0 && passed === 0 && failed === 0 ? "PHPUnit runner error" : undefined
     };
   }
-  parseMixTestOutput(stdout, stderr, exitCode, testFile, runner) {
+  parseMixTestOutput(stdout, stderr, exitCode, testFile, runner, displayRoot = path.dirname(testFile), cwd = path.dirname(testFile), spawnCwd = cwd) {
     const output = `${stdout}
 ${stderr}`;
     let passed = 0;
@@ -1113,13 +1279,17 @@ ${stderr}`;
       duration = Math.round(Number.parseFloat(durationMatch[1]) * 1000);
     }
     const failures = [];
-    const failureRegex = /^\s*\d+\)\s+(.+?)\s*\(([^)]+)\)\s*$/gm;
+    const failureRegex = /^[^\S\n]*\d+\)\s+(.+?)\s*\(([^)]+)\)\s*$/gm;
     let match;
     while ((match = failureRegex.exec(output)) !== null) {
+      const afterFailure = output.slice(match.index + match[0].length);
+      const nextFailure = afterFailure.search(/(?:^|\n)[^\S\n]*\d+\)\s/);
+      const failureBlock = nextFailure === -1 ? afterFailure : afterFailure.slice(0, nextFailure);
+      const locationMatch = /(?:^|\n)[^\S\n]*([^\s:]+\.exs):(\d+)/.exec(failureBlock);
       failures.push({
         name: match[1].trim(),
         message: match[1].trim(),
-        location: match[2].trim()
+        location: this.renderTextLocation(displayRoot, [spawnCwd, cwd], locationMatch?.[1], locationMatch?.[2]) ?? match[2].trim()
       });
     }
     return {
@@ -1213,7 +1383,7 @@ ${stderr}`;
       return;
     return toMeasuredDurationMs(Number.parseFloat(minitestTime[1]) * 1000);
   }
-  parseGenericRunnerOutput(stdout, stderr, exitCode, testFile, runner) {
+  parseGenericRunnerOutput(stdout, stderr, exitCode, testFile, runner, displayRoot = path.dirname(testFile), cwd = path.dirname(testFile), spawnCwd = cwd) {
     const output = `${stdout}
 ${stderr}`;
     const lower = output.toLowerCase();
@@ -1312,7 +1482,14 @@ ${stderr}`;
     for (const m of otherNames) {
       if (failures.length >= 5)
         break;
-      failures.push({ name: m[1].trim(), message: m[1].trim() });
+      const name = m[1].trim();
+      const locationMatch = /(?<!\S)([^\s:]+\.(?:go|rs|rb|java|kt|cs|fs|py|php|exs)):(\d+)/.exec(name);
+      const location = this.renderTextLocation(displayRoot, [spawnCwd, cwd], locationMatch?.[1], locationMatch?.[2]);
+      failures.push({
+        name,
+        message: name,
+        ...location === undefined ? {} : { location }
+      });
     }
     const runnerError = exitCode !== 0 && !matched && goFailNames.length === 0 && (lower.includes("error") || goInfraVerdict) ? `Runner ${runner} exited with ${exitCode}` : undefined;
     if (runnerError) {
@@ -1385,7 +1562,7 @@ ${stderr}`;
     }
     return [];
   }
-  findTestFileByImport(sourceFilePath, cwd) {
+  findTestFileByImport(sourceFilePath, cwd, acceptCandidate) {
     const ext = path.extname(sourceFilePath);
     const basename = path.basename(sourceFilePath, ext);
     const testPattern = /\.(test|spec)\.(ts|tsx|js|jsx|mjs)$/;
@@ -1402,9 +1579,9 @@ ${stderr}`;
         continue;
       }
       for (const entry of entries) {
-        if (!testPattern.test(entry))
-          continue;
         const testPath = path.join(dir, entry);
+        if (!testPattern.test(entry) || !acceptCandidate(testPath))
+          continue;
         let content;
         try {
           content = fs.readFileSync(testPath, "utf-8");
@@ -1419,42 +1596,66 @@ ${stderr}`;
     }
     return null;
   }
-  async resolveExec(runner, config, testFile, cwd, spawnCwd = cwd) {
+  async resolveExec(runner, config, testFile, cwd, spawnCwd = cwd, requireOwnInstall = false) {
+    const needsInstall = config.command === "npx" || runner === "pytest" || runner === "phpunit";
     if (runner === "pytest") {
-      const pythonEnvironment = await detectPythonEnvironment(cwd);
+      const pythonEnvironment = await detectPythonEnvironment(cwd, undefined, {
+        allowAmbient: !requireOwnInstall
+      });
       if (pythonEnvironment) {
         return {
           command: pythonEnvironment.pythonPath,
           args: config.args(testFile, spawnCwd),
-          env: augmentPythonEnvironment(process.env, pythonEnvironment)
+          env: augmentPythonEnvironment(process.env, pythonEnvironment),
+          ownInstall: true
         };
       }
     }
     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) };
+      const vendorBin = localBinPath(findLocalBinAt("phpunit", cwd, {
+        windowsExt: suffix,
+        binDirs: [path.join("vendor", "bin")]
+      }));
+      if (vendorBin) {
+        return {
+          command: vendorBin,
+          args: config.args(testFile, spawnCwd),
+          ownInstall: true
+        };
       }
-      return { command: "phpunit", args: config.args(testFile, spawnCwd) };
+      return {
+        command: "phpunit",
+        args: config.args(testFile, spawnCwd),
+        ownInstall: false
+      };
     }
     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)) {
+    const localBin = localBinPath(findLocalBinAt(binName, cwd, {
+      windowsExt: suffix,
+      binDirs: [path.join("node_modules", ".bin")]
+    }));
+    if (localBin) {
       return {
         command: localBin,
-        args: stripWrapperArgs(binName, config.args(testFile, spawnCwd))
+        args: stripWrapperArgs(binName, config.args(testFile, spawnCwd)),
+        ownInstall: true
       };
     }
     const globalBin = await findGlobalBinary(binName);
     if (globalBin) {
       return {
         command: globalBin,
-        args: stripWrapperArgs(binName, config.args(testFile, spawnCwd))
+        args: stripWrapperArgs(binName, config.args(testFile, spawnCwd)),
+        ownInstall: !needsInstall
       };
     }
-    return { command: config.command, args: config.args(testFile, spawnCwd) };
+    return {
+      command: config.command,
+      args: config.args(testFile, spawnCwd),
+      ownInstall: !needsInstall
+    };
   }
   emptyResult(testFile, sourceFile, runner, error) {
     return {
@@ -1479,6 +1680,15 @@ ${stderr}`;
   recordResult(record) {
     const { cwd, runner, testFile, result, turnIndex } = record;
     const targetPath = path.resolve(testFile);
+    if (result.failed > 0 && foreignGitRoot(targetPath, cwd)) {
+      this.recordFailedTargetState({
+        outcome: "rejected-nested-checkout",
+        runner,
+        candidate: targetPath,
+        turnIndex
+      });
+      return;
+    }
     const target = canonicalFailedPath(targetPath);
     let failedTargets = this.getFailedTargets(cwd, runner, result.failed > 0);
     if (!failedTargets)