issaquahd commited on
Commit
a6c60d7
·
verified ·
1 Parent(s): 32a06ad

Initial release

Browse files
DATA_LICENSE.md ADDED
@@ -0,0 +1,15 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Data licence
2
+
3
+ The data in this repository is licensed under the
4
+ [Creative Commons Attribution 4.0 International licence (CC BY 4.0)](https://creativecommons.org/licenses/by/4.0/).
5
+
6
+ Covered: `data/`, `results/`, `reference/`, the task, protocol and manifest files in `frozen/`
7
+ (`*.json`), and the documentation (`*.md`).
8
+
9
+ Not covered: source code (`*.py`, `*.sh`, including the frozen evaluators and prompt builder in
10
+ `frozen/`), which is licensed under the MIT licence in [`LICENSE`](LICENSE).
11
+
12
+ Attribution: "Intelligence Ladder, cloudlabworks, 2026, CC BY 4.0", with a link to the dataset.
13
+
14
+ Model outputs are not included. Scores describe the behaviour of third-party models; model names are
15
+ used only to identify what was measured.
LICENSE ADDED
@@ -0,0 +1,21 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ MIT License
2
+
3
+ Copyright (c) 2026 cloudlabworks
4
+
5
+ Permission is hereby granted, free of charge, to any person obtaining a copy
6
+ of this software and associated documentation files (the "Software"), to deal
7
+ in the Software without restriction, including without limitation the rights
8
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9
+ copies of the Software, and to permit persons to whom the Software is
10
+ furnished to do so, subject to the following conditions:
11
+
12
+ The above copyright notice and this permission notice shall be included in all
13
+ copies or substantial portions of the Software.
14
+
15
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21
+ SOFTWARE.
README.md ADDED
@@ -0,0 +1,141 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ ---
2
+ license: cc-by-4.0
3
+ language:
4
+ - en
5
+ pretty_name: Intelligence Ladder
6
+ size_categories:
7
+ - 1K<n<10K
8
+ task_categories:
9
+ - text-generation
10
+ tags:
11
+ - code
12
+ - benchmark
13
+ - evaluation
14
+ - llm-evaluation
15
+ - edge-ai
16
+ - python
17
+ configs:
18
+ - config_name: results
19
+ data_files:
20
+ - split: train
21
+ path: data/results.jsonl
22
+ - config_name: leaderboard
23
+ data_files:
24
+ - split: train
25
+ path: results/leaderboard.csv
26
+ ---
27
+
28
+ # Intelligence Ladder
29
+
30
+ Per-trial results and frozen task files for a seven-rung, behaviourally graded Python coding benchmark.
31
+ It measures how far up a ladder of harder task families a model climbs under one fixed protocol, and
32
+ how consistently, for hosted API models and a 4B model on an owned edge NPU node.
33
+
34
+ ## Dataset summary
35
+
36
+ - **1309 trials** across 8 models: 28 tasks (7 rungs x 4) x (3 productive + 3 trap repeats) = 168 per
37
+ model; `qwen-plus` has 133 (stopped during R6, R7 not run).
38
+ - **Grading is behavioural only**: hidden asserts run under pytest, planted mutants, existing and feature
39
+ test suites. No LLM judge, no text similarity.
40
+ - **Traps**: an impossible variant of each task whose only correct answer is `UNKNOWN`. Traps are reported
41
+ separately and never rescue productive failures.
42
+ - **Solved task**: at least 2 of 3 productive repeats pass.
43
+
44
+ | Rung | Family |
45
+ |---|---|
46
+ | R1 | Simple functions |
47
+ | R2 | Edge cases / Unicode / nonmutation |
48
+ | R3 | Three-file package repairs |
49
+ | R4 | Tool-mediated debugging (simulated `read` tool, exact call accounting) |
50
+ | R5 | Bounded two-turn revisions (revised spec must reject the old behaviour) |
51
+ | R6 | Implementation plus self-authored tests that kill at least 4 of 5 planted mutants |
52
+ | R7 | Multi-file package feature (three required source files changed; existing and feature tests green) |
53
+
54
+ ## Configurations
55
+
56
+ ### `results` (`data/results.jsonl`)
57
+
58
+ One row per trial.
59
+
60
+ | Field | Type | Meaning |
61
+ |---|---|---|
62
+ | `id` | string | `<task>-<code|trap>-<repeat>` |
63
+ | `task`, `rung`, `repeat`, `trap` | string, int, int, bool | Task id (e.g. `R4-C`), rung 1–7, repeat 1–3, trap flag |
64
+ | `model` | string | Result label; see `data/models.json` for model ref, route and hardware class |
65
+ | `freeze_sha256` | string | sha256 of the freeze manifest the trial ran under (both shipped in `frozen/`) |
66
+ | `score.pass` | bool | Trial verdict |
67
+ | `score.*` | mixed | Structural fields by rung: `returncode`, `kind` (trap), `tool_exact`, `actual_calls`, `initial`/`final`/`obsolete_rejected` (R5), `behavior`/`tests_on_reference`/`mutants`/`mutants_killed`/`mutation_kill_rate` (R6), `existing`/`feature`/`changed_paths` (R7), `error` (harness rejection message only) |
68
+ | `wall_s` | float | Trial wall time, seconds, including transport and scoring |
69
+ | `turn_metrics[]` | list | Per model turn: `wall_s`, `ttft_s`, `tok_s`, `inference_s` (RK1), `output_tokens`, `usage.{prompt,completion,total,reasoning,cached}_tokens` where the route reports them, `metric_source` |
70
+ | `evaluation_repair` | string | Present on 3 rows re-scored from the saved answer with the frozen evaluator (no new model call) |
71
+
72
+ `score` has a rung-dependent shape; load with `json` if your tooling needs a fixed schema.
73
+
74
+ ### `leaderboard` (`results/leaderboard.csv`)
75
+
76
+ One row per model, generated by `reproduce.py --write` from `data/results.jsonl`: tasks solved with
77
+ cluster-bootstrap 95% CI, productive pass rate with CI, eligible families, ladder height, trap abstention,
78
+ coverage, token totals, median and p90 trial wall time, median TTFT and median tok/s (non-reasoning turns).
79
+
80
+ ## Frozen files
81
+
82
+ `frozen/` holds byte-identical copies of the task files (`rungs/R1–R7.json`, which include the grading
83
+ asserts, reference solutions for R6 and package files), the prompt builder, both evaluators, the protocol
84
+ and the freeze manifests. `reproduce.py` checks every shipped file against the manifests. Reserved
85
+ held-out variants and the site-specific runner are **withheld**; their hashes stay in the manifest so a
86
+ later release can prove they were not changed (see `frozen/WITHHELD.md`).
87
+
88
+ ## Models
89
+
90
+ | Label | Model ref | Route | Hardware class |
91
+ |---|---|---|---|
92
+ | `astra` | openai/gpt-6-astra | OpenRouter, streaming | hosted API |
93
+ | `deepseek-v4-flash` | deepseek/deepseek-v4-flash | OpenRouter, streaming | hosted API |
94
+ | `glm-4.7-flash` | z-ai/glm-4.7-flash | OpenRouter, streaming | hosted API |
95
+ | `gpt-5-nano` | openai/gpt-5-nano | OpenRouter, streaming | hosted API |
96
+ | `qwen3.7-flash` | qwen/qwen3.7-flash | OpenRouter, streaming | hosted API |
97
+ | `alibaba/qwen-flash` | qwen-flash | Alibaba Cloud Model Studio, buffered, thinking off | hosted API |
98
+ | `alibaba/qwen-plus` | qwen-plus | Alibaba Cloud Model Studio, buffered, thinking off | hosted API |
99
+ | `RK1-Qwen3-4B` | Qwen3-4B-Instruct-2507, RKLLM W8A8, context 2048 | local NPU via RKLLM runtime 1.3.1 | edge SoC: Turing RK1, Rockchip RK3588, 3-core NPU, 32 GB |
100
+
101
+ Output caps: 512 tokens on R1–R5 and 2048 on R6–R7 for hosted routes; RK1 kept its native 512-token output
102
+ and 2048-token context on every rung.
103
+
104
+ ## Intended uses
105
+
106
+ - Compare where on the ladder different models stop under a fixed, small output cap.
107
+ - Compare an edge NPU model with hosted models on identical tasks and grading.
108
+ - Study trap abstention and reasoning-token exhaustion under a fixed cap.
109
+ - Template for adding a model with the public runner (`harness/run_model.py`).
110
+
111
+ ## Limitations and biases
112
+
113
+ - 28 tasks and 3 repeats at temperature 0: intervals are wide and repeats are not independent.
114
+ - The task files are now public. Any model trained after this release may have seen them; treat new
115
+ results as contaminated unless checked against the withheld variants.
116
+ - Resource caps differ between RK1 and hosted routes on R6/R7.
117
+ - Latency comes from different instruments per route and includes transport; it is not a serving
118
+ benchmark. Hosted serving hardware is not disclosed. Power was not metered.
119
+ - `qwen-plus` coverage is incomplete. Hosted models can change behind a stable model ref; results describe
120
+ the runs made on 2026-10-27 and 2026-10-28.
121
+ - English-only prompts; Python-only tasks.
122
+
123
+ ## Personal and sensitive information
124
+
125
+ None. The dataset holds synthetic programming tasks and machine-generated scores. Model answer text,
126
+ evaluator logs and all operator or infrastructure details were removed before release.
127
+
128
+ ## Licence
129
+
130
+ Data, task files and documentation: CC BY 4.0. Code in the companion repository: MIT.
131
+
132
+ ## Citation
133
+
134
+ ```
135
+ @misc{intelligence_ladder_2026,
136
+ title = {Intelligence Ladder: a frozen, behaviourally graded coding ladder for hosted and edge models},
137
+ author = {cloudlabworks},
138
+ year = {2026},
139
+ note = {Dataset and reproduce scripts}
140
+ }
141
+ ```
SHA256SUMS ADDED
@@ -0,0 +1,22 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ 720984a28058a66580b424c8d4eaab5b5c8d8c095e904b8d6e6f06f961a79d94 data/models.json
2
+ 85720e7f6cdf759a103a47e7654a18af10ffe7f6701cee964f57526f034e1099 data/results.jsonl
3
+ 311c38c0e227296409f1d89564b6582a6cc4c7d92ca81be89d1d6d739be0dfbc frozen/SHA256SUMS.json
4
+ 9603f3c2cdc795531b2e5198b3640edc1f78c241b02647c5e8d7818121b767c5 frozen/WITHHELD.md
5
+ d40fe9592a2add7acf6ad808bfba4b36bc02705ab31b9c80f8c2b91fffe1d80e frozen/evaluator.py
6
+ 2004b7155233cbd6a04837ae1be362fc2760b757068b431903af03d14af1b6f7 frozen/extension_evaluator.py
7
+ 9cde7661a021b91097b26d141a0f494111a7dd7c702a8e2ed208523ae14647a5 frozen/extension_references.json
8
+ 62cee4207d10260f2c8f65262f4277bb0058018196a45ed48c0eb5b985810eaa frozen/history/R1-R5-SHA256SUMS.json
9
+ 175cda01392a7188fe907142d01d213fe56b8c92e1f9f1097c1a98728a376753 frozen/history/R1-R5-protocol.json
10
+ 7d7f4a4ebd7152cf30472ea54ac18f739e117d956c066d694bc0ffdd70b735b3 frozen/prompts.py
11
+ 37368d5f070ac4cfab5bd0bd5be80626d44fa1fc209e21a377bcdda12596a1aa frozen/protocol.json
12
+ 8b859f23d126f8e88181bffb5fe2c92b33b39b637529883411517cd582c64ab9 frozen/references.json
13
+ ee796e09cf8e38437eafa74ad94b26c79a0167ef15e9cabaa68356c93da63c17 frozen/rungs/R1.json
14
+ 2a29711965c42d421d721323d488f9df13c48d5e8435f86c061463861ae7a646 frozen/rungs/R2.json
15
+ f4de6d8c95212ec04d69261960678f8d93f396aa9b9d6203acfa3f5d9b62adb8 frozen/rungs/R3.json
16
+ 3fec3dc9c632900becaff6589067327bf225bca9e68bb66b684eba9364a32a35 frozen/rungs/R4.json
17
+ 22db6aa4c9ec31073d51e96ebc34d498b4e7ca4ce82595da72f58890f200a366 frozen/rungs/R5.json
18
+ 4b06d80d738530f363507c46bd29a46bf9ea5591d00c858f54f037512434659d frozen/rungs/R6.json
19
+ 9710889bea218b7691c71787c5e1e7e96e3357cb635b671262bd621f38349af4 frozen/rungs/R7.json
20
+ aba390db0ac6e789d1253dff3a5cb869e4bcd7d66d29463e2fda0bceba2493fe reference/RESULTS-reference.md
21
+ 2dab3c579ab790c038ece687f619027f82c8342cedb732720408182cfa4a9fd4 results/leaderboard.csv
22
+ b236ffdceb3aaf8c136e76bafed6a9e6e9b7f087bcb9b700a199e23d3f33ae47 results/leaderboard.md
data/models.json ADDED
@@ -0,0 +1,71 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "note": "Registry of result labels. 'order' of this list fixes the bootstrap RNG stream: append new models at the end so existing confidence intervals never move.",
3
+ "models": [
4
+ {
5
+ "label": "alibaba/qwen-flash",
6
+ "model_ref": "qwen-flash",
7
+ "route": "Alibaba Cloud Model Studio API, buffered (non-streaming), enable_thinking=false, temperature 0",
8
+ "hardware_class": "hosted API; serving hardware not disclosed",
9
+ "output_token_cap": {"R1-R5": 512, "R6-R7": 2048},
10
+ "latency_instrument": "Buffered API: wall time only; TTFT and tok/s unavailable"
11
+ },
12
+ {
13
+ "label": "alibaba/qwen-plus",
14
+ "model_ref": "qwen-plus",
15
+ "route": "Alibaba Cloud Model Studio API, buffered (non-streaming), enable_thinking=false, temperature 0",
16
+ "hardware_class": "hosted API; serving hardware not disclosed",
17
+ "output_token_cap": {"R1-R5": 512, "R6-R7": 2048},
18
+ "latency_instrument": "Buffered API: wall time only; TTFT and tok/s unavailable",
19
+ "coverage_note": "Run stopped during R6; R6 partial and R7 not run. Missing trials are not failures."
20
+ },
21
+ {
22
+ "label": "RK1-Qwen3-4B",
23
+ "model_ref": "Qwen3-4B-Instruct-2507, RKLLM W8A8 build, compiled context 2048",
24
+ "route": "owned edge node, local NPU inference via the RKLLM runtime (1.3.1)",
25
+ "hardware_class": "edge SoC: Turing RK1 compute module, Rockchip RK3588, 3-core NPU, 32 GB",
26
+ "output_token_cap": {"R1-R5": 512, "R6-R7": 512},
27
+ "latency_instrument": "RKLLM native callbacks/perf; trial wall time includes remote shell and model init",
28
+ "coverage_note": "Native 512 output / 2048 context limit kept for R6-R7, unlike the 2048 output cap on hosted routes. Input tokens were not logged."
29
+ },
30
+ {
31
+ "label": "astra",
32
+ "model_ref": "openai/gpt-6-astra",
33
+ "route": "OpenRouter, OpenAI-compatible streaming chat completions, temperature 0",
34
+ "hardware_class": "hosted API; serving hardware not disclosed",
35
+ "output_token_cap": {"R1-R5": 512, "R6-R7": 2048},
36
+ "latency_instrument": "SSE first content event; tok/s = (completion_tokens-1)/(last-first content event)"
37
+ },
38
+ {
39
+ "label": "deepseek-v4-flash",
40
+ "model_ref": "deepseek/deepseek-v4-flash",
41
+ "route": "OpenRouter, OpenAI-compatible streaming chat completions, temperature 0",
42
+ "hardware_class": "hosted API; serving hardware not disclosed",
43
+ "output_token_cap": {"R1-R5": 512, "R6-R7": 2048},
44
+ "latency_instrument": "SSE first content event; tok/s = (completion_tokens-1)/(last-first content event)"
45
+ },
46
+ {
47
+ "label": "glm-4.7-flash",
48
+ "model_ref": "z-ai/glm-4.7-flash",
49
+ "route": "OpenRouter, OpenAI-compatible streaming chat completions, temperature 0",
50
+ "hardware_class": "hosted API; serving hardware not disclosed",
51
+ "output_token_cap": {"R1-R5": 512, "R6-R7": 2048},
52
+ "latency_instrument": "SSE first content event; tok/s = (completion_tokens-1)/(last-first content event)"
53
+ },
54
+ {
55
+ "label": "gpt-5-nano",
56
+ "model_ref": "openai/gpt-5-nano",
57
+ "route": "OpenRouter, OpenAI-compatible streaming chat completions, temperature 0",
58
+ "hardware_class": "hosted API; serving hardware not disclosed",
59
+ "output_token_cap": {"R1-R5": 512, "R6-R7": 2048},
60
+ "latency_instrument": "SSE first content event; tok/s = (completion_tokens-1)/(last-first content event)"
61
+ },
62
+ {
63
+ "label": "qwen3.7-flash",
64
+ "model_ref": "qwen/qwen3.7-flash",
65
+ "route": "OpenRouter, OpenAI-compatible streaming chat completions, temperature 0",
66
+ "hardware_class": "hosted API; serving hardware not disclosed",
67
+ "output_token_cap": {"R1-R5": 512, "R6-R7": 2048},
68
+ "latency_instrument": "SSE first content event; tok/s = (completion_tokens-1)/(last-first content event)"
69
+ }
70
+ ]
71
+ }
data/results.jsonl ADDED
The diff for this file is too large to render. See raw diff
 
frozen/SHA256SUMS.json ADDED
@@ -0,0 +1,43 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "evaluator.py": "d40fe9592a2add7acf6ad808bfba4b36bc02705ab31b9c80f8c2b91fffe1d80e",
3
+ "extension_evaluator.py": "2004b7155233cbd6a04837ae1be362fc2760b757068b431903af03d14af1b6f7",
4
+ "extension_references.json": "9cde7661a021b91097b26d141a0f494111a7dd7c702a8e2ed208523ae14647a5",
5
+ "hidden/R1-A.json": "85c05b3bf6124fad6bb9011386b0cd67448760bbe64add0124fe2365e8524603",
6
+ "hidden/R1-B.json": "1d49f95529af149fbfbc6489084e5cd69067bfbd0191d7e993abb3d67a82b6d4",
7
+ "hidden/R1-C.json": "8a169b6bfbabd8ad9a6ce070d99799aca1b5919dd5a72543359b2a96d5c6cd05",
8
+ "hidden/R1-D.json": "2dc6ca4bde43c0cce1586364235595a445291ab371d51e18eb586d04f5d9aa9f",
9
+ "hidden/R2-A.json": "5cc7324ac117dd040c7fb5b925aecc1f2cc8ba75500f357336c5634b34ec0c56",
10
+ "hidden/R2-B.json": "0b53ebc1822af76094fb1b8a98a5909e9b402ba0211191ea83842a5b9d726f3b",
11
+ "hidden/R2-C.json": "a176bcc704887fc1ca6079e82e6d8f42fdd2432135dbbb1845b0e93cdf804645",
12
+ "hidden/R2-D.json": "5d1501af27c3f3a1c6e13f1222c4f3cb6d651edf60e47664dbf52a04d998f4aa",
13
+ "hidden/R3-A.json": "90f6295efa40f94c6d35f6d7e55f3b7b5f904c3b1f21f28221691c50264af1d9",
14
+ "hidden/R3-B.json": "3ae4a0ecfab26ce147294b16f9a0238dc4f73eec1e2a9ba8643783cb2789693a",
15
+ "hidden/R3-C.json": "760e110df06cb9d8bdf54c476208eb2309b84d5fa163e354c38ca55d6c92c492",
16
+ "hidden/R3-D.json": "4c511cd569a394b94586c30d56eba02ddf6f83a5a5d9125488282129688153b9",
17
+ "hidden/R4-A.json": "38f1dfafe2b89d4081ce43e9b145b1f946ed0d9e68913578166ec17507b2d195",
18
+ "hidden/R4-B.json": "98908638b32e5b3bfbd9447d4c2bf4526e6f44c7e4addd01fbab5db5b59971e7",
19
+ "hidden/R4-C.json": "f4c9b131e762338b7108abd5f90f4ba2f0de80fd63b4ee40db3bf87465e3bcea",
20
+ "hidden/R4-D.json": "50e3ea427f2216a6887fa7127637ff938252d69ed8940a5309d7e8394096ad1a",
21
+ "hidden/R5-A.json": "35c9b1617c4eed9c61d3a466cb4c7410315c09f14d2e8ff8035001d502975f2a",
22
+ "hidden/R5-B.json": "0d0284de23049f9f19d6c9b258abf10246f4f2940eb3d4975013907eb3aa149d",
23
+ "hidden/R5-C.json": "b71db20b84f6241563d6f658e6bac949e9d4776b51c283f69b570639a54066d4",
24
+ "hidden/R5-D.json": "85640f8135d1c65f6a1e5b81a910ed6fa2dfdb98459b295922cdbdbcd3cf7e7c",
25
+ "hidden/R6-A.json": "9723fcfaa9c04b330958e66a0447d70b20ae36e8fdfda0893c78cd9652a9ac4a",
26
+ "hidden/R6-B.json": "d9059a77d8fdb9af4aef9e6e4a99340e51a821072227ddbbcd7561eb99c3887d",
27
+ "hidden/R6-C.json": "8dd21606150c9210e77019f674c7373083beeab789090a4a6c1e6581929ca66e",
28
+ "hidden/R6-D.json": "ee935648c21e66eb92fd0986e965c6e3e41bac59da1e903fc1fb231da63317c0",
29
+ "hidden/R7-A.json": "faf7d51bb9b696d81055162bc2974c3ddf732532c803f4eb76c43a83336adc4b",
30
+ "hidden/R7-B.json": "de7cd0fc405c811d4d0ccac9d4787007da994f0f4302ceb49319637c458ca630",
31
+ "hidden/R7-C.json": "4fa0711fc7e2977261c1b3ffa188e899ea83acbb9f8a58ada446a85180256a00",
32
+ "hidden/R7-D.json": "236ed98c8baf9c467de34eaacbb97283619d13bc7e7c8c73cafc9db0c53b37e9",
33
+ "prompts.py": "7d7f4a4ebd7152cf30472ea54ac18f739e117d956c066d694bc0ffdd70b735b3",
34
+ "protocol.json": "37368d5f070ac4cfab5bd0bd5be80626d44fa1fc209e21a377bcdda12596a1aa",
35
+ "rungs/R1.json": "ee796e09cf8e38437eafa74ad94b26c79a0167ef15e9cabaa68356c93da63c17",
36
+ "rungs/R2.json": "2a29711965c42d421d721323d488f9df13c48d5e8435f86c061463861ae7a646",
37
+ "rungs/R3.json": "f4de6d8c95212ec04d69261960678f8d93f396aa9b9d6203acfa3f5d9b62adb8",
38
+ "rungs/R4.json": "3fec3dc9c632900becaff6589067327bf225bca9e68bb66b684eba9364a32a35",
39
+ "rungs/R5.json": "22db6aa4c9ec31073d51e96ebc34d498b4e7ca4ce82595da72f58890f200a366",
40
+ "rungs/R6.json": "4b06d80d738530f363507c46bd29a46bf9ea5591d00c858f54f037512434659d",
41
+ "rungs/R7.json": "9710889bea218b7691c71787c5e1e7e96e3357cb635b671262bd621f38349af4",
42
+ "runner.py": "832bcd7790288375e23ec3c51cf2d80d32e98a07ce3c5c645ee39347a6fa71a9"
43
+ }
frozen/WITHHELD.md ADDED
@@ -0,0 +1,19 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Withheld frozen files
2
+
3
+ `SHA256SUMS.json` lists 41 frozen files. This release ships 12 of them byte-identical. The other 29 are
4
+ withheld on purpose; their sha256 values stay in the manifest, so the manifest hash recorded on every
5
+ result row (`freeze_sha256`) is unchanged and a later release of these files can be verified against it.
6
+
7
+ | Withheld | Count | Why |
8
+ |---|---:|---|
9
+ | `hidden/R1-A.json` … `hidden/R7-D.json` | 28 | Reserved held-out variants. Never executed in any run. Kept private so they can later test whether a model's ladder score survives on unseen variants of the public tasks. |
10
+ | `runner.py` | 1 | The original site-specific runner. It carries deployment defaults for the original lab and two adapters that only work there. Its trial loop is reproduced unchanged in `harness/run_model.py`. |
11
+
12
+ `history/R1-R5-SHA256SUMS.json` is the earlier manifest (sha256 `62cee420…`) that the first `astra` and
13
+ `RK1-Qwen3-4B` R1–R5 runs used. It covers 28 files: 20 reserved variants (withheld), 7 files identical to
14
+ the current ones, and `protocol.json` version 1, shipped as `history/R1-R5-protocol.json`. The only
15
+ protocol change between versions added the R6/R7 extension fields; R1–R5 tasks, prompts and evaluator are
16
+ byte-identical across both manifests.
17
+
18
+ `references.json` (reference solutions for R1–R5, used by the original self-test) is not in either
19
+ manifest; it is covered by the package `SHA256SUMS`.
frozen/evaluator.py ADDED
@@ -0,0 +1,62 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """Frozen behavioural evaluator; no LLM judges or text similarity."""
2
+ import json,os,pathlib,re,resource,subprocess,sys,time
3
+
4
+ def code_text(text):
5
+ text=text.strip()
6
+ m=re.fullmatch(r'```(?:python)?\s*\n(.*?)\n```',text,re.S)
7
+ return m.group(1) if m else text
8
+
9
+ def object_text(text):
10
+ # JSON is intentionally whole-document strict, no prose or Markdown stripping.
11
+ return json.loads(text)
12
+
13
+ def limits():
14
+ resource.setrlimit(resource.RLIMIT_CPU,(6,6))
15
+ resource.setrlimit(resource.RLIMIT_FSIZE,(1024*1024,1024*1024))
16
+ resource.setrlimit(resource.RLIMIT_NOFILE,(64,64))
17
+ if sys.platform!='darwin':resource.setrlimit(resource.RLIMIT_AS,(512*1024*1024,512*1024*1024))
18
+
19
+ def execute(task,answer,assertions,directory):
20
+ d=pathlib.Path(directory).resolve();d.mkdir(parents=True,exist_ok=True)
21
+ try:
22
+ files=dict(task.get('files',{}))
23
+ if files:
24
+ obj=object_text(answer)
25
+ patch=obj.get('files')
26
+ if not isinstance(patch,dict) or not patch: raise ValueError('files must be a nonempty path->full replacement source mapping')
27
+ allowed={'worker.py'} if task['rung']==4 else set(files)
28
+ if set(patch)-allowed:raise ValueError('patch path outside frozen allowlist')
29
+ if any(not isinstance(v,str) for v in patch.values()):raise ValueError('source must be string')
30
+ files.update(patch); entry=task['entry']
31
+ else:files={'solution.py':code_text(answer)};entry='solution'
32
+ for path,source in files.items():
33
+ p=d/path;p.parent.mkdir(parents=True,exist_ok=True);p.write_text(source)
34
+ test='import sys\nsys.path.insert(0,'+repr(str(d))+')\nfrom '+entry+' import *\n\ndef test_contract():\n'+''.join(' '+s+'\n' for s in assertions.splitlines())
35
+ (d/'test_contract.py').write_text(test)
36
+ cmd=[sys.executable,'-I','-m','pytest','-q','--capture=sys','-p','no:cacheprovider',str(d/'test_contract.py')]
37
+ if sys.platform=='darwin':
38
+ profile='(version 1)(allow default)(deny network*)(deny file-write*)(allow file-write* (literal "/dev/null"))'
39
+ cmd=['/usr/bin/sandbox-exec','-p',profile]+cmd
40
+ start=time.monotonic()
41
+ p=subprocess.run(cmd,cwd=d,capture_output=True,text=True,timeout=task['budgets']['execution_seconds'],preexec_fn=limits,env={'PATH':'/usr/bin:/bin','PYTHONDONTWRITEBYTECODE':'1','PYTEST_DISABLE_PLUGIN_AUTOLOAD':'1','HOME':str(d)})
42
+ log=p.stdout+p.stderr;(d/'result.txt').write_text(log)
43
+ return {'pass':p.returncode==0 and bool(re.search(r'\b1 passed\b',log)),'returncode':p.returncode,'wall_s':time.monotonic()-start,'error':log[-2500:] if p.returncode else None}
44
+ except Exception as e:return {'pass':False,'error':type(e).__name__+': '+str(e)}
45
+
46
+ def score(task,answers,calls,directory,trap=False):
47
+ if trap:return {'pass':answers[-1].strip()==task['trap']['expected'],'kind':'abstention'}
48
+ d=pathlib.Path(directory)
49
+ if task['rung']==5:
50
+ if len(answers)!=2:return {'pass':False,'error':'requires both turns'}
51
+ initial=execute(task,answers[0],task['tests'],d/'turn1')
52
+ final=execute(task,answers[1],task['final_tests'],d/'turn2')
53
+ obsolete=execute(task,answers[1],task['conflict_tests'],d/'obsolete')
54
+ rejected_old=obsolete.get('returncode')==1 and 'AssertionError' in (obsolete.get('error') or '')
55
+ return {'pass':initial['pass'] and final['pass'] and rejected_old,'initial':initial,'final':final,'obsolete_rejected':rejected_old}
56
+ result=execute(task,answers[-1],task['tests'],d/'final')
57
+ if task['rung']==4:
58
+ try:claimed=object_text(answers[-1]).get('tool_calls')
59
+ except Exception:claimed=None
60
+ exact=calls==task['expected_calls'] and claimed==calls
61
+ result={'pass':result['pass'] and exact,'code':result,'tool_exact':exact,'actual_calls':calls}
62
+ return result
frozen/extension_evaluator.py ADDED
@@ -0,0 +1,47 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """Frozen R6 mutation scoring and R7 package integration scoring."""
2
+ import json,pathlib,re,subprocess,sys,time
3
+ from evaluator import execute,limits
4
+
5
+ def pytest_files(task,files,directory,targets):
6
+ d=pathlib.Path(directory).resolve();d.mkdir(parents=True,exist_ok=False)
7
+ for path,source in files.items():
8
+ p=d/path;p.parent.mkdir(parents=True,exist_ok=True);p.write_text(source)
9
+ (d/'conftest.py').write_text('import sys\nsys.path.insert(0,'+repr(str(d))+')\n')
10
+ cmd=[sys.executable,'-I','-m','pytest','-q','--capture=sys','-p','no:cacheprovider',*targets]
11
+ if sys.platform=='darwin':
12
+ # Also hide the private benchmark tree from submitted code, except its own sandbox.
13
+ profile='(version 1)(allow default)(deny network*)(deny file-write*)(allow file-write* (literal "/dev/null"))(deny file-read-data (require-all (subpath '+json.dumps(str(pathlib.Path(__file__).resolve().parent))+') (require-not (subpath '+json.dumps(str(d))+')) (require-not (subpath '+json.dumps(sys.prefix)+'))))'
14
+ cmd=['/usr/bin/sandbox-exec','-p',profile]+cmd
15
+ start=time.monotonic()
16
+ try:
17
+ p=subprocess.run(cmd,cwd=d,capture_output=True,text=True,timeout=task['budgets']['execution_seconds'],preexec_fn=limits,env={'PATH':'/usr/bin:/bin','HOME':str(d),'PYTHONDONTWRITEBYTECODE':'1','PYTEST_DISABLE_PLUGIN_AUTOLOAD':'1'})
18
+ log=p.stdout+p.stderr;(d/'result.txt').write_text(log)
19
+ passed=p.returncode==0 and bool(re.search(r'\b[1-9]\d* passed\b',log))
20
+ killed=p.returncode==1 and bool(re.search(r'\b[1-9]\d* failed\b',log)) and 'ERROR collecting' not in log
21
+ return dict(pass_=passed,killed=killed,returncode=p.returncode,wall_s=time.monotonic()-start,log=log[-3000:])
22
+ except Exception as e:return dict(pass_=False,killed=False,error=type(e).__name__+': '+str(e))
23
+
24
+ def score(task,answers,calls,directory,trap=False):
25
+ if trap:return {'pass':answers[-1].strip()==task['trap']['expected'],'kind':'abstention'}
26
+ d=pathlib.Path(directory)
27
+ try:
28
+ files=json.loads(answers[-1])['files']
29
+ if not isinstance(files,dict) or any(not isinstance(v,str) for v in files.values()):raise ValueError('invalid files mapping')
30
+ if task['rung']==6:
31
+ if set(files)!={'solution.py','test_solution.py'}:raise ValueError('requires exactly solution.py and test_solution.py')
32
+ contract='import pytest\nfrom solution import *\ndef test_contract():\n'+''.join(' '+s+'\n' for s in task['tests'].splitlines())
33
+ code=pytest_files(task,{'solution.py':files['solution.py'],'test_contract.py':contract},d/'behavior',['test_contract.py'])
34
+ ref=pytest_files(task,{'solution.py':task['reference'],'test_solution.py':files['test_solution.py']},d/'reference',['test_solution.py'])
35
+ mutants=[pytest_files(task,{'solution.py':m,'test_solution.py':files['test_solution.py']},d/f'mutant-{i}',['test_solution.py']) for i,m in enumerate(task['mutants'],1)]
36
+ kills=sum(x['killed'] for x in mutants);rate=kills/len(mutants)
37
+ return {'pass':code['pass_'] and ref['pass_'] and rate>=.8,'behavior':code,'tests_on_reference':ref,'mutants':mutants,'mutants_killed':kills,'mutants_total':len(mutants),'mutation_kill_rate':rate}
38
+ allowed=set(task['required_paths'])|{'pkg/__init__.py'}
39
+ if set(files)-allowed:raise ValueError('patch outside source allowlist')
40
+ changed=[p for p in files if files[p]!=task['files'][p]]
41
+ if len(changed)<3 or not set(task['required_paths']).issubset(changed):raise ValueError('must change all three feature source files')
42
+ merged={**task['files'],**files}
43
+ merged['test_feature.py']='from pkg import *\ndef test_feature():\n'+''.join(' '+s+'\n' for s in task['tests'].splitlines())
44
+ old=pytest_files(task,merged,d/'existing',['test_existing.py'])
45
+ new=pytest_files(task,merged,d/'feature',['test_feature.py'])
46
+ return {'pass':old['pass_'] and new['pass_'],'existing':old,'feature':new,'changed_paths':changed}
47
+ except Exception as e:return {'pass':False,'error':type(e).__name__+': '+str(e)}
frozen/extension_references.json ADDED
@@ -0,0 +1,54 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "R6-A": {
3
+ "files": {
4
+ "solution.py": "def clamp(x,lo,hi):\n if lo>hi: raise ValueError(\"bounds\")\n return max(lo,min(x,hi))\n",
5
+ "test_solution.py": "import pytest\nfrom solution import *\ndef test_contract():\n assert clamp(5,0,10)==5\n assert clamp(-2,0,10)==0\n assert clamp(12,0,10)==10\n assert clamp(3,3,3)==3\n assert clamp(-5,-9,-2)==-5\n with pytest.raises(ValueError): clamp(1,3,2)\n"
6
+ }
7
+ },
8
+ "R6-B": {
9
+ "files": {
10
+ "solution.py": "def chunks(xs,n):\n if n<=0: raise ValueError(\"size\")\n return [xs[i:i+n] for i in range(0,len(xs),n)]\n",
11
+ "test_solution.py": "import pytest\nfrom solution import *\ndef test_contract():\n assert chunks([],2)==[]\n assert chunks([1,2,3,4,5],2)==[[1,2],[3,4],[5]]\n assert chunks([1,2],4)==[[1,2]]\n x=[1,2,3]; chunks(x,2); assert x==[1,2,3]\n with pytest.raises(ValueError): chunks([1],0)\n with pytest.raises(ValueError): chunks([1],-1)\n"
12
+ }
13
+ },
14
+ "R6-C": {
15
+ "files": {
16
+ "solution.py": "def unique(xs):\n return list(dict.fromkeys(xs))\n",
17
+ "test_solution.py": "import pytest\nfrom solution import *\ndef test_contract():\n assert unique([])==[]\n assert unique([3,1,3,2,1])==[3,1,2]\n assert unique([-1,0,-1,2])==[-1,0,2]\n x=[3,1,3]; unique(x); assert x==[3,1,3]\n"
18
+ }
19
+ },
20
+ "R6-D": {
21
+ "files": {
22
+ "solution.py": "def runs(xs):\n out=[]\n for x in xs:\n if out and out[-1][0]==x: out[-1]=(x,out[-1][1]+1)\n else: out.append((x,1))\n return out\n",
23
+ "test_solution.py": "import pytest\nfrom solution import *\ndef test_contract():\n assert runs([])==[]\n assert runs([1])==[(1,1)]\n assert runs([2,2,1,2,2,2])==[(2,2),(1,1),(2,3)]\n assert runs([-1,-1,0])==[(-1,2),(0,1)]\n x=[2,1,2]; runs(x); assert x==[2,1,2]\n"
24
+ }
25
+ },
26
+ "R7-A": {
27
+ "files": {
28
+ "pkg/config.py": "def options(factor=1):\n return {'factor': factor}\n",
29
+ "pkg/core.py": "def transform(values,factor=1):\n return [x * factor for x in values]\n",
30
+ "pkg/api.py": "from .config import options\nfrom .core import transform\ndef process(values,factor=1):\n return transform(values,**options(factor=factor))\n"
31
+ }
32
+ },
33
+ "R7-B": {
34
+ "files": {
35
+ "pkg/config.py": "def options(amount=0):\n return {'amount': amount}\n",
36
+ "pkg/core.py": "def transform(values,amount=0):\n return [x + amount for x in values]\n",
37
+ "pkg/api.py": "from .config import options\nfrom .core import transform\ndef process(values,amount=0):\n return transform(values,**options(amount=amount))\n"
38
+ }
39
+ },
40
+ "R7-C": {
41
+ "files": {
42
+ "pkg/config.py": "def options(minimum=None):\n return {'minimum': minimum}\n",
43
+ "pkg/core.py": "def transform(values,minimum=None):\n return [x if minimum is None else max(x,minimum) for x in values]\n",
44
+ "pkg/api.py": "from .config import options\nfrom .core import transform\ndef process(values,minimum=None):\n return transform(values,**options(minimum=minimum))\n"
45
+ }
46
+ },
47
+ "R7-D": {
48
+ "files": {
49
+ "pkg/config.py": "def options(maximum=None):\n return {'maximum': maximum}\n",
50
+ "pkg/core.py": "def transform(values,maximum=None):\n return [x if maximum is None else min(x,maximum) for x in values]\n",
51
+ "pkg/api.py": "from .config import options\nfrom .core import transform\ndef process(values,maximum=None):\n return transform(values,**options(maximum=maximum))\n"
52
+ }
53
+ }
54
+ }
frozen/history/R1-R5-SHA256SUMS.json ADDED
@@ -0,0 +1,30 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "evaluator.py": "d40fe9592a2add7acf6ad808bfba4b36bc02705ab31b9c80f8c2b91fffe1d80e",
3
+ "hidden/R1-A.json": "85c05b3bf6124fad6bb9011386b0cd67448760bbe64add0124fe2365e8524603",
4
+ "hidden/R1-B.json": "1d49f95529af149fbfbc6489084e5cd69067bfbd0191d7e993abb3d67a82b6d4",
5
+ "hidden/R1-C.json": "8a169b6bfbabd8ad9a6ce070d99799aca1b5919dd5a72543359b2a96d5c6cd05",
6
+ "hidden/R1-D.json": "2dc6ca4bde43c0cce1586364235595a445291ab371d51e18eb586d04f5d9aa9f",
7
+ "hidden/R2-A.json": "5cc7324ac117dd040c7fb5b925aecc1f2cc8ba75500f357336c5634b34ec0c56",
8
+ "hidden/R2-B.json": "0b53ebc1822af76094fb1b8a98a5909e9b402ba0211191ea83842a5b9d726f3b",
9
+ "hidden/R2-C.json": "a176bcc704887fc1ca6079e82e6d8f42fdd2432135dbbb1845b0e93cdf804645",
10
+ "hidden/R2-D.json": "5d1501af27c3f3a1c6e13f1222c4f3cb6d651edf60e47664dbf52a04d998f4aa",
11
+ "hidden/R3-A.json": "90f6295efa40f94c6d35f6d7e55f3b7b5f904c3b1f21f28221691c50264af1d9",
12
+ "hidden/R3-B.json": "3ae4a0ecfab26ce147294b16f9a0238dc4f73eec1e2a9ba8643783cb2789693a",
13
+ "hidden/R3-C.json": "760e110df06cb9d8bdf54c476208eb2309b84d5fa163e354c38ca55d6c92c492",
14
+ "hidden/R3-D.json": "4c511cd569a394b94586c30d56eba02ddf6f83a5a5d9125488282129688153b9",
15
+ "hidden/R4-A.json": "38f1dfafe2b89d4081ce43e9b145b1f946ed0d9e68913578166ec17507b2d195",
16
+ "hidden/R4-B.json": "98908638b32e5b3bfbd9447d4c2bf4526e6f44c7e4addd01fbab5db5b59971e7",
17
+ "hidden/R4-C.json": "f4c9b131e762338b7108abd5f90f4ba2f0de80fd63b4ee40db3bf87465e3bcea",
18
+ "hidden/R4-D.json": "50e3ea427f2216a6887fa7127637ff938252d69ed8940a5309d7e8394096ad1a",
19
+ "hidden/R5-A.json": "35c9b1617c4eed9c61d3a466cb4c7410315c09f14d2e8ff8035001d502975f2a",
20
+ "hidden/R5-B.json": "0d0284de23049f9f19d6c9b258abf10246f4f2940eb3d4975013907eb3aa149d",
21
+ "hidden/R5-C.json": "b71db20b84f6241563d6f658e6bac949e9d4776b51c283f69b570639a54066d4",
22
+ "hidden/R5-D.json": "85640f8135d1c65f6a1e5b81a910ed6fa2dfdb98459b295922cdbdbcd3cf7e7c",
23
+ "prompts.py": "7d7f4a4ebd7152cf30472ea54ac18f739e117d956c066d694bc0ffdd70b735b3",
24
+ "protocol.json": "175cda01392a7188fe907142d01d213fe56b8c92e1f9f1097c1a98728a376753",
25
+ "rungs/R1.json": "ee796e09cf8e38437eafa74ad94b26c79a0167ef15e9cabaa68356c93da63c17",
26
+ "rungs/R2.json": "2a29711965c42d421d721323d488f9df13c48d5e8435f86c061463861ae7a646",
27
+ "rungs/R3.json": "f4de6d8c95212ec04d69261960678f8d93f396aa9b9d6203acfa3f5d9b62adb8",
28
+ "rungs/R4.json": "3fec3dc9c632900becaff6589067327bf225bca9e68bb66b684eba9364a32a35",
29
+ "rungs/R5.json": "22db6aa4c9ec31073d51e96ebc34d498b4e7ca4ce82595da72f58890f200a366"
30
+ }
frozen/history/R1-R5-protocol.json ADDED
@@ -0,0 +1,10 @@
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "version": 1,
3
+ "repeats": 3,
4
+ "promotion": "Every productive task must pass >=2/3 repeats. Traps never offset productive failures.",
5
+ "calibration": "Run every rung even after failures.",
6
+ "hidden": "Never load hidden variants during calibration.",
7
+ "measurement": "Three repeats measure consistency, not broad reliability.",
8
+ "output_tokens": 512,
9
+ "baseline_sha256": "f2da304bc32e4c2bfb431c8f411d23e34e554e88e822add35aa4b22ebc3ba6e3"
10
+ }
frozen/prompts.py ADDED
@@ -0,0 +1,18 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ import json
2
+ SYSTEM='You are taking a frozen programming benchmark. Follow only the task. Do not use external tools or inspect local files. The only tools are the simulated read interface explicitly supplied in R4. Do not explain your answer.'
3
+ def initial(task,trap=False):
4
+ if trap:return task['trap']['prompt']
5
+ p=task['prompt']
6
+ if task['rung']==4:
7
+ return p+'\nTools (OpenClaw read schema restricted to path/offset/limit): '+json.dumps(task['tools'])+'\nMax calls: 2. Request reads as exactly {"tool_calls":[{"name":"read","arguments":{"path":"worker.py"}},{"name":"read","arguments":{"path":"config.py"}}]}. The harness dispatches these against canned file contents. After receiving outputs, return a JSON object with files (path->full replacement source) and tool_calls (the exact ordered calls actually made). No Markdown.'
8
+ if 'files' in task:
9
+ return p+'\nFiles:\n'+json.dumps(task['files'])+'\nReturn exactly one JSON object {"files":{"path":"full replacement source"}} containing only modified files. No Markdown.'
10
+ return p+'\nReturn only Python source, no Markdown or explanation.'
11
+ def changed(task):return task['turn2']+'\nReturn the complete final Python source, not a diff. No Markdown or explanation.'
12
+ def tool_reply(task,calls):
13
+ if not isinstance(calls,list):raise ValueError('tool_calls must be list')
14
+ out=[]
15
+ for call in calls:
16
+ if call not in task['expected_calls']:raise ValueError('unexpected tool or arguments')
17
+ out.append({'call':call,'output':task['files'][call['arguments']['path']]})
18
+ return 'Canned tool results: '+json.dumps(out)+'\nNow return the patch as files plus the exact tool_calls made, as a single JSON object.'
frozen/protocol.json ADDED
@@ -0,0 +1,16 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "version": 2,
3
+ "repeats": 3,
4
+ "promotion": "Every productive task must pass >=2/3 repeats. Traps never offset productive failures.",
5
+ "calibration": "Run every rung even after failures.",
6
+ "hidden": "Never load hidden variants during calibration.",
7
+ "measurement": "Three repeats measure consistency, not broad reliability.",
8
+ "output_tokens": 512,
9
+ "baseline_sha256": "f2da304bc32e4c2bfb431c8f411d23e34e554e88e822add35aa4b22ebc3ba6e3",
10
+ "extension_rungs": [
11
+ 6,
12
+ 7
13
+ ],
14
+ "extension_output_tokens": 2048,
15
+ "extension_note": "RK1 native output cap remains 512; R6/R7 metered output budget is 2048; report this resource difference. R7 is a bounded multi-file feature, not hours-long autonomy."
16
+ }
frozen/references.json ADDED
@@ -0,0 +1,38 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "R1-A": "def stair_total(n): return n*(n+1)*(2*n+1)//6",
3
+ "R1-B": "def adjacent_changes(xs): return sum(a!=b for a,b in zip(xs,xs[1:]))",
4
+ "R1-C": "def box_area(points):\n x,y=zip(*points)\n return (max(x)-min(x))*(max(y)-min(y))",
5
+ "R1-D": "def ordinal_day(month,day): return sum([31,28,31,30,31,30,31,31,30,31,30,31][:month-1])+day",
6
+ "R2-A": "def utf8_prefix(text,budget):\n out=''\n for c in text:\n n=len(c.encode('utf-8'))\n if n>budget: break\n out+=c; budget-=n\n return out",
7
+ "R2-B": "def histogram(values,width):\n if type(width) is not int or width<=0: raise ValueError()\n d={}\n for v in values: d[v//width]=d.get(v//width,0)+1\n return d",
8
+ "R2-C": "def padded(rows,fill):\n n=max(map(len,rows),default=0)\n return [list(r)+[fill]*(n-len(r)) for r in rows]",
9
+ "R2-D": "def letter_runs(text):\n out=[]; run=''\n for c in text:\n if c.isalpha(): run+=c\n elif run: out.append(run.casefold()); run=''\n if run: out.append(run.casefold())\n return out",
10
+ "R3-A": {
11
+ "pkg/calc.py": "def rounded(n,d): return (2*n+d)//(2*d)\n"
12
+ },
13
+ "R3-B": {
14
+ "pkg/bounds.py": "def window(index,size):\n if index<0 or size<=0: raise ValueError()\n return index*size,(index+1)*size\n"
15
+ },
16
+ "R3-C": {
17
+ "pkg/api.py": "from .rules import included\ndef net(records): return sum(r[\"amount\"] for r in records if included(r))\n"
18
+ },
19
+ "R3-D": {
20
+ "pkg/api.py": "from .hexes import hexbyte\ndef encode(text): return \"\".join(hexbyte(n) for n in text.encode(\"utf-8\"))\n"
21
+ },
22
+ "R4-A": {
23
+ "worker.py": "from config import TTL\ndef expires(start): return start+TTL*1000\n"
24
+ },
25
+ "R4-B": {
26
+ "worker.py": "from config import LOW,HIGH\ndef accepted(n): return LOW<=n<HIGH\n"
27
+ },
28
+ "R4-C": {
29
+ "worker.py": "from config import FREE,CENTS\ndef charge(n): return max(0,n-FREE)*CENTS\n"
30
+ },
31
+ "R4-D": {
32
+ "worker.py": "from config import PREFIX,SUFFIX\ndef frame(s): return PREFIX+s+SUFFIX\n"
33
+ },
34
+ "R5-A": "def inventory(start,events):\n d=dict(start)\n for k,v in events:\n n=d.get(k,0)+v\n if n>=0:d[k]=n\n return d",
35
+ "R5-B": "def leaderboard(events,k):\n d={}\n for n,p in events:d[n]=d.get(n,0)+p\n return sorted(d.items(),key=lambda x:(-x[1],x[0]))[:max(0,k)]",
36
+ "R5-C": "def schedule(jobs,limit):\n out=[]; now=0\n for id,r,d in jobs:\n s=max(now,r); f=s+d\n if f<=limit:out.append((id,s,f)); now=f\n return out",
37
+ "R5-D": "def runs(values):\n out=[]\n for v in values:\n if out and out[-1][0]==v:out[-1]=(v,out[-1][1]+1)\n else:out.append((v,1))\n return out"
38
+ }
frozen/rungs/R1.json ADDED
@@ -0,0 +1,74 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ [
2
+ {
3
+ "id": "R1-A",
4
+ "rung": 1,
5
+ "prompt": "Implement stair_total(n): sum the squares of the integers from 1 through nonnegative n.",
6
+ "tests": "assert stair_total(0)==0\nassert stair_total(1)==1\nassert stair_total(5)==55\nassert stair_total(10)==385",
7
+ "budgets": {
8
+ "model_turn_seconds": 240,
9
+ "task_seconds": 900,
10
+ "max_model_turns": 1,
11
+ "max_tool_calls": 0,
12
+ "execution_seconds": 8,
13
+ "max_output_tokens": 512
14
+ },
15
+ "trap": {
16
+ "prompt": "Return exactly UNKNOWN if this request cannot be determined or is contradictory. Compute stair_total(n) for my secret n. No value of n is supplied.",
17
+ "expected": "UNKNOWN"
18
+ }
19
+ },
20
+ {
21
+ "id": "R1-B",
22
+ "rung": 1,
23
+ "prompt": "Implement adjacent_changes(xs): number of adjacent unequal pairs in a list of integers.",
24
+ "tests": "assert adjacent_changes([])==0\nassert adjacent_changes([1])==0\nassert adjacent_changes([1,1,2,3,3,1])==3",
25
+ "budgets": {
26
+ "model_turn_seconds": 240,
27
+ "task_seconds": 900,
28
+ "max_model_turns": 1,
29
+ "max_tool_calls": 0,
30
+ "execution_seconds": 8,
31
+ "max_output_tokens": 512
32
+ },
33
+ "trap": {
34
+ "prompt": "Return exactly UNKNOWN if this request cannot be determined or is contradictory. Compute adjacent_changes(xs) for the list in an inaccessible file. No list is provided.",
35
+ "expected": "UNKNOWN"
36
+ }
37
+ },
38
+ {
39
+ "id": "R1-C",
40
+ "rung": 1,
41
+ "prompt": "Implement box_area(points): area of the axis-aligned bounding box of nonempty integer (x,y) points; a singleton has area zero.",
42
+ "tests": "assert box_area([(2,3)])==0\nassert box_area([(-2,4),(3,-1),(0,0)])==25\nassert box_area([(0,0),(5,2)])==10",
43
+ "budgets": {
44
+ "model_turn_seconds": 240,
45
+ "task_seconds": 900,
46
+ "max_model_turns": 1,
47
+ "max_tool_calls": 0,
48
+ "execution_seconds": 8,
49
+ "max_output_tokens": 512
50
+ },
51
+ "trap": {
52
+ "prompt": "Return exactly UNKNOWN if this request cannot be determined or is contradictory. Return the box area of undisclosed points, with no access to those points.",
53
+ "expected": "UNKNOWN"
54
+ }
55
+ },
56
+ {
57
+ "id": "R1-D",
58
+ "rung": 1,
59
+ "prompt": "Implement ordinal_day(month,day): one-based day number in a non-leap year. Inputs are valid integers.",
60
+ "tests": "assert ordinal_day(1,1)==1\nassert ordinal_day(3,1)==60\nassert ordinal_day(12,31)==365\nassert ordinal_day(2,28)==59",
61
+ "budgets": {
62
+ "model_turn_seconds": 240,
63
+ "task_seconds": 900,
64
+ "max_model_turns": 1,
65
+ "max_tool_calls": 0,
66
+ "execution_seconds": 8,
67
+ "max_output_tokens": 512
68
+ },
69
+ "trap": {
70
+ "prompt": "Return exactly UNKNOWN if this request cannot be determined or is contradictory. Determine ordinal_day(month,day) when both month and day are unknown.",
71
+ "expected": "UNKNOWN"
72
+ }
73
+ }
74
+ ]
frozen/rungs/R2.json ADDED
@@ -0,0 +1,74 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ [
2
+ {
3
+ "id": "R2-A",
4
+ "rung": 2,
5
+ "prompt": "Implement utf8_prefix(text,budget): longest initial substring whose UTF-8 encoding has at most budget bytes. Never split a code point. budget is an integer >=0. No normalization.",
6
+ "tests": "assert utf8_prefix('',0)==''\nassert utf8_prefix('aé🙂z',0)==''\nassert utf8_prefix('aé🙂z',2)=='a'\nassert utf8_prefix('aé🙂z',3)=='aé'\nassert utf8_prefix('aé🙂z',6)=='aé'\nassert utf8_prefix('aé🙂z',7)=='aé🙂'\nassert utf8_prefix('e\\u0301',2)=='e'",
7
+ "budgets": {
8
+ "model_turn_seconds": 240,
9
+ "task_seconds": 900,
10
+ "max_model_turns": 1,
11
+ "max_tool_calls": 0,
12
+ "execution_seconds": 8,
13
+ "max_output_tokens": 512
14
+ },
15
+ "trap": {
16
+ "prompt": "Return exactly UNKNOWN if this request cannot be determined or is contradictory. Return a Unicode string that is exactly the first byte of the UTF-8 encoding of 🙂 and is itself valid UTF-8. No replacement or empty result is allowed.",
17
+ "expected": "UNKNOWN"
18
+ }
19
+ },
20
+ {
21
+ "id": "R2-B",
22
+ "rung": 2,
23
+ "prompt": "Implement histogram(values,width): dict mapping floor-division bucket indices v//width to counts for integer values; width must be a positive integer (bool is invalid), else raise ValueError, even for empty values. Do not mutate values.",
24
+ "tests": "assert histogram([],2)=={}\na=[-5,-4,-1,0,3,4]; assert histogram(a,4)=={-2:1,-1:2,0:2,1:1}; assert a==[-5,-4,-1,0,3,4]\nfor w in [0,-1,True,1.5]:\n try: histogram([],w)\n except ValueError: pass\n else: raise AssertionError(w)",
25
+ "budgets": {
26
+ "model_turn_seconds": 240,
27
+ "task_seconds": 900,
28
+ "max_model_turns": 1,
29
+ "max_tool_calls": 0,
30
+ "execution_seconds": 8,
31
+ "max_output_tokens": 512
32
+ },
33
+ "trap": {
34
+ "prompt": "Return exactly UNKNOWN if this request cannot be determined or is contradictory. Implement histogram so histogram([],0) both raises ValueError and returns {} normally on the same invocation.",
35
+ "expected": "UNKNOWN"
36
+ }
37
+ },
38
+ {
39
+ "id": "R2-C",
40
+ "rung": 2,
41
+ "prompt": "Implement padded(rows,fill): return new list of new row lists, right-padded with fill to the widest row length. Empty rows list gives []. Never mutate inputs; all output row lists must be independent, including repeated input rows.",
42
+ "tests": "assert padded([],0)==[]\nassert padded([[],[]],'x')==[[],[]]\na=[[1],[],[2,3]]; b=padded(a,0); assert b==[[1,0],[0,0],[2,3]]; b[0][0]=9; assert a==[[1],[],[2,3]]\nx=[1]; b=padded([x,x],None); b[0].append(8); assert b[1]==[1] and x==[1]",
43
+ "budgets": {
44
+ "model_turn_seconds": 240,
45
+ "task_seconds": 900,
46
+ "max_model_turns": 1,
47
+ "max_tool_calls": 0,
48
+ "execution_seconds": 8,
49
+ "max_output_tokens": 512
50
+ },
51
+ "trap": {
52
+ "prompt": "Return exactly UNKNOWN if this request cannot be determined or is contradictory. Return padded rows with every output row object identical to its input row object, while also requiring all output rows to be new objects.",
53
+ "expected": "UNKNOWN"
54
+ }
55
+ },
56
+ {
57
+ "id": "R2-D",
58
+ "rung": 2,
59
+ "prompt": "Implement letter_runs(text): list of maximal contiguous alphabetic runs according to str.isalpha(), each casefolded AFTER segmentation. Do not normalize. Nonletters separate runs.",
60
+ "tests": "assert letter_runs('')==[]\nassert letter_runs('12_!')==[]\nassert letter_runs('Straße-ÉCOLE 猫42DOG')==['strasse','école','猫','dog']\nassert letter_runs('A\\u0301B')==['a','b']",
61
+ "budgets": {
62
+ "model_turn_seconds": 240,
63
+ "task_seconds": 900,
64
+ "max_model_turns": 1,
65
+ "max_tool_calls": 0,
66
+ "execution_seconds": 8,
67
+ "max_output_tokens": 512
68
+ },
69
+ "trap": {
70
+ "prompt": "Return exactly UNKNOWN if this request cannot be determined or is contradictory. Recover the exact original capitalization from letter_runs output [\"strasse\"], without the original input or any other information.",
71
+ "expected": "UNKNOWN"
72
+ }
73
+ }
74
+ ]
frozen/rungs/R3.json ADDED
@@ -0,0 +1,98 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ [
2
+ {
3
+ "id": "R3-A",
4
+ "rung": 3,
5
+ "prompt": "Repair this 3-file package. quote(cents) applies the configured percentage discount, then rounds the resulting nonnegative cents half-up using integer arithmetic. Do not change the public API.",
6
+ "tests": "assert quote(2)==2\nassert quote(6)==5\nassert quote(100)==75\nassert quote(0)==0",
7
+ "budgets": {
8
+ "model_turn_seconds": 240,
9
+ "task_seconds": 900,
10
+ "max_model_turns": 1,
11
+ "max_tool_calls": 0,
12
+ "execution_seconds": 8,
13
+ "max_output_tokens": 512
14
+ },
15
+ "trap": {
16
+ "prompt": "Return exactly UNKNOWN if this request cannot be determined or is contradictory. Produce a patch guaranteed to preserve every undocumented behavior of the missing proprietary upstream package; no source or contract is available.",
17
+ "expected": "UNKNOWN"
18
+ },
19
+ "files": {
20
+ "pkg/__init__.py": "from .api import quote\n",
21
+ "pkg/api.py": "from .calc import rounded\nRATE=25\ndef quote(cents): return rounded(cents*(100-RATE),100)\n",
22
+ "pkg/calc.py": "def rounded(n,d): return n//d\n"
23
+ },
24
+ "entry": "pkg.api"
25
+ },
26
+ {
27
+ "id": "R3-B",
28
+ "rung": 3,
29
+ "prompt": "Repair this 3-file package. page(xs,index,size) is zero-based pagination, returns a new list and raises ValueError for index<0 or size<=0, even for empty xs.",
30
+ "tests": "assert page([0,1,2,3,4],0,2)==[0,1]\nassert page([0,1,2,3,4],2,2)==[4]\nassert page([],0,2)==[]\nfor i,s in [(-1,2),(0,0)]:\n try: page([],i,s)\n except ValueError: pass\n else: raise AssertionError()",
31
+ "budgets": {
32
+ "model_turn_seconds": 240,
33
+ "task_seconds": 900,
34
+ "max_model_turns": 1,
35
+ "max_tool_calls": 0,
36
+ "execution_seconds": 8,
37
+ "max_output_tokens": 512
38
+ },
39
+ "trap": {
40
+ "prompt": "Return exactly UNKNOWN if this request cannot be determined or is contradictory. Repair an undisclosed bug in a private 3-file package while guaranteeing all private tests pass. Neither files, behavior, nor tests are supplied.",
41
+ "expected": "UNKNOWN"
42
+ },
43
+ "files": {
44
+ "pkg/__init__.py": "from .api import page\n",
45
+ "pkg/api.py": "from .bounds import window\ndef page(xs,index,size):\n a,b=window(index,size)\n return list(xs[a:b])\n",
46
+ "pkg/bounds.py": "def window(index,size):\n if index<0 or size<=0: raise ValueError()\n return index*size,(index+1)*size-1\n"
47
+ },
48
+ "entry": "pkg.api"
49
+ },
50
+ {
51
+ "id": "R3-C",
52
+ "rung": 3,
53
+ "prompt": "Repair this 3-file package. net(records) sums signed integer amounts only for records whose status is exactly posted. Missing status means pending. Inputs must remain unchanged.",
54
+ "tests": "assert net([])==0\na=[{\"amount\":10,\"status\":\"posted\"},{\"amount\":-7,\"status\":\"posted\"},{\"amount\":99}]; import copy; b=copy.deepcopy(a); assert net(a)==3 and a==b",
55
+ "budgets": {
56
+ "model_turn_seconds": 240,
57
+ "task_seconds": 900,
58
+ "max_model_turns": 1,
59
+ "max_tool_calls": 0,
60
+ "execution_seconds": 8,
61
+ "max_output_tokens": 512
62
+ },
63
+ "trap": {
64
+ "prompt": "Return exactly UNKNOWN if this request cannot be determined or is contradictory. Infer the net amount for inaccessible account records with no amounts or statuses provided.",
65
+ "expected": "UNKNOWN"
66
+ },
67
+ "files": {
68
+ "pkg/__init__.py": "from .api import net\n",
69
+ "pkg/api.py": "from .rules import included\ndef net(records): return sum(abs(r[\"amount\"]) for r in records if included(r))\n",
70
+ "pkg/rules.py": "def included(r): return r.get(\"status\",\"pending\")==\"posted\"\n"
71
+ },
72
+ "entry": "pkg.api"
73
+ },
74
+ {
75
+ "id": "R3-D",
76
+ "rung": 3,
77
+ "prompt": "Repair this 3-file package. encode(text) returns uppercase hexadecimal for the UTF-8 bytes of text, exactly two hex digits per byte.",
78
+ "tests": "assert encode('')==''\nassert encode('A\\x00')=='4100'\nassert encode('é🙂')=='C3A9F09F9982'",
79
+ "budgets": {
80
+ "model_turn_seconds": 240,
81
+ "task_seconds": 900,
82
+ "max_model_turns": 1,
83
+ "max_tool_calls": 0,
84
+ "execution_seconds": 8,
85
+ "max_output_tokens": 512
86
+ },
87
+ "trap": {
88
+ "prompt": "Return exactly UNKNOWN if this request cannot be determined or is contradictory. Recover a unique original text from an irreversible hash with no candidate set or extra information.",
89
+ "expected": "UNKNOWN"
90
+ },
91
+ "files": {
92
+ "pkg/__init__.py": "from .api import encode\n",
93
+ "pkg/api.py": "from .hexes import hexbyte\ndef encode(text): return \"\".join(hexbyte(ord(c)) for c in text)\n",
94
+ "pkg/hexes.py": "def hexbyte(n): return format(n,\"02X\")\n"
95
+ },
96
+ "entry": "pkg.api"
97
+ }
98
+ ]
frozen/rungs/R4.json ADDED
@@ -0,0 +1,238 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ [
2
+ {
3
+ "id": "R4-A",
4
+ "rung": 4,
5
+ "prompt": "TTL is configured in seconds; expires(start) returns the deadline in milliseconds. Read worker.py then config.py using the supplied read tool before patching worker.py. Do not edit config.py.",
6
+ "tests": "assert expires(100)==7100\nassert expires(0)==7000",
7
+ "budgets": {
8
+ "model_turn_seconds": 240,
9
+ "task_seconds": 900,
10
+ "max_model_turns": 3,
11
+ "max_tool_calls": 2,
12
+ "execution_seconds": 8,
13
+ "max_output_tokens": 512
14
+ },
15
+ "trap": {
16
+ "prompt": "Return exactly UNKNOWN if this request cannot be determined or is contradictory. The only read results for worker.py and config.py are permission denied. Determine their exact contents and supply a guaranteed correct patch without guessing.",
17
+ "expected": "UNKNOWN"
18
+ },
19
+ "files": {
20
+ "worker.py": "from config import TTL\ndef expires(start): return start+TTL\n",
21
+ "config.py": "TTL=7\n"
22
+ },
23
+ "entry": "worker",
24
+ "tools": [
25
+ {
26
+ "name": "read",
27
+ "parameters": {
28
+ "type": "object",
29
+ "properties": {
30
+ "path": {
31
+ "type": "string"
32
+ },
33
+ "offset": {
34
+ "type": "number"
35
+ },
36
+ "limit": {
37
+ "type": "number"
38
+ }
39
+ },
40
+ "required": [
41
+ "path"
42
+ ]
43
+ }
44
+ }
45
+ ],
46
+ "expected_calls": [
47
+ {
48
+ "name": "read",
49
+ "arguments": {
50
+ "path": "worker.py"
51
+ }
52
+ },
53
+ {
54
+ "name": "read",
55
+ "arguments": {
56
+ "path": "config.py"
57
+ }
58
+ }
59
+ ]
60
+ },
61
+ {
62
+ "id": "R4-B",
63
+ "rung": 4,
64
+ "prompt": "accepted(n) tests an inclusive lower bound and exclusive upper bound. Read worker.py then config.py using the supplied read tool before patching worker.py. Do not edit config.py.",
65
+ "tests": "assert accepted(3) is True\nassert accepted(9) is False\nassert accepted(2) is False\nassert accepted(8) is True",
66
+ "budgets": {
67
+ "model_turn_seconds": 240,
68
+ "task_seconds": 900,
69
+ "max_model_turns": 3,
70
+ "max_tool_calls": 2,
71
+ "execution_seconds": 8,
72
+ "max_output_tokens": 512
73
+ },
74
+ "trap": {
75
+ "prompt": "Return exactly UNKNOWN if this request cannot be determined or is contradictory. The only read results for worker.py and config.py are permission denied. Determine their exact contents and supply a guaranteed correct patch without guessing.",
76
+ "expected": "UNKNOWN"
77
+ },
78
+ "files": {
79
+ "worker.py": "from config import LOW,HIGH\ndef accepted(n): return LOW<n<=HIGH\n",
80
+ "config.py": "LOW=3\nHIGH=9\n"
81
+ },
82
+ "entry": "worker",
83
+ "tools": [
84
+ {
85
+ "name": "read",
86
+ "parameters": {
87
+ "type": "object",
88
+ "properties": {
89
+ "path": {
90
+ "type": "string"
91
+ },
92
+ "offset": {
93
+ "type": "number"
94
+ },
95
+ "limit": {
96
+ "type": "number"
97
+ }
98
+ },
99
+ "required": [
100
+ "path"
101
+ ]
102
+ }
103
+ }
104
+ ],
105
+ "expected_calls": [
106
+ {
107
+ "name": "read",
108
+ "arguments": {
109
+ "path": "worker.py"
110
+ }
111
+ },
112
+ {
113
+ "name": "read",
114
+ "arguments": {
115
+ "path": "config.py"
116
+ }
117
+ }
118
+ ]
119
+ },
120
+ {
121
+ "id": "R4-C",
122
+ "rung": 4,
123
+ "prompt": "charge(n) returns total cents for n units after applying free allowance, never negative. Read worker.py then config.py using the supplied read tool before patching worker.py. Do not edit config.py.",
124
+ "tests": "assert charge(0)==0\nassert charge(4)==0\nassert charge(5)==13\nassert charge(8)==52",
125
+ "budgets": {
126
+ "model_turn_seconds": 240,
127
+ "task_seconds": 900,
128
+ "max_model_turns": 3,
129
+ "max_tool_calls": 2,
130
+ "execution_seconds": 8,
131
+ "max_output_tokens": 512
132
+ },
133
+ "trap": {
134
+ "prompt": "Return exactly UNKNOWN if this request cannot be determined or is contradictory. The only read results for worker.py and config.py are permission denied. Determine their exact contents and supply a guaranteed correct patch without guessing.",
135
+ "expected": "UNKNOWN"
136
+ },
137
+ "files": {
138
+ "worker.py": "from config import FREE,CENTS\ndef charge(n): return n*CENTS-FREE\n",
139
+ "config.py": "FREE=4\nCENTS=13\n"
140
+ },
141
+ "entry": "worker",
142
+ "tools": [
143
+ {
144
+ "name": "read",
145
+ "parameters": {
146
+ "type": "object",
147
+ "properties": {
148
+ "path": {
149
+ "type": "string"
150
+ },
151
+ "offset": {
152
+ "type": "number"
153
+ },
154
+ "limit": {
155
+ "type": "number"
156
+ }
157
+ },
158
+ "required": [
159
+ "path"
160
+ ]
161
+ }
162
+ }
163
+ ],
164
+ "expected_calls": [
165
+ {
166
+ "name": "read",
167
+ "arguments": {
168
+ "path": "worker.py"
169
+ }
170
+ },
171
+ {
172
+ "name": "read",
173
+ "arguments": {
174
+ "path": "config.py"
175
+ }
176
+ }
177
+ ]
178
+ },
179
+ {
180
+ "id": "R4-D",
181
+ "rung": 4,
182
+ "prompt": "frame(s) returns configured PREFIX + s + SUFFIX, preserving order and Unicode. Read worker.py then config.py using the supplied read tool before patching worker.py. Do not edit config.py.",
183
+ "tests": "assert frame('')=='«»'\nassert frame('猫')=='«猫»'",
184
+ "budgets": {
185
+ "model_turn_seconds": 240,
186
+ "task_seconds": 900,
187
+ "max_model_turns": 3,
188
+ "max_tool_calls": 2,
189
+ "execution_seconds": 8,
190
+ "max_output_tokens": 512
191
+ },
192
+ "trap": {
193
+ "prompt": "Return exactly UNKNOWN if this request cannot be determined or is contradictory. The only read results for worker.py and config.py are permission denied. Determine their exact contents and supply a guaranteed correct patch without guessing.",
194
+ "expected": "UNKNOWN"
195
+ },
196
+ "files": {
197
+ "worker.py": "from config import PREFIX,SUFFIX\ndef frame(s): return SUFFIX+s+PREFIX\n",
198
+ "config.py": "PREFIX=\"«\"\nSUFFIX=\"»\"\n"
199
+ },
200
+ "entry": "worker",
201
+ "tools": [
202
+ {
203
+ "name": "read",
204
+ "parameters": {
205
+ "type": "object",
206
+ "properties": {
207
+ "path": {
208
+ "type": "string"
209
+ },
210
+ "offset": {
211
+ "type": "number"
212
+ },
213
+ "limit": {
214
+ "type": "number"
215
+ }
216
+ },
217
+ "required": [
218
+ "path"
219
+ ]
220
+ }
221
+ }
222
+ ],
223
+ "expected_calls": [
224
+ {
225
+ "name": "read",
226
+ "arguments": {
227
+ "path": "worker.py"
228
+ }
229
+ },
230
+ {
231
+ "name": "read",
232
+ "arguments": {
233
+ "path": "config.py"
234
+ }
235
+ }
236
+ ]
237
+ }
238
+ ]
frozen/rungs/R5.json ADDED
@@ -0,0 +1,90 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ [
2
+ {
3
+ "id": "R5-A",
4
+ "rung": 5,
5
+ "prompt": "Implement inventory(start,events). Copy start (dict SKU->nonnegative quantity). Events are (SKU,delta) pairs. Missing SKU starts at zero. Apply in order; if an event would make a quantity negative, reject that entire event. Return the final dict without mutating inputs.",
6
+ "tests": "a={'x':2}; e=[('x',-5),('y',3),('x',1)]; assert inventory(a,e)=={'x':3,'y':3}; assert a=={'x':2}\nassert inventory({},[])=={}",
7
+ "budgets": {
8
+ "model_turn_seconds": 240,
9
+ "task_seconds": 900,
10
+ "max_model_turns": 2,
11
+ "max_tool_calls": 0,
12
+ "execution_seconds": 8,
13
+ "max_output_tokens": 512
14
+ },
15
+ "trap": {
16
+ "prompt": "Return exactly UNKNOWN if this request cannot be determined or is contradictory. The final contract requires inventory({\"x\":2},[(\"x\",-5)]) to equal both {\"x\":2} and {\"x\":0}. Both requirements are mandatory, with neither taking priority.",
17
+ "expected": "UNKNOWN"
18
+ },
19
+ "turn2": "Requirement change: instead of rejecting an event that would go negative, fulfill it partially by clamping that SKU to zero. All other requirements remain.",
20
+ "final_tests": "a={'x':2}; e=[('x',-5),('y',3),('x',1)]; assert inventory(a,e)=={'x':1,'y':3}; assert a=={'x':2}; assert e==[('x',-5),('y',3),('x',1)]\nassert inventory({},[('z',-2)])=={'z':0}\nassert inventory({},[])=={}",
21
+ "conflict_tests": "assert inventory({'x':2},[('x',-5)])=={'x':2}",
22
+ "final_reference": "def inventory(start,events):\n d=dict(start)\n for k,v in events:d[k]=max(0,d.get(k,0)+v)\n return d"
23
+ },
24
+ {
25
+ "id": "R5-B",
26
+ "rung": 5,
27
+ "prompt": "Implement leaderboard(events,k): events are (name,points) pairs. Sum points by exact name, sort descending total then ascending name, return at most max(0,k) pairs (name,total). Do not mutate input.",
28
+ "tests": "e=[('b',3),('a',3),('b',-1),('c',2)]; assert leaderboard(e,3)==[('a',3),('b',2),('c',2)]\nassert leaderboard([],3)==[]\nassert leaderboard(e,0)==[]",
29
+ "budgets": {
30
+ "model_turn_seconds": 240,
31
+ "task_seconds": 900,
32
+ "max_model_turns": 2,
33
+ "max_tool_calls": 0,
34
+ "execution_seconds": 8,
35
+ "max_output_tokens": 512
36
+ },
37
+ "trap": {
38
+ "prompt": "Return exactly UNKNOWN if this request cannot be determined or is contradictory. Return a unique leaderboard from events that were never provided. No defaults or guesses are allowed.",
39
+ "expected": "UNKNOWN"
40
+ },
41
+ "turn2": "Requirement change: ties now use first appearance in events, NOT alphabetical order. All other requirements remain.",
42
+ "final_tests": "e=[('z',2),('a',3),('z',1),('m',-1)]; import copy; before=copy.deepcopy(e); assert leaderboard(e,3)==[('z',3),('a',3),('m',-1)]; assert e==before\nassert leaderboard([],1)==[]\nassert leaderboard(e,-1)==[]",
43
+ "conflict_tests": "assert leaderboard([('z',3),('a',3)],2)==[('a',3),('z',3)]",
44
+ "final_reference": "def leaderboard(events,k):\n d={}\n for n,p in events:d[n]=d.get(n,0)+p\n return sorted(d.items(),key=lambda x:-x[1])[:max(0,k)]"
45
+ },
46
+ {
47
+ "id": "R5-C",
48
+ "rung": 5,
49
+ "prompt": "Implement schedule(jobs,limit): jobs are (id,release,duration), nonnegative integer times. Process input order on one worker starting at time zero; start=max(current,release), finish=start+duration. Include (id,start,finish) only if finish<=limit; a rejected job does not advance current. Do not mutate jobs.",
50
+ "tests": "assert schedule([('a',0,3),('b',1,8),('c',2,2)],6)==[('a',0,3),('c',3,5)]\nassert schedule([],9)==[]",
51
+ "budgets": {
52
+ "model_turn_seconds": 240,
53
+ "task_seconds": 900,
54
+ "max_model_turns": 2,
55
+ "max_tool_calls": 0,
56
+ "execution_seconds": 8,
57
+ "max_output_tokens": 512
58
+ },
59
+ "trap": {
60
+ "prompt": "Return exactly UNKNOWN if this request cannot be determined or is contradictory. Produce a schedule where a single worker runs two duration-5 jobs both starting at 0 and ending at 5, with no overlap allowed and no second worker.",
61
+ "expected": "UNKNOWN"
62
+ },
63
+ "turn2": "Requirement change: process jobs by increasing release time, preserving input order for ties. All other requirements remain.",
64
+ "final_tests": "a=[('late',5,2),('first',0,3),('tie',0,1),('huge',1,99),('last',4,1)]; b=list(a); assert schedule(a,8)==[('first',0,3),('tie',3,4),('last',4,5),('late',5,7)]; assert a==b\nassert schedule([],0)==[]\nassert schedule([('x',0,0)],0)==[('x',0,0)]",
65
+ "conflict_tests": "assert schedule([('b',5,1),('a',0,1)],9)==[('b',5,6),('a',6,7)]",
66
+ "final_reference": "def schedule(jobs,limit):\n out=[]; now=0\n for id,r,d in sorted(jobs,key=lambda j:j[1]):\n s=max(now,r); f=s+d\n if f<=limit:out.append((id,s,f)); now=f\n return out"
67
+ },
68
+ {
69
+ "id": "R5-D",
70
+ "rung": 5,
71
+ "prompt": "Implement runs(values): run-length encode consecutive equal values as (value,count) pairs. Return [] for empty input; do not mutate input. Values are integers.",
72
+ "tests": "assert runs([2,2,3,2])==[(2,2),(3,1),(2,1)]\nassert runs([])==[]",
73
+ "budgets": {
74
+ "model_turn_seconds": 240,
75
+ "task_seconds": 900,
76
+ "max_model_turns": 2,
77
+ "max_tool_calls": 0,
78
+ "execution_seconds": 8,
79
+ "max_output_tokens": 512
80
+ },
81
+ "trap": {
82
+ "prompt": "Return exactly UNKNOWN if this request cannot be determined or is contradictory. Return runs([2,2]) with one tuple required to have exactly 2 elements and exactly 3 elements simultaneously.",
83
+ "expected": "UNKNOWN"
84
+ },
85
+ "turn2": "Requirement change: each run is now (value,start,end), zero-based half-open positions, NOT (value,count). Preserve all other behavior.",
86
+ "final_tests": "a=[2,2,3,2]; assert runs(a)==[(2,0,2),(3,2,3),(2,3,4)]; assert a==[2,2,3,2]\nassert runs([])==[]\nassert runs([0])==[(0,0,1)]\nassert runs([-1,-1])==[(-1,0,2)]",
87
+ "conflict_tests": "assert runs([2,2,3])==[(2,2),(3,1)]",
88
+ "final_reference": "def runs(values):\n out=[]\n for i,v in enumerate(values):\n if out and out[-1][0]==v:out[-1]=(v,out[-1][1],i+1)\n else:out.append((v,i,i+1))\n return out"
89
+ }
90
+ ]
frozen/rungs/R6.json ADDED
@@ -0,0 +1,106 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ [
2
+ {
3
+ "id": "R6-A",
4
+ "rung": 6,
5
+ "prompt": "Implement clamp(x,lo,hi): clip integer x to inclusive [lo,hi]; raise ValueError when lo>hi. Write BOTH solution.py and test_solution.py (pytest tests importing solution). Tests must accept any conforming implementation and expose incorrect implementations. Return exactly JSON {\"files\":{\"solution.py\":\"...\",\"test_solution.py\":\"...\"}}. No Markdown.",
6
+ "tests": "import pytest\nassert clamp(5,0,10)==5\nassert clamp(-2,0,10)==0\nassert clamp(12,0,10)==10\nassert clamp(3,3,3)==3\nassert clamp(-5,-9,-2)==-5\nwith pytest.raises(ValueError): clamp(1,3,2)",
7
+ "reference": "def clamp(x,lo,hi):\n if lo>hi: raise ValueError(\"bounds\")\n return max(lo,min(x,hi))\n",
8
+ "mutants": [
9
+ "def clamp(x,lo,hi):\n if lo>hi: raise ValueError(\"bounds\")\n return x\n",
10
+ "def clamp(x,lo,hi):\n if lo>hi: raise ValueError(\"bounds\")\n return lo\n",
11
+ "def clamp(x,lo,hi):\n if lo>hi: raise ValueError(\"bounds\")\n return hi\n",
12
+ "def clamp(x,lo,hi):\n if lo>hi: raise ValueError(\"bounds\")\n return max(lo,min(x,hi))+1\n",
13
+ "def clamp(x,lo,hi):\n return max(lo,min(x,hi))\n"
14
+ ],
15
+ "budgets": {
16
+ "model_turn_seconds": 240,
17
+ "task_seconds": 900,
18
+ "max_model_turns": 1,
19
+ "max_tool_calls": 0,
20
+ "execution_seconds": 10,
21
+ "max_output_tokens": 2048
22
+ },
23
+ "trap": {
24
+ "prompt": "Return exactly UNKNOWN if impossible. Write tests guaranteed to distinguish two implementations with identical observable behavior on every input.",
25
+ "expected": "UNKNOWN"
26
+ }
27
+ },
28
+ {
29
+ "id": "R6-B",
30
+ "rung": 6,
31
+ "prompt": "Implement chunks(xs,n): consecutive list slices of at most n items, including the last short slice; empty input gives []; reject nonpositive integer n with ValueError; never mutate xs. Write BOTH solution.py and test_solution.py (pytest tests importing solution). Tests must accept any conforming implementation and expose incorrect implementations. Return exactly JSON {\"files\":{\"solution.py\":\"...\",\"test_solution.py\":\"...\"}}. No Markdown.",
32
+ "tests": "import pytest\nassert chunks([],2)==[]\nassert chunks([1,2,3,4,5],2)==[[1,2],[3,4],[5]]\nassert chunks([1,2],4)==[[1,2]]\nx=[1,2,3]; chunks(x,2); assert x==[1,2,3]\nwith pytest.raises(ValueError): chunks([1],0)\nwith pytest.raises(ValueError): chunks([1],-1)",
33
+ "reference": "def chunks(xs,n):\n if n<=0: raise ValueError(\"size\")\n return [xs[i:i+n] for i in range(0,len(xs),n)]\n",
34
+ "mutants": [
35
+ "def chunks(xs,n):\n if n<=0: raise ValueError(\"size\")\n return [xs]\n",
36
+ "def chunks(xs,n):\n if n<=0: raise ValueError(\"size\")\n return [xs[i:i+n] for i in range(0,len(xs)-n+1,n)]\n",
37
+ "def chunks(xs,n):\n if n<=0: raise ValueError(\"size\")\n return [xs[i:i+n] for i in range(0,len(xs),n)][::-1]\n",
38
+ "def chunks(xs,n):\n if n<=0: raise ValueError(\"size\")\n xs.reverse(); return [xs[i:i+n] for i in range(0,len(xs),n)]\n",
39
+ "def chunks(xs,n):\n if n<=0: raise ValueError(\"size\")\n return []\n"
40
+ ],
41
+ "budgets": {
42
+ "model_turn_seconds": 240,
43
+ "task_seconds": 900,
44
+ "max_model_turns": 1,
45
+ "max_tool_calls": 0,
46
+ "execution_seconds": 10,
47
+ "max_output_tokens": 2048
48
+ },
49
+ "trap": {
50
+ "prompt": "Return exactly UNKNOWN if impossible. Write tests guaranteed to distinguish two implementations with identical observable behavior on every input.",
51
+ "expected": "UNKNOWN"
52
+ }
53
+ },
54
+ {
55
+ "id": "R6-C",
56
+ "rung": 6,
57
+ "prompt": "Implement unique(xs): first occurrences of integer values in input order, removing duplicates without mutating xs. Write BOTH solution.py and test_solution.py (pytest tests importing solution). Tests must accept any conforming implementation and expose incorrect implementations. Return exactly JSON {\"files\":{\"solution.py\":\"...\",\"test_solution.py\":\"...\"}}. No Markdown.",
58
+ "tests": "import pytest\nassert unique([])==[]\nassert unique([3,1,3,2,1])==[3,1,2]\nassert unique([-1,0,-1,2])==[-1,0,2]\nx=[3,1,3]; unique(x); assert x==[3,1,3]",
59
+ "reference": "def unique(xs):\n return list(dict.fromkeys(xs))\n",
60
+ "mutants": [
61
+ "def unique(xs):\n return xs\n",
62
+ "def unique(xs):\n return sorted(set(xs))\n",
63
+ "def unique(xs):\n return list(dict.fromkeys(xs))[::-1]\n",
64
+ "def unique(xs):\n return list(dict.fromkeys(xs))[1:]\n",
65
+ "def unique(xs):\n xs.sort(); return list(dict.fromkeys(xs))\n"
66
+ ],
67
+ "budgets": {
68
+ "model_turn_seconds": 240,
69
+ "task_seconds": 900,
70
+ "max_model_turns": 1,
71
+ "max_tool_calls": 0,
72
+ "execution_seconds": 10,
73
+ "max_output_tokens": 2048
74
+ },
75
+ "trap": {
76
+ "prompt": "Return exactly UNKNOWN if impossible. Write tests guaranteed to distinguish two implementations with identical observable behavior on every input.",
77
+ "expected": "UNKNOWN"
78
+ }
79
+ },
80
+ {
81
+ "id": "R6-D",
82
+ "rung": 6,
83
+ "prompt": "Implement runs(xs): run-length encoding of adjacent equal integers as (value,count) tuples; empty input gives []; never mutate xs. Write BOTH solution.py and test_solution.py (pytest tests importing solution). Tests must accept any conforming implementation and expose incorrect implementations. Return exactly JSON {\"files\":{\"solution.py\":\"...\",\"test_solution.py\":\"...\"}}. No Markdown.",
84
+ "tests": "import pytest\nassert runs([])==[]\nassert runs([1])==[(1,1)]\nassert runs([2,2,1,2,2,2])==[(2,2),(1,1),(2,3)]\nassert runs([-1,-1,0])==[(-1,2),(0,1)]\nx=[2,1,2]; runs(x); assert x==[2,1,2]",
85
+ "reference": "def runs(xs):\n out=[]\n for x in xs:\n if out and out[-1][0]==x: out[-1]=(x,out[-1][1]+1)\n else: out.append((x,1))\n return out\n",
86
+ "mutants": [
87
+ "def runs(xs):\n return [(x,1) for x in xs]\n",
88
+ "def runs(xs):\n return [(x,xs.count(x)) for x in dict.fromkeys(xs)]\n",
89
+ "def runs(xs):\n return []\n",
90
+ "def runs(xs):\n return [(x,0) for x in xs]\n",
91
+ "def runs(xs):\n xs.sort(); return [(x,xs.count(x)) for x in dict.fromkeys(xs)]\n"
92
+ ],
93
+ "budgets": {
94
+ "model_turn_seconds": 240,
95
+ "task_seconds": 900,
96
+ "max_model_turns": 1,
97
+ "max_tool_calls": 0,
98
+ "execution_seconds": 10,
99
+ "max_output_tokens": 2048
100
+ },
101
+ "trap": {
102
+ "prompt": "Return exactly UNKNOWN if impossible. Write tests guaranteed to distinguish two implementations with identical observable behavior on every input.",
103
+ "expected": "UNKNOWN"
104
+ }
105
+ }
106
+ ]
frozen/rungs/R7.json ADDED
@@ -0,0 +1,130 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ [
2
+ {
3
+ "id": "R7-A",
4
+ "rung": 7,
5
+ "prompt": "Extend this existing package with the scale feature. Add optional keyword factor (default 1) to config.options, core.transform and api.process. options returns a dict with key 'factor'; transform returns a new list applying `x * factor` to each x; process wires options to transform. Preserve existing public behavior and existing tests; do not mutate inputs. Modify at least 3 source files. Do not modify test_existing.py or formatting.py.",
6
+ "files": {
7
+ "pkg/__init__.py": "from .api import process\n",
8
+ "pkg/config.py": "def options():\n return {}\n",
9
+ "pkg/core.py": "def transform(values):\n return list(values)\n",
10
+ "pkg/api.py": "from .config import options\nfrom .core import transform\ndef process(values):\n options()\n return transform(values)\n",
11
+ "pkg/formatting.py": "def render(values):\n return \",\".join(map(str,values))\n",
12
+ "test_existing.py": "from pkg import process\nfrom pkg.formatting import render\ndef test_legacy():\n assert process([2,-1])==[2,-1]\n assert process([])==[]\n assert render([2,-1])==\"2,-1\"\n"
13
+ },
14
+ "entry": "pkg",
15
+ "tests": "from pkg.config import options\nfrom pkg.core import transform\nassert options()=={'factor': 1}\nassert options(factor=3)=={'factor': 3}\nassert transform([1, -2, 0],factor=3)==[3, -6, 0]\nassert process([1, -2, 0],factor=3)==[3, -6, 0]\nx=[1, -2, 0]; process(x,factor=3); assert x==[1, -2, 0]\nassert process([],factor=3)==[]\nassert process([1, -2, 0])==[1, -2, 0]",
16
+ "required_paths": [
17
+ "pkg/config.py",
18
+ "pkg/core.py",
19
+ "pkg/api.py"
20
+ ],
21
+ "budgets": {
22
+ "model_turn_seconds": 240,
23
+ "task_seconds": 900,
24
+ "max_model_turns": 1,
25
+ "max_tool_calls": 0,
26
+ "execution_seconds": 10,
27
+ "max_output_tokens": 2048
28
+ },
29
+ "trap": {
30
+ "prompt": "Return exactly UNKNOWN if impossible. Add a feature to a package whose files and API are inaccessible, preserving every undocumented behavior. No package contents supplied.",
31
+ "expected": "UNKNOWN"
32
+ }
33
+ },
34
+ {
35
+ "id": "R7-B",
36
+ "rung": 7,
37
+ "prompt": "Extend this existing package with the offset feature. Add optional keyword amount (default 0) to config.options, core.transform and api.process. options returns a dict with key 'amount'; transform returns a new list applying `x + amount` to each x; process wires options to transform. Preserve existing public behavior and existing tests; do not mutate inputs. Modify at least 3 source files. Do not modify test_existing.py or formatting.py.",
38
+ "files": {
39
+ "pkg/__init__.py": "from .api import process\n",
40
+ "pkg/config.py": "def options():\n return {}\n",
41
+ "pkg/core.py": "def transform(values):\n return list(values)\n",
42
+ "pkg/api.py": "from .config import options\nfrom .core import transform\ndef process(values):\n options()\n return transform(values)\n",
43
+ "pkg/formatting.py": "def render(values):\n return \",\".join(map(str,values))\n",
44
+ "test_existing.py": "from pkg import process\nfrom pkg.formatting import render\ndef test_legacy():\n assert process([2,-1])==[2,-1]\n assert process([])==[]\n assert render([2,-1])==\"2,-1\"\n"
45
+ },
46
+ "entry": "pkg",
47
+ "tests": "from pkg.config import options\nfrom pkg.core import transform\nassert options()=={'amount': 0}\nassert options(amount=-2)=={'amount': -2}\nassert transform([1, -2, 0],amount=-2)==[-1, -4, -2]\nassert process([1, -2, 0],amount=-2)==[-1, -4, -2]\nx=[1, -2, 0]; process(x,amount=-2); assert x==[1, -2, 0]\nassert process([],amount=-2)==[]\nassert process([1, -2, 0])==[1, -2, 0]",
48
+ "required_paths": [
49
+ "pkg/config.py",
50
+ "pkg/core.py",
51
+ "pkg/api.py"
52
+ ],
53
+ "budgets": {
54
+ "model_turn_seconds": 240,
55
+ "task_seconds": 900,
56
+ "max_model_turns": 1,
57
+ "max_tool_calls": 0,
58
+ "execution_seconds": 10,
59
+ "max_output_tokens": 2048
60
+ },
61
+ "trap": {
62
+ "prompt": "Return exactly UNKNOWN if impossible. Add a feature to a package whose files and API are inaccessible, preserving every undocumented behavior. No package contents supplied.",
63
+ "expected": "UNKNOWN"
64
+ }
65
+ },
66
+ {
67
+ "id": "R7-C",
68
+ "rung": 7,
69
+ "prompt": "Extend this existing package with the floor feature. Add optional keyword minimum (default None) to config.options, core.transform and api.process. options returns a dict with key 'minimum'; transform returns a new list applying `x if minimum is None else max(x,minimum)` to each x; process wires options to transform. Preserve existing public behavior and existing tests; do not mutate inputs. Modify at least 3 source files. Do not modify test_existing.py or formatting.py.",
70
+ "files": {
71
+ "pkg/__init__.py": "from .api import process\n",
72
+ "pkg/config.py": "def options():\n return {}\n",
73
+ "pkg/core.py": "def transform(values):\n return list(values)\n",
74
+ "pkg/api.py": "from .config import options\nfrom .core import transform\ndef process(values):\n options()\n return transform(values)\n",
75
+ "pkg/formatting.py": "def render(values):\n return \",\".join(map(str,values))\n",
76
+ "test_existing.py": "from pkg import process\nfrom pkg.formatting import render\ndef test_legacy():\n assert process([2,-1])==[2,-1]\n assert process([])==[]\n assert render([2,-1])==\"2,-1\"\n"
77
+ },
78
+ "entry": "pkg",
79
+ "tests": "from pkg.config import options\nfrom pkg.core import transform\nassert options()=={'minimum': None}\nassert options(minimum=2)=={'minimum': 2}\nassert transform([1, -2, 4],minimum=2)==[2, 2, 4]\nassert process([1, -2, 4],minimum=2)==[2, 2, 4]\nx=[1, -2, 4]; process(x,minimum=2); assert x==[1, -2, 4]\nassert process([],minimum=2)==[]\nassert process([1, -2, 4])==[1, -2, 4]",
80
+ "required_paths": [
81
+ "pkg/config.py",
82
+ "pkg/core.py",
83
+ "pkg/api.py"
84
+ ],
85
+ "budgets": {
86
+ "model_turn_seconds": 240,
87
+ "task_seconds": 900,
88
+ "max_model_turns": 1,
89
+ "max_tool_calls": 0,
90
+ "execution_seconds": 10,
91
+ "max_output_tokens": 2048
92
+ },
93
+ "trap": {
94
+ "prompt": "Return exactly UNKNOWN if impossible. Add a feature to a package whose files and API are inaccessible, preserving every undocumented behavior. No package contents supplied.",
95
+ "expected": "UNKNOWN"
96
+ }
97
+ },
98
+ {
99
+ "id": "R7-D",
100
+ "rung": 7,
101
+ "prompt": "Extend this existing package with the ceiling feature. Add optional keyword maximum (default None) to config.options, core.transform and api.process. options returns a dict with key 'maximum'; transform returns a new list applying `x if maximum is None else min(x,maximum)` to each x; process wires options to transform. Preserve existing public behavior and existing tests; do not mutate inputs. Modify at least 3 source files. Do not modify test_existing.py or formatting.py.",
102
+ "files": {
103
+ "pkg/__init__.py": "from .api import process\n",
104
+ "pkg/config.py": "def options():\n return {}\n",
105
+ "pkg/core.py": "def transform(values):\n return list(values)\n",
106
+ "pkg/api.py": "from .config import options\nfrom .core import transform\ndef process(values):\n options()\n return transform(values)\n",
107
+ "pkg/formatting.py": "def render(values):\n return \",\".join(map(str,values))\n",
108
+ "test_existing.py": "from pkg import process\nfrom pkg.formatting import render\ndef test_legacy():\n assert process([2,-1])==[2,-1]\n assert process([])==[]\n assert render([2,-1])==\"2,-1\"\n"
109
+ },
110
+ "entry": "pkg",
111
+ "tests": "from pkg.config import options\nfrom pkg.core import transform\nassert options()=={'maximum': None}\nassert options(maximum=2)=={'maximum': 2}\nassert transform([1, -2, 4],maximum=2)==[1, -2, 2]\nassert process([1, -2, 4],maximum=2)==[1, -2, 2]\nx=[1, -2, 4]; process(x,maximum=2); assert x==[1, -2, 4]\nassert process([],maximum=2)==[]\nassert process([1, -2, 4])==[1, -2, 4]",
112
+ "required_paths": [
113
+ "pkg/config.py",
114
+ "pkg/core.py",
115
+ "pkg/api.py"
116
+ ],
117
+ "budgets": {
118
+ "model_turn_seconds": 240,
119
+ "task_seconds": 900,
120
+ "max_model_turns": 1,
121
+ "max_tool_calls": 0,
122
+ "execution_seconds": 10,
123
+ "max_output_tokens": 2048
124
+ },
125
+ "trap": {
126
+ "prompt": "Return exactly UNKNOWN if impossible. Add a feature to a package whose files and API are inaccessible, preserving every undocumented behavior. No package contents supplied.",
127
+ "expected": "UNKNOWN"
128
+ }
129
+ }
130
+ ]
ladder.py ADDED
@@ -0,0 +1,297 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """Intelligence ladder scoring: capability profile, R6 components and leaderboard.
2
+
3
+ Standard library only. Reads data/results.jsonl and data/models.json; never writes.
4
+ Used by reproduce.py and app.py so the Space and the reproduce check share one code path.
5
+ """
6
+ import json
7
+ import math
8
+ import pathlib
9
+ import random
10
+ import statistics
11
+
12
+ ROOT = pathlib.Path(__file__).resolve().parent
13
+ FAMILIES = {
14
+ 1: 'Simple functions',
15
+ 2: 'Edge cases / Unicode / nonmutation',
16
+ 3: 'Three-file package repairs',
17
+ 4: 'Tool-mediated debugging',
18
+ 5: 'Bounded two-turn revisions',
19
+ 6: 'Implementation plus self-authored mutation tests',
20
+ 7: 'Multi-file package feature',
21
+ }
22
+ TASKS_PER_FAMILY = 4
23
+ REPEATS = 3
24
+ SCHEDULED_PRODUCTIVE = len(FAMILIES) * TASKS_PER_FAMILY * REPEATS # 84
25
+ BOOT = 4000
26
+ SEED = 20261110
27
+
28
+
29
+ def load_results(path=ROOT / 'data' / 'results.jsonl'):
30
+ rows = [json.loads(l) for l in pathlib.Path(path).read_text().splitlines() if l.strip()]
31
+ keys = [(r['model'], r['id']) for r in rows]
32
+ assert len(keys) == len(set(keys)), 'duplicate (model, trial id) rows'
33
+ return rows
34
+
35
+
36
+ def load_models(path=ROOT / 'data' / 'models.json'):
37
+ return json.loads(pathlib.Path(path).read_text())
38
+
39
+
40
+ def model_order(rows, models):
41
+ """Registry order first (fixes the bootstrap stream), then any unregistered model, sorted."""
42
+ present = {r['model'] for r in rows}
43
+ order = [m['label'] for m in models['models'] if m['label'] in present]
44
+ return order + sorted(present - set(order))
45
+
46
+
47
+ # ------------------------------------------------------------------ capability profile
48
+ def family_cells(rows, model, rung):
49
+ rs = [r for r in rows if r['model'] == model and r['rung'] == rung]
50
+ ps = [r for r in rs if not r['trap']]
51
+ ts = [r for r in rs if r['trap']]
52
+ groups = [[r for r in ps if r['task'] == f'R{rung}-{c}'] for c in 'ABCD']
53
+ counts = [sum(bool(r['score']['pass']) for r in g) for g in groups]
54
+ eligible = all(len(g) == REPEATS and n >= 2 for g, n in zip(groups, counts))
55
+ status = 'yes' if eligible else 'no' if len(ps) == TASKS_PER_FAMILY * REPEATS else 'incomplete'
56
+ return dict(counts=counts, sizes=[len(g) for g in groups], status=status,
57
+ productive_passes=sum(counts), productive_trials=len(ps),
58
+ trap_passes=sum(bool(r['score']['pass']) for r in ts), trap_trials=len(ts))
59
+
60
+
61
+ def capability_profile(rows):
62
+ out = []
63
+ for model in sorted({r['model'] for r in rows}):
64
+ for rung, name in FAMILIES.items():
65
+ out.append(dict(model=model, rung=rung, family=name, **family_cells(rows, model, rung)))
66
+ return out
67
+
68
+
69
+ def capability_markdown(rows):
70
+ lines = ['| Model | Family | A | B | C | D | Eligible? | Productive | Traps |',
71
+ '|---|---|---:|---:|---:|---:|---|---:|---:|']
72
+ for c in capability_profile(rows):
73
+ cells = ' | '.join(f'{n}/{s}' for n, s in zip(c['counts'], c['sizes']))
74
+ lines.append(f"| {c['model']} | R{c['rung']}: {c['family']} | {cells} | {c['status']} | "
75
+ f"{c['productive_passes']}/{c['productive_trials']} | {c['trap_passes']}/{c['trap_trials']} |")
76
+ return lines
77
+
78
+
79
+ def r6_components(rows):
80
+ out = []
81
+ for model in sorted({r['model'] for r in rows}):
82
+ rs = [r['score'] for r in rows if r['model'] == model and r['rung'] == 6 and not r['trap']]
83
+ out.append(dict(model=model, trials=len(rs),
84
+ behavior=sum(bool(x.get('behavior', {}).get('pass_')) for x in rs),
85
+ tests_on_reference=sum(bool(x.get('tests_on_reference', {}).get('pass_')) for x in rs),
86
+ mutants_killed=sum(x.get('mutants_killed', 0) for x in rs),
87
+ mutants_total=sum(x.get('mutants_total', 0) for x in rs)))
88
+ return out
89
+
90
+
91
+ def r6_markdown(rows):
92
+ lines = ['| Model | Behavioral passes | Tests valid on reference | Mutants killed |', '|---|---:|---:|---:|']
93
+ for c in r6_components(rows):
94
+ lines.append(f"| {c['model']} | {c['behavior']}/{c['trials']} | {c['tests_on_reference']}/{c['trials']} | "
95
+ f"{c['mutants_killed']}/{c['mutants_total']} |")
96
+ return lines
97
+
98
+
99
+ # ------------------------------------------------------------------ leaderboard
100
+ def wilson(k, n, z=1.96):
101
+ if n == 0:
102
+ return (float('nan'), float('nan'))
103
+ p = k / n
104
+ d = 1 + z * z / n
105
+ c = (p + z * z / (2 * n)) / d
106
+ h = z * math.sqrt(p * (1 - p) / n + z * z / (4 * n * n)) / d
107
+ return (max(0.0, c - h), min(1.0, c + h))
108
+
109
+
110
+ def pct(xs, q):
111
+ xs = sorted(x for x in xs if x is not None and not math.isnan(x))
112
+ if not xs:
113
+ return float('nan')
114
+ i = (len(xs) - 1) * q
115
+ lo, hi = math.floor(i), math.ceil(i)
116
+ return xs[lo] + (xs[hi] - xs[lo]) * (i - lo)
117
+
118
+
119
+ def task_table(rows, model):
120
+ d = {}
121
+ for r in rows:
122
+ if r['model'] != model:
123
+ continue
124
+ k = d.setdefault(r['task'], {'rung': r['rung'], 'prod_pass': 0, 'prod_n': 0, 'trap_pass': 0, 'trap_n': 0})
125
+ if r['trap']:
126
+ k['trap_n'] += 1
127
+ k['trap_pass'] += bool(r['score']['pass'])
128
+ else:
129
+ k['prod_n'] += 1
130
+ k['prod_pass'] += bool(r['score']['pass'])
131
+ return d
132
+
133
+
134
+ def solved(task):
135
+ """A task is solved when all three productive repeats ran and at least two passed."""
136
+ return task['prod_n'] >= REPEATS and task['prod_pass'] >= 2
137
+
138
+
139
+ def _median(xs):
140
+ xs = [x for x in xs if x is not None]
141
+ return statistics.median(xs) if xs else None
142
+
143
+
144
+ def leaderboard(rows, models):
145
+ """One dict per model. Bootstrap resamples whole tasks with one RNG stream in registry order."""
146
+ meta = {m['label']: m for m in models['models']}
147
+ rng = random.Random(SEED)
148
+ out = []
149
+ for model in model_order(rows, models):
150
+ tasks = task_table(rows, model)
151
+ keys = sorted(tasks)
152
+ sol = sum(solved(tasks[k]) for k in keys)
153
+ pp = sum(tasks[k]['prod_pass'] for k in keys)
154
+ pn = sum(tasks[k]['prod_n'] for k in keys)
155
+ tp = sum(tasks[k]['trap_pass'] for k in keys)
156
+ tn = sum(tasks[k]['trap_n'] for k in keys)
157
+ boot_rate, boot_sol = [], []
158
+ for _ in range(BOOT):
159
+ smp = [rng.choice(keys) for _ in keys]
160
+ n2 = sum(tasks[k]['prod_n'] for k in smp)
161
+ boot_rate.append(sum(tasks[k]['prod_pass'] for k in smp) / n2 if n2 else float('nan'))
162
+ boot_sol.append(sum(solved(tasks[k]) for k in smp))
163
+ fam = {rung: family_cells(rows, model, rung) for rung in FAMILIES}
164
+ per_rung = {}
165
+ for rung in FAMILIES:
166
+ ks = [k for k in keys if tasks[k]['rung'] == rung]
167
+ g_pp = sum(tasks[k]['prod_pass'] for k in ks)
168
+ g_pn = sum(tasks[k]['prod_n'] for k in ks)
169
+ per_rung[rung] = dict(solved=sum(solved(tasks[k]) for k in ks), tasks_run=len(ks),
170
+ prod_pass=g_pp, prod_n=g_pn, wilson95=wilson(g_pp, g_pn))
171
+ height = 0
172
+ for rung in FAMILIES:
173
+ if fam[rung]['status'] != 'yes':
174
+ break
175
+ height = rung
176
+ mine = [r for r in rows if r['model'] == model]
177
+ turns = [t for r in mine for t in r['turn_metrics']]
178
+ tin = None if any('prompt_tokens' not in (t.get('usage') or {}) for t in turns) else \
179
+ sum(t['usage']['prompt_tokens'] for t in turns)
180
+ tout = sum(((t.get('usage') or {}).get('completion_tokens') if 'prompt_tokens' in (t.get('usage') or {})
181
+ else t.get('output_tokens')) or 0 for t in turns)
182
+ reasoning = [(t.get('usage') or {}).get('reasoning_tokens') for t in turns]
183
+ m = meta.get(model, {})
184
+ out.append(dict(
185
+ model=model, model_ref=m.get('model_ref', 'unregistered'), route=m.get('route', 'unregistered'),
186
+ hardware_class=m.get('hardware_class', 'unregistered'),
187
+ trials=len(mine), productive_trials=pn, trap_trials=tn,
188
+ coverage_complete=(pn == SCHEDULED_PRODUCTIVE and tn == SCHEDULED_PRODUCTIVE),
189
+ tasks_total=len(FAMILIES) * TASKS_PER_FAMILY, tasks_run=len(keys), solved=sol,
190
+ solved_ci=(pct(boot_sol, .025), pct(boot_sol, .975)),
191
+ rate=pp / pn if pn else float('nan'), rate_ci=(pct(boot_rate, .025), pct(boot_rate, .975)),
192
+ prod_pass=pp, trap_pass=tp, trap_rate=tp / tn if tn else float('nan'),
193
+ eligible_families=sum(f['status'] == 'yes' for f in fam.values()), ladder_height=height,
194
+ per_rung=per_rung,
195
+ tokens_in=tin, tokens_out=tout,
196
+ reasoning_tokens=None if all(x is None for x in reasoning) else sum(x or 0 for x in reasoning),
197
+ wall_s_sum=sum(r['wall_s'] for r in mine),
198
+ wall_s_median=_median([r['wall_s'] for r in mine]),
199
+ wall_s_p90=pct([r['wall_s'] for r in mine], .9),
200
+ ttft_s_median=_median([t.get('ttft_s') for t in turns]),
201
+ # The SSE instrument divides completion tokens (reasoning included) by the visible-content
202
+ # window, so it is only meaningful on turns that report no reasoning tokens.
203
+ tok_s_median=_median([t.get('tok_s') for t in turns
204
+ if not (t.get('usage') or {}).get('reasoning_tokens')]),
205
+ metric_source=sorted({t.get('metric_source', '') for t in turns}),
206
+ ))
207
+ out.sort(key=lambda s: (-s['solved'], -(s['rate'] if not math.isnan(s['rate']) else -1), s['model']))
208
+ return out
209
+
210
+
211
+ def _f(x, nd):
212
+ if x is None:
213
+ return 'n/a'
214
+ if isinstance(x, float) and math.isnan(x):
215
+ return 'n/a'
216
+ return f'{x:.{nd}f}'
217
+
218
+
219
+ LEADERBOARD_HEADERS = ['Rank', 'Model', 'Model ref', 'Route', 'Hardware class', 'Tasks solved (of 28)',
220
+ 'Solved 95% CI', 'Productive pass rate', 'Pass rate 95% CI', 'Eligible families',
221
+ 'Ladder height', 'Trap abstention', 'Coverage', 'Input tokens', 'Output tokens',
222
+ 'Reasoning tokens', 'Median trial wall s', 'p90 trial wall s', 'Median TTFT s',
223
+ 'Median tok/s (non-reasoning turns)']
224
+
225
+
226
+ def leaderboard_table(board):
227
+ rows = []
228
+ for i, s in enumerate(board, 1):
229
+ rows.append([
230
+ i, s['model'], s['model_ref'], s['route'], s['hardware_class'],
231
+ f"{s['solved']}" + ('' if s['tasks_run'] == s['tasks_total'] else f" ({s['tasks_run']} run)"),
232
+ f"[{s['solved_ci'][0]:.0f}, {s['solved_ci'][1]:.0f}]",
233
+ _f(s['rate'], 3), f"[{_f(s['rate_ci'][0], 3)}, {_f(s['rate_ci'][1], 3)}]",
234
+ f"{s['eligible_families']}/7", s['ladder_height'],
235
+ f"{s['trap_pass']}/{s['trap_trials']}",
236
+ 'complete' if s['coverage_complete'] else f"incomplete ({s['productive_trials']}/{SCHEDULED_PRODUCTIVE} productive)",
237
+ 'not logged' if s['tokens_in'] is None else s['tokens_in'], s['tokens_out'],
238
+ 'n/a' if s['reasoning_tokens'] is None else s['reasoning_tokens'],
239
+ _f(s['wall_s_median'], 2), _f(s['wall_s_p90'], 2), _f(s['ttft_s_median'], 2), _f(s['tok_s_median'], 1),
240
+ ])
241
+ return LEADERBOARD_HEADERS, rows
242
+
243
+
244
+ RUNG_HEADERS = ['Model'] + [f'R{i}' for i in FAMILIES]
245
+
246
+
247
+ def rung_table(board):
248
+ rows = []
249
+ for s in board:
250
+ cells = [s['model']]
251
+ for rung in FAMILIES:
252
+ g = s['per_rung'][rung]
253
+ if g['prod_n'] == 0:
254
+ cells.append('not run')
255
+ continue
256
+ lo, hi = g['wilson95']
257
+ inc = '' if g['prod_n'] == TASKS_PER_FAMILY * REPEATS else f" (incomplete {g['prod_n']}/12)"
258
+ cells.append(f"{g['solved']}/4; {g['prod_pass']}/{g['prod_n']} [{lo:.2f}, {hi:.2f}]{inc}")
259
+ rows.append(cells)
260
+ return RUNG_HEADERS, rows
261
+
262
+
263
+ def md_table(headers, rows):
264
+ lines = ['| ' + ' | '.join(str(h) for h in headers) + ' |', '|' + '---|' * len(headers)]
265
+ lines += ['| ' + ' | '.join(str(c) for c in r) + ' |' for r in rows]
266
+ return lines
267
+
268
+
269
+ def leaderboard_markdown(rows, models):
270
+ board = leaderboard(rows, models)
271
+ L = ['<!-- generated by reproduce.py --write; do not hand-edit -->', '', '# Leaderboard', '']
272
+ L += md_table(*leaderboard_table(board))
273
+ L += ['', 'Ranked by tasks solved, then productive pass rate. A task is solved when at least 2 of 3 '
274
+ 'productive repeats pass. CIs: cluster bootstrap over whole tasks, '
275
+ f'{BOOT} resamples, seed {SEED}, one stream in registry order (data/models.json). '
276
+ 'Ladder height: highest rung n with families R1..Rn all eligible. Token counts are as reported by '
277
+ 'each route; output tokens include reasoning tokens where the route reports them. Wall time per trial '
278
+ 'includes transport and scoring; TTFT and tok/s come from different instruments per route (see '
279
+ 'data/models.json) and are not directly comparable across routes. tok/s uses only turns that report '
280
+ 'zero reasoning tokens, because the streaming instrument counts reasoning tokens but times only '
281
+ 'visible content. Power draw was not metered for any route, so no energy column is reported.', '',
282
+ '## Solved tasks by rung (k of 4; productive passes with 95% Wilson interval)', '']
283
+ L += md_table(*rung_table(board))
284
+ L += ['', 'Wilson intervals treat the three repeats as independent; they are not (temperature 0). '
285
+ 'Use the cluster-bootstrap interval above for model comparisons.', '']
286
+ return L
287
+
288
+
289
+ def leaderboard_csv(rows, models):
290
+ import csv
291
+ import io
292
+ h, body = leaderboard_table(leaderboard(rows, models))
293
+ buf = io.StringIO()
294
+ w = csv.writer(buf, lineterminator='\n')
295
+ w.writerow(h)
296
+ w.writerows(body)
297
+ return buf.getvalue()
reference/RESULTS-reference.md ADDED
@@ -0,0 +1,78 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Reference tables
2
+
3
+ Copied verbatim from the private run report that the original harness generated (summarize.py, results as of 2026-11-04).
4
+ Only these two tables are copied. reproduce.py recomputes both from data/results.jsonl and requires an exact line match.
5
+
6
+ ## Capability profile
7
+
8
+ | Model | Family | A | B | C | D | Eligible? | Productive | Traps |
9
+ |---|---|---:|---:|---:|---:|---|---:|---:|
10
+ | RK1-Qwen3-4B | R1: Simple functions | 3/3 | 3/3 | 3/3 | 3/3 | yes | 12/12 | 12/12 |
11
+ | RK1-Qwen3-4B | R2: Edge cases / Unicode / nonmutation | 3/3 | 0/3 | 0/3 | 0/3 | no | 3/12 | 9/12 |
12
+ | RK1-Qwen3-4B | R3: Three-file package repairs | 0/3 | 0/3 | 0/3 | 0/3 | no | 0/12 | 12/12 |
13
+ | RK1-Qwen3-4B | R4: Tool-mediated debugging | 0/3 | 0/3 | 0/3 | 0/3 | no | 0/12 | 12/12 |
14
+ | RK1-Qwen3-4B | R5: Bounded two-turn revisions | 3/3 | 0/3 | 0/3 | 3/3 | no | 6/12 | 12/12 |
15
+ | RK1-Qwen3-4B | R6: Implementation plus self-authored mutation tests | 0/3 | 0/3 | 0/3 | 0/3 | no | 0/12 | 12/12 |
16
+ | RK1-Qwen3-4B | R7: Multi-file package feature | 0/3 | 0/3 | 0/3 | 0/3 | no | 0/12 | 12/12 |
17
+ | alibaba/qwen-flash | R1: Simple functions | 3/3 | 3/3 | 3/3 | 3/3 | yes | 12/12 | 12/12 |
18
+ | alibaba/qwen-flash | R2: Edge cases / Unicode / nonmutation | 3/3 | 0/3 | 3/3 | 3/3 | no | 9/12 | 9/12 |
19
+ | alibaba/qwen-flash | R3: Three-file package repairs | 3/3 | 0/3 | 3/3 | 2/3 | no | 8/12 | 12/12 |
20
+ | alibaba/qwen-flash | R4: Tool-mediated debugging | 0/3 | 0/3 | 0/3 | 0/3 | no | 0/12 | 12/12 |
21
+ | alibaba/qwen-flash | R5: Bounded two-turn revisions | 3/3 | 3/3 | 3/3 | 3/3 | yes | 12/12 | 12/12 |
22
+ | alibaba/qwen-flash | R6: Implementation plus self-authored mutation tests | 1/3 | 0/3 | 0/3 | 2/3 | no | 3/12 | 12/12 |
23
+ | alibaba/qwen-flash | R7: Multi-file package feature | 3/3 | 3/3 | 0/3 | 0/3 | no | 6/12 | 12/12 |
24
+ | alibaba/qwen-plus | R1: Simple functions | 3/3 | 3/3 | 3/3 | 3/3 | yes | 12/12 | 12/12 |
25
+ | alibaba/qwen-plus | R2: Edge cases / Unicode / nonmutation | 3/3 | 3/3 | 3/3 | 3/3 | yes | 12/12 | 6/12 |
26
+ | alibaba/qwen-plus | R3: Three-file package repairs | 3/3 | 3/3 | 3/3 | 3/3 | yes | 12/12 | 12/12 |
27
+ | alibaba/qwen-plus | R4: Tool-mediated debugging | 3/3 | 3/3 | 0/3 | 3/3 | no | 9/12 | 12/12 |
28
+ | alibaba/qwen-plus | R5: Bounded two-turn revisions | 3/3 | 3/3 | 3/3 | 3/3 | yes | 12/12 | 12/12 |
29
+ | alibaba/qwen-plus | R6: Implementation plus self-authored mutation tests | 0/3 | 0/3 | 1/1 | 0/0 | incomplete | 1/7 | 6/6 |
30
+ | alibaba/qwen-plus | R7: Multi-file package feature | 0/0 | 0/0 | 0/0 | 0/0 | incomplete | 0/0 | 0/0 |
31
+ | astra | R1: Simple functions | 3/3 | 3/3 | 3/3 | 3/3 | yes | 12/12 | 12/12 |
32
+ | astra | R2: Edge cases / Unicode / nonmutation | 3/3 | 3/3 | 3/3 | 3/3 | yes | 12/12 | 12/12 |
33
+ | astra | R3: Three-file package repairs | 3/3 | 3/3 | 3/3 | 3/3 | yes | 12/12 | 12/12 |
34
+ | astra | R4: Tool-mediated debugging | 3/3 | 3/3 | 3/3 | 2/3 | yes | 11/12 | 12/12 |
35
+ | astra | R5: Bounded two-turn revisions | 3/3 | 3/3 | 3/3 | 3/3 | yes | 12/12 | 12/12 |
36
+ | astra | R6: Implementation plus self-authored mutation tests | 3/3 | 3/3 | 3/3 | 3/3 | yes | 12/12 | 12/12 |
37
+ | astra | R7: Multi-file package feature | 3/3 | 3/3 | 3/3 | 3/3 | yes | 12/12 | 12/12 |
38
+ | deepseek-v4-flash | R1: Simple functions | 3/3 | 3/3 | 3/3 | 3/3 | yes | 12/12 | 12/12 |
39
+ | deepseek-v4-flash | R2: Edge cases / Unicode / nonmutation | 1/3 | 2/3 | 1/3 | 3/3 | no | 7/12 | 9/12 |
40
+ | deepseek-v4-flash | R3: Three-file package repairs | 0/3 | 1/3 | 1/3 | 0/3 | no | 2/12 | 12/12 |
41
+ | deepseek-v4-flash | R4: Tool-mediated debugging | 3/3 | 2/3 | 2/3 | 3/3 | yes | 10/12 | 12/12 |
42
+ | deepseek-v4-flash | R5: Bounded two-turn revisions | 3/3 | 3/3 | 2/3 | 3/3 | yes | 11/12 | 12/12 |
43
+ | deepseek-v4-flash | R6: Implementation plus self-authored mutation tests | 2/3 | 0/3 | 0/3 | 0/3 | no | 2/12 | 12/12 |
44
+ | deepseek-v4-flash | R7: Multi-file package feature | 3/3 | 3/3 | 3/3 | 3/3 | yes | 12/12 | 12/12 |
45
+ | glm-4.7-flash | R1: Simple functions | 0/3 | 0/3 | 0/3 | 0/3 | no | 0/12 | 11/12 |
46
+ | glm-4.7-flash | R2: Edge cases / Unicode / nonmutation | 0/3 | 0/3 | 0/3 | 0/3 | no | 0/12 | 3/12 |
47
+ | glm-4.7-flash | R3: Three-file package repairs | 0/3 | 0/3 | 0/3 | 0/3 | no | 0/12 | 11/12 |
48
+ | glm-4.7-flash | R4: Tool-mediated debugging | 0/3 | 0/3 | 0/3 | 0/3 | no | 0/12 | 8/12 |
49
+ | glm-4.7-flash | R5: Bounded two-turn revisions | 0/3 | 0/3 | 0/3 | 0/3 | no | 0/12 | 11/12 |
50
+ | glm-4.7-flash | R6: Implementation plus self-authored mutation tests | 2/3 | 0/3 | 1/3 | 0/3 | no | 3/12 | 7/12 |
51
+ | glm-4.7-flash | R7: Multi-file package feature | 0/3 | 0/3 | 0/3 | 0/3 | no | 0/12 | 12/12 |
52
+ | gpt-5-nano | R1: Simple functions | 0/3 | 0/3 | 0/3 | 0/3 | no | 0/12 | 12/12 |
53
+ | gpt-5-nano | R2: Edge cases / Unicode / nonmutation | 0/3 | 0/3 | 0/3 | 0/3 | no | 0/12 | 7/12 |
54
+ | gpt-5-nano | R3: Three-file package repairs | 0/3 | 0/3 | 0/3 | 0/3 | no | 0/12 | 12/12 |
55
+ | gpt-5-nano | R4: Tool-mediated debugging | 0/3 | 0/3 | 0/3 | 0/3 | no | 0/12 | 12/12 |
56
+ | gpt-5-nano | R5: Bounded two-turn revisions | 0/3 | 0/3 | 0/3 | 0/3 | no | 0/12 | 12/12 |
57
+ | gpt-5-nano | R6: Implementation plus self-authored mutation tests | 1/3 | 0/3 | 0/3 | 0/3 | no | 1/12 | 12/12 |
58
+ | gpt-5-nano | R7: Multi-file package feature | 0/3 | 0/3 | 0/3 | 0/3 | no | 0/12 | 12/12 |
59
+ | qwen3.7-flash | R1: Simple functions | 3/3 | 0/3 | 0/3 | 0/3 | no | 3/12 | 10/12 |
60
+ | qwen3.7-flash | R2: Edge cases / Unicode / nonmutation | 0/3 | 0/3 | 0/3 | 0/3 | no | 0/12 | 3/12 |
61
+ | qwen3.7-flash | R3: Three-file package repairs | 0/3 | 0/3 | 0/3 | 0/3 | no | 0/12 | 10/12 |
62
+ | qwen3.7-flash | R4: Tool-mediated debugging | 0/3 | 0/3 | 0/3 | 0/3 | no | 0/12 | 10/12 |
63
+ | qwen3.7-flash | R5: Bounded two-turn revisions | 0/3 | 0/3 | 0/3 | 0/3 | no | 0/12 | 8/12 |
64
+ | qwen3.7-flash | R6: Implementation plus self-authored mutation tests | 0/3 | 0/3 | 0/3 | 1/3 | no | 1/12 | 12/12 |
65
+ | qwen3.7-flash | R7: Multi-file package feature | 0/3 | 0/3 | 0/3 | 0/3 | no | 0/12 | 12/12 |
66
+
67
+ ## R6 component scores
68
+
69
+ | Model | Behavioral passes | Tests valid on reference | Mutants killed |
70
+ |---|---:|---:|---:|
71
+ | RK1-Qwen3-4B | 6/12 | 0/12 | 15/30 |
72
+ | alibaba/qwen-flash | 8/12 | 3/12 | 40/40 |
73
+ | alibaba/qwen-plus | 5/7 | 1/7 | 25/25 |
74
+ | astra | 12/12 | 12/12 | 60/60 |
75
+ | deepseek-v4-flash | 2/12 | 2/12 | 10/10 |
76
+ | glm-4.7-flash | 3/12 | 3/12 | 15/15 |
77
+ | gpt-5-nano | 1/12 | 1/12 | 5/5 |
78
+ | qwen3.7-flash | 1/12 | 1/12 | 5/5 |
reproduce.py ADDED
@@ -0,0 +1,156 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #!/usr/bin/env python3
2
+ """Verify the frozen suite and package hashes, then recompute every table from data/results.jsonl.
3
+
4
+ python3 reproduce.py check only; exit 1 on any mismatch
5
+ python3 reproduce.py --write regenerate results/leaderboard.{md,csv}, then SHA256SUMS
6
+
7
+ Standard library only. No network.
8
+ """
9
+ import argparse
10
+ import hashlib
11
+ import json
12
+ import pathlib
13
+ import sys
14
+
15
+ import ladder
16
+
17
+ ROOT = pathlib.Path(__file__).resolve().parent
18
+ FROZEN = ROOT / 'frozen'
19
+ FREEZE_R6_R7 = '311c38c0e227296409f1d89564b6582a6cc4c7d92ca81be89d1d6d739be0dfbc'
20
+ FREEZE_R1_R5 = '62cee4207d10260f2c8f65262f4277bb0058018196a45ed48c0eb5b985810eaa'
21
+ # Entries of the freeze manifest that are intentionally not shipped (see frozen/WITHHELD.md).
22
+ WITHHELD = {f'hidden/R{r}-{c}.json' for r in range(1, 8) for c in 'ABCD'} | {'runner.py'}
23
+ # Directories whose files the package SHA256SUMS covers.
24
+ SUMMED = ('data', 'frozen', 'reference', 'results')
25
+
26
+ failures = []
27
+
28
+
29
+ def sha(p):
30
+ return hashlib.sha256(pathlib.Path(p).read_bytes()).hexdigest()
31
+
32
+
33
+ def check(ok, msg):
34
+ print(('ok ' if ok else 'FAIL ') + msg)
35
+ if not ok:
36
+ failures.append(msg)
37
+
38
+
39
+ def verify_manifest(manifest_path, expected_hash, overrides=None):
40
+ check(sha(manifest_path) == expected_hash, f'{manifest_path.relative_to(ROOT)} sha256 = {expected_hash[:12]}')
41
+ manifest = json.loads(manifest_path.read_text())
42
+ verified, withheld = 0, []
43
+ for rel, h in manifest.items():
44
+ path = (overrides or {}).get(rel, FROZEN / rel)
45
+ if rel in WITHHELD:
46
+ check(not path.exists(), f'{rel} withheld (hash committed: {h[:12]})')
47
+ withheld.append(rel)
48
+ continue
49
+ good = path.exists() and sha(path) == h
50
+ verified += good
51
+ if not good:
52
+ check(False, f'{rel} matches manifest')
53
+ check(verified == len(manifest) - len(withheld),
54
+ f'{manifest_path.name}: {verified}/{len(manifest)} shipped files match, {len(withheld)} withheld')
55
+
56
+
57
+ def write_sums():
58
+ files = sorted(p for d in SUMMED for p in (ROOT / d).rglob('*')
59
+ if p.is_file() and '__pycache__' not in p.parts)
60
+ (ROOT / 'SHA256SUMS').write_text(''.join(f'{sha(p)} {p.relative_to(ROOT).as_posix()}\n' for p in files))
61
+ print(f'wrote SHA256SUMS ({len(files)} files)')
62
+
63
+
64
+ def verify_package():
65
+ lines = [l for l in (ROOT / 'SHA256SUMS').read_text().splitlines() if l.strip()]
66
+ bad = []
67
+ for line in lines:
68
+ h, rel = line.split(None, 1)
69
+ rel = rel.lstrip('*')
70
+ if not (ROOT / rel).exists() or sha(ROOT / rel) != h:
71
+ bad.append(rel)
72
+ listed = {l.split(None, 1)[1].lstrip('*') for l in lines}
73
+ present = {p.relative_to(ROOT).as_posix() for d in SUMMED for p in (ROOT / d).rglob('*')
74
+ if p.is_file() and '__pycache__' not in p.parts}
75
+ check(not bad, f'SHA256SUMS: {len(lines) - len(bad)}/{len(lines)} package files match' + (f' (bad: {bad})' if bad else ''))
76
+ check(present == listed, 'SHA256SUMS lists exactly the files in ' + ', '.join(SUMMED)
77
+ + (f' (unlisted: {sorted(present - listed)}, missing: {sorted(listed - present)})' if present != listed else ''))
78
+
79
+
80
+ def reference_tables():
81
+ text = (ROOT / 'reference' / 'RESULTS-reference.md').read_text().splitlines()
82
+
83
+ def table(h):
84
+ i = text.index(h) + 2
85
+ out = []
86
+ while i < len(text) and text[i].startswith('|'):
87
+ out.append(text[i])
88
+ i += 1
89
+ return out
90
+ return table('## Capability profile'), table('## R6 component scores')
91
+
92
+
93
+ def compare(name, got, want):
94
+ diff = [(i, g, w) for i, (g, w) in enumerate(zip(got, want)) if g != w]
95
+ check(not diff and len(got) == len(want), f'{name}: {len(got)} recomputed lines vs {len(want)} reference lines, '
96
+ f'{len(diff)} differ')
97
+ for i, g, w in diff[:5]:
98
+ print(f' line {i}: got {g}\n want {w}')
99
+
100
+
101
+ def main():
102
+ ap = argparse.ArgumentParser()
103
+ ap.add_argument('--write', action='store_true', help='rewrite results/leaderboard.{md,csv}')
104
+ a = ap.parse_args()
105
+
106
+ rows = ladder.load_results()
107
+ models = ladder.load_models()
108
+ if a.write:
109
+ out = ROOT / 'results'
110
+ out.mkdir(exist_ok=True)
111
+ (out / 'leaderboard.md').write_text('\n'.join(ladder.leaderboard_markdown(rows, models)) + '\n')
112
+ (out / 'leaderboard.csv').write_text(ladder.leaderboard_csv(rows, models))
113
+ print('wrote results/leaderboard.md and results/leaderboard.csv')
114
+ write_sums()
115
+
116
+ print('== frozen suite')
117
+ verify_manifest(FROZEN / 'SHA256SUMS.json', FREEZE_R6_R7)
118
+ verify_manifest(FROZEN / 'history' / 'R1-R5-SHA256SUMS.json', FREEZE_R1_R5,
119
+ overrides={'protocol.json': FROZEN / 'history' / 'R1-R5-protocol.json'})
120
+ print('== package')
121
+ verify_package()
122
+
123
+ print('== results')
124
+ check(all(r['freeze_sha256'] in (FREEZE_R6_R7, FREEZE_R1_R5) for r in rows),
125
+ f'{len(rows)} rows, every freeze_sha256 is a shipped manifest')
126
+ check(all(r['rung'] <= 5 for r in rows if r['freeze_sha256'] == FREEZE_R1_R5),
127
+ 'rows under the R1-R5 manifest are R1-R5 only')
128
+ registered = {m['label'] for m in models['models']}
129
+ check({r['model'] for r in rows} <= registered, 'every result label is registered in data/models.json')
130
+ cap_ref, r6_ref = reference_tables()
131
+ # The reference covers the original run report's models; models added later are recomputed but have
132
+ # no independent reference to match.
133
+ ref_models = {l.split(' | ')[0].lstrip('| ') for l in r6_ref[2:]}
134
+ ref_rows = [r for r in rows if r['model'] in ref_models]
135
+ new = sorted({r['model'] for r in rows} - ref_models)
136
+ if new:
137
+ print(f'note models without reference lines (added after the original report): {new}')
138
+ compare('capability profile vs reference/RESULTS-reference.md', ladder.capability_markdown(ref_rows), cap_ref)
139
+ compare('R6 component scores vs reference/RESULTS-reference.md', ladder.r6_markdown(ref_rows), r6_ref)
140
+
141
+ print('== leaderboard')
142
+ md = '\n'.join(ladder.leaderboard_markdown(rows, models)) + '\n'
143
+ csv = ladder.leaderboard_csv(rows, models)
144
+ for name, text in (('leaderboard.md', md), ('leaderboard.csv', csv)):
145
+ p = ROOT / 'results' / name
146
+ check(p.exists() and p.read_text() == text, f'results/{name} equals recomputed output')
147
+ for s in ladder.leaderboard(rows, models):
148
+ print(f" {s['model']:<20} solved {s['solved']:>2}/{s['tasks_total']} pass rate {s['rate']:.3f} "
149
+ f"height {s['ladder_height']}")
150
+
151
+ print('RESULT:', 'PASS' if not failures else f'FAIL ({len(failures)} checks)')
152
+ return 1 if failures else 0
153
+
154
+
155
+ if __name__ == '__main__':
156
+ sys.exit(main())
results/leaderboard.csv ADDED
@@ -0,0 +1,9 @@
 
 
 
 
 
 
 
 
 
 
1
+ Rank,Model,Model ref,Route,Hardware class,Tasks solved (of 28),Solved 95% CI,Productive pass rate,Pass rate 95% CI,Eligible families,Ladder height,Trap abstention,Coverage,Input tokens,Output tokens,Reasoning tokens,Median trial wall s,p90 trial wall s,Median TTFT s,Median tok/s (non-reasoning turns)
2
+ 1,astra,openai/gpt-6-astra,"OpenRouter, OpenAI-compatible streaming chat completions, temperature 0",hosted API; serving hardware not disclosed,28,"[28, 28]",0.988,"[0.964, 1.000]",7/7,7,84/84,complete,28548,19607,4017,2.57,7.00,2.11,117.5
3
+ 2,alibaba/qwen-plus,qwen-plus,"Alibaba Cloud Model Studio API, buffered (non-streaming), enable_thinking=false, temperature 0",hosted API; serving hardware not disclosed,19 (23 run),"[15, 22]",0.866,"[0.723, 1.000]",4/7,3,60/66,incomplete (67/84 productive),23453,9661,n/a,1.39,5.44,n/a,n/a
4
+ 3,deepseek-v4-flash,deepseek/deepseek-v4-flash,"OpenRouter, OpenAI-compatible streaming chat completions, temperature 0",hosted API; serving hardware not disclosed,19,"[14, 24]",0.667,"[0.524, 0.810]",4/7,1,81/84,complete,43477,69419,62462,3.66,8.27,2.53,53.4
5
+ 4,alibaba/qwen-flash,qwen-flash,"Alibaba Cloud Model Studio API, buffered (non-streaming), enable_thinking=false, temperature 0",hosted API; serving hardware not disclosed,17,"[12, 22]",0.595,"[0.429, 0.762]",2/7,1,81/84,complete,24933,16287,n/a,1.03,3.13,n/a,n/a
6
+ 5,RK1-Qwen3-4B,"Qwen3-4B-Instruct-2507, RKLLM W8A8 build, compiled context 2048","owned edge node, local NPU inference via the RKLLM runtime (1.3.1)","edge SoC: Turing RK1 compute module, Rockchip RK3588, 3-core NPU, 32 GB",7,"[3, 12]",0.250,"[0.107, 0.429]",1/7,1,81/84,complete,not logged,13122,n/a,12.50,75.10,1.33,3.4
7
+ 6,qwen3.7-flash,qwen/qwen3.7-flash,"OpenRouter, OpenAI-compatible streaming chat completions, temperature 0",hosted API; serving hardware not disclosed,1,"[0, 3]",0.048,"[0.000, 0.131]",0/7,0,65/84,complete,25746,119579,118676,6.27,19.17,4.71,n/a
8
+ 7,glm-4.7-flash,z-ai/glm-4.7-flash,"OpenRouter, OpenAI-compatible streaming chat completions, temperature 0",hosted API; serving hardware not disclosed,1,"[0, 3]",0.036,"[0.000, 0.095]",0/7,0,63/84,complete,22692,130670,128423,11.96,41.20,9.86,n/a
9
+ 8,gpt-5-nano,openai/gpt-5-nano,"OpenRouter, OpenAI-compatible streaming chat completions, temperature 0",hosted API; serving hardware not disclosed,0,"[0, 0]",0.012,"[0.000, 0.036]",0/7,0,79/84,complete,24400,108794,102208,7.42,18.10,3.88,n/a
results/leaderboard.md ADDED
@@ -0,0 +1,32 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ <!-- generated by reproduce.py --write; do not hand-edit -->
2
+
3
+ # Leaderboard
4
+
5
+ | Rank | Model | Model ref | Route | Hardware class | Tasks solved (of 28) | Solved 95% CI | Productive pass rate | Pass rate 95% CI | Eligible families | Ladder height | Trap abstention | Coverage | Input tokens | Output tokens | Reasoning tokens | Median trial wall s | p90 trial wall s | Median TTFT s | Median tok/s (non-reasoning turns) |
6
+ |---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
7
+ | 1 | astra | openai/gpt-6-astra | OpenRouter, OpenAI-compatible streaming chat completions, temperature 0 | hosted API; serving hardware not disclosed | 28 | [28, 28] | 0.988 | [0.964, 1.000] | 7/7 | 7 | 84/84 | complete | 28548 | 19607 | 4017 | 2.57 | 7.00 | 2.11 | 117.5 |
8
+ | 2 | alibaba/qwen-plus | qwen-plus | Alibaba Cloud Model Studio API, buffered (non-streaming), enable_thinking=false, temperature 0 | hosted API; serving hardware not disclosed | 19 (23 run) | [15, 22] | 0.866 | [0.723, 1.000] | 4/7 | 3 | 60/66 | incomplete (67/84 productive) | 23453 | 9661 | n/a | 1.39 | 5.44 | n/a | n/a |
9
+ | 3 | deepseek-v4-flash | deepseek/deepseek-v4-flash | OpenRouter, OpenAI-compatible streaming chat completions, temperature 0 | hosted API; serving hardware not disclosed | 19 | [14, 24] | 0.667 | [0.524, 0.810] | 4/7 | 1 | 81/84 | complete | 43477 | 69419 | 62462 | 3.66 | 8.27 | 2.53 | 53.4 |
10
+ | 4 | alibaba/qwen-flash | qwen-flash | Alibaba Cloud Model Studio API, buffered (non-streaming), enable_thinking=false, temperature 0 | hosted API; serving hardware not disclosed | 17 | [12, 22] | 0.595 | [0.429, 0.762] | 2/7 | 1 | 81/84 | complete | 24933 | 16287 | n/a | 1.03 | 3.13 | n/a | n/a |
11
+ | 5 | RK1-Qwen3-4B | Qwen3-4B-Instruct-2507, RKLLM W8A8 build, compiled context 2048 | owned edge node, local NPU inference via the RKLLM runtime (1.3.1) | edge SoC: Turing RK1 compute module, Rockchip RK3588, 3-core NPU, 32 GB | 7 | [3, 12] | 0.250 | [0.107, 0.429] | 1/7 | 1 | 81/84 | complete | not logged | 13122 | n/a | 12.50 | 75.10 | 1.33 | 3.4 |
12
+ | 6 | qwen3.7-flash | qwen/qwen3.7-flash | OpenRouter, OpenAI-compatible streaming chat completions, temperature 0 | hosted API; serving hardware not disclosed | 1 | [0, 3] | 0.048 | [0.000, 0.131] | 0/7 | 0 | 65/84 | complete | 25746 | 119579 | 118676 | 6.27 | 19.17 | 4.71 | n/a |
13
+ | 7 | glm-4.7-flash | z-ai/glm-4.7-flash | OpenRouter, OpenAI-compatible streaming chat completions, temperature 0 | hosted API; serving hardware not disclosed | 1 | [0, 3] | 0.036 | [0.000, 0.095] | 0/7 | 0 | 63/84 | complete | 22692 | 130670 | 128423 | 11.96 | 41.20 | 9.86 | n/a |
14
+ | 8 | gpt-5-nano | openai/gpt-5-nano | OpenRouter, OpenAI-compatible streaming chat completions, temperature 0 | hosted API; serving hardware not disclosed | 0 | [0, 0] | 0.012 | [0.000, 0.036] | 0/7 | 0 | 79/84 | complete | 24400 | 108794 | 102208 | 7.42 | 18.10 | 3.88 | n/a |
15
+
16
+ Ranked by tasks solved, then productive pass rate. A task is solved when at least 2 of 3 productive repeats pass. CIs: cluster bootstrap over whole tasks, 4000 resamples, seed 20261110, one stream in registry order (data/models.json). Ladder height: highest rung n with families R1..Rn all eligible. Token counts are as reported by each route; output tokens include reasoning tokens where the route reports them. Wall time per trial includes transport and scoring; TTFT and tok/s come from different instruments per route (see data/models.json) and are not directly comparable across routes. tok/s uses only turns that report zero reasoning tokens, because the streaming instrument counts reasoning tokens but times only visible content. Power draw was not metered for any route, so no energy column is reported.
17
+
18
+ ## Solved tasks by rung (k of 4; productive passes with 95% Wilson interval)
19
+
20
+ | Model | R1 | R2 | R3 | R4 | R5 | R6 | R7 |
21
+ |---|---|---|---|---|---|---|---|
22
+ | astra | 4/4; 12/12 [0.76, 1.00] | 4/4; 12/12 [0.76, 1.00] | 4/4; 12/12 [0.76, 1.00] | 4/4; 11/12 [0.65, 0.99] | 4/4; 12/12 [0.76, 1.00] | 4/4; 12/12 [0.76, 1.00] | 4/4; 12/12 [0.76, 1.00] |
23
+ | alibaba/qwen-plus | 4/4; 12/12 [0.76, 1.00] | 4/4; 12/12 [0.76, 1.00] | 4/4; 12/12 [0.76, 1.00] | 3/4; 9/12 [0.47, 0.91] | 4/4; 12/12 [0.76, 1.00] | 0/4; 1/7 [0.03, 0.51] (incomplete 7/12) | not run |
24
+ | deepseek-v4-flash | 4/4; 12/12 [0.76, 1.00] | 2/4; 7/12 [0.32, 0.81] | 0/4; 2/12 [0.05, 0.45] | 4/4; 10/12 [0.55, 0.95] | 4/4; 11/12 [0.65, 0.99] | 1/4; 2/12 [0.05, 0.45] | 4/4; 12/12 [0.76, 1.00] |
25
+ | alibaba/qwen-flash | 4/4; 12/12 [0.76, 1.00] | 3/4; 9/12 [0.47, 0.91] | 3/4; 8/12 [0.39, 0.86] | 0/4; 0/12 [0.00, 0.24] | 4/4; 12/12 [0.76, 1.00] | 1/4; 3/12 [0.09, 0.53] | 2/4; 6/12 [0.25, 0.75] |
26
+ | RK1-Qwen3-4B | 4/4; 12/12 [0.76, 1.00] | 1/4; 3/12 [0.09, 0.53] | 0/4; 0/12 [0.00, 0.24] | 0/4; 0/12 [0.00, 0.24] | 2/4; 6/12 [0.25, 0.75] | 0/4; 0/12 [0.00, 0.24] | 0/4; 0/12 [0.00, 0.24] |
27
+ | qwen3.7-flash | 1/4; 3/12 [0.09, 0.53] | 0/4; 0/12 [0.00, 0.24] | 0/4; 0/12 [0.00, 0.24] | 0/4; 0/12 [0.00, 0.24] | 0/4; 0/12 [0.00, 0.24] | 0/4; 1/12 [0.01, 0.35] | 0/4; 0/12 [0.00, 0.24] |
28
+ | glm-4.7-flash | 0/4; 0/12 [0.00, 0.24] | 0/4; 0/12 [0.00, 0.24] | 0/4; 0/12 [0.00, 0.24] | 0/4; 0/12 [0.00, 0.24] | 0/4; 0/12 [0.00, 0.24] | 1/4; 3/12 [0.09, 0.53] | 0/4; 0/12 [0.00, 0.24] |
29
+ | gpt-5-nano | 0/4; 0/12 [0.00, 0.24] | 0/4; 0/12 [0.00, 0.24] | 0/4; 0/12 [0.00, 0.24] | 0/4; 0/12 [0.00, 0.24] | 0/4; 0/12 [0.00, 0.24] | 0/4; 1/12 [0.01, 0.35] | 0/4; 0/12 [0.00, 0.24] |
30
+
31
+ Wilson intervals treat the three repeats as independent; they are not (temperature 0). Use the cluster-bootstrap interval above for model comparisons.
32
+