tb-training-mix-agentpick

Selected by an agent re-rank, not by text similarity. For each of 89 Terminal-Bench 2.1 tasks, an agent ranked ten candidate training tasks drawn from 5 corpora together — TMAX, RST, SWE-Smith, SWE-Rebench and TerminalWorld — scoring every candidate on skill, domain, task_form and overall (integers, 1-5 across the file). 84 of the 89 lists mix corpora. Those scores belong to the selection and are not columns of this dataset. The re-rank used is the first version of the agent re-rank (v1, tb21_agentic_top10.csv at 4f8ec1af; a later v2 exists and is not used here); the copy this build read has sha256 2a018782bfb1a53a….

The 89 x 10 lists hold 778 distinct candidates (TMAX 496, RST 85, SWE-Smith 37, SWE-Rebench 61 and TerminalWorld 99); 85 of them sit in more than one list. metadata/split_assignment.tsv lists all 778. 511 are published here (TMAX 282, RST 60, SWE-Smith 37, SWE-Rebench 61 and TerminalWorld 71), split into what is ready to train on and what needs repair first (TerminalWorld rows are a benchmark's tasks and carry its canary: read TerminalWorld is a benchmark before treating them as training data); the other 267 are listed there with their reason but not shipped.

CalibForge ships in two splits of its own — calibforge_clean (402 rows) and calibforge_repair (225 rows), 627 in all — described in The CalibForge splits below; clean and repair hold no CalibForge row.

Terminal-Lego ships in two splits of its own — terminallego_clean (43 rows) and terminallego_repair (13 rows), 56 in all — described in The Terminal-Lego splits below.

Xiaomi MiMo ships in three splits of its own — xiaomi_clean (4 rows), xiaomi_repair (8 rows) and xiaomi_swe (20 rows), 32 in all — described in The Xiaomi MiMo splits below; the 24 opensource-code rows (the 20 of xiaomi_swe and 4 of xiaomi_repair) were not judged.

Correction (2026-10-03): the CPU of the solution replays

71 rows record more CPUs for their solution replay than the replay had. Their solution_replay_resources_json says cpu 2 or 4, but the replay sandbox ran with 1 vCPU. These are the rows whose solution is a replay of an attempt that ran in a larger sandbox (source_rung 2/2/2 (29), 4/4/4 (16), 4/8/10 (26)): calibforge_clean 36, calibforge_repair 15, xiaomi_swe 20. The replay driver recorded the CPU count of the attempt's sandbox but created the replay sandbox with a fixed single CPU. Memory and disk were applied as recorded.

The verdicts stand. Each of these solutions scored 1 on replay with fewer CPUs than recorded, and fewer CPUs can only make passing harder. Every other row is accurate: it records cpu 1, or carries the resources of a different run (the RST rows' oracle run), or has no replay. This commit changes only this card; no data file changes.

Splits

split	meaning	TMAX	RST	SWE-Smith	SWE-Rebench	TerminalWorld	total
clean	review-clean and a verified solution	173	22	37	59	50	341
repair	every other shipped row	109	38	0	2	21	170
(not shipped)	see below	214	25	0	0	28	267

clean — no blocking defect found AND a verified solution. TMAX and RST: tier SEED (verdict CLEAN) and a solution our own replay scored 1 -- for TMAX a replay of the solution's recorded action sequence, for RST our gate's oracle run of the package's reference solution; a reward published with the upstream row does not count. SWE-Smith and SWE-Rebench enter on their source datasets' curation and are not judged here: clean iff our gate's oracle run of the shipped solution scored 1 with the no-action run at 0. TerminalWorld enters on its judge's verdict: clean iff tier SEED (verdict CLEAN) and that same gate's oracle run scored 1 with the no-action run at 0.

repair — every other shipped row. TMAX and RST: FLAGGED rows whose verdict is not a leak (INSTR-VERIFIER-MISMATCH, UNSTABLE-REWARD), and SEED rows without a solution our replay verified. SWE-Smith and SWE-Rebench: rows whose shipped solution did not score 1 in our gate's oracle run. TerminalWorld: every judged row that is not a leak and not SEED with a gate-verified solution, UNSURE rows included.

Not shipped, by reason — every id is in metadata/split_assignment.tsv with its reason:

• kill 262 — excluded as a leak: verdict ANSWER-LEAK, on every corpus and whatever the solution
• pending 3 — not shipped because no verdict could be asserted not to be a leak: 1 row was never judged and 2 were judged UNSURE (verdict CLEAN, a deciding fact left open), all on TMAX and RST. TerminalWorld's UNSURE rows that are not leaks ship as repair instead; each corpus's rule is under How the TMAX and RST rows were classed and How the TerminalWorld rows were classed
• held_unmeasured 2 — TerminalWorld rows our gate could not measure; see How the TerminalWorld rows were classed

metadata/split_assignment.tsv lists all candidates with these columns beyond the parquet's:

column	meaning
split	clean, repair, or none (not shipped)
class	the class the rules gave the row: pass (tier SEED, or a source-curated row whose solution our gate verified), repair, kill (a leak), pending (never judged, or UNSURE on TMAX and RST), held_unmeasured. It is not the split: a TMAX or RST pass row without a solution our replay verified ships in repair
runtime_ok	1 if the runtime check the row's corpus uses succeeded: TMAX — a no-action run was measured and scored 0; RST — our gate's oracle run passed with no known obstacle; SWE-Smith, SWE-Rebench and TerminalWorld — our gate measured the row
best_rank	the best rank (1-10) the task reached in any TB2.1 task's re-ranked top 10
reason	why the row has its split, in plain words
blocking_fields	the judge's blocking defects (TMAX and RST; see Terms)
verdict_id … capped_turn	TerminalWorld's judge provenance; see How the TerminalWorld rows were classed

Loading

from datasets import load_dataset
ds = load_dataset("Fzz1/tb-training-mix-agentpick")   # public
ds["clean"], ds["repair"], ds["calibforge_clean"], ds["calibforge_repair"], ds["terminallego_clean"], ds["terminallego_repair"], ds["xiaomi_clean"], ds["xiaomi_repair"], ds["xiaomi_swe"]

Terms

Every judged task has a tier and a verdict:

• tier SEED — no blocking defect found; FLAGGED — a blocking defect found, with a reproduction; UNSURE — a deciding fact left open; NOT JUDGED — no judge ran.
• verdict CLEAN — no defect; ANSWER-LEAK — a reward is obtainable without doing the core work; INSTR-VERIFIER-MISMATCH — a correct solution can be refused, or the verifier checks what the instruction does not ask for; UNSTABLE-REWARD — the same solution can score differently.

The rubrics, in short. Each rubric (v13 for TMAX, v13-rst for RST, v13-harbor2 for TerminalWorld) has the judge read the task's instruction, its image build and its verifier — never its reference solution — and look for three kinds of blocking defect, which are the values of blocking_fields: a verifier that can refuse a correct solution or checks more than the instruction asks (overspecific_check); a reward reachable without the core work — the expected output revealed or derivable, or the checked state reachable directly (expectation_revealed, value_derivable, oracle_reachable); and a reward that varies between runs (unstable_reward). A task is SEED only if none is found. The rubric texts are not published; their sha256 digests identify them (see Where the tiers and verdicts came from).

Runs. The oracle run executes the package's own reference solution and grades it with the package's verifier; the no-action run submits nothing and must score 0. Our gate is the runtime check that performs both. Source curation: SWE-Smith and SWE-Rebench publish only tasks they verified, so their rows are not judged here.

How the TMAX and RST rows were classed

In this order: verdict ANSWER-LEAK → excluded as a leak (class kill); tier UNSURE, or never judged → not shipped (class pending: no verdict can be asserted not to be a leak); tier FLAGGED with any other verdict → repair (class repair); tier SEED (verdict CLEAN) → class pass, which ships in clean only if our own replay scored its solution 1 — for TMAX a replay of the solution's recorded action sequence (solution_phase begins replay), for RST our gate's oracle run of the reference solution — and otherwise in repair. A reward published with the upstream row does not count: 1 TMAX row of tier SEED (task_000802_aa7b130a) carries solution_replay_reward 1.0 that was published with the upstream row (solution_phase original_…), not measured by our replay, and so ships in repair. TerminalWorld treats an UNSURE row differently: see below.

How the TerminalWorld rows were classed

TerminalWorld enters on its judge's verdict under the v13-harbor2 rubric (tier_source v13_harbor_row:v2.1.1). In this order: verdict ANSWER-LEAK, at any tier → excluded as a leak (class kill), exactly as for TMAX and RST; a row our gate could not measure → held out; tier SEED (verdict CLEAN) and our gate's oracle run scored 1 with the no-action run at 0 → clean; every other judged row → repair: FLAGGED rows whose verdict is not a leak, SEED rows whose shipped solution scored 0 in our gate, and UNSURE rows. Two TerminalWorld rows are held for a reason that is not about the verdict: one declares two services in docker-compose, and this pipeline runs one container per task, so it was never launched; the other fails the package's own final RUN step on two independent builds. Both are in metadata/split_assignment.tsv with class held_unmeasured.

Rubric and judge. The v13-harbor2 rubric in its v2.1.1 revision (the TerminalWorld re-judge), run once per task by GLM-5.3 at reasoning effort low through a single inference provider (baidu, fp8, no fallbacks). The judge was not shown the reference solution.

Gate results. Our gate ran each TerminalWorld package's own solution/solve.sh (the oracle run) and a no-action run, and graded both with the package's verifier:

gate state	meaning	TerminalWorld candidates
clean	oracle 1, empty run 0	74
failed_on_merits	oracle 0, empty run 0	23
unmeasured	never launched or never built	2

tier	verdict	gate state	split (TSV class)	rows
SEED	CLEAN	clean	clean (class pass)	50
FLAGGED	INSTR-VERIFIER-MISMATCH	clean	repair (class repair)	2
FLAGGED	INSTR-VERIFIER-MISMATCH	failed_on_merits	repair (class repair)	2
SEED	CLEAN	failed_on_merits	repair (class repair)	15
UNSURE	CLEAN	clean	repair (class repair)	2
FLAGGED	ANSWER-LEAK	clean	not shipped (class kill)	19
FLAGGED	ANSWER-LEAK	failed_on_merits	not shipped (class kill)	6
UNSURE	ANSWER-LEAK	clean	not shipped (class kill)	1
SEED	CLEAN	unmeasured	not shipped (class held_unmeasured)	2

A failed_on_merits row is a statement about the shipped solution in our gate, not about the task: a judged non-leak row with it is repair, as a SEED row without a verified solution is for TMAX and RST.

Per-row judge provenance for TerminalWorld is in metadata/split_assignment.tsv, not in the parquet columns: verdict_id, verdict_set, rubric_version, the schema and prompt sha256 (verdict_schema_sha, verdict_prompt_sha), verdict_judge_model, verdict_provider and capped_turn (whether the judge reached its turn limit). They are empty on the other corpora's rows, except capped_turn, which reads False on the SWE-Smith and SWE-Rebench rows (not judged).

TerminalWorld is a benchmark, and its rows here carry its canary

Every TerminalWorld instruction here (71 of 71) contains the upstream's harbor-canary line, as do 62 dockerfile and 62 solution values: our instructions still contain it, because the packages ship byte-verbatim. TerminalWorld is a benchmark. The upstream's stated intended use is as synthesis seeds — tasks to derive harder tasks from — not as a training corpus, and a model trained on trajectories from these tasks is contaminated with respect to the TerminalWorld leaderboard. The upstream card's note of 2026-08-28 asks: "If you train on this data, remove it from what your model actually reads — the instruction and the problem statement — and leave it in the build and grading files, which no model sees."

The training-side converters at commit 393365fe do that. Run over this dataset's 71 TerminalWorld rows, the prompt they build contains the canary on 0, while the build and grading fields they carry keep it (dockerfile, tmax.fixtures.tests/test_state.py, tmax.test_sh); BUILD_RECORD.json (training_side_canary) has the counts per route. A consumer that reads instruction directly must strip the line itself. The TerminalWorld rows in clean are clean under this card's rules; that is not an endorsement of training on a benchmark.

How the SWE-Smith and SWE-Rebench rows were split

Both enter on source curation: each source dataset publishes only tasks it verified, so no judge is consulted and tier / verdict are empty (tier_source source_curation). Our gate ran the solution each package ships: clean iff that oracle run scored 1 with the no-action run at 0, otherwise repair.

A repair row from a gate-run source is a statement about a solution or a verdict, not about a task: it does not mean the task is unsolvable, low quality or broken.

The CalibForge splits: calibforge_clean and calibforge_repair

Why CalibForge has splits of its own. The re-rank that selected clean and repair (the first version) holds no CalibForge task. The CalibForge rows come from the training side's second version (results_v2), and they are not the whole corpus. The original 454 are the distinct CalibForge tasks of its mixed agentic top-10 (500 CalibForge slots) at AweAI-Team/CalibForge fb1e75441a94. The added ids are the ones its per-source CalibForge top-10 (890 slots, 766 distinct ids) lists beyond those (see below). They were judged under their own rubric revision (v13-harbor3), and their solutions are our agent's attempts rather than solutions the corpus ships. So their rows are kept out of clean and repair, which are byte-identical to the previous version, and ship in two splits of their own with the same 70 columns. Everything above this section, and the column tables below, describe clean and repair unless they name CalibForge.

split	what it holds	rows	class from V4.1-Flash	from GLM-5.3 alone	with a verified solution	security rows	of them from the 454 / added
calibforge_clean	tier SEED and a replay-verified solution	402	304	98	402	46	208 / 194
calibforge_repair	a repair verdict, or a task no attempt could solve (below)	225	123	102	99	16	149 / 76

The 454 and the added ids. The splits draw on two populations. The 454 tasks were judged first. The 312 ids the per-source CalibForge top-10 added were judged by V4.1-Flash alone (tier_source v13_harbor_row:cfn_v41max) and rolled out the same way. That top-10 lists the ten CalibForge tasks ranked best for each Terminal-Bench 2.1 task, within CalibForge, and the added ids' tb21_best_rank / tb21_neighbour_of come from it.

What calibforge_repair holds, and the rule for unsolved tasks. A judged task that is not a leak and that no attempt solved, after at least 3 attempts, goes to calibforge_repair with no solution; it is never held back. An attempt counts when the model made it and the verifier graded it: the first round counts once, and each second-round attempt counts once. By reason:

• 79 a repair verdict (FLAGGED of any kind, UNSURE): a judgement about the task, 61 of them with our verified attempt as the solution
• 101 no attempt produced a replay-verified solution in 4–6 attempts, so no solution
• 6 the verifier needs a test fixture the training loader does not carry (a verifier defect), so no attempt can score 1 here and there is no solution
• 1 attempts scored 1, but every replay of them was ungradeable, so there is no solution
• 38 moved from calibforge_clean because they reuse a TB2.1 task's test scaffold (see TB2.1 sibling tasks), with their verified solution

Not uploaded: 139 rows excluded as leaks (verdict ANSWER-LEAK; 42 of them added ids).

Two tasks whose first attempts never started. Every earlier attempt on these failed while the sandbox was being built, with 0 model turns. They were rolled again from a bare FROM of their pinned image, 3 attempts each, before this version was cut: system-administration_20260615_143956_008 ships in calibforge_clean; one security task ships in calibforge_clean.

Where the per-id details are. metadata/split_assignment_calibforge.tsv is authoritative for CalibForge. It lists all 766 ids with their split, class, tier, verdict and reason in plain words, and also cf_attempts, cf_tb21_sibling (with the check that found it), the security flag, cf_judge, cf_verdict_v41, cf_verdict_glm and the replay counts. It holds no task text. metadata/split_assignment.tsv still describes CalibForge as of the version with 240 / 51 rows. tier_source in the parquet names the judge of record: v13_harbor_row:cf_v41max or v13_harbor_row:cf_h3, and v13_harbor_row:cfn_v41max on the added ids.

98 of the 402 calibforge_clean rows rest on GLM-5.3 alone (no valid V4.1-Flash row); the calibration below is the evidence on how far that judge can be trusted here.

The classes were read from our rollout summaries as committed at 2026-09-30T19:30:37+00:00.

Canary markers

7 rows carry a benchmark canary marker; kept by decision. The markers are in environment files the generator copied from a Terminal-Bench task, and in one row also in its solution.

TB2.1 sibling tasks

49 CalibForge tasks reuse part of a Terminal-Bench 2.1 task's test scaffold: existence and dependency checks, helpers and fragments, never its grading logic. Our 13-gram check over the shipped rows found 42, and the check over the full upstream corpus added the 7 rows the 3-attempt rule moves in. Those in calibforge_clean were moved to calibforge_repair with their verified solution; the others were there already. metadata/split_assignment_calibforge.tsv marks each of them in cf_tb21_sibling, with the check that found it. The ids:

49 TB2.1 sibling ids

• data-processing_20260415_002933_002 (section A)
• data-processing_20260614_141608_002 (section A)
• data-science_20260603_181444_004 (section A)
• data-science_20260604_002443_007 (section B, full upstream)
• data-science_20260604_194036_007 (section A)
• data-science_20260606_172606_007 (section A)
• data-science_20260610_111012_007 (section A)
• data-science_20260615_143956_003 (section A)
• data-science_20260617_104707_007 (section B, full upstream)
• debugging_20260415_182321_002 (section A)
• debugging_20260416_031414_002 (section A)
• debugging_20260421_155939_002 (section A)
• debugging_20260610_111702_001 (section A)
• debugging_20260614_141608_003 (section A)
• file-operations_20260604_004411_001 (section A)
• machine-learning_20260425_072438_002 (section A)
• machine-learning_20260504_125558_002 (section A)
• machine-learning_20260509_065529_002 (section A)
• machine-learning_20260510_062946_002 (section A)
• machine-learning_20260601_053159_002 (section A)
• machine-learning_20260604_003113_002 (section B, full upstream)
• mathematics_20260508_204815_003 (section B, full upstream)
• optimization_20260612_191200_001 (section A)
• optimization_20260615_143301_001 (section A)
• optimization_20260618_093107_001 (section A)
• personal-assistant_20260415_182321_001 (section A)
• scientific-computing_20260413_174325_001 (section A)
• scientific-computing_20260415_123352_007 (section A)
• scientific-computing_20260419_065313_007 (section A)
• scientific-computing_20260421_155939_001 (section B, full upstream)
• scientific-computing_20260503_030115_001 (section A)
• scientific-computing_20260503_182123_007 (section A)
• software-engineering_20260414_091921_001 (section A)
• software-engineering_20260415_123352_001 (section A)
• software-engineering_20260419_112101_026 (section A)
• software-engineering_20260420_020307_001 (section A)
• software-engineering_20260501_172213_011 (section A)
• software-engineering_20260501_172213_019 (section A)
• software-engineering_20260503_030115_015 (section A)
• software-engineering_20260507_172207_003 (section A)
• software-engineering_20260508_045800_026 (section A)
• software-engineering_20260511_015840_004 (section A)
• software-engineering_20260602_105139_026 (section A)
• software-engineering_20260604_003814_015 (section A)
• software-engineering_20260606_172554_015 (section A)
• software-engineering_20260617_104707_025 (section B, full upstream)
• video-processing_20260419_065313_001 (section A)
• video-processing_20260429_103257_001 (section A)
• video-processing_20260508_045920_001 (section B, full upstream)

Who judged CalibForge

The judge of record is DeepSeek V4.1-Flash at reasoning effort max, served through the huanzhimao API gateway; GLM-5.3 at reasoning effort low (provider baidu, fp8, a single provider with no fallbacks) decides a row only where no valid V4.1-Flash row exists. cf_judge names the one each row's class came from (v41max or glm53low), and cf_verdict_v41 / cf_verdict_glm carry both verdicts as TIER/VERDICT, so a disagreement stays visible. Both judged under the same v13-harbor3 rubric (the v13-harbor2 rubric's CalibForge revision) and never saw a solution.

Calibration. On a domain-stratified sample, V4.1-Flash and GLM-5.3 agreed on tier and verdict for 36 of 43 rows. An Opus 5.5 reviewer adjudicated the 7 disagreements: V4.1-Flash was right on 5 and GLM-5.3 on 2; five were GLM-5.3 model errors, three of them missed instruction/verifier mismatches, and two were gaps in the rubric's prompt. On the larger overlap when the V4.1-Flash run was stopped, the two agreed on 152 of 176 rows (86.4 %). The 11 disagreements where GLM-5.3 said clean with a verified solution and V4.1-Flash did not were adjudicated the same way: the correct verdict was not clean on 10 of 11; GLM-5.3 was wrong on 10 (model errors) and V4.1-Flash on 1 (a prompt gap), and on 2 of them V4.1-Flash's UNSURE was, on adjudication, an ANSWER-LEAK. These calibrate the judges against each other, not against ground truth.

How the CalibForge rows were classed

In this order: no valid judge row → held; verdict ANSWER-LEAK → excluded as a leak (class kill), as for every corpus; any other tier that is not SEED (FLAGGED of any kind, UNSURE) → repair, because that is a judgement about the task and must not depend on whether a model happened to solve it; SEED with a verified solution → clean; SEED without one → held (class held_no_verified_solution, with the reason in plain words in the split file).

The solution is our agent's attempt. CalibForge ships no solution. Our agent attempted each task in up to two rounds (solution_phase cf_pass1_rollout or cf_pass2_rollout, or cf_dry_run_rollout for the trial round; solution_model and solution_reasoning_effort name the model), and an attempt that scored 1 was then replayed from its recorded actions (+ gate2_replay). A task's solution is that attempt's action list (terminus_tmux_actions_v1), rebuilt the way the replay rebuilt it; its sha256 equals the replay's actions_sha256. A solution counts as verified when a strict majority of its graded replays scored 1 (solution_replay_reward1_n of solution_replay_graded_n). solution_marker_transformed marks the sequences the replay ran with the actions between the last two completion markers dropped, because the recorded form ended in two markers with work between them; the shipped sequence is that transformed one.

14 of the 454 and 20 of the added packages ran from a one-line Dockerfile, and the 30 of them shipped here carry it (FROM aweaiteam/calibforge@<digest>, dockerfile_repaired = true): the training loader refuses their own Dockerfile (a copied build context over 1 MiB, a binary fixture, or a missing copy source), so the attempt ran the pinned prebuilt image, and the package ships what ran.

CalibForge rows in the columns

• corpus calibforge; source_dataset AweAI-Team/CalibForge; rubric v13-harbor3.
• instruction is the package's own; solution is our verified attempt as a terminus_tmux_actions_v1 action list, empty on a calibforge_repair row without one (has_reference_solution false); dockerfile is the package's, or the one-line FROM the attempt ran.
• validation_status / reward_verdict are empty (named in column_gaps): the replay result is in solution_replay_reward and, per replay, in the split file's k/n columns.
• req_cpus / req_memory_mb / est_disk_mb are the sandbox the attempt actually ran in; runtime_peak_* are that attempt's measured peaks.
• dockerfile_repaired is true on the 30 rows that ship the one-line FROM.
• Security rows (46 in calibforge_clean, 16 in calibforge_repair) carry their flags, as in the other splits.

CalibForge through the training-side converters

The training-side converter check was not run on this version. The converters' code (the training side at commit 393365fe) was not available where this version was built. The previous version's 291 CalibForge rows passed both routes with 0 refusals, but the rows added here have not been through them. Neither converter is tied to the names clean / repair: data_release takes one source per split by path, e.g.

{"name": "agentpick-calibforge-clean", "repo": "Fzz1/tb-training-mix-agentpick",
 "revision": "<this commit>", "adapter": "tmax_reaudit",
 "metadata": "data/calibforge_clean.parquet", "archives": ["data/tasks-calibforge_clean.tar"],
 "count": null}

(and the same with calibforge_repair), and build_mix_rebench_tmax takes --tmax-parquet data/<split>.parquet with --tmax-tasks pointing at that split's extracted tar.

CalibForge caveats

1. The two judges were calibrated against each other, not against ground truth, and most rows were judged by one of them only.
2. A CalibForge solution is one agent attempt that scored 1 and whose replays confirmed it; it is a solution, not a reference, and a task may have others.
3. The license is unresolved as found (see License and provenance).
4. 126 calibforge_repair rows have no solution (has_reference_solution false; the reasons are under What calibforge_repair holds). Treat them as tasks to repair, not as tasks known to be solvable.

The Terminal-Lego splits: terminallego_clean and terminallego_repair

What they are. The Terminal-Lego candidates of the second version of the agent re-rank (results_v2, which lists Terminal-Lego among its sources; the first version, which selected clean and repair, did not): 91 tasks of Lego-X/Terminal-Lego-15k at 9c197f1c2e87. They ship in two splits of their own with the same 70 columns, so clean and repair are unchanged.

split	what it holds	rows	security rows
terminallego_clean	tier SEED (verdict CLEAN) and its own solution scored 1 in our gate	43	1
terminallego_repair	a repair verdict (INSTR-VERIFIER-MISMATCH, UNSTABLE-REWARD); its own solution scored 1	13	0

Not uploaded: 33 rows excluded as leaks (verdict ANSWER-LEAK) and 2 rows whose own reference solution did not score 1 in our gate. metadata/split_assignment.tsv and metadata/BUILD_RECORD.json describe the four splits above and hold no Terminal-Lego id.

Judge. DeepSeek V4.1-Flash at reasoning effort max, served through the huanzhimao API gateway, under the Terminal-Lego revision of the v13-harbor3 rubric (tier_source v13_harbor_row:tl_v41max); it read the instruction, image build and verifier, never the solution. A second review of the rows it shared with an earlier judgment changed no verdict. There is no second judge, and its error rate on Terminal-Lego is unmeasured.

Classing. In this order: verdict ANSWER-LEAK → excluded as a leak; the package's own solution did not score 1 in our gate (or the no-action run did not score 0) → held; tier SEED, verdict CLEAN → terminallego_clean; verdict INSTR-VERIFIER-MISMATCH or UNSTABLE-REWARD → terminallego_repair, as for CalibForge.

The solution is the upstream reference solution. Terminal-Lego ships solution/solve.sh; solution holds it, byte for byte the one our gate's oracle run executed (solution_format harbor_solve_sh, solution_phase upstream_reference + results_v2_gate_oracle_arm, solution_actions_sha256 its sha256). No agent rollout was needed.

Peaks come from that reference-solution run, not from an agent rollout. runtime_peak_ram_mb and runtime_cpu_seconds are the oracle run's; its bytes written (peak_written_mb) and environment-inclusive disk (disk_env_mb) are in solution_replay_resources_json, and runtime_peak_disk_mb is empty, as for the other gate-run corpora. req_cpus / req_memory_mb / est_disk_mb are the sandbox the oracle run was given (runtime_sandbox_size); an agent solving the task may need more.

Packages. As staged for our gate from the pinned revision, every file checked against the fetch manifest. Git does not keep empty directories, so packages whose Dockerfile copies an empty environment/task_file/ carry a 0-byte environment/task_file/.gitkeep, the same convention two upstream packages already use.

Through the training-side converters at commit 393365fe: data_release (adapter tmax_reaudit) converts 56/56 and build_mix_rebench_tmax.tmax_rows 56/56 (all sized), 0 refusals; prepare_source completes on terminallego_clean 43, terminallego_repair 13 rows. Select a split as for CalibForge, e.g. "metadata": "data/terminallego_clean.parquet", "archives": ["data/tasks-terminallego_clean.tar"].

The Xiaomi MiMo splits: xiaomi_clean, xiaomi_repair and xiaomi_swe

What they are. The training side's top-10 selection for Terminal-Bench 2.1 (selection/top10_tb21.parquet of the training side's mix repository at revision 42a64ce7, sha256 d67338709746a868…) holds 34 rows from XiaomiMiMo/MiMo-V2.6-RL-oss (revision 639865fd3374). They cover 32 distinct tasks: 8 terminal_bench tasks (9 rows) and 24 opensource-code tasks (25 rows). All 32 ship, in three splits of their own with the same 70 columns, and corpus is MiMo-V2.6-RL-oss. tb21_best_rank and tb21_neighbour_of come from that selection.

split	what it holds	rows	with a verified solution	security rows
xiaomi_clean	terminal_bench tasks of tier SEED (verdict CLEAN) and a replay-verified solution	4	4	1
xiaomi_repair	terminal_bench tasks with verdict INSTR-VERIFIER-MISMATCH (tier FLAGGED), and the opensource-code tasks without a verified solution	8	1	0
xiaomi_swe	the opensource-code tasks with a replay-verified solution, not judged	20	20	0

Judge, for the terminal_bench rows only. The judge was DeepSeek V4.1-Flash at reasoning effort max, served through the huanzhimao API gateway. It ran under the v13-harbor4xm rubric, written for these Xiaomi packages (prompt c3bd0274; tier_source is v13_harbor_row:xm_h4). It wrote 8 valid rows out of 8: 4 SEED CLEAN and 4 FLAGGED INSTR-VERIFIER-MISMATCH. There is no second judge, and its error rate on these tasks is unmeasured.

The opensource-code rows were not judged. On these rows tier and verdict are empty, rubric is not-judged and tier_source is not_judged. They ship on rollout and replay alone. Nothing here asserts that they are free of instruction/verifier mismatches or answer leaks.

The solutions are our agent's attempts, because Xiaomi ships none. Attempts ran on DeepSeek Flash through the gateway: pass 1 at effort high, then up to 3 pass-2 attempts at effort max for each task that had no reward 1. The sandbox network was off for every attempt and every replay; the tasks declare no internet access.

A row's solution is the actions of its counted reward-1 attempt, in the format terminus_tmux_actions_v1. These are byte for byte the sequence whose deciding replay graded 1.0, and solution_actions_sha256 is their digest. Every counted attempt was replayed, and no replay scored 0. On format-code-task-001132 the solution is the marker-transformed arm, and solution_phase says so.

Seven rows ship without a solution: has_reference_solution is false, and column_gaps gives the reason.

• In xiaomi_repair, candidate-0758 and candidate-2760 scored reward 0 on all 4 attempts, and candidate-1824 was not rolled out (below).
• Also in xiaomi_repair, the opensource-code tasks 000520, 001243, 001333 and 002755 scored reward 0 on all 4 attempts. They are there because they have no solution, not because of a verdict: like every opensource-code row, they were not judged.

candidate-1824 cannot score 1 in its image as shipped. Before this release, Xiaomi's 64 terminal_bench packages were run against their own images. 15 of the 64 cannot pass as shipped: 14 need a dependency the image lacks, and 1 is missing a task file. Those 15 are hard exclusions of that review. One of the 8 tasks here is among them: candidate-1824, whose verifier needs node, which its image does not have. It was judged (FLAGGED) and not rolled out, and it ships in xiaomi_repair with no solution.

Environment. Each row's dockerfile is the one its attempts ran, and the package ships it as environment/Dockerfile. It is FROM docker.io/xiaomimimo/mimo-v2.6-rl-oss@<digest> (the digest task.toml pins), followed by the harness's tmux block. No build context is needed, because the image already holds the task.

• On the opensource-code rows, the Dockerfile also runs Xiaomi's own history strip (_strip_future_commits). The build fails unless no commit outside the base remains, reflogs included. It then saves the grading state under /opt/xm_grade/, which protected_paths pins.
• candidate-1824's Dockerfile is built the same way.
• dockerfile_repaired is true on all 32 rows: the shipped Dockerfile is not one of Xiaomi's package files.

Grading.

• terminal_bench rows use Xiaomi's own tests/test.sh, which writes /logs/verifier/reward.txt.
• opensource-code rows use our tests/test.sh, shipped in the package together with tests/test.patch, which is Xiaomi's test_patch.diff byte for byte. It restores the saved git configuration, resets the paths the test patch touches, applies the patch, and runs Xiaomi's test_command with a 1800 s timeout. The reward is 1 when that command exits with status 0.
• Before any attempt, a probe on all 24 opensource-code tasks found that an empty submission scores 0 (runtime_empty_run).

Sizing and peaks.

• req_cpus, req_memory_mb and est_disk_mb are the sandbox the counted attempt ran in (runtime_sandbox_size). For a row without a solution they are the sandbox of its last pass-1 attempt (terminal_bench) or of its largest top-size attempt (opensource-code). candidate-1824 takes its task.toml declaration.
• The peaks are the agent attempt's (runtime_peak_source).
• 000126, 000726 and 000786 carry no peak. Their disk reading reached the 10 GB ceiling of the top sandbox size (13.1–14.9 GB measured), so it is only a lower bound.

Packages. Each package holds Xiaomi's files, each checked against the package's MANIFEST.tsv, which also ships.

• terminal_bench: instruction.md, task.toml, tests/ (Xiaomi's test bundle), environment/app/ (the image's /app, extracted from the pinned image), environment/IMAGE.txt and environment/CHECKS.json.
• opensource-code: instruction.md, task.toml (derived from the row's instance_json), test_patch.diff, test_command.txt and IMAGE.txt. In IMAGE.txt an internal name was removed from the digest cross-check line, and the line for IMAGE.txt in MANIFEST.tsv reads redacted with the shipped bytes' sha256.
• Every package also ships the environment/Dockerfile that ran, and the opensource-code packages also ship tests/test.sh and tests/test.patch.

Not in metadata/. metadata/split_assignment.tsv and metadata/BUILD_RECORD.json describe the splits above and hold no Xiaomi id.

Checks before upload.

• Every file of these splits scans clean: the extended leak scan (keys, host paths, identifiers) found 0 hits.
• A canary scan also found 0 hits. It looks for the three benchmark canary markers (the canary GUID, the harbor canary tag and the benchmark-data notice) in every parquet cell and every tar member.
• The training-side converters were not re-run for these splits.

Cost. Gateway estimates at DeepSeek's list price:

• judge: about $4.77 (30.2M tokens);
• terminal_bench rollouts: about $1.06 (4.4M tokens);
• opensource-code rollouts: about $62.31 (320.6M tokens).

Task packages

The task packages are not part of the loadable config — they ship as one tar per split, data/tasks-clean.tar, data/tasks-repair.tar, data/tasks-calibforge_clean.tar, data/tasks-calibforge_repair.tar, data/tasks-terminallego_clean.tar, data/tasks-terminallego_repair.tar, data/tasks-xiaomi_clean.tar, data/tasks-xiaomi_repair.tar and data/tasks-xiaomi_swe.tar, with members at tasks/<task_id>/... (member_prefix in the table). Both tars are reproducible: sorted members, regular files only, mode 0664, mtime 0, uid/gid 0, empty owner names, so a rebuild is byte-identical.

A package holds only the task itself. Top-level members, as packed:

• TMAX: environment/**, instruction.md, setup.sh, tests/**
• RST: environment/**, instruction.md, solution/**, task.toml, tests/**
• SWE-Smith: environment/**, instruction.md, seed.json, solution/**, task.toml, tests/**
• SWE-Rebench: environment/**, instruction.md, seed.json, solution/**, task.toml, tests/**
• TerminalWorld: environment/**, instruction.md, solution/**, task.toml, tests/**
• CalibForge: environment/**, instruction.md, task.toml, tests/**
• Terminal-Lego: environment/**, instruction.md, solution/**, task.toml, tests/**
• Xiaomi MiMo, terminal_bench (xiaomi_clean, and 4 rows of xiaomi_repair): environment/**, instruction.md, MANIFEST.tsv, task.toml, tests/**
• Xiaomi MiMo, opensource-code (xiaomi_swe, and 4 rows of xiaomi_repair): environment/Dockerfile, IMAGE.txt, instruction.md, MANIFEST.tsv, task.toml, test_command.txt, test_patch.diff, tests/**

RST's generator files (rewrite_*.json, generation_quality_filter.json, static_preflight_*.json) are not included. TMAX runs from a prebuilt image, named in the image column.

Training-side consumption

The dataset is built to be converted as published by the training side's converters at commit 393365fe: evolution/data_release.py with adapter tmax_reaudit, one source per split (data/<split>.parquet + data/tasks-<split>.tar), and build_mix_rebench_tmax.tmax_rows. Three things make that work, and each is recorded per row in BUILD_RECORD.json (training_consumable):

1. shard names this dataset's tar (data/tasks-<split>.tar) on every row.
2. Every TMAX package carries environment/Dockerfile, byte-exact from the dockerfile column. The converter builds each row from the package and refuses one without a Dockerfile; the TMAX Dockerfiles copy nothing in, so no build context is needed. task_content_sha256 and the counts cover the package as shipped.
3. req_cpus / req_memory_mb / est_disk_mb are set on every row, from peaks already measured -- nothing was re-measured. The RST task.toml declaration and the published TMAX values are kept. Every other row takes, per dimension, the maximum of the sources available -- our newest measured peak, the solution replay's own peak (where it marked it usable and unclamped), and the upstream dataset's published peak -- because these numbers size the trainer's agent rollouts, and our oracle replays use far less than an agent does (the upstream figures are agent rollouts). Where none exists the default is 2 GiB. The result is rounded up to the sandbox sizes our runs used (1 / 2 / 4 / 8 GiB), capped at the platform's 8 GiB RAM / 10 GiB disk, and raised to the sandbox size the replay ran in, where recorded. BUILD_RECORD.json names the winning source per row, every other value available for it, and the rows where sources disagree. These are allocations, not declared requirements. Our disk figure for SWE-Smith and SWE-Rebench is environment-inclusive, so a few rows exceed the 10 GiB cap and are allocated the cap, named in req_capped_below_measurement.

Proven on these bytes, by running the training side's own converters at 393365fe (their modules verified byte-identical to that commit) over this dataset's parquets and tars:

route	TMAX	RST	SWE-Smith	SWE-Rebench	TerminalWorld	refusals
data_release, adapter tmax_reaudit	282/282	60/60	37/37	61/61	71/71	0
build_mix_rebench_tmax.tmax_rows	282/282	60/60	37/37	61/61	71/71	0

data_release's prepare_source completes on both splits (clean 341, repair 170 rows), every row sized. prepare_tmax_reaudit_data refuses this dataset by design: RefuseError: split must reference the supported shard data/tasks-reaudit-00000.tar — that converter accepts only Fzz1/Tmax-Tasks-Clean's reaudit tar.

Columns

Columns 1-40 are exactly those of Fzz1/Tmax-Tasks-Clean (revision bb6cf8fd646d), config longlongcheck (that dataset's full-column configuration) — same names, same order, same arrow types, compared field by field against that parquet at build time. Our audit columns are appended after them; there are 70 in all. Where a value genuinely does not exist for a row, strings are "" and numbers are null, and the row names the column in column_gaps with a reason; column_gaps is derived from what is actually empty, so it cannot drift.

Filled rows per column

n of the 282 TMAX, 60 RST, 37 SWE-Smith, 61 SWE-Rebench and 71 TerminalWorld rows that carry a real value (a non-empty string, a non-null number, or a non-empty list). Booleans always count as filled — false is a value.

#	column	TMAX	RST	SWE-Smith	SWE-Rebench	TerminalWorld
1	task_id	282	60	37	61	71
2	task_group_id	282	60	37	61	71
3	task_content_sha256	282	60	37	61	71
4	validation_status	282	60	0	0	0
5	instruction	282	60	37	61	71
6	solution	196	60	37	61	71
7	dockerfile	282	60	37	61	71
8	member_prefix	282	60	37	61	71
9	file_count	282	60	37	61	71
10	archive_entry_count	282	60	37	61	71
11	uncompressed_bytes	282	60	37	61	71
12	shard	282	60	37	61	71
13	terminal_domain	21	58	0	0	0
14	tw_source_type	282	60	0	0	0
15	req_cpus	282	60	37	61	71
16	req_memory_mb	282	60	37	61	71
17	base_image	0	60	0	0	0
18	est_disk_mb	282	60	37	61	71
19	verdict_flipped	282	60	37	61	71
20	reward_verdict	282	60	0	0	0
21	reference_partial	282	60	37	61	71
22	dockerfile_repaired	282	60	37	61	71
23	pre_test_sh	10	0	0	0	0
24	pre_test_env_identity	10	0	0	0	0
25	protected_paths	282	60	37	61	71
26	protected_cmds	282	60	37	61	71
27	corpus_revision	282	60	0	0	71
28	solution_format	196	60	0	0	0
29	solution_model	196	0	0	0	0
30	solution_reasoning_effort	196	0	0	0	0
31	solution_episode_id	196	59	0	0	0
32	solution_phase	196	60	0	0	0
33	solution_replay_reward	196	59	37	61	71
34	solution_actions_sha256	196	60	0	0	0
35	solution_terminal_action_count	196	60	0	0	0
36	solution_replay_resources_json	196	60	0	0	0
37	solution_is_normalized_shell	282	60	37	61	71
38	prepared_row_json	196	59	0	0	0
39	repair_selection	282	60	37	61	71
40	whole_task_certified	282	60	37	61	71
41	corpus (ours)	282	60	37	61	71
42	split (ours)	282	60	37	61	71
43	source_dataset (ours)	282	60	37	61	71
44	security (ours)	282	60	37	61	71
45	rubric (ours)	282	60	37	61	71
46	tier (ours)	282	60	0	0	71
47	tier_source (ours)	282	60	37	61	71
48	verdict (ours)	282	60	0	0	71
49	verdict_source (ours)	282	60	37	61	71
50	blocking_fields (ours)	73	36	0	0	0
51	note_fields (ours)	12	47	0	0	0
52	repair_hint (ours)	0	4	0	0	0
53	v13_pin_candidates (ours)	282	60	37	61	71
54	tb21_best_rank (ours)	282	60	37	61	71
55	tb21_neighbour_of (ours)	282	60	37	61	71
56	runtime_empty_run (ours)	282	17	37	61	71
57	runtime_peak_ram_mb (ours)	40	57	37	61	71
58	runtime_peak_disk_mb (ours)	40	57	0	0	0
59	runtime_cpu_seconds (ours)	0	57	37	61	71
60	runtime_sandbox_size (ours)	22	60	0	0	0
61	rst_oracle (ours)	0	59	0	0	0
62	rst_training_class (ours)	0	60	0	0	0
63	rst_pool (ours)	0	60	0	0	0
64	rst_category (ours)	0	58	0	0	0
65	runtime_peak_source (ours)	40	60	37	61	71
66	runtime_empty_run_sandbox (ours)	275	59	0	0	0
67	image (ours)	282	0	0	0	0
68	tmax_domain (ours)	282	0	0	0	0
69	has_reference_solution (ours)	282	60	37	61	71
70	column_gaps (ours)	282	60	37	61	71

What the columns mean

Columns 1-40 keep their longlongcheck meaning. Where this dataset fills them, the source is:

column	TMAX	RST	SWE-Smith / SWE-Rebench / TerminalWorld
task_group_id	the task id (TMAX publishes no groups)	the upstream corpus's own rts_group_* id	the task id (no groups)
task_content_sha256	sha256 over the package's sorted members of relpath + NUL + content + NUL	sha256 over the package's sorted members of relpath + NUL + content + NUL	sha256 over the package's sorted members of relpath + NUL + content + NUL
validation_status / reward_verdict	EMPTY_RUN_0_NO_REFERENCE_RUN / EMPTY_RUN_0 (261 rows) — an empty run scored 0 — longlongcheck's label from before a solution existed; the current solution evidence is solution_replay_reward and solution_phase; GPT6_SAVED_CURRENT_REPLAY_PASS / SAVED_CURRENT_GPT6_REPLAY_PASS (21 rows) — the label published with the upstream row: a saved solution replayed to pass	RST_GATE_ORACLE_1_EMPTY_0 / ORACLE_1_EMPTY_0 (57 rows) — our gate scored the reference solution 1 and an empty run 0; RST_GATE_ORACLE_0 / ORACLE_0 (2 rows) — our gate's oracle run scored 0; RST_NOT_GATED / NOT_GATED (1 row) — not run by our gate	"", named in column_gaps; the gate's result is in solution_replay_reward and runtime_empty_run
instruction, solution, dockerfile	the package's own bytes	the package's own instruction.md, solution/solve.sh, environment/Dockerfile	the package's own instruction.md and solution/solve.sh; dockerfile is the one the gate built the task from
file_count, archive_entry_count, uncompressed_bytes, member_prefix, shard	of the package as shipped in our tar (not upstream's)	of the package as shipped in our tar (not upstream's)	of the package as shipped in our tar (not upstream's)
terminal_domain	the Terminal-Bench 2 domain name when one exists	tb21_domain_v2, but only when it is one of the 14 domain names longlongcheck uses; otherwise "" and the fact is kept in rst_category	"", named in column_gaps
tw_source_type	tmax_open_instruct	rst_recursive_task_synthesis	"", named in column_gaps — the column is longlongcheck's source-type label; its name does not refer to TerminalWorld
req_cpus, req_memory_mb, est_disk_mb	the published corpus value where one exists; otherwise the training side's sizing policy (see Training-side consumption)	the corpus's declared requirement from task.toml [environment]	the training side's sizing policy (see Training-side consumption)
base_image	"", as in longlongcheck	the Dockerfile's last FROM	"", named in column_gaps
dockerfile_repaired	false	true for the 3 rows whose Dockerfile was re-pinned to snapshot.debian.org because its Debian release is out of support (Debian 10 (buster), Debian 11 (bullseye); see Caveats)	false
protected_paths, protected_cmds	[] except where a published pretest pin exists; our audit's pin candidates are unvalidated and live in v13_pin_candidates	[] except where a published pretest pin exists; our audit's pin candidates are unvalidated and live in v13_pin_candidates	[] except where a published pretest pin exists; our audit's pin candidates are unvalidated and live in v13_pin_candidates
solution_* (28-37)	describe the solution in column 6; solution_phase names where it was verified: our replays (replay…) or the value published with the upstream row (original…)	the reference solve.sh: solution_replay_reward the gate's oracle reward, solution_replay_resources_json the gate run's sandbox size and measured peaks	solution_replay_reward is the gate's oracle-replay reward of the shipped solve.sh; the other solution_* columns are empty, named in column_gaps
prepared_row_json	the trainer-ready row when one can be produced	the row from the shipped mix	"", named in column_gaps

Appended audit columns:

column	meaning
corpus, split	rst, swe_rebench, swe_smith, terminalworld, tmax; clean, repair
source_dataset	the source each row came from — TMAX allenai/tmax-15k-open-instruct; RST Zhongzhi1228/Recursive-Task-Synthesis; SWE-Smith SWE-Smith-Seeds-Clean; SWE-Rebench SWE-Rebench-Tasks-Clean; TerminalWorld TerminalWorld-Seeds-Clean
security	security / CTF-shaped; its judgment row was never opened
rubric, tier, tier_source	the audit rubric (TMAX v13; RST v13-rst; SWE-Smith source-curated; SWE-Rebench source-curated; TerminalWorld v13-harbor2), the tier it produced (empty where no judge ran), and where the tier came from — see the table below
verdict, verdict_source	the verdict that decided the tier, and where it came from — see the table below
blocking_fields, note_fields	what blocked the task (see Terms), and non-blocking observations. Filled from TMAX and RST judgment rows only — blocking_fields on RST 36 and TMAX 73 rows, note_fields on RST 47 and TMAX 12; TerminalWorld's judgment fields are not carried here
repair_hint	the judge's overspecific_check finding, where the judgment row wrote one: filled on RST 4 rows
v13_pin_candidates	JSON list from the judgment row's protected_paths. Candidates, not decisions — unvalidated, which is why they are not in protected_paths
tb21_best_rank, tb21_neighbour_of	the task's best rank (1-10) in the agent re-rank, and every TB2.1 task whose re-ranked top-10 contains it
runtime_empty_run	outcome of a no-action run (must be reward 0)
runtime_peak_ram_mb, runtime_peak_disk_mb, runtime_cpu_seconds, runtime_sandbox_size	measured peaks and the box that run was given; null when never measured
runtime_peak_source	which campaign produced the peaks — they are not one instrument. TMAX: (none) 242, campaign_20260902_legacy641 6, solve_gate_20260902_gate2_max_of_3_attempts 12 and terminus_20260907 22; RST: gated_but_not_measured 2, not_gated 1, rst_gate_oracle_arm:gate 22 and rst_gate_oracle_arm:gate_easy 35; SWE-Smith: gate197_oracle_arm (our gate's oracle run) 37; SWE-Rebench: gate197_oracle_arm 61; TerminalWorld: gate197_oracle_arm 71
runtime_empty_run_sandbox	the box the empty run was given. Recorded so the fact is not lost, but it is not a requirement: nothing ran in it
rst_oracle, rst_training_class, rst_pool, rst_category	RST only
image	TMAX only: the prebuilt container image
has_reference_solution	whether the package ships one
column_gaps	JSON list naming every column 1-40 this row could not fill, each with a reason

Where the tiers and verdicts came from

413 of the 511 rows (TMAX, RST and TerminalWorld) carry a judge's tier: a judge saw the task's instruction, image build and verifier (never its reference solution) under a frozen rubric, and returned a structured row — a tier, a verdict, blocking fields and notes. The rubric texts are not published; these digests identify them — v13 96fbc03bc81ab876…, v13-rst d905473d86f51b3a…; TerminalWorld (v13-harbor2, revision v2.1.1): schema 0d37ee14631bc41531df0af8b15e29d387a33c95e80d713a73fd5cb3d2b439ad, prompt ac3dde0e54c079bfa9ce81635cc0c45960b603f97dd6781c6180de5574db7739. The other 98 rows entered on source curation and carry no tier or verdict at all.

tier_source	rows	what it means
glm_low_agentic	269	judged once, by glm-5.3 at low effort, in the judging run over this re-rank
source_curation	98	SWE-Smith / SWE-Rebench: not judged; the row entered on its source dataset's curation, and our gate decided only clean-vs-repair
tfidf_top10	13	judged in an earlier run over a different candidate population that also held this id; that verdict is reused (see below)
v13_harbor_row:v2.1.1	71	TerminalWorld: the v13-harbor2 judgment row of the v2.1.1 re-judge (the rubric's v2.1.1 revision; schema and prompt digests above)
v13rst_row:agentic_top10	43	RST: the glm-5.3-low v13-rst judgment row from the run over this re-rank
v13rst_row:top10_glm	11	RST: the glm-5.3-low v13-rst judgment row from an earlier top-10 run
v13rst_row:top10_rst_smoke	1	RST: the judgment row from the earlier v13-rst smoke run
v13rst_row:top3	5	RST: the glm-5.3-low v13-rst judgment row from an earlier top-3 run

verdict_source	rows	what it means
glm_low_agentic	312	the one glm-5.3-low verdict from the judging run over this re-rank
tfidf_top10	25	reused from an earlier judging run over a different population (see below)
top3_final	5	two judges; where they disagreed, the adjudicator's verdict
unavailable	98	no v13 verdict exists for this row: it entered on source curation
v13_harbor_row:v2.1.1	71	TerminalWorld: the verdict of the v13-harbor judgment row named in tier_source

25 verdicts (13 TMAX and 12 RST) were reused from an earlier judging run over a TF-IDF-selected population, which had already judged these ids; they carry verdict_source tfidf_top10, and the 13 TMAX ones tier_source tfidf_top10 as well. That is where a verdict came from, not how a row was selected: every row here was selected by the re-rank.

Runtime facts (runtime_empty_run, rst_oracle, rst_training_class, and the gate's replay reward on SWE-Smith, SWE-Rebench and TerminalWorld) come from runtime gates, not from a judge.

Caveats — read these before training on the clean split

1. Most tiers rest on ONE judge. Only 5 of the 413 judged rows here were judged twice and adjudicated (verdict_source top3_final). Everything else is a single judge call; tier_source names the run.
2. That judge's SEED list was measured to be wrong about 11 % of the time on TMAX and 38 % on RST — lower bounds, calibrated on the 147 top-3 ids of an earlier run where two judges and an adjudicator disagreed. It also misses about 12 % of what should be held. So expect a real minority of the judged clean rows to carry a defect nobody caught; the RST part is the weakest. TerminalWorld's judge (v13-harbor2, GLM-5.3 low) was never calibrated: its error rate is unmeasured.
3. A disagreement is almost always a miss, not a false alarm — the judge that flagged was upheld in 26 of 32 adjudications. Tasks where both judges agreed were never adjudicated, so the error rates above are lower bounds.
4. SWE-Smith and SWE-Rebench rows were never judged here. They rest on their source datasets' own verification and on one oracle replay of the shipped solution by our gate; tier and verdict are empty on all 98.
5. Runtime facts are single runs. rst_oracle, runtime_empty_run and the gate's replays each come from one execution. A flaky verifier is not distinguished from a broken one.
6. A reference solution exists for 196 of 282 TMAX, 60 of 60 RST, 37 of 37 SWE-Smith, 61 of 61 SWE-Rebench and 71 of 71 TerminalWorld rows. Raw TMAX packages ship instruction.md, setup.sh and tests/test.sh and nothing else, so the TMAX gap is the state of the corpus, not a gap in the search; every row without one names solution in column_gaps.
7. Measured runtime RAM exists for 40 of 282 TMAX, 57 of 60 RST, 37 of 37 SWE-Smith, 61 of 61 SWE-Rebench and 71 of 71 TerminalWorld rows; the rest were never measured, and the columns are null, not zero. Read runtime_peak_source before comparing numbers across rows. runtime_peak_disk_mb is not filled on SWE-Smith, SWE-Rebench and TerminalWorld rows: the gate's disk readings for them measure a different quantity.
8. req_* is filled on every row but does not mean one thing — RST's is the corpus's declaration, 21 TMAX rows carry the published corpus value, and every other row an allocation from the largest already-measured peak available (or the 2 GiB default), never a requirement anyone declared; BUILD_RECORD.json names the source per row.
9. 3 rows carry dockerfile_repaired = true (RST 3): Dockerfiles re-pinned to snapshot.debian.org because their Debian release is out of support and its mirrors stopped serving or re-signing it: Debian 10 (buster): 1 row (rts_task_020ad1689cad3626497b56fe); Debian 11 (bullseye): 2 rows (rts_task_48df84de654aa6cc91465b6f, rts_task_59ae2da3d0ccc51f525f042a). The shipped Dockerfile is the pinned one; the flag marks that it differs from what the upstream published.
10. Security rows (67 of 511: 35 in clean, 32 in repair; TMAX 33, RST 12, SWE-Smith 7, SWE-Rebench 1 and TerminalWorld 14) carry their flags. Where a judgment row exists it was never opened, so repair_hint is empty for all of them.
11. Sibling tasks are split across clean and repair. 6 of the 48 RST groups present have members in both splits, covering 17 RST rows; group by task_group_id before using one split as a control for the other.
12. SWE-Smith's task.toml is empty on all 37 rows — that is how the corpus ships. seed.json ships on SWE-Smith and SWE-Rebench and holds the test specification and the upstream anchor (repo, base commit, image, workdir, fail_to_pass / pass_to_pass).

License and provenance

Task content is redistributed from 8 upstream datasets, and they do not share one license:

• TMAX — allenai/tmax-15k-open-instruct declares license: odc-by in its dataset card's YAML front matter, and its card states: "This dataset is licensed under ODC-BY." (Open Data Commons Attribution License. The repo ships no separate LICENSE file; the card is the declaration.)
• RST — Zhongzhi1228/Recursive-Task-Synthesis declares license: cc-by-4.0, with the full Creative Commons Attribution 4.0 International text in its LICENSE file.
• SWE-Smith — Fzz1/SWE-Smith-Seeds-Clean (revision 58af1819c6a5) declares license: mit in its card's YAML front matter; the card's text says nothing further about licensing, and the repo ships no LICENSE file. Its card says it is built from SWE-bench/SWE-smith and allenai/open-instruct-swe-smith, whose cards each declare license: mit.
• SWE-Rebench — Fzz1/SWE-Rebench-Tasks-Clean (revision a6d8f8ead159) declares license: mit in its card's YAML front matter; the card's text says nothing further about licensing, and the repo ships no LICENSE file. Its card says it is adapted from nebius/SWE-rebench-V2, whose card declares license: cc-by-4.0 and states: "The dataset is licensed under the Creative Commons Attribution 4.0 license. However, please respect the license of each specific repository on which a particular instance is based." The two declarations differ, and this dataset does not resolve that: honour the stricter terms, and the per-repository licenses the parent asks you to respect.
• TerminalWorld — andylizf/TerminalWorld-Seeds-Clean (revision ef0a100cd93c) declares license: cc-by-4.0 in its card's YAML front matter; its parent andylizf/TerminalWorld-Seeds and its source EuniAI/TerminalWorld each declare cc-by-4.0 too (the source ships a LICENSE file), and the card asks for attribution to TerminalWorld: Benchmarking Agents on Real-World Terminal Tasks (arXiv 2605.22535). Its card also carries a canary notice: "Task content is byte-verbatim from TerminalWorld, including its harbor-canary markers. TerminalWorld is a benchmark; those markers exist to detect benchmark data leaking into training corpora. The intended use here is as synthesis seeds — tasks to derive harder tasks from — not as a training corpus. If trajectories collected on these tasks enter training data, the resulting model is contaminated with respect to the TerminalWorld leaderboard." Its note of 2026-08-28 adds: "If you train on this data, remove it from what your model actually reads — the instruction and the problem statement — and leave it in the build and grading files, which no model sees." See TerminalWorld is a benchmark above.
• CalibForge — AweAI-Team/CalibForge (revision fb1e75441a94) declares no license: in its card's YAML front matter. Its README shows a "License: CC BY 4.0" badge linking to a LICENSE file that the repository does not contain at its root; some task environments vendor third-party code with its own LICENSE file. This dataset states that as found and does not resolve it.
• Terminal-Lego — Lego-X/Terminal-Lego-15k (revision 9c197f1c2e87) declares license: apache-2.0 in its card's YAML front matter; the repository ships no LICENSE file at its root (some task environments carry their own), and the card asks for citation of What Makes Interaction Trajectories Effective for Training Terminal Agents? (arXiv 2606.03461).
• Xiaomi MiMo — XiaomiMiMo/MiMo-V2.6-RL-oss (revision 639865fd3374) declares license: apache-2.0 in its card's YAML front matter; the repository ships no LICENSE file at its root.

No single license is asserted for this dataset — that is why there is no license: field in the YAML above. Use the corpus / source_dataset column to tell which terms apply to a given row, and honour the attribution requirements of each. Nothing here is relicensed.

The judgment tables are ours and are not published; BUILD_RECORD.json names the commit they were read at. metadata/BUILD_RECORD.json carries the per-file sha256, the counts, the definitions, the population, the prompt digests, the command that built it (local paths removed) and every assertion this build checked.