@herbertgao/pi-extensions 2026.9.2 → 2026.9.4

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

@@ -18,14 +18,18 @@ 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 { normalizeEphemeralMapKey, normalizeMapKey, toPosix, } from "./path-utils.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";
 /**
  * #2532: the ONE classification seam for "this `TestResult` carries NO
  * counted failure the agent needs to fix, even though the runner also
@@ -99,10 +103,26 @@ const SOURCE_TO_TEST_PATTERNS = [
     // basename (e.g. lib/accounts/user.ex -> test/accounts/user_test.exs).
     { ext: ".ex", testExts: ["_test.exs"], dirs: ["test"] },
 ];
-// Bound for walking up parent directories to find a hoisted node_modules
-// (monorepo workspaces) — deep enough for realistic nesting
-// (repo/packages/scope/pkg-name), never unbounded to the filesystem root.
-const MAX_NODE_MODULES_WALK_UP = 5;
+/**
+ * Nearest `node_modules/<packageName>` at or above `cwd` — monorepo workspace
+ * hoisting (npm/yarn/pnpm), where a workspace package's own `node_modules` may
+ * not exist at all and the runner lives in the workspace root's.
+ *
+ * #2870 net-count: this was a private bounded climb loop of its own (the
+ * fourth walker in this file). It is now the shared workspace-topology
+ * walker every other per-directory marker walk in the codebase goes through
+ * — same `walkUpDirs` primitive, the `$HOME` ceiling the private loop
+ * lacked, the `MAX_WALK_DEPTH` cap with its cap-trip latency record, and the
+ * per-directory marker cache, so a chain already walked for a language root
+ * is not re-`readdir`'d here. Returns the directory CONTAINING
+ * `node_modules` (the private loop returned the `node_modules` path itself;
+ * only the log line reads it).
+ */
+function findHoistedNodeModulesPackage(cwd, packageName) {
+    return findNearestDirWithAnyBasename(path.resolve(cwd), [
+        `node_modules/${packageName}`,
+    ]);
+}
 // Bound for recursive descent into a Python test directory when the exact
 // same-relative-subdir mirror doesn't match (e.g. tests/unit/ grouping by
 // test type rather than mirroring source layout) — capped depth, never an
@@ -162,6 +182,7 @@ export function isExcludedTestTarget(testFilePath, cwd) {
 // --- Runner Detection ---
 export const RUNNERS = {
     vitest: {
+        kinds: ["jsts"],
         configFiles: ["vitest.config.ts", "vitest.config.js", "vitest.config.mjs"],
         command: "npx",
         binName: "vitest",
@@ -175,6 +196,7 @@ export const RUNNERS = {
         parseJson: true,
     },
     jest: {
+        kinds: ["jsts"],
         configFiles: [
             "jest.config.ts",
             "jest.config.js",
@@ -193,12 +215,26 @@ export const RUNNERS = {
         parseJson: true,
     },
     pytest: {
+        kinds: ["python"],
         configFiles: ["pytest.ini", "pyproject.toml", "setup.cfg", "tox.ini"],
+        // #2879 review round 3, F7: `pyproject.toml` is CONTENT-conditional in
+        // detection — the Priority-1 loop accepts it only when it carries
+        // `[tool.pytest.ini_options]` — but the cwd seam walks basenames, so
+        // handing `configFiles` over verbatim anchored the child on the very
+        // file detection had refused. Omitting it here makes the spawn walk
+        // stop only on evidence the detector itself would accept; a project
+        // whose ONLY pytest config is a real `[tool.pytest.ini_options]`
+        // section therefore falls back to the dispatch root, which is exactly
+        // where master ran it. (The proper fix is to carry detection's
+        // accepted evidence path into the spawn resolution instead of
+        // re-deriving it from a basename table — filed as a follow-up.)
+        spawnCwdMarkers: ["pytest.ini", "tox.ini", "setup.cfg"],
         command: "python",
         args: (testFile, _cwd) => ["-m", "pytest", testFile, "--tb=short", "-q"],
         parseJson: false, // pytest JSON requires plugin, use text parsing
     },
     go: {
+        kinds: ["go"],
         configFiles: ["go.mod"],
         command: "go",
         args: (testFile, cwd) => {
@@ -210,30 +246,47 @@ export const RUNNERS = {
         parseJson: false, // Go test output is text-based
     },
     cargo: {
+        kinds: ["rust"],
         configFiles: ["Cargo.toml"],
         command: "cargo",
         args: (_testFile, _cwd) => ["test", "--no-fail-fast"],
         parseJson: false, // cargo test output is text-based
     },
     dotnet: {
+        kinds: ["csharp", "fsharp"],
         configFiles: ["*.csproj", "*.sln"],
         command: "dotnet",
         args: (_testFile, _cwd) => ["test", "--no-build"],
         parseJson: false,
     },
     gradle: {
-        configFiles: ["build.gradle", "build.gradle.kts", "settings.gradle"],
+        kinds: ["java", "kotlin"],
+        // #2870: `settings.gradle.kts` alongside its Groovy sibling — a
+        // Kotlin-DSL build whose root carries only the settings script was
+        // invisible to detection, the same one-spelling gap the java root
+        // markers had.
+        configFiles: [
+            "build.gradle",
+            "build.gradle.kts",
+            "settings.gradle",
+            "settings.gradle.kts",
+        ],
         command: process.platform === "win32" ? "gradlew.bat" : "./gradlew",
+        // The child's cwd must be a directory the wrapper actually lives in.
+        spawnCwdMarkers: ["gradlew", "gradlew.bat"],
         args: (_testFile, _cwd) => ["test", "--no-daemon"],
         parseJson: false,
     },
     maven: {
+        kinds: ["java", "kotlin"],
         configFiles: ["pom.xml"],
         command: "mvn",
+        spawnCwdMarkers: ["mvnw", "mvnw.cmd"],
         args: (_testFile, _cwd) => ["test", "-q"],
         parseJson: false,
     },
     rspec: {
+        kinds: ["ruby"],
         configFiles: [".rspec", "spec/spec_helper.rb"],
         command: "bundle",
         // The real binary is "bundle" (the command runs `bundle exec rspec
@@ -245,22 +298,33 @@ export const RUNNERS = {
         parseJson: false,
     },
     minitest: {
+        kinds: ["ruby"],
         configFiles: ["Gemfile"],
         command: "ruby",
         args: (testFile, _cwd) => ["-Itest", testFile],
         parseJson: false,
     },
     phpunit: {
+        kinds: ["php"],
         // phpunit.xml(.dist) is the strong signal; composer.json is checked for
         // a require-dev dependency on phpunit/phpunit (see the special case in
         // detectRunner's Priority-1 loop, mirroring the pytest/pyproject.toml
         // handling above).
         configFiles: ["phpunit.xml", "phpunit.xml.dist", "composer.json"],
+        // #2879 review round 3, F7: same shape as pytest's `pyproject.toml`,
+        // and this one is load-bearing — phpunit reads `phpunit.xml` from its
+        // CWD only, so a child launched in a directory whose `composer.json`
+        // carries no `phpunit/phpunit` dependency runs with no bootstrap and
+        // no autoloader, and the resulting fatal error reaches the agent as a
+        // test failure (measured end to end with a fake phpunit recording its
+        // own cwd). `composer.json` is an anchor, never phpunit evidence.
+        spawnCwdMarkers: ["phpunit.xml", "phpunit.xml.dist"],
         command: "phpunit",
         args: (testFile, _cwd) => [testFile],
         parseJson: false, // PHPUnit's default CLI output is text-based
     },
     mix: {
+        kinds: ["elixir"],
         configFiles: ["mix.exs"],
         command: "mix",
         args: (testFile, _cwd) => ["test", testFile],
@@ -441,14 +505,127 @@ export class TestRunnerClient {
             return;
         byRunner.set(runner, { available, evidencePath });
     }
+    /**
+     * Which runners may be handed `sourceFilePath`, and the directory their
+     * config files are probed in (#2870).
+     *
+     * `eligible === null` means "no file was named" — the session-level
+     * caller (`runtime-session.ts`'s summary) asks "what runner does this
+     * project have" and has no file to scope to, so every runner stays a
+     * candidate and the probe root is the dispatch root, exactly as before.
+     *
+     * A named file resolves TWO independent facts, and the order matters:
+     *  - its KIND decides which runners may claim it at all (the gate), and
+     *  - `resolveLanguageRootForFile` decides WHERE that kind's config files
+     *    are looked for (the anchor) — the same per-kind, cached,
+     *    workspace-clamped walk the dispatch runners already resolve their
+     *    roots with, not a private walker.
+     *
+     * Returning `null` means no runner can own this file (a kind no entry
+     * claims: markdown, yaml, an unknown extension), so no directory is
+     * probed at all.
+     */
+    resolveDetectionScope(cwd, sourceFilePath) {
+        if (sourceFilePath === undefined)
+            return { root: cwd, eligible: null };
+        const absoluteFile = path.resolve(sourceFilePath);
+        // #2522 (pinned by "fails closed through the REAL getTestRunTarget when
+        // the resolved target is out of tree"): a file OUTSIDE the dispatch root
+        // keeps the pre-#2870 resolution — every runner, probed at the dispatch
+        // root — so `getTestRunTarget` still hands the exclusion layer a target
+        // to fail closed on instead of quietly answering "no runner" for a file
+        // the turn should refuse loudly. Per-file anchoring has nothing to
+        // anchor to out there: the language-root walk is clamped to the
+        // workspace, so every out-of-tree file resolves to the dispatch root
+        // anyway.
+        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,
+        };
+    }
     /**
      * Check if a test runner is available in the project
      * Detection order:
      * 1. Config files (vitest.config.ts, jest.config.js, etc.)
      * 2. package.json dependencies
      * 3. node_modules presence
+     *
+     * #2870: when `sourceFilePath` is given, the answer is scoped to that
+     * file's kind and resolved language root — see `resolveDetectionScope`.
      */
-    detectRunner(cwd, sourceFilePath) {
+    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;
+        // #2879 review round 2, F1: the anchor is a LANGUAGE root, and
+        // `ROOT_MARKERS_BY_KIND` is deliberately BROADER than any runner's
+        // `configFiles` — `requirements.txt`, `setup.py`, `Pipfile`,
+        // `Rakefile`, `composer.lock`, `.classpath` all anchor a language
+        // without configuring a test runner. Probing the anchored directory
+        // ALONE therefore let any such intermediate marker shadow the
+        // project root's real runner config, and pytest/rspec/minitest/
+        // phpunit have no later priority to rescue them: four single-language
+        // repos went from a working runner to no target at all (measured, the
+        // review's `anchor.mjs` probe), which is exactly what #2870's amended
+        // criterion 4 protects.
+        //
+        // So the anchored probe is a PREFERENCE, not a restriction: on a miss,
+        // re-probe the dispatch root under the SAME kind gate. The gate is
+        // what keeps #2870 fixed — a `.java` file re-probing a polyglot root
+        // still cannot reach `go`, because `go` never claims the `java` kind.
+        const dispatch = path.resolve(dispatchRoot);
+        if (path.resolve(root) !== dispatch) {
+            const atDispatch = this.probeRunnersAt(dispatch, eligible);
+            if (atDispatch)
+                return atDispatch;
+        }
+        // Priority 5: Check if pytest is available globally (Python files only)
+        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) {
+            void err;
+        }
+        return null;
+    }
+    /**
+     * Priorities 1-4 of the detection ladder, against ONE directory: config
+     * files, `package.json` dependencies, a hoisted `node_modules`, and the
+     * glob-capable whole-project runners. `eligible` is the kind gate
+     * (#2870); `null` means no file was named and every runner is a
+     * candidate. Returns `null` when this directory configures no eligible
+     * runner, which is what lets `detectRunner` try the dispatch root next.
+     */
+    probeRunnersAt(cwd, eligible) {
+        // Keyed on the probed directory, not the dispatch root: two modules of
+        // one polyglot repo have different runners available, and a memo keyed
+        // on the shared dispatch root would serve the first module's verdict to
+        // every other module (#2870).
         const rootKey = this.getCanonicalProjectRoot(cwd);
         let byRunner = this.availableRunners.get(rootKey);
         if (!byRunner) {
@@ -457,6 +634,8 @@ export class TestRunnerClient {
         }
         // Priority 1: Config files
         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) {
@@ -520,17 +699,18 @@ export class TestRunnerClient {
                 ...pkg.devDependencies,
             };
             // Check for vitest first (more specific than jest)
-            if (allDeps.vitest) {
+            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) {
+            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"]) {
+            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 };
@@ -543,21 +723,19 @@ export class TestRunnerClient {
         // Priority 3: Check node_modules for installed packages, including a
         // hoisted monorepo layout where cwd is a workspace package (e.g.
         // packages/foo) but the runner only lives in node_modules at the
-        // workspace root (npm/yarn/pnpm workspace hoisting). Walk up a
-        // bounded number of parent directories looking for a node_modules
-        // containing the package — never an unbounded walk to the
-        // filesystem root.
-        const hoistedVitest = this.findHoistedNodeModulesPackage(cwd, "vitest");
-        if (hoistedVitest) {
-            this.log(`Detected vitest in node_modules (${hoistedVitest})`);
-            return { runner: "vitest", config: RUNNERS.vitest };
-        }
-        const hoistedJest = this.findHoistedNodeModulesPackage(cwd, "jest");
-        if (hoistedJest) {
-            this.log(`Detected jest in node_modules (${hoistedJest})`);
-            return { runner: "jest", config: RUNNERS.jest };
+        // workspace root (npm/yarn/pnpm workspace hoisting).
+        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) => {
                 // Handle glob patterns like *.csproj
@@ -577,47 +755,6 @@ export class TestRunnerClient {
                 return { runner: name, config };
             }
         }
-        // Priority 5: Check if pytest is available globally (Python files only)
-        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) {
-            void err;
-        }
-        return null;
-    }
-    /**
-     * Walk up from `cwd` through parent directories looking for a
-     * `node_modules/<packageName>` — handles monorepo workspace hoisting
-     * (npm/yarn/pnpm), where a workspace package's own `node_modules` may
-     * not exist at all, with dependencies hoisted to the workspace root
-     * several directories up. Bounded by `MAX_NODE_MODULES_WALK_UP` levels
-     * and stops at the filesystem root — never an unbounded walk.
-     * Returns the `node_modules` directory where the package was found, or
-     * null if not found within the bound.
-     */
-    findHoistedNodeModulesPackage(cwd, packageName) {
-        let dir = path.resolve(cwd);
-        for (let level = 0; level <= MAX_NODE_MODULES_WALK_UP; level++) {
-            const nodeModulesPath = path.join(dir, "node_modules");
-            if (fs.existsSync(path.join(nodeModulesPath, packageName))) {
-                return nodeModulesPath;
-            }
-            const parent = path.dirname(dir);
-            if (parent === dir)
-                break; // reached filesystem root
-            dir = parent;
-        }
         return null;
     }
     /**
@@ -790,7 +927,8 @@ export class TestRunnerClient {
      * file whose *related* test file needs to be discovered).
      *
      * Primary signal: `detectFileRole` (naming convention: `.test.`/`.spec.`
-     * basenames, `test_`/`spec_` prefixes, `__tests__/`/`tests/`/`spec/`
+     * basenames, `_test.`/`_spec.` suffix infixes, `*Test(s).<ext>` CamelCase
+     * suffixes, `test_`/`spec_` prefixes, `__tests__/`/`tests/`/`spec/`
      * directories — shared with the rest of the codebase, not a second
      * parallel detector).
      *
@@ -1024,6 +1162,43 @@ export class TestRunnerClient {
             strategy: "related",
         };
     }
+    /**
+     * The working directory the test-runner CHILD is spawned in (#2871).
+     *
+     * AGENTS.md defect shape 40: `resolveToolCwd` is the one seam for a child
+     * process's cwd, and this file resolved its own — it handed
+     * `safeSpawnAsync` the dispatch root, so `RUNNERS.go.args` built
+     * `./tools/tapctl/internal/lightning` relative to a root module that does
+     * not own that package. Marker discovery, the `.git` fallback, the
+     * dispatch-root fallback, the `$HOME` ceiling, the once-per-key `tool-cwd`
+     * log line and the bounded `tool-cwd-resolution` degradation now all come
+     * from the seam, with the runner's own table as the markers.
+     *
+     * This is a SECOND value, never a reassignment of `cwd`: the failed-target
+     * ledger (`recordResult` → `getFailedTargets`, read back by
+     * `getTestRunTarget`) is keyed by the DISPATCH root, and re-keying it per
+     * module would make a recorded failure unfindable from the turn that
+     * selects targets.
+     *
+     * Review round 2, F6: there is deliberately NO clamp on a resolution that
+     * lands outside the dispatch root. The seam only answers outside it when
+     * the FILE is outside it (`tool-cwd.ts`: every in-tree branch is
+     * `isUnderDir`-checked), and the one production caller —
+     * `runtime-turn.ts`'s turn-end batch, on both the fresh and the deferred
+     * path — filters every target through `isExcludedTestTarget`, which fails
+     * CLOSED out of tree (#2522). Round 1 shipped that clamp plus a
+     * `tool-cwd-resolution` ledger row for it; neither could fire in a live
+     * session, so the row was a record nothing could observe and the guard was
+     * defence against a caller that does not exist. Both are gone. If a second
+     * caller is ever added that can pass an out-of-tree file, it needs this
+     * decision made where that caller is, with a test that reaches it.
+     */
+    resolveSpawnCwd(runner, config, testFile, dispatchRoot) {
+        return resolveToolCwd("runner", runner, testFile, {
+            cwd: path.resolve(dispatchRoot),
+            rootMarkers: config.spawnCwdMarkers ?? config.configFiles,
+        });
+    }
     async runTestFileAsync(testFile, cwd, runnerOrRequest, legacyConfig) {
         const absoluteTestFile = path.resolve(testFile);
         let request;
@@ -1041,10 +1216,11 @@ export class TestRunnerClient {
             return this.emptyResult(absoluteTestFile, "", runner, "Test file not found");
         }
         try {
-            const { command, args, env } = await this.resolveExec(runner, config, absoluteTestFile, cwd);
-            this.log(`Running (async): ${command} ${args.join(" ")}`);
+            const spawnCwd = this.resolveSpawnCwd(runner, config, absoluteTestFile, 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,
+                cwd: spawnCwd,
                 timeout: 60000,
                 env,
                 // #2522 R2 F1. `safeSpawnAsync` resolves `options.signal ?? ambient`,
@@ -1942,7 +2118,26 @@ export class TestRunnerClient {
             const slash = name.indexOf("/");
             return slash === -1 || !goFailNameSet.has(name.slice(0, slash));
         }).length;
+        // #2870: go's own `[setup failed]` verdict line — "there was no package
+        // to test" — the positive twin of the `(?:build|setup) failed`
+        // lookahead below. #1524-r4 stopped it from being counted as a test
+        // failure but left it with no classification of its own, so whether the
+        // agent saw "could not run tests" or a fabricated `✗ 1/1 failed ✗ go
+        // failure` came down to whether go's output happened to contain the
+        // substring "error" (the runner-error condition below): `FAIL <pkg>
+        // [setup failed]` + `error: no packages to test` was advisory, the same
+        // line on its own was a blocking failure the agent could not tell from
+        // a real one (#2870, measured).
+        //
+        // `[build failed]` is deliberately NOT included (review round 2, F5).
+        // The maintainer's amendment on #2870 names `[setup failed]`; a go
+        // COMPILE error is usually one the agent just introduced, and
+        // downgrading it to advisory is a signal change on master's behaviour
+        // that belongs on the issue, not in this fix. Its classification is
+        // still the coin flip described above — see the PR body's follow-ups.
+        let goInfraVerdict = false;
         if (runner === "go") {
+            goInfraVerdict = /^FAIL[^\S\n]+\S+[^\S\n]+\[setup failed\]/m.test(output);
             // #1524-r4: `(?![^\n]*\[(?:build|setup) failed\])` rejects go's
             // INFRASTRUCTURE verdict lines — `FAIL <pkg> [build failed]` (a
             // compile error) and `FAIL <pkg> [setup failed]` (no packages to
@@ -2018,10 +2213,19 @@ export class TestRunnerClient {
         // runner error they actually are). They still label a name onto
         // `failures` above when `matched` or `goFailNames` already settled
         // the question some other way, but they no longer settle it alone.
+        //
+        // #2870: `goInfraVerdict` is a SECOND sufficient condition, not a
+        // widening of the first. go's `[build failed]`/`[setup failed]` line is
+        // the runner itself saying no test ran, which is exactly what this
+        // branch reports — so it no longer has to also print the word "error"
+        // to be classified as one. The `!matched`/`goFailNames` vetoes still
+        // apply: a run that produced real go counts or a real `--- FAIL:` is a
+        // verdict, never a runner error, even if a later package failed to
+        // build.
         const runnerError = exitCode !== 0 &&
             !matched &&
             goFailNames.length === 0 &&
-            lower.includes("error")
+            (lower.includes("error") || goInfraVerdict)
             ? `Runner ${runner} exited with ${exitCode}`
             : undefined;
         // #1524-r4 (tidy): a runner-error result reports through
@@ -2217,7 +2421,18 @@ export class TestRunnerClient {
      * with an npx-style runner-name arg, which only holds for wrapper-style
      * runners like vitest/jest/pytest).
      */
-    async resolveExec(runner, config, testFile, cwd) {
+    async resolveExec(runner, config, testFile, cwd, 
+    /**
+     * #2871: the directory the child will RUN in, which is the only cwd
+     * `args()` may be built against — go's package path is relative to it.
+     * Where the binary and the Python environment are INSTALLED is a
+     * different question with a different answer: they stay resolved from
+     * the dispatch root, exactly as before, so a workspace package whose
+     * dependencies are hoisted to the repo root still finds
+     * `node_modules/.bin/<runner>` instead of falling through to `npx`.
+     * Defaults to `cwd`, which is every call where the two are the same.
+     */
+    spawnCwd = cwd) {
         // Run pytest through the project interpreter itself, not a generic `python`
         // resolved from the host PATH. The child-only environment also keeps tools
         // spawned by tests inside the same project environment.
@@ -2226,7 +2441,7 @@ export class TestRunnerClient {
             if (pythonEnvironment) {
                 return {
                     command: pythonEnvironment.pythonPath,
-                    args: config.args(testFile, cwd),
+                    args: config.args(testFile, spawnCwd),
                     env: augmentPythonEnvironment(process.env, pythonEnvironment),
                 };
             }
@@ -2238,9 +2453,9 @@ export class TestRunnerClient {
             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, cwd) };
+                return { command: vendorBin, args: config.args(testFile, spawnCwd) };
             }
-            return { command: "phpunit", args: config.args(testFile, cwd) };
+            return { command: "phpunit", args: config.args(testFile, spawnCwd) };
         }
         const binName = config.binName ?? runner;
         const suffix = process.platform === "win32" ? ".cmd" : "";
@@ -2251,7 +2466,7 @@ export class TestRunnerClient {
         if (fs.existsSync(localBin)) {
             return {
                 command: localBin,
-                args: stripWrapperArgs(binName, config.args(testFile, cwd)),
+                args: stripWrapperArgs(binName, config.args(testFile, spawnCwd)),
             };
         }
         // Any package manager's global bin dir (npm/pnpm/yarn/bun) before npx (#375).
@@ -2259,10 +2474,10 @@ export class TestRunnerClient {
         if (globalBin) {
             return {
                 command: globalBin,
-                args: stripWrapperArgs(binName, config.args(testFile, cwd)),
+                args: stripWrapperArgs(binName, config.args(testFile, spawnCwd)),
             };
         }
-        return { command: config.command, args: config.args(testFile, cwd) };
+        return { command: config.command, args: config.args(testFile, spawnCwd) };
     }
     emptyResult(testFile, sourceFile, runner, error) {
         return {