Datasets:
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 |
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.acceptedmeans 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
- replacement verifier must still write
/logs/verifier/reward.txt - never remove a path the instruction references
- never remove a path the verifier reads, unless relocated via
oracle_to_tests - a relocated oracle must actually be read from
/tests/<basename> setup.shmust genuinely stop producing the leaked path- byte/hash inequality is refused as the sole defence of a leak
bash -non 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