CompilingThings Compile Benchmark for MQL5 - v1.1.0

.gitattributes

@@ -1,3 +1,4 @@
 # The manifest hashes these files by byte. Pin the line endings to the tree so a
 # checkout cannot rewrite them and break every hash in SHA256SUMS.txt.
 * text eol=lf
+corpus_row_hashes.json filter=lfs diff=lfs merge=lfs -text

CITATION.cff

@@ -4,17 +4,20 @@ title: CompilingThings Compile Benchmark for MQL5®
 type: dataset
 authors:
   - name: CompilingThings
-version: 1.0.0
-date-released: 2026-09-02
+version: 1.1.0
+date-released: 2026-09-12
 identifiers:
   - type: other
-    value: CompilingThings/compile-benchmark-v1.0.0
+    value: CompilingThings/compile-benchmark-v1.1.0
     description: Release identifier.
 abstract: >-
-  A paired three-arm benchmark of whether generated MQL5® source compiles. It
-  publishes 184 prompts, the serving template and the system prompt, and
-  per-item results for a base model, a fine-tuned model and a frontier model
-  over the same items.
+  A paired benchmark of whether generated MQL5® source compiles. Version 1.1.0
+  carries the 184 public prompts and their 1.0.0 per-item results unchanged.
+  It adds hash-keyed per-item results on two private held-out sets: 300 Expert
+  Advisor prompts run on four arms, and 200 non-EA prompts run on three local
+  arms plus a stability re-run. It also adds a Q8_0 bridge re-run of the 184
+  public prompts, the serving template and system prompts, and a corpus
+  row-hash manifest.
   Released under the CompilingThings Benchmark Evaluation Licence v1.0; see the LICENSE file for terms.
   MQL5® and MetaTrader 5® are registered trademarks of MetaQuotes Ltd.
   CompilingThings is an independent project. No affiliation, sponsorship, certification, endorsement, or approval by MetaQuotes Ltd. is claimed.

LICENSE

@@ -4,7 +4,9 @@ CompilingThings Benchmark Evaluation Licence v1.0
 Copyright © 2026 CompilingThings. All rights reserved.
 
 SCOPE. The grant below covers the published benchmark files: prompts.jsonl,
-per_item_results.jsonl and serving_template.json.
+per_item_results.jsonl, serving_template.json, holdout_ea300_results.jsonl,
+holdout_nonea200_results.jsonl, bridge_q8_184_results.jsonl and
+corpus_row_hashes.json.
 
 The remaining files in this release - README.md, publication_metadata.json,
 PROJECTION_REPORT.json, verify_public_release.py, SHA256SUMS.txt, CITATION.cff,
@@ -19,6 +21,8 @@ Nothing here grants any right to material that is not in this release.
 
 YOU MAY:
   - run the 184 published prompts against any model.
+  - check, cite and compare the published result rows and the corpus row-hash
+    manifest, including the holdout row files, whose prompts are not published.
   - implement and use the published scoring contract.
   - publish and compare benchmark results, including results that disagree with ours.
   - cite the benchmark and the release identifier.

PROJECTION_REPORT.json

@@ -1,8 +1,11 @@
 {
-  "generated_from_evidence_manifest_sha256": "a3ecb53728523005648b995871b8389f40cfa997a45b7f58935e9cecc335b936",
-  "generated_from_evidence_manifest_note": "sha256 of the retained evidence package's checksum manifest file, the same value publication_metadata.json publishes as evidence_manifest_sha256. The evidence remains private; the hash is a commitment, not a means of independent verification.",
+  "generated_from_evidence_manifest_sha256": "4c5328b7ebf2e6f9a037ad0ad09f756c16c794bf2006c465a28ab394c4ee91d4",
+  "generated_from_evidence_manifest_public_half_sha256": "e2a1e2507c6909f7159848d940f54c6be8c4c703621058e346a75582974a3eb1",
+  "carried_from_v1_0_0_evidence_manifest_sha256": "a3ecb53728523005648b995871b8389f40cfa997a45b7f58935e9cecc335b936",
+  "generated_from_evidence_manifest_note": "Each value is the sha256 of the bytes of a retained evidence package's checksum manifest file, and the three are the same three publication_metadata.json publishes as evidence_manifest_v1_1_0_sha256, evidence_manifest_v1_1_0_public_half_sha256 and evidence_manifest_v1_0_0_sha256. Everything this document describes that is new in 1.1.0 was generated from the 1.1.0 package; the 1.0.0 rows and counts it carries forward came from the 1.0.0 package, which is why that hash is still here under its own name. The full-package manifest is not distributed, because it lists the filenames of private holdout material. The evidence remains private; these hashes are commitments, not a means of independent verification.",
   "membership_source_sha256": "9f1a271e664f895d02afea0113ca03db16fdf991dfac2f9386ab95263f624c50",
   "membership_source_note": "sha256 of the sealed point-estimate record the clean-184 membership was read from; the record itself is not distributed",
+  "counts_scope": "n_items, n_public_rows and rows_per_arm below describe per_item_results.jsonl, the 1.0.0 public set. Every row file added in 1.1.0 carries its own item count, row count and per-arm rows under v1_1_row_files.",
   "n_items": 184,
   "n_public_rows": 552,
   "rows_per_arm": {
@@ -103,7 +106,7 @@
       "distribution": "PUBLIC"
     },
     "serving_template.json": {
-      "sha256": "979346bc6c0bfee309188be88a5f1611882344ebd44d7e9796066068cd004541",
+      "sha256": "3601f3ff49381282ee7e3f83e21db9f9e3891910e4092c9461a2a798c9b14756",
       "distribution": "PUBLIC"
     }
   },
@@ -113,5 +116,217 @@
       "sha256": "30e9853232c8239e06206e2e9357b57fd9a6482db9583a775d550b134a031164",
       "distribution": "PRIVATE - not distributed; written agreement only"
     }
+  },
+  "v1_1_row_files": {
+    "holdout_ea300_results.jsonl": {
+      "n_items": 300,
+      "rows": 1200,
+      "sha256": "2814f69247f09f3efdd941ed6013aa0a638d3a2eb16b63c9d90113fb6be23dd9",
+      "arms": {
+        "base": {
+          "rows": 300,
+          "source_extract_sha256": "dd0b406b94427c4a1e54ba4ca0ad181220519cc5e6e1dbfcb60c79928fbdbe82"
+        },
+        "tuned83k": {
+          "rows": 300,
+          "source_extract_sha256": "5ebc111138f12088648ffc428e5abe881774b0734e5b3f67c3efd1e6f7a59d9f"
+        },
+        "tuned220k": {
+          "rows": 300,
+          "source_extract_sha256": "b16d7ae1c00f12832f77972775d23543c07893dcb875a0a9e24ffb9eb253d5fd"
+        },
+        "frontier": {
+          "rows": 300,
+          "source_extract_sha256": "e980c957ae9eb74f80618684d1cc4dd3cd62f7f324a055c12e95774f19f8b43e"
+        }
+      },
+      "item_identity": "item_sha256",
+      "distribution": "PUBLIC"
+    },
+    "holdout_nonea200_results.jsonl": {
+      "n_items": 200,
+      "rows": 800,
+      "sha256": "13c9812df5c390a024d2385c7a6f127124cef061c79baaae36e1b635af593a7a",
+      "arms": {
+        "base": {
+          "rows": 200,
+          "source_extract_sha256": "3d6960ddad752264dbeefc8b0abbdfb5d404b176f9ee6c541d1633c58fb019e8"
+        },
+        "tuned83k": {
+          "rows": 200,
+          "source_extract_sha256": "ed3835bc64896540059f161c09ceaf3359fd0e26a58890b675154d59dff76b4a"
+        },
+        "tuned220k": {
+          "rows": 200,
+          "source_extract_sha256": "53a2779afa1636a507e017cfa3c58f400d4f21b9fa6b2df9cc24d562971187f6"
+        },
+        "tuned220k_q8_replay": {
+          "rows": 200,
+          "source_extract_sha256": "010489a93192aa19a17bc56950c14ba829c6e14c2395bd73daad8062c775075d"
+        }
+      },
+      "item_identity": "item_sha256",
+      "distribution": "PUBLIC"
+    },
+    "bridge_q8_184_results.jsonl": {
+      "n_items": 184,
+      "rows": 552,
+      "sha256": "8ecdaa25fa270968498634d0b5c20fbb3517433bd6ec25f358dbee78d6a73b44",
+      "arms": {
+        "base": {
+          "rows": 184,
+          "source_results_sha256": "54b535ca7314614b038b595d681c152c44949394c52e42f4e92c8b693fabb1e7"
+        },
+        "tuned83k": {
+          "rows": 184,
+          "source_results_sha256": "22a35881e187c289bf4025192b149e24c4d735508cf2d12c1ada9b148523221b"
+        },
+        "tuned220k": {
+          "rows": 184,
+          "source_results_sha256": "edb00e9a8f0f4717d67752d97e677067206a64bde0c841f6b0ffde08f6b0f687"
+        }
+      },
+      "item_identity": "item_id",
+      "distribution": "PUBLIC"
+    },
+    "corpus_row_hashes.json": {
+      "row_hashes": 219867,
+      "sha256": "4dbabd017b4c50f803a83ec981c99b53b9a2b2247ed1000bde4f571f21e1bcfd",
+      "distribution": "PUBLIC"
+    }
+  },
+  "holdout_allow_listed_fields": [
+    "arm",
+    "item_sha256",
+    "prompt_sha256",
+    "category",
+    "verdict_headline",
+    "verdict_strict",
+    "bucket",
+    "errors",
+    "warnings",
+    "truncated",
+    "finish_reason",
+    "mq5_sha256",
+    "ex5_exists",
+    "ex5_sha256"
+  ],
+  "holdout_withheld_fields": [
+    "adapter_path",
+    "adapter_sha256",
+    "base_model_sha256",
+    "compile_infra_reason",
+    "compile_log_path",
+    "compile_log_raw_path",
+    "compile_log_raw_sha256",
+    "compile_log_sha256",
+    "compile_stem",
+    "ea_name",
+    "elapsed_seconds",
+    "ex5_path",
+    "extractor_version",
+    "fence_unterminated",
+    "generated_code_path",
+    "generated_code_sha256",
+    "generation_error",
+    "harness_version",
+    "manifest_selection_sha256",
+    "manifest_sha256",
+    "max_new_tokens",
+    "metaeditor_build",
+    "metaeditor_path",
+    "metaeditor_sha256",
+    "metaeditor_size_bytes",
+    "model_id",
+    "mq5_path",
+    "n_fenced_blocks",
+    "positive_control_errors",
+    "positive_control_warnings",
+    "quantisation",
+    "quantisation_mismatch",
+    "result_line_errors",
+    "result_line_warnings",
+    "seed",
+    "seed_applied",
+    "source_sha256",
+    "system_instruction",
+    "system_instruction_sha256",
+    "system_prompt_sha256",
+    "temperature",
+    "temperature_applied",
+    "usage",
+    "used_block_index",
+    "used_block_unterminated"
+  ],
+  "holdout_withheld_fields_scope": "Measured, not curated: every key present on any sealed row of the eight arms behind the two holdout files, less the fourteen this release publishes. The sealed `arm` field is withheld too and is not in the list, because the published `arm` is derived from the source extract and the two are different fields - see PROJECTION_REPORT.json arm_derivation_v1_1. The prompt text itself is not a row field in any of them and is withheld with the item names.",
+  "bridge_allow_listed_fields": [
+    "arm",
+    "item_id",
+    "prompt_sha256_public",
+    "verdict_headline",
+    "verdict_strict",
+    "bucket",
+    "ex5_exists",
+    "errors",
+    "warnings",
+    "result_line_errors",
+    "result_line_warnings",
+    "compile_infra_reason",
+    "generation_error",
+    "positive_control_errors",
+    "positive_control_warnings",
+    "truncated",
+    "finish_reason",
+    "n_fenced_blocks",
+    "used_block_index",
+    "fence_unterminated",
+    "used_block_unterminated",
+    "extractor_version",
+    "harness_version",
+    "seed",
+    "seed_applied",
+    "temperature",
+    "temperature_applied",
+    "max_new_tokens",
+    "quantisation",
+    "quantisation_mismatch",
+    "prompt_sha256",
+    "mq5_sha256",
+    "ex5_sha256"
+  ],
+  "arm_derivation_v1_1": "From the source extract, exactly as the 1.0.0 rows derived it from the source directory. The sealed rows' own `arm` field reads \"B\" on every local arm of this release and \"C\" on the frontier arm, so it discriminates the four arms of a holdout file not at all and is withheld.",
+  "arm_values": {
+    "holdout_ea300_results.jsonl": [
+      "base",
+      "tuned83k",
+      "tuned220k",
+      "frontier"
+    ],
+    "holdout_nonea200_results.jsonl": [
+      "base",
+      "tuned83k",
+      "tuned220k",
+      "tuned220k_q8_replay"
+    ],
+    "bridge_q8_184_results.jsonl": [
+      "base",
+      "tuned83k",
+      "tuned220k"
+    ]
+  },
+  "category_field_note": "On the non-EA holdout `category` is the item's class: include, indicator, script or service, 50 items each. On the EA holdout it is the empty string, which is the value the harness carries for an EA item and which selects the EA system prompt. The value is published as the source wrote it; it is not normalised to the string \"EA\".",
+  "bridge_item_id_derivation": "The bridge rows key on item_id so they join to prompts.jsonl and to per_item_results.jsonl. The mapping was made from the public files alone: the sealed row's spec_sha256 equals prompt_sha256_public, which the 1.0.0 rows already bind to an item_id. All 184 joined; no private id-to-name mapping was read.",
+  "hash_definitions_v1_1": {
+    "item_sha256": "The SHA-256 of the UTF-8 encoding of the item's specification text. It is the only item identity on a holdout row: the text itself is not published, so the hash is a commitment that binds the four arms' rows to one item and to a retained artifact, not a route to the item.",
+    "prompt_sha256": "Local rows: the SHA-256 of the UTF-8 encoding of the rendered serving template. Frontier rows: the SHA-256 of the system prompt, two newlines, then the prompt. On holdout rows neither is reproducible from this release, because the prompt is not published.",
+    "prompt_sha256_public": "Unchanged from 1.0.0 and carried on the bridge rows, where it does recompute: the 184 prompts are published."
+  },
+  "scoring_rule_the_verifier_enforces": "A pass is verdict_headline true AND truncated false. One row in the release compiled despite being truncated, so the two counts differ by one on that arm; the pre-registered rule scores it as a fail. The protocol that rule is registered in is identified, by name and SHA-256, under `protocol` in publication_metadata.json.",
+  "outputs_v1_1_changed": {
+    "serving_template.json": {
+      "sha256": "3601f3ff49381282ee7e3f83e21db9f9e3891910e4092c9461a2a798c9b14756",
+      "what_changed": "the four non-EA system instructions were added. The EA system prompt, its hash, the template and the worked example are byte-identical to 1.0.0.",
+      "supersedes_sha256": "979346bc6c0bfee309188be88a5f1611882344ebd44d7e9796066068cd004541"
+    }
   }
 }

README.md

@@ -31,35 +31,116 @@ configs:
   data_files:
   - split: test
     path: per_item_results.jsonl
+- config_name: holdout_ea300_results
+  data_files:
+  - split: test
+    path: holdout_ea300_results.jsonl
+- config_name: holdout_nonea200_results
+  data_files:
+  - split: test
+    path: holdout_nonea200_results.jsonl
+- config_name: bridge_q8_184_results
+  data_files:
+  - split: test
+    path: bridge_q8_184_results.jsonl
 ---
 
 # CompilingThings Compile Benchmark for MQL5®
 
-This release evaluates compile success on 184 public MQL5 prompts across three model arms.
+This release evaluates compile success of generated MQL5 on two private held-out sets. The first is 300 Expert Advisor prompts, run on four arms: the base model, two tuned local models and one frontier API model. The second is 200 non-EA prompts (include files, custom indicators, scripts and services, 50 each), run on the three local arms, plus a stability re-run of one of them. The holdout results are attested, not fully verifiable: every row is published as hashes and verdicts, the prompts are not. The 184 public prompts of version 1.0.0 remain in the release, with their published results unchanged.
 
-MQL5 and MetaTrader 5 are registered trademarks of MetaQuotes Ltd. CompilingThings is an independent project. No affiliation, sponsorship, certification, endorsement, or approval by MetaQuotes Ltd. is claimed.
+MQL5® and MetaTrader 5® are registered trademarks of MetaQuotes Ltd. CompilingThings is an independent project. No affiliation, sponsorship, certification, endorsement, or approval by MetaQuotes Ltd. is claimed.
 
-Release identifier: `CompilingThings/compile-benchmark-v1.0.0`.
+Release identifier: `CompilingThings/compile-benchmark-v1.1.0`. This version replaces the card of `v1.0.0` in place; the 1.0.0 files and figures are carried forward, not re-run.
 
 ## Result
 
+A pass requires zero compiler errors and a produced EX5 artifact. A generation cut off at the 8,192-token ceiling counts as a fail. Every local arm run for v1.1 was served at Q8_0 quantisation; see "Serving configuration" and "Q8_0 against the 1.0.0 bf16 arm".
+
+### 300 Expert Advisor prompts, private holdout
+
+| Arm | Compile success | Result | Truncated | Infrastructure failures |
+|---|---:|---:|---:|---:|
+| Base Qwen2.5-Coder-14B-Instruct | 0.33% | 1/300 | 3 | 0 |
+| Tuned 14B, 83k corpus (the 1.0.0 tuned model) | 93.67% | 281/300 | 0 | 0 |
+| Tuned 14B, 220k corpus | 94.00% | 282/300 | 0 | 0 |
+| gpt-5.6-sol | 95.33% | 286/300 | 4 | 3 |
+
+The frontier arm's seven excluded rows are its own: four generations hit the token ceiling and three API calls returned HTTP 500. Excluding those seven rows gives 286/293 = 97.61%; the all-300 headline stays 286/300 = 95.33%.
+
+The two tuned models are flat against each other on EA prompts: they disagree on 35 of 300 items, 18 in favour of the 220k model and 17 in favour of the 83k model, McNemar p = 1.0.
+
+Against gpt-5.6-sol the 220k model is 1.33 points behind over all 300 (p = 0.57) and 3.41 points behind when the frontier arm's seven excluded rows are dropped from both sides (293 pairs, Newcombe 95% CI −6.86 to −0.24 pp, McNemar p = 0.0525). Both denominators are reported because dropping the frontier failures moves the comparison from −1.33 to −3.41 points. These results do not establish equivalence.
+
+### 200 non-EA prompts, private holdout, 50 per class
+
+| Arm | Compile success, all 200 | Excluding own truncations | Truncated |
+|---|---:|---:|---:|
+| Base Qwen2.5-Coder-14B-Instruct | 28.0% (56/200) | 30.1% (56/186) | 14 |
+| Tuned 14B, 83k corpus | 67.5% (135/200) | 72.2% (135/187) | 13 |
+| Tuned 14B, 220k corpus | 84.0% (168/200) | 89.4% (168/188) | 12 |
+
+The first column is the headline: a truncated generation is a fail. The second column drops each arm's own truncated rows from its own denominator. gpt-5.6-sol was not run on this set.
+
+Per class, all 200 counted:
+
+| Class | Base | 83k | 220k |
+|---|---:|---:|---:|
+| Include file | 20/50 | 38/50 | 31/50 |
+| Custom indicator | 0/50 | 49/50 | 50/50 |
+| Script | 13/50 | 19/50 | 39/50 |
+| Service | 23/50 | 29/50 | 48/50 |
+
+Each cell is 50 items and is indicative, not conclusive. The 220k model is 20 items ahead of the 83k model on scripts and 19 ahead on services, and 7 behind on include files (31/50 vs 38/50; McNemar p = 0.14 over the 50 include-file pairs, p = 0.39 over the 38 pairs left when truncations are dropped, both intervals spanning zero). Those four figures are differences between the class totals in the table, not counts of items that changed verdict: item by item, 24 scripts moved to the 220k model and 4 the other way, 19 services and none the other way, 5 include files and 12 the other way, and 1 indicator and none the other way, which is where the 49 and the 16 in the paired-movement table below come from. Eleven of the 220k model's twelve truncations are include files. Whether the truncations cause the include-file loss is not tested by this release; the 83k model truncated eight include files and still scored higher on that class.
+
+Over the whole set the 220k model is 16.5 points ahead of the 83k model (all 200, 49 items gained against 16 lost, Newcombe 95% CI +8.85 to +23.96 pp, McNemar p = 5.1e-5) and 17.0 points ahead with truncations dropped (182 pairs, CI +9.35 to +24.60 pp, p = 3.3e-5). This is the only set in the benchmark where the two tuned models separate.
+
+The 8,192-token ceiling was chosen so that no arm would be truncated. On the two EA sets it achieved that for the tuned arms. On the non-EA set it did not: 14, 13 and 12 rows were cut off. Truncation counts are reported per arm and per class in the result files and are never folded into a compile-failure category.
+
+### 184 public prompts, version 1.0.0 result, unchanged
+
 | Arm | Compile success | Result |
 |---|---:|---:|
 | Base Qwen2.5-Coder-14B-Instruct | 1.09% | 2/184 |
-| Fine-tuned Qwen2.5-Coder-14B-Instruct | 92.39% | 170/184 |
+| Fine-tuned Qwen2.5-Coder-14B-Instruct (83k corpus, bf16) | 92.39% | 170/184 |
 | gpt-5.6-sol | 97.28% | 179/184 |
 
-One epoch of domain fine-tuning increased compile success by 91.30 percentage points, from 2/184 to 170/184. The fine-tuned 14B model finished 4.89 percentage points below gpt-5.6-sol on the same benchmark items.
+These are the 1.0.0 figures under the 1.0.0 serving configuration (bf16 transformers). They are not re-headlined here. The 184 prompts have been public since 1.0.0 and should be treated as a public benchmark, not as an uncontaminated set; the two holdouts above exist for that reason. The 1.0.0 card's description of these arms is carried in "The 1.0.0 arms" below.
+
+### Stability check: the 220k arm re-run on the 200 non-EA prompts
+
+The 220k arm was run a second time on the same 200 prompts under the same configuration. The rule was fixed before the second run started: the first run is the headline regardless of outcome, both runs publish, and neither is averaged or selected.
+
+| | First run (headline) | Second run |
+|---|---:|---:|
+| Compile success, all 200 | 168/200 | 169/200 |
+| Truncated | 12 | 11 |
+| Per class | 31 · 50 · 39 · 48 | 31 · 50 · 40 · 48 |
+
+By the rows' own compile verdicts, two of 200 items flipped, one in each direction, so both runs carry 169 true verdicts. The one-item difference in the table comes from the pre-registered rule (the protocol is identified under `protocol` in `publication_metadata.json` by filename and SHA-256; it is retained in the evidence package and not distributed in this release): the item that compiled despite truncation in the first run is scored as a fail there, and in the second run it did not compile.
+
+The generated source was byte-identical on 164 of 200 items; the 36 that differed were 20 include files, 13 scripts, 2 services and 1 indicator.
+
+Both runs used the same recorded settings; this release does not isolate the cause of the differences. An output hash in this release is provenance of the observed run where a source was produced, not a promise that a re-generation reproduces it. Both runs' rows are published.
+
+## Q8_0 against the 1.0.0 bf16 arm
 
-A pass requires zero compiler errors and a produced EX5 artifact.
+Every local arm run for v1.1 was served as a Q8_0 GGUF through llama.cpp. The 1.0.0 tuned arm was served at bf16 through transformers. To connect the two, the 83k model was re-run at Q8_0 on the 184 public prompts.
 
-The two local arms shared one prompt template, the tuned model's training format. A quantised base-model control comparing that template against the base's native ChatML format changed one verdict out of 183 jointly scoreable items, in the shared template's favour. Details are under "Serving template and control" below.
+| 83k model, 184 public prompts | Result |
+|---|---:|
+| Q8_0, llama.cpp (this release) | 175/184 |
+| bf16, transformers (1.0.0) | 170/184 |
+
+Six items passed under Q8_0 and failed under bf16; one the other way. That is a 5-item gap, Newcombe 95% CI −0.26 to +6.28 pp, McNemar p = 0.125, not significant at n = 184. The two runs also differ in serving backend, so the difference is not attributable to quantisation alone. The bf16 arm is the 1.0.0 tuned arm as published, identified by the weight hashes under `models.tuned.merged_weights` and `model_identities.tuned_83k` in `publication_metadata.json`; this release did not re-verify those weights. The 1.0.0 figures stand as published; the Q8_0 re-run of the 184 is published as a bridge row set, not as a replacement.
+
+The base arm was also re-run at Q8_0 on the 184 (2/184 with 2 truncated, the same two passing items as 1.0.0, which truncated none), and the 220k arm was run on them (169/184, 0 truncated). Those rows ship in the bridge file for completeness. The 184-item set is public, so none of these is a holdout figure.
 
 ## Run the benchmark
 
-Inputs are in `prompts.jsonl`. Render each prompt with the system prompt and template in `serving_template.json`, generate MQL5, compile it, and record the verdict using the schema in `per_item_results.jsonl`.
+The 184 public prompts are in `prompts.jsonl`. Render each prompt with the Expert Advisor system prompt and the template in `serving_template.json`, generate MQL5, compile it, and record the verdict using the schema in `per_item_results.jsonl`. Every published run of the 184 used the Expert Advisor system prompt for all 184 items, including the six whose specification header declares another type; a reproduction that follows that rule reproduces the published request hashes.
 
-The system prompt:
+The system prompt for the 184 public prompts and for the 300 EA holdout:
 
 ```text
 You are an expert MQL5 programmer. Write the complete MQL5 Expert Advisor code that implements the given specification exactly.
@@ -73,160 +154,175 @@ The serving template:
 
 `\n` is a real newline. The `template` field in `serving_template.json` holds actual newline characters, so a JSON parser returns the correct string without further unescaping.
 
-The benchmark prompts and scoring contract are public. Readers can evaluate another model against the same 184 items. The original generation and compilation harness is not distributed, so exact implementation parity on edge cases is not guaranteed.
-
-`verify_public_release.py` ships in this release and checks release hashes, item pairing, row counts, contingency tables, and headline result counts. It needs Python 3.9+ and nothing else.
-
-## Scoring contract
-
-Two verdicts are computed for every item and published side by side:
+The 200 non-EA holdout items use the same sentence with the unit noun replaced, by the class of the set they were drawn into, never by the specification header. The four strings are published in `serving_template.json` and are, verbatim:
 
-- `verdict_headline` — true when the compile log reports zero errors and the .ex5 artifact was produced.
-- `verdict_strict` — true when the compile log reports zero errors and zero warnings and the .ex5 artifact was produced.
-
-Each row carries one of four buckets, assigned in this order. A generation error is an infrastructure failure. Otherwise a truncated response is TRUNCATED. Otherwise a compile-side infrastructure reason is an infrastructure failure. Everything else is compile-pass or compile-fail from `verdict_headline`. TRUNCATED and INFRASTRUCTURE-FAILURE rows leave the denominator. On this release's rows all three arms have zero TRUNCATED rows and zero INFRASTRUCTURE-FAILURE rows, so every comparison is over the full 184 items.
+```text
+You are an expert MQL5 programmer. Write the complete MQL5 include file code that implements the given specification exactly.
+You are an expert MQL5 programmer. Write the complete MQL5 custom indicator code that implements the given specification exactly.
+You are an expert MQL5 programmer. Write the complete MQL5 script code that implements the given specification exactly.
+You are an expert MQL5 programmer. Write the complete MQL5 service code that implements the given specification exactly.
+```
 
-Extraction (`three_way.v4`): truncate the response at the first serving end-token; find every fenced code block; if none, use the whole response; otherwise take the first block that defines a real MQL5 event handler, falling back to the first block. The chosen index is published per row as `used_block_index`. The same extraction runs on every arm.
+The holdout prompts are not published. A reader can evaluate any model on the 184 public prompts under the published contract. The holdout results are attested by per-item hashes, not independently reproducible; see "What is public and what is not".
 
-Compile logs are UTF-16LE with a byte-order mark and must be decoded before matching. A diagnostic is a line matching `(line,col): error N:` or `(line,col): warning N:`. A log without the compiler's own `Result: N errors, M warnings` line is an infrastructure failure, never a model result.
+`verify_public_release.py` ships in this release and checks release hashes, item pairing, row counts, contingency tables, and headline result counts. It needs Python 3.9+ and nothing else. Run it from the release directory:
 
-Compilation used the MetaQuotes Language Compiler supplied with MetaEditor, build 5836, the same build for all three arms.
+```text
+python verify_public_release.py --public .
+```
 
-## Serving configuration, local arms
+## Scoring contract
 
-- Engine: Hugging Face transformers, `AutoModelForCausalLM`, greedy decoding (`do_sample=False`), seed set per generation, bfloat16 compute, no quantisation, 8,192 max new tokens.
-- Hardware: one AMD Radeon AI PRO R9700 (RDNA 4, gfx1201) under ROCm, in an AMD Ryzen 9 7950X3D host with 64 GB of system memory. The device is not recorded in the run parameters; it is stated from the evaluation host's configuration.
-- The transformers, torch and tokenizer versions in force during the evaluation, the host OS, GPU driver version and environment variables were not recorded and are not established. The published experiment cannot be re-run to its exact environment; the same 184 prompts can be run under the published template, scoring contract and generation settings on any stack.
+Two verdicts are computed for every item that reached compilation and published side by side. On the three frontier rows where generation failed before compilation (the API returned HTTP 500), both verdicts are null.
 
-Before an arm is scored, two known fixtures are compiled: one that must produce an error, one that must produce a warning and still build. The harness writes no rows for an arm whose control fails. The per-row `positive_control_*` counts are those fixture results, identical on every row of an arm.
+- `verdict_headline` — true when the compile log reports zero errors and the .ex5 artifact was produced.
+- `verdict_strict` — true when the compile log reports zero errors and zero warnings and the .ex5 artifact was produced.
 
-## Serving template and control
+Each row carries one of four buckets, assigned in this order. A generation error is an infrastructure failure. Otherwise a truncated response is TRUNCATED. Otherwise a compile-side infrastructure reason is an infrastructure failure. Everything else is compile-pass or compile-fail from `verdict_headline`.
 
-Both local arms were served the same prompt template, the one the tuned model was trained on. The published `prompt_sha256` is identical for the two local arms on every item, so this is verifiable from the release.
+A TRUNCATED or INFRASTRUCTURE-FAILURE row counts as a fail in the headline figure and is dropped from the denominator in the second figure printed beside it. One row in the release compiled despite being truncated (a 220k include-file generation in the first non-EA run); the pre-registered rule scores it as a fail, which is why that arm shows 168 passes where 169 rows carry a true verdict. Both numbers are in the result files.
 
-That template is not the base model's native chat format, so part of the measured base-vs-tuned difference could in principle reflect template mismatch rather than capability. A template control measured this in a control configuration: the base model, quantised to Q8_0 on a different inference stack, run over the same 184 items once under the shared template and once under its native ChatML format, with identical settings and scoring.
+Extraction (`three_way.v4`): truncate the response at the first serving end-token; find every fenced code block; if none, use the whole response; otherwise take the first block that defines a real MQL5 event handler, falling back to the first block. The chosen index is published per row as `used_block_index` in `per_item_results.jsonl` and `bridge_q8_184_results.jsonl`. It is null where `n_fenced_blocks` is 0, which is every tuned-arm row in those two files: the tuned models answer with bare code, so the whole response was used and there was no block to index. The holdout row files do not carry it, so holdout extraction choices are not row-auditable from this release. The same extraction runs on every arm.
 
-Among the 183 items with scoreable outputs under both templates, one verdict changed: it compiled under the shared training template and failed under native ChatML. The remaining item was truncated under the shared-template condition and could not be compared. The observed difference on the 183 jointly scoreable items was one compile pass in favour of the shared template. Under the shared template the control reproduced the published base arm's two passing items.
+Compile logs are UTF-16LE with a byte-order mark and must be decoded before matching. A diagnostic is a line matching `(line,col): error N:` or `(line,col): warning N:`. A log without the compiler's own `Result: N errors, M warnings` line is an infrastructure failure, never a model result.
 
-The control served a different quantisation and stack than the published arms, so only the difference between its two conditions carries meaning; neither condition is a published arm. Carrying the one-item result to the published bf16 arms assumes the template effect transfers across quantisation and serving stack, and that transfer was not measured. The control's per-item rows are not distributed; they are identified by SHA-256 in `publication_metadata.json`.
+MQL5 outputs were compiled using the MetaQuotes Language Compiler through MetaEditor, build 5836, the same build for every arm in this release and in 1.0.0. Include-file items are compiled through a minimal caller that includes them, since an include file alone produces no EX5.
 
-## The frontier arm
+The harness, the extractor and the scorer are not distributed, and neither is the compiler. The rules above describe what they do at the level published here; details below that level are not published, so an independent implementation may score individual items differently. Before an arm is scored, two known fixtures are compiled: one that must produce an error, one that must produce a warning and still build. The harness writes no rows for an arm whose control fails. The 1.0.0 rows and the bridge rows carry the control's error and warning counts, which attest that the control ran; the holdout row files do not carry them. The fixture inputs and the control's compiler output were not retained, so the control itself cannot be audited from this release, and no known-answer validation record for the extractor is retained either.
 
-The third arm is `gpt-5.6-sol`, evaluated on 2026-09-02 against the same 184 items, using the same extraction logic, compiler build, and scoring path as the local arms.
+## Serving configuration
 
-All 184 items returned scoreable results. There were no truncations or infrastructure failures.
+Local arms, this release:
 
-The frontier arm was served through the vendor API rather than the local inference stack. It received the same system-prompt text and item text, but the vendor API applied its own chat framing.
+- Engine: llama.cpp `llama-server` build 10441 (commit `0177dcc73`, Clang 20.1.8, Windows x86_64), Q8_0 GGUF, Vulkan backend, 8 parallel slots, 69,632-token context, all layers offloaded (`-ngl 999`), 8 concurrent requests per arm. Launch line, verbatim: `llama-server.exe -m <gguf> -np 8 -c 69632 -ngl 999 --device Vulkan0 --host 127.0.0.1 --port 8088`.
+- Host: Windows 11 Pro 10.0.26200, AMD graphics driver 32.0.31036.15 (2026-08-12). No environment variables were set for the server. Python-side library versions were not recorded and are a gap.
+- Decoding: temperature 0.0, top-k 1 and seed 42 sent with every request, 8,192 max new tokens. The harness records what it sent; whether the server applied every setting as sent is not independently verified by this release.
+- Hardware: one AMD Radeon AI PRO R9700 in an AMD Ryzen 9 7950X3D host with 64 GB of system memory. The device is not recorded in the run parameters; it is stated from the evaluation host's configuration.
 
-Other serving differences:
+The frontier arm, `gpt-5.6-sol`, was evaluated on the 300 EA holdout on 2026-09-11 through the vendor API, one request at a time. That is a statement about concurrency and not about HTTP attempts: one item was in flight at a time. The harness set no retry policy and no client-side timeout for this arm, so any transport retry behind a single request was whatever the vendor's Python client library did by default, and that library's version was not recorded. The three rows that returned HTTP 500 are items whose request failed after whatever the client attempted. The request asked for temperature 1.0 and seed 42 and sent the same 8,192-token cap as `max_completion_tokens`; whether the service applied those settings is not recorded. The system-prompt text and the item text were sent as separate system and user fields; the local arms received them rendered into one serving template. The local arms were run with greedy settings requested, at concurrency 8. The frontier result is a single run of a sampled decoder identified by model name and evaluation date, and a rerun may differ item for item. The two serving and decoding configurations differ, and the head-to-head is a comparison across those configurations, not a configuration-matched one.
 
-- The run used temperature=1. A fixed seed was requested. This is a single run of a sampled decoder; a rerun may differ item-for-item.
-- The model is vendor-hosted and is identified by model name and evaluation date rather than a locally pinned weight hash.
-- The generation cap was 8,192 tokens, sent as the API's `max_completion_tokens` parameter, matching the local arms' cap.
+## Statistics
 
-The frontier rows' `prompt_sha256` is a canonical SHA-256 commitment to the system-prompt text and item text submitted to the API. It is not a hash of the vendor's serialized request or internal chat framing. The exact rule is under "Hash definitions".
+Rate intervals are Wilson score intervals without continuity correction, and paired differences use Newcombe's square-and-add method with the exact-binomial McNemar test on discordant pairs. Two z values are in force, one per release: every interval computed for this release uses z = 1.959963984540054, the two-sided 95% normal quantile at full precision, while the intervals carried forward from 1.0.0 were computed with the rounded z = 1.96 and are republished exactly as 1.0.0 published them. `publication_metadata.json` records both under `interval_conventions`. Every arm ran the same prompts, so no comparison in this release treats two arms as independent samples. Full-precision values, contingency tables and the paired-bootstrap record are in `publication_metadata.json`. Every statistic in the tables above recomputes from the published row files. Two metadata blocks do not: the 183-item precision check, which needs the identity of the one excluded item (not published), and the 19-item replay on the public set, whose rows are not in the release. The bootstrap is recorded, not recomputable.
 
-### Tuned 14B vs frontier
+Per-set paired movement between the two tuned models, 220k against 83k:
 
-| | gpt-5.6-sol pass | gpt-5.6-sol fail |
-|---|---:|---:|
-| Tuned pass | 168 | 2 |
-| Tuned fail | 11 | 3 |
+| Set | Pairs | 220k gains | 220k loses | Difference | p |
+|---|---:|---:|---:|---:|---:|
+| 184 public (both at Q8_0) | 184 | 6 | 12 | −3.26 pp | 0.24 |
+| 300 EA holdout | 300 | 18 | 17 | +0.33 pp | 1.0 |
+| 200 non-EA holdout | 200 | 49 | 16 | +16.50 pp | 5.1e-5 |
 
-gpt-5.6-sol compiled 11 items the tuned model missed. The tuned model compiled 2 items gpt-5.6-sol missed. Three items failed under both. The exact-binomial McNemar test on the 13 discordant pairs gives p = 0.0225.
+On EA prompts the two models move items in both directions in roughly equal numbers. On non-EA prompts the movement strongly favours the 220k model: 49 items moved its way, 16 the other. The three sets are different populations and their rates are not comparable with each other.
 
-Readers can evaluate the public base model and gpt-5.6-sol on the same benchmark prompts, subject to model access. Exact item-level reproduction of the sampled frontier run is not expected. The fine-tuned arm cannot be independently rerun from this public release because its weights are not distributed.
+## Evaluation sets
 
-## Statistics
+The 184 public prompts are unchanged from 1.0.0. All 184 were run under the Expert Advisor instruction, in 1.0.0 and in the bridge; six of them declare another type in their specification header (item_009, item_089 and item_102 script; item_093 and item_134 indicator; item_167 include) and were run under that same instruction regardless; `publication_metadata.json` lists them under `public_set_184_composition`. They are a decontaminated stratum of a frozen 300-item draw, selection rule and hashes as published there and carried in `publication_metadata.json`.
 
-Stratum: `CLEAN 184 — no normalised-exact training twin`.
+The 300 EA holdout was drawn from a private pool of 1,000 EA items held out of training. The items with a normalised-exact match to the 220k corpus were removed (352 of 1,000), leaving 648. The first 300 in the pool's frozen order were taken. The manifest's identity hash is published; the prompts and item names are not. This pool was scanned against the 220k corpus only; no scan of it against the 83k corpus exists, so the 83k arm's holdout figures carry no decontamination evidence of their own.
 
-| Measure | Value | 95% CI |
-|---|---:|---:|
-| Base compile rate | 1.09% (2/184) | 0.30%–3.88% |
-| Tuned compile rate | 92.39% (170/184) | 87.63%–95.41% |
-| Frontier compile rate | 97.28% (179/184) | 93.80%–98.83% |
-| Base-vs-tuned paired difference | +91.30 pp | 85.40–94.55 pp |
+The 200 non-EA holdout was drawn from a private pool of 600 withheld non-EA items, 150 per class, the 21 items with a normalised-exact match to the 220k corpus were removed before the draw (20 scripts, 1 service), then the first 50 of each class in the pool's own order were taken. Manifest identity hashes are published; prompts and names are not. The same scan scope applies: this pool was checked against the 220k corpus, not the 83k corpus. One specification appears in both the 184 public set (run under the Expert Advisor instruction) and this set (run under the indicator instruction); it is identified by hash in the metadata, and the overlap is one item of 200.
 
-Rate intervals are Wilson score intervals at z = 1.96 exactly. The paired-difference interval is Newcombe's square-and-add MOVER method for paired data. The base-vs-tuned contingency table is 1/1/169/13 (both pass / base only / tuned only / both fail); the exact-binomial McNemar p-value is 2.29e-49. Full-precision values, the phi term the MOVER interval needs, and the paired-bootstrap record are in `publication_metadata.json`; every statistic except the bootstrap recomputes from the published rows.
+Both holdouts were frozen before any arm ran and were not redrawn. The stability re-run above used the same 200 items.
 
-## Evaluation set
+## Decontamination
 
-The 184 items are a decontaminated stratum of a frozen 300-item draw from a 9,168-record pool. The draw used seed 42 and a deterministic selection rule with no RNG, stated in full:
+Every evaluation set was scanned against the 220k corpus, and the 184 public items also keep their 1.0.0 scan against the 83k corpus. No holdout was scanned against the 83k corpus. The two methods are those published in 1.0.0: exact SHA-256 equality of the reference solution against every training row, and equality after a domain normaliser that strips comments and canonicalises names, magic numbers, timeframe and price constants, indicator periods, risk multipliers and symbol literals. No similarity threshold decides membership.
 
-> score(ea_name) = sha256(utf8(str(seed)) + b"\x00" + utf8(ea_name)); order by (lowercase hex of score ASC, ea_name ASC); take first n; manifest lists them sorted by ea_name. seed is encoded as its decimal characters (--seed 42 hashes b"42").
+Every scan carries three known-positive fixtures and one falsifying twin, and all passed: a verbatim duplicate was caught by both methods, a cosmetic variant and a line-ending variant by the normalised method only, and the twin by neither. Twelve fixture records are retained in the evidence package and are not distributed: four for the 2026-08-19 scan, four for the 2026-09-10 scan that covered the public 184 and the 1,000-item EA pool together, and four for the 2026-09-11 scan of the 600-item non-EA pool. All twelve are named with their SHA-256 in `publication_metadata.json` under `decontamination.known_answer_validation` and `decontamination.known_answer_validation_scope`, and the two later scans also carried their known positives and their twin through the full corpus pass rather than a fixture sample alone. The two pool scans behind the third and fourth rows of the table below are named and hashed there as well, under `decontamination.holdout_pool_scans`; that is where the 352, the 21 and the split of the 21 into 20 scripts and 1 service are recorded.
 
-The pool's SHA-256 is `2ca2d669626a44b8a0096ce25873e23d6cbf08f6887295a26179218c7e0d29cf`. The selection and manifest identity hashes are published in `publication_metadata.json`; both are canonical-JSON content hashes computed by the rules the frozen manifest records in its own `hash_spec` field, not hashes of a file's raw bytes.
+Both methods are scored on the reference-solution side. The specification text was scanned as well, and only its exact result is scored, at zero collisions: the specifications are entirely comment lines, the normaliser strips comments first, so every specification normalises to the empty string and a normalised-exact count on that side would measure the instrument, not the corpus. The retained scan records that result as escalated rather than scored, and which side the stop conditions bind on is left unsettled.
 
-The original 300-item draw was frozen before any result was seen and was not redrawn.
+| Set | Corpus | Exact | Normalised-exact | Action |
+|---|---|---:|---:|---|
+| 184 public | 83k (83,155 rows) | 0 | 116 of 300 | removed, leaving 184 (1.0.0) |
+| 184 public | 220k (215,541 rows) | 0 | 1 of 184 | reported; nothing removed |
+| 1,000 EA pool | 220k | 0 | 352 of 1,000 | removed before the 300 draw |
+| 600 non-EA pool | 220k | 0 | 21 of 600 | removed before the 200 draw |
 
-## Decontamination
+The 184-item scan against the 83k corpus cannot be re-run today; the corpus file it read no longer exists, and its hash was established by that run. It was re-run once, on 2026-08-31, from an archived copy at the same hash, and agreed; that copy is also gone. The metadata records that event under `reproduction_gate`. The one 184-item collision against the 220k corpus is reported, not removed, so the 220k arm's 169/184 bridge figure includes one item with a normalised twin in its corpus.
 
-The frozen set was scanned against the training corpus with two methods.
+A descriptive similarity curve was also computed for each scan by a candidate-based matcher whose figures are lower bounds; it is retained with the evidence and is not part of this release. Contamination in this release means an exact or normalised-exact collision, and those counts are in the table above.
 
-The exact method computes SHA-256 over the UTF-8 encoding of each evaluation item's reference solution and over each training row's completion field, and tests digest equality. It found 0 collisions.
+The evaluation prompts come from the same specification generator family as the training corpus, so the benchmark measures in-distribution competence on that family's specification style, not generalisation to human-written specifications.
 
-The normalised-equivalence method applies a domain normaliser to both sides before hashing: it strips comments, canonicalises names, magic numbers, timeframe and price constants, indicator periods, risk multipliers and symbol literals, and collapses whitespace. The normaliser source is pinned by SHA-256 in `publication_metadata.json`. This method found 116 collisions; removing them from the frozen 300 produced the clean stratum of 184.
+## Models
 
-The predicate, the collision count of 116 and a capped witness set of 30 identities were recorded before either local arm ran; the pre-run record kept those 30 witnesses, not all 116 identities. After both local arms had run, the fixed predicate was re-executed twice, independently, and each rerun had to reproduce the pre-run count and all 30 witnesses before the full identity list was emitted. What predates the results is the rule and the count; the explicit membership list was derived afterwards from the rule.
+Base: `Qwen/Qwen2.5-Coder-14B-Instruct`, pinned revision `aedcc2d42b622764e023cf882b6652e646b95671`, quantised to Q8_0 for this release.
 
-The normaliser is deliberately aggressive: it collapses parameter variation, so items differing only in parameters normalise to the same string. The clean stratum removes more than a strict reading requires.
+Tuned, 83k: the 1.0.0 fine-tuned model (one epoch on 83,155 rows, corpus SHA-256 `5e9881b61f3375d3d575c35950a236375eb5648f5fe55b8d18de321f69659c68`), merged and quantised to Q8_0.
 
-No similarity threshold decides membership. The evaluation prompts come from the same specification generator family as the training corpus, so the benchmark measures in-distribution competence on that family's specification style, not generalisation to human-written specifications.
+Tuned, 220k: the same base fine-tuned for one epoch on a 215,541-row corpus, SHA-256 `3c2f57db5986eaac49f7ae5ed6732e1ae702b339b1354bf3d94e33c7b611e023`, merged and quantised to Q8_0. Adapter, merge and GGUF identities are pinned by SHA-256 in `publication_metadata.json`. For the 220k model the one-epoch figure comes from the training plan; no trainer-state epoch or global step was read for it, and the metadata says so. For the 83k model the epoch and global step were read from trainer state. Two historical merges of the 83k model from the same inputs in the same environment produced byte-identical weights. Cross-environment reproduction was not performed for either tuned model. A row-content hash manifest ships as `corpus_row_hashes.json`: 219,867 row hashes, no contents, no names. The 215,541-row corpus the model was trained on is the subset of those rows that passed a maximum-length rule; the 4,326 other hashes are the rows that rule dropped. The threshold is not published and this release did not check the subset row by row, so the check a counterparty holding the corpus can make is that every row they hold hashes to a member of the manifest. No one else can verify it.
 
-## Models
+Frontier: `gpt-5.6-sol` through the vendor API, identified by model name and evaluation date (2026-09-02 on the 184; 2026-09-11 on the 300).
 
-Base: `Qwen/Qwen2.5-Coder-14B-Instruct`, pinned revision `aedcc2d42b622764e023cf882b6652e646b95671`, served at bf16 with no quantisation.
+Model weights are not distributed in any version of this release.
 
-Tuned: the base model fine-tuned for one epoch on the withheld corpus (83,155 rows, SHA-256 `5e9881b61f3375d3d575c35950a236375eb5648f5fe55b8d18de321f69659c68`), merged to bf16 and served directly. Adapter, merge tool, merge settings and merged-weight identities are pinned by SHA-256 in `publication_metadata.json`, including the epoch and global-step evidence read from trainer state rather than directory names. Two historical merges from the same inputs in the same environment produced byte-identical weights; cross-environment reproduction was not performed.
+## The 1.0.0 arms
 
-Frontier: `gpt-5.6-sol` through the vendor API, identified by model name and evaluation date 2026-09-02.
+The 1.0.0 local arms were served through Hugging Face transformers at bf16 with greedy decoding, on the same hardware. The two local arms shared one prompt template, the tuned model's training format; a quantised base-model control comparing that template against the base's native ChatML format changed one verdict out of 183 jointly scoreable items, in the shared template's favour. The 1.0.0 frontier arm ran on 2026-09-02 with temperature 1. The 1.0.0 base-vs-tuned contingency table is 1/1/169/13 (both pass / base only / tuned only / both fail), McNemar p = 2.29e-49; tuned-vs-frontier is 168/2/11/3, p = 0.0225. Those figures and their intervals are unchanged in `publication_metadata.json`.
 
 ## Hash definitions
 
-`prompt_sha256_public` is the SHA-256 of the UTF-8 encoding of the prompt exactly as published in `prompts.jsonl`.
+`prompt_sha256_public` is the SHA-256 of the UTF-8 encoding of the prompt exactly as published in `prompts.jsonl`. Holdout rows carry `item_sha256`, the SHA-256 of the UTF-8 specification text, as their only item identity; the text itself is not published.
 
-`prompt_sha256` is an arm-specific request-content hash. On base and tuned rows it hashes the rendered serving template from `serving_template.json`. On frontier rows it hashes the system prompt, two newline characters, then the prompt, the canonical form of the two fields submitted to the API. Both rules are machine-checked by the release verifier.
+`prompt_sha256` is an arm-specific request-content hash. On local rows it hashes the rendered serving template. On frontier rows it hashes the system prompt, two newline characters, then the prompt. The verifier recomputes both rules on the 184 public rows of `per_item_results.jsonl`. On the holdout and bridge files it checks row counts, arm identities, headline and truncation counts and item pairing. On the two holdout files it cannot recompute a prompt hash because the holdout prompts are not published. On the bridge file the prompts are the 184 public prompts, so each row's `prompt_sha256` equals the local-arm value on the matching 1.0.0 row and can be checked by that equality; the verifier does not recompute it there.
 
-`mq5_sha256` and `ex5_sha256` are commitments to the generated source and compiled artifact of a row. `mq5_sha256` is present on every row. `ex5_sha256` is present only on rows where an EX5 artifact was produced and is null on the rest; a failed compile leaves nothing to hash. Those artifacts are not distributed; the hashes permit integrity verification if they are later disclosed under agreement.
+`mq5_sha256` and `ex5_sha256` are commitments to the generated source and compiled artifact of a row. `mq5_sha256` is present on every row; on the seven frontier rows where no source was extracted (three API failures and four ceiling truncations) it holds the SHA-256 of zero bytes, `e3b0c442…`, and commits to nothing. `ex5_sha256` is present only on rows where an EX5 artifact was produced and is null on the rest. Those artifacts are not distributed; the hashes permit integrity verification if they are later disclosed under agreement.
 
 ## What is public and what is not
 
 | Claim or artifact | Publicly verifiable |
 |---|---|
-| Published prompts and prompt hashes | Yes |
-| Per-arm result arithmetic and statistics | Yes |
+| The 184 published prompts and their hashes | Yes |
+| Per-arm result arithmetic and statistics, every set | Yes |
 | Running a new model on the 184 prompts | Yes |
+| Holdout prompts, item names, and running a model on them | No |
 | Original generated MQL5 and compiler logs | No |
 | Tuned model outputs and weights | No |
-| Training-corpus contents and decontamination scan | No |
+| Training-corpus contents and decontamination scans | No |
 | Exact original harness behaviour | No |
 
-Non-public claims are bound to retained artifacts and hashes but cannot be independently reproduced from this release. Generated MQL5 source is not distributed for any arm. Access to undistributed material is available under written agreement.
-
-Item names are public: each prompt carries a `// NAME:` line because that line was part of the prompt the models were served, and the published prompts are byte-identical to the evaluated ones. The names disclose the corpus naming scheme for these 184 items; the corpus itself remains undistributed. The 184 prompts should be treated as a public benchmark from this release onward, not as an uncontaminated evaluation set. A separate private holdout is reserved for future releases.
+The holdout results are attested, not fully verifiable. Every holdout row is published as item hash, arm, verdicts, bucket, error and warning counts, truncation flag and output hashes. The arithmetic can be checked. Rows with a generated source are bound to the retained source and compiler output by hash; the seven frontier rows with no extracted source are bound only to their item and request identity and to the recorded failure. No third party can regenerate any of them from this release. Access to undistributed material is available under written agreement.
 
 ## Files
 
 | File | Content |
 |---|---|
 | `README.md` | this card |
-| `prompts.jsonl` | 184 prompt rows |
-| `per_item_results.jsonl` | 552 rows: 184 base, 184 tuned, 184 frontier |
-| `serving_template.json` | system prompt and serving template |
-| `publication_metadata.json` | release metadata, full-precision statistics, model provenance |
+| `prompts.jsonl` | 184 public prompt rows (1.0.0) |
+| `per_item_results.jsonl` | 552 rows: 184 base, 184 tuned, 184 frontier (1.0.0, bf16) |
+| `holdout_ea300_results.jsonl` | 1,200 hash-keyed rows: base, 83k, 220k, frontier on the 300 EA holdout |
+| `holdout_nonea200_results.jsonl` | 800 hash-keyed rows: base, 83k, 220k and the 220k re-run on the 200 non-EA holdout |
+| `bridge_q8_184_results.jsonl` | 552 rows: base, 83k and 220k at Q8_0 on the 184 public prompts |
+| `serving_template.json` | system prompts (EA and the four non-EA classes) and serving template |
+| `publication_metadata.json` | release metadata, full-precision statistics, model and manifest identities |
+| `corpus_row_hashes.json` | 219,867 row-content hashes of the 220k corpus, no contents |
 | `PROJECTION_REPORT.json` | row-projection record, field inventory, hash definitions |
 | `verify_public_release.py` | the release verifier |
 | `SHA256SUMS.txt` | checksum manifest over every file except itself |
 | `LICENSE`, `CITATION.cff`, `.gitattributes` | licence, citation metadata, line-ending pin |
 
-File hashes are in `SHA256SUMS.txt`. The hashes cover the files as stored, with LF line endings; `.gitattributes` pins that so checkout does not rewrite them. The per-row field dictionary is in `PROJECTION_REPORT.json`. Two error counts appear on every row: `errors` counts printed diagnostics, which the compiler caps around 100, and `result_line_errors` is the compiler's own final tally; they differ on 12 base-arm rows and both are far above zero wherever they differ.
+File hashes are in `SHA256SUMS.txt`. The hashes cover the files as stored, with LF line endings; `.gitattributes` pins that so checkout does not rewrite them. The per-row field dictionary is in `PROJECTION_REPORT.json`.
+
+## Limitations
+
+- Compilation is a low bar. It is a necessary, not a sufficient, condition for useful code. Nothing in this release measures whether any generated artifact is correct, useful, or safe to run.
+- A single language, with no claim of transfer.
+- The prompts are generator-produced, not harvested from human-written production code, and come from the same generator family as the training corpus. This measures in-distribution competence; it is not a test of generalisation to human-written specifications.
+- The frontier arm is a moving target; its snapshot dates bound the comparison.
+- The 8,192-token ceiling truncated rows on the non-EA set. Whether an item the model would have finished past that ceiling should count against it is a judgement this release makes one way (it counts as a fail).
+- The holdout sets are private, so their results are attested by hash rather than reproducible.
+- Each non-EA class cell is 50 items.
+- Token counts for the training corpora are not published; row counts and corpus hashes are.
+- The harness, extractor and scorer are not distributed. An independent implementation of the scoring contract may score individual items differently.
+- Merge determinism rests on two historical merges of the 83k model, not on a fresh remerge.
 
 ## Licence
 
 The benchmark files are provided under the CompilingThings Benchmark Evaluation Licence v1.0. The summary below is non-exhaustive; LICENSE controls in the event of any conflict.
 
-Permitted: running the 184 published prompts against any model; implementing and using the published scoring contract; publishing and comparing benchmark results, including results that disagree with ours; citing the benchmark and release identifier. The supporting files may be reproduced and quoted for using, checking or citing the benchmark, and `verify_public_release.py` may be run as-is.
+Permitted: running the 184 published prompts against any model; checking, citing and comparing the published result rows and the corpus row-hash manifest, including the holdout row files; implementing and using the published scoring contract; publishing and comparing benchmark results, including results that disagree with ours; citing the benchmark and release identifier. The supporting files may be reproduced and quoted for using, checking or citing the benchmark, and `verify_public_release.py` may be run as-is.
 
 Not permitted: using the prompts for training, fine-tuning, continued pretraining, distillation, or reinforcement learning; incorporating the prompts or result rows into another dataset; creating or selling derivative datasets; representing the benchmark as your own work.
 
@@ -238,10 +334,10 @@ Identity: CompilingThings. For evaluation access, research collaboration, commer
 
 ## Citation
 
-`CITATION.cff` ships with the release and identifies CompilingThings as the author of version 1.0.0.
+`CITATION.cff` ships with the release and identifies CompilingThings as the author of version 1.1.0.
 
 ## MetaQuotes notice
 
 MQL5® and MetaTrader 5® are registered trademarks of MetaQuotes Ltd. CompilingThings is an independent project. No affiliation, sponsorship, certification, endorsement, or approval by MetaQuotes Ltd. is claimed.
 
-Compilation validation used the MetaQuotes Language Compiler supplied with MetaEditor. This release does not distribute MetaTrader 5, MetaEditor, compiler binaries, MetaQuotes documentation, or other MetaQuotes-owned materials. The benchmark prompts published in this release were produced by CompilingThings' own generators and are owned by CompilingThings. No model-generated MQL5 source or other model outputs are distributed.
+MQL5 outputs were compiled using the MetaQuotes Language Compiler through MetaEditor. This release does not distribute MetaTrader 5, MetaEditor, compiler binaries, MetaQuotes documentation, or other MetaQuotes-owned materials. The benchmark prompts published in this release were produced by CompilingThings' own generators and are owned by CompilingThings. No model-generated MQL5 source or other model outputs are distributed.

SHA256SUMS.txt

@@ -1,10 +1,14 @@
 a098d07c577a07fd743b89f23ca6417fc4a8d1577d1c1e4293a74dbf6e75cff9  .gitattributes
-232c0818adbdc5bfa72e6a733862f6c2f7db1950b050836436367c24e5d5d86b  CITATION.cff
-e9ea2cc2c6f2b44b9a011e4ae09d2880a72e4e18d3fa580a541ab3b03c96b08a  LICENSE
+8ecdaa25fa270968498634d0b5c20fbb3517433bd6ec25f358dbee78d6a73b44  bridge_q8_184_results.jsonl
+e5d71c8c25a3e6dc67096fa6719ea1227295fb16270a633d9911668b9af5cdc1  CITATION.cff
+4dbabd017b4c50f803a83ec981c99b53b9a2b2247ed1000bde4f571f21e1bcfd  corpus_row_hashes.json
+2814f69247f09f3efdd941ed6013aa0a638d3a2eb16b63c9d90113fb6be23dd9  holdout_ea300_results.jsonl
+13c9812df5c390a024d2385c7a6f127124cef061c79baaae36e1b635af593a7a  holdout_nonea200_results.jsonl
+a882edcd2c3b7fec1383fd1296b565952d341040b6d34b4eaa9f88a81a6ed59c  LICENSE
 3584aefb4f4226e9ba9ae7453c274eebab6f30b62d0dd89a23f41202c6ec070d  per_item_results.jsonl
-f5d16bb2b25def5823e349359338e22f187e2618895b47167562a90184d4f748  PROJECTION_REPORT.json
+2c7b2ee210391b9e5484ae4b9c83f35e5c96f2025638a5b1b929069013452fe2  PROJECTION_REPORT.json
 d58391038d39b22d1865e5d874764201f65918fbf92fe837a465f58daee7cfa7  prompts.jsonl
-cc9a185490cdaafc26c26df74716a9233055328435e87907dc501c75a5e8e0c4  publication_metadata.json
-42947bc5a30b35dadb43f0255fbc410f4a2621576eaa4eca869f24986e5b936d  README.md
-979346bc6c0bfee309188be88a5f1611882344ebd44d7e9796066068cd004541  serving_template.json
-8f78bd149381a0529787f9c38130f57e4a6858ea5fa1dc453eb2ad8c10eca2ef  verify_public_release.py
+b939f000b91baded760159c8192ac6a390070b154f8ab26bf526072ea9aab06d  publication_metadata.json
+a8064651458cf42e1cb615bbd4ebb8a0c6ce4415e43b9543e65748c6197c9115  README.md
+3601f3ff49381282ee7e3f83e21db9f9e3891910e4092c9461a2a798c9b14756  serving_template.json
+1aaacb967d748d1cfe6d6ca2e089daa963ba8a9e8df8800bb60521d135d72d9a  verify_public_release.py

corpus_row_hashes.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4dbabd017b4c50f803a83ec981c99b53b9a2b2247ed1000bde4f571f21e1bcfd
+size 21107837

serving_template.json

@@ -2,10 +2,17 @@
   "system_prompt": "You are an expert MQL5 programmer. Write the complete MQL5 Expert Advisor code that implements the given specification exactly.",
   "system_prompt_sha256": "820208ddccc935fe44222db63416e192f605183e1b77c8e833de0d8aa94c6377",
   "template": "<|system|>{system_prompt}<|end|>\n<|user|>{prompt}<|end|>\n<|assistant|>",
-  "note": "This template applies to the two local arms (base and tuned) only; the frontier arm was not served with it. On local-arm rows prompt_sha256 is sha256 of the UTF-8 encoding of the rendered string; frontier rows follow the system+user rule in PROJECTION_REPORT.json hash_definitions. prompt_sha256_public is sha256 of the UTF-8 encoding of the prompt alone, exactly as published in prompts.jsonl.",
+  "note": "This template applies to the three local arms (base, tuned 83k, tuned 220k) on every set; the frontier arm was not served with it. The four non-EA system instructions are in this file, under system_prompt_by_category. On local-arm rows prompt_sha256 is sha256 of the UTF-8 encoding of the rendered string; frontier rows follow the system+user rule in PROJECTION_REPORT.json hash_definitions. prompt_sha256_public is sha256 of the UTF-8 encoding of the prompt alone, exactly as published in prompts.jsonl.",
   "worked_example": {
     "item_id": "item_001",
     "prompt_sha256_public": "8002a63c52279e6c92f85b146dc099375fa382f06b02f93c9cc424ecf64e605a",
     "prompt_sha256": "02ad9e31a9c46835c8f1e1d1edf7caa1e85f1537eb5e3d98f393a6ff9718147f"
-  }
+  },
+  "system_prompt_by_category": {
+    "include": "You are an expert MQL5 programmer. Write the complete MQL5 include file code that implements the given specification exactly.",
+    "indicator": "You are an expert MQL5 programmer. Write the complete MQL5 custom indicator code that implements the given specification exactly.",
+    "script": "You are an expert MQL5 programmer. Write the complete MQL5 script code that implements the given specification exactly.",
+    "service": "You are an expert MQL5 programmer. Write the complete MQL5 service code that implements the given specification exactly."
+  },
+  "system_prompt_by_category_note": "The instruction an item is sent is chosen by the category recorded for it, which is not the same thing as the artifact type its specification declares. The 184 public prompts, the 300 EA holdout and every 1.0.0 arm are sent the system_prompt above, unchanged - including the six of the 184 whose own specifications declare script, indicator or include, which were neither re-instructed nor excluded; publication_metadata.json lists those six under public_set_184_composition. The four strings here are sent to the non-EA holdout's include, indicator, script and service items respectively. There is no fallback: an item of any other category stops the run before a generation is paid for. The non-EA prompts themselves are not published, so these strings are the whole of what a reader needs to reproduce the non-EA request framing."
 }

verify_public_release.py

@@ -22,8 +22,19 @@ Checks:
      local-arm row
   7  every SHA-256 quoted in the card is one the release stands behind
   8  every checksum-manifest entry recomputes from the shipped files
+  9  the three v1.1 row files carry the row count, the arm ids and the per-arm row
+     counts the card publishes
+ 10  every published headline count falls out of the rows under the pre-registered
+     scoring rule: a pass is verdict_headline true AND truncated false
+ 11  every published per-arm truncation count falls out of the rows
+ 12  the arms of a row file cover one and the same item set, once each
+ 13  corpus_row_hashes.json carries 219,867 row hashes and agrees with its own count
   D  diagnostic: do the sealed spec_sha256 / prompt_sha256 reproduce from the prompt?
 
+Checks 9 to 13 need nothing but the published files. They run on the holdout rows even
+though the holdout prompts are private: the arithmetic of an attested result is still
+arithmetic, and it is the only thing about the holdouts a reader can check.
+
 Checks 1 and 2 need the evaluation pool, the frozen manifest and the id-to-name mapping.
 None of those is distributed, so for a public reader they report SKIPPED and the run
 continues. Checks 3 through 8 need nothing but the published files.
@@ -66,6 +77,49 @@ EXPECTED_FRONTIER = {"n": 184, "frontier": 179,
                      "both_pass": 168, "tuned_only": 2,
                      "frontier_only": 11, "both_fail": 3}
 
+CORPUS_NAME = "corpus_row_hashes.json"
+EXPECTED_CORPUS_ROWS = 219867
+
+# Every count the card publishes for the v1.1 row files, keyed by file and arm.
+# `passes` is the headline figure under the pre-registered rule below; it is NOT a
+# count of rows whose verdict_headline is true. On the 220k arm of the non-EA holdout
+# the two differ by one - a row compiled despite being truncated - and that single
+# item is why the rule is stated here rather than assumed.
+EXPECTED_ROW_FILES = {
+    "holdout_ea300_results.jsonl": {
+        "rows": 1200, "items": 300, "item_key": "item_sha256",
+        "arms": {
+            "base": {"rows": 300, "passes": 1, "truncated": 3},
+            "tuned83k": {"rows": 300, "passes": 281, "truncated": 0},
+            "tuned220k": {"rows": 300, "passes": 282, "truncated": 0},
+            "frontier": {"rows": 300, "passes": 286, "truncated": 4},
+        },
+    },
+    "holdout_nonea200_results.jsonl": {
+        "rows": 800, "items": 200, "item_key": "item_sha256",
+        "arms": {
+            "base": {"rows": 200, "passes": 56, "truncated": 14},
+            "tuned83k": {"rows": 200, "passes": 135, "truncated": 13},
+            "tuned220k": {"rows": 200, "passes": 168, "truncated": 12},
+            "tuned220k_q8_replay": {"rows": 200, "passes": 169, "truncated": 11},
+        },
+    },
+    "bridge_q8_184_results.jsonl": {
+        "rows": 552, "items": 184, "item_key": "item_id",
+        "arms": {
+            "base": {"rows": 184, "passes": 2, "truncated": 2},
+            "tuned83k": {"rows": 184, "passes": 175, "truncated": 0},
+            "tuned220k": {"rows": 184, "passes": 169, "truncated": 0},
+        },
+    },
+}
+
+
+def scored_pass(row: dict) -> bool:
+    """The pre-registered scoring rule, and the whole of it: a generation cut off at
+    the token ceiling counts as a fail even if what it produced happened to compile."""
+    return row.get("verdict_headline") is True and row.get("truncated") is not True
+
 
 def format_api_prompt(system: str, spec: str) -> str:
     """Canonical rendering of the frontier arm's system+user pair. The vendor API
@@ -432,6 +486,99 @@ def main(argv: list[str]) -> int:
         # Same rule as check 7: a copy with no manifest is unverifiable, not verified.
         failures.append(f"[8] cannot run: {MANIFEST_NAME} is missing")
 
+    # ---- checks 9-12 -------------------------------------------------------------
+    # The v1.1 row files. These ship, so a missing one is a failure and never a skip:
+    # the card's headline tables are computed from them and a reader who cannot find
+    # them cannot check a single holdout number.
+    loaded: dict[str, list[dict]] = {}
+    for fname in EXPECTED_ROW_FILES:
+        path = args.public / fname
+        if path.is_file():
+            loaded[fname] = list(read_jsonl(path))
+        else:
+            failures.append(f"[9] {fname} is missing from the public release")
+
+    shape_bad, pass_bad, trunc_bad, pair_bad = [], [], [], []
+    for fname, want in EXPECTED_ROW_FILES.items():
+        rows = loaded.get(fname)
+        if rows is None:
+            continue
+        key = want["item_key"]
+        by_arm: dict[str, list[dict]] = defaultdict(list)
+        for r in rows:
+            by_arm[r.get("arm")].append(r)
+
+        if len(rows) != want["rows"]:
+            shape_bad.append(f"{fname}: {len(rows)} rows, expected {want['rows']}")
+        if sorted(by_arm) != sorted(want["arms"]):
+            shape_bad.append(f"{fname}: arm ids {sorted(by_arm)}, expected "
+                             f"{sorted(want['arms'])}")
+        for arm, cell in want["arms"].items():
+            got_rows = by_arm.get(arm, [])
+            if len(got_rows) != cell["rows"]:
+                shape_bad.append(f"{fname}/{arm}: {len(got_rows)} rows, expected "
+                                 f"{cell['rows']}")
+                continue
+            got_pass = sum(1 for r in got_rows if scored_pass(r))
+            if got_pass != cell["passes"]:
+                pass_bad.append(f"{fname}/{arm}: {got_pass}/{len(got_rows)} passes, "
+                                f"expected {cell['passes']}")
+            got_trunc = sum(1 for r in got_rows if r.get("truncated") is True)
+            if got_trunc != cell["truncated"]:
+                trunc_bad.append(f"{fname}/{arm}: {got_trunc} truncated, expected "
+                                 f"{cell['truncated']}")
+
+        # One item set, once per arm. A duplicate key inside an arm and a key present
+        # in one arm but not another are different faults, so both are named.
+        reference = None
+        for arm in sorted(want["arms"]):
+            keys = [r.get(key) for r in by_arm.get(arm, [])]
+            unique = set(keys)
+            if len(unique) != len(keys):
+                pair_bad.append(f"{fname}/{arm}: {len(keys) - len(unique)} duplicate "
+                                f"{key} value(s)")
+            if len(unique) != want["items"]:
+                pair_bad.append(f"{fname}/{arm}: {len(unique)} distinct {key}, "
+                                f"expected {want['items']}")
+            if reference is None:
+                reference = unique
+            elif unique != reference:
+                pair_bad.append(f"{fname}/{arm}: its {key} set differs from the first "
+                                f"arm's by {len(unique ^ reference)} value(s)")
+
+    for tag, label, problems in (
+            (9, "row counts and arm ids", shape_bad),
+            (10, "headline counts under the pre-registered scoring rule", pass_bad),
+            (11, "per-arm truncation counts", trunc_bad),
+            (12, "item pairing across arms", pair_bad)):
+        if problems:
+            failures.append(f"[{tag}] {label} do not reproduce: {problems[:3]}")
+        elif loaded:
+            print(f"  [{tag}] {label} reproduce for all {len(loaded)} v1.1 row files")
+
+    # ---- check 13 ----------------------------------------------------------------
+    corpus_path = args.public / CORPUS_NAME
+    if not corpus_path.is_file():
+        failures.append(f"[13] {CORPUS_NAME} is missing from the public release")
+    else:
+        corpus = json.loads(corpus_path.read_text(encoding="utf-8"))
+        entries = corpus.get("row_content_hashes", [])
+        declared = corpus.get("counts", {}).get("final")
+        malformed = sum(1 for e in entries
+                        if not re.fullmatch(r"[0-9a-f]{64}", str(e.get("sha256", ""))))
+        if len(entries) != EXPECTED_CORPUS_ROWS:
+            failures.append(f"[13] {CORPUS_NAME} carries {len(entries)} row hashes, "
+                            f"expected {EXPECTED_CORPUS_ROWS}")
+        elif declared != EXPECTED_CORPUS_ROWS:
+            failures.append(f"[13] {CORPUS_NAME} declares counts.final {declared}, "
+                            f"expected {EXPECTED_CORPUS_ROWS}")
+        elif malformed:
+            failures.append(f"[13] {CORPUS_NAME}: {malformed} entr(ies) do not carry a "
+                            f"64-hex sha256")
+        else:
+            print(f"  [13] {CORPUS_NAME} carries {len(entries)} row hashes and agrees "
+                  f"with its own counts.final")
+
     # ---- diagnostic --------------------------------------------------------------
     if args.sealed_rows and args.sealed_rows.is_file():
         sealed = {r["ea_name"]: r for r in read_jsonl(args.sealed_rows)}