@herbertgao/pi-extensions 2026.8.5 → 2026.8.7

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

@@ -16,6 +16,7 @@ import * as path from "node:path";
 import { minimatch } from "./deps/minimatch.js";
 import { detectFileRole } from "./file-role.js";
 import { findGlobalBinary } from "./package-manager.js";
+import { isMeasuredDuration, toMeasuredDurationMs } from "./run-duration.js";
 import { safeSpawn, safeSpawnAsync } from "./safe-spawn.js";
 // Source file → test file patterns (reverse lookup)
 const SOURCE_TO_TEST_PATTERNS = [
@@ -870,9 +871,17 @@ export class TestRunnerClient {
                 runner,
                 passed: json.numPassedTests || 0,
                 failed: json.numFailedTests || 0,
-                skipped: json.numSkippedTests || 0,
+                // #1452: `numSkippedTests` is absent from both reporters' JSON, so
+                // this read was always 0. `numPendingTests` is where a `test.skip`
+                // actually lands; `numTodoTests` is counted with it because the
+                // text parsers (pytest `N skipped`, mix `N excluded` + `N skipped`)
+                // also fold every not-run test into one `skipped` figure.
+                // `??` would accept a present 0, so a reporter that emits
+                // `numSkippedTests: 0` beside a real `numPendingTests` would
+                // reproduce the very defect this removes. Take the larger reading.
+                skipped: Math.max(json.numSkippedTests ?? 0, (json.numPendingTests || 0) + (json.numTodoTests || 0)),
                 failures,
-                duration: 0,
+                duration: this.jsonRunDurationMs(json.testResults),
             };
         }
         catch (err) {
@@ -881,6 +890,74 @@ export class TestRunnerClient {
             return this.emptyResult(testFile, "", runner, failed ? "Tests failed (could not parse output)" : undefined);
         }
     }
+    /**
+     * #1452: real run duration in ms from a vitest/jest `--json` payload.
+     *
+     * NOT `testResults[].perfStats`. That field exists on jest's INTERNAL
+     * `TestResult`, but the JSON reporter's `formatTestResults` projects it to
+     * per-suite `startTime`/`endTime` and drops it — measured absent from both
+     * vitest 4.1.10 and jest 30.4.2 output, so reading it would have left this
+     * at 0. The per-suite epoch pair is what both reporters actually emit.
+     *
+     * Wall-clock SPAN across suites (max end - min start), not a sum: suites in
+     * one payload may have run in parallel workers, and summing would report
+     * more elapsed time than the run took. With the single suite pi-lens
+     * actually produces (one test file per invocation) the two agree.
+     *
+     * The span excludes the runner's own startup: the top-level `startTime` is
+     * ~330ms earlier than the first suite's on this repo. What the per-suite
+     * pair then measures is NOT the same quantity across runners. On vitest it
+     * tracks test time closely (135ms span against 134ms of summed assertions),
+     * but jest stamps a suite's `startTime` before transform and module load,
+     * so the same fields give 5595ms against 128ms of assertions. Both are
+     * honest suite wall clock; neither is comparable to the other, and only the
+     * vitest figure is close to what pytest's `in 0.05s` or ExUnit's
+     * `Finished in 0.05 seconds` report.
+     *
+     * Falls back to the summed per-assertion `duration` when a reporter omits
+     * the suite pair. Never returns a negative or non-finite value — a garbled
+     * payload must degrade to "unmeasured", not to a wrong number.
+     *
+     * #1479: that degradation is now literal. This used to return 0 for a
+     * payload it could not read, which is the figure a sub-millisecond suite
+     * also produces, so the caller could not tell them apart. It returns
+     * `undefined` instead. A readable pair whose span is 0 still returns 0,
+     * because that is a measurement.
+     */
+    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);
+        // Ordering above is unchanged from #1452 on purpose: a positive span
+        // still beats the assertion sum, and the sum still beats a suite pair
+        // that read as zero. Only the terminal case moved. A pair we could
+        // read whose span is 0 is a run that took under a millisecond — report
+        // it. Everything else was never measured.
+        if (Number.isFinite(span) && span === 0)
+            return 0;
+        return undefined;
+    }
     // --- Vitest Parser ---
     parseVitestOutput(stdout, stderr, testFile, cwd, runner) {
         return this.parseJsonTestOutput(stdout, stderr, testFile, cwd, runner);
@@ -899,7 +976,9 @@ export class TestRunnerClient {
         let passed = 0;
         let failed = 0;
         let skipped = 0;
-        let duration = 0;
+        // #1479: undefined until pytest's own `in N.NNs` is read. `in 0.00s` is
+        // a real pytest summary, so 0 has to stay available as a measurement.
+        let duration;
         if (summaryMatch) {
             // Extract numbers from various patterns
             const passedMatch = output.match(/(\d+)\s+passed/);
@@ -909,7 +988,12 @@ export class TestRunnerClient {
             passed = passedMatch ? parseInt(passedMatch[1], 10) : 0;
             failed = failedMatch ? parseInt(failedMatch[1], 10) : 0;
             skipped = skippedMatch ? parseInt(skippedMatch[1], 10) : 0;
-            duration = durationMatch ? parseFloat(durationMatch[1]) * 1000 : 0;
+            // Rounded, like `jsonRunDurationMs` and PHPUnit's legacy path:
+            // `in 2.01s` is 2009.9999999999998 in binary floating point, and
+            // the turn-end log prints the number as it stands.
+            // (Routing this through `toMeasuredDurationMs` is #1484, not this.)
+            if (durationMatch)
+                duration = Math.round(parseFloat(durationMatch[1]) * 1000);
         }
         // Parse individual failures: "FAILED tests/test_foo.py::test_something - AssertionError: ..."
         const failureRegex = /FAILED\s+(\S+::\S+)\s*-\s*(.+?)(?:\n|$)/g;
@@ -972,6 +1056,46 @@ export class TestRunnerClient {
         while ((match = failureRegex.exec(output)) !== null) {
             failures.push({ name: match[1], message: match[1] });
         }
+        // #1452: PHPUnit prints its own elapsed time and this parser dropped it,
+        // so every PHPUnit run reported 0ms. Two shapes are accepted because the
+        // summary changed across supported majors:
+        //   PHPUnit >= 9.3   "Time: 00:00.123, Memory: 8.00 MB"   (HH:)MM:SS.mmm
+        //   PHPUnit <= 9.2   "Time: 1.23 seconds, Memory: 10.00MB" | "Time: 123 ms"
+        // NOT VERIFIED AGAINST A LIVE PHPUnit — there is no PHP toolchain on the
+        // box this was written on. Both shapes are covered by unit tests against
+        // literal summary lines taken from the PHPUnit printers, and the parser
+        // leaves duration UNMEASURED when neither matches (#1479 — it used to
+        // leave 0, which the turn-end log printed as a measurement), so an
+        // unrecognised summary degrades to "we do not know" rather than to a
+        // wrong figure.
+        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);
+            // ".1" is a tenth, ".12" hundredths — pad rather than parseInt, or
+            // "Time: 00:00.1" would read as 1ms instead of 100ms.
+            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")
+                        ? 60_000
+                        : 1000;
+                if (Number.isFinite(value) && value > 0) {
+                    duration = Math.round(value * scale);
+                }
+            }
+        }
         return {
             file: testFile,
             sourceFile: "",
@@ -980,7 +1104,7 @@ export class TestRunnerClient {
             failed,
             skipped,
             failures,
-            duration: 0,
+            duration,
             error: exitCode !== 0 && passed === 0 && failed === 0
                 ? "PHPUnit runner error"
                 : undefined,
@@ -992,7 +1116,8 @@ export class TestRunnerClient {
         let passed = 0;
         let failed = 0;
         let skipped = 0;
-        let duration = 0;
+        // #1479: undefined until ExUnit's own `Finished in N seconds` is read.
+        let duration;
         // Summary: "3 tests, 1 failure" (optionally ", N excluded" / ", N skipped")
         const summaryMatch = output.match(/(\d+)\s+tests?,\s*(\d+)\s+failures?(?:,\s*(\d+)\s+excluded)?(?:,\s*(\d+)\s+skipped)?/i);
         if (summaryMatch) {
@@ -1007,7 +1132,10 @@ export class TestRunnerClient {
         }
         const durationMatch = output.match(/Finished in\s+([\d.]+)\s+seconds?/i);
         if (durationMatch) {
-            duration = Number.parseFloat(durationMatch[1]) * 1000;
+            // Rounded for the same reason pytest's is: `2.01` seconds is
+            // 2009.9999999999998 ms unrounded, and that reaches the log.
+            // (Routing this through `toMeasuredDurationMs` is #1484.)
+            duration = Math.round(Number.parseFloat(durationMatch[1]) * 1000);
         }
         // Individual failures: "  1) test some behavior (MyModuleTest)"
         const failures = [];
@@ -1035,43 +1163,306 @@ export class TestRunnerClient {
         };
     }
     // --- Generic text parser for non-JSON runners ---
+    /**
+     * #1480: elapsed time for the runners `parseGenericRunnerOutput` handles.
+     *
+     * Before this, only go's `ok  pkg  0.25s` was read and every other runner
+     * reported a hardcoded 0. #1479 made the log tell "measured" from
+     * "unmeasured", but this parser is the `default:` arm behind cargo, dotnet,
+     * maven, gradle, rspec, minitest and every unrecognised runner, so all of
+     * them still reported a number nobody measured. Each runner below prints
+     * its elapsed time in the same summary block this parser already regexes
+     * for pass/fail counts.
+     *
+     * Absent, not 0, is the answer when nothing is found — see
+     * `TestResult.duration` and `run-duration.ts`. A probe that returned 0 here
+     * would be claiming a measurement.
+     *
+     * One parser serves all runners, so the probe is selected BY RUNNER NAME.
+     * Running every probe over every runner's output was the original shape of
+     * this code, and it let gradle borrow a number: `BUILD SUCCESSFUL in 3s`
+     * plus a preceding `... ok` line satisfied go's `ok <pkg> <n>s` probe, so
+     * the whole-build wall clock got reported as test time — the exact wrong
+     * number this function refuses to print. Gating on the runner makes that
+     * structurally impossible rather than merely unlikely, and it matters most
+     * for the `default:` arm of the switch, which is where an unrecognised or
+     * custom runner's arbitrary output lands.
+     *
+     * Within a runner the patterns are still anchored where an anchor helps,
+     * for the same reason #1452's PHPUnit `Time:` pattern is anchored: an
+     * unanchored /m match takes the FIRST hit over stdout+stderr, and a failure
+     * diff quoting "Finished in ..." would beat the real summary. Note what the
+     * `^` in `^Finished in` does and does not buy. It rejects a decoy that is
+     * INDENTED, which is what a quoted expectation or an assertion diff is; it
+     * does NOT rank two column-0 matches, so an unindented decoy printed by the
+     * suite itself would still win. It is a cheap filter for the common shape,
+     * not a proof of uniqueness. And it is not an anchor to the counts line for
+     * rspec or minitest: both print their elapsed time on a `Finished in ...`
+     * line and their counts (`3 examples, 0 failures`, `1 runs, 1 assertions,
+     * ...`) on a different line.
+     *
+     * KNOWN LIMIT — first summary only. cargo across multiple crates, `dotnet
+     * test` across multiple assemblies, and `go test ./...` across multiple
+     * packages each print one summary per unit, and these probes take the
+     * first. A multi-unit run therefore UNDER-REPORTS its duration. That is
+     * left as-is deliberately: the count parsers below have the same first-match
+     * shape for those runners, so duration and counts describe the same scope.
+     * Fixing one without the other would trade an under-report for an
+     * inconsistency. Pinned by test so it stays a known limit, not an accident.
+     *
+     * Formats and how each was verified:
+     *
+     * - go — `ok  example.com/pkg  0.253s`. Pre-existing pattern, unchanged
+     *   apart from the shared finite/non-negative guard.
+     *
+     * - cargo — `test result: ok. 3 passed; 0 failed; 1 ignored; 0 measured;
+     *   0 filtered out; finished in 0.253s`. NOT VERIFIED AGAINST A LIVE CARGO
+     *   RUN — this box has no MSVC linker, so `cargo test` cannot link. Format
+     *   read out of the libtest printer shipped with the local rustc 1.94.1:
+     *   `library/test/src/formatters/pretty.rs` builds `"; finished in
+     *   {exec_time}"` and `library/test/src/time.rs` renders `TestSuiteExecTime`
+     *   as `{:.2}s`. Older rustc omits the suffix entirely; that degrades to
+     *   unmeasured.
+     *
+     * - dotnet/vstest — `Failed: 1, Passed: 2, Skipped: 0, Total: 3, Duration:
+     *   1 m 30 s - t.dll (net8.0)`. NOT VERIFIED AGAINST A LIVE `dotnet test` —
+     *   NuGet restore has no network here. Format read out of the
+     *   vstest.console.dll shipped with the local .NET SDK 8.0.423, which holds
+     *   the literal `{0} - Failed: {1}, Passed: {2}, Skipped: {3}, Total: {4},
+     *   Duration: {5}` next to the unit literals `" h"`, `" m"`, `" s"`,
+     *   `" ms"`, `"< 1 ms"`. The duration is a space-joined token list, so it
+     *   is summed rather than read as one number.
+     *
+     * - maven/surefire — `Tests run: 4, Failures: 0, Errors: 0, Skipped: 0,
+     *   Time elapsed: 0.05 s -- in com.example.AppTest`. NOT VERIFIED AGAINST A
+     *   LIVE MAVEN — no mvn on this box. Summed across the per-class lines,
+     *   because surefire prints `Time elapsed` per test class and its final
+     *   `Results:` total carries no time. `[INFO] Total time: 3.4 s` is
+     *   deliberately NOT used: that is whole-build wall clock including compile,
+     *   which would report a wrong number rather than none. Surefire 2.x wrote
+     *   `sec` where 3.x writes `s`; both are accepted.
+     *
+     *   EXPECT THIS TO BE ABSENT IN PRACTICE. pi-lens invokes `mvn test -q`
+     *   (see RUNNERS.maven above), and surefire logs its per-class `Tests run:
+     *   ..., Time elapsed: ...` lines at INFO, which `-q` suppresses. Only the
+     *   ERROR-level lines of a FAILING class survive, so a green maven run
+     *   typically reports unmeasured and a red one reports the failing classes'
+     *   time alone. REASONED, NOT RUN — there is no mvn on this box to confirm
+     *   it. Left in rather than dropped: it costs nothing, it is correct when
+     *   the output does carry the lines (a repo that sets `-Dsurefire.useFile`
+     *   or drops `-q` via `.mvn/maven.config`), and `unmeasured` is an honest
+     *   report of the quiet case.
+     *
+     * - rspec — `Finished in 0.32394 seconds (files took 0.49427 seconds to
+     *   load)`. VERIFIED against a live rspec-core 3.13.6 run on ruby 3.4.10.
+     *   The minutes form (`Finished in 2 minutes 15.14 seconds`) comes from
+     *   `RSpec::Core::Formatters::Helpers.format_duration` in the same
+     *   installed gem; rspec never prints hours. Load time trails the run time
+     *   on the same line and must not be read instead of it.
+     *
+     * - minitest — `Finished in 0.254594s, 7.8557 runs/s, 7.8557 assertions/s.`
+     *   VERIFIED against a live minitest 5.25.4 run on ruby 3.4.10. The format
+     *   string is `"Finished in %.6fs, ..."` in minitest.rb, always seconds.
+     *
+     * - gradle — deliberately left unmeasured, and now UNREACHABLE by any other
+     *   runner's probe rather than merely unmatched by it. Gradle's console
+     *   summary (`4 tests completed, 1 failed`) carries no elapsed time, and
+     *   `BUILD SUCCESSFUL in 3s` is whole-build wall clock including compile
+     *   and dependency resolution. Reporting that as test time would be a wrong
+     *   number; #1479 makes the absence legible in the log instead.
+     */
+    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:
+                // gradle and anything unrecognised: unmeasured, never
+                // zero-as-measurement and never another runner's number.
+                return undefined;
+        }
+    }
+    /** go: `ok  	example.com/pkg	0.253s`. First package summary only. */
+    parseGoDuration(output) {
+        const goSummary = output.match(/ok\s+\S+\s+([\d.]+)s/m);
+        if (!goSummary)
+            return undefined;
+        return toMeasuredDurationMs(Number.parseFloat(goSummary[1]) * 1000);
+    }
+    /** cargo: `...; 0 filtered out; finished in 0.25s`. First crate only. */
+    parseCargoDuration(output) {
+        const cargoTime = output.match(/^test result:.*?;\s*finished in\s+([\d.]+)\s*s\b/im);
+        if (!cargoTime)
+            return undefined;
+        return toMeasuredDurationMs(Number.parseFloat(cargoTime[1]) * 1000);
+    }
+    /**
+     * dotnet/vstest: `..., Total: 3, Duration: 1 m 30 s - t.dll (net8.0)`.
+     *
+     * Anchored to the counts line, and the tail stops at the ` - <dll>`
+     * separator: without that stop an assembly name is scanned for unit tokens,
+     * and a name like `Timeouts.30s.Tests.dll` adds 30 seconds of nothing.
+     * First assembly only.
+     */
+    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 undefined;
+        // `< 1 ms` is vstest's "too fast to name a number", and under the
+        // optional-duration contract 0 is exactly the right thing to say: the
+        // run WAS measured and it rounds to 0 ms. The token scan below would
+        // reach the same 0 by finding no tokens, but only by accident, and the
+        // accident is indistinguishable from an unparseable tail — so the case
+        // is spelled out.
+        if (/^\s*</.test(dotnetTime[1]))
+            return 0;
+        let total = 0;
+        let tokens = 0;
+        // "ms" before "m", or "250 ms" scores as 250 minutes.
+        const units = {
+            ms: 1,
+            s: 1000,
+            m: 60_000,
+            h: 3_600_000,
+        };
+        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++;
+        }
+        // A tail we matched but could not read a single token out of is not a
+        // zero-length run, it is an unrecognised format.
+        if (tokens === 0)
+            return undefined;
+        return toMeasuredDurationMs(total);
+    }
+    /**
+     * maven/surefire: summed across per-class `Time elapsed` lines.
+     *
+     * The guard is "did any line match", NOT "is the sum positive". Surefire
+     * prints `Time elapsed: 0.00 s` for a trivial test class, and that is a
+     * measurement of zero, not a failure to measure.
+     */
+    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 undefined;
+        return toMeasuredDurationMs(surefireTotal * 1000);
+    }
+    /** rspec: `Finished in 2 minutes 15.14 seconds (files took 0.5 ...)`. */
+    parseRspecDuration(output) {
+        const rspecTime = output.match(/^Finished in\s+(?:([\d.]+)\s+minutes?\s+)?([\d.]+)\s+seconds?/im);
+        if (!rspecTime)
+            return undefined;
+        const minutes = rspecTime[1] ? Number.parseFloat(rspecTime[1]) : 0;
+        return toMeasuredDurationMs(minutes * 60_000 + Number.parseFloat(rspecTime[2]) * 1000);
+    }
+    /**
+     * minitest: `Finished in 0.254594s, 7.8557 runs/s, ...`.
+     *
+     * The trailing `,` is load-bearing, not decoration: it is what separates
+     * minitest's own line from a bare `Finished in 99s` the suite under test
+     * printed at column 0, which the `^` alone does not rank.
+     */
+    parseMinitestDuration(output) {
+        const minitestTime = output.match(/^Finished in\s+([\d.]+)s\s*,/im);
+        if (!minitestTime)
+            return undefined;
+        return toMeasuredDurationMs(Number.parseFloat(minitestTime[1]) * 1000);
+    }
     parseGenericRunnerOutput(stdout, stderr, exitCode, testFile, runner) {
         const output = `${stdout}\n${stderr}`;
         const lower = output.toLowerCase();
         let passed = 0;
-        let failed = exitCode === 0 ? 0 : 1;
+        // #1487: NOT `exitCode === 0 ? 0 : 1`. Pre-seeding `failed` to 1 on a
+        // non-zero exit made the runner-error branch below unreachable — it
+        // requires `failed === 0`, which a spawn/config/load failure (no
+        // counts to parse) could never reach once this had already claimed
+        // the slot. `matched` tracks whether a count parser actually found
+        // real counts; the exit-code-distrust fallback further down uses it
+        // to tell "a runner that never ran" from "a runner whose summary
+        // legitimately parsed to zero failures".
+        let failed = 0;
         let skipped = 0;
-        let duration = 0;
-        const goSummary = output.match(/ok\s+\S+\s+([\d.]+)s/m);
-        if (goSummary) {
-            duration = Number.parseFloat(goSummary[1]) * 1000;
-        }
+        let matched = false;
+        // #1480: `number | undefined`, and sourced per runner. This used to be
+        // `let duration = 0` with only go's probe able to move it, so every
+        // other runner reported a zero it never measured.
+        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 mavenSummary = output.match(/Tests run:\s*(\d+),\s*Failures:\s*(\d+),\s*Errors:\s*(\d+),\s*Skipped:\s*(\d+)/i);
-        if (mavenSummary) {
-            const total = Number.parseInt(mavenSummary[1], 10);
-            const failures = Number.parseInt(mavenSummary[2], 10);
-            const errors = Number.parseInt(mavenSummary[3], 10);
-            skipped = Number.parseInt(mavenSummary[4], 10);
-            failed = failures + errors;
+        // #1480 (adjacent, duration-independent): surefire prints one
+        // `Tests run:` line PER TEST CLASS (those carry `Time elapsed:`) and
+        // then a per-MODULE aggregate under `Results:` (which does not). Taking
+        // the FIRST match scored a run by its first class alone — a two-class
+        // run with a failure in the second class reported 0 failures.
+        //
+        // Taking the LAST match is just as wrong, in a worse direction. A
+        // multi-module reactor run prints one `Results:` aggregate per module,
+        // and the last is the last module: a `--fail-at-end` build whose first
+        // module had 3 failures and whose second module was green would report
+        // 0 failures, turning a red build into `PASS` in the turn-end log. That
+        // is reachable without pi-lens passing the flag, because maven also
+        // reads `.mvn/maven.config` and `MAVEN_ARGS`.
+        //
+        // So: SUM the aggregates. That makes counts reactor-wide, the same
+        // scope `parseMavenDuration` sums its per-class times over. When no
+        // aggregate is present (output truncated, or `Results:` suppressed) the
+        // per-class lines sum to the same totals, so they are the fallback.
+        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) {
@@ -1080,25 +1471,160 @@ export class TestRunnerClient {
             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;
         }
-        if (passed === 0 && failed === 0 && skipped === 0 && exitCode === 0) {
-            passed = 1;
+        // #1487/#1524/#1524-r3: `--- FAIL: TestName` is extracted first and
+        // separately from the other two name patterns, because it is the
+        // ONLY one of the three that is unambiguous evidence a real go test
+        // ran — see the `runnerError` comment below for why the other two
+        // may no longer veto on their own. go otherwise has no count parser
+        // at all (only a duration probe), so without this go's `matched`
+        // stayed false even on a real failure.
+        //
+        // #1524-r3: go ALSO gets a real count parser here, not just a name
+        // extractor. A panic inside `TestMain`/package `init` (exit 2) never
+        // prints a `--- FAIL:` line — there is no test to name, the process
+        // died before any test ran — so `goFailNames` alone left `matched`
+        // false and such a panic hit the same runner-error branch as a
+        // spawn failure, even though `go test` DID run and DID fail. `FAIL
+        // \t<pkg>` is go's own per-package verdict line and is printed for
+        // exactly this case; `ok  <pkg>  <n>s` is its pass counterpart.
+        // Package-line counts, like the go duration probe above, take the
+        // FIRST package summary only — the same known limit already
+        // documented on `parseGenericRunnerDuration`.
+        const goFailNames = [
+            ...output.matchAll(/--- FAIL:[^\S\n]+([^\s(]+)/g),
+        ];
+        // #1524-r4: only COUNT unparented failures. go prints a `--- FAIL:`
+        // line for every level of a failing subtest tree — `TestA` AND
+        // `TestA/sub` each get their own line for what is really one
+        // underlying failure — so counting every line inflated `failed`
+        // (two lines here read as two failures for one broken test). A name
+        // containing "/" whose prefix up to that "/" is itself in the list
+        // is a subtest of an already-counted parent; only names that are
+        // NOT such a subtest count. `goFailNames` itself (all lines) is
+        // still what decides `matched`/the runner-error veto below and
+        // what's listed in `failures` — subtest names are still useful
+        // detail there, just not double-counted.
+        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;
+        if (runner === "go") {
+            // #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
+            // test) — which matched the same shape as a real `FAIL <pkg>
+            // <duration>` test verdict line. Neither ran a single test; both
+            // were rendering as `✗ 1/1 failed ✗ go failure` instead of the
+            // runner error they are.
+            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;
+            }
+            // #1524-r4: unconditional, not `else if`. A multi-package run
+            // can have BOTH a real failure and packages that passed clean —
+            // `ok a` / `--- FAIL: TestB` / `ok c` is 2 passed AND 1 failed,
+            // not "1 failed, 0 passed" with the green packages silently
+            // dropped because the fail branch above already ran.
+            if (goOkPackages.length > 0) {
+                passed = Math.max(passed, goOkPackages.length);
+                matched = true;
+            }
         }
+        // #1524-r3: anchored to line START (`^`), and `[^\S\n]` (horizontal
+        // whitespace only) in place of `\s` between the keyword and the
+        // name. The prior `\bFAILED\s+([^\n]+)` and `Failure:\s+([^\n]+)`
+        // let their OWN `\s+` gap cross the newline: a bare `FAILED` at the
+        // end of a line has nothing after it on that line, so `\s+` ate the
+        // newline itself and `([^\n]+)` captured the FIRST TOKEN OF THE
+        // NEXT LINE as the "test name" — proven on a gradle compile failure
+        // (`> Task :compileJava FAILED` followed by
+        // `FAILURE: Build failed with an exception.`, which then rendered
+        // as the invented failure name) and the newline-spanning shape in
+        // general (`FAILED\n\nsome trailing note` → name "some trailing
+        // note"). Requiring `(\S.*)$` on the SAME line makes a keyword with
+        // nothing following it on that line simply not match, rather than
+        // reaching across for content that was never the name.
         const failures = [];
-        const names = [
-            ...output.matchAll(/--- FAIL:\s+([^\s(]+)/g),
-            ...output.matchAll(/\bFAILED\s+([^\n]+)/g),
-            ...output.matchAll(/Failure:\s+([^\n]+)/g),
+        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 names.slice(0, 5)) {
+        for (const m of otherNames) {
+            if (failures.length >= 5)
+                break;
             failures.push({ name: m[1].trim(), message: m[1].trim() });
         }
+        // #1487: gated on `!matched`, not on `failed === 0`. A non-zero exit
+        // with NO count parser match — a spawn/config/load failure, nothing
+        // ran — is infrastructure, not a test verdict: report it as a runner
+        // error. A non-zero exit a count parser DID match (even to a
+        // legitimate `failed === 0`, e.g. a green last module of a red
+        // reactor) is a real run that produced real counts, so it is never a
+        // runner error, and the exit-code-distrust guard below still forces
+        // at least one failure so it can't render as PASS.
+        //
+        // #1524-r3: the veto is `goFailNames.length === 0`, NOT
+        // `failures.length === 0`. Only `--- FAIL:` is a marker a test
+        // runner emits SPECIFICALLY for a failed test; `FAILED`/`Failure:`
+        // are generic words a build tool prints for reasons that have
+        // nothing to do with a test — a gradle task failing to compile, a
+        // maven goal failing before surefire ever runs, an rspec file that
+        // never loaded. Letting those two veto the runner-error branch on
+        // their own reintroduced #1487's exact symptom for the commonest
+        // gradle/maven/rspec failure shapes (proven: `[ERROR] Failed to
+        // execute goal ... FAILED` and rspec's `Failure: cannot load such
+        // file` both rendered as a fabricated test failure instead of the
+        // runner error they actually are). They still label a name onto
+        // `failures` above when `matched` or `goFailNames` already settled
+        // the question some other way, but they no longer settle it alone.
+        const runnerError = exitCode !== 0 && !matched && goFailNames.length === 0 && lower.includes("error")
+            ? `Runner ${runner} exited with ${exitCode}`
+            : undefined;
+        // #1524-r4 (tidy): a runner-error result reports through
+        // `formatResult`'s runner-error branch, not the failed-tests
+        // branch, so any name `otherNames` picked up before this was
+        // decided (e.g. a same-line `Failure: cannot load such file`)
+        // would sit in `failures` unused but visible to anything reading
+        // the raw `TestResult` — an error result with a non-empty
+        // `failures` list is a self-contradiction. Clear it here so the
+        // result is one or the other, never both.
+        if (runnerError) {
+            failures.length = 0;
+        }
+        // #1480 (adjacent): a non-zero exit is the runner saying the run
+        // failed. Every count parser above can legitimately arrive at
+        // `failed === 0` — a summary that only covers part of the run, a green
+        // module of a red reactor build, a failure outside any test — and the
+        // turn-end log would then print PASS over a build the runner rejected.
+        // Trust the exit code: no parse of the text may talk it out of at least
+        // one failure. Skipped when `runnerError` is set — that case already
+        // reports through `formatResult`'s runner-error branch, which requires
+        // `passed === 0 && failed === 0` to stay reachable, and forcing
+        // `failed` to 1 here would make it unreachable again (#1487).
+        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("\n")
@@ -1107,6 +1633,9 @@ export class TestRunnerClient {
                 .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: "",
@@ -1116,9 +1645,7 @@ export class TestRunnerClient {
             skipped,
             failures,
             duration,
-            error: exitCode !== 0 && failed === 0 && lower.includes("error")
-                ? `Runner ${runner} exited with ${exitCode}`
-                : undefined,
+            error: runnerError,
         };
     }
     // --- Formatting ---
@@ -1134,7 +1661,21 @@ export class TestRunnerClient {
         if (total === 0) {
             return ""; // No tests to report
         }
-        const durationStr = result.duration > 0 ? ` (${(result.duration / 1000).toFixed(2)}s)` : "";
+        // #1479 deliberately does NOT change this surface. The agent-facing
+        // string already suppressed the suffix for a 0, so an unmeasured run
+        // and a zero-length one look the same here and always did. The issue
+        // scopes the unmeasured/zero distinction to the turn-end log line;
+        // widening it to the LLM prompt is a separate call about prompt noise.
+        // #1480: the "is this a measurement at all" half of the test comes from
+        // `run-duration.ts` so this surface cannot drift from the log's answer.
+        // The `> 0` half is the scope decision above and stays local to it — it
+        // is what suppresses the suffix for a measured zero, which is a choice
+        // about prompt noise rather than about the duration contract. Routing
+        // the first half through the shared predicate also stops a non-finite
+        // duration rendering as ` (Infinitys)`.
+        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}`;
         }
@@ -1283,7 +1824,8 @@ export class TestRunnerClient {
             failed: 0,
             skipped: 0,
             failures: [],
-            duration: 0,
+            // #1479: no duration key at all. Nothing ran, so there is nothing
+            // to report — this used to say 0, which reads as "ran, instantly".
             error,
         };
     }