From 71dfd899dfd2ffc625d9dd99c24db1a72806c67e Mon Sep 17 00:00:00 2001
From: Karthik Suresh <7954591+k21993@users.noreply.github.com>
Date: Thu, 17 Sep 2026 01:55:00 -0700
Subject: [PATCH] pr_runtime: run vitest with its verbose reporter and parse it

normalize_test_cmds_for_runtime appended `--verbose` to vitest commands,
which vitest 3-5 reject with `CACError: Unknown option`, so no test ran.
Its per-test output comes from `--reporter=verbose` instead.

That output was not parseable either: vitest colors it whenever TERM is
unset, and its bare ` 12ms` duration was left in the test name. Strip
escape codes, then read vitest's fully qualified verbose lines, dropping
the run suffixes and keeping project labels as part of the identity.

Vitest's default reporter is ignored on purpose: it collapses a fully
passing file to one line, so a patch that fixed more than the gold patch
would lose its FAIL_TO_PASS tests from the log.

Stripping escape codes also lets colored jest output parse, once its
padded ` FAIL ` header is accepted.

Closes #142
---
 src/repo2rlenv/log_parsers/jest_parser.py     |  59 ++-
 .../pipelines/_pr_runtime_verifier.py         |  29 +-
 src/repo2rlenv/pipelines/pr_runtime.py        |  16 +-
 tests/test_pipeline_pr_runtime.py             |  15 +
 tests/test_vitest_output.py                   | 400 ++++++++++++++++++
 5 files changed, 511 insertions(+), 8 deletions(-)
 create mode 100644 tests/test_vitest_output.py

diff --git a/src/repo2rlenv/log_parsers/jest_parser.py b/src/repo2rlenv/log_parsers/jest_parser.py
index 935b2db6..fea280f0 100644
--- a/src/repo2rlenv/log_parsers/jest_parser.py
+++ b/src/repo2rlenv/log_parsers/jest_parser.py
@@ -30,8 +30,19 @@
   ○ / "skipped"   → SKIPPED
 
 Mocha (the other common JS runner) uses the same ✓/✕ glyphs, so this parser
-covers most mocha output too. Vitest's default reporter is jest-compatible
-by design — also covered.
+covers most mocha output too.
+
+Vitest (3+) is detected by its ` RUN  vX.Y.Z` / ` Test Files` markers and read
+from `--reporter=verbose`, which prints one fully qualified line per test:
+
+     ✓ src/foo.test.ts > Foo > returns 200 1ms
+     × |unit| src/foo.test.ts > Foo > returns 500 3ms
+
+The name is kept as printed, minus the duration and retry/heap/note suffixes.
+Vitest's default reporter collapses fully passing files to one summary line,
+so its per-test lines are ignored: a test would vanish from the log as soon as
+a patch fixed the rest of its file. Vitest also colors output whenever TERM is
+unset, as in a non-TTY `docker exec`, so escape codes are stripped first.
 
 Released under Apache-2.0.
 """
@@ -44,8 +55,9 @@
 
 # File header: `PASS src/foo.test.ts (123 ms)` or `FAIL src/foo.test.ts`.
 # Captures the file path so we can prefix it onto test names.
+# With color, the label is padded (` FAIL `), leaving one leading space.
 _JEST_FILE_RE = re.compile(
-    r"^(?:PASS|FAIL)\s+(?P<path>\S+\.(?:ts|tsx|js|jsx|mjs|cjs))\b",
+    r"^ ?(?:PASS|FAIL)\s+(?P<path>\S+\.(?:ts|tsx|js|jsx|mjs|cjs))\b",
 )
 
 # Per-test glyph line. Indented arbitrarily; the glyph is the discriminator.
@@ -65,6 +77,44 @@
     "◯": "SKIPPED",
 }
 
+# Terminal escape codes (colors), stripped before any matching.
+_ANSI_RE = re.compile(r"\x1b\[[0-9;?]*[A-Za-z]")
+
+# ` RUN  v5.0.1 /repo` starts a vitest run; ` Test Files  1 passed (1)` ends it.
+_VITEST_MARKER_RE = re.compile(r"^\s*(?:RUN\s+v\d+\.\d+|Test Files\s+\d)", re.MULTILINE)
+
+# A `--reporter=verbose` test line. The optional project label is `|unit| `
+# without color and ` unit  ` with it. Suffixes follow vitest's
+# getTestCaseSuffix: duration, retries, repeats, heap usage, skip note.
+_VITEST_TEST_RE = re.compile(
+    r"^\s*(?P<glyph>[✓×↓□]) (?:\|(?P<project>[^|]+)\| | (?P<label>\S+)  )?"
+    r"(?P<name>\S+ > .+?)(?P<duration> \d{1,9}ms)?"
+    r"(?: \(retry x\d{1,9}\))?(?: \(repeat x\d{1,9}\))?(?: \d{1,9} MB heap used)?(?: \[[^\[\]]*\])?$"
+)
+
+_VITEST_STATUS: dict[str, TestStatus] = {
+    "✓": "PASSED",
+    "×": "FAILED",
+    "↓": "SKIPPED",
+    "□": "SKIPPED",
+}
+
+
+def _parse_vitest(log: str) -> dict[str, TestStatus]:
+    out: dict[str, TestStatus] = {}
+    for raw in log.split("\n"):
+        m = _VITEST_TEST_RE.match(raw.rstrip())
+        if not m:
+            continue
+        glyph = m.group("glyph")
+        name = m.group("name")
+        # Only finished tests print a duration; keep a skipped title's own "5ms".
+        if glyph in "↓□" and m.group("duration"):
+            name += m.group("duration")
+        project = m.group("project") or m.group("label")
+        out[f"|{project}| {name}" if project else name] = _VITEST_STATUS[glyph]
+    return out
+
 
 def parse_jest(log: str) -> dict[str, TestStatus]:
     """Return {test_name -> status} parsed from Jest / Mocha / Vitest output.
@@ -78,6 +128,9 @@ def parse_jest(log: str) -> dict[str, TestStatus]:
     out: dict[str, TestStatus] = {}
     if not log:
         return out
+    log = _ANSI_RE.sub("", log)
+    if _VITEST_MARKER_RE.search(log):
+        return _parse_vitest(log)
 
     current_file: str | None = None
     # describe stack indexed by indent depth (in characters). On a new test
diff --git a/src/repo2rlenv/pipelines/_pr_runtime_verifier.py b/src/repo2rlenv/pipelines/_pr_runtime_verifier.py
index 56ab3425..618ecd20 100644
--- a/src/repo2rlenv/pipelines/_pr_runtime_verifier.py
+++ b/src/repo2rlenv/pipelines/_pr_runtime_verifier.py
@@ -173,7 +173,7 @@ def parse_cargo_test(log: str) -> dict[str, str]:
     return out
 
 
-_JEST_FILE_RE = re.compile(r"^(?:PASS|FAIL)\s+(?P<path>\S+\.(?:ts|tsx|js|jsx|mjs|cjs))\b")
+_JEST_FILE_RE = re.compile(r"^ ?(?:PASS|FAIL)\s+(?P<path>\S+\.(?:ts|tsx|js|jsx|mjs|cjs))\b")
 _JEST_TEST_RE = re.compile(
     r"^(?P<indent>\s*)(?P<glyph>✓|√|✕|×|✗|○|◯)\s+(?P<name>.+?)(?:\s+\(\d+(?:\.\d+)?\s*m?s\))?$"
 )
@@ -186,6 +186,30 @@ def parse_cargo_test(log: str) -> dict[str, str]:
     "○": SKIPPED,
     "◯": SKIPPED,
 }
+# Keep these patterns in sync with log_parsers/jest_parser.py.
+_ANSI_RE = re.compile(r"\x1b\[[0-9;?]*[A-Za-z]")
+_VITEST_MARKER_RE = re.compile(r"^\s*(?:RUN\s+v\d+\.\d+|Test Files\s+\d)", re.MULTILINE)
+_VITEST_TEST_RE = re.compile(
+    r"^\s*(?P<glyph>[✓×↓□]) (?:\|(?P<project>[^|]+)\| | (?P<label>\S+)  )?"
+    r"(?P<name>\S+ > .+?)(?P<duration> \d{1,9}ms)?"
+    r"(?: \(retry x\d{1,9}\))?(?: \(repeat x\d{1,9}\))?(?: \d{1,9} MB heap used)?(?: \[[^\[\]]*\])?$"
+)
+_VITEST_STATUS = {"✓": PASSED, "×": FAILED, "↓": SKIPPED, "□": SKIPPED}
+
+
+def _parse_vitest(log: str) -> dict[str, str]:
+    """{test_name -> status} from vitest `--reporter=verbose` lines only."""
+    out: dict[str, str] = {}
+    for raw in log.split("\n"):
+        m = _VITEST_TEST_RE.match(raw.rstrip())
+        if not m:
+            continue
+        glyph, name = m.group("glyph"), m.group("name")
+        if glyph in "↓□" and m.group("duration"):
+            name += m.group("duration")
+        project = m.group("project") or m.group("label")
+        out[f"|{project}| {name}" if project else name] = _VITEST_STATUS[glyph]
+    return out
 
 
 def parse_jest(log: str) -> dict[str, str]:
@@ -193,6 +217,9 @@ def parse_jest(log: str) -> dict[str, str]:
     out: dict[str, str] = {}
     if not log:
         return out
+    log = _ANSI_RE.sub("", log)
+    if _VITEST_MARKER_RE.search(log):
+        return _parse_vitest(log)
     current_file: str | None = None
     describe_stack: list[tuple[int, str]] = []
     last_test_indent: int | None = None
diff --git a/src/repo2rlenv/pipelines/pr_runtime.py b/src/repo2rlenv/pipelines/pr_runtime.py
index 2ae22637..4b5637c8 100644
--- a/src/repo2rlenv/pipelines/pr_runtime.py
+++ b/src/repo2rlenv/pipelines/pr_runtime.py
@@ -629,9 +629,12 @@ def normalize_test_cmds_for_runtime(test_cmds: list[str]) -> list[str]:
         - Add `-v` if missing (default `go test` doesn't print --- PASS lines)
       cargo test:
         - Default output is already parseable; no transform needed
-      jest / npm test:
+      jest / mocha / npm test:
         - Add `--verbose` if not present, so per-test ✓/✕ lines are emitted
         - Some configs swallow stdout via `--silent`; we strip that
+      vitest:
+        - Use `--reporter=verbose` instead: vitest rejects `--verbose`, and its
+          default reporter collapses fully passing files to one summary line
     """
     out: list[str] = []
     for cmd in test_cmds:
@@ -674,9 +677,14 @@ def normalize_test_cmds_for_runtime(test_cmds: list[str]) -> list[str]:
         # --- jest / npm test / yarn test / pnpm test ---
         elif re.search(r"\b(?:jest|mocha|vitest|npm\s+test|yarn\s+test|pnpm\s+test)\b", cleaned):
             cleaned = re.sub(r"\s+--silent\b", "", cleaned)
-            # Add --verbose if the cmd is the runner itself (skip wrappers
-            # where flags need to go after `--`)
-            if re.search(r"\b(?:jest|mocha|vitest)\b", cleaned) and not re.search(
+            # Add a per-test reporter if the cmd is the runner itself (skip
+            # wrappers where flags need to go after `--`)
+            if re.search(r"\bvitest\b", cleaned):
+                # `vitest --verbose` exits with `CACError: Unknown option`.
+                cleaned = re.sub(r"\s+--verbose\b", "", cleaned)
+                if not re.search(r"\s--reporter\b", cleaned):
+                    cleaned = cleaned.rstrip() + " --reporter=verbose"
+            elif re.search(r"\b(?:jest|mocha)\b", cleaned) and not re.search(
                 r"\s--verbose\b|\s--reporter\b", cleaned
             ):
                 cleaned = cleaned.rstrip() + " --verbose"
diff --git a/tests/test_pipeline_pr_runtime.py b/tests/test_pipeline_pr_runtime.py
index 10ec7311..7fceb822 100644
--- a/tests/test_pipeline_pr_runtime.py
+++ b/tests/test_pipeline_pr_runtime.py
@@ -529,6 +529,21 @@ def test_normalize_jest_adds_verbose_and_strips_silent():
     assert normalize_test_cmds_for_runtime(["jest --verbose"]) == ["jest --verbose"]
 
 
+def test_normalize_vitest_uses_verbose_reporter():
+    # `vitest --verbose` exits with `CACError: Unknown option`.
+    assert normalize_test_cmds_for_runtime(["npx vitest run"]) == [
+        "npx vitest run --reporter=verbose"
+    ]
+    assert normalize_test_cmds_for_runtime(["npx vitest run --verbose --silent"]) == [
+        "npx vitest run --reporter=verbose"
+    ]
+    # An explicit reporter is the repo's choice ⇒ keep
+    assert normalize_test_cmds_for_runtime(["vitest run --reporter=junit"]) == [
+        "vitest run --reporter=junit"
+    ]
+    assert normalize_test_cmds_for_runtime(["npx mocha"]) == ["npx mocha --verbose"]
+
+
 def test_normalize_strips_trailing_pipe_head_or_tail():
     """Bootstrap agents sometimes save commands with a `| head -N` tail truncator.
 
diff --git a/tests/test_vitest_output.py b/tests/test_vitest_output.py
new file mode 100644
index 00000000..18045e3d
--- /dev/null
+++ b/tests/test_vitest_output.py
@@ -0,0 +1,400 @@
+"""Vitest runs must survive generation-time and standalone parsing."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+from repo2rlenv.log_parsers.jest_parser import parse_jest
+from repo2rlenv.pipelines import _pr_runtime_verifier as verifier
+
+
+@pytest.fixture(params=[parse_jest, verifier.parse_jest], ids=["canonical", "standalone"])
+def parser(request):
+    return request.param
+
+
+# Real `npx vitest run --reporter=verbose` output (vitest 5.0.1, colored because
+# TERM is unset) for a fix to `div`: before it, with the gold patch, and with an
+# agent patch that also fixes the unrelated `rounds half up` test.
+_BASE = (
+    "\n"
+    "\x1b[1m\x1b[30m\x1b[46m RUN \x1b[49m\x1b[39m\x1b[22m \x1b[36mv5.0.1 \x1b[39m\x1b[90m/repo\x1b[39m\n"
+    "\n"
+    " \x1b[32m✓\x1b[39m math.test.ts\x1b[2m > \x1b[22mmath\x1b[2m > \x1b[22madds\x1b[32m 1\x1b[2mms\x1b[22m\x1b[39m\n"
+    " \x1b[31m×\x1b[39m math.test.ts\x1b[2m > \x1b[22mmath\x1b[2m > \x1b[22mrejects division by zero\x1b[32m 3\x1b[2mms\x1b[22m\x1b[39m\n"
+    "\x1b[31m   → expected [Function] to throw an error\x1b[39m\n"
+    " \x1b[31m×\x1b[39m math.test.ts\x1b[2m > \x1b[22mmath\x1b[2m > \x1b[22mrounds half up\x1b[32m 1\x1b[2mms\x1b[22m\x1b[39m\n"
+    "\x1b[31m   → expected 2 to be 3 // Object.is equality\x1b[39m\n"
+    "\n"
+    "\x1b[31m⎯⎯⎯⎯⎯⎯⎯\x1b[39m\x1b[1m\x1b[41m Failed Tests 2 \x1b[49m\x1b[22m\x1b[31m⎯⎯⎯⎯⎯⎯⎯\x1b[39m\n"
+    "\n"
+    "\x1b[41m\x1b[1m FAIL \x1b[22m\x1b[49m math.test.ts\x1b[2m > \x1b[22mmath\x1b[2m > \x1b[22mrejects division by zero\n"
+    "\x1b[31m\x1b[1mAssertionError\x1b[22m: expected [Function] to throw an error\x1b[39m\n"
+    "\n"
+    "\x1b[32m- Expected:\x1b[39m\n"
+    "null\n"
+    "\n"
+    "\x1b[31m+ Received:\x1b[39m\n"
+    "undefined\n"
+    "\n"
+    "\x1b[36m \x1b[2m❯\x1b[22m math.test.ts:\x1b[2m5:66\x1b[22m\x1b[39m\n"
+    '    \x1b[90m  3|\x1b[39m describe("math", () => {\n'
+    '    \x1b[90m  4|\x1b[39m   it("adds", () => { expect(add(1, 2)).toBe(3); });\n'
+    '    \x1b[90m  5|\x1b[39m   it("rejects division by zero", () => { expect(() => div(1, 0)).toThr…\n'
+    "    \x1b[90m   |\x1b[39m                                                                  \x1b[31m^\x1b[39m\n"
+    '    \x1b[90m  6|\x1b[39m   it("rounds half up", () => { expect(round(2.5)).toBe(3); });\n'
+    "    \x1b[90m  7|\x1b[39m });\n"
+    "\n"
+    "\x1b[31m\x1b[2m⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[1/2]⎯\x1b[22m\x1b[39m\n"
+    "\n"
+    "\x1b[41m\x1b[1m FAIL \x1b[22m\x1b[49m math.test.ts\x1b[2m > \x1b[22mmath\x1b[2m > \x1b[22mrounds half up\n"
+    "\x1b[31m\x1b[1mAssertionError\x1b[22m: expected 2 to be 3 // Object.is equality\x1b[39m\n"
+    "\n"
+    "\x1b[32m- Expected\x1b[39m\n"
+    "\x1b[31m+ Received\x1b[39m\n"
+    "\n"
+    "\x1b[32m- 3\x1b[39m\n"
+    "\x1b[31m+ 2\x1b[39m\n"
+    "\n"
+    "\x1b[36m \x1b[2m❯\x1b[22m math.test.ts:\x1b[2m6:51\x1b[22m\x1b[39m\n"
+    '    \x1b[90m  4|\x1b[39m   it("adds", () => { expect(add(1, 2)).toBe(3); });\n'
+    '    \x1b[90m  5|\x1b[39m   it("rejects division by zero", () => { expect(() => div(1, 0)).toThr…\n'
+    '    \x1b[90m  6|\x1b[39m   it("rounds half up", () => { expect(round(2.5)).toBe(3); });\n'
+    "    \x1b[90m   |\x1b[39m                                                   \x1b[31m^\x1b[39m\n"
+    "    \x1b[90m  7|\x1b[39m });\n"
+    "    \x1b[90m  8|\x1b[39m\n"
+    "\n"
+    "\x1b[31m\x1b[2m⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[2/2]⎯\x1b[22m\x1b[39m\n"
+    "\n"
+    "\n"
+    "\x1b[2m Test Files \x1b[22m \x1b[1m\x1b[31m1 failed\x1b[39m\x1b[22m\x1b[90m (1)\x1b[39m\n"
+    "\x1b[2m      Tests \x1b[22m \x1b[1m\x1b[31m2 failed\x1b[39m\x1b[22m\x1b[2m | \x1b[22m\x1b[1m\x1b[32m1 passed\x1b[39m\x1b[22m\x1b[90m (3)\x1b[39m\n"
+    "\x1b[2m   Start at \x1b[22m 01:51:08\n"
+    "\x1b[2m   Duration \x1b[22m 119ms\x1b[2m (transform 59%, import 18%, tests 15%, worker 7%)\x1b[22m\n"
+    "\n"
+)
+
+_GOLD = (
+    "\n"
+    "\x1b[1m\x1b[30m\x1b[46m RUN \x1b[49m\x1b[39m\x1b[22m \x1b[36mv5.0.1 \x1b[39m\x1b[90m/repo\x1b[39m\n"
+    "\n"
+    " \x1b[32m✓\x1b[39m math.test.ts\x1b[2m > \x1b[22mmath\x1b[2m > \x1b[22madds\x1b[32m 1\x1b[2mms\x1b[22m\x1b[39m\n"
+    " \x1b[32m✓\x1b[39m math.test.ts\x1b[2m > \x1b[22mmath\x1b[2m > \x1b[22mrejects division by zero\x1b[32m 0\x1b[2mms\x1b[22m\x1b[39m\n"
+    " \x1b[31m×\x1b[39m math.test.ts\x1b[2m > \x1b[22mmath\x1b[2m > \x1b[22mrounds half up\x1b[32m 3\x1b[2mms\x1b[22m\x1b[39m\n"
+    "\x1b[31m   → expected 2 to be 3 // Object.is equality\x1b[39m\n"
+    "\n"
+    "\x1b[31m⎯⎯⎯⎯⎯⎯⎯\x1b[39m\x1b[1m\x1b[41m Failed Tests 1 \x1b[49m\x1b[22m\x1b[31m⎯⎯⎯⎯⎯⎯⎯\x1b[39m\n"
+    "\n"
+    "\x1b[41m\x1b[1m FAIL \x1b[22m\x1b[49m math.test.ts\x1b[2m > \x1b[22mmath\x1b[2m > \x1b[22mrounds half up\n"
+    "\x1b[31m\x1b[1mAssertionError\x1b[22m: expected 2 to be 3 // Object.is equality\x1b[39m\n"
+    "\n"
+    "\x1b[32m- Expected\x1b[39m\n"
+    "\x1b[31m+ Received\x1b[39m\n"
+    "\n"
+    "\x1b[32m- 3\x1b[39m\n"
+    "\x1b[31m+ 2\x1b[39m\n"
+    "\n"
+    "\x1b[36m \x1b[2m❯\x1b[22m math.test.ts:\x1b[2m6:51\x1b[22m\x1b[39m\n"
+    '    \x1b[90m  4|\x1b[39m   it("adds", () => { expect(add(1, 2)).toBe(3); });\n'
+    '    \x1b[90m  5|\x1b[39m   it("rejects division by zero", () => { expect(() => div(1, 0)).toThr…\n'
+    '    \x1b[90m  6|\x1b[39m   it("rounds half up", () => { expect(round(2.5)).toBe(3); });\n'
+    "    \x1b[90m   |\x1b[39m                                                   \x1b[31m^\x1b[39m\n"
+    "    \x1b[90m  7|\x1b[39m });\n"
+    "    \x1b[90m  8|\x1b[39m\n"
+    "\n"
+    "\x1b[31m\x1b[2m⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[1/1]⎯\x1b[22m\x1b[39m\n"
+    "\n"
+    "\n"
+    "\x1b[2m Test Files \x1b[22m \x1b[1m\x1b[31m1 failed\x1b[39m\x1b[22m\x1b[90m (1)\x1b[39m\n"
+    "\x1b[2m      Tests \x1b[22m \x1b[1m\x1b[31m1 failed\x1b[39m\x1b[22m\x1b[2m | \x1b[22m\x1b[1m\x1b[32m2 passed\x1b[39m\x1b[22m\x1b[90m (3)\x1b[39m\n"
+    "\x1b[2m   Start at \x1b[22m 01:51:10\n"
+    "\x1b[2m   Duration \x1b[22m 95ms\x1b[2m (transform 50%, import 22%, tests 20%, worker 8%)\x1b[22m\n"
+    "\n"
+)
+
+_AGENT = (
+    "\n"
+    "\x1b[1m\x1b[30m\x1b[46m RUN \x1b[49m\x1b[39m\x1b[22m \x1b[36mv5.0.1 \x1b[39m\x1b[90m/repo\x1b[39m\n"
+    "\n"
+    " \x1b[32m✓\x1b[39m math.test.ts\x1b[2m > \x1b[22mmath\x1b[2m > \x1b[22madds\x1b[32m 1\x1b[2mms\x1b[22m\x1b[39m\n"
+    " \x1b[32m✓\x1b[39m math.test.ts\x1b[2m > \x1b[22mmath\x1b[2m > \x1b[22mrejects division by zero\x1b[32m 0\x1b[2mms\x1b[22m\x1b[39m\n"
+    " \x1b[32m✓\x1b[39m math.test.ts\x1b[2m > \x1b[22mmath\x1b[2m > \x1b[22mrounds half up\x1b[32m 0\x1b[2mms\x1b[22m\x1b[39m\n"
+    "\n"
+    "\x1b[2m Test Files \x1b[22m \x1b[1m\x1b[32m1 passed\x1b[39m\x1b[22m\x1b[90m (1)\x1b[39m\n"
+    "\x1b[2m      Tests \x1b[22m \x1b[1m\x1b[32m3 passed\x1b[39m\x1b[22m\x1b[90m (3)\x1b[39m\n"
+    "\x1b[2m   Start at \x1b[22m 01:51:11\n"
+    "\x1b[2m   Duration \x1b[22m 87ms\x1b[2m (transform 56%, import 25%, tests 9%, worker 9%)\x1b[22m\n"
+    "\n"
+)
+
+# The same gold run through vitest's default reporter.
+_GOLD_DEFAULT = (
+    "\n"
+    "\x1b[1m\x1b[30m\x1b[46m RUN \x1b[49m\x1b[39m\x1b[22m \x1b[36mv5.0.1 \x1b[39m\x1b[90m/repo\x1b[39m\n"
+    "\n"
+    " \x1b[31m❯\x1b[39m math.test.ts \x1b[2m(\x1b[22m\x1b[2m3 tests\x1b[22m\x1b[2m | \x1b[22m\x1b[31m1 failed\x1b[39m\x1b[2m)\x1b[22m\x1b[32m 5\x1b[2mms\x1b[22m\x1b[39m\n"
+    "   \x1b[31m❯\x1b[39m math \x1b[2m(3)\x1b[22m\n"
+    "     \x1b[32m✓\x1b[39m adds\x1b[32m 1\x1b[2mms\x1b[22m\x1b[39m\n"
+    "     \x1b[32m✓\x1b[39m rejects division by zero\x1b[32m 0\x1b[2mms\x1b[22m\x1b[39m\n"
+    "\x1b[31m     \x1b[31m×\x1b[31m rounds half up\x1b[39m\x1b[32m 3\x1b[2mms\x1b[22m\x1b[39m\n"
+    "\n"
+    "\x1b[31m⎯⎯⎯⎯⎯⎯⎯\x1b[39m\x1b[1m\x1b[41m Failed Tests 1 \x1b[49m\x1b[22m\x1b[31m⎯⎯⎯⎯⎯⎯⎯\x1b[39m\n"
+    "\n"
+    "\x1b[41m\x1b[1m FAIL \x1b[22m\x1b[49m math.test.ts\x1b[2m > \x1b[22mmath\x1b[2m > \x1b[22mrounds half up\n"
+    "\x1b[31m\x1b[1mAssertionError\x1b[22m: expected 2 to be 3 // Object.is equality\x1b[39m\n"
+    "\n"
+    "\x1b[32m- Expected\x1b[39m\n"
+    "\x1b[31m+ Received\x1b[39m\n"
+    "\n"
+    "\x1b[32m- 3\x1b[39m\n"
+    "\x1b[31m+ 2\x1b[39m\n"
+    "\n"
+    "\x1b[36m \x1b[2m❯\x1b[22m math.test.ts:\x1b[2m6:51\x1b[22m\x1b[39m\n"
+    '    \x1b[90m  4|\x1b[39m   it("adds", () => { expect(add(1, 2)).toBe(3); });\n'
+    '    \x1b[90m  5|\x1b[39m   it("rejects division by zero", () => { expect(() => div(1, 0)).toThr…\n'
+    '    \x1b[90m  6|\x1b[39m   it("rounds half up", () => { expect(round(2.5)).toBe(3); });\n'
+    "    \x1b[90m   |\x1b[39m                                                   \x1b[31m^\x1b[39m\n"
+    "    \x1b[90m  7|\x1b[39m });\n"
+    "    \x1b[90m  8|\x1b[39m\n"
+    "\n"
+    "\x1b[31m\x1b[2m⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[1/1]⎯\x1b[22m\x1b[39m\n"
+    "\n"
+    "\n"
+    "\x1b[2m Test Files \x1b[22m \x1b[1m\x1b[31m1 failed\x1b[39m\x1b[22m\x1b[90m (1)\x1b[39m\n"
+    "\x1b[2m      Tests \x1b[22m \x1b[1m\x1b[31m1 failed\x1b[39m\x1b[22m\x1b[2m | \x1b[22m\x1b[1m\x1b[32m2 passed\x1b[39m\x1b[22m\x1b[90m (3)\x1b[39m\n"
+    "\x1b[2m   Start at \x1b[22m 01:51:10\n"
+    "\x1b[2m   Duration \x1b[22m 95ms\x1b[2m (transform 50%, import 22%, tests 20%, worker 8%)\x1b[22m\n"
+    "\n"
+)
+
+# Test lines of a vitest 5.0.1 run with two projects, with and without color.
+_PROJECTS_COLOR = (
+    "\x1b[1m\x1b[30m\x1b[46m RUN \x1b[49m\x1b[39m\x1b[22m \x1b[36mv5.0.1 \x1b[39m\x1b[90m/repo\x1b[39m\n"
+    " \x1b[32m✓\x1b[39m \x1b[30m\x1b[42m unit \x1b[49m\x1b[39m vt/other.test.ts\x1b[2m > \x1b[22mstandalone passes\x1b[32m 1\x1b[2mms\x1b[22m\x1b[39m\n"
+    " \x1b[32m✓\x1b[39m \x1b[30m\x1b[43m node \x1b[49m\x1b[39m vt/other.test.ts\x1b[2m > \x1b[22mstandalone passes\x1b[32m 1\x1b[2mms\x1b[22m\x1b[39m\n"
+    " \x1b[32m✓\x1b[39m \x1b[30m\x1b[42m unit \x1b[49m\x1b[39m vt/math.test.ts\x1b[2m > \x1b[22mMath\x1b[2m > \x1b[22madd()\x1b[2m > \x1b[22madds two numbers\x1b[32m 2\x1b[2mms\x1b[22m\x1b[39m\n"
+    " \x1b[32m✓\x1b[39m \x1b[30m\x1b[42m unit \x1b[49m\x1b[39m vt/math.test.ts\x1b[2m > \x1b[22mMath\x1b[2m > \x1b[22madd()\x1b[2m > \x1b[22mhandles negatives (edge case)\x1b[32m 0\x1b[2mms\x1b[22m\x1b[39m\n"
+    " \x1b[31m×\x1b[39m \x1b[30m\x1b[42m unit \x1b[49m\x1b[39m vt/math.test.ts\x1b[2m > \x1b[22mMath\x1b[2m > \x1b[22madd()\x1b[2m > \x1b[22mbreaks on purpose\x1b[32m 4\x1b[2mms\x1b[22m\x1b[39m\n"
+    " \x1b[2m\x1b[90m↓\x1b[39m\x1b[22m \x1b[30m\x1b[42m unit \x1b[49m\x1b[39m vt/math.test.ts\x1b[2m > \x1b[22mMath\x1b[2m > \x1b[22madd()\x1b[2m > \x1b[22mskipped test\n"
+    " \x1b[2m\x1b[90m□\x1b[39m\x1b[22m \x1b[30m\x1b[42m unit \x1b[49m\x1b[39m vt/math.test.ts\x1b[2m > \x1b[22mMath\x1b[2m > \x1b[22madd()\x1b[2m > \x1b[22mtodo test\n"
+    " \x1b[32m✓\x1b[39m \x1b[30m\x1b[42m unit \x1b[49m\x1b[39m vt/math.test.ts\x1b[2m > \x1b[22mMath\x1b[2m > \x1b[22mis slow\x1b[33m 352\x1b[2mms\x1b[22m\x1b[39m\n"
+    " \x1b[32m✓\x1b[39m \x1b[30m\x1b[42m unit \x1b[49m\x1b[39m vt/math.test.ts\x1b[2m > \x1b[22mTop level\x1b[2m > \x1b[22mreturns 200 (OK)\x1b[32m 0\x1b[2mms\x1b[22m\x1b[39m\n"
+    "\x1b[2m Test Files \x1b[22m \x1b[1m\x1b[31m1 failed\x1b[39m\x1b[22m\x1b[2m | \x1b[22m\x1b[1m\x1b[32m2 passed\x1b[39m\x1b[22m\x1b[90m (3)\x1b[39m\n"
+)
+
+_PROJECTS_PLAIN = (
+    " RUN  v5.0.1 /repo\n"
+    " ✓ |unit| vt/other.test.ts > standalone passes 1ms\n"
+    " ✓ |node| vt/other.test.ts > standalone passes 1ms\n"
+    " ✓ |unit| vt/math.test.ts > Math > add() > adds two numbers 1ms\n"
+    " ✓ |unit| vt/math.test.ts > Math > add() > handles negatives (edge case) 0ms\n"
+    " × |unit| vt/math.test.ts > Math > add() > breaks on purpose 3ms\n"
+    " ↓ |unit| vt/math.test.ts > Math > add() > skipped test\n"
+    " □ |unit| vt/math.test.ts > Math > add() > todo test\n"
+    " ✓ |unit| vt/math.test.ts > Math > is slow 352ms\n"
+    " ✓ |unit| vt/math.test.ts > Top level > returns 200 (OK) 0ms\n"
+    " Test Files  1 failed | 2 passed (3)\n"
+)
+
+# Test lines of vitest 3.2.7, which marks todo tests with ↓.
+_V3_PLAIN = (
+    " RUN  v3.2.7 /repo\n"
+    " ✓ other.test.ts > standalone passes 1ms\n"
+    " ✓ math.test.ts > Math > add() > adds two numbers 1ms\n"
+    " ✓ math.test.ts > Math > add() > handles negatives (edge case) 0ms\n"
+    " × math.test.ts > Math > add() > breaks on purpose 3ms\n"
+    " ↓ math.test.ts > Math > add() > skipped test\n"
+    " ↓ math.test.ts > Math > add() > todo test\n"
+    " ✓ math.test.ts > Math > is slow 351ms\n"
+    " ✓ math.test.ts > Top level > returns 200 (OK) 0ms\n"
+    " Test Files  1 failed | 1 passed (2)\n"
+)
+
+# Real `npx jest --verbose` output (jest 30.5.0) with FORCE_COLOR=1.
+_JEST_COLOR = (
+    "\x1b[0m\x1b[7m\x1b[1m\x1b[31m FAIL \x1b[39m\x1b[22m\x1b[27m\x1b[0m \x1b[2mjt/\x1b[22m\x1b[1mmath.test.js\x1b[22m\n"
+    "  Math\n"
+    "    add()\n"
+    "      \x1b[32m✓\x1b[39m \x1b[2madds two numbers (1 ms)\x1b[22m\n"
+    "      \x1b[32m✓\x1b[39m \x1b[2mhandles negatives (edge case) (1 ms)\x1b[22m\n"
+    "      \x1b[31m✕\x1b[39m \x1b[2mbreaks on purpose (1 ms)\x1b[22m\n"
+    "      \x1b[33m○\x1b[39m \x1b[2mskipped skipped test\x1b[22m\n"
+    "      \x1b[35m✎\x1b[39m \x1b[2mtodo todo test\x1b[22m\n"
+    "  Top level\n"
+    "    \x1b[32m✓\x1b[39m \x1b[2mreturns 200 (OK)\x1b[22m\n"
+    "\n"
+    "\x1b[1m\x1b[31m  \x1b[1m● \x1b[22m\x1b[1mMath › add() › breaks on purpose\x1b[39m\x1b[22m\n"
+    "\n"
+    "    \x1b[2mexpect(\x1b[22m\x1b[31mreceived\x1b[39m\x1b[2m).\x1b[22mtoBe\x1b[2m(\x1b[22m\x1b[32mexpected\x1b[39m\x1b[2m) // Object.is equality\x1b[22m\n"
+    "\n"
+    "    Expected: \x1b[32m3\x1b[39m\n"
+    "    Received: \x1b[31m2\x1b[39m\n"
+    "\n"
+    '\x1b[2m    \x1b[0m \x1b[90m 3 |\x1b[39m     it(\x1b[32m"adds two numbers"\x1b[39m\x1b[33m,\x1b[39m () \x1b[33m=>\x1b[39m { expect(\x1b[35m1\x1b[39m \x1b[33m+\x1b[39m \x1b[35m1\x1b[39m)\x1b[33m.\x1b[39mtoBe(\x1b[35m2\x1b[39m)\x1b[33m;\x1b[39m })\x1b[33m;\x1b[39m\x1b[22m\n'
+    '\x1b[2m     \x1b[90m 4 |\x1b[39m     it(\x1b[32m"handles negatives (edge case)"\x1b[39m\x1b[33m,\x1b[39m () \x1b[33m=>\x1b[39m { expect(\x1b[33m-\x1b[39m\x1b[35m1\x1b[39m \x1b[33m+\x1b[39m \x1b[33m-\x1b[39m\x1b[35m1\x1b[39m)\x1b[33m.\x1b[39mtoBe(\x1b[33m-\x1b[39m\x1b[35m2\x1b[39m)\x1b[33m;\x1b[39m })\x1b[33m;\x1b[39m\x1b[22m\n'
+    '\x1b[2m    \x1b[31m\x1b[1m>\x1b[22m\x1b[2m\x1b[39m\x1b[90m 5 |\x1b[39m     it(\x1b[32m"breaks on purpose"\x1b[39m\x1b[33m,\x1b[39m () \x1b[33m=>\x1b[39m { expect(\x1b[35m1\x1b[39m \x1b[33m+\x1b[39m \x1b[35m1\x1b[39m)\x1b[33m.\x1b[39mtoBe(\x1b[35m3\x1b[39m)\x1b[33m;\x1b[39m })\x1b[33m;\x1b[39m\x1b[22m\n'
+    "\x1b[2m     \x1b[90m   |\x1b[39m                                                   \x1b[31m\x1b[1m^\x1b[22m\x1b[2m\x1b[39m\x1b[22m\n"
+    '\x1b[2m     \x1b[90m 6 |\x1b[39m     it\x1b[33m.\x1b[39mskip(\x1b[32m"skipped test"\x1b[39m\x1b[33m,\x1b[39m () \x1b[33m=>\x1b[39m {})\x1b[33m;\x1b[39m\x1b[22m\n'
+    '\x1b[2m     \x1b[90m 7 |\x1b[39m     it\x1b[33m.\x1b[39mtodo(\x1b[32m"todo test"\x1b[39m)\x1b[33m;\x1b[39m\x1b[22m\n'
+    "\x1b[2m     \x1b[90m 8 |\x1b[39m   })\x1b[33m;\x1b[39m\x1b[0m\x1b[22m\n"
+    "\n"
+    "\x1b[2m      \x1b[2mat Object.toBe (\x1b[22m\x1b[2m\x1b[0m\x1b[36mmath.test.js\x1b[39m\x1b[0m\x1b[2m:5:51)\x1b[22m\x1b[2m\x1b[22m\n"
+    "\n"
+    "\x1b[0m\x1b[7m\x1b[1m\x1b[32m PASS \x1b[39m\x1b[22m\x1b[27m\x1b[0m \x1b[2mjt/\x1b[22m\x1b[1mother.test.js\x1b[22m\n"
+    "  \x1b[32m✓\x1b[39m \x1b[2mstandalone passes\x1b[22m\n"
+    "\n"
+    "\x1b[1mTest Suites: \x1b[22m\x1b[1m\x1b[31m1 failed\x1b[39m\x1b[22m, \x1b[1m\x1b[32m1 passed\x1b[39m\x1b[22m, 2 total\n"
+    "\x1b[1mTests:       \x1b[22m\x1b[1m\x1b[31m1 failed\x1b[39m\x1b[22m, \x1b[1m\x1b[33m1 skipped\x1b[39m\x1b[22m, \x1b[1m\x1b[35m1 todo\x1b[39m\x1b[22m, \x1b[1m\x1b[32m4 passed\x1b[39m\x1b[22m, 7 total\n"
+    "\x1b[1mSnapshots:   \x1b[22m0 total\n"
+    "\x1b[1mTime:\x1b[22m        0.214 s, estimated 1 s\n"
+    "\x1b[2mRan all test suites\x1b[22m\x1b[2m.\x1b[22m\n"
+)
+
+
+def test_colored_verbose_runs_keep_every_test(parser):
+    assert parser(_BASE) == {
+        "math.test.ts > math > adds": "PASSED",
+        "math.test.ts > math > rejects division by zero": "FAILED",
+        "math.test.ts > math > rounds half up": "FAILED",
+    }
+    assert parser(_AGENT) == {
+        "math.test.ts > math > adds": "PASSED",
+        "math.test.ts > math > rejects division by zero": "PASSED",
+        "math.test.ts > math > rounds half up": "PASSED",
+    }
+
+
+def test_project_names_are_part_of_the_identity_with_or_without_color(parser):
+    expected = {
+        "|unit| vt/other.test.ts > standalone passes": "PASSED",
+        "|node| vt/other.test.ts > standalone passes": "PASSED",
+        "|unit| vt/math.test.ts > Math > add() > adds two numbers": "PASSED",
+        "|unit| vt/math.test.ts > Math > add() > handles negatives (edge case)": "PASSED",
+        "|unit| vt/math.test.ts > Math > add() > breaks on purpose": "FAILED",
+        "|unit| vt/math.test.ts > Math > add() > skipped test": "SKIPPED",
+        "|unit| vt/math.test.ts > Math > add() > todo test": "SKIPPED",
+        "|unit| vt/math.test.ts > Math > is slow": "PASSED",
+        "|unit| vt/math.test.ts > Top level > returns 200 (OK)": "PASSED",
+    }
+    assert parser(_PROJECTS_COLOR) == parser(_PROJECTS_PLAIN) == expected
+
+
+def test_vitest_3_verbose_format(parser):
+    status = parser(_V3_PLAIN)
+    assert status["math.test.ts > Math > add() > breaks on purpose"] == "FAILED"
+    assert status["math.test.ts > Math > add() > todo test"] == "SKIPPED"
+    assert status["math.test.ts > Top level > returns 200 (OK)"] == "PASSED"
+    assert len(status) == 8
+
+
+@pytest.mark.parametrize(
+    "suffix",
+    [
+        " 12ms",
+        " 0ms (retry x2)",
+        " 12ms (repeat x3)",
+        " 12ms (retry x1) (repeat x2) 30 MB heap used",
+    ],
+)
+def test_run_suffixes_are_not_part_of_the_name(parser, suffix):
+    log = f" RUN  v5.0.1 /repo\n ✓ src/a.test.ts > waits 5ms{suffix}\n"
+    assert parser(log) == {"src/a.test.ts > waits 5ms": "PASSED"}
+
+
+def test_skipped_tests_keep_their_title_and_drop_the_note(parser):
+    log = " RUN  v5.0.1 /repo\n ↓ src/a.test.ts > waits 5ms\n □ src/a.test.ts > later [not ready]\n"
+    assert parser(log) == {
+        "src/a.test.ts > waits 5ms": "SKIPPED",
+        "src/a.test.ts > later": "SKIPPED",
+    }
+
+
+def test_default_reporter_lines_are_not_recorded(parser):
+    # Once a patch fixes the rest of a file, the default reporter collapses it
+    # to `✓ math.test.ts (3 tests)`, so its per-test lines can't be graded.
+    assert parser(_GOLD_DEFAULT) == {}
+
+
+def test_colored_jest_output_matches_plain_jest(parser):
+    assert parser(_JEST_COLOR) == {
+        "jt/other.test.js > standalone passes": "PASSED",
+        "jt/math.test.js > Math > add() > adds two numbers": "PASSED",
+        "jt/math.test.js > Math > add() > handles negatives (edge case)": "PASSED",
+        "jt/math.test.js > Math > add() > breaks on purpose": "FAILED",
+        "jt/math.test.js > Math > add() > skipped skipped test": "SKIPPED",
+        "jt/math.test.js > Top level > returns 200 (OK)": "PASSED",
+    }
+
+
+def test_long_lines_do_not_stall_parsing():
+    # Isolate the timeout so a backtracking regression cannot hang the suite.
+    result = subprocess.run(
+        [
+            sys.executable,
+            "-c",
+            "from repo2rlenv.log_parsers.jest_parser import parse_jest\n"
+            "from repo2rlenv.pipelines._pr_runtime_verifier import parse_jest as standalone\n"
+            "noise = [' ✓ a > b' + ' [' * 100000, ' ✓ a > b' + ' 1' * 100000,\n"
+            "         ' ✓ a > ' + ' (retry x1)' * 20000 + 'x', ' ✓ ' + 'a > ' * 50000 + 'x',\n"
+            "         ' ✓ a > ' + ' 1 MB heap used' * 20000 + 'x', '\\x1b[' * 100000]\n"
+            "log = ' RUN  v5.0.1 /repo\\n' + '\\n'.join(noise) + '\\n ✓ a.test.ts > b 1ms\\n'\n"
+            "for parser in (parse_jest, standalone):\n"
+            "    assert parser(log)['a.test.ts > b'] == 'PASSED'\n",
+        ],
+        capture_output=True,
+        text=True,
+        timeout=10,
+    )
+    assert result.returncode == 0, result.stdout + result.stderr
+
+
+def test_vitest_fix_grades_through_the_standalone_verifier(tmp_path: Path):
+    pre, gold = parse_jest(_BASE), parse_jest(_GOLD)
+    f2p = [
+        name for name, status in pre.items() if status == "FAILED" and gold.get(name) == "PASSED"
+    ]
+    p2p = [
+        name for name, status in pre.items() if status == "PASSED" and gold.get(name) == "PASSED"
+    ]
+    assert f2p == ["math.test.ts > math > rejects division by zero"]
+    assert p2p == ["math.test.ts > math > adds"]
+
+    # Run the verifier in isolation, with no installed repo2rlenv imports.
+    standalone = tmp_path / "verifier.py"
+    standalone.write_text(Path(verifier.__file__).read_text(encoding="utf-8"), encoding="utf-8")
+    (tmp_path / "out.log").write_text(_AGENT, encoding="utf-8")
+    (tmp_path / "f2p.json").write_text(json.dumps(f2p), encoding="utf-8")
+    (tmp_path / "p2p.json").write_text(json.dumps(p2p), encoding="utf-8")
+    result = subprocess.run(
+        [
+            sys.executable,
+            "-I",
+            str(standalone),
+            "--log",
+            "out.log",
+            "--f2p",
+            "f2p.json",
+            "--p2p",
+            "p2p.json",
+            "--test-cmds",
+            "npx vitest run --reporter=verbose",
+            "--exit-code",
+            "0",
+            "--out-dir",
+            "rewards",
+        ],
+        cwd=tmp_path,
+        capture_output=True,
+        text=True,
+        timeout=30,
+    )
+    assert result.returncode == 0, result.stdout + result.stderr
+    details = json.loads((tmp_path / "rewards/reward-details.json").read_text())
+    assert details["runner"] == "jest"
+    assert details["reward"] == 1.0
+    assert details["resolved"] is True