release v1: 65 held-out tasks, 78 bootstrap records, r2e_local adapter, manifest ae94c40b (part 5)

heldout_pool/codereverser__casparser-ede19d2e304e/tests/test.sh

@@ -0,0 +1,82 @@
+#!/bin/bash
+set -uxo pipefail
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+cd /workspace
+git config --global --add safe.directory /workspace
+mkdir -p /logs/verifier
+git checkout 31b743b0e8ba5b6188cbdcc86eeb56a16afd4c77 -- tests/test_demat_units.py || true
+git apply --verbose --reject - <<'EOF_R2E_TEST_PATCH'
+diff --git a/tests/test_demat_units.py b/tests/test_demat_units.py
+index 9512c48..d9ef327 100644
+--- a/tests/test_demat_units.py
++++ b/tests/test_demat_units.py
+@@ -1408,3 +1408,54 @@ class TestNPS:
+             _block(_cell("INE000A01001", 20, 75, 50, 10), _cell("SOME EQUITY", 80, 200, 50, 10)),
+         ]
+         assert cdsl_p._parse_nps(blocks) is None
++
++    def test_parse_nps_scheme_spanning_page_break(self):
++        """A scheme row straddling a page break must not absorb the next
++        page's furniture (bank header, tab bar, investor name, column header,
++        footer), and the scheme/fund-manager split must not depend on a fixed
++        x (fund manager here sits at x=1000, below the old threshold)."""
++        blocks = [
++            _block(_cell("HOLDING STATEMENT AS ON 31-05-2026", 2044, 4000, 700, 660)),
++            # scheme line 1 (name @200, fund-manager @1000) + units/nav
++            _block(
++                _cell("NPS TRUST A/C HDFC PENSION FUND", 200, 900, 600, 560),
++                _cell("HDFC PENSION FUND MANAGEMENT", 1000, 1800, 600, 560),
++            ),
++            _block(
++                _cell("45,982.3138", 4000, 4600, 555, 515), _cell("27.6140", 5000, 5400, 555, 515)
++            ),
++            # --- page break: furniture that must be skipped ---
++            _block(_cell("Central Depository Services (India) Limited", 2000, 3500, 550, 510)),
++            _block(
++                _cell(
++                    "CONSOLIDATED ACCOUNT STATEMENT (CAS) FOR SECURITIES HELD IN DEMAT",
++                    800,
++                    4000,
++                    540,
++                    500,
++                )
++            ),
++            _block(_cell("VINEET MENON", 250, 900, 530, 490)),
++            _block(
++                _cell("Scheme Name", 800, 1500, 520, 480),
++                _cell("Fund Manager", 2000, 2800, 520, 480),
++            ),
++            _block(_cell("Page 18 of 21", 500, 900, 510, 470)),
++            # scheme line 2 (continuation) + fund-manager line 2
++            _block(
++                _cell("MANAGEMENT LIMITED SCHEME G - TIER I GS", 200, 900, 500, 460),
++                _cell("LIMITED", 1000, 1400, 500, 460),
++            ),
++            _block(_cell("Portfolio Value ` 12,69,755.61 as on 31-05-2026", 239, 3000, 440, 400)),
++        ]
++        nps = cdsl_p._parse_nps(blocks)
++        assert nps is not None
++        assert len(nps.schemes) == 1
++        s = nps.schemes[0]
++        assert s.scheme == "NPS TRUST A/C HDFC PENSION FUND MANAGEMENT LIMITED SCHEME G - TIER I GS"
++        assert s.fund_manager == "HDFC PENSION FUND MANAGEMENT LIMITED"
++        assert s.asset_class == "G" and s.tier == "I"
++        assert s.units == Decimal("45982.3138") and s.nav == Decimal("27.6140")
++        # no page furniture leaked into the scheme name
++        for junk in ("VINEET", "Central", "Page", "CONSOLIDATED", "Scheme Name"):
++            assert junk not in s.scheme
+
+EOF_R2E_TEST_PATCH
+R2E_APPLY_RC=$?
+if [ "$R2E_APPLY_RC" -ne 0 ]; then
+  echo "0.000000" > /logs/verifier/reward.txt
+  printf '%s' '{"reward": 0.0, "resolved": false, "parse_status": "test_patch_apply_failed"}' > /logs/verifier/reward-details.json
+  echo "R2E: test_patch failed to apply (rc=$R2E_APPLY_RC) — failing closed" >&2
+  exit 0
+fi
+( python -m pytest -v tests/test_demat_units.py ) > /logs/verifier/test_output.log 2>&1
+TEST_EXIT_CODE=$?
+cat /logs/verifier/test_output.log
+python3 "$SCRIPT_DIR/verifier.py" --log /logs/verifier/test_output.log --f2p "$SCRIPT_DIR/f2p.json" --p2p "$SCRIPT_DIR/p2p.json" --test-cmds 'python -m pytest -v tests/test_demat_units.py' --exit-code "$TEST_EXIT_CODE" --out-dir /logs/verifier || { [ "$TEST_EXIT_CODE" -eq 0 ] && echo "1.0" > /logs/verifier/reward.txt || echo "0.0" > /logs/verifier/reward.txt; }
+git checkout 31b743b0e8ba5b6188cbdcc86eeb56a16afd4c77 -- tests/test_demat_units.py || true
+exit 0

heldout_pool/codereverser__casparser-ede19d2e304e/tests/verifier.py

@@ -0,0 +1,475 @@
+"""In-container verifier for pr_runtime tasks (graded F2P/P2P reward).
+
+This module is the **standalone verifier** that runs inside the task's
+Docker container, NOT a helper used at generation time. It is read as
+source at generation time, base64-encoded, and embedded into
+``tests/test.sh``. At run time the container decodes it back to a file
+and invokes it after the test suite has run.
+
+Why a graded reward instead of binary pass/fail
+------------------------------------------------
+SWE-bench resolution is binary: a patch "resolves" the issue iff ALL
+FAIL_TO_PASS tests pass AND ALL PASS_TO_PASS tests still pass. That's
+the right signal for an eval leaderboard, but a terrible gradient for
+RL training — an agent that fixes 4 of 5 failing tests scores the same
+0.0 as one that fixes nothing.
+
+So this verifier emits BOTH:
+  * /logs/verifier/reward.txt  — the GRADED scalar (training signal,
+        which Harbor reads):  reward = f2p_rate * p2p_factor
+  * /logs/verifier/reward-details.json — carries the strict SWE-bench
+        ``resolved`` bool (eval signal) PLUS the full breakdown.
+
+Refs: SWE-bench (F2P/P2P semantics), SWE-RL / SWE-Gym (dense reward for
+RL), UTBoost (weak-test coverage lets wrong patches pass — hence we
+record p2p_count so consumers can judge regression-guard strength).
+
+Scoring
+-------
+Given the baked FAIL_TO_PASS / PASS_TO_PASS test-name lists (computed by
+the generation-time two-stage validation) and the agent-run test log:
+
+  f2p_rate   = (# F2P tests now PASSED) / (# F2P tests)
+  p2p_rate   = (# P2P tests still PASSED) / (# P2P tests)   [1.0 if no P2P]
+  p2p_factor = p2p_rate          # regressions scale the reward down
+  reward     = f2p_rate * p2p_factor
+  resolved   = (all F2P pass) AND (all P2P pass)            # strict SWE-bench
+
+Oracle invariant: the gold patch flips every F2P and keeps every P2P,
+so f2p_rate=1.0, p2p_rate=1.0 -> reward=1.0 and resolved=True. This is
+what the T3 oracle gate (reward == 1.0) relies on.
+
+Graceful degradation: if the log can't be parsed into per-test
+statuses (unrecognized runner output), fall back to the exit-code
+reward (1.0 if the suite exited 0, else 0.0) and stamp
+``parse_status="fallback_exitcode"`` — never crash, never silently
+zero out a real fix.
+
+Pure stdlib — uses only ``argparse``, ``json``, ``os``, ``re``, ``sys``.
+The 4 per-runner parsers are condensed ports of
+``repo2rlenv.log_parsers.*`` kept in lockstep via the unit tests under
+``tests/test_pr_runtime_verifier.py``.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import sys
+
+# Canonical statuses. (Plain strings — no typing.Literal so the baked
+# module stays import-light when decoded standalone in the container.)
+PASSED = "PASSED"
+FAILED = "FAILED"
+SKIPPED = "SKIPPED"
+ERROR = "ERROR"
+
+# ---------------------------------------------------------------------------
+# Per-runner log parsers (condensed ports of repo2rlenv.log_parsers.*)
+# ---------------------------------------------------------------------------
+
+_PYTEST_STATUSES = (PASSED, FAILED, SKIPPED, ERROR)
+# Keep these patterns in sync with log_parsers/pytest_parser.py. This module
+# also runs standalone inside task containers, without a repo2rlenv install.
+_PYTEST_PROGRESS = (
+    r"\[\s*\d+%\]|\[\s*\d+\s*/\s*\d+\s*\]"
+    r"|\d+(?:\.\d+)?(?:us|ms|s)|\d+m \d+s|\d+h \d+m"
+)
+_PYTEST_VERBOSE_RE = re.compile(
+    r"^(?P<name>.+?(?:\[.*?\])?)\s+(?P<status>PASSED|FAILED|SKIPPED|ERROR)"
+    rf"(?:\s+\(.*\))?(?:\s+(?:{_PYTEST_PROGRESS}))?$"
+)
+_PYTEST_SUMMARY_NAME_RE = re.compile(r"^(?P<name>.+?(?:\[.*?\])?)(?: - .*)?$")
+# pytest-xdist worker label, e.g. `[gw1] [ 20%] PASSED tests/foo.py::test_x`.
+_PYTEST_XDIST_PREFIX_RE = re.compile(rf"^\[gw\d+\]\s+(?:(?:{_PYTEST_PROGRESS})\s+)?")
+
+
+def parse_pytest(log: str) -> dict[str, str]:
+    """{test_name -> status} from pytest output (verbose or summary)."""
+    out: dict[str, str] = {}
+    if not log:
+        return out
+    for raw in log.split("\n"):
+        line = raw.strip()
+        if not line:
+            continue
+        line = _PYTEST_XDIST_PREFIX_RE.sub("", line, count=1)
+        # Summary lines (STATUS first), preserving the full node ID.
+        leading = None
+        for st in _PYTEST_STATUSES:
+            if line.startswith(st + " ") or line == st:
+                leading = st
+                break
+        if leading is not None:
+            work = line[len(leading) :].strip()
+            if leading == SKIPPED and re.match(r"^\[\d+\](?:\s|$)", work):
+                # Folded skips report a file location, not a parametrized ID.
+                tokens = work.split(maxsplit=2)
+                if len(tokens) < 2:
+                    continue
+                out[tokens[1]] = leading
+            elif m := _PYTEST_SUMMARY_NAME_RE.match(work):
+                out[m.group("name")] = leading
+            continue
+        # Verbose progress (NAME first, STATUS after)
+        # Filter non-test output before attempting the backtracking regex.
+        head = line.split(None, 1)[0]
+        if "::" not in head and not head.endswith(".py"):
+            continue
+        m = _PYTEST_VERBOSE_RE.match(line)
+        if m:
+            name = m.group("name")
+            if "::" in name or name.endswith(".py"):
+                out[name] = m.group("status")
+    return out
+
+
+_GO_TEST_RE = re.compile(r"^\s*---\s+(?P<status>PASS|FAIL|SKIP):\s+(?P<name>\S+)")
+_GO_STATUS = {"PASS": PASSED, "FAIL": FAILED, "SKIP": SKIPPED}
+
+
+def parse_go_test(log: str) -> dict[str, str]:
+    """{test_name -> status} from `go test -v` output."""
+    out: dict[str, str] = {}
+    if not log:
+        return out
+    for raw in log.split("\n"):
+        m = _GO_TEST_RE.match(raw)
+        if m:
+            out[m.group("name")] = _GO_STATUS[m.group("status")]
+    return out
+
+
+# Keep these patterns in sync with log_parsers/cargo_parser.py.
+_CARGO_TEST_RE = re.compile(r"^test\s+(?P<name>\S.*?) \.\.\. (?P<status>ok|FAILED|ignored)\b")
+_CARGO_MODE_RE = re.compile(r" - (?:should panic|compile fail|compile)$")
+_CARGO_DOCTEST_RE = re.compile(r"^(?P<file>\S+) - (?:(?P<item>.+?) )?\(line \d+\)$")
+_CARGO_STATUS = {"ok": PASSED, "FAILED": FAILED, "ignored": SKIPPED}
+_CARGO_DOCTEST_RANK = {SKIPPED: 0, PASSED: 1, FAILED: 2}
+
+
+def parse_cargo_test(log: str) -> dict[str, str]:
+    """{test_name -> status} from `cargo test` output.
+
+    Test modes (` - should panic`) are dropped from names, and doctests are
+    keyed without their `(line N)` so line shifts don't change identity; the
+    worst status among an item's doctests wins.
+    """
+    out: dict[str, str] = {}
+    if not log:
+        return out
+    for raw in log.split("\n"):
+        m = _CARGO_TEST_RE.match(raw)
+        if not m:
+            continue
+        name = _CARGO_MODE_RE.sub("", m.group("name")).rstrip()
+        status = _CARGO_STATUS[m.group("status")]
+        doctest = _CARGO_DOCTEST_RE.match(name)
+        if doctest:
+            item = doctest.group("item")
+            name = f"{doctest.group('file')} - {item}" if item else doctest.group("file")
+            if name in out and _CARGO_DOCTEST_RANK[out[name]] > _CARGO_DOCTEST_RANK[status]:
+                continue
+        out[name] = status
+    return out
+
+
+_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\))?$"
+)
+_JEST_GLYPH = {
+    "✓": PASSED,
+    "√": PASSED,
+    "✕": FAILED,
+    "×": FAILED,
+    "✗": FAILED,
+    "○": 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]:
+    """{test_name -> status} from Jest / Mocha / Vitest output."""
+    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
+    for raw in log.split("\n"):
+        line = raw.rstrip()
+        if not line:
+            continue
+        m = _JEST_FILE_RE.match(line)
+        if m:
+            current_file = m.group("path")
+            describe_stack = []
+            last_test_indent = None
+            continue
+        m = _JEST_TEST_RE.match(line)
+        if m:
+            indent = len(m.group("indent"))
+            name = re.sub(r"^(?:skipped|todo):\s*", "", m.group("name").strip())
+            describes = [d for ind, d in describe_stack if ind < indent]
+            parts = ([current_file] if current_file else []) + describes + [name]
+            out[" > ".join(parts)] = _JEST_GLYPH[m.group("glyph")]
+            last_test_indent = indent
+            continue
+        stripped = line.lstrip()
+        if not stripped or stripped.startswith(
+            ("Tests:", "Test Suites:", "Snapshots:", "Time:", "Ran all", "●", "→", "✗:")
+        ):
+            continue
+        indent_here = len(line) - len(stripped)
+        if current_file and (last_test_indent is None or indent_here < last_test_indent):
+            describe_stack = [(i, d) for i, d in describe_stack if i < indent_here]
+            describe_stack.append((indent_here, stripped))
+    return out
+
+
+def _detect_runner(test_cmds: str) -> str:
+    joined = test_cmds.lower()
+    if "pytest" in joined:
+        return "pytest"
+    if re.search(r"\bgo\s+test\b", joined):
+        return "go"
+    if re.search(r"\bcargo\s+test\b", joined):
+        return "cargo"
+    if any(k in joined for k in ("jest", "mocha", "vitest", "npm test", "yarn test", "pnpm test")):
+        return "jest"
+    return "unknown"
+
+
+def parse_logs(runner: str, log: str) -> dict[str, str]:
+    """Dispatch to the right per-runner parser. Empty dict if unknown."""
+    if runner == "pytest":
+        return parse_pytest(log)
+    if runner == "go":
+        return parse_go_test(log)
+    if runner == "cargo":
+        return parse_cargo_test(log)
+    if runner == "jest":
+        return parse_jest(log)
+    return {}
+
+
+# ---------------------------------------------------------------------------
+# Grading
+# ---------------------------------------------------------------------------
+def _has_go_parent(name: str, status_map: dict[str, str]) -> bool:
+    """Return True if a Go test has an ancestor represented in the status map."""
+    parts = name.split("/")
+
+    for i in range(1, len(parts)):
+        parent = "/".join(parts[:i])
+        if status_map.get(parent) == FAILED:
+            return True
+
+    return False
+
+
+def grade(
+    fail_to_pass: list[str],
+    pass_to_pass: list[str],
+    status_map: dict[str, str],
+    runner: str | None = None,
+) -> dict:
+    """Compute the graded reward + strict resolved bool from a status map.
+
+    f2p_rate   = (# F2P now PASSED) / (# F2P)
+    p2p_rate   = (# P2P still PASSED) / (# P2P)   [1.0 when no P2P]
+    reward     = f2p_rate * p2p_rate                       (dense training signal)
+    resolved   = all F2P pass AND all P2P pass   (SWE-bench TRACKED resolution —
+                 the gold patch always satisfies this, preserving the oracle
+                 invariant)
+
+    Two distinct EVAL signals (see the audit's "tracked vs command resolved"):
+      * `resolved`         — tracked resolution (above). Gold patch -> True.
+      * `command_resolved` — stricter: tracked resolution AND the selected test
+                             command had NO failures outside F2P/P2P AND exit
+                             code 0. Computed in main() where the exit code is
+                             known. A benchmark that wants "the whole command
+                             passed cleanly" gates on this; SWE-bench-style
+                             scoring uses `resolved`.
+
+    `untracked_failed` are FAILED tests in the run that are neither F2P nor
+    P2P (e.g. always-failing/flaky tests pulled in by running a whole test
+    file). They don't change the graded `reward` or tracked `resolved`, but
+    they block `command_resolved` and are recorded for transparency.
+    """
+    f2p_total = len(fail_to_pass)
+    p2p_total = len(pass_to_pass)
+    f2p_set = set(fail_to_pass)
+    p2p_set = set(pass_to_pass)
+    f2p_passed = sum(1 for t in fail_to_pass if status_map.get(t) == PASSED)
+    p2p_passed = sum(1 for t in pass_to_pass if status_map.get(t) == PASSED)
+    # Tests that should have stayed green but regressed (PASS->not-pass).
+    regressions = [t for t in pass_to_pass if status_map.get(t) != PASSED]
+
+    # FAILED tests outside the tracked sets — the selected command isn't clean.
+    if runner == "go":
+        failed_tests = {
+            t
+            for t, s in status_map.items()
+            if s == FAILED and t not in f2p_set and t not in p2p_set
+        }
+
+        untracked_failed = sorted(t for t in failed_tests if not _has_go_parent(t, status_map))
+    else:
+        untracked_failed = sorted(
+            t
+            for t, s in status_map.items()
+            if s == FAILED and t not in f2p_set and t not in p2p_set
+        )
+
+    f2p_rate = (f2p_passed / f2p_total) if f2p_total else 0.0
+    p2p_rate = (p2p_passed / p2p_total) if p2p_total else 1.0
+    reward = f2p_rate * p2p_rate
+    resolved = f2p_total > 0 and f2p_passed == f2p_total and p2p_passed == p2p_total
+
+    return {
+        "reward": round(max(0.0, min(1.0, reward)), 6),
+        "resolved": resolved,
+        "f2p_total": f2p_total,
+        "f2p_passed": f2p_passed,
+        "f2p_rate": round(f2p_rate, 6),
+        "p2p_total": p2p_total,
+        "p2p_passed": p2p_passed,
+        "p2p_rate": round(p2p_rate, 6),
+        "regressions": sorted(regressions),
+        "untracked_failed_count": len(untracked_failed),
+        "untracked_failed": untracked_failed[:20],  # cap the list
+    }
+
+
+# ---------------------------------------------------------------------------
+# Entry point (invoked by tests/test.sh inside the container)
+# ---------------------------------------------------------------------------
+
+
+def _read_json_list(path: str) -> list[str]:
+    try:
+        with open(path, encoding="utf-8") as f:
+            data = json.load(f)
+        return [str(x) for x in data] if isinstance(data, list) else []
+    except (OSError, ValueError):
+        return []
+
+
+def _read_text(path: str) -> str:
+    try:
+        with open(path, encoding="utf-8") as f:
+            return f.read()
+    except (OSError, UnicodeDecodeError):
+        return ""
+
+
+def main(argv: list[str] | None = None) -> int:
+    p = argparse.ArgumentParser(description="pr_runtime graded F2P/P2P verifier")
+    p.add_argument("--log", required=True, help="captured test-run log file")
+    p.add_argument("--f2p", required=True, help="JSON file: FAIL_TO_PASS test names")
+    p.add_argument("--p2p", required=True, help="JSON file: PASS_TO_PASS test names")
+    p.add_argument("--runner", default="", help="pytest|go|cargo|jest (else auto-detect)")
+    p.add_argument("--test-cmds", default="", help="test command string (runner auto-detect)")
+    p.add_argument("--exit-code", type=int, default=1, help="test suite exit code (fallback)")
+    p.add_argument("--out-dir", default="/logs/verifier", help="where to write reward.{txt,json}")
+    args = p.parse_args(argv)
+
+    log = _read_text(args.log)
+    f2p = _read_json_list(args.f2p)
+    p2p = _read_json_list(args.p2p)
+    runner = args.runner.strip() or _detect_runner(args.test_cmds)
+
+    status_map = parse_logs(runner, log)
+
+    if not status_map:
+        # Unparseable runner output → fall back to the binary exit-code reward
+        # (a coarse TRAINING signal) so we never silently zero a real fix on an
+        # unrecognized format. But `resolved` is the strict EVAL signal: without
+        # parsed per-test status we have NO evidence the declared FAIL_TO_PASS
+        # tests passed, so when an F2P oracle exists we must NOT claim resolved.
+        # (resolved stays exit-code-based only when there's no declared oracle,
+        # e.g. --skip-validation.)
+        reward = 1.0 if args.exit_code == 0 else 0.0
+        has_oracle = len(f2p) > 0
+        resolved = (args.exit_code == 0) and not has_oracle
+        breakdown = {
+            "reward": reward,
+            "resolved": resolved,
+            "command_resolved": bool(resolved and args.exit_code == 0),
+            "parse_status": "fallback_exitcode",
+            "eval_trustworthy": not has_oracle,
+            "runner": runner,
+            "f2p_total": len(f2p),
+            "p2p_total": len(p2p),
+            "exit_code": args.exit_code,
+        }
+    else:
+        breakdown = grade(f2p, p2p, status_map, runner)
+        breakdown["parse_status"] = "ok"
+        breakdown["runner"] = runner
+        breakdown["tests_parsed"] = len(status_map)
+        breakdown["exit_code"] = args.exit_code
+        # Strict eval signal: tracked resolution AND a clean command (no
+        # untracked failures, exit code 0). Benchmarks wanting "the whole test
+        # command passed" gate on this; SWE-bench-style scoring uses `resolved`.
+        breakdown["command_resolved"] = bool(
+            breakdown["resolved"]
+            and breakdown["untracked_failed_count"] == 0
+            and args.exit_code == 0
+        )
+        reward = breakdown["reward"]
+
+    os.makedirs(args.out_dir, exist_ok=True)
+    with open(os.path.join(args.out_dir, "reward.txt"), "w", encoding="utf-8") as f:
+        f.write(f"{reward:.6f}\n")
+    with open(os.path.join(args.out_dir, "reward-details.json"), "w", encoding="utf-8") as f:
+        json.dump(breakdown, f, indent=2)
+
+    print(json.dumps(breakdown, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
+
+
+__all__ = [
+    "grade",
+    "main",
+    "parse_cargo_test",
+    "parse_go_test",
+    "parse_jest",
+    "parse_logs",
+    "parse_pytest",
+]

heldout_pool/codereverser__casparser-f960976ba489/environment/Dockerfile

@@ -0,0 +1,36 @@
+# Auto-generated by Repo2RLEnv pr_runtime
+FROM local/codereverser__casparser
+WORKDIR /workspace
+# Defensive: ensure git is on PATH at build time. Bootstrap base
+# images vary — some (Python slim) don't ship git; some agents
+# install it; others don't. Re-installing is a no-op when already
+# present. Tries apt-get first (Debian/Ubuntu), then apk (Alpine).
+# Install git + ca-certificates. Minimal images (node:alpine) ship
+# without CA certs, so HTTPS git fetch fails verification.
+RUN (command -v git >/dev/null 2>&1 && [ -e /etc/ssl/certs/ca-certificates.crt ]) || \
+    (apt-get update && apt-get install -y --no-install-recommends git ca-certificates \
+     && rm -rf /var/lib/apt/lists/*) || \
+    (apk add --no-cache git ca-certificates && update-ca-certificates) || true
+# Defensive: the graded F2P/P2P verifier is Python.
+# Language-specific bootstrap images (Go/Rust/Node) may not
+# ship python3 — install it so test.sh can score F2P/P2P. No-op when
+# python3 is already present (every Python-repo image has it).
+RUN command -v python3 >/dev/null 2>&1 || \
+    (apt-get update && apt-get install -y --no-install-recommends python3 \
+     && rm -rf /var/lib/apt/lists/*) || \
+    apk add --no-cache python3 || true
+# Position the working tree at the PR's base commit so subsequent
+# model-patch applications align with the line context the patch
+# was authored against. The fetch is a no-op if the commit is
+# already in the shallow clone.
+RUN git config --global --add safe.directory /workspace \
+    && git fetch --depth 1 origin dc6b4bad9a9d10e298fad1f3708587e4eea5f1fd 2>/dev/null \
+       || git fetch --unshallow origin 2>/dev/null || true
+RUN git reset --hard dc6b4bad9a9d10e298fad1f3708587e4eea5f1fd && git clean -fdx -e .venv -e venv -e __pycache__ -e .tox -e node_modules -e target -e vendor -e .gradle -e .next -e .pytest_cache
+RUN git checkout -q -B base dc6b4bad9a9d10e298fad1f3708587e4eea5f1fd \
+    && git remote remove origin 2>/dev/null || true
+RUN for ref in $(git branch --format='%(refname:short)' | grep -vx base); do git branch -D "$ref" 2>/dev/null || true; done \
+    && git tag -l | xargs -r git tag -d >/dev/null 2>&1 || true \
+    && git for-each-ref --format='%(refname)' refs/remotes 2>/dev/null | xargs -r -n1 git update-ref -d 2>/dev/null || true \
+    && git reflog expire --expire=now --all 2>/dev/null || true \
+    && git gc --prune=now 2>/dev/null || true

heldout_pool/codereverser__casparser-f960976ba489/environment/docker-compose.yaml

@@ -0,0 +1,16 @@
+# Auto-generated by Repo2RLEnv: anti-contamination egress guard.
+# Blackholes the hosts that serve this repo's published fix and hidden
+# tests, so an agent cannot fetch the answer (pip download / git fetch /
+# WebFetch against these fail). General internet stays up so the agent
+# can install itself and reach its model API. See pipelines/_env_guard.py.
+services:
+  main:
+    extra_hosts:
+      - "pypi.org:0.0.0.0"
+      - "pypi.python.org:0.0.0.0"
+      - "files.pythonhosted.org:0.0.0.0"
+      - "github.com:0.0.0.0"
+      - "api.github.com:0.0.0.0"
+      - "raw.githubusercontent.com:0.0.0.0"
+      - "codeload.github.com:0.0.0.0"
+      - "objects.githubusercontent.com:0.0.0.0"

heldout_pool/codereverser__casparser-f960976ba489/instruction.md

@@ -0,0 +1,10 @@
+# Issue
+
+**Title:** CDSL/NSDL parser misclassifies leading-dot decimal numbers
+
+## Description
+When parsing CDSL or NSDL statements, numeric values that begin with a decimal point (e.g., `.196` instead of `0.196`) are incorrectly classified as text. This causes the row layout to shift unexpectedly and leads to an incorrect sum of holdings (Σholdings) that does not match the actual balance. Expected behavior is for these leading-dot decimals to be recognized as valid numbers and parsed correctly, ensuring accurate balance calculations.
+
+## Task
+
+Modify the repository so that the issue described above is resolved. The task's test suite verifies your patch by applying it on top of the base commit `dc6b4bad9a9d` and running the modified tests.

heldout_pool/codereverser__casparser-f960976ba489/solution/patch.diff

@@ -0,0 +1,48 @@
+diff --git a/CHANGELOG.md b/CHANGELOG.md
+index 687c157..019724e 100644
+--- a/CHANGELOG.md
++++ b/CHANGELOG.md
+@@ -74,6 +74,11 @@ parser tuned to their template family.
+   page 8, dropping holdings sections that landed on pages 4-7.
+ - **CDSL MF holdings** rows with `DIRECT` (or any non-`ARN-XXXX`
+   distribution-mode token) now correctly populate `pnl` and `return_`.
++- **Leading-dot decimals** (`.196`, `-.5`) are now recognised as
++  numeric by the NSDL / CDSL cell classifier. CDSL occasionally
++  drops the leading zero on sub-unit balances; under the old regex
++  those cells were mis-bucketed as text, shifting the row layout
++  and producing a silent `Σholdings ≠ balance` mismatch.
+ 
+ ## 0.9.0 - 2026-05-22
+ - Add support for CDSL statements
+diff --git a/casparser/parsers/cdsl.py b/casparser/parsers/cdsl.py
+index 2ce58e8..0b82d30 100644
+--- a/casparser/parsers/cdsl.py
++++ b/casparser/parsers/cdsl.py
+@@ -55,7 +55,10 @@ from .pageobj import Block
+ ISIN_RE = re.compile(r"^[A-Z]{2}[0-9A-Z]{9}\d$")
+ INF_ISIN_RE = re.compile(r"^INF[0-9A-Z]{8}\d$")
+ INE_ISIN_RE = re.compile(r"^IN[E9][0-9A-Z]{8}\d$")
+-NUMERIC_RE = re.compile(r"^-?[\d,]+(?:\.\d+)?$")
++# CDSL sometimes drops the leading zero on fractional values (e.g. a
++# `0.196` unit balance prints as `.196`), so the integer part is
++# optional when a decimal part is present.
++NUMERIC_RE = re.compile(r"^-?(?:[\d,]+(?:\.\d+)?|\.\d+)$")
+ 
+ PERIOD_RE = re.compile(
+     r"(?:for\s+the\s+period\s+from|statement\s+for\s+the\s+period\s+from)\s+"
+diff --git a/casparser/parsers/nsdl.py b/casparser/parsers/nsdl.py
+index aa123b2..25707b7 100644
+--- a/casparser/parsers/nsdl.py
++++ b/casparser/parsers/nsdl.py
+@@ -56,7 +56,10 @@ from .pageobj import Block, Cell
+ ISIN_RE = re.compile(r"^[A-Z]{2}[0-9A-Z]{9}\d$")
+ INF_ISIN_RE = re.compile(r"^INF[0-9A-Z]{8}\d$")
+ INE_ISIN_RE = re.compile(r"^IN[E9][0-9A-Z]{8}\d$")
+-NUMERIC_RE = re.compile(r"^-?[\d,]+(?:\.\d+)?$")
++# Some templates drop the leading zero on fractional values (e.g. a
++# `0.196` unit balance prints as `.196`), so the integer part is
++# optional when a decimal part is present.
++NUMERIC_RE = re.compile(r"^-?(?:[\d,]+(?:\.\d+)?|\.\d+)$")
+ 
+ PERIOD_RE = re.compile(
+     r"(?:for\s+the\s+period\s+from|statement\s+for\s+the\s+period\s+from)\s+"

heldout_pool/codereverser__casparser-f960976ba489/solution/solve.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+set -euxo pipefail
+cd /workspace
+git config --global --add safe.directory /workspace
+PATCH="$(dirname "$0")/patch.diff"
+git apply --verbose --reject "$PATCH"

heldout_pool/codereverser__casparser-f960976ba489/task.toml

@@ -0,0 +1,104 @@
+version = "1.0"
+
+[task]
+name = "commit-runtime/codereverser__casparser-f960976ba489"
+description = "Fix NUMERIC_RE to accept leading-dot decimals in NSDL/CDSL parsers"
+
+[metadata]
+difficulty = "small"
+category = "bugfix"
+keywords = [
+    "casparser",
+    "commit_runtime",
+]
+
+[metadata.repo2env]
+pipeline = "commit_runtime"
+pipeline_version = "0.8.3"
+repo = "codereverser/casparser"
+ref = "dc6b4bad9a9d10e298fad1f3708587e4eea5f1fd"
+reference = "https://github.com/codereverser/casparser/commit/f960976ba4895a2225e6d7b3f3985d53445aea91"
+source_access = "public"
+built_at = "2026-09-24T13:12:19.162103+00:00"
+synthesis_llm = "gemini/gemini-2.5-flash"
+reward_kinds = [
+    "test_execution",
+    "diff_similarity",
+]
+spec_version = "0.2.0"
+content_hash = "sha256:8a882eb5408e1686feb78ef66dcce993266caf876b3dd81efe8d7f3c1897921a"
+
+[metadata.repo2env.commit_runtime]
+commit_sha = "f960976ba4895a2225e6d7b3f3985d53445aea91"
+parent_sha = "dc6b4bad9a9d10e298fad1f3708587e4eea5f1fd"
+authored_at = "2026-05-28T12:44:45+10:00"
+author_email = "codereverser@gmail.com"
+subject = "Fix NUMERIC_RE to accept leading-dot decimals in NSDL/CDSL parsers"
+fail_to_pass = [
+    "tests/test_demat_units.py::TestCDSLHelpers::test_looks_numeric_leading_dot",
+]
+pass_to_pass = [
+    "tests/test_demat_units.py::TestCDSLHelpers::test_account_key_normalises",
+    "tests/test_demat_units.py::TestCDSLHelpers::test_full_type_format",
+    "tests/test_demat_units.py::TestCDSLHelpers::test_looks_numeric",
+    "tests/test_demat_units.py::TestCDSLHelpers::test_split_bo_id_cdsl",
+    "tests/test_demat_units.py::TestCDSLHelpers::test_split_bo_id_invalid_length",
+    "tests/test_demat_units.py::TestCDSLHelpers::test_split_bo_id_nsdl",
+    "tests/test_demat_units.py::TestCDSLHelpers::test_split_bo_id_unrecognised",
+    "tests/test_demat_units.py::TestDecimalHelpers::test_opt_decimal_parses_value[casparser.parsers.cdsl]",
+    "tests/test_demat_units.py::TestDecimalHelpers::test_opt_decimal_parses_value[casparser.parsers.nsdl]",
+    "tests/test_demat_units.py::TestDecimalHelpers::test_opt_decimal_returns_none_on_placeholders[casparser.parsers.cdsl]",
+    "tests/test_demat_units.py::TestDecimalHelpers::test_opt_decimal_returns_none_on_placeholders[casparser.parsers.nsdl]",
+    "tests/test_demat_units.py::TestDecimalHelpers::test_to_decimal_handles_none[casparser.parsers.cdsl]",
+    "tests/test_demat_units.py::TestDecimalHelpers::test_to_decimal_handles_none[casparser.parsers.nsdl]",
+    "tests/test_demat_units.py::TestDecimalHelpers::test_to_decimal_handles_placeholders[ -casparser.parsers.cdsl]",
+    "tests/test_demat_units.py::TestDecimalHelpers::test_to_decimal_handles_placeholders[ -casparser.parsers.nsdl]",
+    "tests/test_demat_units.py::TestDecimalHelpers::test_to_decimal_handles_placeholders[---casparser.parsers.cdsl]",
+    "tests/test_demat_units.py::TestDecimalHelpers::test_to_decimal_handles_placeholders[---casparser.parsers.nsdl]",
+    "tests/test_demat_units.py::TestDecimalHelpers::test_to_decimal_handles_placeholders[--casparser.parsers.cdsl]",
+    "tests/test_demat_units.py::TestDecimalHelpers::test_to_decimal_handles_placeholders[--casparser.parsers.nsdl]",
+    "tests/test_demat_units.py::TestDecimalHelpers::test_to_decimal_handles_placeholders[-casparser.parsers.cdsl]",
+    "tests/test_demat_units.py::TestDecimalHelpers::test_to_decimal_handles_placeholders[-casparser.parsers.nsdl]",
+    "tests/test_demat_units.py::TestDecimalHelpers::test_to_decimal_handles_placeholders[N.A-casparser.parsers.cdsl]",
+    "tests/test_demat_units.py::TestDecimalHelpers::test_to_decimal_handles_placeholders[N.A-casparser.parsers.nsdl]",
+    "tests/test_demat_units.py::TestDecimalHelpers::test_to_decimal_handles_placeholders[NA-casparser.parsers.cdsl]",
+    "tests/test_demat_units.py::TestDecimalHelpers::test_to_decimal_handles_placeholders[NA-casparser.parsers.nsdl]",
+    "tests/test_demat_units.py::TestDecimalHelpers::test_to_decimal_strips_commas[casparser.parsers.cdsl]",
+    "tests/test_demat_units.py::TestDecimalHelpers::test_to_decimal_strips_commas[casparser.parsers.nsdl]",
+    "tests/test_demat_units.py::TestDecimalHelpers::test_to_decimal_swallows_invalid[casparser.parsers.cdsl]",
+    "tests/test_demat_units.py::TestDecimalHelpers::test_to_decimal_swallows_invalid[casparser.parsers.nsdl]",
+]
+validation_status = "verified"
+bootstrap_image = "local-venv:codereverser__casparser"
+instruction_synthesized = true
+llm_cost_usd = 0.010387
+
+[metadata.repo2env.reward_calibration]
+f2p_count = 1
+p2p_count = 29
+source_files = 3
+loc_changed = 15
+difficulty = "small"
+
+[metadata.repo2env.evaluation]
+schema_version = "1"
+status = "unverified"
+stage = "generation"
+reason_codes = [
+    "validation_not_run",
+]
+detail = "Generated task; validation has not been established."
+provenance = "unknown"
+evidence = []
+
+[metadata.repo2env.reproducibility]
+mode = "local_only"
+image_ref = "local/codereverser__casparser"
+image_tag = "local/codereverser__casparser"
+image_visibility = "private"
+
+[agent]
+timeout_sec = 1800.0
+
+[verifier]
+timeout_sec = 300.0

heldout_pool/codereverser__casparser-f960976ba489/tests/f2p.json

@@ -0,0 +1,3 @@
+[
+  "tests/test_demat_units.py::TestCDSLHelpers::test_looks_numeric_leading_dot"
+]

heldout_pool/codereverser__casparser-f960976ba489/tests/p2p.json

@@ -0,0 +1,31 @@
+[
+  "tests/test_demat_units.py::TestCDSLHelpers::test_account_key_normalises",
+  "tests/test_demat_units.py::TestCDSLHelpers::test_full_type_format",
+  "tests/test_demat_units.py::TestCDSLHelpers::test_looks_numeric",
+  "tests/test_demat_units.py::TestCDSLHelpers::test_split_bo_id_cdsl",
+  "tests/test_demat_units.py::TestCDSLHelpers::test_split_bo_id_invalid_length",
+  "tests/test_demat_units.py::TestCDSLHelpers::test_split_bo_id_nsdl",
+  "tests/test_demat_units.py::TestCDSLHelpers::test_split_bo_id_unrecognised",
+  "tests/test_demat_units.py::TestDecimalHelpers::test_opt_decimal_parses_value[casparser.parsers.cdsl]",
+  "tests/test_demat_units.py::TestDecimalHelpers::test_opt_decimal_parses_value[casparser.parsers.nsdl]",
+  "tests/test_demat_units.py::TestDecimalHelpers::test_opt_decimal_returns_none_on_placeholders[casparser.parsers.cdsl]",
+  "tests/test_demat_units.py::TestDecimalHelpers::test_opt_decimal_returns_none_on_placeholders[casparser.parsers.nsdl]",
+  "tests/test_demat_units.py::TestDecimalHelpers::test_to_decimal_handles_none[casparser.parsers.cdsl]",
+  "tests/test_demat_units.py::TestDecimalHelpers::test_to_decimal_handles_none[casparser.parsers.nsdl]",
+  "tests/test_demat_units.py::TestDecimalHelpers::test_to_decimal_handles_placeholders[ -casparser.parsers.cdsl]",
+  "tests/test_demat_units.py::TestDecimalHelpers::test_to_decimal_handles_placeholders[ -casparser.parsers.nsdl]",
+  "tests/test_demat_units.py::TestDecimalHelpers::test_to_decimal_handles_placeholders[---casparser.parsers.cdsl]",
+  "tests/test_demat_units.py::TestDecimalHelpers::test_to_decimal_handles_placeholders[---casparser.parsers.nsdl]",
+  "tests/test_demat_units.py::TestDecimalHelpers::test_to_decimal_handles_placeholders[--casparser.parsers.cdsl]",
+  "tests/test_demat_units.py::TestDecimalHelpers::test_to_decimal_handles_placeholders[--casparser.parsers.nsdl]",
+  "tests/test_demat_units.py::TestDecimalHelpers::test_to_decimal_handles_placeholders[-casparser.parsers.cdsl]",
+  "tests/test_demat_units.py::TestDecimalHelpers::test_to_decimal_handles_placeholders[-casparser.parsers.nsdl]",
+  "tests/test_demat_units.py::TestDecimalHelpers::test_to_decimal_handles_placeholders[N.A-casparser.parsers.cdsl]",
+  "tests/test_demat_units.py::TestDecimalHelpers::test_to_decimal_handles_placeholders[N.A-casparser.parsers.nsdl]",
+  "tests/test_demat_units.py::TestDecimalHelpers::test_to_decimal_handles_placeholders[NA-casparser.parsers.cdsl]",
+  "tests/test_demat_units.py::TestDecimalHelpers::test_to_decimal_handles_placeholders[NA-casparser.parsers.nsdl]",
+  "tests/test_demat_units.py::TestDecimalHelpers::test_to_decimal_strips_commas[casparser.parsers.cdsl]",
+  "tests/test_demat_units.py::TestDecimalHelpers::test_to_decimal_strips_commas[casparser.parsers.nsdl]",
+  "tests/test_demat_units.py::TestDecimalHelpers::test_to_decimal_swallows_invalid[casparser.parsers.cdsl]",
+  "tests/test_demat_units.py::TestDecimalHelpers::test_to_decimal_swallows_invalid[casparser.parsers.nsdl]"
+]

heldout_pool/codereverser__casparser-f960976ba489/tests/test.sh

@@ -0,0 +1,64 @@
+#!/bin/bash
+set -uxo pipefail
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+cd /workspace
+git config --global --add safe.directory /workspace
+mkdir -p /logs/verifier
+git checkout dc6b4bad9a9d10e298fad1f3708587e4eea5f1fd -- tests/test_demat_units.py || true
+git apply --verbose --reject - <<'EOF_R2E_TEST_PATCH'
+diff --git a/tests/test_demat_units.py b/tests/test_demat_units.py
+index 1cbdba6..42b28c7 100644
+--- a/tests/test_demat_units.py
++++ b/tests/test_demat_units.py
+@@ -115,6 +115,19 @@ class TestCDSLHelpers:
+         assert not cdsl_p._looks_numeric("DIRECT")
+         assert not cdsl_p._looks_numeric("")
+ 
++    def test_looks_numeric_leading_dot(self):
++        """CDSL drops the leading zero on small fractional balances
++        (`0.196` -> `.196`); the classifier must still treat them as
++        numeric, otherwise the cell mis-buckets and the row layout
++        shifts silently."""
++        assert cdsl_p._looks_numeric(".196")
++        assert cdsl_p._looks_numeric(".69")
++        assert cdsl_p._looks_numeric("-.5")
++        assert cdsl_p._looks_numeric("0.196")
++        # naked separators must still fail
++        assert not cdsl_p._looks_numeric(".")
++        assert not cdsl_p._looks_numeric("-")
++
+     def test_is_total_row(self):
+         block = _block(_cell("Sub Total"), _cell("100.00"))
+         assert cdsl_p._is_total_row(block)
+@@ -465,6 +478,16 @@ class TestNSDLHelpers:
+         assert not cdsl_p._looks_numeric("")
+         assert not cdsl_p._looks_numeric("   ")
+ 
++    def test_looks_numeric_leading_dot_both(self):
++        """Sub-unit balances rendered without the leading zero
++        (`.196`, `-.5`) must be recognised as numeric in BOTH NSDL and
++        CDSL classifiers; the parsers share the regex shape."""
++        for fn in (nsdl_p._looks_numeric, cdsl_p._looks_numeric):
++            assert fn(".196")
++            assert fn("-.5")
++            # naked dot must still fail
++            assert not fn(".")
++
+     def test_per_account_header_joint_form(self):
+         """The NSDL joint-account section header is split across THREE
+         blocks: `NSDL Demat Account / ACCOUNT HOLDERS`, broker + first
+
+EOF_R2E_TEST_PATCH
+R2E_APPLY_RC=$?
+if [ "$R2E_APPLY_RC" -ne 0 ]; then
+  echo "0.000000" > /logs/verifier/reward.txt
+  printf '%s' '{"reward": 0.0, "resolved": false, "parse_status": "test_patch_apply_failed"}' > /logs/verifier/reward-details.json
+  echo "R2E: test_patch failed to apply (rc=$R2E_APPLY_RC) — failing closed" >&2
+  exit 0
+fi
+( python -m pytest -v tests/test_demat_units.py ) > /logs/verifier/test_output.log 2>&1
+TEST_EXIT_CODE=$?
+cat /logs/verifier/test_output.log
+python3 "$SCRIPT_DIR/verifier.py" --log /logs/verifier/test_output.log --f2p "$SCRIPT_DIR/f2p.json" --p2p "$SCRIPT_DIR/p2p.json" --test-cmds 'python -m pytest -v tests/test_demat_units.py' --exit-code "$TEST_EXIT_CODE" --out-dir /logs/verifier || { [ "$TEST_EXIT_CODE" -eq 0 ] && echo "1.0" > /logs/verifier/reward.txt || echo "0.0" > /logs/verifier/reward.txt; }
+git checkout dc6b4bad9a9d10e298fad1f3708587e4eea5f1fd -- tests/test_demat_units.py || true
+exit 0

heldout_pool/codereverser__casparser-f960976ba489/tests/verifier.py

@@ -0,0 +1,475 @@
+"""In-container verifier for pr_runtime tasks (graded F2P/P2P reward).
+
+This module is the **standalone verifier** that runs inside the task's
+Docker container, NOT a helper used at generation time. It is read as
+source at generation time, base64-encoded, and embedded into
+``tests/test.sh``. At run time the container decodes it back to a file
+and invokes it after the test suite has run.
+
+Why a graded reward instead of binary pass/fail
+------------------------------------------------
+SWE-bench resolution is binary: a patch "resolves" the issue iff ALL
+FAIL_TO_PASS tests pass AND ALL PASS_TO_PASS tests still pass. That's
+the right signal for an eval leaderboard, but a terrible gradient for
+RL training — an agent that fixes 4 of 5 failing tests scores the same
+0.0 as one that fixes nothing.
+
+So this verifier emits BOTH:
+  * /logs/verifier/reward.txt  — the GRADED scalar (training signal,
+        which Harbor reads):  reward = f2p_rate * p2p_factor
+  * /logs/verifier/reward-details.json — carries the strict SWE-bench
+        ``resolved`` bool (eval signal) PLUS the full breakdown.
+
+Refs: SWE-bench (F2P/P2P semantics), SWE-RL / SWE-Gym (dense reward for
+RL), UTBoost (weak-test coverage lets wrong patches pass — hence we
+record p2p_count so consumers can judge regression-guard strength).
+
+Scoring
+-------
+Given the baked FAIL_TO_PASS / PASS_TO_PASS test-name lists (computed by
+the generation-time two-stage validation) and the agent-run test log:
+
+  f2p_rate   = (# F2P tests now PASSED) / (# F2P tests)
+  p2p_rate   = (# P2P tests still PASSED) / (# P2P tests)   [1.0 if no P2P]
+  p2p_factor = p2p_rate          # regressions scale the reward down
+  reward     = f2p_rate * p2p_factor
+  resolved   = (all F2P pass) AND (all P2P pass)            # strict SWE-bench
+
+Oracle invariant: the gold patch flips every F2P and keeps every P2P,
+so f2p_rate=1.0, p2p_rate=1.0 -> reward=1.0 and resolved=True. This is
+what the T3 oracle gate (reward == 1.0) relies on.
+
+Graceful degradation: if the log can't be parsed into per-test
+statuses (unrecognized runner output), fall back to the exit-code
+reward (1.0 if the suite exited 0, else 0.0) and stamp
+``parse_status="fallback_exitcode"`` — never crash, never silently
+zero out a real fix.
+
+Pure stdlib — uses only ``argparse``, ``json``, ``os``, ``re``, ``sys``.
+The 4 per-runner parsers are condensed ports of
+``repo2rlenv.log_parsers.*`` kept in lockstep via the unit tests under
+``tests/test_pr_runtime_verifier.py``.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import sys
+
+# Canonical statuses. (Plain strings — no typing.Literal so the baked
+# module stays import-light when decoded standalone in the container.)
+PASSED = "PASSED"
+FAILED = "FAILED"
+SKIPPED = "SKIPPED"
+ERROR = "ERROR"
+
+# ---------------------------------------------------------------------------
+# Per-runner log parsers (condensed ports of repo2rlenv.log_parsers.*)
+# ---------------------------------------------------------------------------
+
+_PYTEST_STATUSES = (PASSED, FAILED, SKIPPED, ERROR)
+# Keep these patterns in sync with log_parsers/pytest_parser.py. This module
+# also runs standalone inside task containers, without a repo2rlenv install.
+_PYTEST_PROGRESS = (
+    r"\[\s*\d+%\]|\[\s*\d+\s*/\s*\d+\s*\]"
+    r"|\d+(?:\.\d+)?(?:us|ms|s)|\d+m \d+s|\d+h \d+m"
+)
+_PYTEST_VERBOSE_RE = re.compile(
+    r"^(?P<name>.+?(?:\[.*?\])?)\s+(?P<status>PASSED|FAILED|SKIPPED|ERROR)"
+    rf"(?:\s+\(.*\))?(?:\s+(?:{_PYTEST_PROGRESS}))?$"
+)
+_PYTEST_SUMMARY_NAME_RE = re.compile(r"^(?P<name>.+?(?:\[.*?\])?)(?: - .*)?$")
+# pytest-xdist worker label, e.g. `[gw1] [ 20%] PASSED tests/foo.py::test_x`.
+_PYTEST_XDIST_PREFIX_RE = re.compile(rf"^\[gw\d+\]\s+(?:(?:{_PYTEST_PROGRESS})\s+)?")
+
+
+def parse_pytest(log: str) -> dict[str, str]:
+    """{test_name -> status} from pytest output (verbose or summary)."""
+    out: dict[str, str] = {}
+    if not log:
+        return out
+    for raw in log.split("\n"):
+        line = raw.strip()
+        if not line:
+            continue
+        line = _PYTEST_XDIST_PREFIX_RE.sub("", line, count=1)
+        # Summary lines (STATUS first), preserving the full node ID.
+        leading = None
+        for st in _PYTEST_STATUSES:
+            if line.startswith(st + " ") or line == st:
+                leading = st
+                break
+        if leading is not None:
+            work = line[len(leading) :].strip()
+            if leading == SKIPPED and re.match(r"^\[\d+\](?:\s|$)", work):
+                # Folded skips report a file location, not a parametrized ID.
+                tokens = work.split(maxsplit=2)
+                if len(tokens) < 2:
+                    continue
+                out[tokens[1]] = leading
+            elif m := _PYTEST_SUMMARY_NAME_RE.match(work):
+                out[m.group("name")] = leading
+            continue
+        # Verbose progress (NAME first, STATUS after)
+        # Filter non-test output before attempting the backtracking regex.
+        head = line.split(None, 1)[0]
+        if "::" not in head and not head.endswith(".py"):
+            continue
+        m = _PYTEST_VERBOSE_RE.match(line)
+        if m:
+            name = m.group("name")
+            if "::" in name or name.endswith(".py"):
+                out[name] = m.group("status")
+    return out
+
+
+_GO_TEST_RE = re.compile(r"^\s*---\s+(?P<status>PASS|FAIL|SKIP):\s+(?P<name>\S+)")
+_GO_STATUS = {"PASS": PASSED, "FAIL": FAILED, "SKIP": SKIPPED}
+
+
+def parse_go_test(log: str) -> dict[str, str]:
+    """{test_name -> status} from `go test -v` output."""
+    out: dict[str, str] = {}
+    if not log:
+        return out
+    for raw in log.split("\n"):
+        m = _GO_TEST_RE.match(raw)
+        if m:
+            out[m.group("name")] = _GO_STATUS[m.group("status")]
+    return out
+
+
+# Keep these patterns in sync with log_parsers/cargo_parser.py.
+_CARGO_TEST_RE = re.compile(r"^test\s+(?P<name>\S.*?) \.\.\. (?P<status>ok|FAILED|ignored)\b")
+_CARGO_MODE_RE = re.compile(r" - (?:should panic|compile fail|compile)$")
+_CARGO_DOCTEST_RE = re.compile(r"^(?P<file>\S+) - (?:(?P<item>.+?) )?\(line \d+\)$")
+_CARGO_STATUS = {"ok": PASSED, "FAILED": FAILED, "ignored": SKIPPED}
+_CARGO_DOCTEST_RANK = {SKIPPED: 0, PASSED: 1, FAILED: 2}
+
+
+def parse_cargo_test(log: str) -> dict[str, str]:
+    """{test_name -> status} from `cargo test` output.
+
+    Test modes (` - should panic`) are dropped from names, and doctests are
+    keyed without their `(line N)` so line shifts don't change identity; the
+    worst status among an item's doctests wins.
+    """
+    out: dict[str, str] = {}
+    if not log:
+        return out
+    for raw in log.split("\n"):
+        m = _CARGO_TEST_RE.match(raw)
+        if not m:
+            continue
+        name = _CARGO_MODE_RE.sub("", m.group("name")).rstrip()
+        status = _CARGO_STATUS[m.group("status")]
+        doctest = _CARGO_DOCTEST_RE.match(name)
+        if doctest:
+            item = doctest.group("item")
+            name = f"{doctest.group('file')} - {item}" if item else doctest.group("file")
+            if name in out and _CARGO_DOCTEST_RANK[out[name]] > _CARGO_DOCTEST_RANK[status]:
+                continue
+        out[name] = status
+    return out
+
+
+_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\))?$"
+)
+_JEST_GLYPH = {
+    "✓": PASSED,
+    "√": PASSED,
+    "✕": FAILED,
+    "×": FAILED,
+    "✗": FAILED,
+    "○": 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]:
+    """{test_name -> status} from Jest / Mocha / Vitest output."""
+    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
+    for raw in log.split("\n"):
+        line = raw.rstrip()
+        if not line:
+            continue
+        m = _JEST_FILE_RE.match(line)
+        if m:
+            current_file = m.group("path")
+            describe_stack = []
+            last_test_indent = None
+            continue
+        m = _JEST_TEST_RE.match(line)
+        if m:
+            indent = len(m.group("indent"))
+            name = re.sub(r"^(?:skipped|todo):\s*", "", m.group("name").strip())
+            describes = [d for ind, d in describe_stack if ind < indent]
+            parts = ([current_file] if current_file else []) + describes + [name]
+            out[" > ".join(parts)] = _JEST_GLYPH[m.group("glyph")]
+            last_test_indent = indent
+            continue
+        stripped = line.lstrip()
+        if not stripped or stripped.startswith(
+            ("Tests:", "Test Suites:", "Snapshots:", "Time:", "Ran all", "●", "→", "✗:")
+        ):
+            continue
+        indent_here = len(line) - len(stripped)
+        if current_file and (last_test_indent is None or indent_here < last_test_indent):
+            describe_stack = [(i, d) for i, d in describe_stack if i < indent_here]
+            describe_stack.append((indent_here, stripped))
+    return out
+
+
+def _detect_runner(test_cmds: str) -> str:
+    joined = test_cmds.lower()
+    if "pytest" in joined:
+        return "pytest"
+    if re.search(r"\bgo\s+test\b", joined):
+        return "go"
+    if re.search(r"\bcargo\s+test\b", joined):
+        return "cargo"
+    if any(k in joined for k in ("jest", "mocha", "vitest", "npm test", "yarn test", "pnpm test")):
+        return "jest"
+    return "unknown"
+
+
+def parse_logs(runner: str, log: str) -> dict[str, str]:
+    """Dispatch to the right per-runner parser. Empty dict if unknown."""
+    if runner == "pytest":
+        return parse_pytest(log)
+    if runner == "go":
+        return parse_go_test(log)
+    if runner == "cargo":
+        return parse_cargo_test(log)
+    if runner == "jest":
+        return parse_jest(log)
+    return {}
+
+
+# ---------------------------------------------------------------------------
+# Grading
+# ---------------------------------------------------------------------------
+def _has_go_parent(name: str, status_map: dict[str, str]) -> bool:
+    """Return True if a Go test has an ancestor represented in the status map."""
+    parts = name.split("/")
+
+    for i in range(1, len(parts)):
+        parent = "/".join(parts[:i])
+        if status_map.get(parent) == FAILED:
+            return True
+
+    return False
+
+
+def grade(
+    fail_to_pass: list[str],
+    pass_to_pass: list[str],
+    status_map: dict[str, str],
+    runner: str | None = None,
+) -> dict:
+    """Compute the graded reward + strict resolved bool from a status map.
+
+    f2p_rate   = (# F2P now PASSED) / (# F2P)
+    p2p_rate   = (# P2P still PASSED) / (# P2P)   [1.0 when no P2P]
+    reward     = f2p_rate * p2p_rate                       (dense training signal)
+    resolved   = all F2P pass AND all P2P pass   (SWE-bench TRACKED resolution —
+                 the gold patch always satisfies this, preserving the oracle
+                 invariant)
+
+    Two distinct EVAL signals (see the audit's "tracked vs command resolved"):
+      * `resolved`         — tracked resolution (above). Gold patch -> True.
+      * `command_resolved` — stricter: tracked resolution AND the selected test
+                             command had NO failures outside F2P/P2P AND exit
+                             code 0. Computed in main() where the exit code is
+                             known. A benchmark that wants "the whole command
+                             passed cleanly" gates on this; SWE-bench-style
+                             scoring uses `resolved`.
+
+    `untracked_failed` are FAILED tests in the run that are neither F2P nor
+    P2P (e.g. always-failing/flaky tests pulled in by running a whole test
+    file). They don't change the graded `reward` or tracked `resolved`, but
+    they block `command_resolved` and are recorded for transparency.
+    """
+    f2p_total = len(fail_to_pass)
+    p2p_total = len(pass_to_pass)
+    f2p_set = set(fail_to_pass)
+    p2p_set = set(pass_to_pass)
+    f2p_passed = sum(1 for t in fail_to_pass if status_map.get(t) == PASSED)
+    p2p_passed = sum(1 for t in pass_to_pass if status_map.get(t) == PASSED)
+    # Tests that should have stayed green but regressed (PASS->not-pass).
+    regressions = [t for t in pass_to_pass if status_map.get(t) != PASSED]
+
+    # FAILED tests outside the tracked sets — the selected command isn't clean.
+    if runner == "go":
+        failed_tests = {
+            t
+            for t, s in status_map.items()
+            if s == FAILED and t not in f2p_set and t not in p2p_set
+        }
+
+        untracked_failed = sorted(t for t in failed_tests if not _has_go_parent(t, status_map))
+    else:
+        untracked_failed = sorted(
+            t
+            for t, s in status_map.items()
+            if s == FAILED and t not in f2p_set and t not in p2p_set
+        )
+
+    f2p_rate = (f2p_passed / f2p_total) if f2p_total else 0.0
+    p2p_rate = (p2p_passed / p2p_total) if p2p_total else 1.0
+    reward = f2p_rate * p2p_rate
+    resolved = f2p_total > 0 and f2p_passed == f2p_total and p2p_passed == p2p_total
+
+    return {
+        "reward": round(max(0.0, min(1.0, reward)), 6),
+        "resolved": resolved,
+        "f2p_total": f2p_total,
+        "f2p_passed": f2p_passed,
+        "f2p_rate": round(f2p_rate, 6),
+        "p2p_total": p2p_total,
+        "p2p_passed": p2p_passed,
+        "p2p_rate": round(p2p_rate, 6),
+        "regressions": sorted(regressions),
+        "untracked_failed_count": len(untracked_failed),
+        "untracked_failed": untracked_failed[:20],  # cap the list
+    }
+
+
+# ---------------------------------------------------------------------------
+# Entry point (invoked by tests/test.sh inside the container)
+# ---------------------------------------------------------------------------
+
+
+def _read_json_list(path: str) -> list[str]:
+    try:
+        with open(path, encoding="utf-8") as f:
+            data = json.load(f)
+        return [str(x) for x in data] if isinstance(data, list) else []
+    except (OSError, ValueError):
+        return []
+
+
+def _read_text(path: str) -> str:
+    try:
+        with open(path, encoding="utf-8") as f:
+            return f.read()
+    except (OSError, UnicodeDecodeError):
+        return ""
+
+
+def main(argv: list[str] | None = None) -> int:
+    p = argparse.ArgumentParser(description="pr_runtime graded F2P/P2P verifier")
+    p.add_argument("--log", required=True, help="captured test-run log file")
+    p.add_argument("--f2p", required=True, help="JSON file: FAIL_TO_PASS test names")
+    p.add_argument("--p2p", required=True, help="JSON file: PASS_TO_PASS test names")
+    p.add_argument("--runner", default="", help="pytest|go|cargo|jest (else auto-detect)")
+    p.add_argument("--test-cmds", default="", help="test command string (runner auto-detect)")
+    p.add_argument("--exit-code", type=int, default=1, help="test suite exit code (fallback)")
+    p.add_argument("--out-dir", default="/logs/verifier", help="where to write reward.{txt,json}")
+    args = p.parse_args(argv)
+
+    log = _read_text(args.log)
+    f2p = _read_json_list(args.f2p)
+    p2p = _read_json_list(args.p2p)
+    runner = args.runner.strip() or _detect_runner(args.test_cmds)
+
+    status_map = parse_logs(runner, log)
+
+    if not status_map:
+        # Unparseable runner output → fall back to the binary exit-code reward
+        # (a coarse TRAINING signal) so we never silently zero a real fix on an
+        # unrecognized format. But `resolved` is the strict EVAL signal: without
+        # parsed per-test status we have NO evidence the declared FAIL_TO_PASS
+        # tests passed, so when an F2P oracle exists we must NOT claim resolved.
+        # (resolved stays exit-code-based only when there's no declared oracle,
+        # e.g. --skip-validation.)
+        reward = 1.0 if args.exit_code == 0 else 0.0
+        has_oracle = len(f2p) > 0
+        resolved = (args.exit_code == 0) and not has_oracle
+        breakdown = {
+            "reward": reward,
+            "resolved": resolved,
+            "command_resolved": bool(resolved and args.exit_code == 0),
+            "parse_status": "fallback_exitcode",
+            "eval_trustworthy": not has_oracle,
+            "runner": runner,
+            "f2p_total": len(f2p),
+            "p2p_total": len(p2p),
+            "exit_code": args.exit_code,
+        }
+    else:
+        breakdown = grade(f2p, p2p, status_map, runner)
+        breakdown["parse_status"] = "ok"
+        breakdown["runner"] = runner
+        breakdown["tests_parsed"] = len(status_map)
+        breakdown["exit_code"] = args.exit_code
+        # Strict eval signal: tracked resolution AND a clean command (no
+        # untracked failures, exit code 0). Benchmarks wanting "the whole test
+        # command passed" gate on this; SWE-bench-style scoring uses `resolved`.
+        breakdown["command_resolved"] = bool(
+            breakdown["resolved"]
+            and breakdown["untracked_failed_count"] == 0
+            and args.exit_code == 0
+        )
+        reward = breakdown["reward"]
+
+    os.makedirs(args.out_dir, exist_ok=True)
+    with open(os.path.join(args.out_dir, "reward.txt"), "w", encoding="utf-8") as f:
+        f.write(f"{reward:.6f}\n")
+    with open(os.path.join(args.out_dir, "reward-details.json"), "w", encoding="utf-8") as f:
+        json.dump(breakdown, f, indent=2)
+
+    print(json.dumps(breakdown, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
+
+
+__all__ = [
+    "grade",
+    "main",
+    "parse_cargo_test",
+    "parse_go_test",
+    "parse_jest",
+    "parse_logs",
+    "parse_pytest",
+]

heldout_pool/cx-lukas-salkauskas-x__InAppPy-5cbdd002e4eb/environment/Dockerfile

@@ -0,0 +1,36 @@
+# Auto-generated by Repo2RLEnv pr_runtime
+FROM local/cx-lukas-salkauskas-x__InAppPy
+WORKDIR /workspace
+# Defensive: ensure git is on PATH at build time. Bootstrap base
+# images vary — some (Python slim) don't ship git; some agents
+# install it; others don't. Re-installing is a no-op when already
+# present. Tries apt-get first (Debian/Ubuntu), then apk (Alpine).
+# Install git + ca-certificates. Minimal images (node:alpine) ship
+# without CA certs, so HTTPS git fetch fails verification.
+RUN (command -v git >/dev/null 2>&1 && [ -e /etc/ssl/certs/ca-certificates.crt ]) || \
+    (apt-get update && apt-get install -y --no-install-recommends git ca-certificates \
+     && rm -rf /var/lib/apt/lists/*) || \
+    (apk add --no-cache git ca-certificates && update-ca-certificates) || true
+# Defensive: the graded F2P/P2P verifier is Python.
+# Language-specific bootstrap images (Go/Rust/Node) may not
+# ship python3 — install it so test.sh can score F2P/P2P. No-op when
+# python3 is already present (every Python-repo image has it).
+RUN command -v python3 >/dev/null 2>&1 || \
+    (apt-get update && apt-get install -y --no-install-recommends python3 \
+     && rm -rf /var/lib/apt/lists/*) || \
+    apk add --no-cache python3 || true
+# Position the working tree at the PR's base commit so subsequent
+# model-patch applications align with the line context the patch
+# was authored against. The fetch is a no-op if the commit is
+# already in the shallow clone.
+RUN git config --global --add safe.directory /workspace \
+    && git fetch --depth 1 origin 4c6d971b70b62e94d43944062c72590a8e1db313 2>/dev/null \
+       || git fetch --unshallow origin 2>/dev/null || true
+RUN git reset --hard 4c6d971b70b62e94d43944062c72590a8e1db313 && git clean -fdx -e .venv -e venv -e __pycache__ -e .tox -e node_modules -e target -e vendor -e .gradle -e .next -e .pytest_cache
+RUN git checkout -q -B base 4c6d971b70b62e94d43944062c72590a8e1db313 \
+    && git remote remove origin 2>/dev/null || true
+RUN for ref in $(git branch --format='%(refname:short)' | grep -vx base); do git branch -D "$ref" 2>/dev/null || true; done \
+    && git tag -l | xargs -r git tag -d >/dev/null 2>&1 || true \
+    && git for-each-ref --format='%(refname)' refs/remotes 2>/dev/null | xargs -r -n1 git update-ref -d 2>/dev/null || true \
+    && git reflog expire --expire=now --all 2>/dev/null || true \
+    && git gc --prune=now 2>/dev/null || true

heldout_pool/cx-lukas-salkauskas-x__InAppPy-5cbdd002e4eb/environment/docker-compose.yaml

@@ -0,0 +1,16 @@
+# Auto-generated by Repo2RLEnv: anti-contamination egress guard.
+# Blackholes the hosts that serve this repo's published fix and hidden
+# tests, so an agent cannot fetch the answer (pip download / git fetch /
+# WebFetch against these fail). General internet stays up so the agent
+# can install itself and reach its model API. See pipelines/_env_guard.py.
+services:
+  main:
+    extra_hosts:
+      - "pypi.org:0.0.0.0"
+      - "pypi.python.org:0.0.0.0"
+      - "files.pythonhosted.org:0.0.0.0"
+      - "github.com:0.0.0.0"
+      - "api.github.com:0.0.0.0"
+      - "raw.githubusercontent.com:0.0.0.0"
+      - "codeload.github.com:0.0.0.0"
+      - "objects.githubusercontent.com:0.0.0.0"

heldout_pool/cx-lukas-salkauskas-x__InAppPy-5cbdd002e4eb/instruction.md

@@ -0,0 +1,10 @@
+# Issue
+
+**Title:** Requests fail immediately when targeting the wrong environment
+## Description
+When a request is made that targets an incorrect environment, the operation fails outright. This forces users to manually re-initiate the request after identifying and correcting the environment.
+Expected behavior: The system should automatically detect requests targeting the wrong environment and attempt to retry them, potentially after adjusting to the correct environment.
+
+## Task
+
+Modify the repository so that the issue described above is resolved. The task's test suite verifies your patch by applying it on top of the base commit `4c6d971b70b6` and running the modified tests.

heldout_pool/cx-lukas-salkauskas-x__InAppPy-5cbdd002e4eb/solution/patch.diff

@@ -0,0 +1,107 @@
+diff --git a/inapppy/appstore.py b/inapppy/appstore.py
+index 84bbc2e..96599c1 100644
+--- a/inapppy/appstore.py
++++ b/inapppy/appstore.py
+@@ -3,7 +3,8 @@ from inapppy.errors import InAppPyValidationError
+ from requests.exceptions import RequestException
+ import requests
+ 
+-
++# https://developer.apple.com/library/content/releasenotes/General/ValidateAppStoreReceipt/Chapters/ValidateRemotely.html
++# `Table 2-1  Status codes`
+ api_result_ok = 0
+ api_result_errors = {
+     21000: InAppPyValidationError('Bad json'),
+@@ -12,6 +13,8 @@ api_result_errors = {
+     21004: InAppPyValidationError('Shared secret mismatch'),
+     21005: InAppPyValidationError('Server is unavailable'),
+     21006: InAppPyValidationError('Subscription has expired'),
++
++    # two following errors can use auto_retry_wrong_env_request.
+     21007: InAppPyValidationError('Sandbox receipt was sent to the production env'),
+     21008: InAppPyValidationError('Production receipt was sent to the sandbox env'),
+ }
+@@ -21,14 +24,23 @@ class AppStoreValidator(object):
+     bundle_id = None
+     sandbox = None
+     url = None
++    auto_retry_wrong_env_request = False
+ 
+-    def __init__(self, bundle_id, sandbox=False):
++    def __init__(self, bundle_id, sandbox=False, auto_retry_wrong_env_request=False):
++        """ Constructor for AppStoreValidator
++
++        :param bundle_id: apple bundle id
++        :param sandbox: sandbox mode ?
++        :param auto_retry_wrong_env_request: auto retry on wrong env ?
++        """
+         self.bundle_id = bundle_id
+         self.sandbox = sandbox
+ 
+         if not self.bundle_id:
+             raise InAppPyValidationError('`bundle_id` cannot be empty')
+ 
++        self.auto_retry_wrong_env_request = auto_retry_wrong_env_request
++
+         self._change_url_by_sandbox()
+ 
+     def _change_url_by_sandbox(self):
+@@ -38,21 +50,35 @@ class AppStoreValidator(object):
+     def post_json(self, request_json):
+         self._change_url_by_sandbox()
+ 
+-        return requests.post(self.url, json=request_json).json()
+-
+-    def validate(self, receipt, shared_secret=None):
+-        receipt_json = {'receipt-data': receipt}
+-
+-        # if shared secret is provided, attach it as `password`.
+-        if shared_secret:
+-            receipt_json['password'] = shared_secret
+-
+         try:
+-            api_response = self.post_json(receipt_json)
++            return requests.post(self.url, json=request_json).json()
+         except (ValueError, RequestException):
+             raise InAppPyValidationError('HTTP error')
+ 
++    def validate(self, receipt, shared_secret=None):
++        """ Validates receipt against apple services.
++
++        :param receipt: receipt
++        :param shared_secret: optional shared secret.
++        :return: validation result or exception.
++        """
++        receipt_json = {'receipt-data': receipt}
++
++        if shared_secret:
++            receipt_json['password'] = shared_secret
++
++        # Do a request.
++        api_response = self.post_json(receipt_json)
+         status = api_response['status']
++
++        # Check retry case.
++        if self.auto_retry_wrong_env_request and status in [21007, 21008]:
++            # switch environment
++            self.sandbox = not self.sandbox
++
++            api_response = self.post_json(receipt_json)
++            status = api_response['status']
++
+         if status != api_result_ok:
+             error = api_result_errors.get(status, InAppPyValidationError('Unknown API status'))
+             error.raw_response = api_response
+diff --git a/setup.py b/setup.py
+index 8fab1fd..df0ca90 100644
+--- a/setup.py
++++ b/setup.py
+@@ -3,7 +3,7 @@ from setuptools import setup
+ 
+ setup(
+     name='inapppy',
+-    version='0.4',
++    version='0.5',
+     packages=['inapppy'],
+     install_requires=['rsa', 'requests'],
+     description="In-app purchase validation library for Apple AppStore and GooglePlay.",

heldout_pool/cx-lukas-salkauskas-x__InAppPy-5cbdd002e4eb/solution/solve.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+set -euxo pipefail
+cd /workspace
+git config --global --add safe.directory /workspace
+PATCH="$(dirname "$0")/patch.diff"
+git apply --verbose --reject "$PATCH"

heldout_pool/cx-lukas-salkauskas-x__InAppPy-5cbdd002e4eb/task.toml

@@ -0,0 +1,81 @@
+version = "1.0"
+
+[task]
+name = "commit-runtime/cx-lukas-salkauskas-x__InAppPy-5cbdd002e4eb"
+description = "added ability to auto retry on wrong environment request."
+
+[metadata]
+difficulty = "medium"
+category = "bugfix"
+keywords = [
+    "InAppPy",
+    "commit_runtime",
+]
+
+[metadata.repo2env]
+pipeline = "commit_runtime"
+pipeline_version = "0.8.3"
+repo = "cx-lukas-salkauskas-x/InAppPy"
+ref = "4c6d971b70b62e94d43944062c72590a8e1db313"
+reference = "https://github.com/cx-lukas-salkauskas-x/InAppPy/commit/5cbdd002e4eb1adb0f5055e0ef1bf3374c6132d4"
+source_access = "public"
+built_at = "2026-09-24T13:11:52.992916+00:00"
+synthesis_llm = "gemini/gemini-2.5-flash"
+reward_kinds = [
+    "test_execution",
+    "diff_similarity",
+]
+spec_version = "0.2.0"
+content_hash = "sha256:dc3b8939fe1a87f177810dfd7b49f937a486acbfae8cb5ed52cac5c8a02bc94e"
+
+[metadata.repo2env.commit_runtime]
+commit_sha = "5cbdd002e4eb1adb0f5055e0ef1bf3374c6132d4"
+parent_sha = "4c6d971b70b62e94d43944062c72590a8e1db313"
+authored_at = "2017-02-07T13:21:59+02:00"
+author_email = "halfas.online@gmail.com"
+subject = "added ability to auto retry on wrong environment request."
+fail_to_pass = [
+    "tests/test_appstore.py::test_appstore_auto_retry_wrong_env_request",
+]
+pass_to_pass = [
+    "tests/test_appstore.py::test_appstore_validate_attach_raw_response_to_the_exception",
+    "tests/test_appstore.py::test_appstore_validate_sandbox",
+    "tests/test_appstore.py::test_appstore_validate_simple",
+    "tests/test_appstore.py::test_appstore_validator_initiation_raises_if_no_bundle_id",
+    "tests/test_appstore.py::test_appstore_validator_initiation_sandbox",
+    "tests/test_appstore.py::test_appstore_validator_initiation_simple",
+]
+validation_status = "verified"
+bootstrap_image = "local-venv:cx-lukas-salkauskas-x__InAppPy"
+instruction_synthesized = true
+llm_cost_usd = 0.0
+
+[metadata.repo2env.reward_calibration]
+f2p_count = 1
+p2p_count = 6
+source_files = 2
+loc_changed = 52
+difficulty = "medium"
+
+[metadata.repo2env.evaluation]
+schema_version = "1"
+status = "unverified"
+stage = "generation"
+reason_codes = [
+    "validation_not_run",
+]
+detail = "Generated task; validation has not been established."
+provenance = "unknown"
+evidence = []
+
+[metadata.repo2env.reproducibility]
+mode = "local_only"
+image_ref = "local/cx-lukas-salkauskas-x__InAppPy"
+image_tag = "local/cx-lukas-salkauskas-x__InAppPy"
+image_visibility = "private"
+
+[agent]
+timeout_sec = 1800.0
+
+[verifier]
+timeout_sec = 300.0

heldout_pool/cx-lukas-salkauskas-x__InAppPy-5cbdd002e4eb/tests/f2p.json

@@ -0,0 +1,3 @@
+[
+  "tests/test_appstore.py::test_appstore_auto_retry_wrong_env_request"
+]

heldout_pool/cx-lukas-salkauskas-x__InAppPy-5cbdd002e4eb/tests/p2p.json

@@ -0,0 +1,8 @@
+[
+  "tests/test_appstore.py::test_appstore_validate_attach_raw_response_to_the_exception",
+  "tests/test_appstore.py::test_appstore_validate_sandbox",
+  "tests/test_appstore.py::test_appstore_validate_simple",
+  "tests/test_appstore.py::test_appstore_validator_initiation_raises_if_no_bundle_id",
+  "tests/test_appstore.py::test_appstore_validator_initiation_sandbox",
+  "tests/test_appstore.py::test_appstore_validator_initiation_simple"
+]

heldout_pool/cx-lukas-salkauskas-x__InAppPy-5cbdd002e4eb/tests/test.sh

@@ -0,0 +1,57 @@
+#!/bin/bash
+set -uxo pipefail
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+cd /workspace
+git config --global --add safe.directory /workspace
+mkdir -p /logs/verifier
+git checkout 4c6d971b70b62e94d43944062c72590a8e1db313 -- tests/test_appstore.py || true
+git apply --verbose --reject - <<'EOF_R2E_TEST_PATCH'
+diff --git a/tests/test_appstore.py b/tests/test_appstore.py
+index b75ef19..4605e52 100644
+--- a/tests/test_appstore.py
++++ b/tests/test_appstore.py
+@@ -70,3 +70,29 @@ def test_appstore_validate_attach_raw_response_to_the_exception():
+             assert mock_method.call_args[0][0] == {'receipt-data': 'test-receipt', 'password': 'shared-secret'}
+             assert ex.raw_response is not None
+             assert ex.raw_response == raw_response
++
++
++def test_appstore_auto_retry_wrong_env_request():
++    validator = AppStoreValidator(bundle_id='test-bundle-id', sandbox=False, auto_retry_wrong_env_request=True)
++    assert validator is not None
++    assert not validator.sandbox
++    assert validator.auto_retry_wrong_env_request
++
++    raw_response = {'status': 21007, 'foo': 'bar'}
++    with pytest.raises(InAppPyValidationError):
++        with patch.object(AppStoreValidator, 'post_json', return_value=raw_response) as mock_method:
++            validator.validate(receipt='test-receipt', shared_secret='shared-secret')
++            assert mock_method.call_count == 1
++            assert validator.url == 'https://buy.itunes.apple.com/verifyReceipt'
++            assert mock_method.call_args[0][0] == {'receipt-data': 'test-receipt', 'password': 'shared-secret'}
++            assert validator.sandbox is True
++
++    raw_response = {'status': 21008, 'foo': 'bar'}
++    with pytest.raises(InAppPyValidationError):
++        with patch.object(AppStoreValidator, 'post_json', return_value=raw_response) as mock_method:
++            validator.validate(receipt='test-receipt', shared_secret='shared-secret')
++            assert validator.sandbox is False
++            assert mock_method.call_count == 1
++            assert validator.url == 'https://buy.itunes.apple.com/verifyReceipt'
++            assert mock_method.call_args[0][0] == {'receipt-data': 'test-receipt', 'password': 'shared-secret'}
++
+
+EOF_R2E_TEST_PATCH
+R2E_APPLY_RC=$?
+if [ "$R2E_APPLY_RC" -ne 0 ]; then
+  echo "0.000000" > /logs/verifier/reward.txt
+  printf '%s' '{"reward": 0.0, "resolved": false, "parse_status": "test_patch_apply_failed"}' > /logs/verifier/reward-details.json
+  echo "R2E: test_patch failed to apply (rc=$R2E_APPLY_RC) — failing closed" >&2
+  exit 0
+fi
+( python -m pytest -v tests/test_appstore.py ) > /logs/verifier/test_output.log 2>&1
+TEST_EXIT_CODE=$?
+cat /logs/verifier/test_output.log
+python3 "$SCRIPT_DIR/verifier.py" --log /logs/verifier/test_output.log --f2p "$SCRIPT_DIR/f2p.json" --p2p "$SCRIPT_DIR/p2p.json" --test-cmds 'python -m pytest -v tests/test_appstore.py' --exit-code "$TEST_EXIT_CODE" --out-dir /logs/verifier || { [ "$TEST_EXIT_CODE" -eq 0 ] && echo "1.0" > /logs/verifier/reward.txt || echo "0.0" > /logs/verifier/reward.txt; }
+git checkout 4c6d971b70b62e94d43944062c72590a8e1db313 -- tests/test_appstore.py || true
+exit 0

heldout_pool/cx-lukas-salkauskas-x__InAppPy-5cbdd002e4eb/tests/verifier.py

@@ -0,0 +1,475 @@
+"""In-container verifier for pr_runtime tasks (graded F2P/P2P reward).
+
+This module is the **standalone verifier** that runs inside the task's
+Docker container, NOT a helper used at generation time. It is read as
+source at generation time, base64-encoded, and embedded into
+``tests/test.sh``. At run time the container decodes it back to a file
+and invokes it after the test suite has run.
+
+Why a graded reward instead of binary pass/fail
+------------------------------------------------
+SWE-bench resolution is binary: a patch "resolves" the issue iff ALL
+FAIL_TO_PASS tests pass AND ALL PASS_TO_PASS tests still pass. That's
+the right signal for an eval leaderboard, but a terrible gradient for
+RL training — an agent that fixes 4 of 5 failing tests scores the same
+0.0 as one that fixes nothing.
+
+So this verifier emits BOTH:
+  * /logs/verifier/reward.txt  — the GRADED scalar (training signal,
+        which Harbor reads):  reward = f2p_rate * p2p_factor
+  * /logs/verifier/reward-details.json — carries the strict SWE-bench
+        ``resolved`` bool (eval signal) PLUS the full breakdown.
+
+Refs: SWE-bench (F2P/P2P semantics), SWE-RL / SWE-Gym (dense reward for
+RL), UTBoost (weak-test coverage lets wrong patches pass — hence we
+record p2p_count so consumers can judge regression-guard strength).
+
+Scoring
+-------
+Given the baked FAIL_TO_PASS / PASS_TO_PASS test-name lists (computed by
+the generation-time two-stage validation) and the agent-run test log:
+
+  f2p_rate   = (# F2P tests now PASSED) / (# F2P tests)
+  p2p_rate   = (# P2P tests still PASSED) / (# P2P tests)   [1.0 if no P2P]
+  p2p_factor = p2p_rate          # regressions scale the reward down
+  reward     = f2p_rate * p2p_factor
+  resolved   = (all F2P pass) AND (all P2P pass)            # strict SWE-bench
+
+Oracle invariant: the gold patch flips every F2P and keeps every P2P,
+so f2p_rate=1.0, p2p_rate=1.0 -> reward=1.0 and resolved=True. This is
+what the T3 oracle gate (reward == 1.0) relies on.
+
+Graceful degradation: if the log can't be parsed into per-test
+statuses (unrecognized runner output), fall back to the exit-code
+reward (1.0 if the suite exited 0, else 0.0) and stamp
+``parse_status="fallback_exitcode"`` — never crash, never silently
+zero out a real fix.
+
+Pure stdlib — uses only ``argparse``, ``json``, ``os``, ``re``, ``sys``.
+The 4 per-runner parsers are condensed ports of
+``repo2rlenv.log_parsers.*`` kept in lockstep via the unit tests under
+``tests/test_pr_runtime_verifier.py``.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import sys
+
+# Canonical statuses. (Plain strings — no typing.Literal so the baked
+# module stays import-light when decoded standalone in the container.)
+PASSED = "PASSED"
+FAILED = "FAILED"
+SKIPPED = "SKIPPED"
+ERROR = "ERROR"
+
+# ---------------------------------------------------------------------------
+# Per-runner log parsers (condensed ports of repo2rlenv.log_parsers.*)
+# ---------------------------------------------------------------------------
+
+_PYTEST_STATUSES = (PASSED, FAILED, SKIPPED, ERROR)
+# Keep these patterns in sync with log_parsers/pytest_parser.py. This module
+# also runs standalone inside task containers, without a repo2rlenv install.
+_PYTEST_PROGRESS = (
+    r"\[\s*\d+%\]|\[\s*\d+\s*/\s*\d+\s*\]"
+    r"|\d+(?:\.\d+)?(?:us|ms|s)|\d+m \d+s|\d+h \d+m"
+)
+_PYTEST_VERBOSE_RE = re.compile(
+    r"^(?P<name>.+?(?:\[.*?\])?)\s+(?P<status>PASSED|FAILED|SKIPPED|ERROR)"
+    rf"(?:\s+\(.*\))?(?:\s+(?:{_PYTEST_PROGRESS}))?$"
+)
+_PYTEST_SUMMARY_NAME_RE = re.compile(r"^(?P<name>.+?(?:\[.*?\])?)(?: - .*)?$")
+# pytest-xdist worker label, e.g. `[gw1] [ 20%] PASSED tests/foo.py::test_x`.
+_PYTEST_XDIST_PREFIX_RE = re.compile(rf"^\[gw\d+\]\s+(?:(?:{_PYTEST_PROGRESS})\s+)?")
+
+
+def parse_pytest(log: str) -> dict[str, str]:
+    """{test_name -> status} from pytest output (verbose or summary)."""
+    out: dict[str, str] = {}
+    if not log:
+        return out
+    for raw in log.split("\n"):
+        line = raw.strip()
+        if not line:
+            continue
+        line = _PYTEST_XDIST_PREFIX_RE.sub("", line, count=1)
+        # Summary lines (STATUS first), preserving the full node ID.
+        leading = None
+        for st in _PYTEST_STATUSES:
+            if line.startswith(st + " ") or line == st:
+                leading = st
+                break
+        if leading is not None:
+            work = line[len(leading) :].strip()
+            if leading == SKIPPED and re.match(r"^\[\d+\](?:\s|$)", work):
+                # Folded skips report a file location, not a parametrized ID.
+                tokens = work.split(maxsplit=2)
+                if len(tokens) < 2:
+                    continue
+                out[tokens[1]] = leading
+            elif m := _PYTEST_SUMMARY_NAME_RE.match(work):
+                out[m.group("name")] = leading
+            continue
+        # Verbose progress (NAME first, STATUS after)
+        # Filter non-test output before attempting the backtracking regex.
+        head = line.split(None, 1)[0]
+        if "::" not in head and not head.endswith(".py"):
+            continue
+        m = _PYTEST_VERBOSE_RE.match(line)
+        if m:
+            name = m.group("name")
+            if "::" in name or name.endswith(".py"):
+                out[name] = m.group("status")
+    return out
+
+
+_GO_TEST_RE = re.compile(r"^\s*---\s+(?P<status>PASS|FAIL|SKIP):\s+(?P<name>\S+)")
+_GO_STATUS = {"PASS": PASSED, "FAIL": FAILED, "SKIP": SKIPPED}
+
+
+def parse_go_test(log: str) -> dict[str, str]:
+    """{test_name -> status} from `go test -v` output."""
+    out: dict[str, str] = {}
+    if not log:
+        return out
+    for raw in log.split("\n"):
+        m = _GO_TEST_RE.match(raw)
+        if m:
+            out[m.group("name")] = _GO_STATUS[m.group("status")]
+    return out
+
+
+# Keep these patterns in sync with log_parsers/cargo_parser.py.
+_CARGO_TEST_RE = re.compile(r"^test\s+(?P<name>\S.*?) \.\.\. (?P<status>ok|FAILED|ignored)\b")
+_CARGO_MODE_RE = re.compile(r" - (?:should panic|compile fail|compile)$")
+_CARGO_DOCTEST_RE = re.compile(r"^(?P<file>\S+) - (?:(?P<item>.+?) )?\(line \d+\)$")
+_CARGO_STATUS = {"ok": PASSED, "FAILED": FAILED, "ignored": SKIPPED}
+_CARGO_DOCTEST_RANK = {SKIPPED: 0, PASSED: 1, FAILED: 2}
+
+
+def parse_cargo_test(log: str) -> dict[str, str]:
+    """{test_name -> status} from `cargo test` output.
+
+    Test modes (` - should panic`) are dropped from names, and doctests are
+    keyed without their `(line N)` so line shifts don't change identity; the
+    worst status among an item's doctests wins.
+    """
+    out: dict[str, str] = {}
+    if not log:
+        return out
+    for raw in log.split("\n"):
+        m = _CARGO_TEST_RE.match(raw)
+        if not m:
+            continue
+        name = _CARGO_MODE_RE.sub("", m.group("name")).rstrip()
+        status = _CARGO_STATUS[m.group("status")]
+        doctest = _CARGO_DOCTEST_RE.match(name)
+        if doctest:
+            item = doctest.group("item")
+            name = f"{doctest.group('file')} - {item}" if item else doctest.group("file")
+            if name in out and _CARGO_DOCTEST_RANK[out[name]] > _CARGO_DOCTEST_RANK[status]:
+                continue
+        out[name] = status
+    return out
+
+
+_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\))?$"
+)
+_JEST_GLYPH = {
+    "✓": PASSED,
+    "√": PASSED,
+    "✕": FAILED,
+    "×": FAILED,
+    "✗": FAILED,
+    "○": 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]:
+    """{test_name -> status} from Jest / Mocha / Vitest output."""
+    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
+    for raw in log.split("\n"):
+        line = raw.rstrip()
+        if not line:
+            continue
+        m = _JEST_FILE_RE.match(line)
+        if m:
+            current_file = m.group("path")
+            describe_stack = []
+            last_test_indent = None
+            continue
+        m = _JEST_TEST_RE.match(line)
+        if m:
+            indent = len(m.group("indent"))
+            name = re.sub(r"^(?:skipped|todo):\s*", "", m.group("name").strip())
+            describes = [d for ind, d in describe_stack if ind < indent]
+            parts = ([current_file] if current_file else []) + describes + [name]
+            out[" > ".join(parts)] = _JEST_GLYPH[m.group("glyph")]
+            last_test_indent = indent
+            continue
+        stripped = line.lstrip()
+        if not stripped or stripped.startswith(
+            ("Tests:", "Test Suites:", "Snapshots:", "Time:", "Ran all", "●", "→", "✗:")
+        ):
+            continue
+        indent_here = len(line) - len(stripped)
+        if current_file and (last_test_indent is None or indent_here < last_test_indent):
+            describe_stack = [(i, d) for i, d in describe_stack if i < indent_here]
+            describe_stack.append((indent_here, stripped))
+    return out
+
+
+def _detect_runner(test_cmds: str) -> str:
+    joined = test_cmds.lower()
+    if "pytest" in joined:
+        return "pytest"
+    if re.search(r"\bgo\s+test\b", joined):
+        return "go"
+    if re.search(r"\bcargo\s+test\b", joined):
+        return "cargo"
+    if any(k in joined for k in ("jest", "mocha", "vitest", "npm test", "yarn test", "pnpm test")):
+        return "jest"
+    return "unknown"
+
+
+def parse_logs(runner: str, log: str) -> dict[str, str]:
+    """Dispatch to the right per-runner parser. Empty dict if unknown."""
+    if runner == "pytest":
+        return parse_pytest(log)
+    if runner == "go":
+        return parse_go_test(log)
+    if runner == "cargo":
+        return parse_cargo_test(log)
+    if runner == "jest":
+        return parse_jest(log)
+    return {}
+
+
+# ---------------------------------------------------------------------------
+# Grading
+# ---------------------------------------------------------------------------
+def _has_go_parent(name: str, status_map: dict[str, str]) -> bool:
+    """Return True if a Go test has an ancestor represented in the status map."""
+    parts = name.split("/")
+
+    for i in range(1, len(parts)):
+        parent = "/".join(parts[:i])
+        if status_map.get(parent) == FAILED:
+            return True
+
+    return False
+
+
+def grade(
+    fail_to_pass: list[str],
+    pass_to_pass: list[str],
+    status_map: dict[str, str],
+    runner: str | None = None,
+) -> dict:
+    """Compute the graded reward + strict resolved bool from a status map.
+
+    f2p_rate   = (# F2P now PASSED) / (# F2P)
+    p2p_rate   = (# P2P still PASSED) / (# P2P)   [1.0 when no P2P]
+    reward     = f2p_rate * p2p_rate                       (dense training signal)
+    resolved   = all F2P pass AND all P2P pass   (SWE-bench TRACKED resolution —
+                 the gold patch always satisfies this, preserving the oracle
+                 invariant)
+
+    Two distinct EVAL signals (see the audit's "tracked vs command resolved"):
+      * `resolved`         — tracked resolution (above). Gold patch -> True.
+      * `command_resolved` — stricter: tracked resolution AND the selected test
+                             command had NO failures outside F2P/P2P AND exit
+                             code 0. Computed in main() where the exit code is
+                             known. A benchmark that wants "the whole command
+                             passed cleanly" gates on this; SWE-bench-style
+                             scoring uses `resolved`.
+
+    `untracked_failed` are FAILED tests in the run that are neither F2P nor
+    P2P (e.g. always-failing/flaky tests pulled in by running a whole test
+    file). They don't change the graded `reward` or tracked `resolved`, but
+    they block `command_resolved` and are recorded for transparency.
+    """
+    f2p_total = len(fail_to_pass)
+    p2p_total = len(pass_to_pass)
+    f2p_set = set(fail_to_pass)
+    p2p_set = set(pass_to_pass)
+    f2p_passed = sum(1 for t in fail_to_pass if status_map.get(t) == PASSED)
+    p2p_passed = sum(1 for t in pass_to_pass if status_map.get(t) == PASSED)
+    # Tests that should have stayed green but regressed (PASS->not-pass).
+    regressions = [t for t in pass_to_pass if status_map.get(t) != PASSED]
+
+    # FAILED tests outside the tracked sets — the selected command isn't clean.
+    if runner == "go":
+        failed_tests = {
+            t
+            for t, s in status_map.items()
+            if s == FAILED and t not in f2p_set and t not in p2p_set
+        }
+
+        untracked_failed = sorted(t for t in failed_tests if not _has_go_parent(t, status_map))
+    else:
+        untracked_failed = sorted(
+            t
+            for t, s in status_map.items()
+            if s == FAILED and t not in f2p_set and t not in p2p_set
+        )
+
+    f2p_rate = (f2p_passed / f2p_total) if f2p_total else 0.0
+    p2p_rate = (p2p_passed / p2p_total) if p2p_total else 1.0
+    reward = f2p_rate * p2p_rate
+    resolved = f2p_total > 0 and f2p_passed == f2p_total and p2p_passed == p2p_total
+
+    return {
+        "reward": round(max(0.0, min(1.0, reward)), 6),
+        "resolved": resolved,
+        "f2p_total": f2p_total,
+        "f2p_passed": f2p_passed,
+        "f2p_rate": round(f2p_rate, 6),
+        "p2p_total": p2p_total,
+        "p2p_passed": p2p_passed,
+        "p2p_rate": round(p2p_rate, 6),
+        "regressions": sorted(regressions),
+        "untracked_failed_count": len(untracked_failed),
+        "untracked_failed": untracked_failed[:20],  # cap the list
+    }
+
+
+# ---------------------------------------------------------------------------
+# Entry point (invoked by tests/test.sh inside the container)
+# ---------------------------------------------------------------------------
+
+
+def _read_json_list(path: str) -> list[str]:
+    try:
+        with open(path, encoding="utf-8") as f:
+            data = json.load(f)
+        return [str(x) for x in data] if isinstance(data, list) else []
+    except (OSError, ValueError):
+        return []
+
+
+def _read_text(path: str) -> str:
+    try:
+        with open(path, encoding="utf-8") as f:
+            return f.read()
+    except (OSError, UnicodeDecodeError):
+        return ""
+
+
+def main(argv: list[str] | None = None) -> int:
+    p = argparse.ArgumentParser(description="pr_runtime graded F2P/P2P verifier")
+    p.add_argument("--log", required=True, help="captured test-run log file")
+    p.add_argument("--f2p", required=True, help="JSON file: FAIL_TO_PASS test names")
+    p.add_argument("--p2p", required=True, help="JSON file: PASS_TO_PASS test names")
+    p.add_argument("--runner", default="", help="pytest|go|cargo|jest (else auto-detect)")
+    p.add_argument("--test-cmds", default="", help="test command string (runner auto-detect)")
+    p.add_argument("--exit-code", type=int, default=1, help="test suite exit code (fallback)")
+    p.add_argument("--out-dir", default="/logs/verifier", help="where to write reward.{txt,json}")
+    args = p.parse_args(argv)
+
+    log = _read_text(args.log)
+    f2p = _read_json_list(args.f2p)
+    p2p = _read_json_list(args.p2p)
+    runner = args.runner.strip() or _detect_runner(args.test_cmds)
+
+    status_map = parse_logs(runner, log)
+
+    if not status_map:
+        # Unparseable runner output → fall back to the binary exit-code reward
+        # (a coarse TRAINING signal) so we never silently zero a real fix on an
+        # unrecognized format. But `resolved` is the strict EVAL signal: without
+        # parsed per-test status we have NO evidence the declared FAIL_TO_PASS
+        # tests passed, so when an F2P oracle exists we must NOT claim resolved.
+        # (resolved stays exit-code-based only when there's no declared oracle,
+        # e.g. --skip-validation.)
+        reward = 1.0 if args.exit_code == 0 else 0.0
+        has_oracle = len(f2p) > 0
+        resolved = (args.exit_code == 0) and not has_oracle
+        breakdown = {
+            "reward": reward,
+            "resolved": resolved,
+            "command_resolved": bool(resolved and args.exit_code == 0),
+            "parse_status": "fallback_exitcode",
+            "eval_trustworthy": not has_oracle,
+            "runner": runner,
+            "f2p_total": len(f2p),
+            "p2p_total": len(p2p),
+            "exit_code": args.exit_code,
+        }
+    else:
+        breakdown = grade(f2p, p2p, status_map, runner)
+        breakdown["parse_status"] = "ok"
+        breakdown["runner"] = runner
+        breakdown["tests_parsed"] = len(status_map)
+        breakdown["exit_code"] = args.exit_code
+        # Strict eval signal: tracked resolution AND a clean command (no
+        # untracked failures, exit code 0). Benchmarks wanting "the whole test
+        # command passed" gate on this; SWE-bench-style scoring uses `resolved`.
+        breakdown["command_resolved"] = bool(
+            breakdown["resolved"]
+            and breakdown["untracked_failed_count"] == 0
+            and args.exit_code == 0
+        )
+        reward = breakdown["reward"]
+
+    os.makedirs(args.out_dir, exist_ok=True)
+    with open(os.path.join(args.out_dir, "reward.txt"), "w", encoding="utf-8") as f:
+        f.write(f"{reward:.6f}\n")
+    with open(os.path.join(args.out_dir, "reward-details.json"), "w", encoding="utf-8") as f:
+        json.dump(breakdown, f, indent=2)
+
+    print(json.dumps(breakdown, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
+
+
+__all__ = [
+    "grade",
+    "main",
+    "parse_cargo_test",
+    "parse_go_test",
+    "parse_jest",
+    "parse_logs",
+    "parse_pytest",
+]

heldout_pool/frostming__marko-7b31460c08f9/environment/Dockerfile

@@ -0,0 +1,36 @@
+# Auto-generated by Repo2RLEnv pr_runtime
+FROM local/frostming__marko
+WORKDIR /workspace
+# Defensive: ensure git is on PATH at build time. Bootstrap base
+# images vary — some (Python slim) don't ship git; some agents
+# install it; others don't. Re-installing is a no-op when already
+# present. Tries apt-get first (Debian/Ubuntu), then apk (Alpine).
+# Install git + ca-certificates. Minimal images (node:alpine) ship
+# without CA certs, so HTTPS git fetch fails verification.
+RUN (command -v git >/dev/null 2>&1 && [ -e /etc/ssl/certs/ca-certificates.crt ]) || \
+    (apt-get update && apt-get install -y --no-install-recommends git ca-certificates \
+     && rm -rf /var/lib/apt/lists/*) || \
+    (apk add --no-cache git ca-certificates && update-ca-certificates) || true
+# Defensive: the graded F2P/P2P verifier is Python.
+# Language-specific bootstrap images (Go/Rust/Node) may not
+# ship python3 — install it so test.sh can score F2P/P2P. No-op when
+# python3 is already present (every Python-repo image has it).
+RUN command -v python3 >/dev/null 2>&1 || \
+    (apt-get update && apt-get install -y --no-install-recommends python3 \
+     && rm -rf /var/lib/apt/lists/*) || \
+    apk add --no-cache python3 || true
+# Position the working tree at the PR's base commit so subsequent
+# model-patch applications align with the line context the patch
+# was authored against. The fetch is a no-op if the commit is
+# already in the shallow clone.
+RUN git config --global --add safe.directory /workspace \
+    && git fetch --depth 1 origin 0a870ce8485cc2067f077f8485bccf9f0aba05ed 2>/dev/null \
+       || git fetch --unshallow origin 2>/dev/null || true
+RUN git reset --hard 0a870ce8485cc2067f077f8485bccf9f0aba05ed && git clean -fdx -e .venv -e venv -e __pycache__ -e .tox -e node_modules -e target -e vendor -e .gradle -e .next -e .pytest_cache
+RUN git checkout -q -B base 0a870ce8485cc2067f077f8485bccf9f0aba05ed \
+    && git remote remove origin 2>/dev/null || true
+RUN for ref in $(git branch --format='%(refname:short)' | grep -vx base); do git branch -D "$ref" 2>/dev/null || true; done \
+    && git tag -l | xargs -r git tag -d >/dev/null 2>&1 || true \
+    && git for-each-ref --format='%(refname)' refs/remotes 2>/dev/null | xargs -r -n1 git update-ref -d 2>/dev/null || true \
+    && git reflog expire --expire=now --all 2>/dev/null || true \
+    && git gc --prune=now 2>/dev/null || true

heldout_pool/frostming__marko-7b31460c08f9/environment/docker-compose.yaml

@@ -0,0 +1,16 @@
+# Auto-generated by Repo2RLEnv: anti-contamination egress guard.
+# Blackholes the hosts that serve this repo's published fix and hidden
+# tests, so an agent cannot fetch the answer (pip download / git fetch /
+# WebFetch against these fail). General internet stays up so the agent
+# can install itself and reach its model API. See pipelines/_env_guard.py.
+services:
+  main:
+    extra_hosts:
+      - "pypi.org:0.0.0.0"
+      - "pypi.python.org:0.0.0.0"
+      - "files.pythonhosted.org:0.0.0.0"
+      - "github.com:0.0.0.0"
+      - "api.github.com:0.0.0.0"
+      - "raw.githubusercontent.com:0.0.0.0"
+      - "codeload.github.com:0.0.0.0"
+      - "objects.githubusercontent.com:0.0.0.0"

heldout_pool/frostming__marko-7b31460c08f9/instruction.md

@@ -0,0 +1,10 @@
+# Issue
+
+**Title:** Strikethrough formatting is not applied correctly when nested with other formatting
+
+## Description
+When text includes strikethrough formatting nested with other inline formatting (e.g., italic or bold), the strikethrough is sometimes ignored or rendered incorrectly. For instance, `~~*italic text*~~` might display as only *italic text* without the strikethrough. The expected behavior is for the strikethrough to be applied, taking precedence over the nested formatting.
+
+## Task
+
+Modify the repository so that the issue described above is resolved. The task's test suite verifies your patch by applying it on top of the base commit `0a870ce8485c` and running the modified tests.

heldout_pool/frostming__marko-7b31460c08f9/solution/patch.diff

@@ -0,0 +1,26 @@
+diff --git a/marko/ext/gfm/elements.py b/marko/ext/gfm/elements.py
+index ee81cc6..f2b0886 100644
+--- a/marko/ext/gfm/elements.py
++++ b/marko/ext/gfm/elements.py
+@@ -35,7 +35,7 @@ class InlineHTML(inline.InlineHTML):
+ class Strikethrough(inline.InlineElement):
+ 
+     pattern = re.compile(r"~~([^~]+)~~")
+-    priority = 4
++    priority = 5
+     parse_children = True
+ 
+ 
+diff --git a/noxfile.py b/noxfile.py
+index e7f0ea1..a5047e9 100644
+--- a/noxfile.py
++++ b/noxfile.py
+@@ -5,7 +5,7 @@ import nox
+ os.environ.update(PDM_IGNORE_SAVED_PYTHON="1")
+ 
+ 
+-@nox.session(python=["3.6", "3.8", "3.9", "3.10"])
++@nox.session(python=["3.6", "3.8", "3.9", "3.10", "3.11"])
+ def tests(session):
+     session.run("pdm", "install", "-d", external=True)
+     session.run("pytest", "tests/")

heldout_pool/frostming__marko-7b31460c08f9/solution/solve.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+set -euxo pipefail
+cd /workspace
+git config --global --add safe.directory /workspace
+PATCH="$(dirname "$0")/patch.diff"
+git apply --verbose --reject "$PATCH"

heldout_pool/frostming__marko-7b31460c08f9/task.toml

@@ -0,0 +1,87 @@
+version = "1.0"
+
+[task]
+name = "commit-runtime/frostming__marko-7b31460c08f9"
+description = "Make strikethrough precedence the default; add strikethrough tests (#136)"
+
+[metadata]
+difficulty = "trivial"
+category = "bugfix"
+keywords = [
+    "marko",
+    "commit_runtime",
+]
+
+[metadata.repo2env]
+pipeline = "commit_runtime"
+pipeline_version = "0.8.3"
+repo = "frostming/marko"
+ref = "0a870ce8485cc2067f077f8485bccf9f0aba05ed"
+reference = "https://github.com/frostming/marko/commit/7b31460c08f913bf67bb24464c26c606b8739e3f"
+source_access = "public"
+built_at = "2026-09-24T13:20:02.080635+00:00"
+synthesis_llm = "gemini/gemini-2.5-flash"
+reward_kinds = [
+    "test_execution",
+    "diff_similarity",
+]
+spec_version = "0.2.0"
+content_hash = "sha256:e7060ed0277e6447f079f1dc783b8d1eeabb1e0aae6a5f3ddc50312e0238006e"
+
+[metadata.repo2env.commit_runtime]
+commit_sha = "7b31460c08f913bf67bb24464c26c606b8739e3f"
+parent_sha = "0a870ce8485cc2067f077f8485bccf9f0aba05ed"
+authored_at = "2023-01-28T02:43:41-05:00"
+author_email = "github@kevinmgranger.me"
+subject = "fix: Make strikethrough precedence the default; add strikethrough tests (#136)"
+fail_to_pass = [
+    "tests/test_ext.py::TestGFM::test_strikethrough_link",
+]
+pass_to_pass = [
+    "tests/test_ext.py::TestCodeHilite::test_codehilite_options",
+    "tests/test_ext.py::TestCodeHilite::test_render_code_block",
+    "tests/test_ext.py::TestCodeHilite::test_render_code_block_with_extra",
+    "tests/test_ext.py::TestCodeHilite::test_render_fenced_code",
+    "tests/test_ext.py::TestFootnote::test_footnote",
+    "tests/test_ext.py::TestFootnote::test_non_footnote",
+    "tests/test_ext.py::TestGFM::test_gfm_autolink",
+    "tests/test_ext.py::TestGFM::test_strikethrough_inside_link",
+    "tests/test_ext.py::TestGFM::test_strikethrough_spec_new_paragraph",
+    "tests/test_ext.py::TestGFM::test_strikethrough_spec_standard",
+    "tests/test_ext.py::TestPangu::test_chinese_punctuations",
+    "tests/test_ext.py::TestPangu::test_render_pangu",
+]
+validation_status = "verified"
+bootstrap_image = "local-venv:frostming__marko"
+instruction_synthesized = true
+llm_cost_usd = 0.007009
+
+[metadata.repo2env.reward_calibration]
+f2p_count = 1
+p2p_count = 12
+source_files = 2
+loc_changed = 4
+difficulty = "trivial"
+
+[metadata.repo2env.evaluation]
+schema_version = "1"
+status = "unverified"
+stage = "generation"
+reason_codes = [
+    "validation_not_run",
+]
+detail = "Generated task; validation has not been established."
+provenance = "unknown"
+evidence = []
+
+[metadata.repo2env.reproducibility]
+mode = "local_only"
+image_ref = "local/frostming__marko"
+image_tag = "local/frostming__marko"
+image_visibility = "private"
+
+[agent]
+timeout_sec = 1800.0
+
+[verifier]
+timeout_sec = 300.0

heldout_pool/frostming__marko-7b31460c08f9/tests/f2p.json

@@ -0,0 +1,3 @@
+[
+  "tests/test_ext.py::TestGFM::test_strikethrough_link"
+]

heldout_pool/frostming__marko-7b31460c08f9/tests/p2p.json

@@ -0,0 +1,14 @@
+[
+  "tests/test_ext.py::TestCodeHilite::test_codehilite_options",
+  "tests/test_ext.py::TestCodeHilite::test_render_code_block",
+  "tests/test_ext.py::TestCodeHilite::test_render_code_block_with_extra",
+  "tests/test_ext.py::TestCodeHilite::test_render_fenced_code",
+  "tests/test_ext.py::TestFootnote::test_footnote",
+  "tests/test_ext.py::TestFootnote::test_non_footnote",
+  "tests/test_ext.py::TestGFM::test_gfm_autolink",
+  "tests/test_ext.py::TestGFM::test_strikethrough_inside_link",
+  "tests/test_ext.py::TestGFM::test_strikethrough_spec_new_paragraph",
+  "tests/test_ext.py::TestGFM::test_strikethrough_spec_standard",
+  "tests/test_ext.py::TestPangu::test_chinese_punctuations",
+  "tests/test_ext.py::TestPangu::test_render_pangu"
+]

heldout_pool/frostming__marko-7b31460c08f9/tests/test.sh

@@ -0,0 +1,75 @@
+#!/bin/bash
+set -uxo pipefail
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+cd /workspace
+git config --global --add safe.directory /workspace
+mkdir -p /logs/verifier
+git checkout 0a870ce8485cc2067f077f8485bccf9f0aba05ed -- tests/test_ext.py || true
+git apply --verbose --reject - <<'EOF_R2E_TEST_PATCH'
+diff --git a/tests/test_ext.py b/tests/test_ext.py
+index a239883..0ed6382 100644
+--- a/tests/test_ext.py
++++ b/tests/test_ext.py
+@@ -1,5 +1,7 @@
+ #! -*- coding: utf-8 -*-
+ 
++import pytest
++
+ from marko import Markdown
+ 
+ 
+@@ -76,6 +78,39 @@ class TestGFM:
+     def setup_method(self):
+         self.markdown = Markdown(extensions=["gfm"])
+ 
++    def test_strikethrough_link(self):
++        content = "~~[google](https://google.com)~~"
++        assert (
++            self.markdown(content).strip()
++            == '<p><del><a href="https://google.com">google</a></del></p>'
++        )
++
++    def test_strikethrough_inside_link(self):
++        content = "[~~google~~](https://google.com)"
++        assert (
++            self.markdown(content).strip()
++            == '<p><a href="https://google.com"><del>google</del></a></p>'
++        )
++
++    def test_strikethrough_spec_standard(self):
++        content = "~~Hi~~ Hello, world!"
++        expected = "<p><del>Hi</del> Hello, world!</p>"
++        assert self.markdown(content).strip() == expected
++
++    def test_strikethrough_spec_new_paragraph(self):
++        content = """This ~~has a
++
++new paragraph~~."""
++        expected = """<p>This ~~has a</p>
++<p>new paragraph~~.</p>"""
++        assert self.markdown(content).strip() == expected
++
++    @pytest.mark.skip(reason="existing GFM won't-strike bug")
++    def test_strikethrough_spec_wont_strike(self):
++        content = "This will ~~~not~~~ strike."
++        expected = "<p>This will ~~~not~~~ strike.</p>"
++        assert self.markdown(content).strip() == expected
++
+     def test_gfm_autolink(self):
+         content = "地址：https://google.com"
+         assert (
+
+EOF_R2E_TEST_PATCH
+R2E_APPLY_RC=$?
+if [ "$R2E_APPLY_RC" -ne 0 ]; then
+  echo "0.000000" > /logs/verifier/reward.txt
+  printf '%s' '{"reward": 0.0, "resolved": false, "parse_status": "test_patch_apply_failed"}' > /logs/verifier/reward-details.json
+  echo "R2E: test_patch failed to apply (rc=$R2E_APPLY_RC) — failing closed" >&2
+  exit 0
+fi
+( python -m pytest -v tests/test_ext.py ) > /logs/verifier/test_output.log 2>&1
+TEST_EXIT_CODE=$?
+cat /logs/verifier/test_output.log
+python3 "$SCRIPT_DIR/verifier.py" --log /logs/verifier/test_output.log --f2p "$SCRIPT_DIR/f2p.json" --p2p "$SCRIPT_DIR/p2p.json" --test-cmds 'python -m pytest -v tests/test_ext.py' --exit-code "$TEST_EXIT_CODE" --out-dir /logs/verifier || { [ "$TEST_EXIT_CODE" -eq 0 ] && echo "1.0" > /logs/verifier/reward.txt || echo "0.0" > /logs/verifier/reward.txt; }
+git checkout 0a870ce8485cc2067f077f8485bccf9f0aba05ed -- tests/test_ext.py || true
+exit 0

heldout_pool/frostming__marko-7b31460c08f9/tests/verifier.py

@@ -0,0 +1,475 @@
+"""In-container verifier for pr_runtime tasks (graded F2P/P2P reward).
+
+This module is the **standalone verifier** that runs inside the task's
+Docker container, NOT a helper used at generation time. It is read as
+source at generation time, base64-encoded, and embedded into
+``tests/test.sh``. At run time the container decodes it back to a file
+and invokes it after the test suite has run.
+
+Why a graded reward instead of binary pass/fail
+------------------------------------------------
+SWE-bench resolution is binary: a patch "resolves" the issue iff ALL
+FAIL_TO_PASS tests pass AND ALL PASS_TO_PASS tests still pass. That's
+the right signal for an eval leaderboard, but a terrible gradient for
+RL training — an agent that fixes 4 of 5 failing tests scores the same
+0.0 as one that fixes nothing.
+
+So this verifier emits BOTH:
+  * /logs/verifier/reward.txt  — the GRADED scalar (training signal,
+        which Harbor reads):  reward = f2p_rate * p2p_factor
+  * /logs/verifier/reward-details.json — carries the strict SWE-bench
+        ``resolved`` bool (eval signal) PLUS the full breakdown.
+
+Refs: SWE-bench (F2P/P2P semantics), SWE-RL / SWE-Gym (dense reward for
+RL), UTBoost (weak-test coverage lets wrong patches pass — hence we
+record p2p_count so consumers can judge regression-guard strength).
+
+Scoring
+-------
+Given the baked FAIL_TO_PASS / PASS_TO_PASS test-name lists (computed by
+the generation-time two-stage validation) and the agent-run test log:
+
+  f2p_rate   = (# F2P tests now PASSED) / (# F2P tests)
+  p2p_rate   = (# P2P tests still PASSED) / (# P2P tests)   [1.0 if no P2P]
+  p2p_factor = p2p_rate          # regressions scale the reward down
+  reward     = f2p_rate * p2p_factor
+  resolved   = (all F2P pass) AND (all P2P pass)            # strict SWE-bench
+
+Oracle invariant: the gold patch flips every F2P and keeps every P2P,
+so f2p_rate=1.0, p2p_rate=1.0 -> reward=1.0 and resolved=True. This is
+what the T3 oracle gate (reward == 1.0) relies on.
+
+Graceful degradation: if the log can't be parsed into per-test
+statuses (unrecognized runner output), fall back to the exit-code
+reward (1.0 if the suite exited 0, else 0.0) and stamp
+``parse_status="fallback_exitcode"`` — never crash, never silently
+zero out a real fix.
+
+Pure stdlib — uses only ``argparse``, ``json``, ``os``, ``re``, ``sys``.
+The 4 per-runner parsers are condensed ports of
+``repo2rlenv.log_parsers.*`` kept in lockstep via the unit tests under
+``tests/test_pr_runtime_verifier.py``.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import sys
+
+# Canonical statuses. (Plain strings — no typing.Literal so the baked
+# module stays import-light when decoded standalone in the container.)
+PASSED = "PASSED"
+FAILED = "FAILED"
+SKIPPED = "SKIPPED"
+ERROR = "ERROR"
+
+# ---------------------------------------------------------------------------
+# Per-runner log parsers (condensed ports of repo2rlenv.log_parsers.*)
+# ---------------------------------------------------------------------------
+
+_PYTEST_STATUSES = (PASSED, FAILED, SKIPPED, ERROR)
+# Keep these patterns in sync with log_parsers/pytest_parser.py. This module
+# also runs standalone inside task containers, without a repo2rlenv install.
+_PYTEST_PROGRESS = (
+    r"\[\s*\d+%\]|\[\s*\d+\s*/\s*\d+\s*\]"
+    r"|\d+(?:\.\d+)?(?:us|ms|s)|\d+m \d+s|\d+h \d+m"
+)
+_PYTEST_VERBOSE_RE = re.compile(
+    r"^(?P<name>.+?(?:\[.*?\])?)\s+(?P<status>PASSED|FAILED|SKIPPED|ERROR)"
+    rf"(?:\s+\(.*\))?(?:\s+(?:{_PYTEST_PROGRESS}))?$"
+)
+_PYTEST_SUMMARY_NAME_RE = re.compile(r"^(?P<name>.+?(?:\[.*?\])?)(?: - .*)?$")
+# pytest-xdist worker label, e.g. `[gw1] [ 20%] PASSED tests/foo.py::test_x`.
+_PYTEST_XDIST_PREFIX_RE = re.compile(rf"^\[gw\d+\]\s+(?:(?:{_PYTEST_PROGRESS})\s+)?")
+
+
+def parse_pytest(log: str) -> dict[str, str]:
+    """{test_name -> status} from pytest output (verbose or summary)."""
+    out: dict[str, str] = {}
+    if not log:
+        return out
+    for raw in log.split("\n"):
+        line = raw.strip()
+        if not line:
+            continue
+        line = _PYTEST_XDIST_PREFIX_RE.sub("", line, count=1)
+        # Summary lines (STATUS first), preserving the full node ID.
+        leading = None
+        for st in _PYTEST_STATUSES:
+            if line.startswith(st + " ") or line == st:
+                leading = st
+                break
+        if leading is not None:
+            work = line[len(leading) :].strip()
+            if leading == SKIPPED and re.match(r"^\[\d+\](?:\s|$)", work):
+                # Folded skips report a file location, not a parametrized ID.
+                tokens = work.split(maxsplit=2)
+                if len(tokens) < 2:
+                    continue
+                out[tokens[1]] = leading
+            elif m := _PYTEST_SUMMARY_NAME_RE.match(work):
+                out[m.group("name")] = leading
+            continue
+        # Verbose progress (NAME first, STATUS after)
+        # Filter non-test output before attempting the backtracking regex.
+        head = line.split(None, 1)[0]
+        if "::" not in head and not head.endswith(".py"):
+            continue
+        m = _PYTEST_VERBOSE_RE.match(line)
+        if m:
+            name = m.group("name")
+            if "::" in name or name.endswith(".py"):
+                out[name] = m.group("status")
+    return out
+
+
+_GO_TEST_RE = re.compile(r"^\s*---\s+(?P<status>PASS|FAIL|SKIP):\s+(?P<name>\S+)")
+_GO_STATUS = {"PASS": PASSED, "FAIL": FAILED, "SKIP": SKIPPED}
+
+
+def parse_go_test(log: str) -> dict[str, str]:
+    """{test_name -> status} from `go test -v` output."""
+    out: dict[str, str] = {}
+    if not log:
+        return out
+    for raw in log.split("\n"):
+        m = _GO_TEST_RE.match(raw)
+        if m:
+            out[m.group("name")] = _GO_STATUS[m.group("status")]
+    return out
+
+
+# Keep these patterns in sync with log_parsers/cargo_parser.py.
+_CARGO_TEST_RE = re.compile(r"^test\s+(?P<name>\S.*?) \.\.\. (?P<status>ok|FAILED|ignored)\b")
+_CARGO_MODE_RE = re.compile(r" - (?:should panic|compile fail|compile)$")
+_CARGO_DOCTEST_RE = re.compile(r"^(?P<file>\S+) - (?:(?P<item>.+?) )?\(line \d+\)$")
+_CARGO_STATUS = {"ok": PASSED, "FAILED": FAILED, "ignored": SKIPPED}
+_CARGO_DOCTEST_RANK = {SKIPPED: 0, PASSED: 1, FAILED: 2}
+
+
+def parse_cargo_test(log: str) -> dict[str, str]:
+    """{test_name -> status} from `cargo test` output.
+
+    Test modes (` - should panic`) are dropped from names, and doctests are
+    keyed without their `(line N)` so line shifts don't change identity; the
+    worst status among an item's doctests wins.
+    """
+    out: dict[str, str] = {}
+    if not log:
+        return out
+    for raw in log.split("\n"):
+        m = _CARGO_TEST_RE.match(raw)
+        if not m:
+            continue
+        name = _CARGO_MODE_RE.sub("", m.group("name")).rstrip()
+        status = _CARGO_STATUS[m.group("status")]
+        doctest = _CARGO_DOCTEST_RE.match(name)
+        if doctest:
+            item = doctest.group("item")
+            name = f"{doctest.group('file')} - {item}" if item else doctest.group("file")
+            if name in out and _CARGO_DOCTEST_RANK[out[name]] > _CARGO_DOCTEST_RANK[status]:
+                continue
+        out[name] = status
+    return out
+
+
+_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\))?$"
+)
+_JEST_GLYPH = {
+    "✓": PASSED,
+    "√": PASSED,
+    "✕": FAILED,
+    "×": FAILED,
+    "✗": FAILED,
+    "○": 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]:
+    """{test_name -> status} from Jest / Mocha / Vitest output."""
+    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
+    for raw in log.split("\n"):
+        line = raw.rstrip()
+        if not line:
+            continue
+        m = _JEST_FILE_RE.match(line)
+        if m:
+            current_file = m.group("path")
+            describe_stack = []
+            last_test_indent = None
+            continue
+        m = _JEST_TEST_RE.match(line)
+        if m:
+            indent = len(m.group("indent"))
+            name = re.sub(r"^(?:skipped|todo):\s*", "", m.group("name").strip())
+            describes = [d for ind, d in describe_stack if ind < indent]
+            parts = ([current_file] if current_file else []) + describes + [name]
+            out[" > ".join(parts)] = _JEST_GLYPH[m.group("glyph")]
+            last_test_indent = indent
+            continue
+        stripped = line.lstrip()
+        if not stripped or stripped.startswith(
+            ("Tests:", "Test Suites:", "Snapshots:", "Time:", "Ran all", "●", "→", "✗:")
+        ):
+            continue
+        indent_here = len(line) - len(stripped)
+        if current_file and (last_test_indent is None or indent_here < last_test_indent):
+            describe_stack = [(i, d) for i, d in describe_stack if i < indent_here]
+            describe_stack.append((indent_here, stripped))
+    return out
+
+
+def _detect_runner(test_cmds: str) -> str:
+    joined = test_cmds.lower()
+    if "pytest" in joined:
+        return "pytest"
+    if re.search(r"\bgo\s+test\b", joined):
+        return "go"
+    if re.search(r"\bcargo\s+test\b", joined):
+        return "cargo"
+    if any(k in joined for k in ("jest", "mocha", "vitest", "npm test", "yarn test", "pnpm test")):
+        return "jest"
+    return "unknown"
+
+
+def parse_logs(runner: str, log: str) -> dict[str, str]:
+    """Dispatch to the right per-runner parser. Empty dict if unknown."""
+    if runner == "pytest":
+        return parse_pytest(log)
+    if runner == "go":
+        return parse_go_test(log)
+    if runner == "cargo":
+        return parse_cargo_test(log)
+    if runner == "jest":
+        return parse_jest(log)
+    return {}
+
+
+# ---------------------------------------------------------------------------
+# Grading
+# ---------------------------------------------------------------------------
+def _has_go_parent(name: str, status_map: dict[str, str]) -> bool:
+    """Return True if a Go test has an ancestor represented in the status map."""
+    parts = name.split("/")
+
+    for i in range(1, len(parts)):
+        parent = "/".join(parts[:i])
+        if status_map.get(parent) == FAILED:
+            return True
+
+    return False
+
+
+def grade(
+    fail_to_pass: list[str],
+    pass_to_pass: list[str],
+    status_map: dict[str, str],
+    runner: str | None = None,
+) -> dict:
+    """Compute the graded reward + strict resolved bool from a status map.
+
+    f2p_rate   = (# F2P now PASSED) / (# F2P)
+    p2p_rate   = (# P2P still PASSED) / (# P2P)   [1.0 when no P2P]
+    reward     = f2p_rate * p2p_rate                       (dense training signal)
+    resolved   = all F2P pass AND all P2P pass   (SWE-bench TRACKED resolution —
+                 the gold patch always satisfies this, preserving the oracle
+                 invariant)
+
+    Two distinct EVAL signals (see the audit's "tracked vs command resolved"):
+      * `resolved`         — tracked resolution (above). Gold patch -> True.
+      * `command_resolved` — stricter: tracked resolution AND the selected test
+                             command had NO failures outside F2P/P2P AND exit
+                             code 0. Computed in main() where the exit code is
+                             known. A benchmark that wants "the whole command
+                             passed cleanly" gates on this; SWE-bench-style
+                             scoring uses `resolved`.
+
+    `untracked_failed` are FAILED tests in the run that are neither F2P nor
+    P2P (e.g. always-failing/flaky tests pulled in by running a whole test
+    file). They don't change the graded `reward` or tracked `resolved`, but
+    they block `command_resolved` and are recorded for transparency.
+    """
+    f2p_total = len(fail_to_pass)
+    p2p_total = len(pass_to_pass)
+    f2p_set = set(fail_to_pass)
+    p2p_set = set(pass_to_pass)
+    f2p_passed = sum(1 for t in fail_to_pass if status_map.get(t) == PASSED)
+    p2p_passed = sum(1 for t in pass_to_pass if status_map.get(t) == PASSED)
+    # Tests that should have stayed green but regressed (PASS->not-pass).
+    regressions = [t for t in pass_to_pass if status_map.get(t) != PASSED]
+
+    # FAILED tests outside the tracked sets — the selected command isn't clean.
+    if runner == "go":
+        failed_tests = {
+            t
+            for t, s in status_map.items()
+            if s == FAILED and t not in f2p_set and t not in p2p_set
+        }
+
+        untracked_failed = sorted(t for t in failed_tests if not _has_go_parent(t, status_map))
+    else:
+        untracked_failed = sorted(
+            t
+            for t, s in status_map.items()
+            if s == FAILED and t not in f2p_set and t not in p2p_set
+        )
+
+    f2p_rate = (f2p_passed / f2p_total) if f2p_total else 0.0
+    p2p_rate = (p2p_passed / p2p_total) if p2p_total else 1.0
+    reward = f2p_rate * p2p_rate
+    resolved = f2p_total > 0 and f2p_passed == f2p_total and p2p_passed == p2p_total
+
+    return {
+        "reward": round(max(0.0, min(1.0, reward)), 6),
+        "resolved": resolved,
+        "f2p_total": f2p_total,
+        "f2p_passed": f2p_passed,
+        "f2p_rate": round(f2p_rate, 6),
+        "p2p_total": p2p_total,
+        "p2p_passed": p2p_passed,
+        "p2p_rate": round(p2p_rate, 6),
+        "regressions": sorted(regressions),
+        "untracked_failed_count": len(untracked_failed),
+        "untracked_failed": untracked_failed[:20],  # cap the list
+    }
+
+
+# ---------------------------------------------------------------------------
+# Entry point (invoked by tests/test.sh inside the container)
+# ---------------------------------------------------------------------------
+
+
+def _read_json_list(path: str) -> list[str]:
+    try:
+        with open(path, encoding="utf-8") as f:
+            data = json.load(f)
+        return [str(x) for x in data] if isinstance(data, list) else []
+    except (OSError, ValueError):
+        return []
+
+
+def _read_text(path: str) -> str:
+    try:
+        with open(path, encoding="utf-8") as f:
+            return f.read()
+    except (OSError, UnicodeDecodeError):
+        return ""
+
+
+def main(argv: list[str] | None = None) -> int:
+    p = argparse.ArgumentParser(description="pr_runtime graded F2P/P2P verifier")
+    p.add_argument("--log", required=True, help="captured test-run log file")
+    p.add_argument("--f2p", required=True, help="JSON file: FAIL_TO_PASS test names")
+    p.add_argument("--p2p", required=True, help="JSON file: PASS_TO_PASS test names")
+    p.add_argument("--runner", default="", help="pytest|go|cargo|jest (else auto-detect)")
+    p.add_argument("--test-cmds", default="", help="test command string (runner auto-detect)")
+    p.add_argument("--exit-code", type=int, default=1, help="test suite exit code (fallback)")
+    p.add_argument("--out-dir", default="/logs/verifier", help="where to write reward.{txt,json}")
+    args = p.parse_args(argv)
+
+    log = _read_text(args.log)
+    f2p = _read_json_list(args.f2p)
+    p2p = _read_json_list(args.p2p)
+    runner = args.runner.strip() or _detect_runner(args.test_cmds)
+
+    status_map = parse_logs(runner, log)
+
+    if not status_map:
+        # Unparseable runner output → fall back to the binary exit-code reward
+        # (a coarse TRAINING signal) so we never silently zero a real fix on an
+        # unrecognized format. But `resolved` is the strict EVAL signal: without
+        # parsed per-test status we have NO evidence the declared FAIL_TO_PASS
+        # tests passed, so when an F2P oracle exists we must NOT claim resolved.
+        # (resolved stays exit-code-based only when there's no declared oracle,
+        # e.g. --skip-validation.)
+        reward = 1.0 if args.exit_code == 0 else 0.0
+        has_oracle = len(f2p) > 0
+        resolved = (args.exit_code == 0) and not has_oracle
+        breakdown = {
+            "reward": reward,
+            "resolved": resolved,
+            "command_resolved": bool(resolved and args.exit_code == 0),
+            "parse_status": "fallback_exitcode",
+            "eval_trustworthy": not has_oracle,
+            "runner": runner,
+            "f2p_total": len(f2p),
+            "p2p_total": len(p2p),
+            "exit_code": args.exit_code,
+        }
+    else:
+        breakdown = grade(f2p, p2p, status_map, runner)
+        breakdown["parse_status"] = "ok"
+        breakdown["runner"] = runner
+        breakdown["tests_parsed"] = len(status_map)
+        breakdown["exit_code"] = args.exit_code
+        # Strict eval signal: tracked resolution AND a clean command (no
+        # untracked failures, exit code 0). Benchmarks wanting "the whole test
+        # command passed" gate on this; SWE-bench-style scoring uses `resolved`.
+        breakdown["command_resolved"] = bool(
+            breakdown["resolved"]
+            and breakdown["untracked_failed_count"] == 0
+            and args.exit_code == 0
+        )
+        reward = breakdown["reward"]
+
+    os.makedirs(args.out_dir, exist_ok=True)
+    with open(os.path.join(args.out_dir, "reward.txt"), "w", encoding="utf-8") as f:
+        f.write(f"{reward:.6f}\n")
+    with open(os.path.join(args.out_dir, "reward-details.json"), "w", encoding="utf-8") as f:
+        json.dump(breakdown, f, indent=2)
+
+    print(json.dumps(breakdown, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
+
+
+__all__ = [
+    "grade",
+    "main",
+    "parse_cargo_test",
+    "parse_go_test",
+    "parse_jest",
+    "parse_logs",
+    "parse_pytest",
+]

heldout_pool/frostming__marko-88e65f1f51c1/environment/Dockerfile

@@ -0,0 +1,36 @@
+# Auto-generated by Repo2RLEnv pr_runtime
+FROM local/frostming__marko
+WORKDIR /workspace
+# Defensive: ensure git is on PATH at build time. Bootstrap base
+# images vary — some (Python slim) don't ship git; some agents
+# install it; others don't. Re-installing is a no-op when already
+# present. Tries apt-get first (Debian/Ubuntu), then apk (Alpine).
+# Install git + ca-certificates. Minimal images (node:alpine) ship
+# without CA certs, so HTTPS git fetch fails verification.
+RUN (command -v git >/dev/null 2>&1 && [ -e /etc/ssl/certs/ca-certificates.crt ]) || \
+    (apt-get update && apt-get install -y --no-install-recommends git ca-certificates \
+     && rm -rf /var/lib/apt/lists/*) || \
+    (apk add --no-cache git ca-certificates && update-ca-certificates) || true
+# Defensive: the graded F2P/P2P verifier is Python.
+# Language-specific bootstrap images (Go/Rust/Node) may not
+# ship python3 — install it so test.sh can score F2P/P2P. No-op when
+# python3 is already present (every Python-repo image has it).
+RUN command -v python3 >/dev/null 2>&1 || \
+    (apt-get update && apt-get install -y --no-install-recommends python3 \
+     && rm -rf /var/lib/apt/lists/*) || \
+    apk add --no-cache python3 || true
+# Position the working tree at the PR's base commit so subsequent
+# model-patch applications align with the line context the patch
+# was authored against. The fetch is a no-op if the commit is
+# already in the shallow clone.
+RUN git config --global --add safe.directory /workspace \
+    && git fetch --depth 1 origin e34793226fc0ab80142d23cef2078ab0035a6104 2>/dev/null \
+       || git fetch --unshallow origin 2>/dev/null || true
+RUN git reset --hard e34793226fc0ab80142d23cef2078ab0035a6104 && git clean -fdx -e .venv -e venv -e __pycache__ -e .tox -e node_modules -e target -e vendor -e .gradle -e .next -e .pytest_cache
+RUN git checkout -q -B base e34793226fc0ab80142d23cef2078ab0035a6104 \
+    && git remote remove origin 2>/dev/null || true
+RUN for ref in $(git branch --format='%(refname:short)' | grep -vx base); do git branch -D "$ref" 2>/dev/null || true; done \
+    && git tag -l | xargs -r git tag -d >/dev/null 2>&1 || true \
+    && git for-each-ref --format='%(refname)' refs/remotes 2>/dev/null | xargs -r -n1 git update-ref -d 2>/dev/null || true \
+    && git reflog expire --expire=now --all 2>/dev/null || true \
+    && git gc --prune=now 2>/dev/null || true

heldout_pool/frostming__marko-88e65f1f51c1/environment/docker-compose.yaml

@@ -0,0 +1,16 @@
+# Auto-generated by Repo2RLEnv: anti-contamination egress guard.
+# Blackholes the hosts that serve this repo's published fix and hidden
+# tests, so an agent cannot fetch the answer (pip download / git fetch /
+# WebFetch against these fail). General internet stays up so the agent
+# can install itself and reach its model API. See pipelines/_env_guard.py.
+services:
+  main:
+    extra_hosts:
+      - "pypi.org:0.0.0.0"
+      - "pypi.python.org:0.0.0.0"
+      - "files.pythonhosted.org:0.0.0.0"
+      - "github.com:0.0.0.0"
+      - "api.github.com:0.0.0.0"
+      - "raw.githubusercontent.com:0.0.0.0"
+      - "codeload.github.com:0.0.0.0"
+      - "objects.githubusercontent.com:0.0.0.0"

heldout_pool/frostming__marko-88e65f1f51c1/instruction.md

@@ -0,0 +1,15 @@
+# Issue
+
+**Title:** GFM Alerts not parsed correctly with extra header content or mixed-case types
+
+## Description
+When parsing GitHub Flavored Markdown (GFM) alert blocks, two issues are observed:
+
+1.  **Extra content on header line:** An alert block is incorrectly recognized even when there is additional text on the same line as the alert type declaration. For example, `> [!NOTE] Some extra text` is currently parsed as a valid alert header.
+    *   **Expected behavior:** Lines containing any text after the `[!TYPE]` declaration should not be recognized as a GFM alert header.
+2.  **Case-sensitive alert types:** Alert blocks are not recognized if the alert type (e.g., `NOTE`, `WARNING`) is not in all uppercase. For example, `> [!note]` or `> [!Warning]` are currently ignored.
+    *   **Expected behavior:** GFM
+
+## Task
+
+Modify the repository so that the issue described above is resolved. The task's test suite verifies your patch by applying it on top of the base commit `e34793226fc0` and running the modified tests.

heldout_pool/frostming__marko-88e65f1f51c1/solution/patch.diff

@@ -0,0 +1,48 @@
+diff --git a/CHANGELOG.md b/CHANGELOG.md
+index 0346323..9aa152c 100644
+--- a/CHANGELOG.md
++++ b/CHANGELOG.md
+@@ -1,3 +1,10 @@
++## v2.2.2(2026-01-05)
++
++### Fixed
++
++- Fix a bug in GFM alert block parsing where alert types were case-sensitive.
++- Fix GFM alert regex to disallow content on header line.
++
+ ## v2.2.1(2025-10-13)
+ 
+ ### Changed
+diff --git a/marko/__init__.py b/marko/__init__.py
+index 4aae580..a21e6dd 100644
+--- a/marko/__init__.py
++++ b/marko/__init__.py
+@@ -23,7 +23,7 @@ if TYPE_CHECKING:
+     from .block import Document
+     from .parser import ElementType
+ 
+-__version__ = "2.2.1"
++__version__ = "2.2.2"
+ 
+ 
+ class SetupDone(Exception):
+diff --git a/marko/ext/gfm/elements.py b/marko/ext/gfm/elements.py
+index fa98289..2edcaeb 100644
+--- a/marko/ext/gfm/elements.py
++++ b/marko/ext/gfm/elements.py
+@@ -225,11 +225,13 @@ class Alert(block.Quote):
+ 
+     @classmethod
+     def match(cls, source):
+-        return source.expect_re(r" {,3}>\s*\[\!(WARNING|NOTE|TIP|IMPORTANT|CAUTION)\]")
++        return source.expect_re(
++            r"(?im) {,3}>\s*\[\!(WARNING|NOTE|TIP|IMPORTANT|CAUTION)\]\s*$"
++        )
+ 
+     @classmethod
+     def parse(cls, source):
+-        alert_type = source.match.group(1)
++        alert_type = source.match.group(1).upper()
+         source.next_line(require_prefix=False)
+         source.consume()
+         state = cls(alert_type)

heldout_pool/frostming__marko-88e65f1f51c1/solution/solve.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+set -euxo pipefail
+cd /workspace
+git config --global --add safe.directory /workspace
+PATCH="$(dirname "$0")/patch.diff"
+git apply --verbose --reject "$PATCH"

heldout_pool/frostming__marko-88e65f1f51c1/task.toml

@@ -0,0 +1,96 @@
+version = "1.0"
+
+[task]
+name = "commit-runtime/frostming__marko-88e65f1f51c1"
+description = "Update GFM alert regex to disallow content on header line (#252)"
+
+[metadata]
+difficulty = "small"
+category = "bugfix"
+keywords = [
+    "marko",
+    "commit_runtime",
+]
+
+[metadata.repo2env]
+pipeline = "commit_runtime"
+pipeline_version = "0.8.3"
+repo = "frostming/marko"
+ref = "e34793226fc0ab80142d23cef2078ab0035a6104"
+reference = "https://github.com/frostming/marko/commit/88e65f1f51c1e88e9e06a8f0b855200122578b28"
+source_access = "public"
+built_at = "2026-09-24T13:19:45.243670+00:00"
+synthesis_llm = "gemini/gemini-2.5-flash"
+reward_kinds = [
+    "test_execution",
+    "diff_similarity",
+]
+spec_version = "0.2.0"
+content_hash = "sha256:4f757b95b49545b2d37cd22bebac5475195d38a6d62d53e4ca3e178bbf7cf529"
+
+[metadata.repo2env.commit_runtime]
+commit_sha = "88e65f1f51c1e88e9e06a8f0b855200122578b28"
+parent_sha = "e34793226fc0ab80142d23cef2078ab0035a6104"
+authored_at = "2026-01-05T19:01:56+08:00"
+author_email = "me@frostming.com"
+subject = "fix: Update GFM alert regex to disallow content on header line (#252)"
+fail_to_pass = [
+    "tests/test_ext.py::TestGFMAlert::test_alert_ast[Caution]",
+    "tests/test_ext.py::TestGFMAlert::test_alert_ast[warning]",
+    "tests/test_ext.py::TestGFMAlert::test_alert_disallow_content_on_header_line",
+    "tests/test_ext.py::TestGFMAlert::test_alert_html[Caution]",
+    "tests/test_ext.py::TestGFMAlert::test_alert_html[warning]",
+]
+pass_to_pass = [
+    "tests/test_ext.py::TestCodeHilite::test_codehilite_options",
+    "tests/test_ext.py::TestCodeHilite::test_render_code_block",
+    "tests/test_ext.py::TestCodeHilite::test_render_code_block_with_extra",
+    "tests/test_ext.py::TestCodeHilite::test_render_fenced_code",
+    "tests/test_ext.py::TestFootnote::test_footnote",
+    "tests/test_ext.py::TestFootnote::test_non_footnote",
+    "tests/test_ext.py::TestGFMAlert::test_alert_ast[CAUTION]",
+    "tests/test_ext.py::TestGFMAlert::test_alert_ast[TIP]",
+    "tests/test_ext.py::TestGFMAlert::test_alert_ast[WARNING]",
+    "tests/test_ext.py::TestGFMAlert::test_alert_html[CAUTION]",
+    "tests/test_ext.py::TestGFMAlert::test_alert_html[TIP]",
+    "tests/test_ext.py::TestGFMAlert::test_alert_html[WARNING]",
+    "tests/test_ext.py::TestPangu::test_chinese_punctuations",
+    "tests/test_ext.py::TestPangu::test_render_pangu",
+    "tests/test_ext.py::TestToc::test_render_toc",
+    "tests/test_ext.py::TestToc::test_render_toc_exceeding_maxdepth",
+    "tests/test_ext.py::TestToc::test_render_toc_replace_tags",
+]
+validation_status = "verified"
+bootstrap_image = "local-venv:frostming__marko"
+instruction_synthesized = true
+llm_cost_usd = 0.002596
+
+[metadata.repo2env.reward_calibration]
+f2p_count = 5
+p2p_count = 17
+source_files = 3
+loc_changed = 15
+difficulty = "small"
+
+[metadata.repo2env.evaluation]
+schema_version = "1"
+status = "unverified"
+stage = "generation"
+reason_codes = [
+    "validation_not_run",
+]
+detail = "Generated task; validation has not been established."
+provenance = "unknown"
+evidence = []
+
+[metadata.repo2env.reproducibility]
+mode = "local_only"
+image_ref = "local/frostming__marko"
+image_tag = "local/frostming__marko"
+image_visibility = "private"
+
+[agent]
+timeout_sec = 1800.0
+
+[verifier]
+timeout_sec = 300.0

heldout_pool/frostming__marko-88e65f1f51c1/tests/f2p.json

@@ -0,0 +1,7 @@
+[
+  "tests/test_ext.py::TestGFMAlert::test_alert_ast[Caution]",
+  "tests/test_ext.py::TestGFMAlert::test_alert_ast[warning]",
+  "tests/test_ext.py::TestGFMAlert::test_alert_disallow_content_on_header_line",
+  "tests/test_ext.py::TestGFMAlert::test_alert_html[Caution]",
+  "tests/test_ext.py::TestGFMAlert::test_alert_html[warning]"
+]

heldout_pool/frostming__marko-88e65f1f51c1/tests/p2p.json

@@ -0,0 +1,19 @@
+[
+  "tests/test_ext.py::TestCodeHilite::test_codehilite_options",
+  "tests/test_ext.py::TestCodeHilite::test_render_code_block",
+  "tests/test_ext.py::TestCodeHilite::test_render_code_block_with_extra",
+  "tests/test_ext.py::TestCodeHilite::test_render_fenced_code",
+  "tests/test_ext.py::TestFootnote::test_footnote",
+  "tests/test_ext.py::TestFootnote::test_non_footnote",
+  "tests/test_ext.py::TestGFMAlert::test_alert_ast[CAUTION]",
+  "tests/test_ext.py::TestGFMAlert::test_alert_ast[TIP]",
+  "tests/test_ext.py::TestGFMAlert::test_alert_ast[WARNING]",
+  "tests/test_ext.py::TestGFMAlert::test_alert_html[CAUTION]",
+  "tests/test_ext.py::TestGFMAlert::test_alert_html[TIP]",
+  "tests/test_ext.py::TestGFMAlert::test_alert_html[WARNING]",
+  "tests/test_ext.py::TestPangu::test_chinese_punctuations",
+  "tests/test_ext.py::TestPangu::test_render_pangu",
+  "tests/test_ext.py::TestToc::test_render_toc",
+  "tests/test_ext.py::TestToc::test_render_toc_exceeding_maxdepth",
+  "tests/test_ext.py::TestToc::test_render_toc_replace_tags"
+]

heldout_pool/frostming__marko-88e65f1f51c1/tests/test.sh

@@ -0,0 +1,73 @@
+#!/bin/bash
+set -uxo pipefail
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+cd /workspace
+git config --global --add safe.directory /workspace
+mkdir -p /logs/verifier
+git checkout e34793226fc0ab80142d23cef2078ab0035a6104 -- tests/test_ext.py || true
+git apply --verbose --reject - <<'EOF_R2E_TEST_PATCH'
+diff --git a/tests/test_ext.py b/tests/test_ext.py
+index d20e2db..0b3f04e 100644
+--- a/tests/test_ext.py
++++ b/tests/test_ext.py
+@@ -1,3 +1,5 @@
++import pytest
++
+ from marko import Markdown
+ 
+ 
+@@ -106,20 +108,32 @@ class TestGFMAlert:
+         self.md_ast = Markdown(renderer=ASTRenderer, extensions=[GFM])
+         self.md_html = Markdown(extensions=[GFM])
+ 
+-    def test_alert_ast(self):
+-        text = "> [!WARNING]\n> Foo bar\n> Bar\n"
++    @pytest.mark.parametrize(
++        "alert_type", ["WARNING", "CAUTION", "TIP", "warning", "Caution"]
++    )
++    def test_alert_ast(self, alert_type):
++        text = f"> [!{alert_type}]\n> Foo bar\n> Bar\n"
+         ast = self.md_ast(text)
+         admon = ast["children"][0]
+         assert admon["element"] == "alert"
+-        assert admon["alert_type"] == "WARNING"
++        assert admon["alert_type"] == alert_type.upper()
+         inner = admon["children"][0]["children"]
+         assert inner[0]["children"] == "Foo bar"
+         assert inner[1]["element"] == "line_break"
+         assert inner[2]["children"] == "Bar"
+ 
+-    def test_alert_html(self):
+-        text = "> [!WARNING]\n> Foo bar\n> Bar\n"
++    @pytest.mark.parametrize(
++        "alert_type", ["WARNING", "CAUTION", "TIP", "warning", "Caution"]
++    )
++    def test_alert_html(self, alert_type):
++        text = f"> [!{alert_type}]\n> Foo bar\n> Bar\n"
+         html = self.md_html(text)
+-        assert '<blockquote class="alert alert-warning">' in html
+-        assert "<p>Warning</p>" in html
++        assert f'<blockquote class="alert alert-{alert_type.lower()}">' in html
++        assert f"<p>{alert_type.title()}</p>" in html
+         assert "<p>Foo bar\nBar</p>" in html
++
++    def test_alert_disallow_content_on_header_line(self):
++        text = "> [!NOTE] This is not allowed.\n> Foo bar\n"
++        html = self.md_html(text)
++        # Should be treated as a normal blockquote.
++        assert "<blockquote>\n<p>[!NOTE] This is not allowed." in html
+
+EOF_R2E_TEST_PATCH
+R2E_APPLY_RC=$?
+if [ "$R2E_APPLY_RC" -ne 0 ]; then
+  echo "0.000000" > /logs/verifier/reward.txt
+  printf '%s' '{"reward": 0.0, "resolved": false, "parse_status": "test_patch_apply_failed"}' > /logs/verifier/reward-details.json
+  echo "R2E: test_patch failed to apply (rc=$R2E_APPLY_RC) — failing closed" >&2
+  exit 0
+fi
+( python -m pytest -v tests/test_ext.py ) > /logs/verifier/test_output.log 2>&1
+TEST_EXIT_CODE=$?
+cat /logs/verifier/test_output.log
+python3 "$SCRIPT_DIR/verifier.py" --log /logs/verifier/test_output.log --f2p "$SCRIPT_DIR/f2p.json" --p2p "$SCRIPT_DIR/p2p.json" --test-cmds 'python -m pytest -v tests/test_ext.py' --exit-code "$TEST_EXIT_CODE" --out-dir /logs/verifier || { [ "$TEST_EXIT_CODE" -eq 0 ] && echo "1.0" > /logs/verifier/reward.txt || echo "0.0" > /logs/verifier/reward.txt; }
+git checkout e34793226fc0ab80142d23cef2078ab0035a6104 -- tests/test_ext.py || true
+exit 0

heldout_pool/frostming__marko-88e65f1f51c1/tests/verifier.py

@@ -0,0 +1,475 @@
+"""In-container verifier for pr_runtime tasks (graded F2P/P2P reward).
+
+This module is the **standalone verifier** that runs inside the task's
+Docker container, NOT a helper used at generation time. It is read as
+source at generation time, base64-encoded, and embedded into
+``tests/test.sh``. At run time the container decodes it back to a file
+and invokes it after the test suite has run.
+
+Why a graded reward instead of binary pass/fail
+------------------------------------------------
+SWE-bench resolution is binary: a patch "resolves" the issue iff ALL
+FAIL_TO_PASS tests pass AND ALL PASS_TO_PASS tests still pass. That's
+the right signal for an eval leaderboard, but a terrible gradient for
+RL training — an agent that fixes 4 of 5 failing tests scores the same
+0.0 as one that fixes nothing.
+
+So this verifier emits BOTH:
+  * /logs/verifier/reward.txt  — the GRADED scalar (training signal,
+        which Harbor reads):  reward = f2p_rate * p2p_factor
+  * /logs/verifier/reward-details.json — carries the strict SWE-bench
+        ``resolved`` bool (eval signal) PLUS the full breakdown.
+
+Refs: SWE-bench (F2P/P2P semantics), SWE-RL / SWE-Gym (dense reward for
+RL), UTBoost (weak-test coverage lets wrong patches pass — hence we
+record p2p_count so consumers can judge regression-guard strength).
+
+Scoring
+-------
+Given the baked FAIL_TO_PASS / PASS_TO_PASS test-name lists (computed by
+the generation-time two-stage validation) and the agent-run test log:
+
+  f2p_rate   = (# F2P tests now PASSED) / (# F2P tests)
+  p2p_rate   = (# P2P tests still PASSED) / (# P2P tests)   [1.0 if no P2P]
+  p2p_factor = p2p_rate          # regressions scale the reward down
+  reward     = f2p_rate * p2p_factor
+  resolved   = (all F2P pass) AND (all P2P pass)            # strict SWE-bench
+
+Oracle invariant: the gold patch flips every F2P and keeps every P2P,
+so f2p_rate=1.0, p2p_rate=1.0 -> reward=1.0 and resolved=True. This is
+what the T3 oracle gate (reward == 1.0) relies on.
+
+Graceful degradation: if the log can't be parsed into per-test
+statuses (unrecognized runner output), fall back to the exit-code
+reward (1.0 if the suite exited 0, else 0.0) and stamp
+``parse_status="fallback_exitcode"`` — never crash, never silently
+zero out a real fix.
+
+Pure stdlib — uses only ``argparse``, ``json``, ``os``, ``re``, ``sys``.
+The 4 per-runner parsers are condensed ports of
+``repo2rlenv.log_parsers.*`` kept in lockstep via the unit tests under
+``tests/test_pr_runtime_verifier.py``.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import sys
+
+# Canonical statuses. (Plain strings — no typing.Literal so the baked
+# module stays import-light when decoded standalone in the container.)
+PASSED = "PASSED"
+FAILED = "FAILED"
+SKIPPED = "SKIPPED"
+ERROR = "ERROR"
+
+# ---------------------------------------------------------------------------
+# Per-runner log parsers (condensed ports of repo2rlenv.log_parsers.*)
+# ---------------------------------------------------------------------------
+
+_PYTEST_STATUSES = (PASSED, FAILED, SKIPPED, ERROR)
+# Keep these patterns in sync with log_parsers/pytest_parser.py. This module
+# also runs standalone inside task containers, without a repo2rlenv install.
+_PYTEST_PROGRESS = (
+    r"\[\s*\d+%\]|\[\s*\d+\s*/\s*\d+\s*\]"
+    r"|\d+(?:\.\d+)?(?:us|ms|s)|\d+m \d+s|\d+h \d+m"
+)
+_PYTEST_VERBOSE_RE = re.compile(
+    r"^(?P<name>.+?(?:\[.*?\])?)\s+(?P<status>PASSED|FAILED|SKIPPED|ERROR)"
+    rf"(?:\s+\(.*\))?(?:\s+(?:{_PYTEST_PROGRESS}))?$"
+)
+_PYTEST_SUMMARY_NAME_RE = re.compile(r"^(?P<name>.+?(?:\[.*?\])?)(?: - .*)?$")
+# pytest-xdist worker label, e.g. `[gw1] [ 20%] PASSED tests/foo.py::test_x`.
+_PYTEST_XDIST_PREFIX_RE = re.compile(rf"^\[gw\d+\]\s+(?:(?:{_PYTEST_PROGRESS})\s+)?")
+
+
+def parse_pytest(log: str) -> dict[str, str]:
+    """{test_name -> status} from pytest output (verbose or summary)."""
+    out: dict[str, str] = {}
+    if not log:
+        return out
+    for raw in log.split("\n"):
+        line = raw.strip()
+        if not line:
+            continue
+        line = _PYTEST_XDIST_PREFIX_RE.sub("", line, count=1)
+        # Summary lines (STATUS first), preserving the full node ID.
+        leading = None
+        for st in _PYTEST_STATUSES:
+            if line.startswith(st + " ") or line == st:
+                leading = st
+                break
+        if leading is not None:
+            work = line[len(leading) :].strip()
+            if leading == SKIPPED and re.match(r"^\[\d+\](?:\s|$)", work):
+                # Folded skips report a file location, not a parametrized ID.
+                tokens = work.split(maxsplit=2)
+                if len(tokens) < 2:
+                    continue
+                out[tokens[1]] = leading
+            elif m := _PYTEST_SUMMARY_NAME_RE.match(work):
+                out[m.group("name")] = leading
+            continue
+        # Verbose progress (NAME first, STATUS after)
+        # Filter non-test output before attempting the backtracking regex.
+        head = line.split(None, 1)[0]
+        if "::" not in head and not head.endswith(".py"):
+            continue
+        m = _PYTEST_VERBOSE_RE.match(line)
+        if m:
+            name = m.group("name")
+            if "::" in name or name.endswith(".py"):
+                out[name] = m.group("status")
+    return out
+
+
+_GO_TEST_RE = re.compile(r"^\s*---\s+(?P<status>PASS|FAIL|SKIP):\s+(?P<name>\S+)")
+_GO_STATUS = {"PASS": PASSED, "FAIL": FAILED, "SKIP": SKIPPED}
+
+
+def parse_go_test(log: str) -> dict[str, str]:
+    """{test_name -> status} from `go test -v` output."""
+    out: dict[str, str] = {}
+    if not log:
+        return out
+    for raw in log.split("\n"):
+        m = _GO_TEST_RE.match(raw)
+        if m:
+            out[m.group("name")] = _GO_STATUS[m.group("status")]
+    return out
+
+
+# Keep these patterns in sync with log_parsers/cargo_parser.py.
+_CARGO_TEST_RE = re.compile(r"^test\s+(?P<name>\S.*?) \.\.\. (?P<status>ok|FAILED|ignored)\b")
+_CARGO_MODE_RE = re.compile(r" - (?:should panic|compile fail|compile)$")
+_CARGO_DOCTEST_RE = re.compile(r"^(?P<file>\S+) - (?:(?P<item>.+?) )?\(line \d+\)$")
+_CARGO_STATUS = {"ok": PASSED, "FAILED": FAILED, "ignored": SKIPPED}
+_CARGO_DOCTEST_RANK = {SKIPPED: 0, PASSED: 1, FAILED: 2}
+
+
+def parse_cargo_test(log: str) -> dict[str, str]:
+    """{test_name -> status} from `cargo test` output.
+
+    Test modes (` - should panic`) are dropped from names, and doctests are
+    keyed without their `(line N)` so line shifts don't change identity; the
+    worst status among an item's doctests wins.
+    """
+    out: dict[str, str] = {}
+    if not log:
+        return out
+    for raw in log.split("\n"):
+        m = _CARGO_TEST_RE.match(raw)
+        if not m:
+            continue
+        name = _CARGO_MODE_RE.sub("", m.group("name")).rstrip()
+        status = _CARGO_STATUS[m.group("status")]
+        doctest = _CARGO_DOCTEST_RE.match(name)
+        if doctest:
+            item = doctest.group("item")
+            name = f"{doctest.group('file')} - {item}" if item else doctest.group("file")
+            if name in out and _CARGO_DOCTEST_RANK[out[name]] > _CARGO_DOCTEST_RANK[status]:
+                continue
+        out[name] = status
+    return out
+
+
+_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\))?$"
+)
+_JEST_GLYPH = {
+    "✓": PASSED,
+    "√": PASSED,
+    "✕": FAILED,
+    "×": FAILED,
+    "✗": FAILED,
+    "○": 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]:
+    """{test_name -> status} from Jest / Mocha / Vitest output."""
+    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
+    for raw in log.split("\n"):
+        line = raw.rstrip()
+        if not line:
+            continue
+        m = _JEST_FILE_RE.match(line)
+        if m:
+            current_file = m.group("path")
+            describe_stack = []
+            last_test_indent = None
+            continue
+        m = _JEST_TEST_RE.match(line)
+        if m:
+            indent = len(m.group("indent"))
+            name = re.sub(r"^(?:skipped|todo):\s*", "", m.group("name").strip())
+            describes = [d for ind, d in describe_stack if ind < indent]
+            parts = ([current_file] if current_file else []) + describes + [name]
+            out[" > ".join(parts)] = _JEST_GLYPH[m.group("glyph")]
+            last_test_indent = indent
+            continue
+        stripped = line.lstrip()
+        if not stripped or stripped.startswith(
+            ("Tests:", "Test Suites:", "Snapshots:", "Time:", "Ran all", "●", "→", "✗:")
+        ):
+            continue
+        indent_here = len(line) - len(stripped)
+        if current_file and (last_test_indent is None or indent_here < last_test_indent):
+            describe_stack = [(i, d) for i, d in describe_stack if i < indent_here]
+            describe_stack.append((indent_here, stripped))
+    return out
+
+
+def _detect_runner(test_cmds: str) -> str:
+    joined = test_cmds.lower()
+    if "pytest" in joined:
+        return "pytest"
+    if re.search(r"\bgo\s+test\b", joined):
+        return "go"
+    if re.search(r"\bcargo\s+test\b", joined):
+        return "cargo"
+    if any(k in joined for k in ("jest", "mocha", "vitest", "npm test", "yarn test", "pnpm test")):
+        return "jest"
+    return "unknown"
+
+
+def parse_logs(runner: str, log: str) -> dict[str, str]:
+    """Dispatch to the right per-runner parser. Empty dict if unknown."""
+    if runner == "pytest":
+        return parse_pytest(log)
+    if runner == "go":
+        return parse_go_test(log)
+    if runner == "cargo":
+        return parse_cargo_test(log)
+    if runner == "jest":
+        return parse_jest(log)
+    return {}
+
+
+# ---------------------------------------------------------------------------
+# Grading
+# ---------------------------------------------------------------------------
+def _has_go_parent(name: str, status_map: dict[str, str]) -> bool:
+    """Return True if a Go test has an ancestor represented in the status map."""
+    parts = name.split("/")
+
+    for i in range(1, len(parts)):
+        parent = "/".join(parts[:i])
+        if status_map.get(parent) == FAILED:
+            return True
+
+    return False
+
+
+def grade(
+    fail_to_pass: list[str],
+    pass_to_pass: list[str],
+    status_map: dict[str, str],
+    runner: str | None = None,
+) -> dict:
+    """Compute the graded reward + strict resolved bool from a status map.
+
+    f2p_rate   = (# F2P now PASSED) / (# F2P)
+    p2p_rate   = (# P2P still PASSED) / (# P2P)   [1.0 when no P2P]
+    reward     = f2p_rate * p2p_rate                       (dense training signal)
+    resolved   = all F2P pass AND all P2P pass   (SWE-bench TRACKED resolution —
+                 the gold patch always satisfies this, preserving the oracle
+                 invariant)
+
+    Two distinct EVAL signals (see the audit's "tracked vs command resolved"):
+      * `resolved`         — tracked resolution (above). Gold patch -> True.
+      * `command_resolved` — stricter: tracked resolution AND the selected test
+                             command had NO failures outside F2P/P2P AND exit
+                             code 0. Computed in main() where the exit code is
+                             known. A benchmark that wants "the whole command
+                             passed cleanly" gates on this; SWE-bench-style
+                             scoring uses `resolved`.
+
+    `untracked_failed` are FAILED tests in the run that are neither F2P nor
+    P2P (e.g. always-failing/flaky tests pulled in by running a whole test
+    file). They don't change the graded `reward` or tracked `resolved`, but
+    they block `command_resolved` and are recorded for transparency.
+    """
+    f2p_total = len(fail_to_pass)
+    p2p_total = len(pass_to_pass)
+    f2p_set = set(fail_to_pass)
+    p2p_set = set(pass_to_pass)
+    f2p_passed = sum(1 for t in fail_to_pass if status_map.get(t) == PASSED)
+    p2p_passed = sum(1 for t in pass_to_pass if status_map.get(t) == PASSED)
+    # Tests that should have stayed green but regressed (PASS->not-pass).
+    regressions = [t for t in pass_to_pass if status_map.get(t) != PASSED]
+
+    # FAILED tests outside the tracked sets — the selected command isn't clean.
+    if runner == "go":
+        failed_tests = {
+            t
+            for t, s in status_map.items()
+            if s == FAILED and t not in f2p_set and t not in p2p_set
+        }
+
+        untracked_failed = sorted(t for t in failed_tests if not _has_go_parent(t, status_map))
+    else:
+        untracked_failed = sorted(
+            t
+            for t, s in status_map.items()
+            if s == FAILED and t not in f2p_set and t not in p2p_set
+        )
+
+    f2p_rate = (f2p_passed / f2p_total) if f2p_total else 0.0
+    p2p_rate = (p2p_passed / p2p_total) if p2p_total else 1.0
+    reward = f2p_rate * p2p_rate
+    resolved = f2p_total > 0 and f2p_passed == f2p_total and p2p_passed == p2p_total
+
+    return {
+        "reward": round(max(0.0, min(1.0, reward)), 6),
+        "resolved": resolved,
+        "f2p_total": f2p_total,
+        "f2p_passed": f2p_passed,
+        "f2p_rate": round(f2p_rate, 6),
+        "p2p_total": p2p_total,
+        "p2p_passed": p2p_passed,
+        "p2p_rate": round(p2p_rate, 6),
+        "regressions": sorted(regressions),
+        "untracked_failed_count": len(untracked_failed),
+        "untracked_failed": untracked_failed[:20],  # cap the list
+    }
+
+
+# ---------------------------------------------------------------------------
+# Entry point (invoked by tests/test.sh inside the container)
+# ---------------------------------------------------------------------------
+
+
+def _read_json_list(path: str) -> list[str]:
+    try:
+        with open(path, encoding="utf-8") as f:
+            data = json.load(f)
+        return [str(x) for x in data] if isinstance(data, list) else []
+    except (OSError, ValueError):
+        return []
+
+
+def _read_text(path: str) -> str:
+    try:
+        with open(path, encoding="utf-8") as f:
+            return f.read()
+    except (OSError, UnicodeDecodeError):
+        return ""
+
+
+def main(argv: list[str] | None = None) -> int:
+    p = argparse.ArgumentParser(description="pr_runtime graded F2P/P2P verifier")
+    p.add_argument("--log", required=True, help="captured test-run log file")
+    p.add_argument("--f2p", required=True, help="JSON file: FAIL_TO_PASS test names")
+    p.add_argument("--p2p", required=True, help="JSON file: PASS_TO_PASS test names")
+    p.add_argument("--runner", default="", help="pytest|go|cargo|jest (else auto-detect)")
+    p.add_argument("--test-cmds", default="", help="test command string (runner auto-detect)")
+    p.add_argument("--exit-code", type=int, default=1, help="test suite exit code (fallback)")
+    p.add_argument("--out-dir", default="/logs/verifier", help="where to write reward.{txt,json}")
+    args = p.parse_args(argv)
+
+    log = _read_text(args.log)
+    f2p = _read_json_list(args.f2p)
+    p2p = _read_json_list(args.p2p)
+    runner = args.runner.strip() or _detect_runner(args.test_cmds)
+
+    status_map = parse_logs(runner, log)
+
+    if not status_map:
+        # Unparseable runner output → fall back to the binary exit-code reward
+        # (a coarse TRAINING signal) so we never silently zero a real fix on an
+        # unrecognized format. But `resolved` is the strict EVAL signal: without
+        # parsed per-test status we have NO evidence the declared FAIL_TO_PASS
+        # tests passed, so when an F2P oracle exists we must NOT claim resolved.
+        # (resolved stays exit-code-based only when there's no declared oracle,
+        # e.g. --skip-validation.)
+        reward = 1.0 if args.exit_code == 0 else 0.0
+        has_oracle = len(f2p) > 0
+        resolved = (args.exit_code == 0) and not has_oracle
+        breakdown = {
+            "reward": reward,
+            "resolved": resolved,
+            "command_resolved": bool(resolved and args.exit_code == 0),
+            "parse_status": "fallback_exitcode",
+            "eval_trustworthy": not has_oracle,
+            "runner": runner,
+            "f2p_total": len(f2p),
+            "p2p_total": len(p2p),
+            "exit_code": args.exit_code,
+        }
+    else:
+        breakdown = grade(f2p, p2p, status_map, runner)
+        breakdown["parse_status"] = "ok"
+        breakdown["runner"] = runner
+        breakdown["tests_parsed"] = len(status_map)
+        breakdown["exit_code"] = args.exit_code
+        # Strict eval signal: tracked resolution AND a clean command (no
+        # untracked failures, exit code 0). Benchmarks wanting "the whole test
+        # command passed" gate on this; SWE-bench-style scoring uses `resolved`.
+        breakdown["command_resolved"] = bool(
+            breakdown["resolved"]
+            and breakdown["untracked_failed_count"] == 0
+            and args.exit_code == 0
+        )
+        reward = breakdown["reward"]
+
+    os.makedirs(args.out_dir, exist_ok=True)
+    with open(os.path.join(args.out_dir, "reward.txt"), "w", encoding="utf-8") as f:
+        f.write(f"{reward:.6f}\n")
+    with open(os.path.join(args.out_dir, "reward-details.json"), "w", encoding="utf-8") as f:
+        json.dump(breakdown, f, indent=2)
+
+    print(json.dumps(breakdown, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
+
+
+__all__ = [
+    "grade",
+    "main",
+    "parse_cargo_test",
+    "parse_go_test",
+    "parse_jest",
+    "parse_logs",
+    "parse_pytest",
+]

heldout_pool/frostming__marko-b5a628f28dbd/environment/Dockerfile

@@ -0,0 +1,36 @@
+# Auto-generated by Repo2RLEnv pr_runtime
+FROM local/frostming__marko
+WORKDIR /workspace
+# Defensive: ensure git is on PATH at build time. Bootstrap base
+# images vary — some (Python slim) don't ship git; some agents
+# install it; others don't. Re-installing is a no-op when already
+# present. Tries apt-get first (Debian/Ubuntu), then apk (Alpine).
+# Install git + ca-certificates. Minimal images (node:alpine) ship
+# without CA certs, so HTTPS git fetch fails verification.
+RUN (command -v git >/dev/null 2>&1 && [ -e /etc/ssl/certs/ca-certificates.crt ]) || \
+    (apt-get update && apt-get install -y --no-install-recommends git ca-certificates \
+     && rm -rf /var/lib/apt/lists/*) || \
+    (apk add --no-cache git ca-certificates && update-ca-certificates) || true
+# Defensive: the graded F2P/P2P verifier is Python.
+# Language-specific bootstrap images (Go/Rust/Node) may not
+# ship python3 — install it so test.sh can score F2P/P2P. No-op when
+# python3 is already present (every Python-repo image has it).
+RUN command -v python3 >/dev/null 2>&1 || \
+    (apt-get update && apt-get install -y --no-install-recommends python3 \
+     && rm -rf /var/lib/apt/lists/*) || \
+    apk add --no-cache python3 || true
+# Position the working tree at the PR's base commit so subsequent
+# model-patch applications align with the line context the patch
+# was authored against. The fetch is a no-op if the commit is
+# already in the shallow clone.
+RUN git config --global --add safe.directory /workspace \
+    && git fetch --depth 1 origin 3a39989a01d34324809898243eb78c102174efd8 2>/dev/null \
+       || git fetch --unshallow origin 2>/dev/null || true
+RUN git reset --hard 3a39989a01d34324809898243eb78c102174efd8 && git clean -fdx -e .venv -e venv -e __pycache__ -e .tox -e node_modules -e target -e vendor -e .gradle -e .next -e .pytest_cache
+RUN git checkout -q -B base 3a39989a01d34324809898243eb78c102174efd8 \
+    && git remote remove origin 2>/dev/null || true
+RUN for ref in $(git branch --format='%(refname:short)' | grep -vx base); do git branch -D "$ref" 2>/dev/null || true; done \
+    && git tag -l | xargs -r git tag -d >/dev/null 2>&1 || true \
+    && git for-each-ref --format='%(refname)' refs/remotes 2>/dev/null | xargs -r -n1 git update-ref -d 2>/dev/null || true \
+    && git reflog expire --expire=now --all 2>/dev/null || true \
+    && git gc --prune=now 2>/dev/null || true

heldout_pool/frostming__marko-b5a628f28dbd/environment/docker-compose.yaml

@@ -0,0 +1,16 @@
+# Auto-generated by Repo2RLEnv: anti-contamination egress guard.
+# Blackholes the hosts that serve this repo's published fix and hidden
+# tests, so an agent cannot fetch the answer (pip download / git fetch /
+# WebFetch against these fail). General internet stays up so the agent
+# can install itself and reach its model API. See pipelines/_env_guard.py.
+services:
+  main:
+    extra_hosts:
+      - "pypi.org:0.0.0.0"
+      - "pypi.python.org:0.0.0.0"
+      - "files.pythonhosted.org:0.0.0.0"
+      - "github.com:0.0.0.0"
+      - "api.github.com:0.0.0.0"
+      - "raw.githubusercontent.com:0.0.0.0"
+      - "codeload.github.com:0.0.0.0"
+      - "objects.githubusercontent.com:0.0.0.0"

heldout_pool/frostming__marko-b5a628f28dbd/instruction.md

@@ -0,0 +1,10 @@
+# Issue
+
+**Title:** Links with line breaks in their text do not render correctly
+
+## Description
+When a Markdown link's display text contains a line break, the link fails to render as a single, clickable entity. For example, `[This is a\nmulti-line link text](https://example.com)` results in a broken or partially rendered link. The expected behavior is for the entire text, including the line break, to form a single, clickable link to the specified URL.
+
+## Task
+
+Modify the repository so that the issue described above is resolved. The task's test suite verifies your patch by applying it on top of the base commit `3a39989a01d3` and running the modified tests.

heldout_pool/frostming__marko-b5a628f28dbd/solution/patch.diff

@@ -0,0 +1,34 @@
+diff --git a/CHANGELOG.md b/CHANGELOG.md
+index a39481c..a338c44 100644
+--- a/CHANGELOG.md
++++ b/CHANGELOG.md
+@@ -1,3 +1,7 @@
++## Unreleased
++
++- Fix a rendering bug when line breaks exist in a link text. [#126](https://github.com/frostming/marko/issue/126)
++
+ ## v1.2.2(2022-09-22)
+ 
+ - Fix a bug of markdown renderer, the ordered list index isn't increasing. [#112](https://github.com/frostming/marko/pull/112)
+diff --git a/marko/inline.py b/marko/inline.py
+index f497132..a1fc175 100644
+--- a/marko/inline.py
++++ b/marko/inline.py
+@@ -80,6 +80,7 @@ class LineBreak(InlineElement):
+ 
+     def __init__(self, match: "_Match") -> None:
+         self.soft = not match.group(1).startswith(("  ", "\\"))
++        self.children = "\n"
+ 
+ 
+ class InlineHTML(InlineElement):
+@@ -190,9 +191,6 @@ class RawText(InlineElement):
+ 
+     virtual = True
+ 
+-    if TYPE_CHECKING:
+-        children: str
+-
+     def __init__(self, match: str, escape: bool = True) -> None:
+         self.children = match
+         self.escape = escape

heldout_pool/frostming__marko-b5a628f28dbd/solution/solve.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+set -euxo pipefail
+cd /workspace
+git config --global --add safe.directory /workspace
+PATCH="$(dirname "$0")/patch.diff"
+git apply --verbose --reject "$PATCH"

heldout_pool/frostming__marko-b5a628f28dbd/task.toml

@@ -0,0 +1,776 @@
+version = "1.0"
+
+[task]
+name = "commit-runtime/frostming__marko-b5a628f28dbd"
+description = "rendering link with line breaks in the link text Fix #126"
+
+[metadata]
+difficulty = "small"
+category = "bugfix"
+keywords = [
+    "marko",
+    "commit_runtime",
+]
+
+[metadata.repo2env]
+pipeline = "commit_runtime"
+pipeline_version = "0.8.3"
+repo = "frostming/marko"
+ref = "3a39989a01d34324809898243eb78c102174efd8"
+reference = "https://github.com/frostming/marko/commit/b5a628f28dbd2957b5263fd76839eacb3eee001f"
+source_access = "public"
+built_at = "2026-09-24T13:20:09.271533+00:00"
+synthesis_llm = "gemini/gemini-2.5-flash"
+reward_kinds = [
+    "test_execution",
+    "diff_similarity",
+]
+spec_version = "0.2.0"
+content_hash = "sha256:a76f48ab97bc7b381ccc8c39895eac40aa914cb6f91d9334ef3e98bb654590b1"
+
+[metadata.repo2env.commit_runtime]
+commit_sha = "b5a628f28dbd2957b5263fd76839eacb3eee001f"
+parent_sha = "3a39989a01d34324809898243eb78c102174efd8"
+authored_at = "2022-12-02T10:06:06+08:00"
+author_email = "me@frostming.com"
+subject = "fix: rendering link with line breaks in the link text Fix #126"
+fail_to_pass = [
+    "tests/test_spec.py::TestCommonMark::test_atx_headings_001",
+    "tests/test_spec.py::TestCommonMark::test_atx_headings_002",
+    "tests/test_spec.py::TestCommonMark::test_atx_headings_003",
+    "tests/test_spec.py::TestCommonMark::test_atx_headings_004",
+    "tests/test_spec.py::TestCommonMark::test_atx_headings_005",
+    "tests/test_spec.py::TestCommonMark::test_atx_headings_006",
+    "tests/test_spec.py::TestCommonMark::test_atx_headings_007",
+    "tests/test_spec.py::TestCommonMark::test_atx_headings_008",
+    "tests/test_spec.py::TestCommonMark::test_atx_headings_009",
+    "tests/test_spec.py::TestCommonMark::test_atx_headings_010",
+    "tests/test_spec.py::TestCommonMark::test_atx_headings_011",
+    "tests/test_spec.py::TestCommonMark::test_atx_headings_012",
+    "tests/test_spec.py::TestCommonMark::test_atx_headings_013",
+    "tests/test_spec.py::TestCommonMark::test_atx_headings_014",
+    "tests/test_spec.py::TestCommonMark::test_atx_headings_015",
+    "tests/test_spec.py::TestCommonMark::test_atx_headings_016",
+    "tests/test_spec.py::TestCommonMark::test_atx_headings_017",
+    "tests/test_spec.py::TestCommonMark::test_atx_headings_018",
+    "tests/test_spec.py::TestCommonMark::test_autolinks_001",
+    "tests/test_spec.py::TestCommonMark::test_autolinks_002",
+    "tests/test_spec.py::TestCommonMark::test_autolinks_003",
+    "tests/test_spec.py::TestCommonMark::test_autolinks_004",
+    "tests/test_spec.py::TestCommonMark::test_autolinks_005",
+    "tests/test_spec.py::TestCommonMark::test_autolinks_006",
+    "tests/test_spec.py::TestCommonMark::test_autolinks_007",
+    "tests/test_spec.py::TestCommonMark::test_autolinks_008",
+    "tests/test_spec.py::TestCommonMark::test_autolinks_009",
+    "tests/test_spec.py::TestCommonMark::test_autolinks_010",
+    "tests/test_spec.py::TestCommonMark::test_autolinks_011",
+    "tests/test_spec.py::TestCommonMark::test_autolinks_012",
+    "tests/test_spec.py::TestCommonMark::test_autolinks_013",
+    "tests/test_spec.py::TestCommonMark::test_autolinks_014",
+    "tests/test_spec.py::TestCommonMark::test_autolinks_015",
+    "tests/test_spec.py::TestCommonMark::test_autolinks_016",
+    "tests/test_spec.py::TestCommonMark::test_autolinks_017",
+    "tests/test_spec.py::TestCommonMark::test_autolinks_018",
+    "tests/test_spec.py::TestCommonMark::test_autolinks_019",
+    "tests/test_spec.py::TestCommonMark::test_backslash_escapes_001",
+    "tests/test_spec.py::TestCommonMark::test_backslash_escapes_002",
+    "tests/test_spec.py::TestCommonMark::test_backslash_escapes_003",
+    "tests/test_spec.py::TestCommonMark::test_backslash_escapes_004",
+    "tests/test_spec.py::TestCommonMark::test_backslash_escapes_005",
+    "tests/test_spec.py::TestCommonMark::test_backslash_escapes_006",
+    "tests/test_spec.py::TestCommonMark::test_backslash_escapes_007",
+    "tests/test_spec.py::TestCommonMark::test_backslash_escapes_008",
+    "tests/test_spec.py::TestCommonMark::test_backslash_escapes_009",
+    "tests/test_spec.py::TestCommonMark::test_backslash_escapes_010",
+    "tests/test_spec.py::TestCommonMark::test_backslash_escapes_011",
+    "tests/test_spec.py::TestCommonMark::test_backslash_escapes_012",
+    "tests/test_spec.py::TestCommonMark::test_backslash_escapes_013",
+    "tests/test_spec.py::TestCommonMark::test_blank_lines_001",
+    "tests/test_spec.py::TestCommonMark::test_block_quotes_001",
+    "tests/test_spec.py::TestCommonMark::test_block_quotes_002",
+    "tests/test_spec.py::TestCommonMark::test_block_quotes_003",
+    "tests/test_spec.py::TestCommonMark::test_block_quotes_004",
+    "tests/test_spec.py::TestCommonMark::test_block_quotes_005",
+    "tests/test_spec.py::TestCommonMark::test_block_quotes_006",
+    "tests/test_spec.py::TestCommonMark::test_block_quotes_007",
+    "tests/test_spec.py::TestCommonMark::test_block_quotes_008",
+    "tests/test_spec.py::TestCommonMark::test_block_quotes_009",
+    "tests/test_spec.py::TestCommonMark::test_block_quotes_010",
+    "tests/test_spec.py::TestCommonMark::test_block_quotes_011",
+    "tests/test_spec.py::TestCommonMark::test_block_quotes_012",
+    "tests/test_spec.py::TestCommonMark::test_block_quotes_013",
+    "tests/test_spec.py::TestCommonMark::test_block_quotes_014",
+    "tests/test_spec.py::TestCommonMark::test_block_quotes_015",
+    "tests/test_spec.py::TestCommonMark::test_block_quotes_016",
+    "tests/test_spec.py::TestCommonMark::test_block_quotes_017",
+    "tests/test_spec.py::TestCommonMark::test_block_quotes_018",
+    "tests/test_spec.py::TestCommonMark::test_block_quotes_019",
+    "tests/test_spec.py::TestCommonMark::test_block_quotes_020",
+    "tests/test_spec.py::TestCommonMark::test_block_quotes_021",
+    "tests/test_spec.py::TestCommonMark::test_block_quotes_022",
+    "tests/test_spec.py::TestCommonMark::test_block_quotes_023",
+    "tests/test_spec.py::TestCommonMark::test_block_quotes_024",
+    "tests/test_spec.py::TestCommonMark::test_block_quotes_025",
+    "tests/test_spec.py::TestCommonMark::test_code_spans_001",
+    "tests/test_spec.py::TestCommonMark::test_code_spans_002",
+    "tests/test_spec.py::TestCommonMark::test_code_spans_003",
+    "tests/test_spec.py::TestCommonMark::test_code_spans_004",
+    "tests/test_spec.py::TestCommonMark::test_code_spans_005",
+    "tests/test_spec.py::TestCommonMark::test_code_spans_006",
+    "tests/test_spec.py::TestCommonMark::test_code_spans_007",
+    "tests/test_spec.py::TestCommonMark::test_code_spans_008",
+    "tests/test_spec.py::TestCommonMark::test_code_spans_009",
+    "tests/test_spec.py::TestCommonMark::test_code_spans_010",
+    "tests/test_spec.py::TestCommonMark::test_code_spans_011",
+    "tests/test_spec.py::TestCommonMark::test_code_spans_012",
+    "tests/test_spec.py::TestCommonMark::test_code_spans_013",
+    "tests/test_spec.py::TestCommonMark::test_code_spans_014",
+    "tests/test_spec.py::TestCommonMark::test_code_spans_015",
+    "tests/test_spec.py::TestCommonMark::test_code_spans_016",
+    "tests/test_spec.py::TestCommonMark::test_code_spans_017",
+    "tests/test_spec.py::TestCommonMark::test_code_spans_018",
+    "tests/test_spec.py::TestCommonMark::test_code_spans_019",
+    "tests/test_spec.py::TestCommonMark::test_code_spans_020",
+    "tests/test_spec.py::TestCommonMark::test_code_spans_021",
+    "tests/test_spec.py::TestCommonMark::test_code_spans_022",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_001",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_002",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_003",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_004",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_005",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_006",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_007",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_008",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_009",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_010",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_011",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_012",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_013",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_014",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_015",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_016",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_017",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_018",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_019",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_020",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_021",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_022",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_023",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_024",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_025",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_026",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_027",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_028",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_029",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_030",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_031",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_032",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_033",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_034",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_035",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_036",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_037",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_038",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_039",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_040",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_041",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_042",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_043",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_044",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_045",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_046",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_047",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_048",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_049",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_050",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_051",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_052",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_053",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_054",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_055",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_056",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_057",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_058",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_059",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_060",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_061",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_062",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_063",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_064",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_065",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_066",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_067",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_068",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_069",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_070",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_071",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_072",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_073",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_074",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_075",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_076",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_077",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_078",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_079",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_080",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_081",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_082",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_083",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_084",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_085",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_086",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_087",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_088",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_089",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_090",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_091",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_092",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_093",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_094",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_095",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_096",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_097",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_098",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_099",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_100",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_101",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_102",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_103",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_104",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_105",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_106",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_107",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_108",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_109",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_110",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_111",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_112",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_113",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_114",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_115",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_116",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_117",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_118",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_119",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_120",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_121",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_122",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_123",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_124",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_125",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_126",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_127",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_128",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_129",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_130",
+    "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_131",
+    "tests/test_spec.py::TestCommonMark::test_entity_and_numeric_character_references_001",
+    "tests/test_spec.py::TestCommonMark::test_entity_and_numeric_character_references_002",
+    "tests/test_spec.py::TestCommonMark::test_entity_and_numeric_character_references_003",
+    "tests/test_spec.py::TestCommonMark::test_entity_and_numeric_character_references_004",
+    "tests/test_spec.py::TestCommonMark::test_entity_and_numeric_character_references_005",
+    "tests/test_spec.py::TestCommonMark::test_entity_and_numeric_character_references_006",
+    "tests/test_spec.py::TestCommonMark::test_entity_and_numeric_character_references_007",
+    "tests/test_spec.py::TestCommonMark::test_entity_and_numeric_character_references_008",
+    "tests/test_spec.py::TestCommonMark::test_entity_and_numeric_character_references_009",
+    "tests/test_spec.py::TestCommonMark::test_entity_and_numeric_character_references_010",
+    "tests/test_spec.py::TestCommonMark::test_entity_and_numeric_character_references_011",
+    "tests/test_spec.py::TestCommonMark::test_entity_and_numeric_character_references_012",
+    "tests/test_spec.py::TestCommonMark::test_entity_and_numeric_character_references_013",
+    "tests/test_spec.py::TestCommonMark::test_entity_and_numeric_character_references_014",
+    "tests/test_spec.py::TestCommonMark::test_entity_and_numeric_character_references_015",
+    "tests/test_spec.py::TestCommonMark::test_entity_and_numeric_character_references_016",
+    "tests/test_spec.py::TestCommonMark::test_entity_and_numeric_character_references_017",
+    "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_001",
+    "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_002",
+    "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_003",
+    "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_004",
+    "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_005",
+    "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_006",
+    "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_007",
+    "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_008",
+    "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_009",
+    "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_010",
+    "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_011",
+    "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_012",
+    "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_013",
+    "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_014",
+    "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_015",
+    "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_016",
+    "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_017",
+    "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_018",
+    "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_019",
+    "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_020",
+    "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_021",
+    "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_022",
+    "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_023",
+    "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_024",
+    "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_025",
+    "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_026",
+    "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_027",
+    "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_028",
+    "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_029",
+    "tests/test_spec.py::TestCommonMark::test_hard_line_breaks_001",
+    "tests/test_spec.py::TestCommonMark::test_hard_line_breaks_002",
+    "tests/test_spec.py::TestCommonMark::test_hard_line_breaks_003",
+    "tests/test_spec.py::TestCommonMark::test_hard_line_breaks_004",
+    "tests/test_spec.py::TestCommonMark::test_hard_line_breaks_005",
+    "tests/test_spec.py::TestCommonMark::test_hard_line_breaks_006",
+    "tests/test_spec.py::TestCommonMark::test_hard_line_breaks_007",
+    "tests/test_spec.py::TestCommonMark::test_hard_line_breaks_008",
+    "tests/test_spec.py::TestCommonMark::test_hard_line_breaks_009",
+    "tests/test_spec.py::TestCommonMark::test_hard_line_breaks_010",
+    "tests/test_spec.py::TestCommonMark::test_hard_line_breaks_011",
+    "tests/test_spec.py::TestCommonMark::test_hard_line_breaks_012",
+    "tests/test_spec.py::TestCommonMark::test_hard_line_breaks_013",
+    "tests/test_spec.py::TestCommonMark::test_hard_line_breaks_014",
+    "tests/test_spec.py::TestCommonMark::test_hard_line_breaks_015",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_001",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_002",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_003",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_004",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_005",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_006",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_007",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_008",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_009",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_010",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_011",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_012",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_013",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_014",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_015",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_016",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_017",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_018",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_019",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_020",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_021",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_022",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_023",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_024",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_025",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_026",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_027",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_028",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_029",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_030",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_031",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_032",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_033",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_034",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_035",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_036",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_037",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_038",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_039",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_040",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_041",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_042",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_043",
+    "tests/test_spec.py::TestCommonMark::test_html_blocks_044",
+    "tests/test_spec.py::TestCommonMark::test_images_001",
+    "tests/test_spec.py::TestCommonMark::test_images_002",
+    "tests/test_spec.py::TestCommonMark::test_images_003",
+    "tests/test_spec.py::TestCommonMark::test_images_004",
+    "tests/test_spec.py::TestCommonMark::test_images_005",
+    "tests/test_spec.py::TestCommonMark::test_images_006",
+    "tests/test_spec.py::TestCommonMark::test_images_007",
+    "tests/test_spec.py::TestCommonMark::test_images_008",
+    "tests/test_spec.py::TestCommonMark::test_images_009",
+    "tests/test_spec.py::TestCommonMark::test_images_010",
+    "tests/test_spec.py::TestCommonMark::test_images_011",
+    "tests/test_spec.py::TestCommonMark::test_images_012",
+    "tests/test_spec.py::TestCommonMark::test_images_013",
+    "tests/test_spec.py::TestCommonMark::test_images_014",
+    "tests/test_spec.py::TestCommonMark::test_images_015",
+    "tests/test_spec.py::TestCommonMark::test_images_016",
+    "tests/test_spec.py::TestCommonMark::test_images_017",
+    "tests/test_spec.py::TestCommonMark::test_images_018",
+    "tests/test_spec.py::TestCommonMark::test_images_019",
+    "tests/test_spec.py::TestCommonMark::test_images_020",
+    "tests/test_spec.py::TestCommonMark::test_images_021",
+    "tests/test_spec.py::TestCommonMark::test_images_022",
+    "tests/test_spec.py::TestCommonMark::test_indented_code_blocks_001",
+    "tests/test_spec.py::TestCommonMark::test_indented_code_blocks_002",
+    "tests/test_spec.py::TestCommonMark::test_indented_code_blocks_003",
+    "tests/test_spec.py::TestCommonMark::test_indented_code_blocks_004",
+    "tests/test_spec.py::TestCommonMark::test_indented_code_blocks_005",
+    "tests/test_spec.py::TestCommonMark::test_indented_code_blocks_006",
+    "tests/test_spec.py::TestCommonMark::test_indented_code_blocks_007",
+    "tests/test_spec.py::TestCommonMark::test_indented_code_blocks_008",
+    "tests/test_spec.py::TestCommonMark::test_indented_code_blocks_009",
+    "tests/test_spec.py::TestCommonMark::test_indented_code_blocks_010",
+    "tests/test_spec.py::TestCommonMark::test_indented_code_blocks_011",
+    "tests/test_spec.py::TestCommonMark::test_indented_code_blocks_012",
+    "tests/test_spec.py::TestCommonMark::test_inlines_001",
+    "tests/test_spec.py::TestCommonMark::test_line_break_in_link_text",
+    "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_001",
+    "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_002",
+    "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_003",
+    "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_004",
+    "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_005",
+    "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_006",
+    "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_007",
+    "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_008",
+    "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_009",
+    "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_010",
+    "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_011",
+    "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_012",
+    "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_013",
+    "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_014",
+    "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_015",
+    "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_016",
+    "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_017",
+    "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_018",
+    "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_019",
+    "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_020",
+    "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_021",
+    "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_022",
+    "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_023",
+    "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_024",
+    "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_025",
+    "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_026",
+    "tests/test_spec.py::TestCommonMark::test_links_001",
+    "tests/test_spec.py::TestCommonMark::test_links_002",
+    "tests/test_spec.py::TestCommonMark::test_links_003",
+    "tests/test_spec.py::TestCommonMark::test_links_004",
+    "tests/test_spec.py::TestCommonMark::test_links_005",
+    "tests/test_spec.py::TestCommonMark::test_links_006",
+    "tests/test_spec.py::TestCommonMark::test_links_007",
+    "tests/test_spec.py::TestCommonMark::test_links_008",
+    "tests/test_spec.py::TestCommonMark::test_links_009",
+    "tests/test_spec.py::TestCommonMark::test_links_010",
+    "tests/test_spec.py::TestCommonMark::test_links_011",
+    "tests/test_spec.py::TestCommonMark::test_links_012",
+    "tests/test_spec.py::TestCommonMark::test_links_013",
+    "tests/test_spec.py::TestCommonMark::test_links_014",
+    "tests/test_spec.py::TestCommonMark::test_links_015",
+    "tests/test_spec.py::TestCommonMark::test_links_016",
+    "tests/test_spec.py::TestCommonMark::test_links_017",
+    "tests/test_spec.py::TestCommonMark::test_links_018",
+    "tests/test_spec.py::TestCommonMark::test_links_019",
+    "tests/test_spec.py::TestCommonMark::test_links_020",
+    "tests/test_spec.py::TestCommonMark::test_links_021",
+    "tests/test_spec.py::TestCommonMark::test_links_022",
+    "tests/test_spec.py::TestCommonMark::test_links_023",
+    "tests/test_spec.py::TestCommonMark::test_links_024",
+    "tests/test_spec.py::TestCommonMark::test_links_025",
+    "tests/test_spec.py::TestCommonMark::test_links_026",
+    "tests/test_spec.py::TestCommonMark::test_links_027",
+    "tests/test_spec.py::TestCommonMark::test_links_028",
+    "tests/test_spec.py::TestCommonMark::test_links_029",
+    "tests/test_spec.py::TestCommonMark::test_links_030",
+    "tests/test_spec.py::TestCommonMark::test_links_031",
+    "tests/test_spec.py::TestCommonMark::test_links_032",
+    "tests/test_spec.py::TestCommonMark::test_links_033",
+    "tests/test_spec.py::TestCommonMark::test_links_034",
+    "tests/test_spec.py::TestCommonMark::test_links_035",
+    "tests/test_spec.py::TestCommonMark::test_links_036",
+    "tests/test_spec.py::TestCommonMark::test_links_037",
+    "tests/test_spec.py::TestCommonMark::test_links_038",
+    "tests/test_spec.py::TestCommonMark::test_links_039",
+    "tests/test_spec.py::TestCommonMark::test_links_040",
+    "tests/test_spec.py::TestCommonMark::test_links_041",
+    "tests/test_spec.py::TestCommonMark::test_links_042",
+    "tests/test_spec.py::TestCommonMark::test_links_043",
+    "tests/test_spec.py::TestCommonMark::test_links_044",
+    "tests/test_spec.py::TestCommonMark::test_links_045",
+    "tests/test_spec.py::TestCommonMark::test_links_046",
+    "tests/test_spec.py::TestCommonMark::test_links_047",
+    "tests/test_spec.py::TestCommonMark::test_links_048",
+    "tests/test_spec.py::TestCommonMark::test_links_049",
+    "tests/test_spec.py::TestCommonMark::test_links_050",
+    "tests/test_spec.py::TestCommonMark::test_links_051",
+    "tests/test_spec.py::TestCommonMark::test_links_052",
+    "tests/test_spec.py::TestCommonMark::test_links_053",
+    "tests/test_spec.py::TestCommonMark::test_links_054",
+    "tests/test_spec.py::TestCommonMark::test_links_055",
+    "tests/test_spec.py::TestCommonMark::test_links_056",
+    "tests/test_spec.py::TestCommonMark::test_links_057",
+    "tests/test_spec.py::TestCommonMark::test_links_058",
+    "tests/test_spec.py::TestCommonMark::test_links_059",
+    "tests/test_spec.py::TestCommonMark::test_links_060",
+    "tests/test_spec.py::TestCommonMark::test_links_061",
+    "tests/test_spec.py::TestCommonMark::test_links_062",
+    "tests/test_spec.py::TestCommonMark::test_links_063",
+    "tests/test_spec.py::TestCommonMark::test_links_064",
+    "tests/test_spec.py::TestCommonMark::test_links_065",
+    "tests/test_spec.py::TestCommonMark::test_links_066",
+    "tests/test_spec.py::TestCommonMark::test_links_067",
+    "tests/test_spec.py::TestCommonMark::test_links_068",
+    "tests/test_spec.py::TestCommonMark::test_links_069",
+    "tests/test_spec.py::TestCommonMark::test_links_070",
+    "tests/test_spec.py::TestCommonMark::test_links_071",
+    "tests/test_spec.py::TestCommonMark::test_links_072",
+    "tests/test_spec.py::TestCommonMark::test_links_073",
+    "tests/test_spec.py::TestCommonMark::test_links_074",
+    "tests/test_spec.py::TestCommonMark::test_links_075",
+    "tests/test_spec.py::TestCommonMark::test_links_076",
+    "tests/test_spec.py::TestCommonMark::test_links_077",
+    "tests/test_spec.py::TestCommonMark::test_links_078",
+    "tests/test_spec.py::TestCommonMark::test_links_079",
+    "tests/test_spec.py::TestCommonMark::test_links_080",
+    "tests/test_spec.py::TestCommonMark::test_links_081",
+    "tests/test_spec.py::TestCommonMark::test_links_082",
+    "tests/test_spec.py::TestCommonMark::test_links_083",
+    "tests/test_spec.py::TestCommonMark::test_links_084",
+    "tests/test_spec.py::TestCommonMark::test_links_085",
+    "tests/test_spec.py::TestCommonMark::test_links_086",
+    "tests/test_spec.py::TestCommonMark::test_links_087",
+    "tests/test_spec.py::TestCommonMark::test_links_088",
+    "tests/test_spec.py::TestCommonMark::test_links_089",
+    "tests/test_spec.py::TestCommonMark::test_links_090",
+    "tests/test_spec.py::TestCommonMark::test_list_items_001",
+    "tests/test_spec.py::TestCommonMark::test_list_items_002",
+    "tests/test_spec.py::TestCommonMark::test_list_items_003",
+    "tests/test_spec.py::TestCommonMark::test_list_items_004",
+    "tests/test_spec.py::TestCommonMark::test_list_items_005",
+    "tests/test_spec.py::TestCommonMark::test_list_items_006",
+    "tests/test_spec.py::TestCommonMark::test_list_items_007",
+    "tests/test_spec.py::TestCommonMark::test_list_items_008",
+    "tests/test_spec.py::TestCommonMark::test_list_items_009",
+    "tests/test_spec.py::TestCommonMark::test_list_items_010",
+    "tests/test_spec.py::TestCommonMark::test_list_items_011",
+    "tests/test_spec.py::TestCommonMark::test_list_items_012",
+    "tests/test_spec.py::TestCommonMark::test_list_items_013",
+    "tests/test_spec.py::TestCommonMark::test_list_items_014",
+    "tests/test_spec.py::TestCommonMark::test_list_items_015",
+    "tests/test_spec.py::TestCommonMark::test_list_items_016",
+    "tests/test_spec.py::TestCommonMark::test_list_items_017",
+    "tests/test_spec.py::TestCommonMark::test_list_items_018",
+    "tests/test_spec.py::TestCommonMark::test_list_items_019",
+    "tests/test_spec.py::TestCommonMark::test_list_items_020",
+    "tests/test_spec.py::TestCommonMark::test_list_items_021",
+    "tests/test_spec.py::TestCommonMark::test_list_items_022",
+    "tests/test_spec.py::TestCommonMark::test_list_items_023",
+    "tests/test_spec.py::TestCommonMark::test_list_items_024",
+    "tests/test_spec.py::TestCommonMark::test_list_items_025",
+    "tests/test_spec.py::TestCommonMark::test_list_items_026",
+    "tests/test_spec.py::TestCommonMark::test_list_items_027",
+    "tests/test_spec.py::TestCommonMark::test_list_items_028",
+    "tests/test_spec.py::TestCommonMark::test_list_items_029",
+    "tests/test_spec.py::TestCommonMark::test_list_items_030",
+    "tests/test_spec.py::TestCommonMark::test_list_items_031",
+    "tests/test_spec.py::TestCommonMark::test_list_items_032",
+    "tests/test_spec.py::TestCommonMark::test_list_items_033",
+    "tests/test_spec.py::TestCommonMark::test_list_items_034",
+    "tests/test_spec.py::TestCommonMark::test_list_items_035",
+    "tests/test_spec.py::TestCommonMark::test_list_items_036",
+    "tests/test_spec.py::TestCommonMark::test_list_items_037",
+    "tests/test_spec.py::TestCommonMark::test_list_items_038",
+    "tests/test_spec.py::TestCommonMark::test_list_items_039",
+    "tests/test_spec.py::TestCommonMark::test_list_items_040",
+    "tests/test_spec.py::TestCommonMark::test_list_items_041",
+    "tests/test_spec.py::TestCommonMark::test_list_items_042",
+    "tests/test_spec.py::TestCommonMark::test_list_items_043",
+    "tests/test_spec.py::TestCommonMark::test_list_items_044",
+    "tests/test_spec.py::TestCommonMark::test_list_items_045",
+    "tests/test_spec.py::TestCommonMark::test_list_items_046",
+    "tests/test_spec.py::TestCommonMark::test_list_items_047",
+    "tests/test_spec.py::TestCommonMark::test_list_items_048",
+    "tests/test_spec.py::TestCommonMark::test_lists_001",
+    "tests/test_spec.py::TestCommonMark::test_lists_002",
+    "tests/test_spec.py::TestCommonMark::test_lists_003",
+    "tests/test_spec.py::TestCommonMark::test_lists_004",
+    "tests/test_spec.py::TestCommonMark::test_lists_005",
+    "tests/test_spec.py::TestCommonMark::test_lists_006",
+    "tests/test_spec.py::TestCommonMark::test_lists_007",
+    "tests/test_spec.py::TestCommonMark::test_lists_008",
+    "tests/test_spec.py::TestCommonMark::test_lists_009",
+    "tests/test_spec.py::TestCommonMark::test_lists_010",
+    "tests/test_spec.py::TestCommonMark::test_lists_011",
+    "tests/test_spec.py::TestCommonMark::test_lists_012",
+    "tests/test_spec.py::TestCommonMark::test_lists_013",
+    "tests/test_spec.py::TestCommonMark::test_lists_014",
+    "tests/test_spec.py::TestCommonMark::test_lists_015",
+    "tests/test_spec.py::TestCommonMark::test_lists_016",
+    "tests/test_spec.py::TestCommonMark::test_lists_017",
+    "tests/test_spec.py::TestCommonMark::test_lists_018",
+    "tests/test_spec.py::TestCommonMark::test_lists_019",
+    "tests/test_spec.py::TestCommonMark::test_lists_020",
+    "tests/test_spec.py::TestCommonMark::test_lists_021",
+    "tests/test_spec.py::TestCommonMark::test_lists_022",
+    "tests/test_spec.py::TestCommonMark::test_lists_023",
+    "tests/test_spec.py::TestCommonMark::test_lists_024",
+    "tests/test_spec.py::TestCommonMark::test_lists_025",
+    "tests/test_spec.py::TestCommonMark::test_lists_026",
+    "tests/test_spec.py::TestCommonMark::test_paragraphs_001",
+    "tests/test_spec.py::TestCommonMark::test_paragraphs_002",
+    "tests/test_spec.py::TestCommonMark::test_paragraphs_003",
+    "tests/test_spec.py::TestCommonMark::test_paragraphs_004",
+    "tests/test_spec.py::TestCommonMark::test_paragraphs_005",
+    "tests/test_spec.py::TestCommonMark::test_paragraphs_006",
+    "tests/test_spec.py::TestCommonMark::test_paragraphs_007",
+    "tests/test_spec.py::TestCommonMark::test_paragraphs_008",
+    "tests/test_spec.py::TestCommonMark::test_precedence_001",
+    "tests/test_spec.py::TestCommonMark::test_raw_html_001",
+    "tests/test_spec.py::TestCommonMark::test_raw_html_002",
+    "tests/test_spec.py::TestCommonMark::test_raw_html_003",
+    "tests/test_spec.py::TestCommonMark::test_raw_html_004",
+    "tests/test_spec.py::TestCommonMark::test_raw_html_005",
+    "tests/test_spec.py::TestCommonMark::test_raw_html_006",
+    "tests/test_spec.py::TestCommonMark::test_raw_html_007",
+    "tests/test_spec.py::TestCommonMark::test_raw_html_008",
+    "tests/test_spec.py::TestCommonMark::test_raw_html_009",
+    "tests/test_spec.py::TestCommonMark::test_raw_html_010",
+    "tests/test_spec.py::TestCommonMark::test_raw_html_011",
+    "tests/test_spec.py::TestCommonMark::test_raw_html_012",
+    "tests/test_spec.py::TestCommonMark::test_raw_html_013",
+    "tests/test_spec.py::TestCommonMark::test_raw_html_014",
+    "tests/test_spec.py::TestCommonMark::test_raw_html_015",
+    "tests/test_spec.py::TestCommonMark::test_raw_html_016",
+    "tests/test_spec.py::TestCommonMark::test_raw_html_017",
+    "tests/test_spec.py::TestCommonMark::test_raw_html_018",
+    "tests/test_spec.py::TestCommonMark::test_raw_html_019",
+    "tests/test_spec.py::TestCommonMark::test_raw_html_020",
+    "tests/test_spec.py::TestCommonMark::test_raw_html_021",
+    "tests/test_spec.py::TestCommonMark::test_setext_headings_001",
+    "tests/test_spec.py::TestCommonMark::test_setext_headings_002",
+    "tests/test_spec.py::TestCommonMark::test_setext_headings_003",
+    "tests/test_spec.py::TestCommonMark::test_setext_headings_004",
+    "tests/test_spec.py::TestCommonMark::test_setext_headings_005",
+    "tests/test_spec.py::TestCommonMark::test_setext_headings_006",
+    "tests/test_spec.py::TestCommonMark::test_setext_headings_007",
+    "tests/test_spec.py::TestCommonMark::test_setext_headings_008",
+    "tests/test_spec.py::TestCommonMark::test_setext_headings_009",
+    "tests/test_spec.py::TestCommonMark::test_setext_headings_010",
+    "tests/test_spec.py::TestCommonMark::test_setext_headings_011",
+    "tests/test_spec.py::TestCommonMark::test_setext_headings_012",
+    "tests/test_spec.py::TestCommonMark::test_setext_headings_013",
+    "tests/test_spec.py::TestCommonMark::test_setext_headings_014",
+    "tests/test_spec.py::TestCommonMark::test_setext_headings_015",
+    "tests/test_spec.py::TestCommonMark::test_setext_headings_016",
+    "tests/test_spec.py::TestCommonMark::test_setext_headings_017",
+    "tests/test_spec.py::TestCommonMark::test_setext_headings_018",
+    "tests/test_spec.py::TestCommonMark::test_setext_headings_019",
+    "tests/test_spec.py::TestCommonMark::test_setext_headings_020",
+    "tests/test_spec.py::TestCommonMark::test_setext_headings_021",
+    "tests/test_spec.py::TestCommonMark::test_setext_headings_022",
+    "tests/test_spec.py::TestCommonMark::test_setext_headings_023",
+    "tests/test_spec.py::TestCommonMark::test_setext_headings_024",
+    "tests/test_spec.py::TestCommonMark::test_setext_headings_025",
+    "tests/test_spec.py::TestCommonMark::test_setext_headings_026",
+    "tests/test_spec.py::TestCommonMark::test_setext_headings_027",
+    "tests/test_spec.py::TestCommonMark::test_soft_line_breaks_001",
+    "tests/test_spec.py::TestCommonMark::test_soft_line_breaks_002",
+    "tests/test_spec.py::TestCommonMark::test_tabs_001",
+    "tests/test_spec.py::TestCommonMark::test_tabs_002",
+    "tests/test_spec.py::TestCommonMark::test_tabs_003",
+    "tests/test_spec.py::TestCommonMark::test_tabs_004",
+    "tests/test_spec.py::TestCommonMark::test_tabs_005",
+    "tests/test_spec.py::TestCommonMark::test_tabs_006",
+    "tests/test_spec.py::TestCommonMark::test_tabs_007",
+    "tests/test_spec.py::TestCommonMark::test_tabs_008",
+    "tests/test_spec.py::TestCommonMark::test_tabs_009",
+    "tests/test_spec.py::TestCommonMark::test_tabs_010",
+    "tests/test_spec.py::TestCommonMark::test_tabs_011",
+    "tests/test_spec.py::TestCommonMark::test_textual_content_001",
+    "tests/test_spec.py::TestCommonMark::test_textual_content_002",
+    "tests/test_spec.py::TestCommonMark::test_textual_content_003",
+    "tests/test_spec.py::TestCommonMark::test_thematic_breaks_001",
+    "tests/test_spec.py::TestCommonMark::test_thematic_breaks_002",
+    "tests/test_spec.py::TestCommonMark::test_thematic_breaks_003",
+    "tests/test_spec.py::TestCommonMark::test_thematic_breaks_004",
+    "tests/test_spec.py::TestCommonMark::test_thematic_breaks_005",
+    "tests/test_spec.py::TestCommonMark::test_thematic_breaks_006",
+    "tests/test_spec.py::TestCommonMark::test_thematic_breaks_007",
+    "tests/test_spec.py::TestCommonMark::test_thematic_breaks_008",
+    "tests/test_spec.py::TestCommonMark::test_thematic_breaks_009",
+    "tests/test_spec.py::TestCommonMark::test_thematic_breaks_010",
+    "tests/test_spec.py::TestCommonMark::test_thematic_breaks_011",
+    "tests/test_spec.py::TestCommonMark::test_thematic_breaks_012",
+    "tests/test_spec.py::TestCommonMark::test_thematic_breaks_013",
+    "tests/test_spec.py::TestCommonMark::test_thematic_breaks_014",
+    "tests/test_spec.py::TestCommonMark::test_thematic_breaks_015",
+    "tests/test_spec.py::TestCommonMark::test_thematic_breaks_016",
+    "tests/test_spec.py::TestCommonMark::test_thematic_breaks_017",
+    "tests/test_spec.py::TestCommonMark::test_thematic_breaks_018",
+    "tests/test_spec.py::TestCommonMark::test_thematic_breaks_019",
+]
+pass_to_pass = [
+    "tests/test_spec.py::TestCommonMark::test_greedy_consume_prefix",
+    "tests/test_spec.py::TestCommonMark::test_mixed_tab_space_in_list_item",
+    "tests/test_spec.py::TestCommonMark::test_parse_nbsp_no_crash",
+    "tests/test_spec.py::TestGFM::test_atx_headings_001",
+    "tests/test_spec.py::TestGFM::test_atx_headings_002",
+    "tests/test_spec.py::TestGFM::test_atx_headings_003",
+    "tests/test_spec.py::TestGFM::test_atx_headings_004",
+    "tests/test_spec.py::TestGFM::test_atx_headings_005",
+    "tests/test_spec.py::TestGFM::test_atx_headings_006",
+    "tests/test_spec.py::TestGFM::test_atx_headings_007",
+    "tests/test_spec.py::TestGFM::test_atx_headings_008",
+    "tests/test_spec.py::TestGFM::test_atx_headings_009",
+    "tests/test_spec.py::TestGFM::test_atx_headings_010",
+    "tests/test_spec.py::TestGFM::test_atx_headings_011",
+    "tests/test_spec.py::TestGFM::test_atx_headings_012",
+    "tests/test_spec.py::TestGFM::test_atx_headings_013",
+    "tests/test_spec.py::TestGFM::test_atx_headings_014",
+    "tests/test_spec.py::TestGFM::test_atx_headings_015",
+    "tests/test_spec.py::TestGFM::test_atx_headings_016",
+    "tests/test_spec.py::TestGFM::test_atx_headings_017",
+    "tests/test_spec.py::TestGFM::test_atx_headings_018",
+    "tests/test_spec.py::TestGFM::test_autolinks_001",
+    "tests/test_spec.py::TestGFM::test_autolinks_002",
+    "tests/test_spec.py::TestGFM::test_autolinks_003",
+    "tests/test_spec.py::TestGFM::test_autolinks_004",
+    "tests/test_spec.py::TestGFM::test_autolinks_005",
+    "tests/test_spec.py::TestGFM::test_autolinks_006",
+    "tests/test_spec.py::TestGFM::test_autolinks_007",
+    "tests/test_spec.py::TestGFM::test_autolinks_008",
+    "tests/test_spec.py::TestGFM::test_autolinks_009",
+    "tests/test_spec.py::TestGFM::test_autolinks_010",
+    "tests/test_spec.py::TestGFM::test_autolinks_011",
+    "tests/test_spec.py::TestGFM::test_autolinks_012",
+    "tests/test_spec.py::TestGFM::test_autolinks_013",
+    "tests/test_spec.py::TestGFM::test_autolinks_014",
+    "tests/test_spec.py::TestGFM::test_autolinks_016",
+    "tests/test_spec.py::TestGFM::test_autolinks_017",
+    "tests/test_spec.py::TestGFM::test_backslash_escapes_001",
+    "tests/test_spec.py::TestGFM::test_backslash_escapes_002",
+    "tests/test_spec.py::TestGFM::test_backslash_escapes_003",
+    "tests/test_spec.py::TestGFM::test_backslash_escapes_004",
+    "tests/test_spec.py::TestGFM::test_backslash_escapes_005",
+    "tests/test_spec.py::TestGFM::test_backslash_escapes_006",
+    "tests/test_spec.py::TestGFM::test_backslash_escapes_007",
+    "tests/test_spec.py::TestGFM::test_backslash_escapes_008",
+    "tests/test_spec.py::TestGFM::test_backslash_escapes_009",
+    "tests/test_spec.py::TestGFM::test_backslash_escapes_010",
+    "tests/test_spec.py::TestGFM::test_backslash_escapes_011",
+    "tests/test_spec.py::TestGFM::test_backslash_escapes_012",
+    "tests/test_spec.py::TestGFM::test_backslash_escapes_013",
+]
+validation_status = "verified"
+bootstrap_image = "local-venv:frostming__marko"
+instruction_synthesized = true
+llm_cost_usd = 0.008464
+
+[metadata.repo2env.reward_calibration]
+f2p_count = 652
+p2p_count = 50
+source_files = 2
+loc_changed = 8
+difficulty = "small"
+
+[metadata.repo2env.evaluation]
+schema_version = "1"
+status = "unverified"
+stage = "generation"
+reason_codes = [
+    "validation_not_run",
+]
+detail = "Generated task; validation has not been established."
+provenance = "unknown"
+evidence = []
+
+[metadata.repo2env.reproducibility]
+mode = "local_only"
+image_ref = "local/frostming__marko"
+image_tag = "local/frostming__marko"
+image_visibility = "private"
+
+[agent]
+timeout_sec = 1800.0
+
+[verifier]
+timeout_sec = 300.0

heldout_pool/frostming__marko-b5a628f28dbd/tests/f2p.json

@@ -0,0 +1,654 @@
+[
+  "tests/test_spec.py::TestCommonMark::test_atx_headings_001",
+  "tests/test_spec.py::TestCommonMark::test_atx_headings_002",
+  "tests/test_spec.py::TestCommonMark::test_atx_headings_003",
+  "tests/test_spec.py::TestCommonMark::test_atx_headings_004",
+  "tests/test_spec.py::TestCommonMark::test_atx_headings_005",
+  "tests/test_spec.py::TestCommonMark::test_atx_headings_006",
+  "tests/test_spec.py::TestCommonMark::test_atx_headings_007",
+  "tests/test_spec.py::TestCommonMark::test_atx_headings_008",
+  "tests/test_spec.py::TestCommonMark::test_atx_headings_009",
+  "tests/test_spec.py::TestCommonMark::test_atx_headings_010",
+  "tests/test_spec.py::TestCommonMark::test_atx_headings_011",
+  "tests/test_spec.py::TestCommonMark::test_atx_headings_012",
+  "tests/test_spec.py::TestCommonMark::test_atx_headings_013",
+  "tests/test_spec.py::TestCommonMark::test_atx_headings_014",
+  "tests/test_spec.py::TestCommonMark::test_atx_headings_015",
+  "tests/test_spec.py::TestCommonMark::test_atx_headings_016",
+  "tests/test_spec.py::TestCommonMark::test_atx_headings_017",
+  "tests/test_spec.py::TestCommonMark::test_atx_headings_018",
+  "tests/test_spec.py::TestCommonMark::test_autolinks_001",
+  "tests/test_spec.py::TestCommonMark::test_autolinks_002",
+  "tests/test_spec.py::TestCommonMark::test_autolinks_003",
+  "tests/test_spec.py::TestCommonMark::test_autolinks_004",
+  "tests/test_spec.py::TestCommonMark::test_autolinks_005",
+  "tests/test_spec.py::TestCommonMark::test_autolinks_006",
+  "tests/test_spec.py::TestCommonMark::test_autolinks_007",
+  "tests/test_spec.py::TestCommonMark::test_autolinks_008",
+  "tests/test_spec.py::TestCommonMark::test_autolinks_009",
+  "tests/test_spec.py::TestCommonMark::test_autolinks_010",
+  "tests/test_spec.py::TestCommonMark::test_autolinks_011",
+  "tests/test_spec.py::TestCommonMark::test_autolinks_012",
+  "tests/test_spec.py::TestCommonMark::test_autolinks_013",
+  "tests/test_spec.py::TestCommonMark::test_autolinks_014",
+  "tests/test_spec.py::TestCommonMark::test_autolinks_015",
+  "tests/test_spec.py::TestCommonMark::test_autolinks_016",
+  "tests/test_spec.py::TestCommonMark::test_autolinks_017",
+  "tests/test_spec.py::TestCommonMark::test_autolinks_018",
+  "tests/test_spec.py::TestCommonMark::test_autolinks_019",
+  "tests/test_spec.py::TestCommonMark::test_backslash_escapes_001",
+  "tests/test_spec.py::TestCommonMark::test_backslash_escapes_002",
+  "tests/test_spec.py::TestCommonMark::test_backslash_escapes_003",
+  "tests/test_spec.py::TestCommonMark::test_backslash_escapes_004",
+  "tests/test_spec.py::TestCommonMark::test_backslash_escapes_005",
+  "tests/test_spec.py::TestCommonMark::test_backslash_escapes_006",
+  "tests/test_spec.py::TestCommonMark::test_backslash_escapes_007",
+  "tests/test_spec.py::TestCommonMark::test_backslash_escapes_008",
+  "tests/test_spec.py::TestCommonMark::test_backslash_escapes_009",
+  "tests/test_spec.py::TestCommonMark::test_backslash_escapes_010",
+  "tests/test_spec.py::TestCommonMark::test_backslash_escapes_011",
+  "tests/test_spec.py::TestCommonMark::test_backslash_escapes_012",
+  "tests/test_spec.py::TestCommonMark::test_backslash_escapes_013",
+  "tests/test_spec.py::TestCommonMark::test_blank_lines_001",
+  "tests/test_spec.py::TestCommonMark::test_block_quotes_001",
+  "tests/test_spec.py::TestCommonMark::test_block_quotes_002",
+  "tests/test_spec.py::TestCommonMark::test_block_quotes_003",
+  "tests/test_spec.py::TestCommonMark::test_block_quotes_004",
+  "tests/test_spec.py::TestCommonMark::test_block_quotes_005",
+  "tests/test_spec.py::TestCommonMark::test_block_quotes_006",
+  "tests/test_spec.py::TestCommonMark::test_block_quotes_007",
+  "tests/test_spec.py::TestCommonMark::test_block_quotes_008",
+  "tests/test_spec.py::TestCommonMark::test_block_quotes_009",
+  "tests/test_spec.py::TestCommonMark::test_block_quotes_010",
+  "tests/test_spec.py::TestCommonMark::test_block_quotes_011",
+  "tests/test_spec.py::TestCommonMark::test_block_quotes_012",
+  "tests/test_spec.py::TestCommonMark::test_block_quotes_013",
+  "tests/test_spec.py::TestCommonMark::test_block_quotes_014",
+  "tests/test_spec.py::TestCommonMark::test_block_quotes_015",
+  "tests/test_spec.py::TestCommonMark::test_block_quotes_016",
+  "tests/test_spec.py::TestCommonMark::test_block_quotes_017",
+  "tests/test_spec.py::TestCommonMark::test_block_quotes_018",
+  "tests/test_spec.py::TestCommonMark::test_block_quotes_019",
+  "tests/test_spec.py::TestCommonMark::test_block_quotes_020",
+  "tests/test_spec.py::TestCommonMark::test_block_quotes_021",
+  "tests/test_spec.py::TestCommonMark::test_block_quotes_022",
+  "tests/test_spec.py::TestCommonMark::test_block_quotes_023",
+  "tests/test_spec.py::TestCommonMark::test_block_quotes_024",
+  "tests/test_spec.py::TestCommonMark::test_block_quotes_025",
+  "tests/test_spec.py::TestCommonMark::test_code_spans_001",
+  "tests/test_spec.py::TestCommonMark::test_code_spans_002",
+  "tests/test_spec.py::TestCommonMark::test_code_spans_003",
+  "tests/test_spec.py::TestCommonMark::test_code_spans_004",
+  "tests/test_spec.py::TestCommonMark::test_code_spans_005",
+  "tests/test_spec.py::TestCommonMark::test_code_spans_006",
+  "tests/test_spec.py::TestCommonMark::test_code_spans_007",
+  "tests/test_spec.py::TestCommonMark::test_code_spans_008",
+  "tests/test_spec.py::TestCommonMark::test_code_spans_009",
+  "tests/test_spec.py::TestCommonMark::test_code_spans_010",
+  "tests/test_spec.py::TestCommonMark::test_code_spans_011",
+  "tests/test_spec.py::TestCommonMark::test_code_spans_012",
+  "tests/test_spec.py::TestCommonMark::test_code_spans_013",
+  "tests/test_spec.py::TestCommonMark::test_code_spans_014",
+  "tests/test_spec.py::TestCommonMark::test_code_spans_015",
+  "tests/test_spec.py::TestCommonMark::test_code_spans_016",
+  "tests/test_spec.py::TestCommonMark::test_code_spans_017",
+  "tests/test_spec.py::TestCommonMark::test_code_spans_018",
+  "tests/test_spec.py::TestCommonMark::test_code_spans_019",
+  "tests/test_spec.py::TestCommonMark::test_code_spans_020",
+  "tests/test_spec.py::TestCommonMark::test_code_spans_021",
+  "tests/test_spec.py::TestCommonMark::test_code_spans_022",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_001",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_002",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_003",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_004",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_005",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_006",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_007",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_008",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_009",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_010",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_011",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_012",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_013",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_014",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_015",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_016",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_017",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_018",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_019",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_020",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_021",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_022",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_023",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_024",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_025",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_026",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_027",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_028",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_029",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_030",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_031",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_032",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_033",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_034",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_035",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_036",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_037",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_038",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_039",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_040",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_041",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_042",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_043",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_044",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_045",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_046",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_047",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_048",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_049",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_050",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_051",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_052",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_053",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_054",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_055",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_056",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_057",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_058",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_059",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_060",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_061",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_062",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_063",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_064",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_065",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_066",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_067",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_068",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_069",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_070",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_071",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_072",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_073",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_074",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_075",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_076",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_077",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_078",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_079",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_080",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_081",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_082",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_083",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_084",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_085",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_086",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_087",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_088",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_089",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_090",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_091",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_092",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_093",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_094",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_095",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_096",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_097",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_098",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_099",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_100",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_101",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_102",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_103",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_104",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_105",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_106",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_107",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_108",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_109",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_110",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_111",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_112",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_113",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_114",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_115",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_116",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_117",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_118",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_119",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_120",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_121",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_122",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_123",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_124",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_125",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_126",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_127",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_128",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_129",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_130",
+  "tests/test_spec.py::TestCommonMark::test_emphasis_and_strong_emphasis_131",
+  "tests/test_spec.py::TestCommonMark::test_entity_and_numeric_character_references_001",
+  "tests/test_spec.py::TestCommonMark::test_entity_and_numeric_character_references_002",
+  "tests/test_spec.py::TestCommonMark::test_entity_and_numeric_character_references_003",
+  "tests/test_spec.py::TestCommonMark::test_entity_and_numeric_character_references_004",
+  "tests/test_spec.py::TestCommonMark::test_entity_and_numeric_character_references_005",
+  "tests/test_spec.py::TestCommonMark::test_entity_and_numeric_character_references_006",
+  "tests/test_spec.py::TestCommonMark::test_entity_and_numeric_character_references_007",
+  "tests/test_spec.py::TestCommonMark::test_entity_and_numeric_character_references_008",
+  "tests/test_spec.py::TestCommonMark::test_entity_and_numeric_character_references_009",
+  "tests/test_spec.py::TestCommonMark::test_entity_and_numeric_character_references_010",
+  "tests/test_spec.py::TestCommonMark::test_entity_and_numeric_character_references_011",
+  "tests/test_spec.py::TestCommonMark::test_entity_and_numeric_character_references_012",
+  "tests/test_spec.py::TestCommonMark::test_entity_and_numeric_character_references_013",
+  "tests/test_spec.py::TestCommonMark::test_entity_and_numeric_character_references_014",
+  "tests/test_spec.py::TestCommonMark::test_entity_and_numeric_character_references_015",
+  "tests/test_spec.py::TestCommonMark::test_entity_and_numeric_character_references_016",
+  "tests/test_spec.py::TestCommonMark::test_entity_and_numeric_character_references_017",
+  "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_001",
+  "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_002",
+  "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_003",
+  "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_004",
+  "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_005",
+  "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_006",
+  "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_007",
+  "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_008",
+  "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_009",
+  "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_010",
+  "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_011",
+  "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_012",
+  "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_013",
+  "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_014",
+  "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_015",
+  "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_016",
+  "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_017",
+  "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_018",
+  "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_019",
+  "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_020",
+  "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_021",
+  "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_022",
+  "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_023",
+  "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_024",
+  "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_025",
+  "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_026",
+  "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_027",
+  "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_028",
+  "tests/test_spec.py::TestCommonMark::test_fenced_code_blocks_029",
+  "tests/test_spec.py::TestCommonMark::test_hard_line_breaks_001",
+  "tests/test_spec.py::TestCommonMark::test_hard_line_breaks_002",
+  "tests/test_spec.py::TestCommonMark::test_hard_line_breaks_003",
+  "tests/test_spec.py::TestCommonMark::test_hard_line_breaks_004",
+  "tests/test_spec.py::TestCommonMark::test_hard_line_breaks_005",
+  "tests/test_spec.py::TestCommonMark::test_hard_line_breaks_006",
+  "tests/test_spec.py::TestCommonMark::test_hard_line_breaks_007",
+  "tests/test_spec.py::TestCommonMark::test_hard_line_breaks_008",
+  "tests/test_spec.py::TestCommonMark::test_hard_line_breaks_009",
+  "tests/test_spec.py::TestCommonMark::test_hard_line_breaks_010",
+  "tests/test_spec.py::TestCommonMark::test_hard_line_breaks_011",
+  "tests/test_spec.py::TestCommonMark::test_hard_line_breaks_012",
+  "tests/test_spec.py::TestCommonMark::test_hard_line_breaks_013",
+  "tests/test_spec.py::TestCommonMark::test_hard_line_breaks_014",
+  "tests/test_spec.py::TestCommonMark::test_hard_line_breaks_015",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_001",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_002",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_003",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_004",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_005",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_006",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_007",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_008",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_009",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_010",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_011",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_012",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_013",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_014",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_015",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_016",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_017",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_018",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_019",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_020",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_021",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_022",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_023",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_024",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_025",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_026",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_027",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_028",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_029",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_030",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_031",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_032",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_033",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_034",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_035",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_036",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_037",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_038",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_039",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_040",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_041",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_042",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_043",
+  "tests/test_spec.py::TestCommonMark::test_html_blocks_044",
+  "tests/test_spec.py::TestCommonMark::test_images_001",
+  "tests/test_spec.py::TestCommonMark::test_images_002",
+  "tests/test_spec.py::TestCommonMark::test_images_003",
+  "tests/test_spec.py::TestCommonMark::test_images_004",
+  "tests/test_spec.py::TestCommonMark::test_images_005",
+  "tests/test_spec.py::TestCommonMark::test_images_006",
+  "tests/test_spec.py::TestCommonMark::test_images_007",
+  "tests/test_spec.py::TestCommonMark::test_images_008",
+  "tests/test_spec.py::TestCommonMark::test_images_009",
+  "tests/test_spec.py::TestCommonMark::test_images_010",
+  "tests/test_spec.py::TestCommonMark::test_images_011",
+  "tests/test_spec.py::TestCommonMark::test_images_012",
+  "tests/test_spec.py::TestCommonMark::test_images_013",
+  "tests/test_spec.py::TestCommonMark::test_images_014",
+  "tests/test_spec.py::TestCommonMark::test_images_015",
+  "tests/test_spec.py::TestCommonMark::test_images_016",
+  "tests/test_spec.py::TestCommonMark::test_images_017",
+  "tests/test_spec.py::TestCommonMark::test_images_018",
+  "tests/test_spec.py::TestCommonMark::test_images_019",
+  "tests/test_spec.py::TestCommonMark::test_images_020",
+  "tests/test_spec.py::TestCommonMark::test_images_021",
+  "tests/test_spec.py::TestCommonMark::test_images_022",
+  "tests/test_spec.py::TestCommonMark::test_indented_code_blocks_001",
+  "tests/test_spec.py::TestCommonMark::test_indented_code_blocks_002",
+  "tests/test_spec.py::TestCommonMark::test_indented_code_blocks_003",
+  "tests/test_spec.py::TestCommonMark::test_indented_code_blocks_004",
+  "tests/test_spec.py::TestCommonMark::test_indented_code_blocks_005",
+  "tests/test_spec.py::TestCommonMark::test_indented_code_blocks_006",
+  "tests/test_spec.py::TestCommonMark::test_indented_code_blocks_007",
+  "tests/test_spec.py::TestCommonMark::test_indented_code_blocks_008",
+  "tests/test_spec.py::TestCommonMark::test_indented_code_blocks_009",
+  "tests/test_spec.py::TestCommonMark::test_indented_code_blocks_010",
+  "tests/test_spec.py::TestCommonMark::test_indented_code_blocks_011",
+  "tests/test_spec.py::TestCommonMark::test_indented_code_blocks_012",
+  "tests/test_spec.py::TestCommonMark::test_inlines_001",
+  "tests/test_spec.py::TestCommonMark::test_line_break_in_link_text",
+  "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_001",
+  "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_002",
+  "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_003",
+  "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_004",
+  "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_005",
+  "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_006",
+  "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_007",
+  "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_008",
+  "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_009",
+  "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_010",
+  "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_011",
+  "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_012",
+  "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_013",
+  "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_014",
+  "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_015",
+  "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_016",
+  "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_017",
+  "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_018",
+  "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_019",
+  "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_020",
+  "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_021",
+  "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_022",
+  "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_023",
+  "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_024",
+  "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_025",
+  "tests/test_spec.py::TestCommonMark::test_link_reference_definitions_026",
+  "tests/test_spec.py::TestCommonMark::test_links_001",
+  "tests/test_spec.py::TestCommonMark::test_links_002",
+  "tests/test_spec.py::TestCommonMark::test_links_003",
+  "tests/test_spec.py::TestCommonMark::test_links_004",
+  "tests/test_spec.py::TestCommonMark::test_links_005",
+  "tests/test_spec.py::TestCommonMark::test_links_006",
+  "tests/test_spec.py::TestCommonMark::test_links_007",
+  "tests/test_spec.py::TestCommonMark::test_links_008",
+  "tests/test_spec.py::TestCommonMark::test_links_009",
+  "tests/test_spec.py::TestCommonMark::test_links_010",
+  "tests/test_spec.py::TestCommonMark::test_links_011",
+  "tests/test_spec.py::TestCommonMark::test_links_012",
+  "tests/test_spec.py::TestCommonMark::test_links_013",
+  "tests/test_spec.py::TestCommonMark::test_links_014",
+  "tests/test_spec.py::TestCommonMark::test_links_015",
+  "tests/test_spec.py::TestCommonMark::test_links_016",
+  "tests/test_spec.py::TestCommonMark::test_links_017",
+  "tests/test_spec.py::TestCommonMark::test_links_018",
+  "tests/test_spec.py::TestCommonMark::test_links_019",
+  "tests/test_spec.py::TestCommonMark::test_links_020",
+  "tests/test_spec.py::TestCommonMark::test_links_021",
+  "tests/test_spec.py::TestCommonMark::test_links_022",
+  "tests/test_spec.py::TestCommonMark::test_links_023",
+  "tests/test_spec.py::TestCommonMark::test_links_024",
+  "tests/test_spec.py::TestCommonMark::test_links_025",
+  "tests/test_spec.py::TestCommonMark::test_links_026",
+  "tests/test_spec.py::TestCommonMark::test_links_027",
+  "tests/test_spec.py::TestCommonMark::test_links_028",
+  "tests/test_spec.py::TestCommonMark::test_links_029",
+  "tests/test_spec.py::TestCommonMark::test_links_030",
+  "tests/test_spec.py::TestCommonMark::test_links_031",
+  "tests/test_spec.py::TestCommonMark::test_links_032",
+  "tests/test_spec.py::TestCommonMark::test_links_033",
+  "tests/test_spec.py::TestCommonMark::test_links_034",
+  "tests/test_spec.py::TestCommonMark::test_links_035",
+  "tests/test_spec.py::TestCommonMark::test_links_036",
+  "tests/test_spec.py::TestCommonMark::test_links_037",
+  "tests/test_spec.py::TestCommonMark::test_links_038",
+  "tests/test_spec.py::TestCommonMark::test_links_039",
+  "tests/test_spec.py::TestCommonMark::test_links_040",
+  "tests/test_spec.py::TestCommonMark::test_links_041",
+  "tests/test_spec.py::TestCommonMark::test_links_042",
+  "tests/test_spec.py::TestCommonMark::test_links_043",
+  "tests/test_spec.py::TestCommonMark::test_links_044",
+  "tests/test_spec.py::TestCommonMark::test_links_045",
+  "tests/test_spec.py::TestCommonMark::test_links_046",
+  "tests/test_spec.py::TestCommonMark::test_links_047",
+  "tests/test_spec.py::TestCommonMark::test_links_048",
+  "tests/test_spec.py::TestCommonMark::test_links_049",
+  "tests/test_spec.py::TestCommonMark::test_links_050",
+  "tests/test_spec.py::TestCommonMark::test_links_051",
+  "tests/test_spec.py::TestCommonMark::test_links_052",
+  "tests/test_spec.py::TestCommonMark::test_links_053",
+  "tests/test_spec.py::TestCommonMark::test_links_054",
+  "tests/test_spec.py::TestCommonMark::test_links_055",
+  "tests/test_spec.py::TestCommonMark::test_links_056",
+  "tests/test_spec.py::TestCommonMark::test_links_057",
+  "tests/test_spec.py::TestCommonMark::test_links_058",
+  "tests/test_spec.py::TestCommonMark::test_links_059",
+  "tests/test_spec.py::TestCommonMark::test_links_060",
+  "tests/test_spec.py::TestCommonMark::test_links_061",
+  "tests/test_spec.py::TestCommonMark::test_links_062",
+  "tests/test_spec.py::TestCommonMark::test_links_063",
+  "tests/test_spec.py::TestCommonMark::test_links_064",
+  "tests/test_spec.py::TestCommonMark::test_links_065",
+  "tests/test_spec.py::TestCommonMark::test_links_066",
+  "tests/test_spec.py::TestCommonMark::test_links_067",
+  "tests/test_spec.py::TestCommonMark::test_links_068",
+  "tests/test_spec.py::TestCommonMark::test_links_069",
+  "tests/test_spec.py::TestCommonMark::test_links_070",
+  "tests/test_spec.py::TestCommonMark::test_links_071",
+  "tests/test_spec.py::TestCommonMark::test_links_072",
+  "tests/test_spec.py::TestCommonMark::test_links_073",
+  "tests/test_spec.py::TestCommonMark::test_links_074",
+  "tests/test_spec.py::TestCommonMark::test_links_075",
+  "tests/test_spec.py::TestCommonMark::test_links_076",
+  "tests/test_spec.py::TestCommonMark::test_links_077",
+  "tests/test_spec.py::TestCommonMark::test_links_078",
+  "tests/test_spec.py::TestCommonMark::test_links_079",
+  "tests/test_spec.py::TestCommonMark::test_links_080",
+  "tests/test_spec.py::TestCommonMark::test_links_081",
+  "tests/test_spec.py::TestCommonMark::test_links_082",
+  "tests/test_spec.py::TestCommonMark::test_links_083",
+  "tests/test_spec.py::TestCommonMark::test_links_084",
+  "tests/test_spec.py::TestCommonMark::test_links_085",
+  "tests/test_spec.py::TestCommonMark::test_links_086",
+  "tests/test_spec.py::TestCommonMark::test_links_087",
+  "tests/test_spec.py::TestCommonMark::test_links_088",
+  "tests/test_spec.py::TestCommonMark::test_links_089",
+  "tests/test_spec.py::TestCommonMark::test_links_090",
+  "tests/test_spec.py::TestCommonMark::test_list_items_001",
+  "tests/test_spec.py::TestCommonMark::test_list_items_002",
+  "tests/test_spec.py::TestCommonMark::test_list_items_003",
+  "tests/test_spec.py::TestCommonMark::test_list_items_004",
+  "tests/test_spec.py::TestCommonMark::test_list_items_005",
+  "tests/test_spec.py::TestCommonMark::test_list_items_006",
+  "tests/test_spec.py::TestCommonMark::test_list_items_007",
+  "tests/test_spec.py::TestCommonMark::test_list_items_008",
+  "tests/test_spec.py::TestCommonMark::test_list_items_009",
+  "tests/test_spec.py::TestCommonMark::test_list_items_010",
+  "tests/test_spec.py::TestCommonMark::test_list_items_011",
+  "tests/test_spec.py::TestCommonMark::test_list_items_012",
+  "tests/test_spec.py::TestCommonMark::test_list_items_013",
+  "tests/test_spec.py::TestCommonMark::test_list_items_014",
+  "tests/test_spec.py::TestCommonMark::test_list_items_015",
+  "tests/test_spec.py::TestCommonMark::test_list_items_016",
+  "tests/test_spec.py::TestCommonMark::test_list_items_017",
+  "tests/test_spec.py::TestCommonMark::test_list_items_018",
+  "tests/test_spec.py::TestCommonMark::test_list_items_019",
+  "tests/test_spec.py::TestCommonMark::test_list_items_020",
+  "tests/test_spec.py::TestCommonMark::test_list_items_021",
+  "tests/test_spec.py::TestCommonMark::test_list_items_022",
+  "tests/test_spec.py::TestCommonMark::test_list_items_023",
+  "tests/test_spec.py::TestCommonMark::test_list_items_024",
+  "tests/test_spec.py::TestCommonMark::test_list_items_025",
+  "tests/test_spec.py::TestCommonMark::test_list_items_026",
+  "tests/test_spec.py::TestCommonMark::test_list_items_027",
+  "tests/test_spec.py::TestCommonMark::test_list_items_028",
+  "tests/test_spec.py::TestCommonMark::test_list_items_029",
+  "tests/test_spec.py::TestCommonMark::test_list_items_030",
+  "tests/test_spec.py::TestCommonMark::test_list_items_031",
+  "tests/test_spec.py::TestCommonMark::test_list_items_032",
+  "tests/test_spec.py::TestCommonMark::test_list_items_033",
+  "tests/test_spec.py::TestCommonMark::test_list_items_034",
+  "tests/test_spec.py::TestCommonMark::test_list_items_035",
+  "tests/test_spec.py::TestCommonMark::test_list_items_036",
+  "tests/test_spec.py::TestCommonMark::test_list_items_037",
+  "tests/test_spec.py::TestCommonMark::test_list_items_038",
+  "tests/test_spec.py::TestCommonMark::test_list_items_039",
+  "tests/test_spec.py::TestCommonMark::test_list_items_040",
+  "tests/test_spec.py::TestCommonMark::test_list_items_041",
+  "tests/test_spec.py::TestCommonMark::test_list_items_042",
+  "tests/test_spec.py::TestCommonMark::test_list_items_043",
+  "tests/test_spec.py::TestCommonMark::test_list_items_044",
+  "tests/test_spec.py::TestCommonMark::test_list_items_045",
+  "tests/test_spec.py::TestCommonMark::test_list_items_046",
+  "tests/test_spec.py::TestCommonMark::test_list_items_047",
+  "tests/test_spec.py::TestCommonMark::test_list_items_048",
+  "tests/test_spec.py::TestCommonMark::test_lists_001",
+  "tests/test_spec.py::TestCommonMark::test_lists_002",
+  "tests/test_spec.py::TestCommonMark::test_lists_003",
+  "tests/test_spec.py::TestCommonMark::test_lists_004",
+  "tests/test_spec.py::TestCommonMark::test_lists_005",
+  "tests/test_spec.py::TestCommonMark::test_lists_006",
+  "tests/test_spec.py::TestCommonMark::test_lists_007",
+  "tests/test_spec.py::TestCommonMark::test_lists_008",
+  "tests/test_spec.py::TestCommonMark::test_lists_009",
+  "tests/test_spec.py::TestCommonMark::test_lists_010",
+  "tests/test_spec.py::TestCommonMark::test_lists_011",
+  "tests/test_spec.py::TestCommonMark::test_lists_012",
+  "tests/test_spec.py::TestCommonMark::test_lists_013",
+  "tests/test_spec.py::TestCommonMark::test_lists_014",
+  "tests/test_spec.py::TestCommonMark::test_lists_015",
+  "tests/test_spec.py::TestCommonMark::test_lists_016",
+  "tests/test_spec.py::TestCommonMark::test_lists_017",
+  "tests/test_spec.py::TestCommonMark::test_lists_018",
+  "tests/test_spec.py::TestCommonMark::test_lists_019",
+  "tests/test_spec.py::TestCommonMark::test_lists_020",
+  "tests/test_spec.py::TestCommonMark::test_lists_021",
+  "tests/test_spec.py::TestCommonMark::test_lists_022",
+  "tests/test_spec.py::TestCommonMark::test_lists_023",
+  "tests/test_spec.py::TestCommonMark::test_lists_024",
+  "tests/test_spec.py::TestCommonMark::test_lists_025",
+  "tests/test_spec.py::TestCommonMark::test_lists_026",
+  "tests/test_spec.py::TestCommonMark::test_paragraphs_001",
+  "tests/test_spec.py::TestCommonMark::test_paragraphs_002",
+  "tests/test_spec.py::TestCommonMark::test_paragraphs_003",
+  "tests/test_spec.py::TestCommonMark::test_paragraphs_004",
+  "tests/test_spec.py::TestCommonMark::test_paragraphs_005",
+  "tests/test_spec.py::TestCommonMark::test_paragraphs_006",
+  "tests/test_spec.py::TestCommonMark::test_paragraphs_007",
+  "tests/test_spec.py::TestCommonMark::test_paragraphs_008",
+  "tests/test_spec.py::TestCommonMark::test_precedence_001",
+  "tests/test_spec.py::TestCommonMark::test_raw_html_001",
+  "tests/test_spec.py::TestCommonMark::test_raw_html_002",
+  "tests/test_spec.py::TestCommonMark::test_raw_html_003",
+  "tests/test_spec.py::TestCommonMark::test_raw_html_004",
+  "tests/test_spec.py::TestCommonMark::test_raw_html_005",
+  "tests/test_spec.py::TestCommonMark::test_raw_html_006",
+  "tests/test_spec.py::TestCommonMark::test_raw_html_007",
+  "tests/test_spec.py::TestCommonMark::test_raw_html_008",
+  "tests/test_spec.py::TestCommonMark::test_raw_html_009",
+  "tests/test_spec.py::TestCommonMark::test_raw_html_010",
+  "tests/test_spec.py::TestCommonMark::test_raw_html_011",
+  "tests/test_spec.py::TestCommonMark::test_raw_html_012",
+  "tests/test_spec.py::TestCommonMark::test_raw_html_013",
+  "tests/test_spec.py::TestCommonMark::test_raw_html_014",
+  "tests/test_spec.py::TestCommonMark::test_raw_html_015",
+  "tests/test_spec.py::TestCommonMark::test_raw_html_016",
+  "tests/test_spec.py::TestCommonMark::test_raw_html_017",
+  "tests/test_spec.py::TestCommonMark::test_raw_html_018",
+  "tests/test_spec.py::TestCommonMark::test_raw_html_019",
+  "tests/test_spec.py::TestCommonMark::test_raw_html_020",
+  "tests/test_spec.py::TestCommonMark::test_raw_html_021",
+  "tests/test_spec.py::TestCommonMark::test_setext_headings_001",
+  "tests/test_spec.py::TestCommonMark::test_setext_headings_002",
+  "tests/test_spec.py::TestCommonMark::test_setext_headings_003",
+  "tests/test_spec.py::TestCommonMark::test_setext_headings_004",
+  "tests/test_spec.py::TestCommonMark::test_setext_headings_005",
+  "tests/test_spec.py::TestCommonMark::test_setext_headings_006",
+  "tests/test_spec.py::TestCommonMark::test_setext_headings_007",
+  "tests/test_spec.py::TestCommonMark::test_setext_headings_008",
+  "tests/test_spec.py::TestCommonMark::test_setext_headings_009",
+  "tests/test_spec.py::TestCommonMark::test_setext_headings_010",
+  "tests/test_spec.py::TestCommonMark::test_setext_headings_011",
+  "tests/test_spec.py::TestCommonMark::test_setext_headings_012",
+  "tests/test_spec.py::TestCommonMark::test_setext_headings_013",
+  "tests/test_spec.py::TestCommonMark::test_setext_headings_014",
+  "tests/test_spec.py::TestCommonMark::test_setext_headings_015",
+  "tests/test_spec.py::TestCommonMark::test_setext_headings_016",
+  "tests/test_spec.py::TestCommonMark::test_setext_headings_017",
+  "tests/test_spec.py::TestCommonMark::test_setext_headings_018",
+  "tests/test_spec.py::TestCommonMark::test_setext_headings_019",
+  "tests/test_spec.py::TestCommonMark::test_setext_headings_020",
+  "tests/test_spec.py::TestCommonMark::test_setext_headings_021",
+  "tests/test_spec.py::TestCommonMark::test_setext_headings_022",
+  "tests/test_spec.py::TestCommonMark::test_setext_headings_023",
+  "tests/test_spec.py::TestCommonMark::test_setext_headings_024",
+  "tests/test_spec.py::TestCommonMark::test_setext_headings_025",
+  "tests/test_spec.py::TestCommonMark::test_setext_headings_026",
+  "tests/test_spec.py::TestCommonMark::test_setext_headings_027",
+  "tests/test_spec.py::TestCommonMark::test_soft_line_breaks_001",
+  "tests/test_spec.py::TestCommonMark::test_soft_line_breaks_002",
+  "tests/test_spec.py::TestCommonMark::test_tabs_001",
+  "tests/test_spec.py::TestCommonMark::test_tabs_002",
+  "tests/test_spec.py::TestCommonMark::test_tabs_003",
+  "tests/test_spec.py::TestCommonMark::test_tabs_004",
+  "tests/test_spec.py::TestCommonMark::test_tabs_005",
+  "tests/test_spec.py::TestCommonMark::test_tabs_006",
+  "tests/test_spec.py::TestCommonMark::test_tabs_007",
+  "tests/test_spec.py::TestCommonMark::test_tabs_008",
+  "tests/test_spec.py::TestCommonMark::test_tabs_009",
+  "tests/test_spec.py::TestCommonMark::test_tabs_010",
+  "tests/test_spec.py::TestCommonMark::test_tabs_011",
+  "tests/test_spec.py::TestCommonMark::test_textual_content_001",
+  "tests/test_spec.py::TestCommonMark::test_textual_content_002",
+  "tests/test_spec.py::TestCommonMark::test_textual_content_003",
+  "tests/test_spec.py::TestCommonMark::test_thematic_breaks_001",
+  "tests/test_spec.py::TestCommonMark::test_thematic_breaks_002",
+  "tests/test_spec.py::TestCommonMark::test_thematic_breaks_003",
+  "tests/test_spec.py::TestCommonMark::test_thematic_breaks_004",
+  "tests/test_spec.py::TestCommonMark::test_thematic_breaks_005",
+  "tests/test_spec.py::TestCommonMark::test_thematic_breaks_006",
+  "tests/test_spec.py::TestCommonMark::test_thematic_breaks_007",
+  "tests/test_spec.py::TestCommonMark::test_thematic_breaks_008",
+  "tests/test_spec.py::TestCommonMark::test_thematic_breaks_009",
+  "tests/test_spec.py::TestCommonMark::test_thematic_breaks_010",
+  "tests/test_spec.py::TestCommonMark::test_thematic_breaks_011",
+  "tests/test_spec.py::TestCommonMark::test_thematic_breaks_012",
+  "tests/test_spec.py::TestCommonMark::test_thematic_breaks_013",
+  "tests/test_spec.py::TestCommonMark::test_thematic_breaks_014",
+  "tests/test_spec.py::TestCommonMark::test_thematic_breaks_015",
+  "tests/test_spec.py::TestCommonMark::test_thematic_breaks_016",
+  "tests/test_spec.py::TestCommonMark::test_thematic_breaks_017",
+  "tests/test_spec.py::TestCommonMark::test_thematic_breaks_018",
+  "tests/test_spec.py::TestCommonMark::test_thematic_breaks_019"
+]

heldout_pool/frostming__marko-b5a628f28dbd/tests/p2p.json

@@ -0,0 +1,52 @@
+[
+  "tests/test_spec.py::TestCommonMark::test_greedy_consume_prefix",
+  "tests/test_spec.py::TestCommonMark::test_mixed_tab_space_in_list_item",
+  "tests/test_spec.py::TestCommonMark::test_parse_nbsp_no_crash",
+  "tests/test_spec.py::TestGFM::test_atx_headings_001",
+  "tests/test_spec.py::TestGFM::test_atx_headings_002",
+  "tests/test_spec.py::TestGFM::test_atx_headings_003",
+  "tests/test_spec.py::TestGFM::test_atx_headings_004",
+  "tests/test_spec.py::TestGFM::test_atx_headings_005",
+  "tests/test_spec.py::TestGFM::test_atx_headings_006",
+  "tests/test_spec.py::TestGFM::test_atx_headings_007",
+  "tests/test_spec.py::TestGFM::test_atx_headings_008",
+  "tests/test_spec.py::TestGFM::test_atx_headings_009",
+  "tests/test_spec.py::TestGFM::test_atx_headings_010",
+  "tests/test_spec.py::TestGFM::test_atx_headings_011",
+  "tests/test_spec.py::TestGFM::test_atx_headings_012",
+  "tests/test_spec.py::TestGFM::test_atx_headings_013",
+  "tests/test_spec.py::TestGFM::test_atx_headings_014",
+  "tests/test_spec.py::TestGFM::test_atx_headings_015",
+  "tests/test_spec.py::TestGFM::test_atx_headings_016",
+  "tests/test_spec.py::TestGFM::test_atx_headings_017",
+  "tests/test_spec.py::TestGFM::test_atx_headings_018",
+  "tests/test_spec.py::TestGFM::test_autolinks_001",
+  "tests/test_spec.py::TestGFM::test_autolinks_002",
+  "tests/test_spec.py::TestGFM::test_autolinks_003",
+  "tests/test_spec.py::TestGFM::test_autolinks_004",
+  "tests/test_spec.py::TestGFM::test_autolinks_005",
+  "tests/test_spec.py::TestGFM::test_autolinks_006",
+  "tests/test_spec.py::TestGFM::test_autolinks_007",
+  "tests/test_spec.py::TestGFM::test_autolinks_008",
+  "tests/test_spec.py::TestGFM::test_autolinks_009",
+  "tests/test_spec.py::TestGFM::test_autolinks_010",
+  "tests/test_spec.py::TestGFM::test_autolinks_011",
+  "tests/test_spec.py::TestGFM::test_autolinks_012",
+  "tests/test_spec.py::TestGFM::test_autolinks_013",
+  "tests/test_spec.py::TestGFM::test_autolinks_014",
+  "tests/test_spec.py::TestGFM::test_autolinks_016",
+  "tests/test_spec.py::TestGFM::test_autolinks_017",
+  "tests/test_spec.py::TestGFM::test_backslash_escapes_001",
+  "tests/test_spec.py::TestGFM::test_backslash_escapes_002",
+  "tests/test_spec.py::TestGFM::test_backslash_escapes_003",
+  "tests/test_spec.py::TestGFM::test_backslash_escapes_004",
+  "tests/test_spec.py::TestGFM::test_backslash_escapes_005",
+  "tests/test_spec.py::TestGFM::test_backslash_escapes_006",
+  "tests/test_spec.py::TestGFM::test_backslash_escapes_007",
+  "tests/test_spec.py::TestGFM::test_backslash_escapes_008",
+  "tests/test_spec.py::TestGFM::test_backslash_escapes_009",
+  "tests/test_spec.py::TestGFM::test_backslash_escapes_010",
+  "tests/test_spec.py::TestGFM::test_backslash_escapes_011",
+  "tests/test_spec.py::TestGFM::test_backslash_escapes_012",
+  "tests/test_spec.py::TestGFM::test_backslash_escapes_013"
+]