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

heldout/mirumee__google-i18n-address-311eb0f1a0fa/tests/test.sh

@@ -0,0 +1,86 @@
+#!/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 21693704723afbe9a9fadffa206caaa41bf217e2 -- tests/test_i18naddress.py tests/test_normalization.py || true
+git apply --verbose --reject - <<'EOF_R2E_TEST_PATCH'
+diff --git a/tests/test_i18naddress.py b/tests/test_i18naddress.py
+index 95a722b..8dbfb56 100644
+--- a/tests/test_i18naddress.py
++++ b/tests/test_i18naddress.py
+@@ -20,6 +20,31 @@ def test_dictionary_access():
+     assert state['name'] == 'Nevada'
+ 
+ 
++def test_validation_rules_canada():
++    validation_data = get_validation_rules({'country_code': 'CA'})
++    assert validation_data.country_area_choices == [
++        ('AB', 'Alberta'),
++        ('BC', 'British Columbia'),
++        ('BC', 'Colombie-Britannique'),
++        ('MB', 'Manitoba'),
++        ('NB', 'New Brunswick'),
++        ('NB', 'Nouveau-Brunswick'),
++        ('NL', 'Newfoundland and Labrador'),
++        ('NL', 'Terre-Neuve-et-Labrador'),
++        ('NT', 'Northwest Territories'),
++        ('NT', 'Territoires du Nord-Ouest'),
++        ('NS', 'Nouvelle-Écosse'),
++        ('NS', 'Nova Scotia'),
++        ('NU', 'Nunavut'),
++        ('ON', 'Ontario'),
++        ('PE', 'Prince Edward Island'),
++        ('PE', 'Île-du-Prince-Édouard'),
++        ('QC', 'Quebec'),
++        ('QC', 'Québec'),
++        ('SK', 'Saskatchewan'),
++        ('YT', 'Yukon')]
++
++
+ def test_validation_rules_switzerland():
+     validation_data = get_validation_rules({'country_code': 'CH'})
+     assert validation_data.allowed_fields == {
+diff --git a/tests/test_normalization.py b/tests/test_normalization.py
+index bc43fd5..77a551b 100644
+--- a/tests/test_normalization.py
++++ b/tests/test_normalization.py
+@@ -149,6 +149,22 @@ def test_address_latinization():
+         'street_address': '1600 Charleston Rd.'}
+     address = latinize_address(address)
+     assert address['country_area'] == 'California'
++    address = {
++        'country_code': 'CN',
++        'country_area': '云南省',
++        'postal_code': '677400',
++        'city': '临沧市',
++        'city_area': '凤庆县',
++        'street_address': '中关村东路1号'}
++    address = latinize_address(address)
++    assert address == {
++        'country_code': 'CN',
++        'country_area': 'Yunnan Sheng',
++        'postal_code': '677400',
++        'city': 'Lincang Shi',
++        'city_area': 'Fengqing Xian',
++        'street_address': '中关村东路1号',
++        'sorting_code': ''}
+     address = {
+         'name': 'Zhang San',
+         'company_name': 'Beijing Kid Toy Company',
+
+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_i18naddress.py tests/test_normalization.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_i18naddress.py tests/test_normalization.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 21693704723afbe9a9fadffa206caaa41bf217e2 -- tests/test_i18naddress.py tests/test_normalization.py || true
+exit 0

heldout/mirumee__google-i18n-address-311eb0f1a0fa/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/osantana__prettyconf-16570d889998/environment/Dockerfile

@@ -0,0 +1,36 @@
+# Auto-generated by Repo2RLEnv pr_runtime
+FROM local/osantana__prettyconf
+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 4572e2897fd8172cb47a26ac159734eef1ba669e 2>/dev/null \
+       || git fetch --unshallow origin 2>/dev/null || true
+RUN git reset --hard 4572e2897fd8172cb47a26ac159734eef1ba669e && 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 4572e2897fd8172cb47a26ac159734eef1ba669e \
+    && 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/osantana__prettyconf-16570d889998/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/osantana__prettyconf-16570d889998/instruction.md

@@ -0,0 +1,10 @@
+# Issue
+
+**Title:** `config.eval` fails due to incorrect type casting
+
+## Description
+When attempting to use `config.eval`, the operation fails because of an incorrect type cast. This prevents the configuration from being evaluated successfully and blocks further progress. The expected behavior is for `config.eval` to correctly handle all necessary type conversions and complete its evaluation without errors.
+
+## 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 `4572e2897fd8` and running the modified tests.

heldout/osantana__prettyconf-16570d889998/solution/patch.diff

@@ -0,0 +1,26 @@
+diff --git a/CHANGES.txt b/CHANGES.txt
+index 2b9229c..a29d240 100644
+--- a/CHANGES.txt
++++ b/CHANGES.txt
+@@ -1,3 +1,8 @@
++1.2.3
++=====
++
++  - Fix a blocker issue with ``config.eval`` cast and add a test to prevent regressions
++
+ 1.2.2
+ =====
+ 
+diff --git a/prettyconf/configuration.py b/prettyconf/configuration.py
+index 3409546..c167fd6 100644
+--- a/prettyconf/configuration.py
++++ b/prettyconf/configuration.py
+@@ -77,7 +77,7 @@ class Configuration(object):
+     list = List()
+     tuple = Tuple()
+     option = Option
+-    eval = ast.literal_eval
++    eval = staticmethod(ast.literal_eval)
+ 
+     def __init__(self, configs=None, starting_path=None, root_path="/"):
+         if configs is None:

heldout/osantana__prettyconf-16570d889998/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/osantana__prettyconf-16570d889998/task.toml

@@ -0,0 +1,82 @@
+version = "1.0"
+
+[task]
+name = "commit-runtime/osantana__prettyconf-16570d889998"
+description = "Fix a blocker issue with config.eval cast and add a test to prevent regressions"
+
+[metadata]
+difficulty = "small"
+category = "bugfix"
+keywords = [
+    "prettyconf",
+    "commit_runtime",
+]
+
+[metadata.repo2env]
+pipeline = "commit_runtime"
+pipeline_version = "0.8.3"
+repo = "osantana/prettyconf"
+ref = "4572e2897fd8172cb47a26ac159734eef1ba669e"
+reference = "https://github.com/osantana/prettyconf/commit/16570d889998f3e83c5230a03daf8ad60bff64e6"
+source_access = "public"
+built_at = "2026-09-24T13:12:11.425066+00:00"
+synthesis_llm = "gemini/gemini-2.5-flash"
+reward_kinds = [
+    "test_execution",
+    "diff_similarity",
+]
+spec_version = "0.2.0"
+content_hash = "sha256:1200e462d7db36b2690b03bf1249663c13632fc22ba0d556112405537c608d1b"
+
+[metadata.repo2env.commit_runtime]
+commit_sha = "16570d889998f3e83c5230a03daf8ad60bff64e6"
+parent_sha = "4572e2897fd8172cb47a26ac159734eef1ba669e"
+authored_at = "2016-02-16T13:09:42-02:00"
+author_email = "github@osantana.me"
+subject = "Fix a blocker issue with config.eval cast and add a test to prevent regressions"
+fail_to_pass = [
+    "tests/test_casts.py::EvalCastTestCase::test_if_cast_is_unbounded",
+]
+pass_to_pass = [
+    "tests/test_casts.py::BooleanCastTestCase::test_basic_boolean_cast",
+    "tests/test_casts.py::BooleanCastTestCase::test_fail_invalid_boolean_cast",
+    "tests/test_casts.py::BooleanCastTestCase::test_more_valid_boolean_values",
+    "tests/test_casts.py::OptionCastTestCase::test_fail_invalid_option_config",
+    "tests/test_casts.py::OptionCastTestCase::test_options",
+    "tests/test_casts.py::SequenceCastTestCase::test_basic_list_cast",
+    "tests/test_casts.py::SequenceCastTestCase::test_basic_tuple_cast",
+]
+validation_status = "verified"
+bootstrap_image = "local-venv:osantana__prettyconf"
+instruction_synthesized = true
+llm_cost_usd = 0.0
+
+[metadata.repo2env.reward_calibration]
+f2p_count = 1
+p2p_count = 7
+source_files = 2
+loc_changed = 7
+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/osantana__prettyconf"
+image_tag = "local/osantana__prettyconf"
+image_visibility = "private"
+
+[agent]
+timeout_sec = 1800.0
+
+[verifier]
+timeout_sec = 300.0

heldout/osantana__prettyconf-16570d889998/tests/f2p.json

@@ -0,0 +1,3 @@
+[
+  "tests/test_casts.py::EvalCastTestCase::test_if_cast_is_unbounded"
+]

heldout/osantana__prettyconf-16570d889998/tests/p2p.json

@@ -0,0 +1,9 @@
+[
+  "tests/test_casts.py::BooleanCastTestCase::test_basic_boolean_cast",
+  "tests/test_casts.py::BooleanCastTestCase::test_fail_invalid_boolean_cast",
+  "tests/test_casts.py::BooleanCastTestCase::test_more_valid_boolean_values",
+  "tests/test_casts.py::OptionCastTestCase::test_fail_invalid_option_config",
+  "tests/test_casts.py::OptionCastTestCase::test_options",
+  "tests/test_casts.py::SequenceCastTestCase::test_basic_list_cast",
+  "tests/test_casts.py::SequenceCastTestCase::test_basic_tuple_cast"
+]

heldout/osantana__prettyconf-16570d889998/tests/test.sh

@@ -0,0 +1,44 @@
+#!/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 4572e2897fd8172cb47a26ac159734eef1ba669e -- tests/test_casts.py || true
+git apply --verbose --reject - <<'EOF_R2E_TEST_PATCH'
+diff --git a/tests/test_casts.py b/tests/test_casts.py
+index 0bdb4b8..0a5f68f 100644
+--- a/tests/test_casts.py
++++ b/tests/test_casts.py
+@@ -4,6 +4,7 @@
+ from unittest import TestCase
+ 
+ from prettyconf.casts import Boolean, Option, InvalidConfiguration, List, Tuple
++from prettyconf import config
+ 
+ 
+ class BooleanCastTestCase(TestCase):
+@@ -81,3 +82,8 @@ class OptionCastTestCase(TestCase):
+ 
+         with self.assertRaises(InvalidConfiguration):
+             option("unknown")
++
++
++class EvalCastTestCase(TestCase):
++    def test_if_cast_is_unbounded(self):
++        self.assertIsNone(config.eval("None"))
+
+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_casts.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_casts.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 4572e2897fd8172cb47a26ac159734eef1ba669e -- tests/test_casts.py || true
+exit 0

heldout/osantana__prettyconf-16570d889998/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/sloria__environs-1a47a3658bf7/environment/Dockerfile

@@ -0,0 +1,36 @@
+# Auto-generated by Repo2RLEnv pr_runtime
+FROM local/sloria__environs
+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 f678dabd2ebb32a22a90f439d8518f8c2ddcb60c 2>/dev/null \
+       || git fetch --unshallow origin 2>/dev/null || true
+RUN git reset --hard f678dabd2ebb32a22a90f439d8518f8c2ddcb60c && 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 f678dabd2ebb32a22a90f439d8518f8c2ddcb60c \
+    && 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/sloria__environs-1a47a3658bf7/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/sloria__environs-1a47a3658bf7/instruction.md

@@ -0,0 +1,16 @@
+# Issue
+
+**Title:** Variable expansion incorrectly discards trailing string content
+
+## Description
+When processing a string with variable expansion enabled (e.g., `expand_vars=True`), if the string begins with a variable reference like `${VAR}` but includes additional characters or content afterwards, the entire trailing portion of the string is unexpectedly discarded.
+
+**Reproduction:**
+Given a variable `A="foo"`, processing the string `"${A};Val_B;"` with variable expansion enabled.
+
+**Actual Result:** The output is `"foo"`.
+**Expected Result:** The output should be `"foo;Val_B;"`.
+
+## 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 `f678dabd2ebb` and running the modified tests.

heldout/sloria__environs-1a47a3658bf7/solution/patch.diff

@@ -0,0 +1,29 @@
+diff --git a/CHANGELOG.md b/CHANGELOG.md
+index 31b7f06..79e79e0 100644
+--- a/CHANGELOG.md
++++ b/CHANGELOG.md
+@@ -2,6 +2,11 @@
+ 
+ ## next
+ 
++Bug fixes:
++
++- Fix variable expansion with other characters ([#359](https://github.com/sloria/environs/issues/359)).
++  Thanks [flymanzhao](https://github.com/flymanzhao) for reporting and [veeceey](https://github.com/veeceey) for the PR.
++
+ Other changes:
+ 
+ - Update lowest supported marshmallow version to 3.26.2 ([#448](https://github.com/sloria/environs/pull/448)).
+diff --git a/src/environs/__init__.py b/src/environs/__init__.py
+index f418392..dfd647e 100644
+--- a/src/environs/__init__.py
++++ b/src/environs/__init__.py
+@@ -523,7 +523,7 @@ class Env:
+         env_key = self._get_key(key, omit_prefix=proxied)
+         value = self._get_value(env_key, default)
+         if hasattr(value, "strip"):
+-            expand_match = self.expand_vars and _EXPANDED_VAR_PATTERN.match(value)
++            expand_match = self.expand_vars and _EXPANDED_VAR_PATTERN.fullmatch(value)
+             if expand_match:  # Full match expand_vars - special case keep default
+                 proxied_key: _StrType = expand_match.groups()[0]
+                 subs_default: _StrType | None = expand_match.groups()[1]

heldout/sloria__environs-1a47a3658bf7/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/sloria__environs-1a47a3658bf7/task.toml

@@ -0,0 +1,125 @@
+version = "1.0"
+
+[task]
+name = "commit-runtime/sloria__environs-1a47a3658bf7"
+description = "use fullmatch for expand_vars single-variable detection (#450)"
+
+[metadata]
+difficulty = "small"
+category = "bugfix"
+keywords = [
+    "environs",
+    "commit_runtime",
+]
+
+[metadata.repo2env]
+pipeline = "commit_runtime"
+pipeline_version = "0.8.3"
+repo = "sloria/environs"
+ref = "f678dabd2ebb32a22a90f439d8518f8c2ddcb60c"
+reference = "https://github.com/sloria/environs/commit/1a47a3658bf705e6270cb685efc38c22264c9110"
+source_access = "public"
+built_at = "2026-09-24T13:07:49.771316+00:00"
+synthesis_llm = "gemini/gemini-2.5-flash"
+reward_kinds = [
+    "test_execution",
+    "diff_similarity",
+]
+spec_version = "0.2.0"
+content_hash = "sha256:696c2b9120b71a40eb51e7e88a6096337c1d0a3f1bd306939d6d002e5e4a1347"
+
+[metadata.repo2env.commit_runtime]
+commit_sha = "1a47a3658bf705e6270cb685efc38c22264c9110"
+parent_sha = "f678dabd2ebb32a22a90f439d8518f8c2ddcb60c"
+authored_at = "2026-02-19T19:59:13-08:00"
+author_email = "34209028+veeceey@users.noreply.github.com"
+subject = "fix: use fullmatch for expand_vars single-variable detection (#450)"
+fail_to_pass = [
+    "tests/test_environs.py::TestExpandVars::test_expand_var_at_start_with_trailing_content",
+]
+pass_to_pass = [
+    "tests/test_environs.py::TestCasting::test_basic",
+    "tests/test_environs.py::TestCasting::test_bool",
+    "tests/test_environs.py::TestCasting::test_call",
+    "tests/test_environs.py::TestCasting::test_call_with_default",
+    "tests/test_environs.py::TestCasting::test_custom_subcast_keys_values",
+    "tests/test_environs.py::TestCasting::test_custom_subcast_list",
+    "tests/test_environs.py::TestCasting::test_date_cast",
+    "tests/test_environs.py::TestCasting::test_datetime_cast",
+    "tests/test_environs.py::TestCasting::test_decimal_cast",
+    "tests/test_environs.py::TestCasting::test_default_set",
+    "tests/test_environs.py::TestCasting::test_default_set_to_internal_type[date]",
+    "tests/test_environs.py::TestCasting::test_default_set_to_internal_type[datetime]",
+    "tests/test_environs.py::TestCasting::test_default_set_to_internal_type[time]",
+    "tests/test_environs.py::TestCasting::test_dict",
+    "tests/test_environs.py::TestCasting::test_dict_with_colon_key_value_delimiter",
+    "tests/test_environs.py::TestCasting::test_dict_with_dict_default",
+    "tests/test_environs.py::TestCasting::test_dict_with_equal",
+    "tests/test_environs.py::TestCasting::test_dict_with_spaces_as_delimiter",
+    "tests/test_environs.py::TestCasting::test_dict_with_subcast_keys",
+    "tests/test_environs.py::TestCasting::test_dict_with_subcast_values",
+    "tests/test_environs.py::TestCasting::test_dict_without_subcast_keys",
+    "tests/test_environs.py::TestCasting::test_empty_str",
+    "tests/test_environs.py::TestCasting::test_enum_by_value_field",
+    "tests/test_environs.py::TestCasting::test_enum_by_value_true",
+    "tests/test_environs.py::TestCasting::test_enum_cast",
+    "tests/test_environs.py::TestCasting::test_enum_default",
+    "tests/test_environs.py::TestCasting::test_float_cast",
+    "tests/test_environs.py::TestCasting::test_int_cast",
+    "tests/test_environs.py::TestCasting::test_invalid_enum",
+    "tests/test_environs.py::TestCasting::test_invalid_int",
+    "tests/test_environs.py::TestCasting::test_invalid_json_raises_error",
+    "tests/test_environs.py::TestCasting::test_invalid_log_level",
+    "tests/test_environs.py::TestCasting::test_invalid_url[42]",
+    "tests/test_environs.py::TestCasting::test_invalid_url[foo@bar]",
+    "tests/test_environs.py::TestCasting::test_invalid_url[foo]",
+    "tests/test_environs.py::TestCasting::test_json_cast",
+    "tests/test_environs.py::TestCasting::test_json_default",
+    "tests/test_environs.py::TestCasting::test_list_cast",
+    "tests/test_environs.py::TestCasting::test_list_with_default_from_list",
+    "tests/test_environs.py::TestCasting::test_list_with_default_list_and_subcast",
+    "tests/test_environs.py::TestCasting::test_list_with_default_none",
+    "tests/test_environs.py::TestCasting::test_list_with_empty_env_and_subcast",
+    "tests/test_environs.py::TestCasting::test_list_with_spaces",
+    "tests/test_environs.py::TestCasting::test_list_with_spaces_as_delimiter",
+    "tests/test_environs.py::TestCasting::test_list_with_subcast",
+    "tests/test_environs.py::TestCasting::test_log_level_cast",
+    "tests/test_environs.py::TestCasting::test_missing_raises_error",
+    "tests/test_environs.py::TestCasting::test_path_cast",
+    "tests/test_environs.py::TestCasting::test_path_default_value",
+    "tests/test_environs.py::TestCasting::test_time_cast",
+]
+validation_status = "verified"
+bootstrap_image = "local-venv:sloria__environs"
+instruction_synthesized = true
+llm_cost_usd = 0.001491
+
+[metadata.repo2env.reward_calibration]
+f2p_count = 1
+p2p_count = 50
+source_files = 2
+loc_changed = 7
+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/sloria__environs"
+image_tag = "local/sloria__environs"
+image_visibility = "private"
+
+[agent]
+timeout_sec = 1800.0
+
+[verifier]
+timeout_sec = 300.0

heldout/sloria__environs-1a47a3658bf7/tests/f2p.json

@@ -0,0 +1,3 @@
+[
+  "tests/test_environs.py::TestExpandVars::test_expand_var_at_start_with_trailing_content"
+]

heldout/sloria__environs-1a47a3658bf7/tests/p2p.json

@@ -0,0 +1,52 @@
+[
+  "tests/test_environs.py::TestCasting::test_basic",
+  "tests/test_environs.py::TestCasting::test_bool",
+  "tests/test_environs.py::TestCasting::test_call",
+  "tests/test_environs.py::TestCasting::test_call_with_default",
+  "tests/test_environs.py::TestCasting::test_custom_subcast_keys_values",
+  "tests/test_environs.py::TestCasting::test_custom_subcast_list",
+  "tests/test_environs.py::TestCasting::test_date_cast",
+  "tests/test_environs.py::TestCasting::test_datetime_cast",
+  "tests/test_environs.py::TestCasting::test_decimal_cast",
+  "tests/test_environs.py::TestCasting::test_default_set",
+  "tests/test_environs.py::TestCasting::test_default_set_to_internal_type[date]",
+  "tests/test_environs.py::TestCasting::test_default_set_to_internal_type[datetime]",
+  "tests/test_environs.py::TestCasting::test_default_set_to_internal_type[time]",
+  "tests/test_environs.py::TestCasting::test_dict",
+  "tests/test_environs.py::TestCasting::test_dict_with_colon_key_value_delimiter",
+  "tests/test_environs.py::TestCasting::test_dict_with_dict_default",
+  "tests/test_environs.py::TestCasting::test_dict_with_equal",
+  "tests/test_environs.py::TestCasting::test_dict_with_spaces_as_delimiter",
+  "tests/test_environs.py::TestCasting::test_dict_with_subcast_keys",
+  "tests/test_environs.py::TestCasting::test_dict_with_subcast_values",
+  "tests/test_environs.py::TestCasting::test_dict_without_subcast_keys",
+  "tests/test_environs.py::TestCasting::test_empty_str",
+  "tests/test_environs.py::TestCasting::test_enum_by_value_field",
+  "tests/test_environs.py::TestCasting::test_enum_by_value_true",
+  "tests/test_environs.py::TestCasting::test_enum_cast",
+  "tests/test_environs.py::TestCasting::test_enum_default",
+  "tests/test_environs.py::TestCasting::test_float_cast",
+  "tests/test_environs.py::TestCasting::test_int_cast",
+  "tests/test_environs.py::TestCasting::test_invalid_enum",
+  "tests/test_environs.py::TestCasting::test_invalid_int",
+  "tests/test_environs.py::TestCasting::test_invalid_json_raises_error",
+  "tests/test_environs.py::TestCasting::test_invalid_log_level",
+  "tests/test_environs.py::TestCasting::test_invalid_url[42]",
+  "tests/test_environs.py::TestCasting::test_invalid_url[foo@bar]",
+  "tests/test_environs.py::TestCasting::test_invalid_url[foo]",
+  "tests/test_environs.py::TestCasting::test_json_cast",
+  "tests/test_environs.py::TestCasting::test_json_default",
+  "tests/test_environs.py::TestCasting::test_list_cast",
+  "tests/test_environs.py::TestCasting::test_list_with_default_from_list",
+  "tests/test_environs.py::TestCasting::test_list_with_default_list_and_subcast",
+  "tests/test_environs.py::TestCasting::test_list_with_default_none",
+  "tests/test_environs.py::TestCasting::test_list_with_empty_env_and_subcast",
+  "tests/test_environs.py::TestCasting::test_list_with_spaces",
+  "tests/test_environs.py::TestCasting::test_list_with_spaces_as_delimiter",
+  "tests/test_environs.py::TestCasting::test_list_with_subcast",
+  "tests/test_environs.py::TestCasting::test_log_level_cast",
+  "tests/test_environs.py::TestCasting::test_missing_raises_error",
+  "tests/test_environs.py::TestCasting::test_path_cast",
+  "tests/test_environs.py::TestCasting::test_path_default_value",
+  "tests/test_environs.py::TestCasting::test_time_cast"
+]

heldout/sloria__environs-1a47a3658bf7/tests/test.sh

@@ -0,0 +1,44 @@
+#!/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 f678dabd2ebb32a22a90f439d8518f8c2ddcb60c -- tests/test_environs.py || true
+git apply --verbose --reject - <<'EOF_R2E_TEST_PATCH'
+diff --git a/tests/test_environs.py b/tests/test_environs.py
+index f8c1053..420475c 100644
+--- a/tests/test_environs.py
++++ b/tests/test_environs.py
+@@ -1099,6 +1099,16 @@ class TestExpandVars:
+             "wget_params": '--header="Referer: https://radiocut.fm/"',
+         }
+ 
++    def test_expand_var_at_start_with_trailing_content(self, env: environs.Env, set_env):
++        """Regression test for https://github.com/sloria/environs/issues/359"""
++        set_env(
++            {
++                "A": "Val_A",
++                "B": "${A};Val_B;",
++            },
++        )
++        assert env.str("B") == "Val_A;Val_B;"
++
+ 
+ class TestFileAwareEnv:
+     @pytest.fixture
+
+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_environs.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_environs.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 f678dabd2ebb32a22a90f439d8518f8c2ddcb60c -- tests/test_environs.py || true
+exit 0

heldout/sloria__environs-1a47a3658bf7/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/sloria__environs-9c51c66940a1/environment/Dockerfile

@@ -0,0 +1,36 @@
+# Auto-generated by Repo2RLEnv pr_runtime
+FROM local/sloria__environs
+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 4654e60b62aae63638533c6aa8d4605680d2e3f1 2>/dev/null \
+       || git fetch --unshallow origin 2>/dev/null || true
+RUN git reset --hard 4654e60b62aae63638533c6aa8d4605680d2e3f1 && 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 4654e60b62aae63638533c6aa8d4605680d2e3f1 \
+    && 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/sloria__environs-9c51c66940a1/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/sloria__environs-9c51c66940a1/instruction.md

@@ -0,0 +1,19 @@
+# Issue
+
+**Title:** Environment variables from `os.environ` are overridden by `.env` files
+
+## Description
+When an environment variable is already set in the system's `os.environ` (e.g., from the shell or system-wide configuration), and the same variable is also defined within a `.env` file, the value from the `.env` file incorrectly takes precedence.
+
+**Reproduction:**
+1. Set an environment variable in your shell: `export MY_VAR=from_shell`
+2. Create a `.env` file with the same variable: `echo "MY_VAR=from_dot_env" > .env`
+3. Load environment variables (e.g., using a library that processes `.env` files).
+4. Check the value of `MY_VAR`.
+
+**Actual Behavior:** The application reads `MY_VAR` as `from_dot_env`.
+**Expected Behavior:** The application should read `MY_VAR` as `from_shell`, respecting the precedence of `os.environ` over `.env` files.
+
+## 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 `4654e60b62aa` and running the modified tests.

heldout/sloria__environs-9c51c66940a1/solution/patch.diff

@@ -0,0 +1,42 @@
+diff --git a/CHANGELOG.md b/CHANGELOG.md
+index c94fb52..e8be1f4 100644
+--- a/CHANGELOG.md
++++ b/CHANGELOG.md
+@@ -1,5 +1,12 @@
+ # Changelog
+ 
++## unreleased
++
++Bug fixes:
++
++- Exported environment variables take precedence over `.env` files (regression from 15.0.0) ([#464](https://github.com/sloria/environs/issues/464)).
++  Thanks [DougEdey-Slice](https://github.com/DougEdey-Slice) for reporting.
++
+ ## 15.0.0 (2026-03-31)
+ 
+ Features:
+diff --git a/src/environs/__init__.py b/src/environs/__init__.py
+index 66432c8..8168cec 100644
+--- a/src/environs/__init__.py
++++ b/src/environs/__init__.py
+@@ -595,9 +595,9 @@ class Env:
+ 
+     def _get_value(self, env_key: _StrType, default: typing.Any) -> typing.Any:
+         try:
+-            return self._environ[env_key]
++            return os.environ[env_key]
+         except KeyError:
+-            return os.environ.get(env_key, default)
++            return self._environ.get(env_key, default)
+ 
+ 
+ class FileAwareEnv(Env):
+@@ -619,7 +619,7 @@ class FileAwareEnv(Env):
+     def _get_value(self, env_key: _StrType, default: typing.Any) -> typing.Any:
+         """Return the contents of the file referenced in key <env_key>_FILE, if present."""
+         file_key = f"{env_key}{self.file_suffix}"
+-        if file_path := self._environ.get(file_key) or os.environ.get(file_key):
++        if file_path := os.environ.get(file_key) or self._environ.get(file_key):
+             try:
+                 value: _StrType = Path(file_path).read_text()
+                 return value.strip() if self.strip_whitespace else value

heldout/sloria__environs-9c51c66940a1/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/sloria__environs-9c51c66940a1/task.toml

@@ -0,0 +1,126 @@
+version = "1.0"
+
+[task]
+name = "commit-runtime/sloria__environs-9c51c66940a1"
+description = "Fix precedence of os.environ over .env (#465)"
+
+[metadata]
+difficulty = "small"
+category = "bugfix"
+keywords = [
+    "environs",
+    "commit_runtime",
+]
+
+[metadata.repo2env]
+pipeline = "commit_runtime"
+pipeline_version = "0.8.3"
+repo = "sloria/environs"
+ref = "4654e60b62aae63638533c6aa8d4605680d2e3f1"
+reference = "https://github.com/sloria/environs/commit/9c51c66940a1fb0fb9c4623c5c2dbd3987eeeb39"
+source_access = "public"
+built_at = "2026-09-24T13:07:42.520074+00:00"
+synthesis_llm = "gemini/gemini-2.5-flash"
+reward_kinds = [
+    "test_execution",
+    "diff_similarity",
+]
+spec_version = "0.2.0"
+content_hash = "sha256:ee6ad05e460704b9b341bae1c4524b7c90284f80d5d748b70604620d3f1e878b"
+
+[metadata.repo2env.commit_runtime]
+commit_sha = "9c51c66940a1fb0fb9c4623c5c2dbd3987eeeb39"
+parent_sha = "4654e60b62aae63638533c6aa8d4605680d2e3f1"
+authored_at = "2026-04-06T10:09:25-04:00"
+author_email = "git@stevenloria.com"
+subject = "Fix precedence of os.environ over .env (#465)"
+fail_to_pass = [
+    "tests/test_environs.py::TestEnvFileReading::test_read_env_os_environ_takes_precedence",
+    "tests/test_environs.py::TestEnvFileReading::test_read_env_os_environ_takes_precedence_with_override",
+]
+pass_to_pass = [
+    "tests/test_environs.py::TestCasting::test_basic",
+    "tests/test_environs.py::TestCasting::test_bool",
+    "tests/test_environs.py::TestCasting::test_call",
+    "tests/test_environs.py::TestCasting::test_call_with_default",
+    "tests/test_environs.py::TestCasting::test_custom_subcast_keys_values",
+    "tests/test_environs.py::TestCasting::test_custom_subcast_list",
+    "tests/test_environs.py::TestCasting::test_date_cast",
+    "tests/test_environs.py::TestCasting::test_datetime_cast",
+    "tests/test_environs.py::TestCasting::test_decimal_cast",
+    "tests/test_environs.py::TestCasting::test_default_set",
+    "tests/test_environs.py::TestCasting::test_default_set_to_internal_type[date]",
+    "tests/test_environs.py::TestCasting::test_default_set_to_internal_type[datetime]",
+    "tests/test_environs.py::TestCasting::test_default_set_to_internal_type[time]",
+    "tests/test_environs.py::TestCasting::test_dict",
+    "tests/test_environs.py::TestCasting::test_dict_with_colon_key_value_delimiter",
+    "tests/test_environs.py::TestCasting::test_dict_with_dict_default",
+    "tests/test_environs.py::TestCasting::test_dict_with_equal",
+    "tests/test_environs.py::TestCasting::test_dict_with_spaces_as_delimiter",
+    "tests/test_environs.py::TestCasting::test_dict_with_subcast_keys",
+    "tests/test_environs.py::TestCasting::test_dict_with_subcast_values",
+    "tests/test_environs.py::TestCasting::test_dict_without_subcast_keys",
+    "tests/test_environs.py::TestCasting::test_empty_str",
+    "tests/test_environs.py::TestCasting::test_enum_by_value_field",
+    "tests/test_environs.py::TestCasting::test_enum_by_value_true",
+    "tests/test_environs.py::TestCasting::test_enum_cast",
+    "tests/test_environs.py::TestCasting::test_enum_default",
+    "tests/test_environs.py::TestCasting::test_float_cast",
+    "tests/test_environs.py::TestCasting::test_int_cast",
+    "tests/test_environs.py::TestCasting::test_invalid_enum",
+    "tests/test_environs.py::TestCasting::test_invalid_int",
+    "tests/test_environs.py::TestCasting::test_invalid_json_raises_error",
+    "tests/test_environs.py::TestCasting::test_invalid_log_level",
+    "tests/test_environs.py::TestCasting::test_invalid_url[42]",
+    "tests/test_environs.py::TestCasting::test_invalid_url[foo@bar]",
+    "tests/test_environs.py::TestCasting::test_invalid_url[foo]",
+    "tests/test_environs.py::TestCasting::test_json_cast",
+    "tests/test_environs.py::TestCasting::test_json_default",
+    "tests/test_environs.py::TestCasting::test_list_cast",
+    "tests/test_environs.py::TestCasting::test_list_with_default_from_list",
+    "tests/test_environs.py::TestCasting::test_list_with_default_list_and_subcast",
+    "tests/test_environs.py::TestCasting::test_list_with_default_none",
+    "tests/test_environs.py::TestCasting::test_list_with_empty_env_and_subcast",
+    "tests/test_environs.py::TestCasting::test_list_with_spaces",
+    "tests/test_environs.py::TestCasting::test_list_with_spaces_as_delimiter",
+    "tests/test_environs.py::TestCasting::test_list_with_subcast",
+    "tests/test_environs.py::TestCasting::test_log_level_cast",
+    "tests/test_environs.py::TestCasting::test_missing_raises_error",
+    "tests/test_environs.py::TestCasting::test_none_default_unchanged",
+    "tests/test_environs.py::TestCasting::test_path_cast",
+    "tests/test_environs.py::TestCasting::test_path_default_value",
+]
+validation_status = "verified"
+bootstrap_image = "local-venv:sloria__environs"
+instruction_synthesized = true
+llm_cost_usd = 0.0
+
+[metadata.repo2env.reward_calibration]
+f2p_count = 2
+p2p_count = 50
+source_files = 2
+loc_changed = 13
+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/sloria__environs"
+image_tag = "local/sloria__environs"
+image_visibility = "private"
+
+[agent]
+timeout_sec = 1800.0
+
+[verifier]
+timeout_sec = 300.0

heldout/sloria__environs-9c51c66940a1/tests/f2p.json

@@ -0,0 +1,4 @@
+[
+  "tests/test_environs.py::TestEnvFileReading::test_read_env_os_environ_takes_precedence",
+  "tests/test_environs.py::TestEnvFileReading::test_read_env_os_environ_takes_precedence_with_override"
+]

heldout/sloria__environs-9c51c66940a1/tests/p2p.json

@@ -0,0 +1,52 @@
+[
+  "tests/test_environs.py::TestCasting::test_basic",
+  "tests/test_environs.py::TestCasting::test_bool",
+  "tests/test_environs.py::TestCasting::test_call",
+  "tests/test_environs.py::TestCasting::test_call_with_default",
+  "tests/test_environs.py::TestCasting::test_custom_subcast_keys_values",
+  "tests/test_environs.py::TestCasting::test_custom_subcast_list",
+  "tests/test_environs.py::TestCasting::test_date_cast",
+  "tests/test_environs.py::TestCasting::test_datetime_cast",
+  "tests/test_environs.py::TestCasting::test_decimal_cast",
+  "tests/test_environs.py::TestCasting::test_default_set",
+  "tests/test_environs.py::TestCasting::test_default_set_to_internal_type[date]",
+  "tests/test_environs.py::TestCasting::test_default_set_to_internal_type[datetime]",
+  "tests/test_environs.py::TestCasting::test_default_set_to_internal_type[time]",
+  "tests/test_environs.py::TestCasting::test_dict",
+  "tests/test_environs.py::TestCasting::test_dict_with_colon_key_value_delimiter",
+  "tests/test_environs.py::TestCasting::test_dict_with_dict_default",
+  "tests/test_environs.py::TestCasting::test_dict_with_equal",
+  "tests/test_environs.py::TestCasting::test_dict_with_spaces_as_delimiter",
+  "tests/test_environs.py::TestCasting::test_dict_with_subcast_keys",
+  "tests/test_environs.py::TestCasting::test_dict_with_subcast_values",
+  "tests/test_environs.py::TestCasting::test_dict_without_subcast_keys",
+  "tests/test_environs.py::TestCasting::test_empty_str",
+  "tests/test_environs.py::TestCasting::test_enum_by_value_field",
+  "tests/test_environs.py::TestCasting::test_enum_by_value_true",
+  "tests/test_environs.py::TestCasting::test_enum_cast",
+  "tests/test_environs.py::TestCasting::test_enum_default",
+  "tests/test_environs.py::TestCasting::test_float_cast",
+  "tests/test_environs.py::TestCasting::test_int_cast",
+  "tests/test_environs.py::TestCasting::test_invalid_enum",
+  "tests/test_environs.py::TestCasting::test_invalid_int",
+  "tests/test_environs.py::TestCasting::test_invalid_json_raises_error",
+  "tests/test_environs.py::TestCasting::test_invalid_log_level",
+  "tests/test_environs.py::TestCasting::test_invalid_url[42]",
+  "tests/test_environs.py::TestCasting::test_invalid_url[foo@bar]",
+  "tests/test_environs.py::TestCasting::test_invalid_url[foo]",
+  "tests/test_environs.py::TestCasting::test_json_cast",
+  "tests/test_environs.py::TestCasting::test_json_default",
+  "tests/test_environs.py::TestCasting::test_list_cast",
+  "tests/test_environs.py::TestCasting::test_list_with_default_from_list",
+  "tests/test_environs.py::TestCasting::test_list_with_default_list_and_subcast",
+  "tests/test_environs.py::TestCasting::test_list_with_default_none",
+  "tests/test_environs.py::TestCasting::test_list_with_empty_env_and_subcast",
+  "tests/test_environs.py::TestCasting::test_list_with_spaces",
+  "tests/test_environs.py::TestCasting::test_list_with_spaces_as_delimiter",
+  "tests/test_environs.py::TestCasting::test_list_with_subcast",
+  "tests/test_environs.py::TestCasting::test_log_level_cast",
+  "tests/test_environs.py::TestCasting::test_missing_raises_error",
+  "tests/test_environs.py::TestCasting::test_none_default_unchanged",
+  "tests/test_environs.py::TestCasting::test_path_cast",
+  "tests/test_environs.py::TestCasting::test_path_default_value"
+]

heldout/sloria__environs-9c51c66940a1/tests/test.sh

@@ -0,0 +1,50 @@
+#!/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 4654e60b62aae63638533c6aa8d4605680d2e3f1 -- tests/test_environs.py || true
+git apply --verbose --reject - <<'EOF_R2E_TEST_PATCH'
+diff --git a/tests/test_environs.py b/tests/test_environs.py
+index 756223b..dfef7e5 100644
+--- a/tests/test_environs.py
++++ b/tests/test_environs.py
+@@ -547,6 +547,22 @@ class TestEnvFileReading:
+         assert env("STRING") == "foo"
+         assert "STRING" not in os.environ
+ 
++    def test_read_env_os_environ_takes_precedence(self, env: environs.Env, monkeypatch):
++        monkeypatch.setenv("STRING", "from_os")
++        env.read_env()
++        assert env("STRING") == "from_os"
++
++    def test_read_env_os_environ_takes_precedence_with_override(
++        self, tmp_path, monkeypatch
++    ):
++        monkeypatch.setenv("A", "from_os")
++        (tmp_path / "first.env").write_text("A=first\n")
++        (tmp_path / "second.env").write_text("A=second\n")
++        env = environs.Env()
++        env.read_env(tmp_path / "first.env")
++        env.read_env(tmp_path / "second.env", override=True)
++        assert env("A") == "from_os"
++
+     def test_read_env_override(self, tmp_path):
+         (tmp_path / "first.env").write_text("A=first\n")
+         (tmp_path / "second.env").write_text("A=second\n")
+
+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_environs.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_environs.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 4654e60b62aae63638533c6aa8d4605680d2e3f1 -- tests/test_environs.py || true
+exit 0

heldout/sloria__environs-9c51c66940a1/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/sloria__environs-9d1ff82555e0/environment/Dockerfile

@@ -0,0 +1,36 @@
+# Auto-generated by Repo2RLEnv pr_runtime
+FROM local/sloria__environs
+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 a873df3460939554806834390a6c82dac194b2ad 2>/dev/null \
+       || git fetch --unshallow origin 2>/dev/null || true
+RUN git reset --hard a873df3460939554806834390a6c82dac194b2ad && 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 a873df3460939554806834390a6c82dac194b2ad \
+    && 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/sloria__environs-9d1ff82555e0/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/sloria__environs-9d1ff82555e0/instruction.md

@@ -0,0 +1,10 @@
+# Issue
+
+**Title:** `read_env` always searches recursively and can raise `UnboundLocalError`
+
+## Description
+The `read_env` function exhibits an "always recursive" behavior, meaning it searches parent directories for `.env` files even when not explicitly intended, potentially leading to unexpected file loading. Furthermore, under specific conditions, calling `read_env` can result in an `UnboundLocalError`. When `return_path=True` and no `.env` file is located, the function should return `None` but currently does not.
+
+## 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 `a873df346093` and running the modified tests.

heldout/sloria__environs-9d1ff82555e0/solution/patch.diff

@@ -0,0 +1,49 @@
+diff --git a/CHANGELOG.md b/CHANGELOG.md
+index eb26dd6..96c2563 100644
+--- a/CHANGELOG.md
++++ b/CHANGELOG.md
+@@ -1,5 +1,13 @@
+ # Changelog
+ 
++## 11.2.1 (unreleased)
++
++Bug fixes:
++
++- Fix `Env.read_env(recurse=True)` so that it returns as soon as a `.env`
++  file is found ([#370](https://github.com/sloria/environs/pull/370)).
++  Thanks [senese](https://github.com/senese) for the PR.
++
+ ## 11.2.0 (2024-11-14)
+ 
+ Features:
+diff --git a/src/environs/__init__.py b/src/environs/__init__.py
+index 8014260..2fb8e40 100644
+--- a/src/environs/__init__.py
++++ b/src/environs/__init__.py
+@@ -454,7 +454,7 @@ class Env:
+         verbose: _BoolType = False,
+         override: _BoolType = False,
+         return_path: _BoolType = False,
+-    ) -> typing.Union[_BoolType, _StrType]:
++    ) -> typing.Union[_BoolType, typing.Optional[_StrType]]:
+         """Read a .env file into os.environ.
+ 
+         If .env is not found in the directory from which this method is called,
+@@ -462,7 +462,7 @@ class Env:
+         file is found. If you do not wish to recurse up the tree, you may pass
+         False as a second positional argument.
+         """
+-
++        env_path = None
+         is_env_loaded = False
+         if path is None:
+             # By default, start search from the same directory this function is called
+@@ -488,6 +488,8 @@ class Env:
+                         check_path, verbose=verbose, override=override
+                     )
+                     env_path = str(check_path)
++                    break
++
+         else:
+             is_env_loaded = load_dotenv(str(start), verbose=verbose, override=override)
+             env_path = str(start)

heldout/sloria__environs-9d1ff82555e0/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/sloria__environs-9d1ff82555e0/task.toml

@@ -0,0 +1,126 @@
+version = "1.0"
+
+[task]
+name = "commit-runtime/sloria__environs-9d1ff82555e0"
+description = "Fix read_env recursive bug (#370)"
+
+[metadata]
+difficulty = "small"
+category = "bugfix"
+keywords = [
+    "environs",
+    "commit_runtime",
+]
+
+[metadata.repo2env]
+pipeline = "commit_runtime"
+pipeline_version = "0.8.3"
+repo = "sloria/environs"
+ref = "a873df3460939554806834390a6c82dac194b2ad"
+reference = "https://github.com/sloria/environs/commit/9d1ff82555e053990dc8c3bfbdf268015f3502bc"
+source_access = "public"
+built_at = "2026-09-24T13:07:59.861100+00:00"
+synthesis_llm = "gemini/gemini-2.5-flash"
+reward_kinds = [
+    "test_execution",
+    "diff_similarity",
+]
+spec_version = "0.2.0"
+content_hash = "sha256:1f4fe7e9bb123e887810eeaf2697c3ae748769a679d903b453544fe404944ee6"
+
+[metadata.repo2env.commit_runtime]
+commit_sha = "9d1ff82555e053990dc8c3bfbdf268015f3502bc"
+parent_sha = "a873df3460939554806834390a6c82dac194b2ad"
+authored_at = "2024-11-20T14:30:32-03:00"
+author_email = "30537409+senese@users.noreply.github.com"
+subject = "Fix read_env recursive bug (#370)"
+fail_to_pass = [
+    "tests/test_environs.py::TestEnvFileReading::test_read_env_return_path_if_env_not_found",
+    "tests/test_environs.py::TestEnvFileReading::test_read_env_return_path_with_dotenv_in_working_dir",
+]
+pass_to_pass = [
+    "tests/test_environs.py::TestCasting::test_basic",
+    "tests/test_environs.py::TestCasting::test_bool",
+    "tests/test_environs.py::TestCasting::test_call",
+    "tests/test_environs.py::TestCasting::test_call_with_default",
+    "tests/test_environs.py::TestCasting::test_custom_subcast_keys_values",
+    "tests/test_environs.py::TestCasting::test_custom_subcast_list",
+    "tests/test_environs.py::TestCasting::test_date_cast",
+    "tests/test_environs.py::TestCasting::test_datetime_cast",
+    "tests/test_environs.py::TestCasting::test_decimal_cast",
+    "tests/test_environs.py::TestCasting::test_dict",
+    "tests/test_environs.py::TestCasting::test_dict_with_default_from_dict",
+    "tests/test_environs.py::TestCasting::test_dict_with_default_from_string",
+    "tests/test_environs.py::TestCasting::test_dict_with_equal",
+    "tests/test_environs.py::TestCasting::test_dict_with_spaces_as_delimiter",
+    "tests/test_environs.py::TestCasting::test_dict_with_subcast_keys",
+    "tests/test_environs.py::TestCasting::test_dict_with_subcast_values",
+    "tests/test_environs.py::TestCasting::test_dict_without_subcast_keys",
+    "tests/test_environs.py::TestCasting::test_empty_str",
+    "tests/test_environs.py::TestCasting::test_enum_cast",
+    "tests/test_environs.py::TestCasting::test_enum_cast_ignore_case",
+    "tests/test_environs.py::TestCasting::test_float_cast",
+    "tests/test_environs.py::TestCasting::test_int_cast",
+    "tests/test_environs.py::TestCasting::test_invalid_enum",
+    "tests/test_environs.py::TestCasting::test_invalid_enum_ignore_case",
+    "tests/test_environs.py::TestCasting::test_invalid_int",
+    "tests/test_environs.py::TestCasting::test_invalid_json_raises_error",
+    "tests/test_environs.py::TestCasting::test_invalid_log_level",
+    "tests/test_environs.py::TestCasting::test_invalid_url[42]",
+    "tests/test_environs.py::TestCasting::test_invalid_url[foo@bar]",
+    "tests/test_environs.py::TestCasting::test_invalid_url[foo]",
+    "tests/test_environs.py::TestCasting::test_json_cast",
+    "tests/test_environs.py::TestCasting::test_json_default",
+    "tests/test_environs.py::TestCasting::test_list_cast",
+    "tests/test_environs.py::TestCasting::test_list_with_default_from_list",
+    "tests/test_environs.py::TestCasting::test_list_with_default_from_string",
+    "tests/test_environs.py::TestCasting::test_list_with_default_none",
+    "tests/test_environs.py::TestCasting::test_list_with_empty_env_and_subcast",
+    "tests/test_environs.py::TestCasting::test_list_with_spaces",
+    "tests/test_environs.py::TestCasting::test_list_with_spaces_as_delimiter",
+    "tests/test_environs.py::TestCasting::test_list_with_subcast",
+    "tests/test_environs.py::TestCasting::test_log_level_cast",
+    "tests/test_environs.py::TestCasting::test_missing_raises_error",
+    "tests/test_environs.py::TestCasting::test_path_cast",
+    "tests/test_environs.py::TestCasting::test_path_default_value",
+    "tests/test_environs.py::TestCasting::test_time_cast",
+    "tests/test_environs.py::TestCasting::test_url_cast",
+    "tests/test_environs.py::TestCasting::test_url_db_cast",
+    "tests/test_environs.py::TestCasting::test_uuid_cast",
+    "tests/test_environs.py::TestCustomTypes::test_add_parser",
+    "tests/test_environs.py::TestCustomTypes::test_add_parser_from_field",
+]
+validation_status = "verified"
+bootstrap_image = "local-venv:sloria__environs"
+instruction_synthesized = true
+llm_cost_usd = 0.004334
+
+[metadata.repo2env.reward_calibration]
+f2p_count = 2
+p2p_count = 50
+source_files = 2
+loc_changed = 14
+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/sloria__environs"
+image_tag = "local/sloria__environs"
+image_visibility = "private"
+
+[agent]
+timeout_sec = 1800.0
+
+[verifier]
+timeout_sec = 300.0

heldout/sloria__environs-9d1ff82555e0/tests/f2p.json

@@ -0,0 +1,4 @@
+[
+  "tests/test_environs.py::TestEnvFileReading::test_read_env_return_path_if_env_not_found",
+  "tests/test_environs.py::TestEnvFileReading::test_read_env_return_path_with_dotenv_in_working_dir"
+]

heldout/sloria__environs-9d1ff82555e0/tests/p2p.json

@@ -0,0 +1,52 @@
+[
+  "tests/test_environs.py::TestCasting::test_basic",
+  "tests/test_environs.py::TestCasting::test_bool",
+  "tests/test_environs.py::TestCasting::test_call",
+  "tests/test_environs.py::TestCasting::test_call_with_default",
+  "tests/test_environs.py::TestCasting::test_custom_subcast_keys_values",
+  "tests/test_environs.py::TestCasting::test_custom_subcast_list",
+  "tests/test_environs.py::TestCasting::test_date_cast",
+  "tests/test_environs.py::TestCasting::test_datetime_cast",
+  "tests/test_environs.py::TestCasting::test_decimal_cast",
+  "tests/test_environs.py::TestCasting::test_dict",
+  "tests/test_environs.py::TestCasting::test_dict_with_default_from_dict",
+  "tests/test_environs.py::TestCasting::test_dict_with_default_from_string",
+  "tests/test_environs.py::TestCasting::test_dict_with_equal",
+  "tests/test_environs.py::TestCasting::test_dict_with_spaces_as_delimiter",
+  "tests/test_environs.py::TestCasting::test_dict_with_subcast_keys",
+  "tests/test_environs.py::TestCasting::test_dict_with_subcast_values",
+  "tests/test_environs.py::TestCasting::test_dict_without_subcast_keys",
+  "tests/test_environs.py::TestCasting::test_empty_str",
+  "tests/test_environs.py::TestCasting::test_enum_cast",
+  "tests/test_environs.py::TestCasting::test_enum_cast_ignore_case",
+  "tests/test_environs.py::TestCasting::test_float_cast",
+  "tests/test_environs.py::TestCasting::test_int_cast",
+  "tests/test_environs.py::TestCasting::test_invalid_enum",
+  "tests/test_environs.py::TestCasting::test_invalid_enum_ignore_case",
+  "tests/test_environs.py::TestCasting::test_invalid_int",
+  "tests/test_environs.py::TestCasting::test_invalid_json_raises_error",
+  "tests/test_environs.py::TestCasting::test_invalid_log_level",
+  "tests/test_environs.py::TestCasting::test_invalid_url[42]",
+  "tests/test_environs.py::TestCasting::test_invalid_url[foo@bar]",
+  "tests/test_environs.py::TestCasting::test_invalid_url[foo]",
+  "tests/test_environs.py::TestCasting::test_json_cast",
+  "tests/test_environs.py::TestCasting::test_json_default",
+  "tests/test_environs.py::TestCasting::test_list_cast",
+  "tests/test_environs.py::TestCasting::test_list_with_default_from_list",
+  "tests/test_environs.py::TestCasting::test_list_with_default_from_string",
+  "tests/test_environs.py::TestCasting::test_list_with_default_none",
+  "tests/test_environs.py::TestCasting::test_list_with_empty_env_and_subcast",
+  "tests/test_environs.py::TestCasting::test_list_with_spaces",
+  "tests/test_environs.py::TestCasting::test_list_with_spaces_as_delimiter",
+  "tests/test_environs.py::TestCasting::test_list_with_subcast",
+  "tests/test_environs.py::TestCasting::test_log_level_cast",
+  "tests/test_environs.py::TestCasting::test_missing_raises_error",
+  "tests/test_environs.py::TestCasting::test_path_cast",
+  "tests/test_environs.py::TestCasting::test_path_default_value",
+  "tests/test_environs.py::TestCasting::test_time_cast",
+  "tests/test_environs.py::TestCasting::test_url_cast",
+  "tests/test_environs.py::TestCasting::test_url_db_cast",
+  "tests/test_environs.py::TestCasting::test_uuid_cast",
+  "tests/test_environs.py::TestCustomTypes::test_add_parser",
+  "tests/test_environs.py::TestCustomTypes::test_add_parser_from_field"
+]

heldout/sloria__environs-9d1ff82555e0/tests/test.sh

@@ -0,0 +1,61 @@
+#!/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 a873df3460939554806834390a6c82dac194b2ad -- tests/test_environs.py || true
+git apply --verbose --reject - <<'EOF_R2E_TEST_PATCH'
+diff --git a/tests/test_environs.py b/tests/test_environs.py
+index 1920c52..102e0b8 100644
+--- a/tests/test_environs.py
++++ b/tests/test_environs.py
+@@ -407,6 +407,33 @@ class TestEnvFileReading:
+         env_path = str(HERE / ".env")
+         assert path == env_path
+ 
++    def test_read_env_return_path_with_dotenv_in_working_dir(self, env):
++        working_dir = pathlib.Path(os.getcwd())
++        temp_env = working_dir / ".env"
++        try:
++            # Create an empty .env file in working dir
++            temp_env.touch()
++            path = env.read_env(return_path=True)
++        finally:
++            if temp_env.exists():
++                temp_env.unlink()
++
++        env_path = str(HERE / ".env")
++        assert path == env_path
++
++    def test_read_env_return_path_if_env_not_found(self, env, tmp_path):
++        # Move .env file to temp location
++        env_path = HERE / ".env"
++        temp_env = tmp_path / ".env"
++        try:
++            env_path.rename(temp_env)
++            path = env.read_env(return_path=True)
++            assert path is None
++        finally:
++            # Restore .env file
++            if temp_env.exists():
++                temp_env.rename(env_path)
++
+ 
+ def always_fail(value):
+     raise environs.EnvError("something went wrong")
+
+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_environs.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_environs.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 a873df3460939554806834390a6c82dac194b2ad -- tests/test_environs.py || true
+exit 0

heldout/sloria__environs-9d1ff82555e0/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/sloria__environs-aa99f02fb39d/environment/Dockerfile

@@ -0,0 +1,36 @@
+# Auto-generated by Repo2RLEnv pr_runtime
+FROM local/sloria__environs
+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 7ed9ec4cf3fc27c83efd8fe8d29a442a09a457d0 2>/dev/null \
+       || git fetch --unshallow origin 2>/dev/null || true
+RUN git reset --hard 7ed9ec4cf3fc27c83efd8fe8d29a442a09a457d0 && 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 7ed9ec4cf3fc27c83efd8fe8d29a442a09a457d0 \
+    && 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/sloria__environs-aa99f02fb39d/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/sloria__environs-aa99f02fb39d/instruction.md

@@ -0,0 +1,10 @@
+# Issue
+
+**Title:** Values read from files include trailing newlines
+
+## Description
+When reading a value from a file, any trailing newline characters are retained as part of the retrieved value. For instance, if a file named `config.txt` contains `my_setting\n`, the value obtained will be `"my_setting\n"`. The expected behavior is that trailing newlines should be automatically stripped, returning `"my_setting"` instead.
+
+## 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 `7ed9ec4cf3fc` and running the modified tests.

heldout/sloria__environs-aa99f02fb39d/solution/patch.diff

@@ -0,0 +1,83 @@
+diff --git a/CHANGELOG.md b/CHANGELOG.md
+index 08025d9..d8e45a6 100644
+--- a/CHANGELOG.md
++++ b/CHANGELOG.md
+@@ -1,5 +1,12 @@
+ # Changelog
+ 
++## unreleased
++
++Features:
++
++- Add `strip_whitespace` param to `FileAwareEnv` ([#431](https://github.com/sloria/environs/issues/431)).
++  Thanks [eandersons](https://github.com/eandersons) for the suggestion and PR.
++
+ ## 14.4.0 (2025-10-29)
+ 
+ Features:
+diff --git a/README.md b/README.md
+index a8d31e4..d5cb72e 100644
+--- a/README.md
++++ b/README.md
+@@ -350,7 +350,7 @@ file is found, its contents will be read and returned.
+ ```python
+ from environs import FileAwareEnv
+ 
+-# echo 'my secret password' > /run/secrets/password
++# printf 'my secret password' >/run/secrets/password
+ # export PASSWORD_FILE=/run/secrets/password
+ 
+ env = FileAwareEnv()
+@@ -362,13 +362,25 @@ It's also possible to set a different suffix for the variable names:
+ ```python
+ from environs import FileAwareEnv
+ 
+-# echo 'my secret password' > /run/secrets/password
++# printf 'my secret password' >/run/secrets/password
+ # export PASSWORD_SECRET=/run/secrets/password
+ 
+ env = FileAwareEnv(file_suffix="_SECRET")
+ password = env.str("PASSWORD")  #  => 'my secret password'
+ ```
+ 
++To strip leading and trailing whitespaces from the value:
++
++```python
++from environs import FileAwareEnv
++
++# printf '  value with leading and trailing whitespaces \n' >/run/secrets/password
++# export PASSWORD_SECRET=/run/secrets/password
++
++env: FileAwareEnv = FileAwareEnv(strip_whitespace=True)
++password: str = env.str("PASSWORD")  # => `value with leading and trailing whitespaces`
++```
++
+ ## Defining custom parser behavior
+ 
+ ```python
+diff --git a/src/environs/__init__.py b/src/environs/__init__.py
+index f3ff8ba..555c763 100644
+--- a/src/environs/__init__.py
++++ b/src/environs/__init__.py
+@@ -584,8 +584,10 @@ class FileAwareEnv(Env):
+         eager: _BoolType = True,
+         expand_vars: _BoolType = False,
+         prefix: _StrType | None = None,
++        strip_whitespace: _BoolType = False,
+     ):
+-        self.file_suffix = file_suffix
++        self.file_suffix: _StrType = file_suffix
++        self.strip_whitespace: _BoolType = strip_whitespace
+         super().__init__(eager=eager, expand_vars=expand_vars, prefix=prefix)
+ 
+     def _get_value(self, env_key: _StrType, default: typing.Any) -> typing.Any:
+@@ -593,7 +595,8 @@ class FileAwareEnv(Env):
+         file_key = f"{env_key}{self.file_suffix}"
+         if file_path := os.environ.get(file_key, None):
+             try:
+-                return Path(file_path).read_text()
++                value: _StrType = Path(file_path).read_text()
++                return value.strip() if self.strip_whitespace else value
+             except (FileNotFoundError, IsADirectoryError, PermissionError) as err:
+                 raise ValueError(
+                     f"The value of {file_key} must be a readable file path."

heldout/sloria__environs-aa99f02fb39d/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/sloria__environs-aa99f02fb39d/task.toml

@@ -0,0 +1,125 @@
+version = "1.0"
+
+[task]
+name = "commit-runtime/sloria__environs-aa99f02fb39d"
+description = "Strip newlines from values retrieved from files (#436)"
+
+[metadata]
+difficulty = "medium"
+category = "bugfix"
+keywords = [
+    "environs",
+    "commit_runtime",
+]
+
+[metadata.repo2env]
+pipeline = "commit_runtime"
+pipeline_version = "0.8.3"
+repo = "sloria/environs"
+ref = "7ed9ec4cf3fc27c83efd8fe8d29a442a09a457d0"
+reference = "https://github.com/sloria/environs/commit/aa99f02fb39dda419d6ce27e2e635a948239659c"
+source_access = "public"
+built_at = "2026-09-24T13:07:54.382003+00:00"
+synthesis_llm = "gemini/gemini-2.5-flash"
+reward_kinds = [
+    "test_execution",
+    "diff_similarity",
+]
+spec_version = "0.2.0"
+content_hash = "sha256:1842f3d765b39504e653896b76a9542904b05a9030f6b3d2f05983c12a264620"
+
+[metadata.repo2env.commit_runtime]
+commit_sha = "aa99f02fb39dda419d6ce27e2e635a948239659c"
+parent_sha = "7ed9ec4cf3fc27c83efd8fe8d29a442a09a457d0"
+authored_at = "2025-11-02T23:21:26+02:00"
+author_email = "eandersons@users.noreply.github.com"
+subject = "Strip newlines from values retrieved from files (#436)"
+fail_to_pass = [
+    "tests/test_environs.py::TestFileAwareEnv::test_read_from_file[STRIP_WHITESPACE-\\n  value from file with leading and trailing whitespaces \\n-kwargs2-value from file with leading and trailing whitespaces]",
+]
+pass_to_pass = [
+    "tests/test_environs.py::TestCasting::test_basic",
+    "tests/test_environs.py::TestCasting::test_bool",
+    "tests/test_environs.py::TestCasting::test_call",
+    "tests/test_environs.py::TestCasting::test_call_with_default",
+    "tests/test_environs.py::TestCasting::test_custom_subcast_keys_values",
+    "tests/test_environs.py::TestCasting::test_custom_subcast_list",
+    "tests/test_environs.py::TestCasting::test_date_cast",
+    "tests/test_environs.py::TestCasting::test_datetime_cast",
+    "tests/test_environs.py::TestCasting::test_decimal_cast",
+    "tests/test_environs.py::TestCasting::test_default_set",
+    "tests/test_environs.py::TestCasting::test_default_set_to_internal_type[date]",
+    "tests/test_environs.py::TestCasting::test_default_set_to_internal_type[datetime]",
+    "tests/test_environs.py::TestCasting::test_default_set_to_internal_type[time]",
+    "tests/test_environs.py::TestCasting::test_dict",
+    "tests/test_environs.py::TestCasting::test_dict_with_colon_key_value_delimiter",
+    "tests/test_environs.py::TestCasting::test_dict_with_dict_default",
+    "tests/test_environs.py::TestCasting::test_dict_with_equal",
+    "tests/test_environs.py::TestCasting::test_dict_with_spaces_as_delimiter",
+    "tests/test_environs.py::TestCasting::test_dict_with_subcast_keys",
+    "tests/test_environs.py::TestCasting::test_dict_with_subcast_values",
+    "tests/test_environs.py::TestCasting::test_dict_without_subcast_keys",
+    "tests/test_environs.py::TestCasting::test_empty_str",
+    "tests/test_environs.py::TestCasting::test_enum_by_value_field",
+    "tests/test_environs.py::TestCasting::test_enum_by_value_true",
+    "tests/test_environs.py::TestCasting::test_enum_cast",
+    "tests/test_environs.py::TestCasting::test_enum_default",
+    "tests/test_environs.py::TestCasting::test_float_cast",
+    "tests/test_environs.py::TestCasting::test_int_cast",
+    "tests/test_environs.py::TestCasting::test_invalid_enum",
+    "tests/test_environs.py::TestCasting::test_invalid_int",
+    "tests/test_environs.py::TestCasting::test_invalid_json_raises_error",
+    "tests/test_environs.py::TestCasting::test_invalid_log_level",
+    "tests/test_environs.py::TestCasting::test_invalid_url[42]",
+    "tests/test_environs.py::TestCasting::test_invalid_url[foo@bar]",
+    "tests/test_environs.py::TestCasting::test_invalid_url[foo]",
+    "tests/test_environs.py::TestCasting::test_json_cast",
+    "tests/test_environs.py::TestCasting::test_json_default",
+    "tests/test_environs.py::TestCasting::test_list_cast",
+    "tests/test_environs.py::TestCasting::test_list_with_default_from_list",
+    "tests/test_environs.py::TestCasting::test_list_with_default_list_and_subcast",
+    "tests/test_environs.py::TestCasting::test_list_with_default_none",
+    "tests/test_environs.py::TestCasting::test_list_with_empty_env_and_subcast",
+    "tests/test_environs.py::TestCasting::test_list_with_spaces",
+    "tests/test_environs.py::TestCasting::test_list_with_spaces_as_delimiter",
+    "tests/test_environs.py::TestCasting::test_list_with_subcast",
+    "tests/test_environs.py::TestCasting::test_log_level_cast",
+    "tests/test_environs.py::TestCasting::test_missing_raises_error",
+    "tests/test_environs.py::TestCasting::test_path_cast",
+    "tests/test_environs.py::TestCasting::test_path_default_value",
+    "tests/test_environs.py::TestCasting::test_time_cast",
+]
+validation_status = "verified"
+bootstrap_image = "local-venv:sloria__environs"
+instruction_synthesized = true
+llm_cost_usd = 0.002652
+
+[metadata.repo2env.reward_calibration]
+f2p_count = 1
+p2p_count = 50
+source_files = 3
+loc_changed = 30
+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/sloria__environs"
+image_tag = "local/sloria__environs"
+image_visibility = "private"
+
+[agent]
+timeout_sec = 1800.0
+
+[verifier]
+timeout_sec = 300.0

heldout/sloria__environs-aa99f02fb39d/tests/f2p.json

@@ -0,0 +1,3 @@
+[
+  "tests/test_environs.py::TestFileAwareEnv::test_read_from_file[STRIP_WHITESPACE-\\n  value from file with leading and trailing whitespaces \\n-kwargs2-value from file with leading and trailing whitespaces]"
+]

heldout/sloria__environs-aa99f02fb39d/tests/p2p.json

@@ -0,0 +1,52 @@
+[
+  "tests/test_environs.py::TestCasting::test_basic",
+  "tests/test_environs.py::TestCasting::test_bool",
+  "tests/test_environs.py::TestCasting::test_call",
+  "tests/test_environs.py::TestCasting::test_call_with_default",
+  "tests/test_environs.py::TestCasting::test_custom_subcast_keys_values",
+  "tests/test_environs.py::TestCasting::test_custom_subcast_list",
+  "tests/test_environs.py::TestCasting::test_date_cast",
+  "tests/test_environs.py::TestCasting::test_datetime_cast",
+  "tests/test_environs.py::TestCasting::test_decimal_cast",
+  "tests/test_environs.py::TestCasting::test_default_set",
+  "tests/test_environs.py::TestCasting::test_default_set_to_internal_type[date]",
+  "tests/test_environs.py::TestCasting::test_default_set_to_internal_type[datetime]",
+  "tests/test_environs.py::TestCasting::test_default_set_to_internal_type[time]",
+  "tests/test_environs.py::TestCasting::test_dict",
+  "tests/test_environs.py::TestCasting::test_dict_with_colon_key_value_delimiter",
+  "tests/test_environs.py::TestCasting::test_dict_with_dict_default",
+  "tests/test_environs.py::TestCasting::test_dict_with_equal",
+  "tests/test_environs.py::TestCasting::test_dict_with_spaces_as_delimiter",
+  "tests/test_environs.py::TestCasting::test_dict_with_subcast_keys",
+  "tests/test_environs.py::TestCasting::test_dict_with_subcast_values",
+  "tests/test_environs.py::TestCasting::test_dict_without_subcast_keys",
+  "tests/test_environs.py::TestCasting::test_empty_str",
+  "tests/test_environs.py::TestCasting::test_enum_by_value_field",
+  "tests/test_environs.py::TestCasting::test_enum_by_value_true",
+  "tests/test_environs.py::TestCasting::test_enum_cast",
+  "tests/test_environs.py::TestCasting::test_enum_default",
+  "tests/test_environs.py::TestCasting::test_float_cast",
+  "tests/test_environs.py::TestCasting::test_int_cast",
+  "tests/test_environs.py::TestCasting::test_invalid_enum",
+  "tests/test_environs.py::TestCasting::test_invalid_int",
+  "tests/test_environs.py::TestCasting::test_invalid_json_raises_error",
+  "tests/test_environs.py::TestCasting::test_invalid_log_level",
+  "tests/test_environs.py::TestCasting::test_invalid_url[42]",
+  "tests/test_environs.py::TestCasting::test_invalid_url[foo@bar]",
+  "tests/test_environs.py::TestCasting::test_invalid_url[foo]",
+  "tests/test_environs.py::TestCasting::test_json_cast",
+  "tests/test_environs.py::TestCasting::test_json_default",
+  "tests/test_environs.py::TestCasting::test_list_cast",
+  "tests/test_environs.py::TestCasting::test_list_with_default_from_list",
+  "tests/test_environs.py::TestCasting::test_list_with_default_list_and_subcast",
+  "tests/test_environs.py::TestCasting::test_list_with_default_none",
+  "tests/test_environs.py::TestCasting::test_list_with_empty_env_and_subcast",
+  "tests/test_environs.py::TestCasting::test_list_with_spaces",
+  "tests/test_environs.py::TestCasting::test_list_with_spaces_as_delimiter",
+  "tests/test_environs.py::TestCasting::test_list_with_subcast",
+  "tests/test_environs.py::TestCasting::test_log_level_cast",
+  "tests/test_environs.py::TestCasting::test_missing_raises_error",
+  "tests/test_environs.py::TestCasting::test_path_cast",
+  "tests/test_environs.py::TestCasting::test_path_default_value",
+  "tests/test_environs.py::TestCasting::test_time_cast"
+]