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

heldout/RDFLib__rdflib-2be67dca9f5d/tests/test.sh

@@ -0,0 +1,294 @@
+#!/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 6539dfef42c5b853ccab41c046772a8e0c8e1658 -- test/test_sparql/test_expressions.py test/test_sparql/test_tsvresults.py || true
+git apply --verbose --reject - <<'EOF_R2E_TEST_PATCH'
+diff --git a/test/test_sparql/test_expressions.py b/test/test_sparql/test_expressions.py
+index 200c6854..cee2fb6e 100644
+--- a/test/test_sparql/test_expressions.py
++++ b/test/test_sparql/test_expressions.py
+@@ -26,119 +26,121 @@ def _translate(e):
+ 
+ 
+ def test_regex():
+-    assert _eval(_translate(p.Expression.parseString('REGEX("zxcabczxc","abc")')[0]))
++    assert _eval(_translate(p.Expression.parse_string('REGEX("zxcabczxc","abc")')[0]))
+ 
+     eq(
+-        bool(_eval(_translate(p.Expression.parseString('REGEX("zxczxc","abc")')[0]))),
++        bool(_eval(_translate(p.Expression.parse_string('REGEX("zxczxc","abc")')[0]))),
+         False,
+     )
+ 
+-    assert _eval(_translate(p.Expression.parseString('REGEX("bbbaaaaabbb","ba*b")')[0]))
++    assert _eval(
++        _translate(p.Expression.parse_string('REGEX("bbbaaaaabbb","ba*b")')[0])
++    )
+ 
+ 
+ def test_arithmetic():
+-    eq(_eval(_translate(p.Expression.parseString("2+3")[0])).value, 5)
+-    eq(_eval(_translate(p.Expression.parseString("3-2")[0])).value, 1)
++    eq(_eval(_translate(p.Expression.parse_string("2+3")[0])).value, 5)
++    eq(_eval(_translate(p.Expression.parse_string("3-2")[0])).value, 1)
+ 
+-    eq(_eval(_translate(p.Expression.parseString("2*3")[0])).value, 6)
+-    eq(_eval(_translate(p.Expression.parseString("4/2")[0])).value, 2)
++    eq(_eval(_translate(p.Expression.parse_string("2*3")[0])).value, 6)
++    eq(_eval(_translate(p.Expression.parse_string("4/2")[0])).value, 2)
+ 
+-    eq(_eval(_translate(p.Expression.parseString("2+2+2")[0])).value, 6)
+-    eq(_eval(_translate(p.Expression.parseString("2-2+2")[0])).value, 2)
+-    eq(_eval(_translate(p.Expression.parseString("(2-2)+2")[0])).value, 2)
+-    eq(_eval(_translate(p.Expression.parseString("2-(2+2)")[0])).value, -2)
++    eq(_eval(_translate(p.Expression.parse_string("2+2+2")[0])).value, 6)
++    eq(_eval(_translate(p.Expression.parse_string("2-2+2")[0])).value, 2)
++    eq(_eval(_translate(p.Expression.parse_string("(2-2)+2")[0])).value, 2)
++    eq(_eval(_translate(p.Expression.parse_string("2-(2+2)")[0])).value, -2)
+ 
+-    eq(_eval(_translate(p.Expression.parseString("2*2*2")[0])).value, 8)
+-    eq(_eval(_translate(p.Expression.parseString("4/2*2")[0])).value, 4)
+-    eq(_eval(_translate(p.Expression.parseString("8/4*2")[0])).value, 4)
+-    eq(_eval(_translate(p.Expression.parseString("8/(4*2)")[0])).value, 1)
+-    eq(_eval(_translate(p.Expression.parseString("(2/2)*2")[0])).value, 2)
+-    eq(_eval(_translate(p.Expression.parseString("4/(2*2)")[0])).value, 1)
++    eq(_eval(_translate(p.Expression.parse_string("2*2*2")[0])).value, 8)
++    eq(_eval(_translate(p.Expression.parse_string("4/2*2")[0])).value, 4)
++    eq(_eval(_translate(p.Expression.parse_string("8/4*2")[0])).value, 4)
++    eq(_eval(_translate(p.Expression.parse_string("8/(4*2)")[0])).value, 1)
++    eq(_eval(_translate(p.Expression.parse_string("(2/2)*2")[0])).value, 2)
++    eq(_eval(_translate(p.Expression.parse_string("4/(2*2)")[0])).value, 1)
+ 
+-    eq(_eval(_translate(p.Expression.parseString("2+3*2")[0])).value, 8)
+-    eq(_eval(_translate(p.Expression.parseString("(2+3)*2")[0])).value, 10)
+-    eq(_eval(_translate(p.Expression.parseString("2+4/2")[0])).value, 4)
+-    eq(_eval(_translate(p.Expression.parseString("(2+4)/2")[0])).value, 3)
++    eq(_eval(_translate(p.Expression.parse_string("2+3*2")[0])).value, 8)
++    eq(_eval(_translate(p.Expression.parse_string("(2+3)*2")[0])).value, 10)
++    eq(_eval(_translate(p.Expression.parse_string("2+4/2")[0])).value, 4)
++    eq(_eval(_translate(p.Expression.parse_string("(2+4)/2")[0])).value, 3)
+ 
+ 
+ def test_arithmetic_var():
+     ctx = QueryContext()
+     ctx[Variable("x")] = Literal(2)
+ 
+-    eq(_eval(_translate(p.Expression.parseString("2+?x")[0]), ctx).value, 4)
++    eq(_eval(_translate(p.Expression.parse_string("2+?x")[0]), ctx).value, 4)
+ 
+-    eq(_eval(_translate(p.Expression.parseString("?x+3")[0]), ctx).value, 5)
+-    eq(_eval(_translate(p.Expression.parseString("3-?x")[0]), ctx).value, 1)
++    eq(_eval(_translate(p.Expression.parse_string("?x+3")[0]), ctx).value, 5)
++    eq(_eval(_translate(p.Expression.parse_string("3-?x")[0]), ctx).value, 1)
+ 
+-    eq(_eval(_translate(p.Expression.parseString("?x*3")[0]), ctx).value, 6)
+-    eq(_eval(_translate(p.Expression.parseString("4/?x")[0]), ctx).value, 2)
++    eq(_eval(_translate(p.Expression.parse_string("?x*3")[0]), ctx).value, 6)
++    eq(_eval(_translate(p.Expression.parse_string("4/?x")[0]), ctx).value, 2)
+ 
+-    eq(_eval(_translate(p.Expression.parseString("?x+?x+?x")[0]), ctx).value, 6)
+-    eq(_eval(_translate(p.Expression.parseString("?x-?x+?x")[0]), ctx).value, 2)
+-    eq(_eval(_translate(p.Expression.parseString("(?x-?x)+?x")[0]), ctx).value, 2)
+-    eq(_eval(_translate(p.Expression.parseString("?x-(?x+?x)")[0]), ctx).value, -2)
++    eq(_eval(_translate(p.Expression.parse_string("?x+?x+?x")[0]), ctx).value, 6)
++    eq(_eval(_translate(p.Expression.parse_string("?x-?x+?x")[0]), ctx).value, 2)
++    eq(_eval(_translate(p.Expression.parse_string("(?x-?x)+?x")[0]), ctx).value, 2)
++    eq(_eval(_translate(p.Expression.parse_string("?x-(?x+?x)")[0]), ctx).value, -2)
+ 
+-    eq(_eval(_translate(p.Expression.parseString("?x*?x*?x")[0]), ctx).value, 8)
+-    eq(_eval(_translate(p.Expression.parseString("4/?x*?x")[0]), ctx).value, 4)
+-    eq(_eval(_translate(p.Expression.parseString("8/4*?x")[0]), ctx).value, 4)
+-    eq(_eval(_translate(p.Expression.parseString("8/(4*?x)")[0]), ctx).value, 1)
+-    eq(_eval(_translate(p.Expression.parseString("(?x/?x)*?x")[0]), ctx).value, 2)
+-    eq(_eval(_translate(p.Expression.parseString("4/(?x*?x)")[0]), ctx).value, 1)
++    eq(_eval(_translate(p.Expression.parse_string("?x*?x*?x")[0]), ctx).value, 8)
++    eq(_eval(_translate(p.Expression.parse_string("4/?x*?x")[0]), ctx).value, 4)
++    eq(_eval(_translate(p.Expression.parse_string("8/4*?x")[0]), ctx).value, 4)
++    eq(_eval(_translate(p.Expression.parse_string("8/(4*?x)")[0]), ctx).value, 1)
++    eq(_eval(_translate(p.Expression.parse_string("(?x/?x)*?x")[0]), ctx).value, 2)
++    eq(_eval(_translate(p.Expression.parse_string("4/(?x*?x)")[0]), ctx).value, 1)
+ 
+ 
+ def test_comparisons():
+-    eq(bool(_eval(_translate(p.Expression.parseString("2<3")[0]))), True)
+-    eq(bool(_eval(_translate(p.Expression.parseString("2<3.0")[0]))), True)
+-    eq(bool(_eval(_translate(p.Expression.parseString("2<3e0")[0]))), True)
++    eq(bool(_eval(_translate(p.Expression.parse_string("2<3")[0]))), True)
++    eq(bool(_eval(_translate(p.Expression.parse_string("2<3.0")[0]))), True)
++    eq(bool(_eval(_translate(p.Expression.parse_string("2<3e0")[0]))), True)
+ 
+-    eq(bool(_eval(_translate(p.Expression.parseString("4<3")[0]))), False)
+-    eq(bool(_eval(_translate(p.Expression.parseString("4<3.0")[0]))), False)
+-    eq(bool(_eval(_translate(p.Expression.parseString("4<3e0")[0]))), False)
++    eq(bool(_eval(_translate(p.Expression.parse_string("4<3")[0]))), False)
++    eq(bool(_eval(_translate(p.Expression.parse_string("4<3.0")[0]))), False)
++    eq(bool(_eval(_translate(p.Expression.parse_string("4<3e0")[0]))), False)
+ 
+-    eq(bool(_eval(_translate(p.Expression.parseString("2<2.1")[0]))), True)
+-    eq(bool(_eval(_translate(p.Expression.parseString("2<21e-1")[0]))), True)
++    eq(bool(_eval(_translate(p.Expression.parse_string("2<2.1")[0]))), True)
++    eq(bool(_eval(_translate(p.Expression.parse_string("2<21e-1")[0]))), True)
+ 
+-    eq(bool(_eval(_translate(p.Expression.parseString("2=2.0")[0]))), True)
+-    eq(bool(_eval(_translate(p.Expression.parseString("2=2e0")[0]))), True)
++    eq(bool(_eval(_translate(p.Expression.parse_string("2=2.0")[0]))), True)
++    eq(bool(_eval(_translate(p.Expression.parse_string("2=2e0")[0]))), True)
+ 
+-    eq(bool(_eval(_translate(p.Expression.parseString('2="cake"')[0]))), False)
++    eq(bool(_eval(_translate(p.Expression.parse_string('2="cake"')[0]))), False)
+ 
+ 
+ def test_comparisons_var():
+     ctx = QueryContext()
+     ctx[Variable("x")] = Literal(2)
+ 
+-    eq(bool(_eval(_translate(p.Expression.parseString("?x<3")[0]), ctx)), True)
+-    eq(bool(_eval(_translate(p.Expression.parseString("?x<3.0")[0]), ctx)), True)
+-    eq(bool(_eval(_translate(p.Expression.parseString("?x<3e0")[0]), ctx)), True)
++    eq(bool(_eval(_translate(p.Expression.parse_string("?x<3")[0]), ctx)), True)
++    eq(bool(_eval(_translate(p.Expression.parse_string("?x<3.0")[0]), ctx)), True)
++    eq(bool(_eval(_translate(p.Expression.parse_string("?x<3e0")[0]), ctx)), True)
+ 
+-    eq(bool(_eval(_translate(p.Expression.parseString("?x<2.1")[0]), ctx)), True)
+-    eq(bool(_eval(_translate(p.Expression.parseString("?x<21e-1")[0]), ctx)), True)
++    eq(bool(_eval(_translate(p.Expression.parse_string("?x<2.1")[0]), ctx)), True)
++    eq(bool(_eval(_translate(p.Expression.parse_string("?x<21e-1")[0]), ctx)), True)
+ 
+-    eq(bool(_eval(_translate(p.Expression.parseString("?x=2.0")[0]), ctx)), True)
+-    eq(bool(_eval(_translate(p.Expression.parseString("?x=2e0")[0]), ctx)), True)
++    eq(bool(_eval(_translate(p.Expression.parse_string("?x=2.0")[0]), ctx)), True)
++    eq(bool(_eval(_translate(p.Expression.parse_string("?x=2e0")[0]), ctx)), True)
+ 
+-    eq(bool(_eval(_translate(p.Expression.parseString('?x="cake"')[0]), ctx)), False)
++    eq(bool(_eval(_translate(p.Expression.parse_string('?x="cake"')[0]), ctx)), False)
+ 
+     ctx = QueryContext()
+     ctx[Variable("x")] = Literal(4)
+ 
+-    eq(bool(_eval(_translate(p.Expression.parseString("?x<3")[0]), ctx)), False)
+-    eq(bool(_eval(_translate(p.Expression.parseString("?x<3.0")[0]), ctx)), False)
+-    eq(bool(_eval(_translate(p.Expression.parseString("?x<3e0")[0]), ctx)), False)
++    eq(bool(_eval(_translate(p.Expression.parse_string("?x<3")[0]), ctx)), False)
++    eq(bool(_eval(_translate(p.Expression.parse_string("?x<3.0")[0]), ctx)), False)
++    eq(bool(_eval(_translate(p.Expression.parse_string("?x<3e0")[0]), ctx)), False)
+ 
+ 
+ def test_and_or():
+-    eq(bool(_eval(_translate(p.Expression.parseString("3>2 && 3>1")[0]))), True)
++    eq(bool(_eval(_translate(p.Expression.parse_string("3>2 && 3>1")[0]))), True)
+     eq(
+-        bool(_eval(_translate(p.Expression.parseString("3>2 && 3>4 || 2>1")[0]))),
++        bool(_eval(_translate(p.Expression.parse_string("3>2 && 3>4 || 2>1")[0]))),
+         True,
+     )
+     eq(
+-        bool(_eval(_translate(p.Expression.parseString("2>1 || 3>2 && 3>4")[0]))),
++        bool(_eval(_translate(p.Expression.parse_string("2>1 || 3>2 && 3>4")[0]))),
+         True,
+     )
+     eq(
+-        bool(_eval(_translate(p.Expression.parseString("(2>1 || 3>2) && 3>4")[0]))),
++        bool(_eval(_translate(p.Expression.parse_string("(2>1 || 3>2) && 3>4")[0]))),
+         False,
+     )
+diff --git a/test/test_sparql/test_tsvresults.py b/test/test_sparql/test_tsvresults.py
+index c5e72d19..e4ad55d4 100644
+--- a/test/test_sparql/test_tsvresults.py
++++ b/test/test_sparql/test_tsvresults.py
+@@ -1,7 +1,11 @@
+-from io import StringIO
++from io import BytesIO, StringIO
+ 
++import pytest
++
++from rdflib.plugins.sparql.parserutils import CompValue
+ from rdflib.plugins.sparql.results.tsvresults import TSVResultParser
+ from rdflib.query import ResultRow
++from rdflib.term import Literal, URIRef
+ 
+ 
+ def test_empty_tsvresults_bindings() -> None:
+@@ -18,3 +22,65 @@ def test_empty_tsvresults_bindings() -> None:
+     for idx, row in enumerate(result):
+         assert isinstance(row, ResultRow)
+         assert row[idx] is None
++
++
++def test_dbpedia_style_optional_unbound_var() -> None:
++    source = (
++        "?person\t?deathDate\n"
++        '<http://dbpedia.org/resource/Albert_Einstein>\t"1955-04-18"^^<http://www.w3.org/2001/XMLSchema#date>\n'
++        "<http://dbpedia.org/resource/Barack_Obama>\t\n"
++    )
++
++    parser = TSVResultParser()
++    result = parser.parse(StringIO(source))
++    assert result.vars is not None
++    person, death_date = result.vars
++
++    assert len(result.bindings) == 2
++    assert result.bindings[0][person] == URIRef(
++        "http://dbpedia.org/resource/Albert_Einstein"
++    )
++    assert result.bindings[0][death_date] == Literal(
++        "1955-04-18", datatype=URIRef("http://www.w3.org/2001/XMLSchema#date")
++    )
++    assert result.bindings[1][person] == URIRef(
++        "http://dbpedia.org/resource/Barack_Obama"
++    )
++    assert death_date not in result.bindings[1]
++
++
++def test_dbpedia_style_all_projected_vars_unbound_row_is_preserved() -> None:
++    source = "?x\t?y\n\t\n"
++
++    parser = TSVResultParser()
++    result = parser.parse(StringIO(source))
++
++    # Parser should preserve fully-unbound solution rows as empty mappings.
++    assert len(result.bindings) == 1
++    assert result.bindings[0] == {}
++
++
++def test_parse_tsv_from_bytes_skips_blank_lines() -> None:
++    source = BytesIO(b"?x\n\n<urn:x1>\n")
++
++    parser = TSVResultParser()
++    result = parser.parse(source)
++    assert result.vars is not None
++    var_x = result.vars[0]
++
++    assert len(result.bindings) == 1
++    assert result.bindings[0][var_x] == URIRef("urn:x1")
++
++
++def test_convert_term_rejects_unknown_compvalue_name() -> None:
++    parser = TSVResultParser()
++
++    with pytest.raises(Exception, match="I dont know how to handle this"):
++        parser.convertTerm(CompValue("unknown", value="x"))
++
++
++def test_convert_term_rejects_unexpected_type() -> None:
++    parser = TSVResultParser()
++
++    with pytest.raises(ValueError, match="Unexpected type"):
++        parser.convertTerm("not-a-term")
+
+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 test/test_sparql/test_expressions.py test/test_sparql/test_tsvresults.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 test/test_sparql/test_expressions.py test/test_sparql/test_tsvresults.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 6539dfef42c5b853ccab41c046772a8e0c8e1658 -- test/test_sparql/test_expressions.py test/test_sparql/test_tsvresults.py || true
+exit 0

heldout/RDFLib__rdflib-2be67dca9f5d/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/RDFLib__rdflib-49afac8c15ce/environment/Dockerfile

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

@@ -0,0 +1,12 @@
+# Issue
+
+**Title:** Base namespace predicates generate unnecessary prefixes in Turtle/LongTurtle output
+
+## Description
+When serializing data into Turtle or LongTurtle formats, predicates that belong to the base namespace are incorrectly rendered with an explicit prefix. For example, a predicate that should appear as `myPredicate` might instead be output as `base:myPredicate` or `_base:myPredicate`. This is unexpected, as predicates in the base namespace should not require an explicit prefix.
+
+Additionally, in LongTurtle format, pnames (prefixed names) containing bracket characters are not properly escaped, leading to malformed output.
+
+## 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 `1964642d472c` and running the modified tests.

heldout/RDFLib__rdflib-49afac8c15ce/solution/patch.diff

@@ -0,0 +1,71 @@
+diff --git a/rdflib/plugins/serializers/longturtle.py b/rdflib/plugins/serializers/longturtle.py
+index 2aaed36e..1e68e684 100644
+--- a/rdflib/plugins/serializers/longturtle.py
++++ b/rdflib/plugins/serializers/longturtle.py
+@@ -22,7 +22,7 @@ from typing import IO, Any, Optional
+ 
+ from rdflib.compare import to_canonical_graph
+ from rdflib.exceptions import Error
+-from rdflib.graph import Graph
++from rdflib.graph import Graph, _TripleType
+ from rdflib.namespace import RDF
+ from rdflib.term import BNode, Literal, URIRef
+ 
+@@ -149,11 +149,20 @@ class LongTurtleSerializer(RecursiveSerializer):
+ 
+         self.base = None
+ 
+-    def preprocessTriple(self, triple):
++    def preprocessTriple(self, triple: _TripleType) -> None:
+         super(LongTurtleSerializer, self).preprocessTriple(triple)
+         for i, node in enumerate(triple):
+-            if node in self.keywords:
+-                continue
++            if i == VERB:
++                if node in self.keywords:
++                    # predicate is a keyword
++                    continue
++                if (
++                    self.base is not None
++                    and isinstance(node, URIRef)
++                    and node.startswith(self.base)
++                ):
++                    # predicate corresponds to base namespace
++                    continue
+             # Don't use generated prefixes for subjects and objects
+             self.getQName(node, gen_prefix=(i == VERB))
+             if isinstance(node, Literal) and node.datatype:
+@@ -180,6 +189,8 @@ class LongTurtleSerializer(RecursiveSerializer):
+ 
+         prefix, namespace, local = parts
+ 
++        local = local.replace(r"(", r"\(").replace(r")", r"\)")
++
+         # QName cannot end with .
+         if local.endswith("."):
+             return None
+diff --git a/rdflib/plugins/serializers/turtle.py b/rdflib/plugins/serializers/turtle.py
+index d1dfcf4a..abee2e43 100644
+--- a/rdflib/plugins/serializers/turtle.py
++++ b/rdflib/plugins/serializers/turtle.py
+@@ -263,9 +263,17 @@ class TurtleSerializer(RecursiveSerializer):
+     def preprocessTriple(self, triple: _TripleType) -> None:
+         super(TurtleSerializer, self).preprocessTriple(triple)
+         for i, node in enumerate(triple):
+-            if i == VERB and node in self.keywords:
+-                # predicate is a keyword
+-                continue
++            if i == VERB:
++                if node in self.keywords:
++                    # predicate is a keyword
++                    continue
++                if (
++                    self.base is not None
++                    and isinstance(node, URIRef)
++                    and node.startswith(self.base)
++                ):
++                    # predicate corresponds to base namespace
++                    continue
+             # Don't use generated prefixes for subjects and objects
+             self.getQName(node, gen_prefix=(i == VERB))
+             if isinstance(node, Literal) and node.datatype:

heldout/RDFLib__rdflib-49afac8c15ce/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/RDFLib__rdflib-49afac8c15ce/task.toml

@@ -0,0 +1,75 @@
+version = "1.0"
+
+[task]
+name = "commit-runtime/RDFLib__rdflib-49afac8c15ce"
+description = "skip prefix generation for predicates corresponding to base namespace (#3244)"
+
+[metadata]
+difficulty = "medium"
+category = "bugfix"
+keywords = [
+    "rdflib",
+    "commit_runtime",
+]
+
+[metadata.repo2env]
+pipeline = "commit_runtime"
+pipeline_version = "0.8.3"
+repo = "RDFLib/rdflib"
+ref = "1964642d472c4b44de6aba1a6fe3be6b9d7a8153"
+reference = "https://github.com/RDFLib/rdflib/commit/49afac8c15ce345ca797bffa5d6fdc6f738c42a5"
+source_access = "public"
+built_at = "2026-09-24T13:24:14.483462+00:00"
+synthesis_llm = "gemini/gemini-2.5-flash"
+reward_kinds = [
+    "test_execution",
+    "diff_similarity",
+]
+spec_version = "0.2.0"
+content_hash = "sha256:68f625717127fc833b3af3deb0bef9e2ab53810c8b6322a7bb22c1531effcc0f"
+
+[metadata.repo2env.commit_runtime]
+commit_sha = "49afac8c15ce345ca797bffa5d6fdc6f738c42a5"
+parent_sha = "1964642d472c4b44de6aba1a6fe3be6b9d7a8153"
+authored_at = "2025-09-30T15:42:28+10:00"
+author_email = "37032744+edmondchuc@users.noreply.github.com"
+subject = "fix: skip prefix generation for predicates corresponding to base namespace (#3244)"
+fail_to_pass = [
+    "test/test_serializers/test_serializer_turtle_base_namespace.py::test_longturtle",
+    "test/test_serializers/test_serializer_turtle_base_namespace.py::test_turtle",
+]
+pass_to_pass = []
+validation_status = "verified"
+bootstrap_image = "local-venv:RDFLib__rdflib"
+instruction_synthesized = true
+llm_cost_usd = 0.024096
+
+[metadata.repo2env.reward_calibration]
+f2p_count = 2
+p2p_count = 0
+source_files = 2
+loc_changed = 33
+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/RDFLib__rdflib"
+image_tag = "local/RDFLib__rdflib"
+image_visibility = "private"
+
+[agent]
+timeout_sec = 1800.0
+
+[verifier]
+timeout_sec = 300.0

heldout/RDFLib__rdflib-49afac8c15ce/tests/f2p.json

@@ -0,0 +1,4 @@
+[
+  "test/test_serializers/test_serializer_turtle_base_namespace.py::test_longturtle",
+  "test/test_serializers/test_serializer_turtle_base_namespace.py::test_turtle"
+]

heldout/RDFLib__rdflib-49afac8c15ce/tests/p2p.json

@@ -0,0 +1 @@
+[]

heldout/RDFLib__rdflib-49afac8c15ce/tests/test.sh

@@ -0,0 +1,63 @@
+#!/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 1964642d472c4b44de6aba1a6fe3be6b9d7a8153 -- test/test_serializers/test_serializer_turtle_base_namespace.py || true
+git apply --verbose --reject - <<'EOF_R2E_TEST_PATCH'
+diff --git a/test/test_serializers/test_serializer_turtle_base_namespace.py b/test/test_serializers/test_serializer_turtle_base_namespace.py
+new file mode 100644
+index 00000000..f0971611
+--- /dev/null
++++ b/test/test_serializers/test_serializer_turtle_base_namespace.py
+@@ -0,0 +1,34 @@
++from rdflib import Graph, Namespace, URIRef
++
++# https://github.com/RDFLib/rdflib/issues/3237
++# Test that the ns1 prefix is not generated when the base is set.
++mns = Namespace("http://my-namespace.net/")
++
++
++def test_turtle():
++    g = Graph(base="http://my-base.net/")
++    g.add((mns.foo, URIRef("http://my-base.net/my-predicate"), mns.bar))
++    result = g.serialize(format="text/turtle")
++    assert (
++        result
++        == """@base <http://my-base.net/> .
++
++<http://my-namespace.net/foo> <my-predicate> <http://my-namespace.net/bar> .
++
++"""
++    )
++
++
++def test_longturtle():
++    g = Graph(base="http://my-base.net/")
++    g.add((mns.foo, URIRef("http://my-base.net/my-predicate"), mns.bar))
++    result = g.serialize(format="longturtle", canon=True)
++    assert (
++        result
++        == """BASE <http://my-base.net/>
++
++<http://my-namespace.net/foo>
++    <my-predicate> <http://my-namespace.net/bar> ;
++.
++"""
++    ), print(result)
+
+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 test/test_serializers/test_serializer_turtle_base_namespace.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 test/test_serializers/test_serializer_turtle_base_namespace.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 1964642d472c4b44de6aba1a6fe3be6b9d7a8153 -- test/test_serializers/test_serializer_turtle_base_namespace.py || true
+exit 0

heldout/RDFLib__rdflib-49afac8c15ce/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/RDFLib__rdflib-607e086b11a9/environment/Dockerfile

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

@@ -0,0 +1,10 @@
+# Issue
+
+**Title:** Internal ConjunctiveGraph warning displayed when processing JSON-LD
+
+## Description
+When processing JSON-LD data, an internal `ConjunctiveGraph` warning is unexpectedly displayed in the console or logs. This warning indicates the use of a deprecated component within the library. The expected behavior is that no such warning should appear, ensuring clean output and indicating up-to-date internal component usage.
+
+## 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 `b459049af00b` and running the modified tests.

heldout/RDFLib__rdflib-607e086b11a9/solution/patch.diff

@@ -0,0 +1,109 @@
+diff --git a/rdflib/plugins/parsers/jsonld.py b/rdflib/plugins/parsers/jsonld.py
+index fe9503b5..30339be6 100644
+--- a/rdflib/plugins/parsers/jsonld.py
++++ b/rdflib/plugins/parsers/jsonld.py
+@@ -38,7 +38,7 @@ import warnings
+ from typing import TYPE_CHECKING, Any, Dict, Iterable, List, Optional, Union
+ 
+ import rdflib.parser
+-from rdflib.graph import ConjunctiveGraph, Graph
++from rdflib.graph import Dataset, Graph
+ from rdflib.namespace import RDF, XSD
+ from rdflib.parser import InputSource, URLInputSource
+ from rdflib.term import BNode, IdentifiedNode, Literal, Node, URIRef
+@@ -77,6 +77,39 @@ TYPE_TERM = Term(str(RDF.type), TYPE, VOCAB)  # type: ignore[call-arg]
+ ALLOW_LISTS_OF_LISTS = True  # NOTE: Not allowed in JSON-LD 1.0
+ 
+ 
++class _ContextAwareGraph(Graph):
++    """Context-aware graph view used while parsing JSON-LD into a Graph sink."""
++
++    def __init__(self, sink: Graph):
++        super().__init__(store=sink.store, identifier=sink.identifier)
++        assert (
++            self.store.context_aware
++        ), "JSON-LD named graphs require a context-aware store."
++        self.context_aware = True
++        self.default_union = True
++        self._default_context = Graph(
++            store=self.store,
++            identifier=sink.identifier,
++        )
++
++    @property
++    def default_context(self) -> Graph:
++        return self._default_context
++
++    def get_context(
++        self,
++        identifier: Optional[Union[IdentifiedNode, str]],
++        quoted: bool = False,
++        base: Optional[str] = None,
++    ) -> Graph:
++        return Graph(
++            store=self.store,
++            identifier=identifier,
++            namespace_manager=self.namespace_manager,
++            base=base,
++        )
++
++
+ class JsonLDParser(rdflib.parser.Parser):
+     def __init__(self):
+         super(JsonLDParser, self).__init__()
+@@ -151,18 +184,19 @@ class JsonLDParser(rdflib.parser.Parser):
+         if html_base is not None:
+             base = URIRef(html_base, base=base)
+ 
+-        # NOTE: A ConjunctiveGraph parses into a Graph sink, so no sink will be
+-        # context_aware. Keeping this check in case RDFLib is changed, or
+-        # someone passes something context_aware to this parser directly.
+-        conj_sink: Graph
++        # Graph.parse passes a non-context-aware Graph sink to parsers. JSON-LD
++        # needs a context-aware view to preserve named graphs, but Dataset would
++        # additionally require a graph-aware store. Use a minimal internal view
++        # that preserves the existing context-aware store contract.
++        context_sink: Graph
+         if not sink.context_aware:
+-            conj_sink = ConjunctiveGraph(store=sink.store, identifier=sink.identifier)
++            context_sink = _ContextAwareGraph(sink)
+         else:
+-            conj_sink = sink
++            context_sink = sink
+ 
+         to_rdf(
+             data,
+-            conj_sink,
++            context_sink,
+             base,
+             context_data,
+             version,
+@@ -236,8 +270,13 @@ class Parser:
+             if term.id and term.id.endswith(VOCAB_DELIMS):
+                 dataset.bind(name, term.id)
+ 
+-        # type error: "Graph" has no attribute "default_context"
+-        graph = dataset.default_context if dataset.context_aware else dataset  # type: ignore[attr-defined]
++        if isinstance(dataset, Dataset):
++            graph = dataset.default_graph
++        elif dataset.context_aware:
++            # type error: "Graph" has no attribute "default_context"
++            graph = dataset.default_context  # type: ignore[attr-defined]
++        else:
++            graph = dataset
+ 
+         for node in resources:
+             self._add_to_graph(dataset, graph, context, node, topcontext)
+@@ -360,10 +399,8 @@ class Parser:
+ 
+         if GRAPH in (key, term_id):
+             if dataset.context_aware and not no_id:
+-                if TYPE_CHECKING:
+-                    assert isinstance(dataset, ConjunctiveGraph)
+-                # type error: Argument 1 to "get_context" of "ConjunctiveGraph" has incompatible type "Node"; expected "Union[IdentifiedNode, str, None]"
+-                subgraph = dataset.get_context(subj)  # type: ignore[arg-type]
++                # type error: "Graph" has no attribute "get_context"
++                subgraph = dataset.get_context(subj)  # type: ignore[attr-defined]
+             else:
+                 subgraph = graph
+             for onode in obj_nodes:

heldout/RDFLib__rdflib-607e086b11a9/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/RDFLib__rdflib-607e086b11a9/task.toml

@@ -0,0 +1,78 @@
+version = "1.0"
+
+[task]
+name = "commit-runtime/RDFLib__rdflib-607e086b11a9"
+description = "Fix/jsonld internal conjunctivegraph warning (#3495)"
+
+[metadata]
+difficulty = "medium"
+category = "bugfix"
+keywords = [
+    "rdflib",
+    "commit_runtime",
+]
+
+[metadata.repo2env]
+pipeline = "commit_runtime"
+pipeline_version = "0.8.3"
+repo = "RDFLib/rdflib"
+ref = "b459049af00b1cdd1453bf99344636b0cbc910df"
+reference = "https://github.com/RDFLib/rdflib/commit/607e086b11a9d0b465fd034351445200c694f90d"
+source_access = "public"
+built_at = "2026-09-24T13:23:02.648537+00:00"
+synthesis_llm = "gemini/gemini-2.5-flash"
+reward_kinds = [
+    "test_execution",
+    "diff_similarity",
+]
+spec_version = "0.2.0"
+content_hash = "sha256:10b97f0be0a8896202383cb8d3999e09f2b9b7331bb3b6589b00b954b337d95f"
+
+[metadata.repo2env.commit_runtime]
+commit_sha = "607e086b11a9d0b465fd034351445200c694f90d"
+parent_sha = "b459049af00b1cdd1453bf99344636b0cbc910df"
+authored_at = "2026-08-11T08:00:29+02:00"
+author_email = "danielmolinero111@gmail.com"
+subject = "Fix/jsonld internal conjunctivegraph warning (#3495)"
+fail_to_pass = [
+    "test/jsonld/test_parser_deprecation_warnings.py::test_dataset_jsonld_parse_does_not_warn_about_conjunctive_graph",
+    "test/jsonld/test_parser_deprecation_warnings.py::test_graph_jsonld_parse_does_not_warn_about_conjunctive_graph",
+    "test/jsonld/test_parser_deprecation_warnings.py::test_graph_jsonld_parse_preserves_named_graphs",
+    "test/jsonld/test_parser_deprecation_warnings.py::test_graph_jsonld_parse_preserves_target_context",
+    "test/jsonld/test_parser_deprecation_warnings.py::test_graph_jsonld_parse_supports_context_aware_non_graph_aware_store",
+]
+pass_to_pass = []
+validation_status = "verified"
+bootstrap_image = "local-venv:RDFLib__rdflib"
+instruction_synthesized = true
+llm_cost_usd = 0.004753
+
+[metadata.repo2env.reward_calibration]
+f2p_count = 5
+p2p_count = 0
+source_files = 1
+loc_changed = 65
+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/RDFLib__rdflib"
+image_tag = "local/RDFLib__rdflib"
+image_visibility = "private"
+
+[agent]
+timeout_sec = 1800.0
+
+[verifier]
+timeout_sec = 300.0

heldout/RDFLib__rdflib-607e086b11a9/tests/f2p.json

@@ -0,0 +1,7 @@
+[
+  "test/jsonld/test_parser_deprecation_warnings.py::test_dataset_jsonld_parse_does_not_warn_about_conjunctive_graph",
+  "test/jsonld/test_parser_deprecation_warnings.py::test_graph_jsonld_parse_does_not_warn_about_conjunctive_graph",
+  "test/jsonld/test_parser_deprecation_warnings.py::test_graph_jsonld_parse_preserves_named_graphs",
+  "test/jsonld/test_parser_deprecation_warnings.py::test_graph_jsonld_parse_preserves_target_context",
+  "test/jsonld/test_parser_deprecation_warnings.py::test_graph_jsonld_parse_supports_context_aware_non_graph_aware_store"
+]

heldout/RDFLib__rdflib-607e086b11a9/tests/p2p.json

@@ -0,0 +1 @@
+[]

heldout/RDFLib__rdflib-607e086b11a9/tests/test.sh

@@ -0,0 +1,129 @@
+#!/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 b459049af00b1cdd1453bf99344636b0cbc910df -- test/jsonld/test_parser_deprecation_warnings.py || true
+git apply --verbose --reject - <<'EOF_R2E_TEST_PATCH'
+diff --git a/test/jsonld/test_parser_deprecation_warnings.py b/test/jsonld/test_parser_deprecation_warnings.py
+new file mode 100644
+index 00000000..cf519fd6
+--- /dev/null
++++ b/test/jsonld/test_parser_deprecation_warnings.py
+@@ -0,0 +1,100 @@
++from __future__ import annotations
++
++import warnings
++
++from rdflib import Dataset, Graph, URIRef
++from rdflib.plugins.stores.auditable import AuditableStore
++from rdflib.plugins.stores.memory import Memory
++
++CONJUNCTIVE_GRAPH_WARNING = r"ConjunctiveGraph is deprecated, use Dataset instead\."
++
++SUBJECT = URIRef("http://example.org/subject")
++PREDICATE = URIRef("http://example.org/predicate")
++OBJECT = URIRef("http://example.org/object")
++TRIPLE = (SUBJECT, PREDICATE, OBJECT)
++
++SIMPLE_JSONLD = """
++{
++  "@context": {"ex": "http://example.org/"},
++  "@id": "http://example.org/subject",
++  "ex:predicate": {"@id": "http://example.org/object"}
++}
++"""
++
++NAMED_GRAPH_ID = URIRef("http://example.org/named-graph")
++NAMED_GRAPH_JSONLD = """
++{
++  "@context": {"ex": "http://example.org/"},
++  "@id": "http://example.org/named-graph",
++  "@graph": {
++    "@id": "http://example.org/subject",
++    "ex:predicate": {"@id": "http://example.org/object"}
++  }
++}
++"""
++
++
++def parse_without_internal_conjunctive_graph_warning(graph: Graph, data: str) -> None:
++    """Fail if JSON-LD parsing constructs the deprecated internal adapter."""
++    with warnings.catch_warnings():
++        warnings.filterwarnings(
++            "error",
++            message=CONJUNCTIVE_GRAPH_WARNING,
++            category=DeprecationWarning,
++        )
++        graph.parse(data=data, format="json-ld")
++
++
++def test_graph_jsonld_parse_does_not_warn_about_conjunctive_graph() -> None:
++    """Graph.parse must not construct the deprecated ConjunctiveGraph adapter."""
++    graph = Graph()
++
++    parse_without_internal_conjunctive_graph_warning(graph, SIMPLE_JSONLD)
++
++    assert TRIPLE in graph
++
++
++def test_dataset_jsonld_parse_does_not_warn_about_conjunctive_graph() -> None:
++    """Direct Dataset parsing must use its default graph without the legacy warning."""
++    dataset = Dataset()
++
++    parse_without_internal_conjunctive_graph_warning(dataset, SIMPLE_JSONLD)
++
++    assert TRIPLE in dataset.default_graph
++
++
++def test_graph_jsonld_parse_preserves_target_context() -> None:
++    """The context adapter must keep the original Graph identifier as its target."""
++    identifier = URIRef("urn:test:target")
++    graph = Graph(identifier=identifier)
++
++    parse_without_internal_conjunctive_graph_warning(graph, SIMPLE_JSONLD)
++
++    assert TRIPLE in graph
++    assert TRIPLE not in Graph(
++        store=graph.store,
++        identifier=URIRef("urn:test:other"),
++    )
++
++
++def test_graph_jsonld_parse_preserves_named_graphs() -> None:
++    """JSON-LD @graph data must still be routed to its declared named graph."""
++    sink = Graph(identifier=URIRef("urn:test:target"))
++
++    parse_without_internal_conjunctive_graph_warning(sink, NAMED_GRAPH_JSONLD)
++
++    named_graph = Graph(store=sink.store, identifier=NAMED_GRAPH_ID)
++    assert TRIPLE in named_graph
++    assert TRIPLE not in sink
++
++
++def test_graph_jsonld_parse_supports_context_aware_non_graph_aware_store() -> None:
++    """Preserve stores supported by ConjunctiveGraph but rejected by Dataset."""
++    store = AuditableStore(Memory())
++    assert store.context_aware
++    assert not store.graph_aware
++    graph = Graph(store=store, identifier=URIRef("urn:test:auditable"))
++
++    parse_without_internal_conjunctive_graph_warning(graph, SIMPLE_JSONLD)
++
++    assert TRIPLE in graph
+
+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 test/jsonld/test_parser_deprecation_warnings.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 test/jsonld/test_parser_deprecation_warnings.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 b459049af00b1cdd1453bf99344636b0cbc910df -- test/jsonld/test_parser_deprecation_warnings.py || true
+exit 0

heldout/RDFLib__rdflib-607e086b11a9/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/RDFLib__rdflib-72287e45ad1a/environment/Dockerfile

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

@@ -0,0 +1,14 @@
+# Issue
+
+**Title:** Turtle/N3 serializers output undeclared prefixes for predicates matching the base URI
+
+## Description
+When serializing an RDF graph to Turtle, Long Turtle, or N3 format, if a base URI is set and a predicate URI contains that base URI as a substring (e.g., the predicate starts with the base URI), the serializer incorrectly outputs an undeclared prefix for that predicate.
+
+For example, if the base URI is `http://example.org/base/` and a predicate is `http://example.org/base/something`, the output might contain `base:something` without `base` being declared as a prefix. This results in invalid Turtle/N3 output.
+
+The expected behavior
+
+## 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 `2a902e512123` and running the modified tests.

heldout/RDFLib__rdflib-72287e45ad1a/solution/patch.diff

@@ -0,0 +1,63 @@
+diff --git a/rdflib/plugins/serializers/longturtle.py b/rdflib/plugins/serializers/longturtle.py
+index 1e68e684..1cb2fa73 100644
+--- a/rdflib/plugins/serializers/longturtle.py
++++ b/rdflib/plugins/serializers/longturtle.py
+@@ -160,6 +160,8 @@ class LongTurtleSerializer(RecursiveSerializer):
+                     self.base is not None
+                     and isinstance(node, URIRef)
+                     and node.startswith(self.base)
++                    and "#" not in node.replace(self.base, "")
++                    and "/" not in node.replace(self.base, "")
+                 ):
+                     # predicate corresponds to base namespace
+                     continue
+diff --git a/rdflib/plugins/serializers/turtle.py b/rdflib/plugins/serializers/turtle.py
+index abee2e43..a6d2b631 100644
+--- a/rdflib/plugins/serializers/turtle.py
++++ b/rdflib/plugins/serializers/turtle.py
+@@ -17,6 +17,8 @@ from typing import (
+     Optional,
+     Sequence,
+     Tuple,
++    TypeVar,
++    Union,
+ )
+ 
+ from rdflib.exceptions import Error
+@@ -25,6 +27,8 @@ from rdflib.namespace import RDF, RDFS
+ from rdflib.serializer import Serializer
+ from rdflib.term import BNode, Literal, Node, URIRef
+ 
++_StrT = TypeVar("_StrT", bound=str)
++
+ if TYPE_CHECKING:
+     from rdflib.graph import _PredicateType, _SubjectType, _TripleType
+ 
+@@ -169,6 +173,18 @@ class RecursiveSerializer(Serializer):
+         # type error: Item "None" of "Optional[IO[bytes]]" has no attribute "write"
+         self.stream.write(text.encode(self.encoding, "replace"))  # type: ignore[union-attr]
+ 
++    def relativize(self, uri: _StrT) -> Union[_StrT, URIRef]:
++        base = self.base
++        if (
++            base is not None
++            and uri.startswith(base)
++            and "#" not in uri.replace(base, "")
++            and "/" not in uri.replace(base, "")
++        ):
++            # type error: Incompatible types in assignment (expression has type "str", variable has type "Node")
++            uri = URIRef(uri.replace(base, "", 1))  # type: ignore[assignment]
++        return uri
++
+ 
+ SUBJECT = 0
+ VERB = 1
+@@ -271,6 +287,8 @@ class TurtleSerializer(RecursiveSerializer):
+                     self.base is not None
+                     and isinstance(node, URIRef)
+                     and node.startswith(self.base)
++                    and "#" not in node.replace(self.base, "")
++                    and "/" not in node.replace(self.base, "")
+                 ):
+                     # predicate corresponds to base namespace
+                     continue

heldout/RDFLib__rdflib-72287e45ad1a/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/RDFLib__rdflib-72287e45ad1a/task.toml

@@ -0,0 +1,100 @@
+version = "1.0"
+
+[task]
+name = "commit-runtime/RDFLib__rdflib-72287e45ad1a"
+description = "RecursiveSerializer- outputs undeclared prefix for predicates that contains the base as a substring (#3267)"
+
+[metadata]
+difficulty = "small"
+category = "bugfix"
+keywords = [
+    "rdflib",
+    "commit_runtime",
+]
+
+[metadata.repo2env]
+pipeline = "commit_runtime"
+pipeline_version = "0.8.3"
+repo = "RDFLib/rdflib"
+ref = "2a902e512123d1b9a8035fa1652aa3d0a0a918a4"
+reference = "https://github.com/RDFLib/rdflib/commit/72287e45ad1a9801a85d262f20657c23e8831209"
+source_access = "public"
+built_at = "2026-09-24T13:23:39.021912+00:00"
+synthesis_llm = "gemini/gemini-2.5-flash"
+reward_kinds = [
+    "test_execution",
+    "diff_similarity",
+]
+spec_version = "0.2.0"
+content_hash = "sha256:903413a22393fee519c76fd4d35848688c41663dc64ce31fef6cd34cbb82432d"
+
+[metadata.repo2env.commit_runtime]
+commit_sha = "72287e45ad1a9801a85d262f20657c23e8831209"
+parent_sha = "2a902e512123d1b9a8035fa1652aa3d0a0a918a4"
+authored_at = "2025-10-24T14:10:32+10:00"
+author_email = "37032744+edmondchuc@users.noreply.github.com"
+subject = "fix: RecursiveSerializer- outputs undeclared prefix for predicates that contains the base as a substring (#3267)"
+fail_to_pass = [
+    "test/test_serializers/test_serializer_longturtle.py::test_longturtle_undeclared_prefix_when_using_base",
+    "test/test_serializers/test_serializer_turtle.py::test_turtle_undeclared_prefix_when_using_base",
+]
+pass_to_pass = [
+    "test/test_n3.py::TestN3Case::test_base_cumulative",
+    "test/test_n3.py::TestN3Case::test_base_explicit",
+    "test/test_n3.py::TestN3Case::test_base_serialize",
+    "test/test_n3.py::TestN3Case::test_dot_in_prefix",
+    "test/test_n3.py::TestN3Case::test_empty_prefix",
+    "test/test_n3.py::TestN3Case::test_float_no_norm[False-expected_result1]",
+    "test/test_n3.py::TestN3Case::test_float_no_norm[True-expected_result0]",
+    "test/test_n3.py::TestN3Case::test_issue156",
+    "test/test_n3.py::TestN3Case::test_issue23",
+    "test/test_n3.py::TestN3Case::test_issue29",
+    "test/test_n3.py::TestN3Case::test_issue68",
+    "test/test_n3.py::TestN3Case::test_issue999",
+    "test/test_n3.py::TestN3Case::test_model",
+    "test/test_n3.py::TestN3Case::test_parse",
+    "test/test_n3.py::TestN3Case::test_quoted_serialization",
+    "test/test_n3.py::TestN3Case::test_single_quoted_literals",
+    "test/test_n3.py::TestRegularExpressions::test_exponents",
+    "test/test_n3.py::TestRegularExpressions::test_invalid_exponents",
+    "test/test_serializers/test_serializer_longturtle.py::test_longturtle",
+    "test/test_serializers/test_serializer_turtle.py::test_turtle_bool_list",
+    "test/test_serializers/test_serializer_turtle.py::test_turtle_final_dot",
+    "test/test_serializers/test_serializer_turtle.py::test_turtle_namespace",
+    "test/test_serializers/test_serializer_turtle.py::test_turtle_valid_list",
+    "test/test_serializers/test_serializer_turtle.py::test_unicode_escaping",
+]
+validation_status = "verified"
+bootstrap_image = "local-venv:RDFLib__rdflib"
+instruction_synthesized = true
+llm_cost_usd = 0.013674
+
+[metadata.repo2env.reward_calibration]
+f2p_count = 2
+p2p_count = 24
+source_files = 2
+loc_changed = 20
+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/RDFLib__rdflib"
+image_tag = "local/RDFLib__rdflib"
+image_visibility = "private"
+
+[agent]
+timeout_sec = 1800.0
+
+[verifier]
+timeout_sec = 300.0

heldout/RDFLib__rdflib-72287e45ad1a/tests/f2p.json

@@ -0,0 +1,4 @@
+[
+  "test/test_serializers/test_serializer_longturtle.py::test_longturtle_undeclared_prefix_when_using_base",
+  "test/test_serializers/test_serializer_turtle.py::test_turtle_undeclared_prefix_when_using_base"
+]

heldout/RDFLib__rdflib-72287e45ad1a/tests/p2p.json

@@ -0,0 +1,26 @@
+[
+  "test/test_n3.py::TestN3Case::test_base_cumulative",
+  "test/test_n3.py::TestN3Case::test_base_explicit",
+  "test/test_n3.py::TestN3Case::test_base_serialize",
+  "test/test_n3.py::TestN3Case::test_dot_in_prefix",
+  "test/test_n3.py::TestN3Case::test_empty_prefix",
+  "test/test_n3.py::TestN3Case::test_float_no_norm[False-expected_result1]",
+  "test/test_n3.py::TestN3Case::test_float_no_norm[True-expected_result0]",
+  "test/test_n3.py::TestN3Case::test_issue156",
+  "test/test_n3.py::TestN3Case::test_issue23",
+  "test/test_n3.py::TestN3Case::test_issue29",
+  "test/test_n3.py::TestN3Case::test_issue68",
+  "test/test_n3.py::TestN3Case::test_issue999",
+  "test/test_n3.py::TestN3Case::test_model",
+  "test/test_n3.py::TestN3Case::test_parse",
+  "test/test_n3.py::TestN3Case::test_quoted_serialization",
+  "test/test_n3.py::TestN3Case::test_single_quoted_literals",
+  "test/test_n3.py::TestRegularExpressions::test_exponents",
+  "test/test_n3.py::TestRegularExpressions::test_invalid_exponents",
+  "test/test_serializers/test_serializer_longturtle.py::test_longturtle",
+  "test/test_serializers/test_serializer_turtle.py::test_turtle_bool_list",
+  "test/test_serializers/test_serializer_turtle.py::test_turtle_final_dot",
+  "test/test_serializers/test_serializer_turtle.py::test_turtle_namespace",
+  "test/test_serializers/test_serializer_turtle.py::test_turtle_valid_list",
+  "test/test_serializers/test_serializer_turtle.py::test_unicode_escaping"
+]

heldout/RDFLib__rdflib-72287e45ad1a/tests/test.sh

@@ -0,0 +1,123 @@
+#!/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 2a902e512123d1b9a8035fa1652aa3d0a0a918a4 -- test/test_n3.py test/test_serializers/test_serializer_longturtle.py test/test_serializers/test_serializer_turtle.py || true
+git apply --verbose --reject - <<'EOF_R2E_TEST_PATCH'
+diff --git a/test/test_n3.py b/test/test_n3.py
+index 40f87186..c713f357 100644
+--- a/test/test_n3.py
++++ b/test/test_n3.py
+@@ -123,8 +123,10 @@ class TestN3Case:
+                 URIRef("http://example.com/people/Linda"),
+             )
+         )
+-        s = g.serialize(base="http://example.com/", format="n3", encoding="latin-1")
+-        assert b"<people/Bob>" in s
++        s = g.serialize(
++            base="http://example.com/people/", format="n3", encoding="latin-1"
++        )
++        assert b"<Bob>" in s
+         g2 = Dataset()
+         g2.parse(data=s, format="n3")
+         assert list(g) == list(g2.triples((None, None, None)))
+diff --git a/test/test_serializers/test_serializer_longturtle.py b/test/test_serializers/test_serializer_longturtle.py
+index 65821784..b1540097 100644
+--- a/test/test_serializers/test_serializer_longturtle.py
++++ b/test/test_serializers/test_serializer_longturtle.py
+@@ -1,5 +1,6 @@
+ import difflib
+ from pathlib import Path
++from textwrap import dedent
+ 
+ from rdflib import Graph, Namespace
+ from rdflib.namespace import GEO, SDO
+@@ -181,3 +182,31 @@ def test_longturtle():
+     diff = "\n".join(list(difflib.unified_diff(target.split("\n"), output.split("\n"))))
+ 
+     assert not diff, diff
++
++
++def test_longturtle_undeclared_prefix_when_using_base():
++    """
++    See https://github.com/RDFLib/rdflib/issues/3160
++    """
++    from rdflib import Graph, Literal, URIRef
++
++    g = Graph()
++    g.add(
++        (
++            URIRef("https://example.com/subject"),
++            URIRef("https://example.com/p/predicate"),
++            Literal("object"),
++        )
++    )
++    output = g.serialize(format="longturtle", base="https://example.com/")
++    expected = dedent(
++        """
++        BASE <https://example.com/>
++        PREFIX ns1: <https://example.com/p/>
++
++        <subject>
++            ns1:predicate "object" ;
++        .
++    """
++    )
++    assert output.strip() == expected.strip()
+diff --git a/test/test_serializers/test_serializer_turtle.py b/test/test_serializers/test_serializer_turtle.py
+index c9145982..737701d2 100644
+--- a/test/test_serializers/test_serializer_turtle.py
++++ b/test/test_serializers/test_serializer_turtle.py
+@@ -1,3 +1,5 @@
++from textwrap import dedent
++
+ from rdflib import RDF, RDFS, BNode, Graph, Literal, Namespace, URIRef
+ from rdflib.collection import Collection
+ from rdflib.plugins.serializers.turtle import TurtleSerializer
+@@ -113,3 +115,29 @@ def test_turtle_namespace():
+     assert "GENO:0000385" in output
+     assert "SERIAL:0167-6423" in output
+     assert r"EX:name_with_\(parenthesis\)" in output
++
++
++def test_turtle_undeclared_prefix_when_using_base():
++    """
++    See https://github.com/RDFLib/rdflib/issues/3160
++    """
++    from rdflib import Graph, Literal, URIRef
++
++    g = Graph()
++    g.add(
++        (
++            URIRef("https://example.com/subject"),
++            URIRef("https://example.com/p/predicate"),
++            Literal("object"),
++        )
++    )
++    output = g.serialize(format="turtle", base="https://example.com/")
++    expected = dedent(
++        """
++        @base <https://example.com/> .
++        @prefix ns1: <https://example.com/p/> .
++
++        <subject> ns1:predicate "object" .
++    """
++    )
++    assert output.strip() == expected.strip()
+
+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 test/test_n3.py test/test_serializers/test_serializer_longturtle.py test/test_serializers/test_serializer_turtle.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 test/test_n3.py test/test_serializers/test_serializer_longturtle.py test/test_serializers/test_serializer_turtle.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 2a902e512123d1b9a8035fa1652aa3d0a0a918a4 -- test/test_n3.py test/test_serializers/test_serializer_longturtle.py test/test_serializers/test_serializer_turtle.py || true
+exit 0

heldout/RDFLib__rdflib-72287e45ad1a/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/RDFLib__rdflib-8685a85503c1/environment/Dockerfile

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

@@ -0,0 +1,10 @@
+# Issue
+
+**Title:** Incorrect "changed size" reported or unstable iteration when processing store graphs
+
+## Description
+When iterating through the graphs within the store, the "changed size" metric is not being updated or reported accurately. Additionally, the iteration process itself appears unstable, potentially leading to inconsistent results or missed items. Expected behavior is that iterating over the store's graphs should reliably and accurately reflect the "changed size" and provide a stable, consistent traversal of all graphs.
+
+## 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 `9b14b8f97994` and running the modified tests.

heldout/RDFLib__rdflib-8685a85503c1/solution/patch.diff

@@ -0,0 +1,13 @@
+diff --git a/rdflib/plugins/stores/memory.py b/rdflib/plugins/stores/memory.py
+index bd73e0d1..a474c5ca 100644
+--- a/rdflib/plugins/stores/memory.py
++++ b/rdflib/plugins/stores/memory.py
+@@ -556,7 +556,7 @@ class Memory(Store):
+         self, triple: Optional[_TripleType] = None
+     ) -> Generator[_ContextType, None, None]:
+         if triple is None or triple == (None, None, None):
+-            return (context for context in self.__all_contexts)
++            return (context for context in list(self.__all_contexts))
+ 
+         subj, pred, obj = triple
+         try:

heldout/RDFLib__rdflib-8685a85503c1/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/RDFLib__rdflib-8685a85503c1/task.toml

@@ -0,0 +1,77 @@
+version = "1.0"
+
+[task]
+name = "commit-runtime/RDFLib__rdflib-8685a85503c1"
+description = "set changed size when iterating the store's graphs (#3281)"
+
+[metadata]
+difficulty = "trivial"
+category = "bugfix"
+keywords = [
+    "rdflib",
+    "commit_runtime",
+]
+
+[metadata.repo2env]
+pipeline = "commit_runtime"
+pipeline_version = "0.8.3"
+repo = "RDFLib/rdflib"
+ref = "9b14b8f97994222b3744aa3c7710ecab240c9042"
+reference = "https://github.com/RDFLib/rdflib/commit/8685a85503c1385e5d34cc6f37b1d3700fb260cf"
+source_access = "public"
+built_at = "2026-09-24T13:23:31.060294+00:00"
+synthesis_llm = "gemini/gemini-2.5-flash"
+reward_kinds = [
+    "test_execution",
+    "diff_similarity",
+]
+spec_version = "0.2.0"
+content_hash = "sha256:8e50190b7faf0596cd3e0988da181629f0baa9ec78108db3cc6c8a2ae278f2d0"
+
+[metadata.repo2env.commit_runtime]
+commit_sha = "8685a85503c1385e5d34cc6f37b1d3700fb260cf"
+parent_sha = "9b14b8f97994222b3744aa3c7710ecab240c9042"
+authored_at = "2025-10-30T12:47:51+10:00"
+author_email = "37032744+edmondchuc@users.noreply.github.com"
+subject = "fix: set changed size when iterating the store's graphs (#3281)"
+fail_to_pass = [
+    "test/test_store/test_store_memorystore.py::test_sparql_bindings_creating_new_graph",
+]
+pass_to_pass = [
+    "test/test_store/test_store_memorystore.py::test_memory_store[Memory]",
+    "test/test_store/test_store_memorystore.py::test_memory_store[SimpleMemory]",
+]
+validation_status = "verified"
+bootstrap_image = "local-venv:RDFLib__rdflib"
+instruction_synthesized = true
+llm_cost_usd = 0.012444
+
+[metadata.repo2env.reward_calibration]
+f2p_count = 1
+p2p_count = 2
+source_files = 1
+loc_changed = 2
+difficulty = "trivial"
+
+[metadata.repo2env.evaluation]
+schema_version = "1"
+status = "unverified"
+stage = "generation"
+reason_codes = [
+    "validation_not_run",
+]
+detail = "Generated task; validation has not been established."
+provenance = "unknown"
+evidence = []
+
+[metadata.repo2env.reproducibility]
+mode = "local_only"
+image_ref = "local/RDFLib__rdflib"
+image_tag = "local/RDFLib__rdflib"
+image_visibility = "private"
+
+[agent]
+timeout_sec = 1800.0
+
+[verifier]
+timeout_sec = 300.0

heldout/RDFLib__rdflib-8685a85503c1/tests/f2p.json

@@ -0,0 +1,3 @@
+[
+  "test/test_store/test_store_memorystore.py::test_sparql_bindings_creating_new_graph"
+]

heldout/RDFLib__rdflib-8685a85503c1/tests/p2p.json

@@ -0,0 +1,4 @@
+[
+  "test/test_store/test_store_memorystore.py::test_memory_store[Memory]",
+  "test/test_store/test_store_memorystore.py::test_memory_store[SimpleMemory]"
+]

heldout/RDFLib__rdflib-8685a85503c1/tests/test.sh

@@ -0,0 +1,48 @@
+#!/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 9b14b8f97994222b3744aa3c7710ecab240c9042 -- test/test_store/test_store_memorystore.py || true
+git apply --verbose --reject - <<'EOF_R2E_TEST_PATCH'
+diff --git a/test/test_store/test_store_memorystore.py b/test/test_store/test_store_memorystore.py
+index 905dc58b..df51e3bf 100644
+--- a/test/test_store/test_store_memorystore.py
++++ b/test/test_store/test_store_memorystore.py
+@@ -29,3 +29,20 @@ def test_memory_store(get_graph):
+     g.remove(triple1)
+     assert len(g) == 1
+     assert len(g.serialize()) > 0
++
++
++def test_sparql_bindings_creating_new_graph():
++    # Test for https://github.com/RDFLib/rdflib/issues/3102
++    dataset = rdflib.Dataset()
++    # Create a graph
++    dataset.graph(identifier="urn:example:graph")
++    sparql_query = """
++    SELECT *
++    WHERE {
++      GRAPH ?g_1 { }
++      GRAPH ?g_2 { }
++    }"""
++
++    # Ensure it doesn't raise RuntimeError: Set changed size during iteration
++    results = dataset.query(sparql_query)
++    assert len(results) == 1
+
+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 test/test_store/test_store_memorystore.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 test/test_store/test_store_memorystore.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 9b14b8f97994222b3744aa3c7710ecab240c9042 -- test/test_store/test_store_memorystore.py || true
+exit 0

heldout/RDFLib__rdflib-8685a85503c1/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/RDFLib__rdflib-b3e60e79c9b0/environment/Dockerfile

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

@@ -0,0 +1,10 @@
+# Issue
+
+**Title:** WGS namespace IRI mismatch leads to incorrect Turtle serialization prefixes
+
+## Description
+When serializing data containing WGS (W3C Basic Geo) vocabulary to Turtle, the system currently uses an `https://` namespace IRI. This `https://` IRI does not align with the standard `http://www.w3.org/2003/01/geo/wgs84_pos#` IRI found in published W3C data. As a result, the Turtle serialization invents an incorrect `wgs1:` prefix for the WGS vocabulary. The expected behavior is for the system to use the official `http://` WGS namespace IRI, allowing for correct and consistent prefixes like `geo:` or `wgs:` in Turtle output.
+
+## 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 `695f864a6763` and running the modified tests.

heldout/RDFLib__rdflib-b3e60e79c9b0/solution/patch.diff

@@ -0,0 +1,13 @@
+diff --git a/rdflib/namespace/_WGS.py b/rdflib/namespace/_WGS.py
+index 1416154c..a9b3af90 100644
+--- a/rdflib/namespace/_WGS.py
++++ b/rdflib/namespace/_WGS.py
+@@ -10,7 +10,7 @@ class WGS(DefinedNamespace):
+     here <https://www.w3.org/2003/01/geo/>.
+     """
+ 
+-    _NS = Namespace("https://www.w3.org/2003/01/geo/wgs84_pos#")
++    _NS = Namespace("http://www.w3.org/2003/01/geo/wgs84_pos#")
+ 
+     # http://www.w3.org/2000/01/rdf-schema#Class
+     SpatialThing: URIRef

heldout/RDFLib__rdflib-b3e60e79c9b0/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/RDFLib__rdflib-b3e60e79c9b0/task.toml

@@ -0,0 +1,116 @@
+version = "1.0"
+
+[task]
+name = "commit-runtime/RDFLib__rdflib-b3e60e79c9b0"
+description = "use the W3C Basic Geo http namespace IRI for WGS (#3550)"
+
+[metadata]
+difficulty = "small"
+category = "bugfix"
+keywords = [
+    "rdflib",
+    "commit_runtime",
+]
+
+[metadata.repo2env]
+pipeline = "commit_runtime"
+pipeline_version = "0.8.3"
+repo = "RDFLib/rdflib"
+ref = "695f864a67636ef8e5610483dacf2442423c3254"
+reference = "https://github.com/RDFLib/rdflib/commit/b3e60e79c9b0b85d760832fb7bd4d0da3392bb76"
+source_access = "public"
+built_at = "2026-09-24T13:22:35.902760+00:00"
+synthesis_llm = "gemini/gemini-2.5-flash"
+reward_kinds = [
+    "test_execution",
+    "diff_similarity",
+]
+spec_version = "0.2.0"
+content_hash = "sha256:91dd5ce620187a750816ddfdd8e77f46fa5d7283eed128e4ae281c1e739f3dcd"
+
+[metadata.repo2env.commit_runtime]
+commit_sha = "b3e60e79c9b0b85d760832fb7bd4d0da3392bb76"
+parent_sha = "695f864a67636ef8e5610483dacf2442423c3254"
+authored_at = "2026-09-15T04:11:20+01:00"
+author_email = "christopher.pruijsen@gmail.com"
+subject = "fix: use the W3C Basic Geo http namespace IRI for WGS (#3550)"
+fail_to_pass = [
+    "test/test_issues/test_issue3529.py::test_wgs_matches_published_data",
+    "test/test_issues/test_issue3529.py::test_wgs_namespace_iri_is_http",
+    "test/test_issues/test_issue3529.py::test_wgs_prefix_used_on_serialize",
+    "test/test_namespace/test_namespacemanager.py::test_bound_namespaces_subset[None-expected_bindings0]",
+    "test/test_namespace/test_namespacemanager.py::test_bound_namespaces_subset[rdflib-expected_bindings1]",
+]
+pass_to_pass = [
+    "test/test_namespace/test_namespacemanager.py::test_bound_namespaces_subset[core-expected_bindings2]",
+    "test/test_namespace/test_namespacemanager.py::test_cc_prefixes_bound",
+    "test/test_namespace/test_namespacemanager.py::test_compute_qname[http://example.org/here#-True-none-None-None-None-expected_result3]",
+    "test/test_namespace/test_namespacemanager.py::test_compute_qname[http://example.org/here#-True-none-None-None-store_prefixes2-expected_result2]",
+    "test/test_namespace/test_namespacemanager.py::test_compute_qname[http://example.org/here#-True-none-None-graph_prefixes1-None-expected_result1]",
+    "test/test_namespace/test_namespacemanager.py::test_compute_qname[http://example.org/here#-True-none-manager_prefixes0-None-None-expected_result0]",
+    "test/test_namespace/test_namespacemanager.py::test_compute_qname_no_generate",
+    "test/test_namespace/test_namespacemanager.py::test_compute_qname_strict[http://example.org/here#-True-none-None-expected_result1]",
+    "test/test_namespace/test_namespacemanager.py::test_compute_qname_strict[http://example.org/here#-True-none-additional_prefixes0-expected_result0]",
+    "test/test_namespace/test_namespacemanager.py::test_core_prefixes_bound",
+    "test/test_namespace/test_namespacemanager.py::test_expand_curie[:foo-http://example.org/foo]",
+    "test/test_namespace/test_namespacemanager.py::test_expand_curie[egdo:bar-expected_result3]",
+    "test/test_namespace/test_namespacemanager.py::test_expand_curie[rdf:type-http://www.w3.org/1999/02/22-rdf-syntax-ns#type]",
+    "test/test_namespace/test_namespacemanager.py::test_expand_curie[too_small-expected_result2]",
+    "test/test_namespace/test_namespacemanager.py::test_generate_curie[-None-expected_result7]",
+    "test/test_namespace/test_namespacemanager.py::test_generate_curie[http://example.com/-None-expected_result8]",
+    "test/test_namespace/test_namespacemanager.py::test_generate_curie[http://example.com/a#chair-False-expected_result4]",
+    "test/test_namespace/test_namespacemanager.py::test_generate_curie[http://example.com/a#chair-None-ns1:chair]",
+    "test/test_namespace/test_namespacemanager.py::test_generate_curie[http://example.com/a#chair-True-ns1:chair]",
+    "test/test_namespace/test_namespacemanager.py::test_generate_curie[http://example.com/b#chair-None-ns1:chair]",
+    "test/test_namespace/test_namespacemanager.py::test_generate_curie[http://example.com/c-None-ns1:c]",
+    "test/test_namespace/test_namespacemanager.py::test_generate_curie[http://example.org/foo-None-:foo]",
+    "test/test_namespace/test_namespacemanager.py::test_generate_curie[http://www.w3.org/1999/02/22-rdf-syntax-ns#type-None-rdf:type]",
+    "test/test_namespace/test_namespacemanager.py::test_graph_bind_namespaces[None-ValueError]",
+    "test/test_namespace/test_namespacemanager.py::test_graph_bind_namespaces[core-expected_result2]",
+    "test/test_namespace/test_namespacemanager.py::test_graph_bind_namespaces[invalid-ValueError]",
+    "test/test_namespace/test_namespacemanager.py::test_graph_bind_namespaces[none-expected_result4]",
+    "test/test_namespace/test_namespacemanager.py::test_graph_bind_namespaces[rdflib-expected_result3]",
+    "test/test_namespace/test_namespacemanager.py::test_invalid_selector",
+    "test/test_namespace/test_namespacemanager.py::test_nman_bind_namespaces[None-ValueError]",
+    "test/test_namespace/test_namespacemanager.py::test_nman_bind_namespaces[core-expected_result2]",
+    "test/test_namespace/test_namespacemanager.py::test_nman_bind_namespaces[invalid-ValueError]",
+    "test/test_namespace/test_namespacemanager.py::test_nman_bind_namespaces[none-expected_result4]",
+    "test/test_namespace/test_namespacemanager.py::test_nman_bind_namespaces[rdflib-expected_result3]",
+    "test/test_namespace/test_namespacemanager.py::test_rdflib_prefixes_bound",
+    "test/test_namespace/test_namespacemanager.py::test_rebinding",
+    "test/test_namespace/test_namespacemanager.py::test_replace",
+]
+validation_status = "verified"
+bootstrap_image = "local-venv:RDFLib__rdflib"
+instruction_synthesized = true
+llm_cost_usd = 0.0
+
+[metadata.repo2env.reward_calibration]
+f2p_count = 5
+p2p_count = 37
+source_files = 1
+loc_changed = 2
+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/RDFLib__rdflib"
+image_tag = "local/RDFLib__rdflib"
+image_visibility = "private"
+
+[agent]
+timeout_sec = 1800.0
+
+[verifier]
+timeout_sec = 300.0

heldout/RDFLib__rdflib-b3e60e79c9b0/tests/f2p.json

@@ -0,0 +1,7 @@
+[
+  "test/test_issues/test_issue3529.py::test_wgs_matches_published_data",
+  "test/test_issues/test_issue3529.py::test_wgs_namespace_iri_is_http",
+  "test/test_issues/test_issue3529.py::test_wgs_prefix_used_on_serialize",
+  "test/test_namespace/test_namespacemanager.py::test_bound_namespaces_subset[None-expected_bindings0]",
+  "test/test_namespace/test_namespacemanager.py::test_bound_namespaces_subset[rdflib-expected_bindings1]"
+]

heldout/RDFLib__rdflib-b3e60e79c9b0/tests/p2p.json

@@ -0,0 +1,39 @@
+[
+  "test/test_namespace/test_namespacemanager.py::test_bound_namespaces_subset[core-expected_bindings2]",
+  "test/test_namespace/test_namespacemanager.py::test_cc_prefixes_bound",
+  "test/test_namespace/test_namespacemanager.py::test_compute_qname[http://example.org/here#-True-none-None-None-None-expected_result3]",
+  "test/test_namespace/test_namespacemanager.py::test_compute_qname[http://example.org/here#-True-none-None-None-store_prefixes2-expected_result2]",
+  "test/test_namespace/test_namespacemanager.py::test_compute_qname[http://example.org/here#-True-none-None-graph_prefixes1-None-expected_result1]",
+  "test/test_namespace/test_namespacemanager.py::test_compute_qname[http://example.org/here#-True-none-manager_prefixes0-None-None-expected_result0]",
+  "test/test_namespace/test_namespacemanager.py::test_compute_qname_no_generate",
+  "test/test_namespace/test_namespacemanager.py::test_compute_qname_strict[http://example.org/here#-True-none-None-expected_result1]",
+  "test/test_namespace/test_namespacemanager.py::test_compute_qname_strict[http://example.org/here#-True-none-additional_prefixes0-expected_result0]",
+  "test/test_namespace/test_namespacemanager.py::test_core_prefixes_bound",
+  "test/test_namespace/test_namespacemanager.py::test_expand_curie[:foo-http://example.org/foo]",
+  "test/test_namespace/test_namespacemanager.py::test_expand_curie[egdo:bar-expected_result3]",
+  "test/test_namespace/test_namespacemanager.py::test_expand_curie[rdf:type-http://www.w3.org/1999/02/22-rdf-syntax-ns#type]",
+  "test/test_namespace/test_namespacemanager.py::test_expand_curie[too_small-expected_result2]",
+  "test/test_namespace/test_namespacemanager.py::test_generate_curie[-None-expected_result7]",
+  "test/test_namespace/test_namespacemanager.py::test_generate_curie[http://example.com/-None-expected_result8]",
+  "test/test_namespace/test_namespacemanager.py::test_generate_curie[http://example.com/a#chair-False-expected_result4]",
+  "test/test_namespace/test_namespacemanager.py::test_generate_curie[http://example.com/a#chair-None-ns1:chair]",
+  "test/test_namespace/test_namespacemanager.py::test_generate_curie[http://example.com/a#chair-True-ns1:chair]",
+  "test/test_namespace/test_namespacemanager.py::test_generate_curie[http://example.com/b#chair-None-ns1:chair]",
+  "test/test_namespace/test_namespacemanager.py::test_generate_curie[http://example.com/c-None-ns1:c]",
+  "test/test_namespace/test_namespacemanager.py::test_generate_curie[http://example.org/foo-None-:foo]",
+  "test/test_namespace/test_namespacemanager.py::test_generate_curie[http://www.w3.org/1999/02/22-rdf-syntax-ns#type-None-rdf:type]",
+  "test/test_namespace/test_namespacemanager.py::test_graph_bind_namespaces[None-ValueError]",
+  "test/test_namespace/test_namespacemanager.py::test_graph_bind_namespaces[core-expected_result2]",
+  "test/test_namespace/test_namespacemanager.py::test_graph_bind_namespaces[invalid-ValueError]",
+  "test/test_namespace/test_namespacemanager.py::test_graph_bind_namespaces[none-expected_result4]",
+  "test/test_namespace/test_namespacemanager.py::test_graph_bind_namespaces[rdflib-expected_result3]",
+  "test/test_namespace/test_namespacemanager.py::test_invalid_selector",
+  "test/test_namespace/test_namespacemanager.py::test_nman_bind_namespaces[None-ValueError]",
+  "test/test_namespace/test_namespacemanager.py::test_nman_bind_namespaces[core-expected_result2]",
+  "test/test_namespace/test_namespacemanager.py::test_nman_bind_namespaces[invalid-ValueError]",
+  "test/test_namespace/test_namespacemanager.py::test_nman_bind_namespaces[none-expected_result4]",
+  "test/test_namespace/test_namespacemanager.py::test_nman_bind_namespaces[rdflib-expected_result3]",
+  "test/test_namespace/test_namespacemanager.py::test_rdflib_prefixes_bound",
+  "test/test_namespace/test_namespacemanager.py::test_rebinding",
+  "test/test_namespace/test_namespacemanager.py::test_replace"
+]