@herbertgao/pi-extensions 2026.8.5 → 2026.8.6

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,17 +1163,239 @@ 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;
         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;
-        }
+        // #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);
@@ -1058,13 +1408,41 @@ export class TestRunnerClient {
             passed = Number.parseInt(dotnetSummary[2], 10);
             skipped = Number.parseInt(dotnetSummary[3], 10);
         }
-        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);
         }
         const rspecSummary = output.match(/(\d+)\s+examples?,\s+(\d+)\s+failures?/i);
@@ -1087,6 +1465,22 @@ export class TestRunnerClient {
             failed = Number.parseInt(gradleSummary[2], 10);
             passed = Math.max(0, total - failed);
         }
+        // Captured BEFORE the guard below, which rewrites `failed` out of the
+        // state this condition reads. Without this the runner-error string
+        // silently became unreachable.
+        const runnerError = exitCode !== 0 && failed === 0 && lower.includes("error")
+            ? `Runner ${runner} exited with ${exitCode}`
+            : undefined;
+        // #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.
+        if (exitCode !== 0 && failed === 0) {
+            failed = 1;
+        }
         if (passed === 0 && failed === 0 && skipped === 0 && exitCode === 0) {
             passed = 1;
         }
@@ -1116,9 +1510,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 +1526,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 +1689,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,
         };
     }

package/node_modules/pi-lens/dist/clients/tool-policy.js

@@ -1453,6 +1453,7 @@ export function getAutofixPolicyForFile(filePath, context = {}) {
             defaultWhenUnconfigured: true,
             gate: "smart-default",
             safe: true,
+            scope: "cargo-project",
         };
     }
     if ([".json", ".jsonc"].includes(ext)) {
@@ -1595,6 +1596,7 @@ export function getAutofixPolicyForFile(filePath, context = {}) {
             defaultWhenUnconfigured: true,
             gate: "smart-default",
             safe: true,
+            scope: "dart-project",
         };
     }
     return undefined;

package/node_modules/pi-lens/dist/clients/tool-set-policy.js

@@ -0,0 +1,76 @@
+import { logLatency } from "./latency-logger.js";
+/**
+ * Whether the host will send this model deferred (searchable) tool
+ * definitions rather than the full inline list.
+ *
+ * Read the host's own decision off `ctx.model.compat` — pi resolves that
+ * flag from the model config (`core/model-config`, `compat.supportsToolReferences`)
+ * and it is the only capability signal a consumer can honestly observe.
+ * A missing flag means "unknown", which we report as false: this value only
+ * annotates the `tool_set_mutation` log line, so guessing high would make the
+ * log lie, while guessing low merely under-claims.
+ */
+export function supportsDeferredTools(model) {
+    return model?.compat?.supportsToolReferences === true;
+}
+/**
+ * A fresh logical conversation — the only reasons that start with an empty
+ * activation memory. `undefined` is included because older hosts fire
+ * `session_start` with no `reason` at all.
+ *
+ * Every OTHER reason (fork/reload/resume) is a session REBUILD: the host
+ * constructs a brand-new AgentSession with `includeAllExtensionTools: true`
+ * (pi `core/agent-session.js`), so every registered pi-lens tool is active
+ * again by the time our handler runs, while pi-lens's own extension closure
+ * state survives. Those reasons must RESTORE the previous posture, not skip.
+ */
+export function isFreshSessionStart(reason) {
+    return reason === undefined || reason === "startup" || reason === "new";
+}
+/**
+ * Compute the active-tool set pi-lens wants: everything currently active that
+ * is not a lazy tool, plus exactly the lazy tools the model activated in this
+ * logical session (`remembered`).
+ *
+ * On startup/new `remembered` is empty and this is the plain baseline shrink.
+ * On fork/reload/resume the host has just re-activated all registered tools,
+ * and this restores the parent's posture character-for-character — which both
+ * preserves the model's activations and keeps the advertised tool list equal
+ * to the one the prompt cache prefix was built from.
+ */
+export function planToolSet(active, lazyNames, remembered) {
+    const desired = active.filter(
+    // Lazy tools are dropped here and re-appended below in REMEMBERED
+    // (= activation) order. Keeping them in the host's registration
+    // position would restore the right SET in the wrong ARRAY order, and
+    // the active-tools array is what serializes into the request's tool
+    // block — a transposition is a changed prefix, i.e. a cache miss.
+    (name) => !lazyNames.has(name));
+    // A remembered tool the host did not list as active still belongs in the
+    // set (defensive: the host controls what `getActiveTools` returns).
+    const desiredSet = new Set(desired);
+    for (const name of remembered) {
+        if (!desiredSet.has(name)) {
+            desired.push(name);
+            desiredSet.add(name);
+        }
+    }
+    const activeSet = new Set(active);
+    const removedCount = active.filter((name) => !desiredSet.has(name)).length;
+    const addedCount = desired.filter((name) => !activeSet.has(name)).length;
+    return {
+        desired,
+        addedCount,
+        removedCount,
+        changed: addedCount > 0 || removedCount > 0,
+    };
+}
+export function recordToolSetMutation(mutation) {
+    logLatency({
+        type: "phase",
+        filePath: "<pi-lens>",
+        phase: "tool_set_mutation",
+        durationMs: 0,
+        metadata: { ...mutation },
+    });
+}