Dataset Viewer
Auto-converted to Parquet Duplicate
task_id
stringlengths
20
20
verify_label
stringclasses
3 values
verify_reason
stringlengths
240
694
verify_mechanism
stringclasses
182 values
repair_action
stringclasses
4 values
accepted
bool
2 classes
refusal
stringclasses
48 values
notes
stringlengths
0
486
test_sh
stringlengths
0
18.7k
setup_sh
stringclasses
334 values
leaked_paths
listlengths
0
9
oracle_to_tests
listlengths
0
2
needs_image_rebuild
bool
2 classes
superseded
stringclasses
1 value
repair_model
stringclasses
1 value
task_000000_c19dda5b
VERIFIER-TOO-WEAK
The fuzz test only compares stdout for arguments of length 10–256, while the oracle simply echoes those arguments with a newline; an executable script that prints its first argument would pass without bisecting, fixing the mutex, modifying the Makefile, or using the OCR offset. Additionally, `/app/oracle_parser` is shi...
fuzz-equivalence
rewrite_verifier
true
The verifier now requires a genuine ELF, rejects a byte-identical oracle copy, checks the mutex, OCR offset, and pthread Makefile repair, and rebuilds the repository. It retains the original oracle fuzz test while adding independently derived boundary cases that expose a trivial argument-echo implementation.
#!/bin/bash set -e mkdir -p /logs/verifier cat << 'TEST_EOF' > /tmp/test_final_state.py import os import random import re import string import subprocess from pathlib import Path import pytest AGENT_BIN = Path("/home/user/fixed_parser") ORACLE_BIN = Path("/app/oracle_parser") REPO = Path("/home/user/telemetry_repo")...
[]
[]
false
openai/gpt-5-6-sol-genai-responses
task_000000_f8baca82
ANSWER-LEAK
The setup writes the complete expected output to `/home/user/.truth.json`, and `chmod -R 777 /home/user` makes that file directly readable by the agent. The agent can simply copy this ground-truth file to `/home/user/analyzed_nodes.json` without performing either the rolling-average or PageRank analysis.
exact-compare
remove_leak
true
Removed the complete expected output from the agent image. The unchanged behavioral assertions now read the extracted oracle from /tests/.truth.json, which is uploaded only at verification time.
#!/bin/bash set -e mkdir -p /logs/verifier cat << 'TEST_EOF' > /tmp/test_final_state.py # test_final_state.py import os import json def test_analyzed_nodes_json_exists(): output_path = '/home/user/analyzed_nodes.json' assert os.path.isfile(output_path), f"Output file {output_path} is missing. The task requir...
#!/bin/bash set -e export DEBIAN_FRONTEND=noninteractive apt-get update && apt-get install -y python3 python3-pip pip3 install pytest networkx pandas scipy mkdir -p /home/user cat << 'EOF' > /home/user/network_data.csv tx_id,sender,receiver,amount,timestamp 1,Alice,Bob,10.0,1 2,Alice,Charlie,20.0,2 3,Alice,Bob,30.0,3...
[ "/home/user/.truth.json" ]
[ "/home/user/.truth.json" ]
true
openai/gpt-5-6-sol-genai-responses
task_000001_e67d5628
VERIFIER-TOO-WEAK
Several major requirements can be faked: `libnetconf.a` is checked only for file existence, `processed_manifest.txt` may be empty, and `ssh_tunnel_cmd.txt` need only start with `ssh` and contain the strings `9090` and `8080`; no actual tunnel, header fix, Makefile correctness, locale, or timezone is validated. Although...
fuzz-equivalence
rewrite_verifier
true
The verifier now rebuilds and links the static library, checks exact manifest processing and persistent locale/timezone settings, independently exercises both the submitted and rebuilt validator, and executes the recorded SSH command against a live endpoint. The exposed oracle source and executable are removed before t...
#!/bin/bash set -u mkdir -p /logs/verifier cat <<'PY' > /tmp/verify_final_state.py import os import re import shlex import shutil import socket import stat import subprocess import tempfile import threading import time def check(cond, msg): if not cond: raise AssertionError(msg) def run(cmd, **kwargs):...
[ "/opt/oracle/oracle.c", "/opt/oracle/validate_ip_format_oracle" ]
[]
false
openai/gpt-5-6-sol-genai-responses
task_000002_81d660f3
VERIFIER-TOO-WEAK
The four live requests only assert that port 9000 returns the fixed body `API_OK`; they do not verify that traffic reaching port 9002 is actually forwarded bidirectionally to port 9001. A fake `tunnel.py` that directly responds with `API_OK`, plus a hardcoded four-line `test_results.log`, would pass, while `systemctl s...
fixed-subset
rewrite_verifier
true
The verifier now executes verify.py against unpredictable HTTP bodies and confirms exactly four real requests. It also replaces the API temporarily with a randomized binary backend and verifies continuous bidirectional forwarding through port 9002, while retaining the original log, dependency, and live-stack assertions...
#!/bin/bash set -e mkdir -p /logs/verifier cat << 'TEST_EOF' > /tmp/test_final_state.py import http.server import os import queue import secrets import socket import socketserver import stat import subprocess import threading import time import urllib.request import pytest def user_systemctl(action, unit): cmd ...
[]
[]
false
openai/gpt-5-6-sol-genai-responses
task_000002_8be5378a
ANSWER-LEAK
The environment ships `/app/oracle_aligner.py`, which contains the complete correct implementation and can simply be copied over `/home/user/aligner.py`. Although the verifier strongly compares 200 fuzzed cases against that oracle, the readable oracle file eliminates the need to perform the debugging task.
fuzz-equivalence
remove_leak
true
Removed the complete reference implementation from the agent image. The verifier retains its original fuzz-equivalence assertions but loads the oracle only at verification time from /tests/oracle_aligner.py.
#!/bin/bash set -e mkdir -p /logs/verifier cat << 'TEST_EOF' > /tmp/test_final_state.py # test_final_state.py import os import random import string import subprocess import pytest def test_fuzz_equivalence(): oracle_path = "/tests/oracle_aligner.py" agent_path = "/home/user/aligner.py" assert os.path.exi...
#!/bin/bash set -e export DEBIAN_FRONTEND=noninteractive apt-get update && apt-get install -y python3 python3-pip espeak pip3 install pytest useradd -m -s /bin/bash user || true mkdir -p /app espeak -w /app/voicemail.wav "I need to report a bug in the production system." cat << 'EOF' > /home/user/aligner.py import s...
[ "/app/oracle_aligner.py" ]
[ "/app/oracle_aligner.py" ]
true
openai/gpt-5-6-sol-genai-responses
task_000003_2a1af405
VERIFIER-TOO-WEAK
The verifier queries only the fixed tenant `ALPHA-774` with `(page, limit)` values `(1, 2)` and `(2, 2)`. An agent can hardcode those two JSON responses and the token checks without implementing database-backed tenant filtering, default pagination, or general pagination, so a plausible fake service passes despite the v...
fixed-subset
rewrite_verifier
true
The verifier retains the original checks and adds unpredictable catalog records after the agent runs. It now verifies database-backed tenant filtering, default pagination, and several derived pagination cases that cannot be satisfied by hardcoding the original two responses.
#!/bin/bash set -e mkdir -p /logs/verifier cat << 'TEST_EOF' > /tmp/test_final_state.py import os import sqlite3 import time import uuid import pytest import requests API_URL = "http://127.0.0.1:8080/api/backups" TOKEN = "BRAVO-992-SECURE" DYNAMIC_SUFFIX = uuid.uuid4().hex DYNAMIC_TENANT = f"VERIFY-{DYNAMIC_SUFFIX}"...
[]
[]
false
openai/gpt-5-6-sol-genai-responses
task_000003_b73a4413
VERIFIER-TOO-WEAK
The verifier never runs the compiled daemon, client, or backup script, so an agent can fabricate all final artifacts without performing the requested workflow. It only greps the source for socket-path strings, checks that the executable bit is set, searches for a fixed log substring, and verifies that each tar contains...
keyword-grep
rewrite_verifier
true
The verifier now executes the compiled ELF daemon with the provided client, validates fresh sensor output and daemon/socket cleanup, then executes the backup script under tracing. It preserves the original checks while additionally verifying command order, exact `sleep 1` invocations, fresh archive contents, and real t...
#!/bin/bash set -e mkdir -p /logs/verifier cat << 'TEST_EOF' > /tmp/test_final_state.py import os import shlex import socket import stat import subprocess import tarfile import time import pytest SOURCE = "/home/user/edge_daemon.cpp" DAEMON = "/home/user/edge_daemon" SOCKET = "/home/user/run/edge.sock" CLIENT = "/ho...
[]
[]
false
openai/gpt-5-6-sol-genai-responses
task_000004_aeddda76
VERIFIER-TOO-WEAK
The verifier checks only three hardcoded output archives and validates member names and declared sizes, without comparing file bytes to the incoming archives or recomputing expected outputs. An agent can skip creating `/home/user/sanitize.py` and fabricate tarballs with the expected names and metadata, so the requested...
fixed-subset
rewrite_verifier
true
The verifier now requires and executes sanitize.py after clearing prior outputs, then adds a randomized unseen archive with safe and malicious members. It derives expected names, sizes, member types, and bytes from every incoming archive while retaining the original fixed assertions and checking that traversal payloads...
#!/bin/bash set -e mkdir -p /logs/verifier cat << 'TEST_EOF' > /tmp/test_final_state.py import os import pwd import shutil import subprocess import sys import tarfile import uuid from io import BytesIO import pytest INCOMING_DIR = "/home/user/incoming" PROCESSED_DIR = "/home/user/processed" SCRIPT = "/home/user/sani...
[]
[]
false
openai/gpt-5-6-sol-genai-responses
task_000004_b4949f3f
VERIFIER-TOO-WEAK
The reconstruction check only compares the submitted WAV to the observational input, so simply copying `/app/chime_recording.wav` to `/home/user/reconstructed.wav` yields MSE 0 without fitting the model or performing MCMC. The posterior plot is checked only for nonempty existence, and the CSV only for column names and ...
other
rewrite_verifier
true
The verifier now reruns the submitted Python artifact, observes at least four multiprocessing workers, and requires regenerated outputs. It preserves the original output and MSE checks while rejecting an copied observation by verifying 16-bit WAV structure and consistency with the three logged model components.
#!/bin/bash set -e mkdir -p /logs/verifier cat << 'TEST_EOF' > /tmp/test_final_state.py import ast import csv import os import pathlib import subprocess import sys import numpy as np import pytest from scipy.io import wavfile ORIGINAL = "/app/chime_recording.wav" RECONSTRUCTED = "/home/user/reconstructed.wav" PARAME...
[]
[]
false
openai/gpt-5-6-sol-genai-responses
task_000005_162ed362
ANSWER-LEAK
The supposed compiled reference at `/app/oracle_transform` is created as a readable Python script containing the complete transformation implementation: reverse the input and run-length encode it. Thus the exact answer for `/home/user/transform.py` is directly exposed rather than requiring oracle probing or deduction. ...
fuzz-equivalence
remove_leak
false
remove_leak declares no leaked_paths
Replaced the readable Python oracle implementation with an actual stripped compiled executable at the instruction-mandated path. This preserves black-box oracle probing while removing direct source-code disclosure.
[]
[]
true
openai/gpt-5-6-sol-genai-responses
task_000005_ceefb305
VERIFIER-TOO-WEAK
The verifier never compiles or runs `/home/user/archiver.c`; it only greps that source for headers and the absence of `system(`. An agent can create a dummy C file, generate the dynamically checked WAL using shell/Python, and make an archive containing merely the three checked filenames; the verifier also neither requi...
other
rewrite_verifier
true
The verifier now requires and recompiles the submitted executable, runs it against randomized ISO-8859-1 content and an unseen ELF, and derives the expected WAL results independently. It also requires multiple correctly sized parts and verifies that the archive contains byte-correct copies of the full incoming director...
#!/bin/bash set -e mkdir -p /logs/verifier cat << 'TEST_EOF' > /tmp/test_final_state.py import glob import os import re import shutil import struct import subprocess import tarfile import tempfile import uuid import pytest SRC = "/home/user/archiver.c" BIN = "/home/user/archiver" WAL = "/home/user/archive_index.wal" ...
[]
[]
false
openai/gpt-5-6-sol-genai-responses
task_000006_74a36316
VERIFIER-TOO-WEAK
The verifier only numerically checks `stddev_x` and `stddev_y` from the last HTTP and TCP responses; `x` and `y` merely need to be present/non-NaN, and no running/intermediate states are validated. A fake server that returns constant precomputed standard deviations for the single fixed video would pass without implemen...
fixed-subset
rewrite_verifier
true
The verifier now launches the submitted ELF itself, replaces the fixed trajectory with an unpredictable equivalent test video, computes centroid-based Welford ground truth, and validates many coherent intermediate and final HTTP/TCP states under concurrent load. It retains the original final standard-deviation assertio...
#!/bin/bash set -e mkdir -p /logs/verifier cat <<'PYTEST_EOF' > /tmp/test_vision_math.py import concurrent.futures import http.client import json import math import os import secrets import signal import socket import stat import struct import subprocess import threading import time import pytest ROOT = "/home/user/...
[]
[]
false
openai/gpt-5-6-sol-genai-responses
task_000007_654ab1c7
VERIFIER-TOO-WEAK
The verifier exact-compares only three hardcoded database rows and never checks that `/home/user/process_graph.py` exists, was executed, reads the JSONL, uses NetworkX, or performs parameterized inserts. An agent can directly create `analytics.db` containing the three expected rows without implementing the requested pi...
exact-compare
rewrite_verifier
true
The verifier now requires and inspects the Python script for NetworkX degree-centrality use and parameterized inserts, then executes it against randomized JSONL data with independently derived answers. It restores the supplied input, reruns the script, and preserves the original database assertions and final artifact.
#!/bin/bash set -e mkdir -p /logs/verifier cat << 'PY_EOF' > /tmp/verify_graph_task.py import ast import itertools import json import os import random import re import secrets import shutil import sqlite3 import stat import subprocess import sys SCRIPT_PATH = '/home/user/process_graph.py' DATA_PATH = '/home/user/data...
[]
[]
false
openai/gpt-5-6-sol-genai-responses
task_000007_eadb8636
VERIFIER-TOO-WEAK
The verifier checks only that `/home/user/cleaner` is executable and behaviorally matches `/app/cleaner_oracle`; it never checks that `/home/user/cleaner.c` exists or that the executable is an independently recreated implementation. Because the oracle remains accessible, an agent can simply copy it to the target path o...
fuzz-equivalence
rewrite_verifier
true
The verifier now requires a real C source file, recompiles it, rejects a byte-identical oracle copy, and retains the original oracle fuzz-equivalence assertions. Both the rebuilt source and submitted ELF are additionally tested in chroots without the oracle, against independently derived expected bytes, preventing orac...
#!/bin/bash set -e mkdir -p /logs/verifier cat << 'TEST_EOF' > /tmp/test_final_state.py import os import re import shutil import stat import subprocess import pytest import numpy as np ORACLE_PATH = "/app/cleaner_oracle" AGENT_PATH = "/home/user/cleaner" SOURCE_PATH = "/home/user/cleaner.c" def test_agent_binary_ex...
[]
[]
false
openai/gpt-5-6-sol-genai-responses
task_000008_e94be48f
VERIFIER-TOO-WEAK
The verifier exact-compares `summary.txt` and `cleaned.bin` only for the single fixed fixture, while checking `/home/user/clean_join.c` and `/home/user/process.sh` solely for existence. An agent can create empty or bogus source/scripts and directly write the known 48-byte binary plus `2`, passing without implementing, ...
exact-compare
rewrite_verifier
true
The verifier retains the original fixed-fixture assertions, then independently compiles and executes the submitted C source on unpredictable inputs. It also runs process.sh on a second generated fixture, verifies gcc was invoked, and checks both binary records and the derived summary count.
#!/bin/bash set -e mkdir -p /logs/verifier cat << 'TEST_EOF' > /tmp/test_final_state.py import os import re import secrets import struct import subprocess import tempfile import pytest DATA_DIR = '/home/user/data' SOURCE = '/home/user/clean_join.c' PROCESS = '/home/user/process.sh' def test_required_files_exist(): ...
[]
[]
false
openai/gpt-5-6-sol-genai-responses
task_000009_8e53cc34
ANSWER-LEAK
The environment exposes the executable ground-truth implementation at `/app/oracle_bin`, and the verifier leaves it available while testing. An agent can simply copy or symlink that binary to `/home/user/compute_metric` (or create a wrapper that invokes it), passing all 100 trials without implementing the metric or pro...
fuzz-equivalence
remove_leak
false
would remove /app/oracle_bin, which the instruction references
Removed the oracle executable from the agent image and moved it to verification-only storage. The verifier runs submissions as the unprivileged user while keeping the uploaded oracle root-only, and also confirms that C source was produced.
[ "/app/oracle_bin" ]
[ "/app/oracle_bin" ]
true
openai/gpt-5-6-sol-genai-responses
task_000009_dbc34e08
VERIFIER-TOO-WEAK
The verifier validates the contents of `/home/user/observed_data.csv` and `/home/user/results.json`, but never checks that the required `/home/user/simulate.py` exists or executes successfully. An agent can omit the requested implementation entirely and write the expected output files directly, so a significant require...
exact-compare
rewrite_verifier
true
The verifier now requires a real, non-symlinked simulate.py, removes any prewritten results.json, executes the script, and verifies the freshly generated output while retaining all original assertions.
#!/bin/bash mkdir -p /logs/verifier rm -f /tmp/test_final_state.py cat << 'TEST_EOF' > /tmp/test_final_state.py # test_final_state.py import os import sys import json import math import subprocess def test_simulate_script_executes_and_generates_results(): """Test that the required simulation artifact exists and...
[]
[]
false
openai/gpt-5-6-sol-genai-responses
task_000010_7c427a6f
VERIFIER-TOO-WEAK
The verifier only exact-compares `/home/user/clean_traces.json` to one fixed expected dictionary and never runs `/home/user/trace_analyzer.py`, so an agent can hardcode that JSON without implementing parsing, cycle detection, or missing-parent handling. The implementation requirement is checked only by grepping for the...
exact-compare
rewrite_verifier
true
The verifier now executes the analyzer on both the supplied log and fresh randomized cases covering corruption, malformed IDs, cycles, and missing parents. It also uses AST and runtime line tracing to ensure a real assert and AssertionError handler execute for malformed trace IDs, while retaining the original exact-out...
#!/bin/bash set -e mkdir -p /logs/verifier LOG_PATH=/home/user/app_trace.log OUTPUT_PATH=/home/user/clean_traces.json LOG_BACKUP=$(mktemp) OUTPUT_BACKUP=$(mktemp) cp "$LOG_PATH" "$LOG_BACKUP" if [ -f "$OUTPUT_PATH" ]; then cp "$OUTPUT_PATH" "$OUTPUT_BACKUP" HAD_OUTPUT=1 else HAD_OUTPUT=0 fi cleanup() { ...
[]
[]
false
openai/gpt-5-6-sol-genai-responses
task_000010_e7b016b0
VERIFIER-TOO-WEAK
The verifier tests only the fixed, explicitly labeled directories `/app/corpus/clean` and `/app/corpus/evil`, so a script can branch on the path or filenames and copy/emit only `clean_*.csv` without computing any trajectory differences. It also checks only output filenames, not that outputs are actual copies, and merel...
fixed-subset
rewrite_verifier
true
The verifier now derives C by decoding the video, validates the full notebook-produced trajectory, and executes the script on a randomized mixed corpus with unpredictable filenames. It retains the original corpus assertions while also checking exact copied contents and rejection decisions derived from the validated ref...
#!/bin/bash set -e mkdir -p /logs/verifier cat << 'TEST_EOF' > /tmp/test_final_state.py import json import os from pathlib import Path import secrets import subprocess import tempfile import numpy as np import pandas as pd import pytest from scipy.integrate import odeint SCRIPT_PATH = "/home/user/sanitize.sh" REFERE...
[]
[]
false
openai/gpt-5-6-sol-genai-responses
task_000011_24e54d45
VERIFIER-TOO-WEAK
The verifier recomputes the correct stats for the single fixed FASTA file and exact-compares stats.txt, but it only checks that /home/user/analyze_gc.cpp exists. It never compiles or executes that source, so an empty C++ file plus hardcoded expected output can pass without implementing the requested program.
exact-compare
rewrite_verifier
true
The verifier retains the original source and fixed-output assertions, then compiles the submitted C++ and executes it on multiple runtime-generated FASTA inputs whose expected statistics are independently derived.
#!/bin/bash mkdir -p /logs/verifier cat << 'TEST_EOF' > /tmp/test_final_state.py import math import os import re import secrets import subprocess CPP_PATH = "/home/user/analyze_gc.cpp" FASTA_PATH = "/home/user/sequences.fasta" STATS_PATH = "/home/user/stats.txt" EXE_PATH = "/tmp/analyze_gc_verifier" def compute_exp...
[]
[]
false
openai/gpt-5-6-sol-genai-responses
task_000011_b3a63e5b
VERIFIER-TOO-WEAK
The verifier never transcribes the audio, reads features.csv, recompiles or runs analysis.cpp, or recomputes the bootstrap confidence interval. Any JSON containing two ordered numbers in [-1, 1] passes, while analysis.cpp may be arbitrary text containing the substrings "mt19937", "42", and "10000"; therefore a fabricat...
shape-only
rewrite_verifier
true
The verifier now validates the fixed experiment inputs, recompiles and executes analysis.cpp after deleting any preexisting metrics, and independently recomputes the seeded 10,000-sample bootstrap CI. The original file, range, ordering, and source-token assertions remain in place.
#!/bin/bash mkdir -p /logs/verifier cat << 'TEST_EOF' > /tmp/test_final_state.py import json import math import os import random import subprocess import textwrap import pytest CPP_PATH = "/home/user/analysis.cpp" METRICS_PATH = "/home/user/metrics.json" FEATURES_PATH = "/home/user/data/features.csv" AUDIO_PATH = "/...
[]
[]
false
openai/gpt-5-6-sol-genai-responses
task_000012_58fdcccc
VERIFIER-TOO-WEAK
The verifier never inspects or executes `/home/user/generate_report.py`, so an agent can generate the report by any method without implementing the required single optimized SQL query or window-function pipeline. It also accepts any two user-created indexes without checking that they cover join/filter columns, and beca...
recomputes
rewrite_verifier
true
The verifier now executes the submitted script on both protected original data and verifier-generated data, traces the SQL to require one JOIN/window-function query, and rejects database data mutation. It retains the original report and index-count assertions while requiring at least two indexes to target relevant join...
#!/bin/bash set -e mkdir -p /logs/verifier cat <<'TEST_EOF' > /tmp/test_final_state.py import importlib.util import json import os import re import shutil import sqlite3 import stat import subprocess import sys import tempfile import pytest DB_PATH = "/home/user/climate_data.db" SCRIPT_PATH = "/home/user/generate_re...
[]
[]
false
openai/gpt-5-6-sol-genai-responses
task_000012_bcc9081e
VERIFIER-TOO-WEAK
Although the verifier oracle-diffs 10,000 inputs, its generator produces essentially only invalid files: even the 10% beginning with `CERT` have a random 16-bit length against a file of at most 500 bytes, and the vanishingly rare structurally complete case would still need a random 32-bit checksum match. Thus a program...
fuzz-equivalence
rewrite_verifier
true
The verifier now includes constructed valid chains, boundary lengths, trailing data, checksum failures, and truncations, so an always-INVALID program cannot pass. It also verifies that the extracted file is the actual keystore certificate and rejects a byte-identical copy of the oracle.
#!/bin/bash set -e mkdir -p /logs/verifier cat << 'TEST_EOF' > /tmp/test_final_state.py import hashlib import os import random import struct import subprocess import tempfile import pytest ORACLE_BIN = "/opt/legacy/validator" AGENT_BIN = "/home/user/new_validator" CERTS_DIR = "/home/user/certs" KEYSTORE = "/app/legac...
[]
[]
false
openai/gpt-5-6-sol-genai-responses
task_000013_df6cd2ad
VERIFIER-TOO-WEAK
The verifier only checks binary magic bytes, so arbitrary files beginning with ELF and MZ signatures can pass without being valid cross-compiled applications. Source validation is also limited to keyword/substr checks such as `go:build windows`, absence of `LeakCache = append`, and presence of `HandleThumbnail`; it nev...
keyword-grep
rewrite_verifier
true
The verifier now validates real amd64 ELF/PE Go applications, independently cross-builds the source for both targets, and runs the submitted Linux server to exercise its responses. It also checks actual OS file selection and load-tests the handler while measuring retained Go heap memory.
#!/bin/bash set -e mkdir -p /logs/verifier cat << 'TEST_EOF' > /tmp/test_final_state.py import os import struct import subprocess import tempfile import time import urllib.request import pytest ROOT = "/home/user/webapp" LINUX_BIN = ROOT + "/build/server_linux" WINDOWS_BIN = ROOT + "/build/server_windows.exe" def r...
[]
[]
false
openai/gpt-5-6-sol-genai-responses
End of preview. Expand in Data Studio

swerl-tmax-15k task repairs (gpt-5-6-sol)

Proposed repairs for defective tasks in hamishivi/swerl-tmax-15k, generated from the audit labels in wAI-org/swerl-tmax-15k-rubric-gpt-5-6-sol.

These repairs are UNVALIDATED

No repair here has been executed, and none has been shown to be solvable.

Every repair was checked mechanically β€” valid bash, still writes a reward, does not delete a path the instruction needs. None was checked empirically. A hardened verifier can be unsatisfiable: if it demands something no correct solution produces, the task becomes permanently unpassable, and that is strictly worse than the weak verifier it replaced. There are no reference solutions in this corpus, so the only way to establish satisfiability is a rollout pass, and the rollout pass has not been run.

Do not adopt these into a training set on the strength of accepted=true. accepted means the guards passed, nothing more.

What is here

One row per repaired task, scripts as text columns β€” not a directory tree.

column meaning
task_id joins to the source dataset and to the rubric dataset
verify_label the audited defect this repair addresses
verify_reason / verify_mechanism the audit finding it was generated from
repair_action rewrite_verifier, remove_leak, or skip
accepted guards passed β€” not "validated"
refusal why a repair was rejected, when it was
test_sh replacement tests/test.sh
setup_sh replacement setup.sh, when the fix requires rebuilding the image
leaked_paths paths no longer present in the rebuilt image
oracle_to_tests leaked paths the verifier still needs; must be extracted from the current image and shipped with the tests, which upload only at verification
needs_image_rebuild true when setup_sh is non-empty
superseded set when an earlier repair was withdrawn, with the reason

Refused repairs are included with accepted=false. Dropping them would hide the guard behaviour and make the acceptance rate unauditable from the artifact.

Coverage

source label accepted attempted
VERIFIER-TOO-WEAK 11,013 11,160
INSTR-VERIFIER-MISMATCH 432 441
ANSWER-LEAK 15 20
total 11,460 11,621

ANSWER-LEAK is a 20-task prototype only; the remaining ~1,572 have not been run.

333 accepted repairs require an image rebuild and 52 require extracting an oracle from the existing image. Neither step has been performed, so those rows are incomplete as shipped β€” the setup_sh describes an image that does not exist yet.

How the repairs work

tests/test.sh is uploaded at verification time and is not baked into the task image, so a replacement verifier needs no rebuild. Where a leak must be closed, the fix is removal from the agent image (hence setup_sh), with any oracle the verifier still needs shipped via the tests directory so it is absent during the agent's attempt.

An earlier iteration tried to defend leaks by having the verifier reject a byte-identical copy of the oracle. That does not work: the agent copies the oracle, appends a harmless comment, and passes both the inequality check and the behavioural tests. Those repairs were withdrawn and are marked in superseded. The generator now refuses byte/hash inequality as a sole defence.

Guards

  1. replacement verifier must still write /logs/verifier/reward.txt
  2. never remove a path the instruction references
  3. never remove a path the verifier reads, unless relocated via oracle_to_tests
  4. a relocated oracle must actually be read from /tests/<basename>
  5. setup.sh must genuinely stop producing the leaked path
  6. byte/hash inequality is refused as the sole defence of a leak
  7. bash -n on every emitted script

There is deliberately no rule tying the repair action to the audited label. Three separate versions of such a rule rejected correct repairs β€” most notably 133 tasks labelled VERIFIER-TOO-WEAK that also shipped a readable oracle, where removing it and hardening the verifier was the right answer.

Reproducing

rl_data/verify/ on branch verify/tmax15k-rubric of the private tmax repo: repair.py (prompt + guards), fix_tasks.py (runner), export_repairs.py. Generated with openai/gpt-5-6-sol-genai-responses via MetaGen, one pass per task.

Downloads last month
3,210