Publish verified checkpoint and losslessly compressed study evidence

LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Alibaba Cloud
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

NOTICE

@@ -0,0 +1,16 @@
+Stackcraft
+Copyright 2026 Stackcraft contributors.
+
+Stackcraft is an independent educational falling-block game and fine-tuning study.
+It is not affiliated with or endorsed by Tetris, Cloudflare, or the Qwen project.
+
+The optional trained model derives from Cloudflare/Clef-Flash (Apache-2.0),
+revision 17f0b0ad64efb65d273590632833508766b2aae6, which derives from
+Qwen/Qwen3.5-9B. Original backbone weights and native joint-schema implementation
+remain upstream dependencies; this repository does not redistribute the backbone.
+Stackcraft adds game-specific LoRA matrices and trains a separate native decision
+head. The trained head and LoRA weights must be loaded together.
+
+Upstream model: https://huggingface.co/Cloudflare/clef-flash
+Base architecture: https://huggingface.co/Qwen/Qwen3.5-9B
+Python package dependency licenses remain with their respective authors.

README.md

@@ -0,0 +1,159 @@
+---
+license: apache-2.0
+base_model: Cloudflare/clef-flash
+base_model_relation: adapter
+library_name: peft
+language:
+- en
+tags:
+- clef
+- decision-model
+- lora
+- imitation-learning
+- stackcraft
+---
+
+# Stackcraft Clef-Flash
+
+Selected checkpoint: **epoch-02**, chosen on validation before final tests.
+This is a small, synthetic imitation-learning study of a falling-block placement
+policy. It is not a generally capable game agent, reinforcement-learning result,
+or competitive Tetris implementation.
+
+The artifact contains a rank-4 LoRA adapter **and a separately trained FP32 native
+joint decision head** for `Cloudflare/clef-flash`, pinned revision
+`17f0b0ad64efb65d273590632833508766b2aae6`. Load both. The frozen BF16 backbone
+is downloaded separately; these files are not a standalone model. Clef-flash is
+based on Qwen3.5-9B. The native schema head scores every supplied legal placement
+in one forward pass, with no generated text or command parsing.
+
+Related releases: [source and tutorials](https://github.com/kkarimi/stackcraft),
+[model](https://huggingface.co/nima1/stackcraft-clef-flash-lora),
+[dataset](https://huggingface.co/datasets/nima1/stackcraft-data), and
+[planned CPU demo](https://huggingface.co/spaces/nima1/stackcraft).
+The hosted demo awaits Hugging Face's Docker-account subscription requirement;
+[local Docker instructions](https://github.com/kkarimi/stackcraft/blob/main/docs/demo-hosting.md)
+work without that subscription.
+
+## Intended use
+
+Learn how to build deterministic environments, generate search-teacher labels,
+train a custom decision model, preserve its native head, and evaluate complete
+games with paired uncertainty. The playable demo uses recorded model replays;
+it does not provide public live GPU inference.
+
+The observation is a 10×20 occupied-cell grid, current tetromino, exactly one next
+piece, rules and every legal placement with its coordinates. The action selects
+an orientation and column, then drops vertically. There is no hold, wall kick,
+tuck, gravity timer, T-spin bonus or changing speed. Hidden future pieces and
+sequence seeds are excluded from neural input. Probabilities reflect the model's
+choice distribution; they are not calibrated chances of clearing a line or winning.
+
+## Training and data
+
+The study uses 827 training and 215 validation positions generated from fixed
+seven-bag streams. Random, heuristic and search policies collect states. Every
+label comes from a fixed two-placement search using the current piece and one
+preview, with a board-height/holes/bumpiness/line-clear heuristic. These are
+synthetic teacher preferences, not human demonstrations or globally optimal moves.
+Exact duplicate observations are removed across splits. Six source hashes and
+exact file hashes accompany the dataset manifest.
+
+Preregistered training: seed 42, two epochs, batch 1, accumulation 8, rank 4/alpha 8,
+no LoRA dropout, AdamW lr 1e-5/weight_decay 0.01, gradient norm cap 1.0, label smoothing
+0.05 and Brier sum weight0.1. BF16 backbone, FP32 head, text-layer LoRA including
+both hybrid attention types and MLPs. Vision, output and other original parameters
+remain frozen. There are 132,582,404 trainable parameters: 121,762,820 in the
+joint head and 10,819,584 in LoRA. This is why the head is a substantial part of
+the saved artifact, even though most backbone weights stay frozen. Select only between epoch 01/02 using lowest finite target NLL on
+all 215 validation positions; exact ties choose the earlier epoch.
+
+## Evaluation and limitations
+
+Final preregistered comparison: 200 untouched seeds 30000–30199, 200-piece cap,
+selected model versus unchanged native BF16-head Clef, unchanged FP32-head
+ablation, random legal placement and a cheap heuristic. Primary metric is lines
+cleared. Report score, survival, cap hits, failures and latency. Paired 95% bootstrap
+intervals use 10000 episode resamples with seed 2026. Failed episodes remain in the
+analysis, assigned zero primary outcomes with partial outcomes reported separately.
+
+Verified final outcomes on all 200 paired seeds, with a 200-piece cap. Lines, score and placed-piece summaries use the preregistered zero-on-error policy. Cap hits indicate censored survival.
+
+| Player | Lines mean (median) | Score mean (median) | Placed mean (median) | Cap hits | Errors |
+| --- | ---: | ---: | ---: | ---: | ---: |
+| base | 0.070 (0.0) | 7.000 (0.0) | 26.020 (26.0) | 0.0% | 0.0% |
+| base-fp32 | 0.105 (0.0) | 10.500 (0.0) | 26.000 (26.0) | 0.0% | 0.0% |
+| trained | 16.810 (16.0) | 1745.500 (1650.0) | 83.565 (82.0) | 0.0% | 0.0% |
+| random | 0.140 (0.0) | 14.000 (0.0) | 26.645 (27.0) | 0.0% | 0.0% |
+| heuristic | 76.530 (77.0) | 8306.500 (8300.0) | 200.000 (200.0) | 100.0% | 0.0% |
+
+Each paired 95% bootstrap interval resamples complete episode differences. Trained versus native base is the primary comparison; the heuristic and FP32-head comparisons are separate checks. Intervals are not adjusted for multiple comparisons.
+
+| Comparison (first minus second) | Mean lines difference | Paired 95% interval |
+| --- | ---: | ---: |
+| trained − base | 16.740 | [15.740, 17.770] |
+| trained − heuristic | -59.720 | [-60.805, -58.620] |
+| trained − base-fp32 | 16.705 | [15.705, 17.740] |
+| base-fp32 − base | 0.035 | [-0.020, 0.090] |
+
+Decision latency includes recorded first-call effects, tokenization and policy overhead, but excludes game rendering and replay playback.
+
+| Player | Decision mean ms | Median ms | p95 ms | Invalid decisions |
+| --- | ---: | ---: | ---: | ---: |
+| base | 149.110 | 139.381 | 244.916 | 0 |
+| base-fp32 | 150.188 | 140.968 | 247.880 | 0 |
+| trained | 206.814 | 171.844 | 309.000 | 0 |
+| random | 0.001 | 0.001 | 0.003 | 0 |
+| heuristic | 0.199 | 0.139 | 0.281 | 0 |
+
+The full reports retain raw outcomes, all failed seeds and probability logs.
+
+Fine-tuning improved complete-game play over both unchanged Clef references in
+this study. The fixed heuristic still cleared substantially more lines and used
+about one thousandth of the trained model's decision time on this workstation.
+All five policies had zero errors and invalid decisions. Every heuristic game hit
+the 200-piece cap; no neural or random game did. This is evidence of task adaptation,
+not a reason to prefer this 9B model over the heuristic for the simplified game.
+See [the readable study report](code/reports/final-study.md) and
+[the hardware/runtime snapshot](code/reports/evaluation-hardware.json).
+
+
+Only one training seed, one small synthetic dataset, one simplified game ruleset
+and one hardware/software configuration are studied. The finite cap censors
+survival. Validation teacher agreement does not establish game quality. Test
+uncertainty does not capture variation across training seeds.
+
+## Loading
+
+Use the released Stackcraft source and locked ML dependencies. Generic
+`AutoModel` or adapter-only loading omits the custom decision head and is incorrect.
+From the downloaded model repository's `code/` directory, install the locked ML
+environment with `uv sync --locked --extra ml` and cache the pinned upstream
+snapshot as described in [Tutorial 02](code/docs/tutorials/02-baselines.md).
+Run this example with `uv run --locked --extra ml python`; the sibling
+`../checkpoint` directory contains the released adapter and head:
+
+```python
+from stackcraft.clef import ClefPlayer
+from stackcraft.training import load_checkpoint
+from stackcraft.engine import new_game
+from stackcraft.players import observe
+
+player = ClefPlayer.from_pretrained(trust_pinned_code=True, local_files_only=True)
+load_checkpoint(player.model, "../checkpoint")
+print(player.choose(observe(new_game(42))))
+```
+
+`trust_pinned_code=True` executes reviewed, hash-checked upstream Python. It is
+not a sandbox. The measured RTX 5090 inference baseline allocated 19.7 GB; bounded
+LoRA training allocated 23.2 GB. Load only with sufficient free VRAM. Context is
+limited to 4096 tokens, with explicit rejection before any state truncation.
+
+See the released tutorials, training configuration, artifact hashes and evaluation
+report for exact reproduction. Apache-2.0; see LICENSE and NOTICE for upstream
+attribution. This project is independent of Cloudflare, Qwen and Tetris.
+
+
+## Bundle layout
+
+`checkpoint/` preserves the selected checkpoint bytes. `code/` contains the source, locked environment, tests, scripts and milestone tutorials. `evidence.zip` losslessly compresses the frozen selection, both validation candidates and complete final evaluation. From the model repository root, run `python -m zipfile -e evidence.zip .` after download verification to restore `evidence/` and all original relative paths. `evidence-files.json` records each raw file's byte count and SHA256; extraction preserves the original evidence hashes. From `code/`, run `uv sync --locked --extra ml`; load `../checkpoint` using the native Stackcraft loader. No access to a private GitHub repository is required.

checkpoint/adapter/README.md

@@ -0,0 +1,24 @@
+---
+base_model: Cloudflare/clef-flash
+library_name: peft
+tags:
+- lora
+- stackcraft
+---
+
+# Stackcraft LoRA adapter component
+
+This Stackcraft adapter adapts [Cloudflare/clef-flash](https://huggingface.co/Cloudflare/clef-flash),
+released by Cloudflare and pinned at revision `17f0b0ad64efb65d273590632833508766b2aae6`.
+The original model card and license are provided in that upstream repository.
+
+This directory is only one component of the Stackcraft checkpoint. Load the
+parent checkpoint's `joint_head.safetensors` and this adapter together through
+Stackcraft's `load_checkpoint` function. The native decision head contains learned
+parameters; loading only the LoRA adapter does not reproduce the trained model.
+Use the exact pinned base and the parent `training_config.json` contract.
+
+This component card does not claim improved performance or publication status.
+See the release's full model card and evaluation report for measured results,
+limitations, training provenance and reproduction commands. A prepared candidate
+has not necessarily been selected by validation.

checkpoint/adapter/adapter_config.json

@@ -0,0 +1,295 @@
+{
+  "alora_invocation_tokens": null,
+  "alpha_pattern": {},
+  "arrow_config": null,
+  "auto_mapping": {
+    "base_model_class": "Qwen3_5ForConditionalGeneration",
+    "parent_library": "transformers.models.qwen3_5.modeling_qwen3_5"
+  },
+  "base_model_name_or_path": "Cloudflare/clef-flash",
+  "bias": "none",
+  "corda_config": null,
+  "ensure_weight_tying": false,
+  "eva_config": null,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": true,
+  "init_lora_weights": true,
+  "kasa_config": null,
+  "layer_replication": null,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "loftq_config": {},
+  "lora_alpha": 8,
+  "lora_bias": false,
+  "lora_dropout": 0.0,
+  "lora_ga_config": null,
+  "megatron_config": null,
+  "megatron_core": "megatron.core",
+  "modules_to_save": null,
+  "monteclora_config": null,
+  "peft_type": "LORA",
+  "peft_version": "0.21.2",
+  "qalora_group_size": 16,
+  "r": 4,
+  "rank_pattern": {},
+  "revision": "17f0b0ad64efb65d273590632833508766b2aae6",
+  "target_modules": [
+    "model.language_model.layers.0.linear_attn.in_proj_a",
+    "model.language_model.layers.0.linear_attn.in_proj_b",
+    "model.language_model.layers.0.linear_attn.in_proj_qkv",
+    "model.language_model.layers.0.linear_attn.in_proj_z",
+    "model.language_model.layers.0.linear_attn.out_proj",
+    "model.language_model.layers.0.mlp.down_proj",
+    "model.language_model.layers.0.mlp.gate_proj",
+    "model.language_model.layers.0.mlp.up_proj",
+    "model.language_model.layers.1.linear_attn.in_proj_a",
+    "model.language_model.layers.1.linear_attn.in_proj_b",
+    "model.language_model.layers.1.linear_attn.in_proj_qkv",
+    "model.language_model.layers.1.linear_attn.in_proj_z",
+    "model.language_model.layers.1.linear_attn.out_proj",
+    "model.language_model.layers.1.mlp.down_proj",
+    "model.language_model.layers.1.mlp.gate_proj",
+    "model.language_model.layers.1.mlp.up_proj",
+    "model.language_model.layers.10.linear_attn.in_proj_a",
+    "model.language_model.layers.10.linear_attn.in_proj_b",
+    "model.language_model.layers.10.linear_attn.in_proj_qkv",
+    "model.language_model.layers.10.linear_attn.in_proj_z",
+    "model.language_model.layers.10.linear_attn.out_proj",
+    "model.language_model.layers.10.mlp.down_proj",
+    "model.language_model.layers.10.mlp.gate_proj",
+    "model.language_model.layers.10.mlp.up_proj",
+    "model.language_model.layers.11.mlp.down_proj",
+    "model.language_model.layers.11.mlp.gate_proj",
+    "model.language_model.layers.11.mlp.up_proj",
+    "model.language_model.layers.11.self_attn.k_proj",
+    "model.language_model.layers.11.self_attn.o_proj",
+    "model.language_model.layers.11.self_attn.q_proj",
+    "model.language_model.layers.11.self_attn.v_proj",
+    "model.language_model.layers.12.linear_attn.in_proj_a",
+    "model.language_model.layers.12.linear_attn.in_proj_b",
+    "model.language_model.layers.12.linear_attn.in_proj_qkv",
+    "model.language_model.layers.12.linear_attn.in_proj_z",
+    "model.language_model.layers.12.linear_attn.out_proj",
+    "model.language_model.layers.12.mlp.down_proj",
+    "model.language_model.layers.12.mlp.gate_proj",
+    "model.language_model.layers.12.mlp.up_proj",
+    "model.language_model.layers.13.linear_attn.in_proj_a",
+    "model.language_model.layers.13.linear_attn.in_proj_b",
+    "model.language_model.layers.13.linear_attn.in_proj_qkv",
+    "model.language_model.layers.13.linear_attn.in_proj_z",
+    "model.language_model.layers.13.linear_attn.out_proj",
+    "model.language_model.layers.13.mlp.down_proj",
+    "model.language_model.layers.13.mlp.gate_proj",
+    "model.language_model.layers.13.mlp.up_proj",
+    "model.language_model.layers.14.linear_attn.in_proj_a",
+    "model.language_model.layers.14.linear_attn.in_proj_b",
+    "model.language_model.layers.14.linear_attn.in_proj_qkv",
+    "model.language_model.layers.14.linear_attn.in_proj_z",
+    "model.language_model.layers.14.linear_attn.out_proj",
+    "model.language_model.layers.14.mlp.down_proj",
+    "model.language_model.layers.14.mlp.gate_proj",
+    "model.language_model.layers.14.mlp.up_proj",
+    "model.language_model.layers.15.mlp.down_proj",
+    "model.language_model.layers.15.mlp.gate_proj",
+    "model.language_model.layers.15.mlp.up_proj",
+    "model.language_model.layers.15.self_attn.k_proj",
+    "model.language_model.layers.15.self_attn.o_proj",
+    "model.language_model.layers.15.self_attn.q_proj",
+    "model.language_model.layers.15.self_attn.v_proj",
+    "model.language_model.layers.16.linear_attn.in_proj_a",
+    "model.language_model.layers.16.linear_attn.in_proj_b",
+    "model.language_model.layers.16.linear_attn.in_proj_qkv",
+    "model.language_model.layers.16.linear_attn.in_proj_z",
+    "model.language_model.layers.16.linear_attn.out_proj",
+    "model.language_model.layers.16.mlp.down_proj",
+    "model.language_model.layers.16.mlp.gate_proj",
+    "model.language_model.layers.16.mlp.up_proj",
+    "model.language_model.layers.17.linear_attn.in_proj_a",
+    "model.language_model.layers.17.linear_attn.in_proj_b",
+    "model.language_model.layers.17.linear_attn.in_proj_qkv",
+    "model.language_model.layers.17.linear_attn.in_proj_z",
+    "model.language_model.layers.17.linear_attn.out_proj",
+    "model.language_model.layers.17.mlp.down_proj",
+    "model.language_model.layers.17.mlp.gate_proj",
+    "model.language_model.layers.17.mlp.up_proj",
+    "model.language_model.layers.18.linear_attn.in_proj_a",
+    "model.language_model.layers.18.linear_attn.in_proj_b",
+    "model.language_model.layers.18.linear_attn.in_proj_qkv",
+    "model.language_model.layers.18.linear_attn.in_proj_z",
+    "model.language_model.layers.18.linear_attn.out_proj",
+    "model.language_model.layers.18.mlp.down_proj",
+    "model.language_model.layers.18.mlp.gate_proj",
+    "model.language_model.layers.18.mlp.up_proj",
+    "model.language_model.layers.19.mlp.down_proj",
+    "model.language_model.layers.19.mlp.gate_proj",
+    "model.language_model.layers.19.mlp.up_proj",
+    "model.language_model.layers.19.self_attn.k_proj",
+    "model.language_model.layers.19.self_attn.o_proj",
+    "model.language_model.layers.19.self_attn.q_proj",
+    "model.language_model.layers.19.self_attn.v_proj",
+    "model.language_model.layers.2.linear_attn.in_proj_a",
+    "model.language_model.layers.2.linear_attn.in_proj_b",
+    "model.language_model.layers.2.linear_attn.in_proj_qkv",
+    "model.language_model.layers.2.linear_attn.in_proj_z",
+    "model.language_model.layers.2.linear_attn.out_proj",
+    "model.language_model.layers.2.mlp.down_proj",
+    "model.language_model.layers.2.mlp.gate_proj",
+    "model.language_model.layers.2.mlp.up_proj",
+    "model.language_model.layers.20.linear_attn.in_proj_a",
+    "model.language_model.layers.20.linear_attn.in_proj_b",
+    "model.language_model.layers.20.linear_attn.in_proj_qkv",
+    "model.language_model.layers.20.linear_attn.in_proj_z",
+    "model.language_model.layers.20.linear_attn.out_proj",
+    "model.language_model.layers.20.mlp.down_proj",
+    "model.language_model.layers.20.mlp.gate_proj",
+    "model.language_model.layers.20.mlp.up_proj",
+    "model.language_model.layers.21.linear_attn.in_proj_a",
+    "model.language_model.layers.21.linear_attn.in_proj_b",
+    "model.language_model.layers.21.linear_attn.in_proj_qkv",
+    "model.language_model.layers.21.linear_attn.in_proj_z",
+    "model.language_model.layers.21.linear_attn.out_proj",
+    "model.language_model.layers.21.mlp.down_proj",
+    "model.language_model.layers.21.mlp.gate_proj",
+    "model.language_model.layers.21.mlp.up_proj",
+    "model.language_model.layers.22.linear_attn.in_proj_a",
+    "model.language_model.layers.22.linear_attn.in_proj_b",
+    "model.language_model.layers.22.linear_attn.in_proj_qkv",
+    "model.language_model.layers.22.linear_attn.in_proj_z",
+    "model.language_model.layers.22.linear_attn.out_proj",
+    "model.language_model.layers.22.mlp.down_proj",
+    "model.language_model.layers.22.mlp.gate_proj",
+    "model.language_model.layers.22.mlp.up_proj",
+    "model.language_model.layers.23.mlp.down_proj",
+    "model.language_model.layers.23.mlp.gate_proj",
+    "model.language_model.layers.23.mlp.up_proj",
+    "model.language_model.layers.23.self_attn.k_proj",
+    "model.language_model.layers.23.self_attn.o_proj",
+    "model.language_model.layers.23.self_attn.q_proj",
+    "model.language_model.layers.23.self_attn.v_proj",
+    "model.language_model.layers.24.linear_attn.in_proj_a",
+    "model.language_model.layers.24.linear_attn.in_proj_b",
+    "model.language_model.layers.24.linear_attn.in_proj_qkv",
+    "model.language_model.layers.24.linear_attn.in_proj_z",
+    "model.language_model.layers.24.linear_attn.out_proj",
+    "model.language_model.layers.24.mlp.down_proj",
+    "model.language_model.layers.24.mlp.gate_proj",
+    "model.language_model.layers.24.mlp.up_proj",
+    "model.language_model.layers.25.linear_attn.in_proj_a",
+    "model.language_model.layers.25.linear_attn.in_proj_b",
+    "model.language_model.layers.25.linear_attn.in_proj_qkv",
+    "model.language_model.layers.25.linear_attn.in_proj_z",
+    "model.language_model.layers.25.linear_attn.out_proj",
+    "model.language_model.layers.25.mlp.down_proj",
+    "model.language_model.layers.25.mlp.gate_proj",
+    "model.language_model.layers.25.mlp.up_proj",
+    "model.language_model.layers.26.linear_attn.in_proj_a",
+    "model.language_model.layers.26.linear_attn.in_proj_b",
+    "model.language_model.layers.26.linear_attn.in_proj_qkv",
+    "model.language_model.layers.26.linear_attn.in_proj_z",
+    "model.language_model.layers.26.linear_attn.out_proj",
+    "model.language_model.layers.26.mlp.down_proj",
+    "model.language_model.layers.26.mlp.gate_proj",
+    "model.language_model.layers.26.mlp.up_proj",
+    "model.language_model.layers.27.mlp.down_proj",
+    "model.language_model.layers.27.mlp.gate_proj",
+    "model.language_model.layers.27.mlp.up_proj",
+    "model.language_model.layers.27.self_attn.k_proj",
+    "model.language_model.layers.27.self_attn.o_proj",
+    "model.language_model.layers.27.self_attn.q_proj",
+    "model.language_model.layers.27.self_attn.v_proj",
+    "model.language_model.layers.28.linear_attn.in_proj_a",
+    "model.language_model.layers.28.linear_attn.in_proj_b",
+    "model.language_model.layers.28.linear_attn.in_proj_qkv",
+    "model.language_model.layers.28.linear_attn.in_proj_z",
+    "model.language_model.layers.28.linear_attn.out_proj",
+    "model.language_model.layers.28.mlp.down_proj",
+    "model.language_model.layers.28.mlp.gate_proj",
+    "model.language_model.layers.28.mlp.up_proj",
+    "model.language_model.layers.29.linear_attn.in_proj_a",
+    "model.language_model.layers.29.linear_attn.in_proj_b",
+    "model.language_model.layers.29.linear_attn.in_proj_qkv",
+    "model.language_model.layers.29.linear_attn.in_proj_z",
+    "model.language_model.layers.29.linear_attn.out_proj",
+    "model.language_model.layers.29.mlp.down_proj",
+    "model.language_model.layers.29.mlp.gate_proj",
+    "model.language_model.layers.29.mlp.up_proj",
+    "model.language_model.layers.3.mlp.down_proj",
+    "model.language_model.layers.3.mlp.gate_proj",
+    "model.language_model.layers.3.mlp.up_proj",
+    "model.language_model.layers.3.self_attn.k_proj",
+    "model.language_model.layers.3.self_attn.o_proj",
+    "model.language_model.layers.3.self_attn.q_proj",
+    "model.language_model.layers.3.self_attn.v_proj",
+    "model.language_model.layers.30.linear_attn.in_proj_a",
+    "model.language_model.layers.30.linear_attn.in_proj_b",
+    "model.language_model.layers.30.linear_attn.in_proj_qkv",
+    "model.language_model.layers.30.linear_attn.in_proj_z",
+    "model.language_model.layers.30.linear_attn.out_proj",
+    "model.language_model.layers.30.mlp.down_proj",
+    "model.language_model.layers.30.mlp.gate_proj",
+    "model.language_model.layers.30.mlp.up_proj",
+    "model.language_model.layers.31.mlp.down_proj",
+    "model.language_model.layers.31.mlp.gate_proj",
+    "model.language_model.layers.31.mlp.up_proj",
+    "model.language_model.layers.31.self_attn.k_proj",
+    "model.language_model.layers.31.self_attn.o_proj",
+    "model.language_model.layers.31.self_attn.q_proj",
+    "model.language_model.layers.31.self_attn.v_proj",
+    "model.language_model.layers.4.linear_attn.in_proj_a",
+    "model.language_model.layers.4.linear_attn.in_proj_b",
+    "model.language_model.layers.4.linear_attn.in_proj_qkv",
+    "model.language_model.layers.4.linear_attn.in_proj_z",
+    "model.language_model.layers.4.linear_attn.out_proj",
+    "model.language_model.layers.4.mlp.down_proj",
+    "model.language_model.layers.4.mlp.gate_proj",
+    "model.language_model.layers.4.mlp.up_proj",
+    "model.language_model.layers.5.linear_attn.in_proj_a",
+    "model.language_model.layers.5.linear_attn.in_proj_b",
+    "model.language_model.layers.5.linear_attn.in_proj_qkv",
+    "model.language_model.layers.5.linear_attn.in_proj_z",
+    "model.language_model.layers.5.linear_attn.out_proj",
+    "model.language_model.layers.5.mlp.down_proj",
+    "model.language_model.layers.5.mlp.gate_proj",
+    "model.language_model.layers.5.mlp.up_proj",
+    "model.language_model.layers.6.linear_attn.in_proj_a",
+    "model.language_model.layers.6.linear_attn.in_proj_b",
+    "model.language_model.layers.6.linear_attn.in_proj_qkv",
+    "model.language_model.layers.6.linear_attn.in_proj_z",
+    "model.language_model.layers.6.linear_attn.out_proj",
+    "model.language_model.layers.6.mlp.down_proj",
+    "model.language_model.layers.6.mlp.gate_proj",
+    "model.language_model.layers.6.mlp.up_proj",
+    "model.language_model.layers.7.mlp.down_proj",
+    "model.language_model.layers.7.mlp.gate_proj",
+    "model.language_model.layers.7.mlp.up_proj",
+    "model.language_model.layers.7.self_attn.k_proj",
+    "model.language_model.layers.7.self_attn.o_proj",
+    "model.language_model.layers.7.self_attn.q_proj",
+    "model.language_model.layers.7.self_attn.v_proj",
+    "model.language_model.layers.8.linear_attn.in_proj_a",
+    "model.language_model.layers.8.linear_attn.in_proj_b",
+    "model.language_model.layers.8.linear_attn.in_proj_qkv",
+    "model.language_model.layers.8.linear_attn.in_proj_z",
+    "model.language_model.layers.8.linear_attn.out_proj",
+    "model.language_model.layers.8.mlp.down_proj",
+    "model.language_model.layers.8.mlp.gate_proj",
+    "model.language_model.layers.8.mlp.up_proj",
+    "model.language_model.layers.9.linear_attn.in_proj_a",
+    "model.language_model.layers.9.linear_attn.in_proj_b",
+    "model.language_model.layers.9.linear_attn.in_proj_qkv",
+    "model.language_model.layers.9.linear_attn.in_proj_z",
+    "model.language_model.layers.9.linear_attn.out_proj",
+    "model.language_model.layers.9.mlp.down_proj",
+    "model.language_model.layers.9.mlp.gate_proj",
+    "model.language_model.layers.9.mlp.up_proj"
+  ],
+  "target_parameters": null,
+  "task_type": null,
+  "trainable_token_indices": null,
+  "use_bdlora": null,
+  "use_dora": false,
+  "use_qalora": false,
+  "use_rslora": false,
+  "velora_config": null
+}

checkpoint/adapter/adapter_model.safetensors

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

checkpoint/joint_head.safetensors

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

checkpoint/reference.json

@@ -0,0 +1,124 @@
+{
+  "absolute_tolerance": 0.0001,
+  "dataset_manifest_sha256": "aeddcfc1ea5390f12122d2e786c1e2030dcc97d3790b6d7523432548198b1f94",
+  "dataset_train_sha256": "edd682761db95a4f25bb30a284489c54d9336a36da0a9b19d2cda860b428baa8",
+  "max_length": 4096,
+  "probabilities": [
+    {
+      "r0x0": 0.2526208162307739,
+      "r0x1": 0.12492077797651291,
+      "r0x2": 0.08399814367294312,
+      "r0x3": 0.05339020863175392,
+      "r0x4": 0.04619518667459488,
+      "r0x5": 0.044043805450201035,
+      "r0x6": 0.0331004299223423,
+      "r0x7": 0.07307567447423935,
+      "r1x0": 0.06716147065162659,
+      "r1x1": 0.008080358617007732,
+      "r1x2": 0.004807046614587307,
+      "r1x3": 0.004841183312237263,
+      "r1x4": 0.005607179831713438,
+      "r1x5": 0.004920979030430317,
+      "r1x6": 0.004632336087524891,
+      "r1x7": 0.004383244551718235,
+      "r1x8": 0.01221535075455904,
+      "r2x0": 0.02925245091319084,
+      "r2x1": 0.009518387727439404,
+      "r2x2": 0.006364461965858936,
+      "r2x3": 0.007643744349479675,
+      "r2x4": 0.0082625737413764,
+      "r2x5": 0.00851234421133995,
+      "r2x6": 0.007145871873944998,
+      "r2x7": 0.012282103300094604,
+      "r3x0": 0.03042912669479847,
+      "r3x1": 0.006548034492880106,
+      "r3x2": 0.004051720257848501,
+      "r3x3": 0.003932017832994461,
+      "r3x4": 0.004734409507364035,
+      "r3x5": 0.0048585254698991776,
+      "r3x6": 0.0044471994042396545,
+      "r3x7": 0.00464443676173687,
+      "r3x8": 0.019378365948796272
+    },
+    {
+      "r0x0": 0.05243745446205139,
+      "r0x1": 0.0021382851991802454,
+      "r0x2": 0.0015760728856548667,
+      "r0x3": 0.002449487801641226,
+      "r0x4": 0.032596979290246964,
+      "r0x5": 0.37996670603752136,
+      "r0x6": 0.13670691847801208,
+      "r0x7": 0.12666313350200653,
+      "r1x0": 0.0826447382569313,
+      "r1x1": 0.00209549767896533,
+      "r1x2": 0.0008976972894743085,
+      "r1x3": 0.0008652249234728515,
+      "r1x4": 0.0014294564025476575,
+      "r1x5": 0.028665941208600998,
+      "r1x6": 0.008725162595510483,
+      "r1x7": 0.005233264062553644,
+      "r1x8": 0.009060735814273357,
+      "r2x0": 0.03716142103075981,
+      "r2x1": 0.002115321345627308,
+      "r2x2": 0.005341287236660719,
+      "r2x3": 0.001745575456880033,
+      "r2x4": 0.0019583813846111298,
+      "r2x5": 0.019835354760289192,
+      "r2x6": 0.007319271564483643,
+      "r2x7": 0.009388658218085766,
+      "r3x0": 0.005738606210798025,
+      "r3x1": 0.0012146560475230217,
+      "r3x2": 0.0012203187216073275,
+      "r3x3": 0.0019278834806755185,
+      "r3x4": 0.012783590704202652,
+      "r3x5": 0.0051281689666211605,
+      "r3x6": 0.0024644453078508377,
+      "r3x7": 0.0036620264872908592,
+      "r3x8": 0.0068422844633460045
+    },
+    {
+      "r0x0": 0.44664159417152405,
+      "r0x1": 0.00948373880237341,
+      "r0x2": 0.003061962779611349,
+      "r0x3": 0.0024329586885869503,
+      "r0x4": 0.0033077853731811047,
+      "r0x5": 0.0038714406546205282,
+      "r0x6": 0.004481742158532143,
+      "r0x7": 0.4447571933269501,
+      "r1x0": 0.02148980088531971,
+      "r1x1": 0.003787056542932987,
+      "r1x2": 0.0029788941610604525,
+      "r1x3": 0.002205177675932646,
+      "r1x4": 0.002177440095692873,
+      "r1x5": 0.002208774909377098,
+      "r1x6": 0.0032660418655723333,
+      "r1x7": 0.02149323932826519,
+      "r1x8": 0.02235523797571659
+    },
+    {
+      "r0x0": 0.07569620758295059,
+      "r0x1": 0.004194475244730711,
+      "r0x2": 0.002426150254905224,
+      "r0x3": 0.002500610426068306,
+      "r0x4": 0.002711081877350807,
+      "r0x5": 0.0028261507395654917,
+      "r0x6": 0.0035828864201903343,
+      "r0x7": 0.006198260933160782,
+      "r1x0": 0.5267710089683533,
+      "r1x1": 0.2791306972503662,
+      "r1x2": 0.05139099806547165,
+      "r1x3": 0.012985441833734512,
+      "r1x4": 0.005060354247689247,
+      "r1x5": 0.0031180710066109896,
+      "r1x6": 0.002313777571544051,
+      "r1x7": 0.014574174769222736,
+      "r1x8": 0.004519620444625616
+    }
+  ],
+  "row_ids": [
+    "seed-10000-turn-0",
+    "seed-10000-turn-1",
+    "seed-10000-turn-2",
+    "seed-10000-turn-3"
+  ]
+}

checkpoint/training_config.json

@@ -0,0 +1,719 @@
+{
+  "base_model": "Cloudflare/clef-flash",
+  "base_revision": "17f0b0ad64efb65d273590632833508766b2aae6",
+  "encoding_version": "stackcraft-clef-v1",
+  "extra": {
+    "config": {
+      "batch_size": 1,
+      "brier_weight": 0.1,
+      "clip_gradient_norm": 1.0,
+      "epochs": 2,
+      "gradient_accumulation": 8,
+      "label_smoothing": 0.05,
+      "learning_rate": 1e-05,
+      "max_length": 4096,
+      "mode": "lora",
+      "optimizer": "AdamW",
+      "rank": 4,
+      "seed": 42,
+      "selection": "external validation only; this script does not choose a checkpoint",
+      "weight_decay": 0.01
+    },
+    "dataset_config_sha256": "65b72544c80cf19f4ac3b12ca109d0ebda18fb70eadb4b170a55b1e8bb3b4f6d",
+    "dataset_counts": {
+      "train": 827,
+      "validation": 215
+    },
+    "dataset_manifest_sha256": "aeddcfc1ea5390f12122d2e786c1e2030dcc97d3790b6d7523432548198b1f94",
+    "dataset_source_commit": "70d84bd8dc5d4a60f3b96455a57d9e6f9416d109",
+    "dataset_split_sha256": {
+      "train": "edd682761db95a4f25bb30a284489c54d9336a36da0a9b19d2cda860b428baa8",
+      "validation": "eff9cdc5932e935959ac4d26dce6470d335090f7428a91930001954266d133bc"
+    },
+    "epoch": 2,
+    "examples": 827,
+    "mean_training_loss": 1.9667175294878694,
+    "optimizer_steps": 104,
+    "peak_allocated_bytes": 23226543104,
+    "peak_reserved_bytes": 24178065408,
+    "seconds": 744.6554337799898,
+    "shuffle_order_sha256": "b9d20efe77959592c99e9247a58d844be69df50db595bd87c6d7e595f5d2e0c4",
+    "source_commit": "d9fcd05c02e9327d4d791f2338725092cede8bdd",
+    "source_dirty": true,
+    "source_hashes": {
+      "scripts/train_clef.py": "e83586cf0fd0d7bb8c4aa15f9b858b9f9ffdb915622e355deb9513788d5054aa",
+      "src/stackcraft/clef.py": "c505f35d27121ba9ec9db3c663927ac8b28304f4ed864765be61ce96c8c86e13",
+      "src/stackcraft/data.py": "74b68a1f391a3128d2e499c7e86b6c94a1f2a2bef33ffe75c8631207065bd991",
+      "src/stackcraft/training.py": "f7e48b041b331cf2b68674ec2abb1059dd1da47cb261697b46260b4f0169dba8"
+    },
+    "test_trajectories_used": false,
+    "validation_used_for_training": false
+  },
+  "format_version": 1,
+  "head_shapes": {
+    "evidence_layers.0.attention.in_proj_bias": [
+      3072
+    ],
+    "evidence_layers.0.attention.in_proj_weight": [
+      3072,
+      1024
+    ],
+    "evidence_layers.0.attention.out_proj.bias": [
+      1024
+    ],
+    "evidence_layers.0.attention.out_proj.weight": [
+      1024,
+      1024
+    ],
+    "evidence_layers.0.feedforward.0.bias": [
+      4096
+    ],
+    "evidence_layers.0.feedforward.0.weight": [
+      4096,
+      1024
+    ],
+    "evidence_layers.0.feedforward.3.bias": [
+      1024
+    ],
+    "evidence_layers.0.feedforward.3.weight": [
+      1024,
+      4096
+    ],
+    "evidence_layers.0.feedforward_norm.bias": [
+      1024
+    ],
+    "evidence_layers.0.feedforward_norm.weight": [
+      1024
+    ],
+    "evidence_layers.0.memory_norm.bias": [
+      1024
+    ],
+    "evidence_layers.0.memory_norm.weight": [
+      1024
+    ],
+    "evidence_layers.0.query_norm.bias": [
+      1024
+    ],
+    "evidence_layers.0.query_norm.weight": [
+      1024
+    ],
+    "evidence_layers.1.attention.in_proj_bias": [
+      3072
+    ],
+    "evidence_layers.1.attention.in_proj_weight": [
+      3072,
+      1024
+    ],
+    "evidence_layers.1.attention.out_proj.bias": [
+      1024
+    ],
+    "evidence_layers.1.attention.out_proj.weight": [
+      1024,
+      1024
+    ],
+    "evidence_layers.1.feedforward.0.bias": [
+      4096
+    ],
+    "evidence_layers.1.feedforward.0.weight": [
+      4096,
+      1024
+    ],
+    "evidence_layers.1.feedforward.3.bias": [
+      1024
+    ],
+    "evidence_layers.1.feedforward.3.weight": [
+      1024,
+      4096
+    ],
+    "evidence_layers.1.feedforward_norm.bias": [
+      1024
+    ],
+    "evidence_layers.1.feedforward_norm.weight": [
+      1024
+    ],
+    "evidence_layers.1.memory_norm.bias": [
+      1024
+    ],
+    "evidence_layers.1.memory_norm.weight": [
+      1024
+    ],
+    "evidence_layers.1.query_norm.bias": [
+      1024
+    ],
+    "evidence_layers.1.query_norm.weight": [
+      1024
+    ],
+    "field_norm.bias": [
+      1024
+    ],
+    "field_norm.weight": [
+      1024
+    ],
+    "global_projection.weight": [
+      1024,
+      4096
+    ],
+    "hidden_norm.bias": [
+      4096
+    ],
+    "hidden_norm.weight": [
+      4096
+    ],
+    "joint_logit_scale": [],
+    "layers.0.linear1.bias": [
+      4096
+    ],
+    "layers.0.linear1.weight": [
+      4096,
+      1024
+    ],
+    "layers.0.linear2.bias": [
+      1024
+    ],
+    "layers.0.linear2.weight": [
+      1024,
+      4096
+    ],
+    "layers.0.multihead_attn.in_proj_bias": [
+      3072
+    ],
+    "layers.0.multihead_attn.in_proj_weight": [
+      3072,
+      1024
+    ],
+    "layers.0.multihead_attn.out_proj.bias": [
+      1024
+    ],
+    "layers.0.multihead_attn.out_proj.weight": [
+      1024,
+      1024
+    ],
+    "layers.0.norm1.bias": [
+      1024
+    ],
+    "layers.0.norm1.weight": [
+      1024
+    ],
+    "layers.0.norm2.bias": [
+      1024
+    ],
+    "layers.0.norm2.weight": [
+      1024
+    ],
+    "layers.0.norm3.bias": [
+      1024
+    ],
+    "layers.0.norm3.weight": [
+      1024
+    ],
+    "layers.0.self_attn.in_proj_bias": [
+      3072
+    ],
+    "layers.0.self_attn.in_proj_weight": [
+      3072,
+      1024
+    ],
+    "layers.0.self_attn.out_proj.bias": [
+      1024
+    ],
+    "layers.0.self_attn.out_proj.weight": [
+      1024,
+      1024
+    ],
+    "layers.1.linear1.bias": [
+      4096
+    ],
+    "layers.1.linear1.weight": [
+      4096,
+      1024
+    ],
+    "layers.1.linear2.bias": [
+      1024
+    ],
+    "layers.1.linear2.weight": [
+      1024,
+      4096
+    ],
+    "layers.1.multihead_attn.in_proj_bias": [
+      3072
+    ],
+    "layers.1.multihead_attn.in_proj_weight": [
+      3072,
+      1024
+    ],
+    "layers.1.multihead_attn.out_proj.bias": [
+      1024
+    ],
+    "layers.1.multihead_attn.out_proj.weight": [
+      1024,
+      1024
+    ],
+    "layers.1.norm1.bias": [
+      1024
+    ],
+    "layers.1.norm1.weight": [
+      1024
+    ],
+    "layers.1.norm2.bias": [
+      1024
+    ],
+    "layers.1.norm2.weight": [
+      1024
+    ],
+    "layers.1.norm3.bias": [
+      1024
+    ],
+    "layers.1.norm3.weight": [
+      1024
+    ],
+    "layers.1.self_attn.in_proj_bias": [
+      3072
+    ],
+    "layers.1.self_attn.in_proj_weight": [
+      3072,
+      1024
+    ],
+    "layers.1.self_attn.out_proj.bias": [
+      1024
+    ],
+    "layers.1.self_attn.out_proj.weight": [
+      1024,
+      1024
+    ],
+    "layers.2.linear1.bias": [
+      4096
+    ],
+    "layers.2.linear1.weight": [
+      4096,
+      1024
+    ],
+    "layers.2.linear2.bias": [
+      1024
+    ],
+    "layers.2.linear2.weight": [
+      1024,
+      4096
+    ],
+    "layers.2.multihead_attn.in_proj_bias": [
+      3072
+    ],
+    "layers.2.multihead_attn.in_proj_weight": [
+      3072,
+      1024
+    ],
+    "layers.2.multihead_attn.out_proj.bias": [
+      1024
+    ],
+    "layers.2.multihead_attn.out_proj.weight": [
+      1024,
+      1024
+    ],
+    "layers.2.norm1.bias": [
+      1024
+    ],
+    "layers.2.norm1.weight": [
+      1024
+    ],
+    "layers.2.norm2.bias": [
+      1024
+    ],
+    "layers.2.norm2.weight": [
+      1024
+    ],
+    "layers.2.norm3.bias": [
+      1024
+    ],
+    "layers.2.norm3.weight": [
+      1024
+    ],
+    "layers.2.self_attn.in_proj_bias": [
+      3072
+    ],
+    "layers.2.self_attn.in_proj_weight": [
+      3072,
+      1024
+    ],
+    "layers.2.self_attn.out_proj.bias": [
+      1024
+    ],
+    "layers.2.self_attn.out_proj.weight": [
+      1024,
+      1024
+    ],
+    "layers.3.linear1.bias": [
+      4096
+    ],
+    "layers.3.linear1.weight": [
+      4096,
+      1024
+    ],
+    "layers.3.linear2.bias": [
+      1024
+    ],
+    "layers.3.linear2.weight": [
+      1024,
+      4096
+    ],
+    "layers.3.multihead_attn.in_proj_bias": [
+      3072
+    ],
+    "layers.3.multihead_attn.in_proj_weight": [
+      3072,
+      1024
+    ],
+    "layers.3.multihead_attn.out_proj.bias": [
+      1024
+    ],
+    "layers.3.multihead_attn.out_proj.weight": [
+      1024,
+      1024
+    ],
+    "layers.3.norm1.bias": [
+      1024
+    ],
+    "layers.3.norm1.weight": [
+      1024
+    ],
+    "layers.3.norm2.bias": [
+      1024
+    ],
+    "layers.3.norm2.weight": [
+      1024
+    ],
+    "layers.3.norm3.bias": [
+      1024
+    ],
+    "layers.3.norm3.weight": [
+      1024
+    ],
+    "layers.3.self_attn.in_proj_bias": [
+      3072
+    ],
+    "layers.3.self_attn.in_proj_weight": [
+      3072,
+      1024
+    ],
+    "layers.3.self_attn.out_proj.bias": [
+      1024
+    ],
+    "layers.3.self_attn.out_proj.weight": [
+      1024,
+      1024
+    ],
+    "memory_projection.weight": [
+      1024,
+      4096
+    ],
+    "option_context_projection.weight": [
+      1024,
+      4096
+    ],
+    "option_lexical_projection.weight": [
+      1024,
+      4096
+    ],
+    "option_norm.bias": [
+      1024
+    ],
+    "option_norm.weight": [
+      1024
+    ],
+    "option_question_projection.weight": [
+      1024,
+      4096
+    ],
+    "option_summary_norm.bias": [
+      1024
+    ],
+    "option_summary_norm.weight": [
+      1024
+    ],
+    "prior_logit_scale": [],
+    "question_projection.weight": [
+      1024,
+      4096
+    ],
+    "residual_gate": [],
+    "residual_scorer.0.bias": [
+      1024
+    ],
+    "residual_scorer.0.weight": [
+      1024,
+      4096
+    ],
+    "residual_scorer.3.bias": [
+      1
+    ],
+    "residual_scorer.3.weight": [
+      1,
+      1024
+    ],
+    "type_embedding.weight": [
+      3,
+      1024
+    ]
+  },
+  "head_type": "native-joint-schema-fp32-gathered-rows-v1",
+  "lora": {
+    "alpha": 8,
+    "dropout": 0.0,
+    "rank": 4,
+    "target_modules": [
+      "model.language_model.layers.0.linear_attn.in_proj_a",
+      "model.language_model.layers.0.linear_attn.in_proj_b",
+      "model.language_model.layers.0.linear_attn.in_proj_qkv",
+      "model.language_model.layers.0.linear_attn.in_proj_z",
+      "model.language_model.layers.0.linear_attn.out_proj",
+      "model.language_model.layers.0.mlp.down_proj",
+      "model.language_model.layers.0.mlp.gate_proj",
+      "model.language_model.layers.0.mlp.up_proj",
+      "model.language_model.layers.1.linear_attn.in_proj_a",
+      "model.language_model.layers.1.linear_attn.in_proj_b",
+      "model.language_model.layers.1.linear_attn.in_proj_qkv",
+      "model.language_model.layers.1.linear_attn.in_proj_z",
+      "model.language_model.layers.1.linear_attn.out_proj",
+      "model.language_model.layers.1.mlp.down_proj",
+      "model.language_model.layers.1.mlp.gate_proj",
+      "model.language_model.layers.1.mlp.up_proj",
+      "model.language_model.layers.10.linear_attn.in_proj_a",
+      "model.language_model.layers.10.linear_attn.in_proj_b",
+      "model.language_model.layers.10.linear_attn.in_proj_qkv",
+      "model.language_model.layers.10.linear_attn.in_proj_z",
+      "model.language_model.layers.10.linear_attn.out_proj",
+      "model.language_model.layers.10.mlp.down_proj",
+      "model.language_model.layers.10.mlp.gate_proj",
+      "model.language_model.layers.10.mlp.up_proj",
+      "model.language_model.layers.11.mlp.down_proj",
+      "model.language_model.layers.11.mlp.gate_proj",
+      "model.language_model.layers.11.mlp.up_proj",
+      "model.language_model.layers.11.self_attn.k_proj",
+      "model.language_model.layers.11.self_attn.o_proj",
+      "model.language_model.layers.11.self_attn.q_proj",
+      "model.language_model.layers.11.self_attn.v_proj",
+      "model.language_model.layers.12.linear_attn.in_proj_a",
+      "model.language_model.layers.12.linear_attn.in_proj_b",
+      "model.language_model.layers.12.linear_attn.in_proj_qkv",
+      "model.language_model.layers.12.linear_attn.in_proj_z",
+      "model.language_model.layers.12.linear_attn.out_proj",
+      "model.language_model.layers.12.mlp.down_proj",
+      "model.language_model.layers.12.mlp.gate_proj",
+      "model.language_model.layers.12.mlp.up_proj",
+      "model.language_model.layers.13.linear_attn.in_proj_a",
+      "model.language_model.layers.13.linear_attn.in_proj_b",
+      "model.language_model.layers.13.linear_attn.in_proj_qkv",
+      "model.language_model.layers.13.linear_attn.in_proj_z",
+      "model.language_model.layers.13.linear_attn.out_proj",
+      "model.language_model.layers.13.mlp.down_proj",
+      "model.language_model.layers.13.mlp.gate_proj",
+      "model.language_model.layers.13.mlp.up_proj",
+      "model.language_model.layers.14.linear_attn.in_proj_a",
+      "model.language_model.layers.14.linear_attn.in_proj_b",
+      "model.language_model.layers.14.linear_attn.in_proj_qkv",
+      "model.language_model.layers.14.linear_attn.in_proj_z",
+      "model.language_model.layers.14.linear_attn.out_proj",
+      "model.language_model.layers.14.mlp.down_proj",
+      "model.language_model.layers.14.mlp.gate_proj",
+      "model.language_model.layers.14.mlp.up_proj",
+      "model.language_model.layers.15.mlp.down_proj",
+      "model.language_model.layers.15.mlp.gate_proj",
+      "model.language_model.layers.15.mlp.up_proj",
+      "model.language_model.layers.15.self_attn.k_proj",
+      "model.language_model.layers.15.self_attn.o_proj",
+      "model.language_model.layers.15.self_attn.q_proj",
+      "model.language_model.layers.15.self_attn.v_proj",
+      "model.language_model.layers.16.linear_attn.in_proj_a",
+      "model.language_model.layers.16.linear_attn.in_proj_b",
+      "model.language_model.layers.16.linear_attn.in_proj_qkv",
+      "model.language_model.layers.16.linear_attn.in_proj_z",
+      "model.language_model.layers.16.linear_attn.out_proj",
+      "model.language_model.layers.16.mlp.down_proj",
+      "model.language_model.layers.16.mlp.gate_proj",
+      "model.language_model.layers.16.mlp.up_proj",
+      "model.language_model.layers.17.linear_attn.in_proj_a",
+      "model.language_model.layers.17.linear_attn.in_proj_b",
+      "model.language_model.layers.17.linear_attn.in_proj_qkv",
+      "model.language_model.layers.17.linear_attn.in_proj_z",
+      "model.language_model.layers.17.linear_attn.out_proj",
+      "model.language_model.layers.17.mlp.down_proj",
+      "model.language_model.layers.17.mlp.gate_proj",
+      "model.language_model.layers.17.mlp.up_proj",
+      "model.language_model.layers.18.linear_attn.in_proj_a",
+      "model.language_model.layers.18.linear_attn.in_proj_b",
+      "model.language_model.layers.18.linear_attn.in_proj_qkv",
+      "model.language_model.layers.18.linear_attn.in_proj_z",
+      "model.language_model.layers.18.linear_attn.out_proj",
+      "model.language_model.layers.18.mlp.down_proj",
+      "model.language_model.layers.18.mlp.gate_proj",
+      "model.language_model.layers.18.mlp.up_proj",
+      "model.language_model.layers.19.mlp.down_proj",
+      "model.language_model.layers.19.mlp.gate_proj",
+      "model.language_model.layers.19.mlp.up_proj",
+      "model.language_model.layers.19.self_attn.k_proj",
+      "model.language_model.layers.19.self_attn.o_proj",
+      "model.language_model.layers.19.self_attn.q_proj",
+      "model.language_model.layers.19.self_attn.v_proj",
+      "model.language_model.layers.2.linear_attn.in_proj_a",
+      "model.language_model.layers.2.linear_attn.in_proj_b",
+      "model.language_model.layers.2.linear_attn.in_proj_qkv",
+      "model.language_model.layers.2.linear_attn.in_proj_z",
+      "model.language_model.layers.2.linear_attn.out_proj",
+      "model.language_model.layers.2.mlp.down_proj",
+      "model.language_model.layers.2.mlp.gate_proj",
+      "model.language_model.layers.2.mlp.up_proj",
+      "model.language_model.layers.20.linear_attn.in_proj_a",
+      "model.language_model.layers.20.linear_attn.in_proj_b",
+      "model.language_model.layers.20.linear_attn.in_proj_qkv",
+      "model.language_model.layers.20.linear_attn.in_proj_z",
+      "model.language_model.layers.20.linear_attn.out_proj",
+      "model.language_model.layers.20.mlp.down_proj",
+      "model.language_model.layers.20.mlp.gate_proj",
+      "model.language_model.layers.20.mlp.up_proj",
+      "model.language_model.layers.21.linear_attn.in_proj_a",
+      "model.language_model.layers.21.linear_attn.in_proj_b",
+      "model.language_model.layers.21.linear_attn.in_proj_qkv",
+      "model.language_model.layers.21.linear_attn.in_proj_z",
+      "model.language_model.layers.21.linear_attn.out_proj",
+      "model.language_model.layers.21.mlp.down_proj",
+      "model.language_model.layers.21.mlp.gate_proj",
+      "model.language_model.layers.21.mlp.up_proj",
+      "model.language_model.layers.22.linear_attn.in_proj_a",
+      "model.language_model.layers.22.linear_attn.in_proj_b",
+      "model.language_model.layers.22.linear_attn.in_proj_qkv",
+      "model.language_model.layers.22.linear_attn.in_proj_z",
+      "model.language_model.layers.22.linear_attn.out_proj",
+      "model.language_model.layers.22.mlp.down_proj",
+      "model.language_model.layers.22.mlp.gate_proj",
+      "model.language_model.layers.22.mlp.up_proj",
+      "model.language_model.layers.23.mlp.down_proj",
+      "model.language_model.layers.23.mlp.gate_proj",
+      "model.language_model.layers.23.mlp.up_proj",
+      "model.language_model.layers.23.self_attn.k_proj",
+      "model.language_model.layers.23.self_attn.o_proj",
+      "model.language_model.layers.23.self_attn.q_proj",
+      "model.language_model.layers.23.self_attn.v_proj",
+      "model.language_model.layers.24.linear_attn.in_proj_a",
+      "model.language_model.layers.24.linear_attn.in_proj_b",
+      "model.language_model.layers.24.linear_attn.in_proj_qkv",
+      "model.language_model.layers.24.linear_attn.in_proj_z",
+      "model.language_model.layers.24.linear_attn.out_proj",
+      "model.language_model.layers.24.mlp.down_proj",
+      "model.language_model.layers.24.mlp.gate_proj",
+      "model.language_model.layers.24.mlp.up_proj",
+      "model.language_model.layers.25.linear_attn.in_proj_a",
+      "model.language_model.layers.25.linear_attn.in_proj_b",
+      "model.language_model.layers.25.linear_attn.in_proj_qkv",
+      "model.language_model.layers.25.linear_attn.in_proj_z",
+      "model.language_model.layers.25.linear_attn.out_proj",
+      "model.language_model.layers.25.mlp.down_proj",
+      "model.language_model.layers.25.mlp.gate_proj",
+      "model.language_model.layers.25.mlp.up_proj",
+      "model.language_model.layers.26.linear_attn.in_proj_a",
+      "model.language_model.layers.26.linear_attn.in_proj_b",
+      "model.language_model.layers.26.linear_attn.in_proj_qkv",
+      "model.language_model.layers.26.linear_attn.in_proj_z",
+      "model.language_model.layers.26.linear_attn.out_proj",
+      "model.language_model.layers.26.mlp.down_proj",
+      "model.language_model.layers.26.mlp.gate_proj",
+      "model.language_model.layers.26.mlp.up_proj",
+      "model.language_model.layers.27.mlp.down_proj",
+      "model.language_model.layers.27.mlp.gate_proj",
+      "model.language_model.layers.27.mlp.up_proj",
+      "model.language_model.layers.27.self_attn.k_proj",
+      "model.language_model.layers.27.self_attn.o_proj",
+      "model.language_model.layers.27.self_attn.q_proj",
+      "model.language_model.layers.27.self_attn.v_proj",
+      "model.language_model.layers.28.linear_attn.in_proj_a",
+      "model.language_model.layers.28.linear_attn.in_proj_b",
+      "model.language_model.layers.28.linear_attn.in_proj_qkv",
+      "model.language_model.layers.28.linear_attn.in_proj_z",
+      "model.language_model.layers.28.linear_attn.out_proj",
+      "model.language_model.layers.28.mlp.down_proj",
+      "model.language_model.layers.28.mlp.gate_proj",
+      "model.language_model.layers.28.mlp.up_proj",
+      "model.language_model.layers.29.linear_attn.in_proj_a",
+      "model.language_model.layers.29.linear_attn.in_proj_b",
+      "model.language_model.layers.29.linear_attn.in_proj_qkv",
+      "model.language_model.layers.29.linear_attn.in_proj_z",
+      "model.language_model.layers.29.linear_attn.out_proj",
+      "model.language_model.layers.29.mlp.down_proj",
+      "model.language_model.layers.29.mlp.gate_proj",
+      "model.language_model.layers.29.mlp.up_proj",
+      "model.language_model.layers.3.mlp.down_proj",
+      "model.language_model.layers.3.mlp.gate_proj",
+      "model.language_model.layers.3.mlp.up_proj",
+      "model.language_model.layers.3.self_attn.k_proj",
+      "model.language_model.layers.3.self_attn.o_proj",
+      "model.language_model.layers.3.self_attn.q_proj",
+      "model.language_model.layers.3.self_attn.v_proj",
+      "model.language_model.layers.30.linear_attn.in_proj_a",
+      "model.language_model.layers.30.linear_attn.in_proj_b",
+      "model.language_model.layers.30.linear_attn.in_proj_qkv",
+      "model.language_model.layers.30.linear_attn.in_proj_z",
+      "model.language_model.layers.30.linear_attn.out_proj",
+      "model.language_model.layers.30.mlp.down_proj",
+      "model.language_model.layers.30.mlp.gate_proj",
+      "model.language_model.layers.30.mlp.up_proj",
+      "model.language_model.layers.31.mlp.down_proj",
+      "model.language_model.layers.31.mlp.gate_proj",
+      "model.language_model.layers.31.mlp.up_proj",
+      "model.language_model.layers.31.self_attn.k_proj",
+      "model.language_model.layers.31.self_attn.o_proj",
+      "model.language_model.layers.31.self_attn.q_proj",
+      "model.language_model.layers.31.self_attn.v_proj",
+      "model.language_model.layers.4.linear_attn.in_proj_a",
+      "model.language_model.layers.4.linear_attn.in_proj_b",
+      "model.language_model.layers.4.linear_attn.in_proj_qkv",
+      "model.language_model.layers.4.linear_attn.in_proj_z",
+      "model.language_model.layers.4.linear_attn.out_proj",
+      "model.language_model.layers.4.mlp.down_proj",
+      "model.language_model.layers.4.mlp.gate_proj",
+      "model.language_model.layers.4.mlp.up_proj",
+      "model.language_model.layers.5.linear_attn.in_proj_a",
+      "model.language_model.layers.5.linear_attn.in_proj_b",
+      "model.language_model.layers.5.linear_attn.in_proj_qkv",
+      "model.language_model.layers.5.linear_attn.in_proj_z",
+      "model.language_model.layers.5.linear_attn.out_proj",
+      "model.language_model.layers.5.mlp.down_proj",
+      "model.language_model.layers.5.mlp.gate_proj",
+      "model.language_model.layers.5.mlp.up_proj",
+      "model.language_model.layers.6.linear_attn.in_proj_a",
+      "model.language_model.layers.6.linear_attn.in_proj_b",
+      "model.language_model.layers.6.linear_attn.in_proj_qkv",
+      "model.language_model.layers.6.linear_attn.in_proj_z",
+      "model.language_model.layers.6.linear_attn.out_proj",
+      "model.language_model.layers.6.mlp.down_proj",
+      "model.language_model.layers.6.mlp.gate_proj",
+      "model.language_model.layers.6.mlp.up_proj",
+      "model.language_model.layers.7.mlp.down_proj",
+      "model.language_model.layers.7.mlp.gate_proj",
+      "model.language_model.layers.7.mlp.up_proj",
+      "model.language_model.layers.7.self_attn.k_proj",
+      "model.language_model.layers.7.self_attn.o_proj",
+      "model.language_model.layers.7.self_attn.q_proj",
+      "model.language_model.layers.7.self_attn.v_proj",
+      "model.language_model.layers.8.linear_attn.in_proj_a",
+      "model.language_model.layers.8.linear_attn.in_proj_b",
+      "model.language_model.layers.8.linear_attn.in_proj_qkv",
+      "model.language_model.layers.8.linear_attn.in_proj_z",
+      "model.language_model.layers.8.linear_attn.out_proj",
+      "model.language_model.layers.8.mlp.down_proj",
+      "model.language_model.layers.8.mlp.gate_proj",
+      "model.language_model.layers.8.mlp.up_proj",
+      "model.language_model.layers.9.linear_attn.in_proj_a",
+      "model.language_model.layers.9.linear_attn.in_proj_b",
+      "model.language_model.layers.9.linear_attn.in_proj_qkv",
+      "model.language_model.layers.9.linear_attn.in_proj_z",
+      "model.language_model.layers.9.linear_attn.out_proj",
+      "model.language_model.layers.9.mlp.down_proj",
+      "model.language_model.layers.9.mlp.gate_proj",
+      "model.language_model.layers.9.mlp.up_proj"
+    ]
+  },
+  "loss": {
+    "brier_reduction": "sum_options",
+    "brier_weight": 0.1,
+    "label_smoothing": 0.05
+  },
+  "mode": "lora",
+  "native_source_sha256": "0e304cf7c6500e8bb59bef7e2afd2c6373f82596dfb3b57d1aa93c175e2dc3a3"
+}

code/.dockerignore

@@ -0,0 +1,14 @@
+# Send only game source and locked build inputs to Docker.
+**
+!Dockerfile
+!.dockerignore
+!pyproject.toml
+!uv.lock
+!README.md
+!LICENSE
+!NOTICE
+!src/
+!src/stackcraft/
+!src/stackcraft/**
+**/__pycache__/
+**/*.pyc

code/.python-version

@@ -0,0 +1 @@
+3.13

code/Dockerfile

@@ -0,0 +1,23 @@
+FROM python:3.13-slim-bookworm@sha256:5024f48ba9441d4b13a95d3945abc6365538e3a31109833367a1923523c6efed AS builder
+COPY --from=ghcr.io/astral-sh/uv:0.12.23@sha256:61d393e44e249f2e4b526b6c7ddcecce245946826e608e11c93ad4f5bba55b21 /uv /usr/local/bin/uv
+ENV UV_PROJECT_ENVIRONMENT=/opt/venv \
+    UV_PYTHON_DOWNLOADS=never \
+    UV_LINK_MODE=copy
+WORKDIR /opt/build
+COPY pyproject.toml uv.lock README.md LICENSE NOTICE ./
+COPY src/ ./src/
+RUN uv sync --locked --no-dev --no-editable --python /usr/local/bin/python
+
+FROM python:3.13-slim-bookworm@sha256:5024f48ba9441d4b13a95d3945abc6365538e3a31109833367a1923523c6efed AS runtime
+RUN useradd --create-home --uid 1000 stackcraft
+COPY --from=builder --chown=1000:1000 /opt/venv /opt/venv
+COPY --chown=1000:1000 LICENSE NOTICE /home/stackcraft/
+USER 1000
+WORKDIR /home/stackcraft
+ENV PORT=7860 \
+    PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1
+EXPOSE 7860
+HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
+  CMD /opt/venv/bin/python -c "import os, urllib.request; urllib.request.urlopen('http://127.0.0.1:' + os.environ.get('PORT', '7860') + '/health', timeout=3)"
+CMD ["/bin/sh", "-c", "exec /opt/venv/bin/stackcraft serve --host 0.0.0.0 --port \"${PORT:-7860}\""]

code/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Alibaba Cloud
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

code/NOTICE

@@ -0,0 +1,16 @@
+Stackcraft
+Copyright 2026 Stackcraft contributors.
+
+Stackcraft is an independent educational falling-block game and fine-tuning study.
+It is not affiliated with or endorsed by Tetris, Cloudflare, or the Qwen project.
+
+The optional trained model derives from Cloudflare/Clef-Flash (Apache-2.0),
+revision 17f0b0ad64efb65d273590632833508766b2aae6, which derives from
+Qwen/Qwen3.5-9B. Original backbone weights and native joint-schema implementation
+remain upstream dependencies; this repository does not redistribute the backbone.
+Stackcraft adds game-specific LoRA matrices and trains a separate native decision
+head. The trained head and LoRA weights must be loaded together.
+
+Upstream model: https://huggingface.co/Cloudflare/clef-flash
+Base architecture: https://huggingface.co/Qwen/Qwen3.5-9B
+Python package dependency licenses remain with their respective authors.

code/README.md

@@ -0,0 +1,142 @@
+# Stackcraft
+
+A playable, deterministic falling-block game for studying decision models. The goal is a fair comparison of a heuristic player, unchanged Clef-flash, and a fine-tuned model on identical piece sequences.
+
+**Status:** training, validation selection, fresh-process reload and the 1,000-game
+held-out evaluation are complete. The final report and recorded demo passed review. See [the release tutorial](docs/tutorials/06-release.md)
+for milestones and acceptance criteria.
+
+## Releases
+
+- [Planned CPU demo](https://huggingface.co/spaces/nima1/stackcraft) — hosting awaits the account requirement below
+- [Model adapter and decision head](https://huggingface.co/nima1/stackcraft-clef-flash-lora)
+- [Synthetic dataset](https://huggingface.co/datasets/nima1/stackcraft-data)
+- [Source and release verification](https://github.com/kkarimi/stackcraft)
+
+The demo replays actual model decisions alongside live human play. It needs no
+GPU hosting. All four destinations are approved for public release. Hugging Face
+currently requires a PRO subscription to create the Docker CPU Space; the local
+demo works, and hosted publication awaits that account requirement.
+
+## What the experiment found
+
+On 200 paired sequences per player, with a 200-piece cap:
+
+| Player | Mean lines | Mean pieces placed | Mean decision time |
+| --- | ---: | ---: | ---: |
+| Unchanged Clef-flash | 0.070 | 26.020 | 149.11 ms |
+| Unchanged FP32-head control | 0.105 | 26.000 | 150.19 ms |
+| Fine-tuned Clef-flash | 16.810 | 83.565 | 206.81 ms |
+| Random legal placement | 0.140 | 26.645 | 0.0015 ms |
+| Fixed heuristic | 76.530 | 200.000 | 0.1985 ms |
+
+Fine-tuning improved mean lines over native Clef by **16.74**, with a paired 95%
+bootstrap interval of **[15.74, 17.77]**. The same improvement remains against the
+unchanged FP32-head control. The heuristic cleared substantially more lines than
+the trained model and was about 1,042 times faster per decision on this machine.
+All players had zero errors or invalid decisions. The heuristic reached the cap
+in every game; its uncapped survival was not measured.
+
+This is a successful adaptation experiment and a clear example of why a cheap
+baseline matters. It does not establish that a large model is the best tool for
+this game. See [the full study report](reports/final-study.md) for medians,
+uncertainty, validation results, limitations and reproducible evidence.
+
+
+## Run locally
+
+Install [uv](https://docs.astral.sh/uv/), then from this directory:
+
+```bash
+uv sync --locked
+uv run --locked stackcraft serve --port 8087
+```
+
+Open http://127.0.0.1:8087. The game needs no GPU or model credential. Sessions are local, in memory, and expire when the server restarts; download a replay to retain a game. The local service retains 128 sessions and limits each to 2,000 placements. Use a single server worker. The game does not require an account.
+
+## Development
+
+```bash
+uv run --locked ruff check .
+uv run --locked ruff format --check .
+uv run --locked ty check src/stackcraft --exclude src/stackcraft/training.py
+uv run --locked pytest
+```
+
+These commands check the game without installing ML packages. Full-repository
+type checking also covers training scripts and requires the ML extra:
+
+```bash
+uv run --locked --extra ml ty check
+```
+
+Installing that extra does not run GPU inference. When keeping an ML environment,
+use `--extra ml` on uv commands to prevent synchronization from removing those
+optional packages.
+
+The committed lockfile fixes dependency versions; `uv sync --locked` refuses to silently update it. Python 3.13 is selected by `.python-version`. No pip activation or global dependency installation is needed.
+
+Read [tutorial 00](docs/tutorials/00-foundation.md) for the setup rationale, [the rules](docs/rules.md) for the exact game, and [the API contract](docs/interfaces.md) for integration. This is a simplified turn-based placement game, with no gravity timer, hold or wall kicks. It is not affiliated with Tetris.
+
+## Offline baseline tournament
+
+```bash
+uv run --locked stackcraft tournament --seed-start 1000 --episodes 20 --max-pieces 100 --output runs/development.json
+```
+
+This runs random and fixed heuristic players on identical seeds, records every decision and replay, and refuses to overwrite an existing result. See [tutorial02](docs/tutorials/02-baselines.md). Development scores are not held-out model results.
+
+## Expert-labelled data
+
+```bash
+uv run --locked stackcraft generate-data --output data/study-v1
+```
+
+This generates training/validation episodes from fixed disjoint seed pools, labels moves with bounded search, removes duplicate observations and writes a hashed manifest. Final test seeds remain reserved. See [tutorial03](docs/tutorials/03-data.md).
+
+Optional Clef tooling uses `uv sync --locked --extra ml`. Its native encoder, real GPU inference, finite head/LoRA gradients and exact fresh-process checkpoint reload have been verified. Full-study quality is a separate evaluation. See [native adapter documentation](docs/clef.md).
+
+## The model used here
+
+The base is **Cloudflare/clef-flash**, built on Qwen3.5-9B, pinned at
+`17f0b0ad64efb65d273590632833508766b2aae6`. It produces probabilities over every
+supplied legal move instead of generating text. Training updates rank-4 text-layer
+LoRA matrices and the native joint decision head; the original backbone is frozen.
+The checkpoint must save and load both the adapter and head.
+
+On the RTX 5090, the short native inference pilot allocated 19.7 GB and averaged
+144 ms per decision. The training probe allocated 23.2 GB; both head-only and LoRA-plus-head
+checkpoints reproduced their reference probabilities exactly in fresh processes.
+These are engineering measurements, not evidence of better game play. See
+[the measured feasibility report](reports/gpu-feasibility.json).
+
+## Follow the milestones
+
+1. [Foundation and modern Python tools](docs/tutorials/00-foundation.md)
+2. [Deterministic game and replay](docs/tutorials/01-game.md)
+3. [Cheap and unchanged-model baselines](docs/tutorials/02-baselines.md)
+4. [Search-teacher data and leakage checks](docs/tutorials/03-data.md)
+5. [Real GPU training and checkpoint fidelity](docs/tutorials/04-gpu-feasibility.md)
+6. [Validation selection and paired game evaluation](docs/tutorials/05-evaluation.md)
+7. [Release, public reproduction and fresh-download checks](docs/tutorials/06-release.md)
+
+Each tutorial explains the commands, evidence, design choices and alternatives.
+The [evaluation protocol](docs/evaluation-protocol.md) freezes 200 test sequences
+and a 200-piece cap before results. It compares the selected model with the native
+base, an unchanged FP32-head ablation, random moves and a fast heuristic.
+
+The training runner intentionally accepts only the exact frozen study dataset.
+A newly generated dataset can have different provenance hashes even if its labels
+match. For exact reproduction use the released dataset or Tutorial03's source-hash
+checked reconstruction. A new dataset or hyperparameter study should be recorded
+as a new experiment, not quietly substituted into this study.
+
+## Demo hosting
+
+The [Docker deployment guide](docs/demo-hosting.md) builds a CPU-only image with
+no model credentials or Torch. Human gameplay is live; model comparisons replay
+recorded decisions and probabilities. Playback speed is separate from measured
+inference latency. Local packaging has been verified. Release verification is recorded in the GitHub repository.
+
+Apache-2.0. See [LICENSE](LICENSE) and [NOTICE](NOTICE). Stackcraft is independent
+of Cloudflare, Qwen and Tetris.

code/docs/clef.md

@@ -0,0 +1,121 @@
+# Native Clef adapter
+
+Status: native encoding, real-weight BF16 inference and bounded head/LoRA GPU
+training have passed. Fresh-process checkpoint parity and full held-out quality
+are separate gates; see the plan and reports for their current status. Fake
+components in unit tests exercise mapping and failure handling only.
+
+## Pinned upstream contract
+
+- Model: `Cloudflare/clef-flash`.
+- Revision: `17f0b0ad64efb65d273590632833508766b2aae6`.
+- Native file: `joint_schema_model.py`.
+- Source SHA256: `0e304cf7c6500e8bb59bef7e2afd2c6373f82596dfb3b57d1aa93c175e2dc3a3`.
+- Observation encoding: `stackcraft-clef-v1`.
+
+Inspected source: [pinned native implementation](https://huggingface.co/Cloudflare/clef-flash/blob/17f0b0ad64efb65d273590632833508766b2aae6/joint_schema_model.py).
+The loader pins a complete snapshot and supplies its local directory to upstream
+`load_release_model`; passing only the repository name to upstream would download
+an unpinned snapshot. `import_pinned_source` checks exact file bytes before
+executing them. Callers must explicitly set `trust_pinned_code=True`: this executes
+reviewed upstream Python with the process's permissions, not in a sandbox.
+
+The unchanged loader constructs `Qwen3_5ForConditionalGeneration`, loads a separate
+`JointSchemaHead`, then constructs `AutoProcessor`. Its processor configuration is
+multimodal even though this application passes only text. Optional ML dependencies
+must therefore support that native construction; importing `stackcraft.clef` or
+playing the game itself requires none of them.
+
+## Input and outputs
+
+`observation_record(observation)` includes the 20 board rows, current piece, exactly
+one preview piece, rules and coordinate definitions. Occupied cells are `#` and
+empty cells are `.`; colors carry no decision-relevant information in these rules.
+The native choice question contains every legal action ID with its rotation,
+column, landing row and four absolute cell coordinates. It does not include a seed,
+hidden stream, score-derived helper features, or heuristic candidate pruning.
+
+Native choice encoding sorts option IDs lexicographically. Probabilities must be
+mapped using `EncodedQuestion.option_ids`, rather than the input dictionary order.
+The adapter reads `model(collate_records([encoded], pad_id, device))[0][0]` and takes
+FP32 softmax. It retains unrounded float probabilities. Upstream `systemone()`
+rounds probabilities to four decimals, which is unsuitable for precise validation
+and probability metrics. On exact probability ties, Stackcraft uses the shared
+engine action order.
+
+## Context integrity
+
+The native encoder reserves schema tokens and silently truncates state tokens to
+fit `max_length`. Losing some board rows would change the game state presented to
+the model. Before encoding, Stackcraft counts every separately tokenized segment
+used by the pinned encoder. It rejects the entire decision if complete input does
+not fit the configured limit, then checks the resulting length and option IDs.
+It never removes choices or board rows to make a record fit.
+
+The default limit is 4,096 tokens, a memory-conscious initial setting, not a claim
+about the backbone's advertised context. If observed positions exceed it, measure
+the required size and preregister a consistently larger limit for both base and
+trained models. Any different text representation needs a new encoding version.
+
+## Integration example
+
+After ML dependencies and the pinned snapshot are available, and available GPU
+memory has been checked:
+
+```python
+from stackcraft.clef import ClefPlayer
+from stackcraft.engine import new_game
+from stackcraft.players import observe
+
+player = ClefPlayer.from_pretrained(
+    trust_pinned_code=True,
+    local_files_only=True,
+    device="cuda",
+    max_length=4096,
+)
+decision = player.choose(observe(new_game(42)))
+print(decision.action_id, decision.probabilities, player.last_input_tokens)
+```
+
+This example loads real 9B weights. Real inference passed on an RTX 5090.
+The loader does not stop other workloads, allocate rented compute, or implicitly
+download missing weights by default. A caller can deliberately set
+`local_files_only=False` to obtain this pinned snapshot. Model identity, source
+hash and encoding version must accompany measurements.
+
+`player.runtime_config` records model ID, player/checkpoint revision, pinned base
+revision, encoding version, native source SHA256 and configured context limit.
+After each successful decision it also records the actual first model parameter's
+dtype and device. These are initially null until inference succeeds; construction
+does not consume model parameters or import Torch for metadata. The native release
+uses one device and dtype; this field is not a full precision inventory for future
+mixed-precision training models. `last_input_tokens` records the successful
+decision's complete encoded length. Tournament artifacts should snapshot runtime
+metadata and retain token counts per decision, rather than infer them from defaults.
+
+Run the offline adapter checks with:
+
+```sh
+uv run --locked pytest tests/test_clef.py
+```
+
+CPU verification used the actual `Qwen3VLProcessor` and native `encode_record`,
+without constructing a backbone or loading weights. Fourteen fixtures covered
+all seven pieces on an empty board and on a dense 15-row patterned stack, including
+34-choice positions. Exact token counts matched in every case: 848–2,248 tokens,
+all within 4,096. Rejecting a limit one token below each required size also passes
+the dedicated integration check. These fixtures do not establish a universal
+maximum; every inference request still runs preflight.
+
+Reproduce that optional check after installing the ML extra and caching pinned
+tokenizer/processor/source files:
+
+```sh
+STACKCRAFT_TEST_NATIVE_ENCODING=1 uv run --locked --extra ml pytest tests/test_clef.py
+```
+
+The two-seed real-weight development baseline used19.69GB peak allocated memory
+and averaged144ms per decision; reports/clef-development.json records the result.
+These development measurements do not establish trained-model quality. Training must call native
+`ClefModel.forward` with gradients enabled; `choose()` intentionally uses inference
+mode and must not be used as a training path.

code/docs/demo-hosting.md

@@ -0,0 +1,156 @@
+# Host the playable game and recorded comparison
+
+The demo serves the actual Python game and validated recorded model decisions. It
+requires no GPU, Hugging Face token, Torch installation or model download. Human
+moves are live simulator calls; comparison boards replay decisions measured during
+the evaluation. Playback timing is deliberately separate from inference latency.
+
+This is a deployment package, not evidence of publication. Create or upload a new
+Space only after the project owner confirms its destination and visibility.
+
+## Export the fixed example after evaluation
+
+The demonstration seed is **30000**, chosen before inspecting results. Do not pick
+a better-looking seed after the evaluation. A single game illustrates behavior;
+the aggregate evaluation report establishes the quantitative result.
+
+After the final tournament has completed, export to a new file:
+
+```bash
+uv run --locked python scripts/export_demo.py \
+  --input runs/final-evaluation/report.json \
+  --players base trained heuristic \
+  --seed 30000 \
+  --output runs/release-demo/baseline-demo.json
+```
+
+The input path above is an example; use the actual complete evaluation report.
+`--input` can be repeated for separate tournament or individual episode artifacts.
+The exporter requires two to four distinct players, an identical piece cap, and
+exactly one recording per selected player at the fixed seed. The optional
+`base-fp32` player is a precision ablation, not the primary unchanged model.
+
+The exporter replays every selected action with the authoritative engine and
+checks final outcomes, stop reasons, observations, probability distributions and
+decision/action alignment. It preserves errors as errors. It keeps complete
+replays, compact decision probabilities, measured decision times, actual player
+revisions, runtime metadata, source filenames and SHA-256 hashes. It strips the
+large repeated observation payloads because the game can reconstruct them.
+Neither missing players nor invalid records are replaced with simulated model
+results. Existing outputs are never overwritten.
+
+After the results page's publication destination is confirmed, optionally add
+`--report-url` with its absolute HTTPS URL. This adds a "Full study results" link
+to the race without changing source hashes or recorded decisions. Omit it until
+the actual destination is known; the UI hides the link when absent or invalid.
+
+The JSON is compatible with the race manifest loaded from
+`src/stackcraft/web/baseline-demo.json`. Before a release, review the exported
+example and replace that packaged asset explicitly. The checked-in development
+asset must remain labelled as development until actual evaluation replays replace
+it. Do not rename a heuristic recording to make a missing model board appear.
+
+## Build the game-only container
+
+```bash
+docker build -t stackcraft-demo:local .
+docker run --rm --name stackcraft-demo-local \
+  -p 127.0.0.1:7860:7860 stackcraft-demo:local
+```
+
+Open `http://127.0.0.1:7860`. The container runs as UID 1000 and listens on all
+interfaces inside the container; this local command exposes it only on loopback.
+The Dockerfile uses Python 3.13 and a versioned uv executable. Its build stage runs
+`uv sync --locked --no-dev --no-editable` with no ML extra. Installing the project
+rather than an editable source link checks that the wheel contains HTML, CSS,
+JavaScript and the replay JSON. The runtime stage contains that environment and
+uses the CLI directly, with no dependency resolution at startup. This follows the
+[uv container installation guidance](https://docs.astral.sh/uv/guides/integration/docker/).
+
+`.dockerignore` allows only the source and locked build inputs into the build
+context. Local credentials, model weights, training runs, `.venv`, raw datasets
+and Git history are excluded. The image does not need them to reconstruct games.
+The dependency lock freezes Python packages. Both the Python base and uv image
+are pinned by digest; the verified Python base supplies 3.13.16. Update these
+explicitly when upgrading the deployment, and record the final application image
+identity for the published build.
+
+The container defaults to port 7860. To change it locally:
+
+```bash
+docker run --rm --name stackcraft-demo-local \
+  -e PORT=8090 -p 127.0.0.1:8090:8090 stackcraft-demo:local
+```
+
+This container setting does not change the normal CLI's default local port 8080.
+Use a free host port; do not stop another application merely to reclaim 8080.
+
+## Configure a Hugging Face Docker Space
+
+As checked on 2026-10-06, Hugging Face requires a PRO subscription for a personal
+account to create a Docker Space, including `cpu-basic`. That hardware has no
+hourly charge, but it is not subscription-free hosting. Static Spaces have different
+requirements and cannot run this Python HTTP service unchanged. See the
+[official Spaces overview](https://huggingface.co/docs/hub/spaces-overview).
+The initial `nima1/stackcraft` creation returned HTTP 402; no subscription or paid
+hardware was purchased. Resolve the account requirement or choose another CPU host
+before following the deployment steps below.
+
+Once publication is authorized, the Space repository needs the Dockerfile,
+`.dockerignore`, `pyproject.toml`, `uv.lock`, `src/` including the reviewed replay
+asset, and a README. Put this configuration at the top of the Space README:
+
+```yaml
+---
+title: Stackcraft
+emoji: 🧩
+colorFrom: green
+colorTo: purple
+sdk: docker
+app_port: 7860
+---
+```
+
+The README body should link the model, dataset, code, aggregate report and
+reproduction tutorials, and explain which activity is live. The Space configuration
+uses `sdk: docker` and the same exposed port as the application. UID 1000 matches
+Hugging Face's documented container permissions. No GPU hardware upgrade or model
+credential is needed for this recorded demonstration. See the official
+[Docker Spaces documentation](https://huggingface.co/docs/hub/spaces-sdks-docker).
+
+Hugging Face builds from the Space repository. Upload only the explicit release
+files, not the entire working directory. The source repository's visibility and
+the Space's visibility are separate publication choices.
+
+## Check the actual deployment
+
+Run these checks against the built image and repeat them against the published
+Space URL after release:
+
+1. `/health` returns `{"status":"ok"}` and `/` loads its packaged assets.
+2. A human can rotate, place a piece, restart and download a replay.
+3. Opening that replay reproduces the same score, lines and board.
+4. The race clearly says recorded; scrub to both the first and last frame.
+5. The shorter run stays at its actual final state. An error is labelled as an
+   error, and reaching the episode cap is distinct from top-out.
+6. The selected action and any probability alternatives come from the recorded
+   decision at that position. They are not an explanation generated after the run.
+7. "Start live board · seed N" explicitly starts a new human game beside the
+   recorded players using the exact recording seed. Check the same episode cap,
+   keyboard controls, per-move recording synchronization and the live/recorded labels.
+   Scrubbing recorded moves must leave the human board unchanged. "Match my move"
+   restores the shared piece index. Switching Play/race preserves the human session;
+   "Leave comparison" returns it to uncapped ordinary play without a reset. On narrow
+   screens boards stack so controls remain readable; check for horizontal overflow.
+8. The running image imports the game without Torch. No requests download model
+   weights, and no inference service is contacted.
+
+Game sessions live in process memory. A container restart discards them, and the
+service retains a bounded number of sessions. Save a replay for durable evidence.
+Use one application worker with the current in-memory session store; independent
+worker processes would not share game IDs. A larger deployment would need a
+shared session store and request limits, rather than silently adding workers.
+
+Keep the final image identity, released manifest hash and successful URL checks in
+`record.md`. A local Dockerfile or a successful upload alone does not establish
+that the public comparison works.

code/docs/evaluation-protocol.md

@@ -0,0 +1,163 @@
+# Stackcraft evaluation protocol — completed study, frozen procedure
+
+The final test used all **200 episode seeds, 30000–30199**, at the frozen 200-piece
+cap, with all five players and no errors. Training, validation selection, reload
+verification, final evaluation and the independent CPU audit are complete. The
+[final study](../reports/final-study.md) reports the measured outcomes and
+[compact JSON](../reports/final-summary.json) preserves exact statistics and hashes.
+Release verification is tracked separately in the source repository.
+
+The procedure below records decisions frozen before test results were opened;
+completion does not authorize tuning against these now-disclosed sequences.
+`evaluation.py` consumes existing episode artifacts and position predictions;
+it does not invoke models, select checkpoints, or start games.
+
+## Decisions that must be frozen before opening the test results
+
+The final episode cap is now **frozen at 200 pieces**, using all 200 reserved seeds.
+This was chosen before inspecting any test results. The unchanged-model development
+pilot measured approximately 144 ms per decision. If all three neural players reach
+every cap, 120,000 decisions would take roughly 4.8 hours at that rate, excluding
+loading and reporting. Earlier base development games died much sooner; runtime
+must still be measured and reported rather than promised. Each episode is saved
+atomically so interrupted evaluation can resume without discarding difficult games.
+
+Freeze the selected trained checkpoint and original pinned Clef revision, input
+encoding, precision, hardware/runtime configuration, heuristic revision, all
+seeds, cap, inference failure behavior, bootstrap parameters and compute budget.
+The same legal placements and one-piece preview must reach every player. Primary
+base is the pinned native model with its original BF16 head. Training uses an FP32
+head; therefore an explicitly named `base-fp32` ablation keeps the original weights
+but uses the same FP32 wrapper as training. Report trained-versus-native-base as
+the primary comparison and trained-versus-base-fp32 to separate training from head
+precision effects. Backbone BF16, input encoding, context limit, device and source
+revision must agree. A changed base quantization would be a separate comparison.
+
+Checkpoint selection uses validation only. Teacher-action agreement and target
+cross-entropy on validation positions are diagnostic selection metrics, separate
+from complete-game outcomes. A model that imitates the expert more closely may
+still play worse. Preregister any training configuration search and tie rule;
+`paired_report` never makes those choices from test results.
+
+## Paired episode outcomes
+
+Primary outcome is lines cleared. Secondary outcomes are game score and pieces
+placed. Retain every planned seed for each player, including failed episodes.
+Duplicate player/seed pairs, mismatched seed sets, caps or rules, and changing
+player identity/runtime within a comparison are rejected by the report function.
+Its schema checks are not a replacement for verifying replay integrity when
+episodes are collected.
+
+An inference exception or illegal decision ends that player's episode. For the
+primary analysis, assign **zero lines, score and pieces to any errored episode**.
+Keep its original partial achievements in `observed_before_error`, retain its seed,
+and report its error. This explicit reliability penalty prevents a model from
+benefiting statistically from dropping difficult failures. The same policy applies
+to base, trained and heuristic. Never describe a failed episode as a successful
+zero-line game; status and error counts remain separate.
+
+Report mean and median metrics, cap-hit rate, failed episodes, error rate and
+invalid-decision count. Survival is censored at the cap: a cap hit means at least
+that many pieces, not a measured death at that turn. This protocol cannot establish
+uncapped longevity or full competitive Tetris performance.
+
+For each seed, subtract base outcome from trained outcome. Resample these paired
+episode differences with replacement, **10,000 bootstrap replicates, RNG seed
+2026**, and report their mean plus the percentile 95% interval. Resampling turns
+would falsely treat correlated moves within a game as independent observations.
+Pieces and score get descriptive intervals; lines are the single primary endpoint.
+The intervals are conditional on the tested checkpoint and episode distribution;
+one trained seed does not characterize training-seed variability.
+
+`positive_mean_lines_signal` is true only if there are at least two pairs, the
+primary interval's lower bound exceeds zero, and both base and trained episode
+error rates are at or below the declared threshold (**default 0%**). This flag is
+evidence for that measured comparison, not an automatic claim of general
+superiority, approval to publish, or a way to select a checkpoint on the test set.
+The heuristic remains a separate required comparator. Run the same paired analysis
+against it and disclose whether the model actually beats that cheap baseline.
+
+## Timing and input lengths
+
+Summarize decision latency mean, median and nearest-rank p95 from all attempts,
+including failed attempts. These are timings recorded around `Player.choose`;
+they include tokenization and policy overhead, exclude game rendering/replay, and
+should not be advertised as pure GPU kernel time. CUDA probability transfer must
+complete before `choose` returns. Record cold loading separately and identify any
+warmup excluded before measured episodes. Never mix cached-replay speed with live
+model latency. Input-token summaries use only events containing `input_tokens`
+and report their count, so missing token metadata remains visible.
+
+## Position predictions
+
+`summarize_positions` reports agreement with the fixed teacher label, target NLL
+and multiclass Brier score (sum over choices, averaged over positions). The fixed
+label uses engine-order tie-breaking; agreement therefore penalizes choosing a
+different equally valued action. Consider a separately named optimal-value tie
+agreement metric later if preregistered; do not silently change the definition.
+
+Missing or invalid predictions stay in the agreement denominator as failures.
+Aggregate NLL/Brier are available only with a complete legal probability
+distribution for every position. Partial diagnostic means have explicit subset
+denominators and cannot be presented as full-set results. A zero probability on
+the teacher label means infinite NLL; JSON stores a null mean plus an explicit
+`nll_is_infinite` flag and zero-target count, rather than silently clipping it.
+
+```python
+from stackcraft.evaluation import paired_report, summarize_positions
+
+# Load complete, previously collected artifacts; this runs no model or game.
+report = paired_report(episodes, trained_id="trained", base_id="base")
+position_report = summarize_positions(validation_rows, predictions_by_record_id)
+```
+
+Toy tests verify known constant paired improvements, mismatched-pair rejection,
+failure retention, metadata consistency and proper probability-score arithmetic.
+Passing them verifies report mechanics, not any model's game performance.
+
+## Execute and resume a frozen evaluation
+
+`scripts/evaluate_clef.py positions --dataset data/study-v1 --checkpoint PATH
+--output NEWDIR` evaluates the entire validation split and writes unrounded
+predictions plus NLL/agreement/Brier evidence. Its default players are native base,
+base-fp32 and trained. Model loading is sequential to fit one GPU; this is real
+inference and must follow memory admission. `--players trained` evaluates another
+candidate without rerunning the unchanged baselines.
+
+After validation, run `scripts/select_checkpoint.py` with both explicit epoch
+checkpoint/report pairs and a new output directory, as shown in Tutorial 05.
+It recomputes metrics from the raw predictions, verifies both checkpoint trees,
+selects by the preregistered rule, and copies self-contained validation evidence.
+Its `selection.json` contains schema_version 1,
+selection_split `validation`, selected_key, decision_rule, checkpoint_sha256 mapping,
+validation_metrics, validation_evidence `{path,sha256}`, test_seeds, their canonical
+JSON SHA256 as test_seeds_sha256, max_pieces 200, encoding_version, max_length,
+players, head_dtypes, bootstrap_samples 10000, bootstrap_seed 2026, max_error_rate
+0.0. Validation evidence must be the script's position report for the same checkpoint;
+its path is relative to selection.json. Checkpoint hashes include every checkpoint
+file. Set head_dtypes to `{base: bfloat16, base-fp32: float32, trained: float32}`
+when all three neural players are included.
+
+Both epoch candidates and their eligibility reasons are mandatory in the selection
+artifact. Before opening test seeds, the evaluator checks all 215 positions,
+complete finite probability metrics, zero inference errors, checkpoint/dataset
+binding, and the lowest-NLL winner with an earlier-epoch tie rule. All five players,
+including the FP32-head ablation, are required by this study.
+
+```sh
+uv run --locked --extra ml python scripts/evaluate_clef.py tournament \
+  --checkpoint PATH --seeds 30000:30200 --max-pieces 200 \
+  --final-test --selection-file selection.json --output runs/final-evaluation
+```
+
+The default includes all five players. The final-test switch is an explicit
+acknowledgment that these held-out seeds will now be consumed. Without it, the
+script rejects any overlap with the reserved pool before loading a player.
+
+Every completed episode is stored as `PLAYER/seed-N.json`; `progress.json` records
+progress, and the final `report.json` includes all episodes and paired comparisons.
+Repeat exactly the same command with `--resume` after an interruption. The script
+checks request, source hashes, selected checkpoint, frozen protocol and saved replay
+outcomes, skips completed players without loading them, and resumes missing seeds.
+It never retries or deletes a recorded error episode. Loading is timed separately;
+there are no silently excluded warmup decisions.

code/docs/interfaces.md

@@ -0,0 +1,15 @@
+# Initial implementation contract
+
+The Python engine is authoritative. These names are shared across independently implemented engine, service, and UI. All board coordinates have x increasing right and y increasing down; rows are top to bottom. Board cells are 0 for empty or 1 through 7 for piece colors. Board width is 10, height is 20. Four normalized orientations are enumerated and duplicate shapes removed.
+
+`schema.py` defines frozen dataclasses: `Placement(id: str, rotation: int, x: int, y: int, cells: tuple[tuple[int,int], ...])`; `GameState(board: tuple[tuple[int,...],...], seed: int, piece_index: int, current: str, next_piece: str, score: int=0, lines: int=0, terminal: bool=False)`; `Transition(state: GameState, action: Placement, cleared: int)`.
+
+`pieces.py`: `piece_at(seed: int, index: int) -> str`, `rotations(piece: str) -> tuple[tuple[tuple[int,int],...],...]`. Piece colors map in order `I,O,T,S,Z,J,L` to 1..7. Deterministic sequence is versioned, uses a local random generator, and is identical regardless of player pace.
+
+`engine.py`: `new_game(seed: int) -> GameState`, `legal_actions(state: GameState) -> tuple[Placement,...]`, `step(state: GameState, action_id: str) -> Transition`. Action IDs are `r{rotation}x{x}`. Placements are straight vertical hard drops starting fully within the board. No legal placement means terminal. An illegal or terminal-state action raises `ValueError` without mutating state. `legal_actions` includes landing y and absolute cell positions so clients can display a ghost without computing game rules. Clear rows simultaneously, score 100/300/500/800 for 1/2/3/4 lines, advance piece index, and detect next-piece top-out.
+
+`replay.py`: `make_replay(seed: int, actions: list[str]) -> dict` computes a JSON-serializable artifact containing `schema_version: 1`, `rules_version: "stackcraft-v1"`, seed, action IDs, and final score/lines/pieces/terminal. `replay_states(artifact: dict) -> list[GameState]` validates versions and actions and returns initial plus successive states; validate final summary if provided.
+
+Service HTTP endpoints (all JSON unless noted): `GET /` serves the game; `POST /api/games` with `{seed: int}` returns a session snapshot; `POST /api/games/{id}/moves` with `{action_id: str, expected_pieces: int}` returns its next snapshot; `GET /api/games/{id}` snapshot; `GET /api/games/{id}/replay` returns replay artifact; `POST /api/replays` with an artifact returns `{frames: [snapshot_without_id,...]}`. `GET /health` returns `{status:"ok"}`. Snapshots contain `id`, `board`, `current`, `next_piece`, `score`, `lines`, `pieces` (piece index), `terminal`, `legal_actions` (serialized Placement). Error responses have readable `detail`; unknown session 404, invalid action/replay 422, stale expected_pieces 409. On uncertain move response the client refreshes state before allowing another move; replay retries must not advance a second piece. API never reveals future piece stream to model adapters (seed exists only in server storage/replay).
+
+UI uses these routes directly with fetch; no second simulator. Arrow left/right selects legal placements at current rotation, up rotates selection, space/Enter drops. Buttons allow all actions. Restart requests the seed input again. Download replay and load replay use the above endpoints, with frame stepping. UI source belongs in `src/stackcraft/web/` and uses vanilla JS/CSS/HTML to avoid a second package manager. Label the game as turn-based placement; no hold, tucks, kicks, T-spin bonuses or gravity timer. Comparison boards will be added after baselines.

code/docs/rules.md

@@ -0,0 +1,87 @@
+# Stackcraft v1 rules
+
+Rules version: `stackcraft-v1`. Replay schema version: `1`.
+
+Stackcraft is a turn-based tetromino placement game. Its research rules deliberately
+exclude real-time gravity, hold, wall kicks, tucks, lock delay, T-spins, combos,
+back-to-back bonuses, and level multipliers. It is not a full competitive Tetris
+implementation. Humans and every bot use the same legal-placement enumerator.
+
+## Board and pieces
+
+The board has 10 columns and 20 rows. Coordinates increase rightward (`x`) and
+downward (`y`); `(0, 0)` is the top-left cell. Empty cells are `0`. Piece colors
+are integer IDs `1..7` corresponding to `I,O,T,S,Z,J,L`.
+
+Each piece has four cells. Orientation zero is defined in `pieces.py`. Other
+orientations are successive clockwise rotations, normalized so their minimum x
+and y are zero; duplicate orientations are removed. `I,S,Z` have two orientations,
+`O` has one, and `T,J,L` have four. Rotation numbers refer to this unique list,
+not to a wall-kick rotation system.
+
+## Piece stream and information
+
+Each seven-piece bag contains every shape once. Bag number `b` uses a private
+Python `Random` instance seeded with the string `stackcraft-v1:{seed}:{b}` and
+an explicitly defined descending Fisher-Yates shuffle: at position `p` swap with
+`int(random() * (p + 1))`. This avoids dependence on global random state, request
+order, and higher-level shuffle implementation changes. The locked Python
+environment and stream fixture tests provide an additional reproduction check.
+
+Players observe the board, current piece, and exactly one next piece. Seeds,
+bag state, and later pieces must not appear in model observations. Replays contain
+a seed for reconstruction, so replay metadata is not a valid model observation.
+Piece index is the count of successfully placed pieces, initially zero.
+
+## Legal moves and top-out
+
+For each unique orientation and fitting column, place the normalized shape at
+`y=0`, fully within the board. If any of those cells is occupied, this placement
+is unavailable, even if there is space below. Otherwise move the shape down one
+row at a time until the next step would collide or leave the board. This is the
+only landing for that orientation and column. A piece cannot pass through a
+block or slide underneath an overhang.
+
+The action ID is `r{rotation}x{x}`, for example `r1x4`. Legal actions include the
+landing y-coordinate and all four absolute cell coordinates. They are ordered
+by rotation, then x, making deterministic tie-breaking possible. If there are no
+legal moves, the game is terminal. Top-out is evaluated for the next current
+piece after the preceding move's row clears. There are no hidden spawn rows.
+
+## Clearing and scoring
+
+After placing a piece, remove every full row simultaneously. Remaining rows keep
+their relative order and empty rows are added at the top. Award these points:
+
+| Rows cleared by this move | Points |
+| --- | --- |
+| 0 | 0 |
+| 1 | 100 |
+| 2 | 300 |
+| 3 | 500 |
+| 4 | 800 |
+
+Advance to the preview piece and reveal one new preview. Lines and score are
+cumulative; there are no movement or hard-drop points. Lines cleared are the
+primary research outcome. Score, placed pieces, and top-out are additional
+outcomes. Evaluation episode caps are separate from these rules and must be
+reported; reaching a cap does not imply top-out.
+
+## State, errors, and replay
+
+`GameState`, `Placement`, and `Transition` are frozen dataclasses. Boards and
+cell collections are tuples. `step(state, action_id)` validates an ID against
+the current legal moves and returns a new state. Invalid moves, including any
+move after top-out, raise `ValueError`; the input state remains unchanged.
+
+`place(board, piece, action)` is a lower-level helper for expert and heuristic
+afterboard evaluation. It reads no seed or future piece. Its action must already
+come from `legal_actions` for that board and piece; it checks cell bounds and
+occupation, but does not repeat path validation. External move IDs use `step`.
+
+A replay stores schema/rules versions, seed, action IDs, and final score, lines,
+placed pieces and terminal status. Import re-simulates every move. Invalid moves,
+incompatible versions and inconsistent final summaries are rejected. Partial
+games are valid. A consistent replay is reproducible evidence, not a signed
+attestation of who played: changing actions and recomputing their summary creates
+another valid game.

code/docs/tutorials/00-foundation.md

@@ -0,0 +1,57 @@
+# Milestone 00: a reproducible experiment starts with a reproducible game
+
+The eventual question is whether training helps a decision model play better. Before loading a model, establish a game that behaves identically for two players given the same pieces. Otherwise a score difference could reflect easier pieces or different rules.
+
+## 1. Create an isolated Python project
+
+This repository uses Python 3.13, a `src/stackcraft` package, and uv. Run from the repository root:
+
+```bash
+uv sync --locked
+uv run --locked stackcraft --help
+uv run --locked stackcraft --version
+```
+
+The help lists `serve`, `tournament` and `generate-data`; the version is `stackcraft 0.1.0`. uv creates `.venv` and installs the package locally. `pyproject.toml` describes dependencies while `uv.lock` records exact resolved versions. Committing both lets another person recreate the environment. `--locked` detects a stale lock instead of silently selecting new versions.
+
+Development dependencies are a dependency group, installed by default, rather than an optional product feature. This keeps pytest and linting separate from game requirements. The ML extra isolates Torch and large model dependencies so someone can play the game without a GPU. The code does not import a model from the CLI startup path.
+
+## 2. Write the rules before comparing players
+
+Read `docs/rules.md` and `docs/interfaces.md`. All players receive the same board, current piece, and one-piece preview. They select an orientation and column; Python computes the vertical landing. A fixed seven-bag seed makes piece order reproducible. A seed is stored for replay, but never shown to a model: exposing it or later pieces would let one player gain information unavailable to another.
+
+The simplified rules omit real-time gravity and wall kicks. A full Tetris implementation would mix planning ability with timing and control. We first isolate the decision we want to learn: which legal placement is best? The UI must disclose those rules.
+
+## 3. Keep one authoritative engine
+
+Python simulates placements and emits legal actions with landing cells. The browser draws these cells and sends an action ID back. It does not recalculate collisions. Two engines in different languages could diverge and make replays unreliable. Frozen state objects and pure transition functions make mistakes easier to reproduce and test.
+
+FastAPI serves the small JSON API and static HTML/CSS/JavaScript together. This first version needs no separate Node package manager or frontend framework. That reduces setup friction while leaving room to add one when the interface genuinely needs it.
+
+## 4. Verify behavior and source quality
+
+```bash
+uv run --locked ruff check .
+uv run --locked ruff format --check .
+uv run --locked ty check src/stackcraft --exclude src/stackcraft/training.py
+uv run --locked pytest
+```
+
+These commands check the game without installing ML packages. Full-repository
+type checking also covers training scripts and requires the ML extra:
+
+```bash
+uv run --locked --extra ml ty check
+```
+
+Installing that extra does not run GPU inference. When keeping an ML environment,
+use `--extra ml` on uv commands to prevent synchronization from removing those
+optional packages.
+
+Ruff catches common source mistakes and applies one formatting style. ty checks Python types. pytest verifies outcomes such as a cleared row, an unchanged state after an illegal move, and a replay that reaches the original final board. Passing checks does not prove model quality; that requires a later held-out tournament.
+
+## 5. Preserve decisions and evidence
+
+`plan.md` tracks milestones; `record.md` stores concise results and experiment intentions. Code and tutorials use local Git commits. Environments, weights, raw datasets, credentials and checkpoints are ignored. Later reports will refer to their hashes and release revisions rather than placing gigabytes in Git.
+
+The next milestone adds the engine, playable board and replay. Model training starts only after those behaviors can be verified independently.

code/docs/tutorials/01-game.md

@@ -0,0 +1,153 @@
+# Milestone 1: build a game whose decisions can be replayed
+
+The deliverable is a playable turn-based game backed by a deterministic Python
+engine. Before interpreting a model's performance, we need confidence that every
+player follows identical rules and that saved decisions reconstruct the game.
+Read [the complete rules](../rules.md) before extending the simulator.
+
+## 1. Install and start the game
+
+From the repository root, install the committed environment and start the server:
+
+```sh
+uv sync --locked
+uv run --locked stackcraft serve --host 127.0.0.1 --port 8080
+```
+
+Open `http://127.0.0.1:8080`. Choose a seed and start a game. Left/right select a
+column, up changes orientation, and Space or Enter drops the selected placement.
+Buttons provide the same controls. There is no gravity timer: take as long as
+you need. The preview shows exactly one future piece.
+
+Use restart with the same seed to receive the same piece stream. Download the
+replay, load it again, and step through its frames. The imported game is simulated
+again by Python; the browser does not trust a claimed score in the file.
+
+Why this design: real-time input would mix decision quality with timing and
+keyboard control. Placement decisions are an interpretable first experiment.
+The browser displays authoritative legal moves rather than maintaining a second
+simulator that could drift away from training rules.
+
+## 2. Inspect the pure engine
+
+```python
+from stackcraft.engine import legal_actions, new_game, step
+
+before = new_game(seed=42)
+move = legal_actions(before)[0]
+transition = step(before, move.id)
+assert before.piece_index == 0
+assert transition.state.piece_index == 1
+print(move.id, move.cells, transition.cleared)
+```
+
+Every state is immutable. `step` returns a new state and the resolved placement;
+it does not modify `before`. This makes it possible to examine multiple candidate
+moves from exactly the same position without accidentally advancing the real game.
+Actions are ordered by orientation then column so ties can be resolved reproducibly.
+
+The engine starts each candidate shape at row zero and drops it vertically. It
+checks every step rather than picking the lowest empty space: the latter would
+incorrectly let pieces pass through overhangs. Row clears happen simultaneously,
+then the next piece is checked for top-out.
+
+Why not use a mutable board everywhere: shared mutable state makes search branches,
+HTTP sessions, and replay easier to contaminate accidentally. Frozen dataclasses
+and tuple boards make those mistakes visible. For game-scale boards, clarity is
+more valuable than prematurely optimizing away small copies.
+
+## 3. Separate hidden state from observations
+
+The seed determines independently shuffled seven-piece bags. A bag includes every
+shape once; it is not seven independent random draws. `piece_at(seed, index)` is
+random-access and uses its own PRNG, so opening another game cannot alter a stream.
+
+Only the current piece and one preview are legitimate player inputs. The engine
+and replay know the seed to reconstruct games, but a model or search expert must
+not exploit it to look further ahead. The lower-level `place` helper returns an
+afterboard and row-clear count without reading any piece stream. Later baselines
+and the search expert can therefore evaluate a candidate safely.
+
+## 4. Reconstruct and validate a replay
+
+```python
+import json
+
+from stackcraft.replay import make_replay, replay_states
+
+artifact = make_replay(42, [move.id])
+frames = replay_states(json.loads(json.dumps(artifact)))
+assert frames == [before, transition.state]
+```
+
+The replay contains actions rather than a pile of unverified board screenshots.
+Its rules version is necessary: changing rotations or scoring must not silently
+reinterpret an old experiment. Import also checks the final summary against the
+recomputed outcome and rejects moves after terminal state.
+
+This detects inconsistent files, not malicious authorship. Someone can construct
+a different valid action sequence and summary; publication provenance and artifact
+hashes will be separate experiment records.
+
+## 5. Check the behavioural contract
+
+```sh
+uv run --locked pytest tests/test_pieces.py tests/test_engine.py tests/test_replay.py
+```
+
+These tests cover shape orientations, all empty-board placements, boundaries,
+collisions, blocked entry paths, one through four simultaneous row clears,
+score accumulation, top-out, deterministic piece streams, state immutability,
+replay round-trips and tampering. Tests for the service cover request handling
+separately. Browser inspection must additionally check readable ghost pieces,
+keyboard/button actions, restart and replay controls; engine tests cannot prove
+that an interface is usable.
+
+Next, measure random and heuristic players before adding a model. A playable
+game establishes the experimental environment; it does not yet demonstrate that
+fine-tuning helps.
+
+## Watch recorded players side by side
+
+Choose **Watch a race** to load the packaged recordings for unchanged Clef-flash,
+the Stackcraft fine-tune and the heuristic. The release's `baseline-demo.json`
+contains their actual action traces for **seed 30000**, fixed before inspecting
+results, with the same **200-piece cap**. The service reconstructs every frame
+through the authoritative replay engine. This replaces the earlier development
+Random/Heuristic example; it does not rerun model inference in your browser.
+
+At the final frame of this illustrative seed, unchanged Clef has topped out after
+23 pieces without clearing a line, the fine-tune has topped out after 82 pieces
+with 16 lines, and the heuristic has reached the 200-piece cap with 78 lines. These
+are one game's outcomes, not the aggregate result across 200 held-out seeds.
+Consult the full study report to assess overall performance and uncertainty.
+
+The boards are synchronized by placements, not decision time. Playback is
+explicitly recorded and does not imply live inference or model speed. A player
+that tops out keeps its final board visible while other recordings continue.
+Expand a recorded choice to inspect its actual selected-action probability and
+up to three alternatives; these are model outputs, not generated explanations.
+The provenance section lists the source artifact hashes. Returning to Play
+preserves the human game.
+
+## Play alongside recorded opponents
+
+The race view offers an explicit **Start live board · seed N** action. This starts
+a new human game with the recording's seed and episode cap; merely opening or
+leaving the race tab does not reset the current game. The human board is labelled
+**LIVE HUMAN**, while opponents remain labelled as recorded. Both use the Python
+engine's legal placements and the same deterministic piece stream.
+
+Each human placement advances the recorded timeline to the same piece count. A
+recording that ended earlier stays on its final frame. You can scrub the recorded
+timeline independently without changing your board; **Match my move** resynchronizes
+it. The original board DOM and session controller move between views, avoiding a
+second simulator or conflicting copies of live state.
+
+At the recording's episode cap, human placement controls stop and show **Cap
+reached**, distinct from top-out. Switching to Play retains that comparison cap
+and the same session. **Leave comparison** removes comparison mode and returns
+the existing game to ordinary play; only starting/restarting a game resets it.
+Pending moves temporarily disable view changes so a late response cannot update
+a different session. Desktop boards align side by side; narrow screens stack them
+without shrinking the human controls.

code/docs/tutorials/02-baselines.md

@@ -0,0 +1,140 @@
+# Tutorial 02 — Build a comparison before training
+
+This milestone establishes offline opponents and a replayable tournament. **Unchanged Clef now has a small real-GPU development benchmark.** These results cannot establish an advantage from fine-tuning.
+
+## Give every player the same information
+
+`players.observe(state)` creates a frozen `Observation`: board, current piece, exactly
+one next piece, legal placements, and the rules version. It omits the episode seed,
+piece index, and random generator. A seed would reveal the entire future sequence;
+giving it to a search player would invalidate the intended experiment. The tournament
+retains the seed separately so another person can replay an episode.
+
+Players implement `choose(observation) -> Decision`. A decision identifies one legal
+placement and can provide a complete probability distribution. The runner rejects
+illegal moves, missing probabilities, nonfinite probabilities, and incorrect totals.
+An exception ends that player's episode as an explicit error. A random fallback would
+hide deployment failures and turn the measured player into a different policy.
+
+## Start with two cheap opponents
+
+`RandomPlayer(seed=0)` samples uniformly from legal placements using its own random
+generator. Its seed is unrelated to the game's sequence seed. The tournament creates
+a fresh instance for each episode, so earlier game length cannot alter later choices.
+
+`HeuristicPlayer` scores every legal afterboard with these fixed, untuned weights:
+
+    value = -aggregate_height - 4*holes - bumpiness + 8*cleared_lines
+
+Aggregate height sums the ten column heights. A hole is an empty cell below a filled
+cell in its column. Bumpiness sums differences between adjacent column heights. The
+line bonus uses lines cleared by this move. All features describe the board after
+simultaneous row removal. Ties follow the engine's rotation-then-column ordering.
+These intentionally simple integer weights are a declared baseline, not an optimized
+or competitive Tetris claim. The heuristic receives the preview but does not use it;
+the later search expert will be able to search one additional placement.
+
+We call the authoritative engine's `place` helper to obtain afterboards. Calling
+`step` on the full episode state would expose the hidden future sequence, and a
+separate simulator could disagree with the game's actual rules.
+
+## Preregister the development pilot
+
+Before running any tournament, the pilot is fixed as: development seeds **0–19**,
+100-piece cap, random RNG seed 0, the weights above, and two players (random and
+heuristic). Question: does the runner produce repeatable paired games, and does the
+simple board heuristic behave plausibly? This is engineering development, not a
+held-out model study. Do not put these seeds into the final test pool or use this
+pilot to claim model improvement. Stop after 40 episodes or a runner failure.
+
+Expected artifact: `runs/baselines-development.json`. Record mean/median lines,
+score, pieces placed, cap-hit and error rates, and decision latency. Acceptance is
+valid replays and no unexplained errors; poor heuristic play is reportable, not a
+reason to secretly select nicer seeds. Starting commit is
+`53db6bd0e7f42723bc63db7ad56c4ac139a04031`, plus the uncommitted baseline
+implementation recorded in Git at integration.
+
+## Reproduce the pilot
+
+From the repository, after `uv sync --locked --group dev`:
+
+```bash
+uv run --locked python - <<'PY'
+import json
+from pathlib import Path
+from stackcraft.players import HeuristicPlayer, RandomPlayer
+from stackcraft.tournament import run_tournament
+
+result = run_tournament({'random': RandomPlayer, 'heuristic': HeuristicPlayer}, range(20), 100)
+output = Path('runs/baselines-development.json')
+output.parent.mkdir(parents=True, exist_ok=True)
+output.write_text(json.dumps(result, indent=2) + '\n')
+print(json.dumps(result['summary'], indent=2))
+PY
+```
+
+Each episode records visible observations, chosen action IDs, optional probabilities,
+the complete action replay, final outcomes, explicit errors, and decision times.
+`replay_states(episode['replay'])` reconstructs its final board independently. All
+players receive identical piece sequences for each seed, even when one dies earlier.
+
+The cap censors survival: 100 pieces means "survived at least 100", not "would die
+at 100". Report cap-hit rate alongside survival. Latency times only `choose`, not
+rendering, observation construction, engine transition, or replay validation. It
+includes Python overhead and is machine dependent. Game content is deterministic;
+latency is deliberately excluded when checking repeatability.
+
+## Development pilot result
+
+The preregistered pilot ran on 2026-10-05. All 40 episode replays matched their
+recorded final outcomes; neither player produced an error.
+
+| Player | Mean lines | Median lines | Mean score | Mean pieces | Cap-hit rate | Mean decision time |
+| --- | ---: | ---: | ---: | ---: | ---: | ---: |
+| Random | 0.10 | 0 | 10 | 26.9 | 0% | 0.0016 ms |
+| Heuristic | 35.95 | 36 | 3,900 | 100 | 100% | 0.179 ms |
+
+Every heuristic episode reached the cap. This supports using a longer development
+cap to estimate the cost of final evaluation; it does not measure unlimited survival.
+The pilot ran in approximately 3.37 seconds including independent replay checks
+and writing JSON. Timing is illustrative local CPU execution, with no GPU model.
+Artifact SHA-256:
+`ed4973c69496cdc0ebb5720e3beaae621406988a6d298233c10ab962e1c499af`.
+Regeneration preserves game outcomes but changes timing fields and therefore the
+full artifact hash.
+
+## Actual unchanged Clef development run
+
+The pinned native Clef-flash backbone and joint head ran on RTX 5090 in BF16.
+First cache the exact upstream snapshot from the repository root:
+
+```bash
+uv run --locked --extra ml hf download Cloudflare/clef-flash \
+  --revision 17f0b0ad64efb65d273590632833508766b2aae6
+```
+
+This installs the optional ML dependencies and downloads files; it does not load
+the model onto the GPU. The benchmark loader uses local files only and will fail
+on a fresh machine without this step. Once at least25GiB GPU memory is free, run:
+
+```bash
+uv run --locked --extra ml python scripts/benchmark_clef.py \
+  --output runs/clef-development-repeat.json --episodes 2 --max-pieces 30
+```
+
+Choose a new output path if it already exists. Do not stop other workloads without
+authorization. The loader explicitly trusts the pinned, hash-checked upstream
+Python implementation; see Tutorial04 for that trust boundary and memory checks.
+
+On development seeds0–1 (30-piece cap), Clef averaged0lines and27.5pieces;
+the heuristic averaged9lines and reached30pieces both times. No player errored.
+Clef's55decisions averaged144ms (p95 241ms), after a separate warmup.
+These two episodes establish feasibility, not statistical performance. Raw probabilities,
+input-token counts, pinned revisions and timing are retained in
+`runs/clef-development-v1.json`. Reference PyTorch attention kernels were used;
+faster optional kernels were not installed, so latency is implementation-specific.
+The GLM service was temporarily stopped under user authorization and restored;
+its in-container health endpoint returned `{"status":"ok"}`.
+
+Use fresh held-out episode seeds for the final study. A large neural model can lose
+to a few lines of board arithmetic; the report must make that outcome visible.

code/docs/tutorials/03-data.md

@@ -0,0 +1,189 @@
+# Tutorial 03 — Teach from search without leaking future pieces
+
+The dataset records recommendations from a bounded search expert. These are
+synthetic labels from a specified algorithm, not human labels or globally optimal
+Tetris moves. The expert sees the current piece and one preview, exactly as other
+players do.
+
+## Write the experiment before collecting examples
+
+Starting commit: `412be98cf90bc7e3e60cd39d8bf9d479bcf65d27`, plus the expert/data
+implementation committed at integration. Preregistered pilot: training seeds
+10000–10023, validation seeds 20000–20005, at most 40 pieces per episode. Cycle
+behavior policies random, heuristic, expert by episode index within each split.
+Label every visited nonterminal state with the expert. Generate the pilot twice
+and require identical records, manifest and JSONL hashes. Stop each job at 120
+seconds or the first audit failure. Output the first bundle under `data/pilot-v1`.
+
+Reserve seeds 30000–30199 for final evaluation; generate no trajectories from
+them during dataset work. Development seeds 0–19 and 1000 are excluded from all
+dataset pools. A separate development comparison uses only seeds 0–4 and a
+100-piece cap, with heuristic and expert. Its purpose is to inspect search behavior
+and cost, not measure neural-model improvement. Do not tune weights using these
+results. Expected comparison artifact: `runs/expert-development.json`.
+
+## Search only information available to the player
+
+For each legal current placement, the expert clears completed rows and enumerates
+all legal placements of the visible preview. It scores:
+
+    8 * current_lines + max(preview_afterboard_value)
+
+The afterboard value is the same untuned `-height -4*holes -bumpiness +8*lines`
+heuristic from Tutorial 02. If the preview has no legal placement, its value is
+-10000. This is a two-placement search with no pruning. Equal values select the
+first engine action in rotation/column order.
+
+The search constructs a synthetic state with dummy seed/index only to enumerate
+geometry. It calls `place`, never `step`, so it cannot query the piece after the
+preview. Tests make sequence lookup fail during search to enforce that boundary.
+Searching more known future pieces would give the teacher information unavailable
+to the model; it would solve a different task. Long-horizon search is also more
+expensive and is unnecessary for this first imitation-learning experiment.
+
+## Collect recovery states as well as expert play
+
+Only collecting expert trajectories produces many tidy boards and few recovery
+situations. Cycling random, greedy heuristic, and expert behavior visits different
+board conditions. Every behavior's state receives the same expert label. The
+random policy has its own RNG, seeded with episode seed plus one million; this
+controls collection reproducibility without exposing any seed to the teacher.
+
+Each row retains the raw visible observation, action values for every legal move,
+chosen move, behavior policy, episode/turn, rules, teacher revision and source
+commit. Provenance fields are for auditing; training inputs must use only
+`observation`. In particular, never serialize the whole dataset row as model state.
+
+## Split episodes first, then remove duplicate observations
+
+Seed pools are disjoint before generation. All retained states from one episode
+remain in one split. Exact visible observations can still repeat across episodes,
+especially empty boards. Deduplication hashes the full observation after replacing
+board colors with occupied/empty cells, because colors do not affect game dynamics.
+Current piece, preview, legal geometry, and rules remain in that hash.
+
+Process training before validation and keep the first unique observation. Remove
+later duplicates within either split and across splits, recording both counts.
+Require duplicate teacher labels and action values to agree; a conflict stops the
+run. This deterministic policy sacrifices some validation rows rather than letting
+identical positions inflate reported generalization. Full episode IDs and seed
+reservations are checked separately from observation hashes.
+
+## Reproduce and audit
+
+```python
+from pathlib import Path
+from stackcraft.data import DatasetConfig, audit_dataset, generate_dataset, write_dataset
+from stackcraft.provenance import source_identity
+
+config = DatasetConfig()
+identity = source_identity(Path.cwd())
+commit = identity["source_commit"] + ("+working-tree" if identity["source_dirty"] else "")
+output = Path("data/pilot-v1")
+assert not output.exists(), "Choose a new output directory"
+bundle = generate_dataset(config, source_commit=commit)
+assert bundle == generate_dataset(config, source_commit=bundle.manifest["source_commit"])
+print(audit_dataset(bundle.records, bundle.manifest))
+write_dataset(bundle, output)
+```
+
+Run with `uv run --locked python` from the repository root or the public bundle's
+`code/` directory. Source identity uses that exact Git root or verifies the bundled
+source manifest, so private Git access is not required. This creates a new pilot
+with the current source identity, not necessarily the original study's bytes.
+The writer refuses existing artifact files so a new experiment cannot silently
+replace recorded evidence.
+The manifest stores the complete configuration, seed reservations, teacher formula
+revision, collection and exclusion counts, and SHA-256 hashes of canonical JSONL.
+Auditing reconstructs legal placements and verifies label argmax with the tie rule,
+finite values, provenance, duplicate exclusion, and absence of hidden observation
+fields. It does not prove that the teacher is optimal. Evaluation must still test
+complete games, not just how accurately a model copies these labels.
+
+The manifest also fingerprints `engine.py`, `pieces.py`, `schema.py`,
+`players/__init__.py`, `expert.py`, and `data.py`. During development, append
+`+working-tree` to the commit identifier when source edits are not committed.
+Before study training, freeze the dataset against its committed generator source.
+Preserve those exact bytes through publication; later documentation or packaging
+commits are not reasons to regenerate the training dataset. A source hash records
+what ran; it must not imply that an earlier commit includes later code.
+
+## Pilot observations
+
+The preregistered 2026-10-05 pilot collected 833 training and 217 validation
+positions. Six repeated training positions and two validation positions already
+present in training were removed, leaving **827 training / 215 validation** rows.
+Both complete generation runs produced identical bundles. Each took about 9.05
+seconds; a separate structural audit took 0.49 seconds on the development machine.
+
+The historical pilot's JSONL hashes are:
+
+- Train: `bccf62673fb3160ac957650d400edcd6efb28e56b5e212940aba3281fb4bb82d`.
+- Validation: `e6e87cad6aea503ef41894d7aa53cd80d635d540c7d2f2942f79a033692cce76`.
+
+These artifacts used the original pilot source recorded in their manifest. A later
+change allowed the explicit `+working-tree` commit suffix; that change does not
+retroactively change which code produced this pilot. A final committed regeneration
+will have different provenance hashes even when game examples remain the same.
+
+For an additional label check, an independently written nested loop recomputed
+every action value on 16 positions: first and highest-stack examples from each of
+the six split/behavior groups, then further highest-stack positions to reach 16.
+The sample included height-20 recovery boards. All values and chosen labels
+matched. Evidence is `runs/data-pilot-independent-audit.json`. This checks the
+implementation against the declared search formula, not optimality of that formula.
+
+The five-seed development tournament produced mean lines 37.8 for the heuristic
+and 38.6 for search; both reached the 100-piece cap in all five games with no
+errors. Mean search decision time was 8.33 ms versus 0.183 ms for the heuristic.
+The collection and comparison jobs ran concurrently on CPU, so these times are
+illustrative, not isolated performance benchmarks. Five capped games are insufficient
+to establish broad superiority. No neural model was evaluated.
+
+## Reproduce from the public source bundle without private Git access
+
+The model release includes `code/` with source, a lockfile and a source manifest.
+From that directory, `uv sync --locked` installs the game/data tools. The regular
+`stackcraft generate-data` command records the bundle's source identity and flags
+modified source files. Its provenance will therefore differ from the original
+M3 commit even when generator logic is unchanged.
+
+The probe and full-training commands in later tutorials use `data/study-v1`.
+For a fresh reproduction, the command below creates that directory with the exact
+original study bytes. Alternatively, place the released dataset's `train.jsonl`,
+`validation.jsonl` and `manifest.json` in that directory and verify them using the
+release audit. Do not substitute the newly generated pilot above for the study.
+
+To reproduce the original study bytes exactly, first verify that every generator
+source file matches the original dataset manifest, then use its recorded commit
+in the generator API. This avoids falsely stamping changed code with an old commit:
+
+```bash
+uv run --locked python - <<'PY'
+import hashlib
+import json
+from pathlib import Path
+from stackcraft.data import DatasetConfig, generate_dataset, write_dataset
+
+manifest = json.loads(Path('reports/dataset-manifest.json').read_text())
+for name, expected in manifest['source_hashes'].items():
+    path = Path('src/stackcraft') / name
+    assert hashlib.sha256(path.read_bytes()).hexdigest() == expected, name
+output = Path('data/study-v1')
+assert not output.exists(), 'Choose a new output directory'
+bundle = generate_dataset(DatasetConfig(), source_commit=manifest['source_commit'])
+assert bundle.manifest == manifest, 'Generated manifest differs from the frozen study'
+write_dataset(bundle, output)
+for split in ('train', 'validation'):
+    actual = hashlib.sha256((output / f'{split}.jsonl').read_bytes()).hexdigest()
+    assert actual == manifest['splits'][split]['sha256'], split
+print('Both original split hashes match')
+PY
+```
+
+If `data/study-v1` already exists, retain and audit it rather than overwrite it.
+For a separate regeneration, choose a new output directory and supply that path
+with `--dataset` in subsequent probe, training and evaluation commands. Use only
+the audited downloaded dataset or the exact hash-matching reconstruction to
+reproduce study training. If any source hash fails, investigate or generate a
+clearly new dataset; do not suppress the check or reuse the original study's identity.

code/docs/tutorials/04-gpu-feasibility.md

@@ -0,0 +1,300 @@
+# Tutorial 04 — Prove training and reload before running an experiment
+
+This milestone asks a narrow engineering question: can the real pinned Clef-flash
+model take gradient steps on this GPU, save all learned parameters, and reproduce
+its probabilities in a fresh process? It does not ask whether the model plays
+better. The latter requires complete games on the held-out sequences in Milestone 5.
+
+**The bounded real-weight training and fresh-process reload gate passed.** Both
+head-only and LoRA-plus-head artifacts reproduced their reference probabilities
+exactly. The first LoRA reload exposed a saved-configuration compatibility issue;
+the corrected loader and successful retry are documented below. This establishes
+local training feasibility, not improved game performance.
+
+## Start from the native decision model
+
+The base is `Cloudflare/clef-flash`, revision
+`17f0b0ad64efb65d273590632833508766b2aae6`. The local loader verifies the pinned
+`joint_schema_model.py` source hash and loads an explicitly resolved snapshot.
+It requires `trust_pinned_code=True`: pinning and inspecting Python source controls
+which code executes; it does not turn that code into a sandbox.
+
+An observation becomes one native choice question containing every legal
+placement. The answer is a distribution over action IDs, not a generated command
+or natural-language explanation. `encode_observation` checks the complete token
+budget before native encoding, because silently truncating a board would change
+the task. Training uses only the visible board, current piece, one preview and
+legal placements. Dataset seed and episode metadata remain outside the input.
+
+The native encoder sorts option IDs lexicographically. `decision_loss` locates the
+teacher's action in `encoded.questions[0].option_ids`; it must not reuse the
+engine's rotation/column index as a target index. Both orders contain the same
+legal moves, but their order can differ.
+
+Do not train through `systemone()` or `ClefPlayer.choose()`: those are inference
+paths. The probe calls `native.collate_records` and then `model(batch)` with
+normal autograd enabled. `choose()` is appropriate for the before/after reference
+probabilities, where gradients are unnecessary.
+
+## Keep the backbone small in memory and the head stable
+
+`src/stackcraft/training.py` implements two bounded configurations:
+
+| Configuration | Updated parameters | Purpose |
+| --- | --- | --- |
+| Head only | Native joint decision head | Isolate head training and checkpoint handling before a backbone backward pass. |
+| Rank-4 LoRA plus head | Small added text-layer matrices and the native head | Check whether the task can adapt both text representations and decision scoring. |
+
+The backbone remains BF16. The native decision head is converted to FP32, and
+`FP32DecisionHead` disables autocast inside the head. Its floating inputs are
+converted to FP32 while token IDs and masks retain their original types. This
+keeps the trainable scoring operations in full precision without converting the
+whole multi-billion-parameter backbone.
+
+The head reads selected rows of the output vocabulary embedding. Converting the
+entire vocabulary matrix to FP32 first creates a large temporary allocation
+(roughly 3.79 GiB for this release). `GatheredFloat32Embedding` instead implements
+`weight[indices].float()`: select the needed rows first, then cast. This preserves
+the actual native head computation and autograd connections. A tiny actual-native-
+head test compares outputs and gradients with the full-cast reference exactly.
+That test checks the optimization, not full-model training feasibility.
+
+LoRA targets are full module paths under the text transformer layers. They include
+both ordinary attention projections and Qwen3.5's linear-attention projections,
+as well as the MLP projections. Matching only suffixes such as `q_proj` could
+accidentally select the vision encoder; matching only ordinary attention would
+miss the hybrid backbone. The vision tower, vocabulary output layer and unrelated
+modules are excluded. Original backbone parameters are frozen. The probe uses
+rank 4, alpha 8, no LoRA dropout and no trained backbone biases.
+
+Non-reentrant gradient checkpointing recomputes intermediate activations during
+backward instead of retaining all of them. This trades time for memory while
+preserving gradients through frozen parts of the backbone into LoRA matrices.
+A tiny actual Qwen3.5 hybrid-backbone test checks nonzero LoRA gradients in ordinary
+attention, linear attention and MLP layers. These are stronger plumbing checks
+than testing a stand-in linear model alone, but still do not establish the real
+9B GPU memory requirement.
+
+We start with BF16 rather than immediately adding 4-bit quantized training. The
+native model has a custom head and loader; another quantization layer would add
+an unverified compatibility dependency. If BF16 fails, record the failure and
+make a bounded next decision rather than silently changing the experiment.
+
+## Prepare before borrowing the GPU
+
+Run these commands from the repository root or the public bundle's `code/`
+directory. Install the ML tools and cache the pinned release before testing:
+
+```bash
+uv sync --locked --extra ml --group dev
+uv run --locked --extra ml hf download Cloudflare/clef-flash \
+  --revision 17f0b0ad64efb65d273590632833508766b2aae6
+```
+
+Downloading only populates the cache; it does not load GPU weights. It can run
+while other GPU services remain available. The actual native-head tests need
+this cached source. Explicitly enable the native tokenizer/encoder check too:
+
+```bash
+STACKCRAFT_TEST_NATIVE_ENCODING=1 uv run --locked --extra ml \
+  pytest tests/test_training.py tests/test_clef.py
+```
+
+These checks use CPU fixtures and the real tokenizer/source; they do not load
+the full backbone or establish GPU feasibility. Inspect the test summary: a
+skipped test is not a passed native-model test.
+
+The training probe expects the audited `data/study-v1` bundle established by
+Tutorial03's exact-study reconstruction or a verified dataset download. If you
+used a different directory, pass that same path with `--dataset` below.
+It validates the train/validation bundle, then uses only the first four training
+positions. It does not sample held-out test seeds. Record the current source
+commit and any uncommitted probe changes in `record.md` before running.
+
+This workstation normally runs a local GLM Docker service. The user explicitly
+authorized temporarily stopping that service and restoring it after these
+Stackcraft experiments. `scripts/gpu_session.py` is specific to that approved
+service; it is not a generic instruction to stop another machine's workloads.
+It first requires the configured container to be running, then stops it, runs a
+bounded child job, and attempts restoration during cleanup. The training script
+itself never stops services. It refuses to load unless CUDA is available and at
+least **25 GiB is free**. Free-memory admission is a precondition, not a guarantee
+that backward will fit.
+
+## Run the bounded real-weight probe
+
+The initial budget is two configurations and at most 30 minutes of child-job
+time. The commands below allocate 20 minutes to the training probe and 10 minutes
+to the separate reload check. Choose fresh output and session-record paths on a
+retry; neither existing evidence nor checkpoints should be overwritten.
+
+```bash
+uv run --locked --extra ml python scripts/gpu_session.py \
+  --timeout 1200 --record runs/gpu-training-probe-v1.json -- \
+  uv run --locked --extra ml python scripts/probe_clef_training.py \
+  --dataset data/study-v1 --output runs/clef-training-probe-v1
+```
+
+The probe first records unchanged native probabilities. It measures the initial
+probability drift introduced by moving the head to FP32, before training; a
+precision change must not be mistaken for a learned improvement. It then runs
+three head-only steps. After saving that checkpoint, it releases the model and
+loads a fresh unchanged base for five LoRA-plus-head steps. The LoRA experiment
+therefore does not inherit the head-only warm-up.
+
+Both configurations use batch size one, AdamW with learning rate `1e-5`, norm
+clipping at 1.0, and this loss:
+
+    smoothed_cross_entropy(label_smoothing=0.05)
+      + 0.1 * sum_over_options((probability - one_hot_teacher_label)**2)
+
+The cross-entropy term learns the expert action. Smoothing avoids assigning the
+entire training target to one action. The Brier term also penalizes the predicted
+probability distribution's distance from the teacher target. These fixed choices
+are a probe configuration, not evidence of calibrated confidence or optimal
+hyperparameters.
+
+For every step, the probe checks finite loss and gradients and records nonzero
+head/LoRA gradient sums, tokens, elapsed time, and CUDA peak allocated/reserved
+bytes. Before/after parameter hashes check that intended parameters changed and
+frozen parameters did not. Hashing the entire frozen backbone costs time but
+checks something that `requires_grad=False` alone cannot prove: what bytes actually
+changed during this run.
+
+Inspect `runs/clef-training-probe-v1/report.json` and the session record. A timeout,
+CUDA error, absent gradient or failed hash check is a failed gate. A report left at
+`running` after forced termination is incomplete evidence, even if some checkpoint
+files exist. Do not start long training merely because loss fell on four examples.
+
+## Save the head as well as the adapter
+
+A LoRA checkpoint has this structure:
+
+```text
+checkpoint/
+  joint_head.safetensors
+  adapter/
+    adapter_config.json
+    adapter_model.safetensors
+  training_config.json
+  reference.json
+```
+
+The head is an independently trained part of Clef; saving only the PEFT adapter
+would omit learned parameters. `joint_head.safetensors` stores FP32 native head
+keys without wrapper-specific prefixes. The adapter stores only the added LoRA
+weights, not another copy of the frozen base. Metadata identifies the base
+revision, native source hash, input encoding, head format, LoRA settings and
+teacher rows. The loader checks this contract, head shapes and dtypes, and actual
+saved adapter configuration before restoring weights.
+
+The head-only probe writes `head-checkpoint/` without an adapter. It is diagnostic
+output, not a selected release model.
+
+## Require a separate fresh-process reload
+
+Only after the first probe succeeds, run:
+
+```bash
+uv run --locked --extra ml python scripts/gpu_session.py \
+  --timeout 600 --record runs/gpu-training-reload-v1.json -- \
+  uv run --locked --extra ml python scripts/probe_clef_training.py \
+  --dataset data/study-v1 --output runs/clef-training-reload-v1 \
+  --reload runs/clef-training-probe-v1/checkpoint
+```
+
+This starts another Python process, loads the unchanged pinned base, restores both
+adapter and head, and evaluates the same four training observations. Require the
+same option IDs and a **maximum absolute probability difference of at most
+`1e-4`** across all recorded options. The tolerance was declared before the run.
+Compare unrounded probabilities; rounded display values can conceal a mismatch.
+
+A same-process test could accidentally reuse trained parameters that were never
+saved. The fresh process tests the actual inference artifact. A passing reload
+establishes serialization fidelity on these references, not general game skill
+or correctness on every possible input.
+
+## Restore service and record the limits
+
+Inspect both `restored_running` and `restored_healthy` after success and failure.
+The wrapper checks `/health` inside the restored container and allows up to 120
+seconds for readiness, retrying transient timeouts and malformed startup responses.
+It does not query the unrelated service on host port 8080. A running process alone
+would not establish readiness. Nested cleanup ensures a child-termination error
+still reaches restoration; repeated ordinary interrupts are ignored during that
+cleanup. Preserve the wrapper record, probe reports and console logs, including
+errors. Mocked tests exercise these recovery paths without touching Docker.
+
+Process cleanup cannot guarantee recovery after `SIGKILL`, host power loss or a
+Docker daemon failure. If the wrapper was forcibly terminated, inspect the exact
+approved container and any remaining job before acting. Restore the existing
+service only after the experiment has released GPU memory; do not start another
+probe simply because the last terminal stopped printing output.
+
+The earlier M2 real-weight development pilot is useful context: on this RTX 5090,
+it recorded 55 unchanged-Clef decisions at a mean of about **0.144 seconds per
+decision**, with **19,686,539,776 bytes** peak CUDA allocation (about 19.7 GB,
+18.3 GiB). The benchmark script took 12.60 seconds; the stop/job/restore wrapper
+interval was about 14.20 seconds and recorded successful restoration. These are
+inference measurements on two short development games, not training memory or
+held-out quality results. Sources are `runs/clef-development-v1.json` and
+`runs/gpu-baseline-session.json`.
+
+## Measured training probe and the first reload failure
+
+The real-weight probe passed on 2026-10-05 using the RTX 5090 and Torch
+`2.14.1+cu130`. Evidence is `runs/probe-v1/report.json`; the actual run directory
+differs from the fresh reproduction paths shown above. It used training positions
+`seed-10000-turn-0` through `seed-10000-turn-3`, with 1,302–2,252 encoded tokens.
+
+| Measurement | Head-only probe | LoRA-plus-head probe |
+| --- | ---: | ---: |
+| Optimization steps | 3 | 5 |
+| Observed step times | 0.154–0.328 s | 0.670–1.322 s |
+| Peak allocated CUDA bytes | 21,323,760,640 | 23,180,389,888 |
+| Peak reserved CUDA bytes | 21,541,945,344 | 23,595,057,152 |
+| Intended parameter changes | Verified | Verified |
+| Frozen parameter hashes | Unchanged | Unchanged |
+
+All reported losses and gradients were finite, with nonzero gradients in the
+intended groups. Total probe time was **51.81 seconds**, including model reload,
+parameter hashing and checkpoint work. This is not an estimate of a full epoch:
+only four short training positions were exercised. Peak reserved memory is the
+PyTorch allocator's reservation, not the same quantity as all memory reported by
+`nvidia-smi`.
+
+The FP32 head changed initial probabilities by at most **0.00074412** before any
+training. That is a precision effect relative to the original BF16 head, not a
+failed serialization comparison. The `1e-4` reload threshold compares the saved
+trained FP32-head model with its own fresh reload.
+
+The first fresh reload, `runs/probe-reload-v1/report.json`, failed after 4.15
+seconds because the saved adapter configuration differed from our metadata. PEFT
+automatically shortened **248 full target paths to 12 module suffixes**. The strict
+loader correctly refused a mismatch; the failure does not by itself mean the
+weight tensors are corrupt. Accepting suffixes without checking what they match
+could attach an adapter to unintended modules. The correction must expand saved
+target selectors against the actual pinned backbone and require exactly the
+intended full target set, rejecting any extra destinations. This is why fresh
+reload is a milestone gate rather than a final packaging chore.
+
+The corrected loader resolves saved selectors against the pinned backbone and
+requires the exact intended destinations. The retry preserved the original
+checkpoint and failed report; it changed validation of equivalent target selectors,
+not the trained weights. A regression test covers target shortening and rejects
+selectors that also match unintended modules.
+
+Both independent fresh-process checks then passed:
+
+| Artifact | Report | Maximum probability difference | Process time |
+| --- | --- | ---: | ---: |
+| Head only | `runs/probe-head-reload-v1/report.json` | 0.0 | 5.44 s |
+| LoRA plus head | `runs/probe-reload-v2/report.json` | 0.0 | 5.65 s |
+
+The LoRA retry used source commit
+`f7be7ceee9c38566dfebad0ebf5f1c04958faee3`. The dataset manifest SHA-256 was
+`aeddcfc1ea5390f12122d2e786c1e2030dcc97d3790b6d7523432548198b1f94` throughout.
+The approved GLM service was restored and passed its health check after these
+probes. **M4 is complete.** Milestone 5 can now train a selected checkpoint and
+measure complete games; the four-position probe does not demonstrate that the
+trained policy wins or generalizes.

code/docs/tutorials/05-evaluation.md

@@ -0,0 +1,281 @@
+# Tutorial 05 — Select on validation, then measure complete games
+
+Training, validation selection, selected-checkpoint reload and the held-out game
+evaluation are complete. Epoch 02 cleared **16.81 lines per game**, versus **0.07**
+for native Clef and **76.53** for the cheap heuristic on all 200 reserved seeds.
+This tutorial gives the frozen procedure and explains the measured outcome. See
+[the final study](../../reports/final-study.md) for full results and limitations,
+and [the compact JSON](../../reports/final-summary.json) for exact metrics and hashes.
+The experiment results are complete; release verification is tracked separately.
+
+## Separate learning, selection and final testing
+
+The two candidate checkpoints are epochs 01 and 02 of the same seed-42 LoRA run.
+Their training configuration and dataset are fixed before comparison. Evaluate
+both on **all 215 validation positions** and select the lowest finite mean target
+negative log likelihood (NLL). An exact tie chooses the earlier epoch. A candidate
+with inference errors, missing probability distributions, or nonfinite NLL is
+ineligible. If both are ineligible, stop before opening the test set.
+
+NLL measures how much probability the model assigns to the teacher's recommended
+placement. Selecting on a smooth probability score can distinguish checkpoints
+even when their top choices tie. Teacher agreement and Brier score remain useful
+diagnostics, but cannot override the preregistered rule after results are visible.
+
+Copying the teacher is not the same as playing well. Each small mistake changes
+the next board; the model eventually encounters states different from its training
+examples. The teacher itself uses a limited search horizon and a heuristic value
+function. Final evaluation must therefore play complete games on unseen sequences.
+
+## Train exactly the preregistered candidates
+
+Pass the real GPU feasibility and fresh-process reload gates in Tutorial 04 first.
+Use the exact 827/215-row dataset from Tutorial 03. The training runner rejects a
+substituted dataset even when its labels look similar: hashes bind the experiment
+to specific bytes and provenance. Use a fresh run directory when reproducing.
+
+```bash
+uv sync --locked --extra ml --group dev
+uv run --locked --extra ml python scripts/train_clef.py \
+  --dataset data/study-v1 --output runs/study-v1 \
+  --mode lora --epochs 2 --learning-rate 1e-5 \
+  --accumulation 8 --max-length 4096
+```
+
+This command needs a free GPU. On the original workstation only, run it through
+the authorized stop/restore wrapper from Tutorial 04 with a 3,600-second timeout.
+The script uses seed 42, batch size one, rank-4/alpha-8 LoRA with zero dropout,
+AdamW weight decay 0.01, gradient norm clipping at 1.0, and the fixed smoothed
+cross-entropy plus Brier loss from Tutorial 04. The backbone stays BF16 and frozen;
+LoRA matrices and the native FP32 head learn. Each epoch visits all training rows
+in a recorded deterministic shuffled order. Validation rows never train the model.
+
+Accumulating eight single-example gradients fits the memory budget while averaging
+over several boards per optimizer step. The final group has only three rows and
+is divided by three, not eight. Two complete epochs give two declared candidates
+without an open-ended search. Neither falling loss nor a promising demo authorizes
+extra epochs after the test set has been opened. The script defaults to one epoch,
+so the explicit `--epochs 2` above is essential for reproducing this study.
+
+The completed run processed 827 examples and 104 optimizer steps in each epoch:
+
+| Epoch | Mean training loss | Time |
+| --- | ---: | ---: |
+| 01 | 2.577967 | 742.48 s |
+| 02 | 1.966718 | 744.66 s |
+
+Total training time including hashes and checkpoint work was 1,511.25 seconds
+(about 25.2 minutes). Peak CUDA allocation was 23.23 GB, or about 21.64 GiB.
+The head and LoRA parameters changed, while all frozen parameter hashes remained
+unchanged. These are training measurements, not held-out performance. See
+[the training report](../../reports/study-training.json),
+[the original launch source](../../reports/training-launch-source.json), and
+[the archived preregistration](../../reports/study-preregistration.md).
+
+## Prepare checkpoint metadata before freezing it
+
+PEFT can write a generic adapter README with placeholders and a local cache path.
+Keep raw training outputs immutable. Prepare candidate copies before validation:
+
+```bash
+uv run --locked --extra ml python scripts/prepare_checkpoint.py \
+  --source runs/study-v1/epoch-01 --output checkpoints/candidates/epoch-01
+uv run --locked --extra ml python scripts/prepare_checkpoint.py \
+  --source runs/study-v1/epoch-02 --output checkpoints/candidates/epoch-02
+```
+
+The script replaces only `adapter/README.md`, compares every other file byte for
+byte, and saves a sibling preparation record. It does not alter learned weights
+or training settings. Validate and select these exact copies. Once selected,
+even a README edit would break the frozen checkpoint file mapping. See Tutorial 06
+for how release documentation stays outside the checkpoint directory.
+
+## Generate validation evidence
+
+These commands load real GPU models. Use the memory admission and service-restoration
+procedure from Tutorial 04. The evaluator never downloads weights implicitly or
+stops another workload. Replace paths if your run directory differs.
+
+```sh
+uv run --locked --extra ml python scripts/evaluate_clef.py positions \
+  --dataset data/study-v1 --checkpoint checkpoints/candidates/epoch-01 \
+  --players base base-fp32 trained --output runs/validation-epoch-01
+
+uv run --locked --extra ml python scripts/evaluate_clef.py positions \
+  --dataset data/study-v1 --checkpoint checkpoints/candidates/epoch-02 \
+  --players trained --output runs/validation-epoch-02
+```
+
+Every validation row gets an unrounded probability record or an explicit error.
+The position report binds those records to checkpoint file hashes and the dataset
+manifest. Aggregate NLL and Brier are unavailable if any probability distribution
+is missing; a successful subset cannot masquerade as a complete evaluation.
+
+The first command also measures two unchanged-model references. `base` retains
+the original native BF16 head. `base-fp32` keeps those same learned weights but
+uses our FP32 head wrapper. Training uses that wrapper, so the extra comparison
+shows whether a change comes from numerical precision rather than learning.
+The primary comparison remains trained versus native base. All three share the
+same complete observation encoding and BF16 backbone.
+
+## Freeze the choice before running test episodes
+
+```sh
+uv run --locked --extra ml python scripts/select_checkpoint.py \
+  --dataset data/study-v1 \
+  --candidate01 checkpoints/candidates/epoch-01 runs/validation-epoch-01/report.json \
+  --candidate02 checkpoints/candidates/epoch-02 runs/validation-epoch-02/report.json \
+  --output runs/selection-v1
+```
+
+The selector independently recomputes metrics from every raw prediction against
+the audited validation rows. It verifies actual checkpoint bytes, training seed
+and configuration, epoch identity, common dataset and evaluation provenance. It
+accepts exactly the two preregistered candidates. It then copies both validation
+reports, prediction files and checkpoint metadata into a self-contained evidence
+directory. The large model weights remain in their checkpoint directories and
+are referenced by hashes.
+
+`selection.json` records the selected epoch, decision rule, both candidates,
+their eligibility, validation metrics, and the frozen test protocol. The runner
+rechecks that the selected epoch actually wins the declared rule. Manual editing
+of a label such as "best model" is not sufficient to unlock final evaluation.
+Use a new output directory for a new selection attempt; existing evidence is not
+silently overwritten.
+
+## Inspect selection and reload the selected artifact
+
+The measured validation results used all 215 positions for every policy, with
+zero errors and complete probability distributions:
+
+| Policy | Teacher agreement | Mean target NLL | Mean Brier score |
+| --- | ---: | ---: | ---: |
+| Native base | 21/215 (9.77%) | 2.952702 | 0.923173 |
+| Unchanged FP32 head | 22/215 (10.23%) | 2.952393 | 0.923102 |
+| Epoch 01 | 89/215 (41.40%) | 1.860870 | 0.722190 |
+| Epoch 02 | 92/215 (42.79%) | 1.775923 | 0.708980 |
+
+The declared NLL rule selected epoch 02. The saved
+[validation summary](../../reports/validation-summary.json) identifies its complete
+file hashes and the selection hash. Teacher agreement improved on these positions;
+that still does not establish better complete-game play.
+
+Before consuming test seeds, reload the selected artifact in another process:
+
+```bash
+uv run --locked --extra ml python scripts/probe_clef_training.py \
+  --dataset data/study-v1 --reload checkpoints/candidates/epoch-02 \
+  --output runs/selected-reload-v1
+```
+
+This command also needs the GPU admission/restoration procedure. In this study it
+reproduced all four training-position reference distributions with **0.0 maximum
+absolute difference**, below the predeclared `1e-4` tolerance. See
+[the reload report](../../reports/selected-checkpoint-reload.json).
+The references use training positions, so this check does not consume test games.
+
+## Run the paired test once
+
+Use the selected checkpoint path from the evidence, not whichever epoch you hoped
+would win. The reserved pool is all **200 seeds, 30000–30199**, with a **200-piece
+cap**. Each player gets the same piece sequence for a given seed. There are five
+players: native base, FP32-head base ablation, selected trained model, random and
+the fixed cheap heuristic.
+
+```sh
+uv run --locked --extra ml python scripts/evaluate_clef.py tournament \
+  --checkpoint SELECTED_CHECKPOINT \
+  --seeds 30000:30200 --max-pieces 200 --final-test \
+  --selection-file runs/selection-v1/selection.json \
+  --output runs/final-evaluation
+```
+
+`--final-test` explicitly acknowledges that these held-out seeds are being consumed.
+Without it, any overlap with the reserved pool is rejected before model loading.
+The cap and full seed pool cannot silently shrink to finish sooner. The initial
+development timing estimate permits hours in the worst case; short early deaths
+can make actual evaluation much faster.
+
+Each completed episode is saved atomically, with actions, probabilities, runtime
+configuration, errors and a replay. To continue an interrupted run, repeat the same
+command with `--resume`. The runner checks source/dependency hashes, checkpoint
+identity, selection, and saved replay outcomes. It skips completed players without
+loading their models again. Recorded errors remain part of the experiment, rather
+than being retried until a nicer result appears.
+
+## Read the report without hiding failures
+
+The primary outcome is lines cleared. Score and pieces survived are secondary.
+The report includes means, medians, cap-hit rate, failure counts, latency and input
+lengths. The [hardware snapshot](../../reports/evaluation-hardware.json) records
+the RTX 5090, driver, CPU, Python and inference settings observed during this run.
+Compare latency only with that environment in mind; the snapshot does not measure
+energy consumption or continuous GPU clock behavior. A game reaching 200 pieces survived **at least** 200; its eventual death
+was not observed. Always report cap-hit rates with survival statistics.
+
+For the primary reliability-adjusted analysis, any errored episode receives zero
+lines, score and pieces. Its measured partial outcome remains visible separately.
+Dropping failures would bias the result toward easier successful games. Both base
+and trained must have zero episode errors for the default positive-signal flag.
+
+For each seed, subtract base lines from trained lines, then bootstrap these paired
+differences 10,000 times with RNG seed 2026. Report the mean and percentile 95%
+interval. Resampling complete episode pairs respects the fact that moves within
+one game are correlated. Treating every move as independent would exaggerate the
+amount of evidence.
+
+A lower interval bound above zero supports improved mean lines for this checkpoint
+and seed distribution. It does not establish competitive Tetris ability, training
+seed stability, or superiority over the heuristic. Report the trained-versus-
+heuristic comparison even if it is embarrassing. A reproducible negative result
+with clear limitations is a stronger portfolio artifact than a selective win.
+
+After test results are opened, do not use them to choose between epochs or change
+the observation format. A subsequent experiment needs a new preregistered study
+and fresh held-out sequences. The current report should preserve failures and
+limitations alongside the playable recorded comparison.
+
+
+## Completed outcome and what it teaches
+
+All five players completed the 200 paired seeds at the declared 200-piece cap:
+
+| Player | Mean lines | Median lines | Mean pieces | Cap hits |
+| --- | ---: | ---: | ---: | ---: |
+| Native base | 0.070 | 0 | 26.020 | 0/200 |
+| Unchanged FP32 head | 0.105 | 0 | 26.000 | 0/200 |
+| Selected epoch 02 | 16.810 | 16 | 83.565 | 0/200 |
+| Random | 0.140 | 0 | 26.645 | 0/200 |
+| Fixed heuristic | 76.530 | 77 | 200.000 | 200/200 |
+
+There were zero inference errors and zero invalid decisions. The paired mean line
+gain over native base was **16.74 [15.74, 17.77]** (95% percentile bootstrap,
+10,000 replicates, seed 2026). Against the unchanged FP32 head, the gain was
+**16.705 [15.705, 17.74]**, so the observed improvement cannot be attributed to head
+precision alone. Against the heuristic the difference was
+**−59.72 [−60.805, −58.619875]**. Both the improvement and this large shortfall belong
+in the result. The heuristic's eventual survival remains unknown because every
+one of its games reached the cap.
+
+The selected model's mean decision latency was **206.8 ms**, compared with the
+heuristic's **0.1985 ms**, about 1,042 times slower on these measured workloads.
+Policies visited different states, and neural inference used the GPU while the
+heuristic used the CPU. This is an operational comparison, not an isolated
+same-input speed benchmark. The final wrapper took 85.1 minutes, including model
+loading, report writing and service restoration. Energy and monetary costs were
+not measured. The simple heuristic remains the practical choice for this game.
+
+An independent CPU audit replayed all 1,000 saved episodes and independently
+recomputed every paired interval. See [its results](../../reports/final-audit.json).
+The learned model passes the narrow improvement test over its unchanged base;
+that does not turn its 42.79% teacher agreement into a general measure of game
+quality. The final report includes score/survival intervals, all latency summaries,
+hardware, source identities and portable release evidence paths.
+
+To replicate the analysis, first verify the report/checkpoint/dataset hashes in
+[final-summary.json](../../reports/final-summary.json), then use the frozen source
+and commands above in fresh output directories. Reproducing inference needs the
+GPU runtime; inspecting metrics and replaying saved actions do not. Reproduction
+uses the already disclosed sequences, so it is not a new blind test. Any follow-up
+training or design change needs a separate declared experiment and fresh test
+seeds. No post-test tuning was used to produce the results reported here.

code/docs/tutorials/06-release.md

@@ -0,0 +1,234 @@
+# Tutorial 06 — Ship an experiment another person can inspect
+
+Publication is the last milestone, after training, validation selection and held-out
+evaluation. A model upload alone is insufficient: the artifact must load, its claims
+must match measured games, and the demo must distinguish recorded model decisions
+from live human play. This tutorial describes the release process; publication links
+and verified results are recorded in the final release report when available.
+
+## Separate the four deliverables
+
+The source repository contains the simulator, native model adapter, training and
+evaluation scripts, tests, locked environment and tutorials. The model repository
+contains the selected checkpoint's LoRA weights and separately trained decision
+head, plus source and losslessly compressed evidence needed to reproduce the study. The dataset repository
+contains exact train/validation JSONL files and the generator manifest. The demo
+repository runs the game and replays cached model decisions without downloading a
+9B model or renting GPU hardware.
+
+The source bundle also contains `source-manifest.json` with its source commit and
+file hashes. Scripts use an exact Git root when available, otherwise they verify
+that manifest. Changed, missing or newly added source files mark the run as modified;
+an unrelated parent repository is never mistaken for Stackcraft's source identity.
+See Tutorial03 for hash-checked reproduction of the original dataset bytes without
+access to the original Git repository.
+
+These are different visibility decisions. A private GitHub repository does not
+make files inside a public model repository or public Space private. In particular,
+the reproducibility source in the model release and the Space's game source are
+public if those repositories are public. Review the concrete local bundle, proposed
+owners and visibility before creating external repositories.
+
+The owner approved all four destinations as public on 2026-10-06: `kkarimi/stackcraft` on GitHub and
+`nima1/stackcraft-clef-flash-lora`, `nima1/stackcraft-data`, and Space
+`nima1/stackcraft` on Hugging Face. This approval explicitly includes the source
+inside the public model and Space repositories. The final release report in GitHub
+records immutable revisions and actual download/hosting verification.
+
+## Preserve evidence while preparing checkpoint metadata
+
+Raw epoch checkpoints remain under the training run directory. PEFT can generate
+an `adapter/README.md` with placeholders and a local cache path. Before validation,
+copy each epoch checkpoint into a separate candidate directory and replace only
+that documentation with accurate upstream attribution and loading instructions.
+Compare every other file's SHA256 with the raw checkpoint and record the mapping.
+The preparation script performs these checks and writes a sibling provenance file:
+
+```bash
+uv run --locked --extra ml python scripts/prepare_checkpoint.py \
+  --source runs/study-v1/epoch-01 --output checkpoints/candidates/epoch-01
+uv run --locked --extra ml python scripts/prepare_checkpoint.py \
+  --source runs/study-v1/epoch-02 --output checkpoints/candidates/epoch-02
+```
+This edits no learned weights or training configuration.
+
+Validate those exact candidate directories, then freeze the selected directory's
+complete file/hash mapping. Do not revise it after selection. Model cards, reports
+and release links belong outside `model/checkpoint/`, so adding release documentation
+does not silently change the checkpoint used in validation and test evaluation.
+
+A final model repository must contain both `joint_head.safetensors` and
+`adapter/adapter_model.safetensors`. Loading only the adapter discards the learned
+joint head. Loading the selected checkpoint requires the pinned upstream
+`Cloudflare/clef-flash` snapshot and Stackcraft's strict loader, not a generic
+text-generation pipeline. See Tutorial04 for the reason and serialization checks.
+
+## Assemble and audit a local release
+
+Wait for all five players to finish all 200 games, then export the demonstration
+from the complete final report. Seed 30000 was fixed before test results; do not
+choose a more flattering game after seeing outcomes.
+
+```bash
+uv run --locked --extra ml python scripts/export_demo.py \
+  --input runs/final-evaluation/report.json \
+  --players base trained heuristic --seed 30000 \
+  --output runs/demo-final.json
+```
+
+The exporter validates the stored replays, observations and decisions without
+loading a model. Inspect the output, then deliberately replace the packaged
+historical development recording and review that Git diff:
+
+```bash
+cp runs/demo-final.json src/stackcraft/web/baseline-demo.json
+```
+
+Run the local game and check the final three-player comparison plus the optional
+live human board. Then stage a new release directory:
+
+```bash
+uv run --locked --extra ml python scripts/build_release.py \
+  --checkpoint checkpoints/candidates/epoch-02 \
+  --selection runs/selection-v1/selection.json \
+  --evaluation runs/final-evaluation --dataset data/study-v1 \
+  --output runs/release-v1
+```
+
+Epoch 02 is the measured selected checkpoint for this study; use your frozen
+selection's actual path when reproducing. The builder rejects incomplete final
+evaluation, mismatched hashes or a missing selected-checkpoint reference. It also
+requires the packaged demo to match the exact fixed-seed export from that report.
+
+After a public report destination is confirmed, optionally pass the same
+`--report-url https://APPROVED_REPORT_LOCATION` to **both** exporter and builder.
+Use new output directories and deliberately update the packaged demo again.
+Omitting the URL from only one command causes the exact-manifest check to fail.
+These commands prepare local files only; neither creates a remote repository nor
+uploads anything.
+
+The builder stages separate model, dataset and demo directories and a release
+manifest. Raw evaluation and selection files are packed in `model/evidence.zip`
+with an `evidence/` path prefix. `evidence-files.json` records every uncompressed
+file's SHA256 and size; the builder rechecks archive entry bytes before dropping
+its temporary uncompressed copy. Compression changes transport size, not any
+record, checkpoint or frozen evidence hash.
+
+After verifying the downloaded release manifest, extract from the model repository
+root when you need the raw reports or per-episode files:
+
+```bash
+python -m zipfile -e evidence.zip .
+```
+
+This restores the `evidence/evaluation/` and `evidence/selection/` paths used by
+the study report. Model inference itself does not require extracting the logs.
+ It includes only explicit source/build inputs. Environments, credentials,
+Git history, local service data, raw upstream backbone weights and arbitrary files
+from the working directory are excluded. This is safer and more reproducible than
+uploading the repository directory recursively and hoping ignore patterns cover it.
+
+Audit the concrete staged files:
+
+- Model and dataset cards describe synthetic data, teacher bias, simplified rules,
+  the selected training configuration and actual complete-game outcomes.
+- Negative results, model errors, the FP32-head ablation and the cheap heuristic
+  remain visible. There are no unmeasured claims of superiority or calibrated confidence.
+- Every planned test seed is represented for every preregistered player, including
+  failures; aggregate uncertainty agrees with the stored episode outcomes.
+- The fixed demo seed is30000, chosen before results, with actual action probabilities.
+- Dataset bytes and checkpoint bytes match their frozen hashes. The trained
+  checkpoint's probability references identify the same four training positions.
+- LICENSE and NOTICE retain the Apache-2.0 attribution for Clef-flash/Qwen and
+  identify Stackcraft as an independent project.
+- Cards have no placeholder metrics or paths that require the author's machine.
+
+A release manifest identifies bytes, not scientific correctness. Independent replay
+checks, selection review and honest documentation are still needed. Keep the
+manifest hash and source commit with the final release report.
+
+## Validate the game-only deployment
+
+Follow [the deployment guide](../demo-hosting.md) to build the pinned Docker image.
+It installs through uv's lockfile with no ML extra, runs as UID1000 and listens on
+port7860 for a Docker Space. Use the same image configuration locally first.
+
+Test a human game, a downloaded/reloaded replay, the recorded comparison, probability
+displays, scrubbing to final outcomes and returning to the preserved human session.
+Check desktop and phone layouts. The recorded race must not imply that changing
+playback speed changes inference speed. It illustrates one sequence; the report
+summarizes all200 paired sequences.
+
+The public demonstration needs CPU hosting because neural inference already happened
+during evaluation. This removes ongoing GPU expense and makes the portfolio usable
+when the training machine is offline. An interactive live-model endpoint would be a
+separate deployment with admission, latency and concurrency requirements.
+
+## Publish only the approved bundle
+
+Confirm concrete destinations and visibility after the local bundle is reviewable.
+Use existing CLI authentication; do not put access tokens in code, Git, model cards,
+commands or chat. Create the approved GitHub repository and push the reviewed local
+commits. Create the approved model, dataset and Docker Space repositories, uploading
+the corresponding staged directories only. The Space uses `cpu-basic`, with no hourly hardware charge. Creating a personal
+Docker Space nevertheless requires a Hugging Face PRO subscription under the
+current policy; see [the deployment guide](../demo-hosting.md). No subscription
+purchase or paid GPU upgrade is authorized by this study.
+
+Save immutable Hugging Face commit revisions returned by each upload, together with
+the Git commit and model/dataset/demo URLs. Repository names alone are mutable;
+revisions identify which bytes were checked. A successful upload does not establish
+that the Space builds or the model loads.
+
+## Verify the actual release, not the local staging copy
+
+Download the uploaded model and dataset into a new directory using those exact
+revisions. Compare every released file against the release manifest. Run the dataset
+audit on downloaded JSONL files and its manifest. Use a fresh Python process to load
+the downloaded checkpoint onto the pinned upstream backbone and compare its four
+raw reference probability distributions at maximum absolute tolerance1e-4.
+
+Use `huggingface_hub.snapshot_download` with each recorded immutable revision and
+an empty `local_dir` for each repository. Use `repo_type="dataset"` for the dataset
+and `repo_type="space"` for the demo. `local_dir` materializes regular files; passing
+a shared cache snapshot directory directly can expose symlinks, which the verifier
+rejects. Keep the original local `release-manifest.json` separately as the trusted
+comparison, rather than trusting a manifest fetched with the same download.
+
+From the reviewed source checkout, verify all three downloaded repositories:
+
+```bash
+uv run --locked --extra ml python scripts/verify_release.py \
+  --trusted-manifest LOCAL_RELEASE/release-manifest.json \
+  --model DOWNLOADED_MODEL \
+  --dataset DOWNLOADED_DATASET \
+  --demo DOWNLOADED_SPACE \
+  --output runs/released-files-verification.json
+```
+
+This verifies file sizes and SHA256 hashes, checks each uploaded per-repository
+manifest, and reruns the dataset schema/split audit. It rejects missing or extra
+payloads and links, except narrowly defined Hugging Face download bookkeeping,
+which it lists in the report. It does not establish publisher authenticity,
+prove that a download was fresh, or load the neural model. Save the download
+revisions and command separately, then perform the GPU parity check below.
+
+The existing probe script can perform that final serialization check:
+
+```bash
+uv run --locked --extra ml python scripts/probe_clef_training.py \
+  --dataset DOWNLOADED_DATASET \
+  --reload DOWNLOADED_MODEL/checkpoint \
+  --output runs/released-model-reload
+```
+
+Run this only with sufficient free GPU memory. On the original workstation, use the
+approved GLM stop/restore wrapper and verify restored health afterward. Another
+machine must arrange its own workloads; the workstation-specific wrapper is not a
+portable permission to stop services.
+
+Check the published Space's `/health`, static assets, human moves and recorded race
+in a browser. Verify model/dataset links and any private GitHub access expectations.
+Record failures and correct the actual published bundle before declaring release
+complete. Then update the plan's M6 status and final outcomes with verified links,
+revisions, hashes, measured limitations and fresh-download evidence.

code/pyproject.toml

@@ -0,0 +1,59 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "stackcraft"
+version = "0.1.0"
+description = "A reproducible falling-block playground for decision models"
+readme = "README.md"
+requires-python = ">=3.13,<3.14"
+dependencies = ["fastapi", "uvicorn"]
+
+[project.optional-dependencies]
+ml = [
+    "torch==2.14.1",
+    "torchvision",
+    "transformers==5.18.0",
+    "peft==0.21.2",
+    "safetensors>=0.8,<1",
+    "huggingface-hub>=1.33,<2",
+    "pillow>=12,<13",
+]
+
+[project.scripts]
+stackcraft = "stackcraft.cli:main"
+
+[dependency-groups]
+dev = [
+    "pytest",
+    "ruff",
+    "ty",
+    "httpx2>=2.13.1",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/stackcraft"]
+
+[tool.ruff]
+target-version = "py313"
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-ra"
+
+[tool.uv]
+required-version = ">=0.12.23,<0.13"
+
+[tool.uv.sources]
+torch = [{ index = "pytorch-cu130", marker = "sys_platform == 'linux'" }]
+torchvision = [{ index = "pytorch-cu130", marker = "sys_platform == 'linux'" }]
+
+[[tool.uv.index]]
+name = "pytorch-cu130"
+url = "https://download.pytorch.org/whl/cu130"
+explicit = true

code/release/dataset-card.md

@@ -0,0 +1,84 @@
+---
+license: apache-2.0
+language:
+- en
+tags:
+- synthetic
+- imitation-learning
+- games
+- stackcraft
+size_categories:
+- 1K<n<10K
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: train.jsonl
+  - split: validation
+    path: validation.jsonl
+---
+
+# Stackcraft search-teacher positions
+
+A synthetic dataset for a deterministic, simplified falling-block placement game.
+**827 training positions and 215 validation positions**, generated entirely by
+code. No human demonstrations, personal data, web scraping or human row-by-row
+label review are claimed. Independent agent review recomputed 16 pilot labels;
+that sample audit is not a review of every row.
+
+Each row contains a visible board, current piece, one next piece, all legal actions,
+a teacher action, teacher action values and provenance. The board uses integer
+piece colors; the model encoding reduces them to occupancy because color does not
+affect these rules. Metadata includes seed and turn for reproduction; **do not
+feed seed or hidden sequence metadata to the policy**. Stackcraft's encoder feeds
+only the visible observation. Read the dataset schema and tutorial03 before use.
+
+Related releases: [source and tutorials](https://github.com/kkarimi/stackcraft),
+[model](https://huggingface.co/nima1/stackcraft-clef-flash-lora),
+[dataset](https://huggingface.co/datasets/nima1/stackcraft-data), and
+[planned CPU demo](https://huggingface.co/spaces/nima1/stackcraft).
+The hosted demo awaits Hugging Face's Docker-account subscription requirement;
+[local Docker instructions](https://github.com/kkarimi/stackcraft/blob/main/docs/demo-hosting.md)
+work without that subscription.
+
+## Generation
+
+The teacher searches the current placement and exactly one preview placement.
+It rewards current line clears and the best next afterboard, using fixed weights
+for aggregate height, holes, bumpiness and cleared lines. No later pieces are
+available. Labels are heuristic recommendations, not proofs of optimal play.
+
+Collection cycles random, heuristic and search-expert policies, at a 40-piece cap,
+to expose different board conditions. Training seeds 10000–10023 and validation
+seeds 20000–20005 are disjoint. Six within-training and two cross-split duplicate
+observations were excluded. Final test seeds 30000–30199 are reserved for complete
+game evaluation; there is no test-position split for training or selection.
+
+Source commit: `70d84bd8dc5d4a60f3b96455a57d9e6f9416d109`.
+The bundle includes `manifest.json` with source/configuration and split hashes.
+
+- train SHA256: `edd682761db95a4f25bb30a284489c54d9336a36da0a9b19d2cda860b428baa8`
+- validation SHA256: `eff9cdc5932e935959ac4d26dce6470d335090f7428a91930001954266d133bc`
+
+The model release includes public source under `code/` and the exact regeneration
+recipe in `code/docs/tutorials/03-data.md`. Use its **Reproduce from the public
+source bundle without private Git access** procedure: first verify all six generator
+source hashes against this dataset's `manifest.json`, then generate with the
+original source-commit provenance. Access to the original Git repository is not
+required. The procedure reproduced both JSONL hashes exactly on the study machine.
+Ordinary `stackcraft generate-data --output NEWDIR` records the current source
+identity; a new source commit deliberately changes provenance fields and therefore
+file hashes even if labels are identical. A regeneration and an independent
+sample-label audit preceded study training.
+
+## Limits
+
+The study is small and entirely synthetic. Teacher bias, narrow collection seeds,
+short collection episodes and one-step preview limit generalization. Duplicate
+removal prevents exact overlap, not all structural similarity. It is not full
+real-time Tetris: no hold, kicks, tucks or gravity timing. Colors and piece IDs
+are program-generated; Stackcraft uses original game visuals and branding.
+
+Use teacher agreement as a diagnostic and complete held-out games for outcome
+measurement. Do not call a model better solely because it copies these labels.
+Apache-2.0; see LICENSE and accompanying generation/reproduction tutorials.

code/release/model-card.md

@@ -0,0 +1,125 @@
+---
+license: apache-2.0
+base_model: Cloudflare/clef-flash
+base_model_relation: adapter
+library_name: peft
+language:
+- en
+tags:
+- clef
+- decision-model
+- lora
+- imitation-learning
+- stackcraft
+---
+
+# Stackcraft Clef-Flash
+
+**Release preparation: full-study results and selected checkpoint are pending.**
+This is a small, synthetic imitation-learning study of a falling-block placement
+policy. It is not a generally capable game agent, reinforcement-learning result,
+or competitive Tetris implementation.
+
+The artifact contains a rank-4 LoRA adapter **and a separately trained FP32 native
+joint decision head** for `Cloudflare/clef-flash`, pinned revision
+`17f0b0ad64efb65d273590632833508766b2aae6`. Load both. The frozen BF16 backbone
+is downloaded separately; these files are not a standalone model. Clef-flash is
+based on Qwen3.5-9B. The native schema head scores every supplied legal placement
+in one forward pass, with no generated text or command parsing.
+
+Related releases: [source and tutorials](https://github.com/kkarimi/stackcraft),
+[model](https://huggingface.co/nima1/stackcraft-clef-flash-lora),
+[dataset](https://huggingface.co/datasets/nima1/stackcraft-data), and
+[planned CPU demo](https://huggingface.co/spaces/nima1/stackcraft).
+The hosted demo awaits Hugging Face's Docker-account subscription requirement;
+[local Docker instructions](https://github.com/kkarimi/stackcraft/blob/main/docs/demo-hosting.md)
+work without that subscription.
+
+## Intended use
+
+Learn how to build deterministic environments, generate search-teacher labels,
+train a custom decision model, preserve its native head, and evaluate complete
+games with paired uncertainty. The playable demo uses recorded model replays;
+it does not provide public live GPU inference.
+
+The observation is a 10×20 occupied-cell grid, current tetromino, exactly one next
+piece, rules and every legal placement with its coordinates. The action selects
+an orientation and column, then drops vertically. There is no hold, wall kick,
+tuck, gravity timer, T-spin bonus or changing speed. Hidden future pieces and
+sequence seeds are excluded from neural input. Probabilities reflect the model's
+choice distribution; they are not calibrated chances of clearing a line or winning.
+
+## Training and data
+
+The study uses 827 training and 215 validation positions generated from fixed
+seven-bag streams. Random, heuristic and search policies collect states. Every
+label comes from a fixed two-placement search using the current piece and one
+preview, with a board-height/holes/bumpiness/line-clear heuristic. These are
+synthetic teacher preferences, not human demonstrations or globally optimal moves.
+Exact duplicate observations are removed across splits. Six source hashes and
+exact file hashes accompany the dataset manifest.
+
+Preregistered training: seed 42, two epochs, batch 1, accumulation 8, rank 4/alpha 8,
+no LoRA dropout, AdamW lr 1e-5/weight_decay 0.01, gradient norm cap 1.0, label smoothing
+0.05 and Brier sum weight0.1. BF16 backbone, FP32 head, text-layer LoRA including
+both hybrid attention types and MLPs. Vision, output and other original parameters
+remain frozen. There are 132,582,404 trainable parameters: 121,762,820 in the
+joint head and 10,819,584 in LoRA. This is why the head is a substantial part of
+the saved artifact, even though most backbone weights stay frozen. Select only between epoch 01/02 using lowest finite target NLL on
+all 215 validation positions; exact ties choose the earlier epoch.
+
+## Evaluation and limitations
+
+Final preregistered comparison: 200 untouched seeds 30000–30199, 200-piece cap,
+selected model versus unchanged native BF16-head Clef, unchanged FP32-head
+ablation, random legal placement and a cheap heuristic. Primary metric is lines
+cleared. Report score, survival, cap hits, failures and latency. Paired 95% bootstrap
+intervals use 10000 episode resamples with seed 2026. Failed episodes remain in the
+analysis, assigned zero primary outcomes with partial outcomes reported separately.
+
+**Insert verified held-out results here before publication.**
+
+Fine-tuning improved complete-game play over both unchanged Clef references in
+this study. The fixed heuristic still cleared substantially more lines and used
+about one thousandth of the trained model's decision time on this workstation.
+All five policies had zero errors and invalid decisions. Every heuristic game hit
+the 200-piece cap; no neural or random game did. This is evidence of task adaptation,
+not a reason to prefer this 9B model over the heuristic for the simplified game.
+See [the readable study report](code/reports/final-study.md) and
+[the hardware/runtime snapshot](code/reports/evaluation-hardware.json).
+
+
+Only one training seed, one small synthetic dataset, one simplified game ruleset
+and one hardware/software configuration are studied. The finite cap censors
+survival. Validation teacher agreement does not establish game quality. Test
+uncertainty does not capture variation across training seeds.
+
+## Loading
+
+Use the released Stackcraft source and locked ML dependencies. Generic
+`AutoModel` or adapter-only loading omits the custom decision head and is incorrect.
+From the downloaded model repository's `code/` directory, install the locked ML
+environment with `uv sync --locked --extra ml` and cache the pinned upstream
+snapshot as described in [Tutorial 02](code/docs/tutorials/02-baselines.md).
+Run this example with `uv run --locked --extra ml python`; the sibling
+`../checkpoint` directory contains the released adapter and head:
+
+```python
+from stackcraft.clef import ClefPlayer
+from stackcraft.training import load_checkpoint
+from stackcraft.engine import new_game
+from stackcraft.players import observe
+
+player = ClefPlayer.from_pretrained(trust_pinned_code=True, local_files_only=True)
+load_checkpoint(player.model, "../checkpoint")
+print(player.choose(observe(new_game(42))))
+```
+
+`trust_pinned_code=True` executes reviewed, hash-checked upstream Python. It is
+not a sandbox. The measured RTX 5090 inference baseline allocated 19.7 GB; bounded
+LoRA training allocated 23.2 GB. Load only with sufficient free VRAM. Context is
+limited to 4096 tokens, with explicit rejection before any state truncation.
+
+See the released tutorials, training configuration, artifact hashes and evaluation
+report for exact reproduction. Apache-2.0; see LICENSE and NOTICE for upstream
+attribution. This project is independent of Cloudflare, Qwen and Tetris.

code/reports/clef-development.json

@@ -0,0 +1,66 @@
+{
+  "schema_version": 1,
+  "rules_version": "stackcraft-v1",
+  "seeds": [
+    0,
+    1
+  ],
+  "max_pieces": 30,
+  "summary": {
+    "random": {
+      "episodes": 2,
+      "mean_lines": 0,
+      "median_lines": 0.0,
+      "mean_score": 0,
+      "mean_pieces": 27,
+      "cap_hit_rate": 0,
+      "error_rate": 0,
+      "timing": {
+        "count": 54,
+        "total_seconds": 9.454792598262429e-05,
+        "mean_seconds": 1.7508875181967461e-06,
+        "median_seconds": 1.580017851665616e-06,
+        "p95_seconds": 2.9500224627554417e-06
+      }
+    },
+    "heuristic": {
+      "episodes": 2,
+      "mean_lines": 9,
+      "median_lines": 9.0,
+      "mean_score": 1200,
+      "mean_pieces": 30,
+      "cap_hit_rate": 1,
+      "error_rate": 0,
+      "timing": {
+        "count": 60,
+        "total_seconds": 0.010729207948315889,
+        "mean_seconds": 0.00017882013247193148,
+        "median_seconds": 0.00013837897859048098,
+        "p95_seconds": 0.00027111798408441246
+      }
+    },
+    "clef-base": {
+      "episodes": 2,
+      "mean_lines": 0,
+      "median_lines": 0.0,
+      "mean_score": 0,
+      "mean_pieces": 27.5,
+      "cap_hit_rate": 0,
+      "error_rate": 0,
+      "timing": {
+        "count": 55,
+        "total_seconds": 7.934351755975513,
+        "mean_seconds": 0.1442609410177366,
+        "median_seconds": 0.1331863310188055,
+        "p95_seconds": 0.24066273399512284
+      }
+    }
+  },
+  "development_only": true,
+  "gpu": "NVIDIA GeForce RTX 5090",
+  "peak_allocated_bytes": 19686539776,
+  "peak_reserved_bytes": 20002635776,
+  "elapsed_seconds": 12.598100575996796,
+  "artifact_sha256": "3c56622dc2a95eb89df4cae87ecce4bb2a4afb26e47c43553a9e7f826e971e93",
+  "replays_verified": 6
+}

code/reports/dataset-manifest.json

@@ -0,0 +1,539 @@
+{
+  "config": {
+    "behavior_cycle": [
+      "random",
+      "heuristic",
+      "expert"
+    ],
+    "max_pieces": 40,
+    "reserved_test_seeds": [
+      30000,
+      30001,
+      30002,
+      30003,
+      30004,
+      30005,
+      30006,
+      30007,
+      30008,
+      30009,
+      30010,
+      30011,
+      30012,
+      30013,
+      30014,
+      30015,
+      30016,
+      30017,
+      30018,
+      30019,
+      30020,
+      30021,
+      30022,
+      30023,
+      30024,
+      30025,
+      30026,
+      30027,
+      30028,
+      30029,
+      30030,
+      30031,
+      30032,
+      30033,
+      30034,
+      30035,
+      30036,
+      30037,
+      30038,
+      30039,
+      30040,
+      30041,
+      30042,
+      30043,
+      30044,
+      30045,
+      30046,
+      30047,
+      30048,
+      30049,
+      30050,
+      30051,
+      30052,
+      30053,
+      30054,
+      30055,
+      30056,
+      30057,
+      30058,
+      30059,
+      30060,
+      30061,
+      30062,
+      30063,
+      30064,
+      30065,
+      30066,
+      30067,
+      30068,
+      30069,
+      30070,
+      30071,
+      30072,
+      30073,
+      30074,
+      30075,
+      30076,
+      30077,
+      30078,
+      30079,
+      30080,
+      30081,
+      30082,
+      30083,
+      30084,
+      30085,
+      30086,
+      30087,
+      30088,
+      30089,
+      30090,
+      30091,
+      30092,
+      30093,
+      30094,
+      30095,
+      30096,
+      30097,
+      30098,
+      30099,
+      30100,
+      30101,
+      30102,
+      30103,
+      30104,
+      30105,
+      30106,
+      30107,
+      30108,
+      30109,
+      30110,
+      30111,
+      30112,
+      30113,
+      30114,
+      30115,
+      30116,
+      30117,
+      30118,
+      30119,
+      30120,
+      30121,
+      30122,
+      30123,
+      30124,
+      30125,
+      30126,
+      30127,
+      30128,
+      30129,
+      30130,
+      30131,
+      30132,
+      30133,
+      30134,
+      30135,
+      30136,
+      30137,
+      30138,
+      30139,
+      30140,
+      30141,
+      30142,
+      30143,
+      30144,
+      30145,
+      30146,
+      30147,
+      30148,
+      30149,
+      30150,
+      30151,
+      30152,
+      30153,
+      30154,
+      30155,
+      30156,
+      30157,
+      30158,
+      30159,
+      30160,
+      30161,
+      30162,
+      30163,
+      30164,
+      30165,
+      30166,
+      30167,
+      30168,
+      30169,
+      30170,
+      30171,
+      30172,
+      30173,
+      30174,
+      30175,
+      30176,
+      30177,
+      30178,
+      30179,
+      30180,
+      30181,
+      30182,
+      30183,
+      30184,
+      30185,
+      30186,
+      30187,
+      30188,
+      30189,
+      30190,
+      30191,
+      30192,
+      30193,
+      30194,
+      30195,
+      30196,
+      30197,
+      30198,
+      30199
+    ],
+    "train_seeds": [
+      10000,
+      10001,
+      10002,
+      10003,
+      10004,
+      10005,
+      10006,
+      10007,
+      10008,
+      10009,
+      10010,
+      10011,
+      10012,
+      10013,
+      10014,
+      10015,
+      10016,
+      10017,
+      10018,
+      10019,
+      10020,
+      10021,
+      10022,
+      10023
+    ],
+    "validation_seeds": [
+      20000,
+      20001,
+      20002,
+      20003,
+      20004,
+      20005
+    ]
+  },
+  "config_sha256": "65b72544c80cf19f4ac3b12ca109d0ebda18fb70eadb4b170a55b1e8bb3b4f6d",
+  "deduplication": {
+    "exclusions": {
+      "train": {
+        "cross_split": 0,
+        "within_split": 6
+      },
+      "validation": {
+        "cross_split": 2,
+        "within_split": 0
+      }
+    },
+    "normalization": "board occupancy"
+  },
+  "rules_version": "stackcraft-v1",
+  "schema_version": 1,
+  "seed_pools": {
+    "reserved_test": [
+      30000,
+      30001,
+      30002,
+      30003,
+      30004,
+      30005,
+      30006,
+      30007,
+      30008,
+      30009,
+      30010,
+      30011,
+      30012,
+      30013,
+      30014,
+      30015,
+      30016,
+      30017,
+      30018,
+      30019,
+      30020,
+      30021,
+      30022,
+      30023,
+      30024,
+      30025,
+      30026,
+      30027,
+      30028,
+      30029,
+      30030,
+      30031,
+      30032,
+      30033,
+      30034,
+      30035,
+      30036,
+      30037,
+      30038,
+      30039,
+      30040,
+      30041,
+      30042,
+      30043,
+      30044,
+      30045,
+      30046,
+      30047,
+      30048,
+      30049,
+      30050,
+      30051,
+      30052,
+      30053,
+      30054,
+      30055,
+      30056,
+      30057,
+      30058,
+      30059,
+      30060,
+      30061,
+      30062,
+      30063,
+      30064,
+      30065,
+      30066,
+      30067,
+      30068,
+      30069,
+      30070,
+      30071,
+      30072,
+      30073,
+      30074,
+      30075,
+      30076,
+      30077,
+      30078,
+      30079,
+      30080,
+      30081,
+      30082,
+      30083,
+      30084,
+      30085,
+      30086,
+      30087,
+      30088,
+      30089,
+      30090,
+      30091,
+      30092,
+      30093,
+      30094,
+      30095,
+      30096,
+      30097,
+      30098,
+      30099,
+      30100,
+      30101,
+      30102,
+      30103,
+      30104,
+      30105,
+      30106,
+      30107,
+      30108,
+      30109,
+      30110,
+      30111,
+      30112,
+      30113,
+      30114,
+      30115,
+      30116,
+      30117,
+      30118,
+      30119,
+      30120,
+      30121,
+      30122,
+      30123,
+      30124,
+      30125,
+      30126,
+      30127,
+      30128,
+      30129,
+      30130,
+      30131,
+      30132,
+      30133,
+      30134,
+      30135,
+      30136,
+      30137,
+      30138,
+      30139,
+      30140,
+      30141,
+      30142,
+      30143,
+      30144,
+      30145,
+      30146,
+      30147,
+      30148,
+      30149,
+      30150,
+      30151,
+      30152,
+      30153,
+      30154,
+      30155,
+      30156,
+      30157,
+      30158,
+      30159,
+      30160,
+      30161,
+      30162,
+      30163,
+      30164,
+      30165,
+      30166,
+      30167,
+      30168,
+      30169,
+      30170,
+      30171,
+      30172,
+      30173,
+      30174,
+      30175,
+      30176,
+      30177,
+      30178,
+      30179,
+      30180,
+      30181,
+      30182,
+      30183,
+      30184,
+      30185,
+      30186,
+      30187,
+      30188,
+      30189,
+      30190,
+      30191,
+      30192,
+      30193,
+      30194,
+      30195,
+      30196,
+      30197,
+      30198,
+      30199
+    ],
+    "train": [
+      10000,
+      10001,
+      10002,
+      10003,
+      10004,
+      10005,
+      10006,
+      10007,
+      10008,
+      10009,
+      10010,
+      10011,
+      10012,
+      10013,
+      10014,
+      10015,
+      10016,
+      10017,
+      10018,
+      10019,
+      10020,
+      10021,
+      10022,
+      10023
+    ],
+    "validation": [
+      20000,
+      20001,
+      20002,
+      20003,
+      20004,
+      20005
+    ]
+  },
+  "source_commit": "70d84bd8dc5d4a60f3b96455a57d9e6f9416d109",
+  "source_hashes": {
+    "data.py": "74b68a1f391a3128d2e499c7e86b6c94a1f2a2bef33ffe75c8631207065bd991",
+    "engine.py": "0805be38ee968d569fa1c12230730f491490f7d27cfcc570c400ac3b4a546453",
+    "expert.py": "608ea7c1516083807d58dbd9bec82d505c1d4bca61e14579f4821e51607e08b5",
+    "pieces.py": "c5bee0f8767aeeab279cfbadb4c7b4c0bbf1f31c1d29b08dda197f0627654b29",
+    "players/__init__.py": "550bed9237303a845cdcc101542b0b688173a8f5436dd1d08c5f85a5a19fa2b2",
+    "schema.py": "35c70d96e8a49e434dc0a3607412a0ce58141306df59e09b1170511694cb6eb5"
+  },
+  "source_note": "File hashes identify source; commit may precede working-tree edits.",
+  "splits": {
+    "train": {
+      "behavior_records": {
+        "heuristic": 318,
+        "random": 190,
+        "search-expert": 319
+      },
+      "collected": 833,
+      "records": 827,
+      "sha256": "edd682761db95a4f25bb30a284489c54d9336a36da0a9b19d2cda860b428baa8"
+    },
+    "validation": {
+      "behavior_records": {
+        "heuristic": 80,
+        "random": 56,
+        "search-expert": 79
+      },
+      "collected": 217,
+      "records": 215,
+      "sha256": "eff9cdc5932e935959ac4d26dce6470d335090f7428a91930001954266d133bc"
+    }
+  },
+  "teacher": {
+    "optimal": false,
+    "preview_pieces": 1,
+    "search": "exhaustive legal placements"
+  },
+  "teacher_revision": "search-v1-preview1-height1-holes4-bump1-lines8-topout10000",
+  "test_trajectories_generated": false
+}

code/reports/evaluation-hardware.json

@@ -0,0 +1,42 @@
+{
+  "cpu_model": "AMD Ryzen 9 9950X3D 16-Core Processor",
+  "evaluation_request_sha256": "a507e3b947d603b02f56b6df12b160e9e182ee5706d2ac64d8e9f93358f79e62",
+  "gpus": [
+    {
+      "configured_power_limit_watts": 575.0,
+      "driver_version": "610.57.04",
+      "name": "NVIDIA GeForce RTX 5090",
+      "reported_total_memory_mib": 32607
+    }
+  ],
+  "host_reported_memory_kib": 129391464,
+  "kernel": "7.2.5-3-omarchy",
+  "logical_cpu_count": 32,
+  "observed_at_utc": "2026-10-05T21:20:14.982799+00:00",
+  "python_version": "3.13.16",
+  "schema_version": 1,
+  "scope": "Read-only hardware snapshot during final evaluation; no energy usage or continuous clock/temperature measurement",
+  "trained_runtime_config": {
+    "base_revision": "17f0b0ad64efb65d273590632833508766b2aae6",
+    "cpu_threads": 8,
+    "cuda_matmul_allow_tf32": false,
+    "cuda_version": "13.0",
+    "device": "cuda:0",
+    "dtype": "torch.bfloat16",
+    "encoding_version": "stackcraft-clef-v1",
+    "evaluation_head": "fp32-gathered-rows",
+    "float32_matmul_precision": "highest",
+    "head_dtype": "float32",
+    "max_length": 4096,
+    "model_id": "Cloudflare/clef-flash",
+    "revision": "Cloudflare/clef-flash@17f0b0ad64efb65d273590632833508766b2aae6:checkpoint-sha256-b8133e9775a82c6b952fc1a1b1c805c5bc993fbcd919e81f663ad35e122ab7c7:stackcraft-clef-v1",
+    "source_sha256": "0e304cf7c6500e8bb59bef7e2afd2c6373f82596dfb3b57d1aa93c175e2dc3a3",
+    "versions": {
+      "huggingface-hub": "1.33.0",
+      "peft": "0.21.2",
+      "safetensors": "0.8.0",
+      "torch": "2.14.1+cu130",
+      "transformers": "5.18.0"
+    }
+  }
+}

code/reports/final-audit-source.md

@@ -0,0 +1,149 @@
+# Independent final evidence audit
+
+This archives the exact CPU audit script run after evaluation. Its SHA256 is
+recorded in [the audit result](final-audit.json). It assumes the original local
+`runs/`, dataset and checkpoint layout; it is an execution record, not a portable
+release-verification CLI. Use `scripts/verify_release.py` for release downloads.
+No new games or model inference were run by this audit.
+
+```text
+"""Independent CPU-only audit of frozen final evidence; reconstructs saved actions only."""
+import hashlib
+import importlib.util
+import json
+import math
+import random
+import statistics
+import time
+from pathlib import Path
+from types import SimpleNamespace
+
+ROOT = Path.cwd()
+OUT = ROOT / 'runs/final-review/audit.json'
+assert not OUT.exists(), 'Refuse to overwrite audit'
+start = time.monotonic()
+def read(p):
+    return json.loads(Path(p).read_text())
+def sha(p):
+    h = hashlib.sha256()
+    with Path(p).open('rb') as f:
+        while chunk := f.read(1048576):
+            h.update(chunk)
+    return h.hexdigest()
+def module(name):
+    spec = importlib.util.spec_from_file_location(name, ROOT / 'scripts' / name)
+    obj = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(obj)
+    return obj
+
+evaluator = module('evaluate_clef.py')
+exporter = module('export_demo.py')
+request = read('runs/final-evaluation/request.json')
+report_path = Path('runs/final-evaluation/report.json')
+report = read(report_path)
+print('Loaded final report; validating frozen identities.', flush=True)
+players = ['base', 'base-fp32', 'trained', 'random', 'heuristic']
+seeds = list(range(30000, 30200))
+assert request['players'] == players
+assert set(report['players']) == set(players)
+for key, expected in [('mode', 'tournament'), ('final_test', True), ('max_pieces', 200), ('seeds', seeds)]:
+    assert report[key] == request[key] == expected, key
+for file, expected in request['source_hashes'].items():
+    assert sha(file) == expected, file
+assert report['provenance']['source_hashes'] == request['source_hashes']
+assert report['provenance']['installed_versions'] == request['installed_versions']
+checkpoint = Path(request['checkpoint'])
+checkpoint_hashes = evaluator.checkpoint_hashes(checkpoint)
+assert checkpoint_hashes == request['checkpoint_sha256'] == report['checkpoint_sha256']
+selection_path = Path(request['selection_file'])
+assert sha(selection_path) == request['selection_sha256']
+assert read(selection_path) == report['selection']
+args = SimpleNamespace(seeds=tuple(seeds), final_test=True, max_pieces=200, players=players,
+                       selection_file=selection_path, checkpoint=checkpoint, max_length=4096)
+evaluator.validate_selection(args, checkpoint_hashes)
+evaluator.validate_neural_runtimes(report['players'])
+episodes = report['episodes']
+assert len(episodes) == 1000
+indexed = {(e['player_id'], e['seed']): e for e in episodes}
+assert len(indexed) == 1000
+assert set(indexed) == {(p, s) for p in players for s in seeds}
+metrics = ('lines', 'score', 'pieces')
+summaries = {}
+episode_hashes = {}
+def summary(values):
+    if not values:
+        return dict(count=0, mean=None, median=None, p95=None)
+    return dict(count=len(values), mean=statistics.mean(values), median=statistics.median(values),
+                p95=sorted(values)[math.ceil(.95 * len(values)) - 1])
+for player in players:
+    metadata = read(Path('runs/final-evaluation') / player / 'player.json')
+    assert metadata == report['players'][player]
+    rows = []
+    for seed in seeds:
+        path = Path('runs/final-evaluation') / player / f'seed-{seed}.json'
+        episode = read(path)
+        assert episode == indexed[player, seed], str(path)
+        assert episode['player']['revision'] == metadata['revision']
+        assert episode['player']['runtime_config'] == metadata['runtime_config']
+        assert episode['max_pieces'] == 200
+        exporter.validated_player(episode, 0)
+        if player in ('base', 'base-fp32', 'trained'):
+            assert all(d['probabilities'] and 0 < d['input_tokens'] <= 4096 for d in episode['decisions'])
+        episode_hashes[str(path)] = sha(path)
+        rows.append(episode)
+    primary = {m: summary([0 if e['errors'] else e['outcome'][m] for e in rows]) for m in metrics}
+    observed = {m: summary([e['outcome'][m] for e in rows]) for m in metrics}
+    failed = [e['seed'] for e in rows if e['errors']]
+    cap_count = sum(e['outcome']['cap_hit'] for e in rows)
+    events = [d for e in rows for d in e['decisions']]
+    computed = dict(episodes=200, failed_episodes=len(failed), error_rate=len(failed)/200,
+                    invalid_decisions=sum(er['kind']=='invalid_decision' for e in rows for er in e['errors']),
+                    cap_hit_rate=cap_count/200, failure_adjusted=primary, observed_before_error=observed,
+                    latency_seconds=summary([d['decision_seconds'] for d in events]),
+                    input_tokens=summary([d['input_tokens'] for d in events if d.get('input_tokens') is not None]),
+                    failed_seeds=failed)
+    for comparison in ('trained_vs_base', 'trained_vs_heuristic', 'trained_vs_base_fp32', 'base_fp32_vs_base'):
+        stored = report[comparison]['players'][player]
+        for key, value in computed.items():
+            assert stored[key] == value, (comparison, player, key)
+    summaries[player] = {**computed, 'cap_count': cap_count}
+    print(f'{player}: all 200 saved replays/observations/decisions verified; mean lines={primary["lines"]["mean"]}', flush=True)
+comparisons = {}
+for key, left, right in [('trained_vs_base','trained','base'), ('trained_vs_heuristic','trained','heuristic'),
+                          ('trained_vs_base_fp32','trained','base-fp32'), ('base_fp32_vs_base','base-fp32','base')]:
+    stored = report[key]
+    assert stored['trained_id'] == left and stored['base_id'] == right
+    assert stored['seeds'] == seeds and stored['matches_reserved_test_pool'] is True
+    assert stored['max_pieces'] == 200 and stored['selection_performed'] is False
+    assert stored['max_error_rate'] == 0
+    comparisons[key] = {}
+    for metric in metrics:
+        def score(p, seed):
+            e = indexed[p, seed]
+            return 0 if e['errors'] else e['outcome'][metric]
+        deltas = [score(left,s)-score(right,s) for s in seeds]
+        rng = random.Random(2026)
+        means = sorted(sum(rng.choice(deltas) for _ in seeds)/200 for _ in range(10000))
+        def percentile(q):
+            n = 9999*q
+            low = int(n)
+            return means[low] + (means[math.ceil(n)]-means[low])*(n-low)
+        expected = dict(episodes=200, mean_difference=statistics.mean(deltas), ci95_lower=percentile(.025),
+                        ci95_upper=percentile(.975), method='paired episode percentile bootstrap',
+                        bootstrap_samples=10000, bootstrap_seed=2026)
+        assert expected == stored['paired_trained_minus_base'][metric], (key, metric)
+        comparisons[key][metric] = expected
+    acceptable = not summaries[left]['failed_seeds'] and not summaries[right]['failed_seeds']
+    assert stored['errors_acceptable'] == acceptable
+    assert stored['positive_mean_lines_signal'] == (comparisons[key]['lines']['ci95_lower'] > 0 and acceptable)
+    print(f'{key}: all three paired metrics and bootstrap intervals independently match.', flush=True)
+result = dict(status='passed', audit_script_sha256=sha(__file__), elapsed_seconds=time.monotonic()-start,
+              report_sha256=sha(report_path), request_sha256=sha('runs/final-evaluation/request.json'),
+              selection_sha256=sha(selection_path), checkpoint_sha256=checkpoint_hashes,
+              source_hashes=request['source_hashes'], episode_file_sha256=episode_hashes,
+              episodes_verified=1000, summaries=summaries, comparisons=comparisons,
+              method='Saved replay reconstruction; independent statistics and random.choice paired bootstrap. No new policy decisions/model loads.')
+OUT.write_text(json.dumps(result, indent=2, allow_nan=False)+'\n')
+print(json.dumps({k: result[k] for k in ('status','elapsed_seconds','report_sha256','selection_sha256','episodes_verified')}), flush=True)
+
+```

code/reports/final-study.md

@@ -0,0 +1,229 @@
+# Stackcraft: completed Clef fine-tuning study
+
+Fine-tuning improved Clef's play in this small, turn-based block game, but a fixed
+arithmetic heuristic remained much stronger and cheaper. The selected model
+cleared **16.81 lines per game**, compared with **0.07** for the unchanged native
+model and **76.53** for the heuristic. The paired trained-minus-native improvement
+was **16.74 lines, 95% bootstrap interval [15.74, 17.77]**.
+
+These are results from all **200 held-out piece sequences**, seeds 30000–30199,
+with a 200-piece cap for each of five players: 1,000 completed episodes. There
+were **zero inference errors and zero invalid decisions**. Training, selection,
+reload verification, final evaluation and an independent computational audit are
+complete. Publication and fresh-download verification are tracked separately in
+the [source repository](https://github.com/kkarimi/stackcraft).
+
+The [compact machine-readable report](final-summary.json) contains full-precision
+summaries, all paired intervals, runtime configuration and evidence hashes.
+
+## What was tested
+
+Stackcraft uses a 10×20 board, seven tetrominoes and deterministic seven-bag piece
+sequences. A turn selects a legal rotation-and-column placement that drops
+vertically. There is no hold, wall kick, tuck, T-spin scoring or real-time movement
+deadline. Scores are 100/300/500/800 for clearing one/two/three/four lines in a move.
+Each player receives the board, current piece, one next-piece preview and the same
+legal options. Seed, sequence index and future random state are excluded from the
+policy observation. This tests decisions over structured state, not visual play.
+
+The neural players use `Cloudflare/clef-flash`, pinned to revision
+`17f0b0ad64efb65d273590632833508766b2aae6`, with the same full observation encoding,
+option order, BF16 backbone and 4,096-token limit. The three neural conditions are:
+
+- **Native base:** unchanged weights and original BF16 decision head.
+- **FP32 base:** unchanged weights, using the FP32 head wrapper also used in training.
+- **Trained:** selected rank-4 LoRA adapters plus the learned FP32 native decision head.
+
+**Random** chooses uniformly among legal options using its own recorded RNG.
+**Heuristic** greedily scores each resulting board with weights frozen before final evaluation:
+`−aggregate height − 4 × holes − bumpiness + 8 × cleared lines`. It does not use
+the available preview. The lookahead teacher used for labeling is distinct from
+this greedy heuristic and was not one of the five final tournament players.
+
+## Held-out game outcomes
+
+Entries show **mean / median** across all 200 episodes for each player. Survival
+means pieces placed. A cap hit means survival of *at least* 200 pieces, not death
+at piece 200.
+
+| Player | Lines | Score | Pieces survived | Cap hits | Errors / invalid decisions |
+| --- | ---: | ---: | ---: | ---: | ---: |
+| Native base | 0.070 / 0 | 7.0 / 0 | 26.020 / 26 | 0/200 | 0 / 0 |
+| FP32 base | 0.105 / 0 | 10.5 / 0 | 26.000 / 26 | 0/200 | 0 / 0 |
+| Trained | 16.810 / 16 | 1745.5 / 1650 | 83.565 / 82 | 0/200 | 0 / 0 |
+| Random | 0.140 / 0 | 14.0 / 0 | 26.645 / 27 | 0/200 | 0 / 0 |
+| Heuristic | 76.530 / 77 | 8306.5 / 8300 | 200.000 / 200 | 200/200 | 0 / 0 |
+
+No failures were dropped. The frozen analysis assigns zero lines, score and pieces
+to any errored episode and preserves the observed partial outcome separately.
+Because none failed, failure-adjusted and observed summaries coincide here.
+
+For each comparison, subtract the second player's outcome from the first on the
+same seed. Resample the 200 paired differences with replacement 10,000 times,
+using bootstrap seed 2026, and take the percentile 95% interval. Resampling whole
+episodes preserves dependence among moves within a game.
+
+| Comparison | Mean line difference | Paired 95% interval |
+| --- | ---: | ---: |
+| Trained − native base (primary) | +16.740 | [15.740, 17.770] |
+| Trained − FP32 base | +16.705 | [15.705, 17.740] |
+| Trained − heuristic | −59.720 | [−60.805, −58.619875] |
+| FP32 base − native base | +0.035 | [−0.020, 0.090] |
+
+The trained gain persists against the unchanged FP32 head. Head precision alone
+does not explain that gain in this experiment. The FP32-versus-native interval
+includes zero. This is not an ablation separating the effects of learned LoRA
+from learned head weights: both were trained together.
+
+The primary trained-minus-native score difference was +1738.5 [1633.0, 1848.5],
+and survival difference was +57.545 pieces [54.930, 60.210]. All twelve intervals
+(lines, score and pieces for all four comparisons) are preserved in
+[final-summary.json](final-summary.json). Lines are the primary endpoint; score
+and survival intervals are descriptive secondary results, without a multiplicity
+correction. These intervals describe episode variability for one selected
+checkpoint, not variability across training runs.
+
+## Data, training and checkpoint selection
+
+The disclosed synthetic dataset contains **827 training positions and 215
+validation positions**. Separate episode seed pools supplied mixed random,
+heuristic and lookahead-expert trajectories, sampled for at most 40 moves per
+episode. Occupancy-normalized deduplication removed six within-training duplicates
+and two cross-split duplicates. The teacher enumerates placements of the current
+piece and the single visible preview, scoring line clears and the resulting board;
+it cannot inspect unseen pieces. Its labels are bounded-search recommendations,
+not proven optimal moves. See the [dataset manifest](dataset-manifest.json) and
+[Tutorial 03](../docs/tutorials/03-data.md).
+
+One seed-42 training run produced exactly two preregistered epoch candidates.
+Training used BF16 frozen backbone weights without quantization, rank-4/alpha-8
+LoRA with zero dropout, and the full FP32 native joint head: 132,582,404 trainable
+parameters. The fixed loss was cross-entropy with 0.05 label smoothing plus Brier
+loss weighted 0.1. AdamW used learning rate 1e-5 and weight decay 0.01, with batch
+size one, accumulation eight and gradient clipping at 1.0. The final accumulation
+group was normalized by its actual three examples. Each epoch processed all 827
+training positions in 104 optimizer steps. Frozen parameter hashes stayed unchanged.
+
+Selection used the lowest finite mean target negative log likelihood (NLL) on
+**all 215 validation positions**, with exact ties assigned to the earlier epoch.
+Candidates with errors or incomplete probabilities were ineligible. Both were
+eligible; epoch 02 won. Test games did not choose the checkpoint.
+
+| Validation condition | Teacher agreement | Mean target NLL | Mean Brier |
+| --- | ---: | ---: | ---: |
+| Native base | 21/215 (9.77%) | 2.952702 | 0.923173 |
+| FP32 base | 22/215 (10.23%) | 2.952393 | 0.923102 |
+| Epoch 01 | 89/215 (41.40%) | 1.860870 | 0.722190 |
+| Epoch 02, selected | 92/215 (42.79%) | 1.775923 | 0.708980 |
+
+**42.79% teacher agreement is not 42.79% game quality.** It measures agreement
+with one chosen teacher action, including its deterministic tie rule. Small errors
+change subsequent states, and imitation can fail on boards absent from training.
+Complete games provide a separate behavioral measurement.
+
+The selected checkpoint reloaded in a fresh process with **0.0 maximum absolute
+probability difference** on four fixed training-position references, below the
+1e-4 tolerance. This checks those reference distributions, not all possible boards
+or downloaded publication artifacts. Full details are in the
+[training](study-training.json), [validation](validation-summary.json) and
+[reload](selected-checkpoint-reload.json) reports. The training report's status
+reflects its creation before external validation; later evidence completes that
+stage. The [archived preregistration](study-preregistration.md) preserves the
+pre-test choices; it is a local source archive, not a signed external registration.
+
+## Runtime and practical cost
+
+The workstation used an NVIDIA RTX 5090 (reported 32,607 MiB), AMD Ryzen 9 9950X3D,
+eight Torch CPU threads and about 123 GiB host RAM. Runtime was Python 3.13.16,
+Torch 2.14.1+cu130, CUDA 13.0, Transformers 5.18.0 and PEFT 0.21.2. TF32 was disabled.
+The [hardware snapshot](evaluation-hardware.json) records the remaining details.
+
+| Player | Mean decision ms | Median ms | p95 ms | Decisions | Local model initialization s |
+| --- | ---: | ---: | ---: | ---: | ---: |
+| Native base | 149.110 | 139.381 | 244.916 | 5,204 | 3.866 |
+| FP32 base | 150.188 | 140.968 | 247.880 | 5,200 | 2.176 |
+| Trained | 206.814 | 171.844 | 309.000 | 16,713 | 2.528 |
+| Random | 0.001497 | 0.001250 | 0.002879 | 5,329 | 0.000035 |
+| Heuristic | 0.198510 | 0.139489 | 0.280528 | 40,000 | 0.000002 |
+
+Latencies cover all `Player.choose` calls, including encoding and probability
+transfer, with no excluded warmup. They exclude rendering, replay serialization
+and model loading. Initialization was measured separately with weights already
+cached locally; these are not download or reliably disk-cold timings. The neural
+players' mean input lengths were 1,354.30, 1,349.73 and 1,532.11 tokens respectively
+(native, FP32, trained); the trained p95 was 2,259 tokens.
+
+The trained model took about **1,042 times** the heuristic's mean decision time
+while clearing far fewer lines. This is an observed workload comparison: neural
+players use the GPU, the heuristic uses the CPU, and policies visit different
+boards. It is not a controlled same-state kernel benchmark. For a practical game
+bot under these rules, the heuristic is the clear choice. The fine-tuning result
+is useful as a reproducible learning experiment, not a reason to replace the
+heuristic in production.
+
+Training took **1,511.25 seconds (25.2 minutes)** including checkpoint and hash
+work; peak CUDA allocation was **23.23 GB (21.64 GiB)** and reservation 24.18 GB.
+The final evaluation wrapper took **5,103.11 seconds (85.1 minutes)** including
+loading, reporting and the local service stop/restore health checks. This was
+within the pre-test multi-hour budget. These durations exclude earlier development,
+validation and dataset generation. No energy consumption or monetary cost was
+measured; the GPU's configured 575 W ceiling is not an energy-use measurement.
+
+## A fixed replay illustration
+
+Seed **30000**, the first reserved seed and the declared demo sequence, provides
+an exploratory illustration. These values come from saved replays; no additional
+games were generated for this description.
+
+| Player | Lines | Pieces | Final maximum height | Final holes |
+| --- | ---: | ---: | ---: | ---: |
+| Native base | 0 | 23 | 20 | 86 |
+| FP32 base | 0 | 26 | 20 | 79 |
+| Trained | 16 | 82 | 20 | 28 |
+| Random | 0 | 24 | 20 | 88 |
+| Heuristic | 78 | 200 (cap) | 3 | 1 |
+
+A hole is an empty cell below an occupied cell in its column. These are different
+endpoints: the heuristic is still alive at the cap, whereas the other players
+have topped out. The trained player clears lines but eventually reaches the top.
+The table describes this replay; it does not establish why the model fails or
+prove a causal relationship between final holes and the aggregate result.
+
+## Reproducibility and remaining limits
+
+The independently implemented CPU audit checked all 1,000 persisted episodes:
+replayed states, observations, choices, outcomes, source/checkpoint/selection
+bindings and aggregate statistics. It independently recomputed all twelve paired
+intervals and matched the report. The [audit results](final-audit.json) and
+[archived audit source](final-audit-source.md) preserve that check; its script hash
+and compact outcome are also included in the summary. This is an independent code-path check by another agent,
+not an external scientific replication.
+
+The full evaluation JSON is identified by SHA-256
+`5585574b77e81c8d7dd44464c4dfb09f9511ccec0d9150c3ea44793760416857`.
+The frozen selection SHA-256 is
+`025b62587a26bd8cc78c80f362524b8c178190df5188b317299121afa6b1203b`.
+Dataset manifest, checkpoint files, evaluation source files and supporting report
+hashes are all included in [final-summary.json](final-summary.json).
+
+The prepared model-release layout contains `code/` with these reports, source,
+locked environment, tests and tutorials; `evidence.zip` losslessly preserves
+`evidence/evaluation/` with the full
+report, request and per-player episode records; and `evidence/selection/` with
+the frozen choice and both candidates' validation evidence. Extract the ZIP from
+the model repository root to restore these exact paths; `evidence-files.json`
+records their unchanged uncompressed hashes and sizes. These portable paths
+are relative to the model repository root and do not require access to private Git
+history. See the [model release](https://huggingface.co/nima1/stackcraft-clef-flash-lora),
+[dataset](https://huggingface.co/datasets/nima1/stackcraft-data), and
+[CPU demo](https://huggingface.co/spaces/nima1/stackcraft).
+[Tutorial 05](../docs/tutorials/05-evaluation.md) gives the reproduction procedure.
+
+The principal limitations are one training seed, a small synthetic dataset, an
+approximate teacher, a single structured encoding and simplified rules. Training
+positions cover shorter trajectories than the 200-piece test horizon. All 200
+heuristic games reached the cap, so their uncapped longevity is unknown. The weak
+unchanged-model results characterize this pinned model and encoding, not every
+possible way to use Clef. No model, prompt, dataset, policy or checkpoint was tuned
+after opening this final test. Future improvements require a new declared study
+and fresh held-out sequences; these results remain the record of this experiment.

code/reports/final-summary.json

@@ -0,0 +1,1297 @@
+{
+  "checkpoint_sha256": {
+    "adapter/README.md": "bf1fa63446e8ee38c5ac154ade9138a0e2354e3215201f59473102eeb5206fa0",
+    "adapter/adapter_config.json": "bbbce7f19e186b4a79c39d03786bb190d6084e7990a601e8e28672cf1c969741",
+    "adapter/adapter_model.safetensors": "3ed169fe68b20a370bb856f9d91842543374ff3c98fd3bbe139ef2d0b97877a3",
+    "joint_head.safetensors": "4f21c0f315cf1bcf852a9887d158928855eaa9bdcab6b9770d518abf3727fa1b",
+    "reference.json": "adacc63684d28598f8016602bab790cd3967317986b6934dd94a5e14fabe571f",
+    "training_config.json": "3ead31d0a3ccb6a62914c3853ee26332f6412382c5196e40b461182e64d8b329"
+  },
+  "comparisons": {
+    "base_fp32_vs_base": {
+      "base_id": "base",
+      "errors_acceptable": true,
+      "paired_trained_minus_base": {
+        "lines": {
+          "bootstrap_samples": 10000,
+          "bootstrap_seed": 2026,
+          "ci95_lower": -0.02,
+          "ci95_upper": 0.09,
+          "episodes": 200,
+          "mean_difference": 0.035,
+          "method": "paired episode percentile bootstrap"
+        },
+        "pieces": {
+          "bootstrap_samples": 10000,
+          "bootstrap_seed": 2026,
+          "ci95_lower": -0.405,
+          "ci95_upper": 0.36,
+          "episodes": 200,
+          "mean_difference": -0.02,
+          "method": "paired episode percentile bootstrap"
+        },
+        "score": {
+          "bootstrap_samples": 10000,
+          "bootstrap_seed": 2026,
+          "ci95_lower": -2.0,
+          "ci95_upper": 9.0,
+          "episodes": 200,
+          "mean_difference": 3.5,
+          "method": "paired episode percentile bootstrap"
+        }
+      },
+      "positive_mean_lines_signal": false,
+      "trained_id": "base-fp32"
+    },
+    "trained_vs_base": {
+      "base_id": "base",
+      "errors_acceptable": true,
+      "paired_trained_minus_base": {
+        "lines": {
+          "bootstrap_samples": 10000,
+          "bootstrap_seed": 2026,
+          "ci95_lower": 15.74,
+          "ci95_upper": 17.77,
+          "episodes": 200,
+          "mean_difference": 16.74,
+          "method": "paired episode percentile bootstrap"
+        },
+        "pieces": {
+          "bootstrap_samples": 10000,
+          "bootstrap_seed": 2026,
+          "ci95_lower": 54.93,
+          "ci95_upper": 60.21,
+          "episodes": 200,
+          "mean_difference": 57.545,
+          "method": "paired episode percentile bootstrap"
+        },
+        "score": {
+          "bootstrap_samples": 10000,
+          "bootstrap_seed": 2026,
+          "ci95_lower": 1633.0,
+          "ci95_upper": 1848.5,
+          "episodes": 200,
+          "mean_difference": 1738.5,
+          "method": "paired episode percentile bootstrap"
+        }
+      },
+      "positive_mean_lines_signal": true,
+      "trained_id": "trained"
+    },
+    "trained_vs_base_fp32": {
+      "base_id": "base-fp32",
+      "errors_acceptable": true,
+      "paired_trained_minus_base": {
+        "lines": {
+          "bootstrap_samples": 10000,
+          "bootstrap_seed": 2026,
+          "ci95_lower": 15.705,
+          "ci95_upper": 17.74,
+          "episodes": 200,
+          "mean_difference": 16.705,
+          "method": "paired episode percentile bootstrap"
+        },
+        "pieces": {
+          "bootstrap_samples": 10000,
+          "bootstrap_seed": 2026,
+          "ci95_lower": 55.01,
+          "ci95_upper": 60.185,
+          "episodes": 200,
+          "mean_difference": 57.565,
+          "method": "paired episode percentile bootstrap"
+        },
+        "score": {
+          "bootstrap_samples": 10000,
+          "bootstrap_seed": 2026,
+          "ci95_lower": 1629.4875,
+          "ci95_upper": 1845.0,
+          "episodes": 200,
+          "mean_difference": 1735,
+          "method": "paired episode percentile bootstrap"
+        }
+      },
+      "positive_mean_lines_signal": true,
+      "trained_id": "trained"
+    },
+    "trained_vs_heuristic": {
+      "base_id": "heuristic",
+      "errors_acceptable": true,
+      "paired_trained_minus_base": {
+        "lines": {
+          "bootstrap_samples": 10000,
+          "bootstrap_seed": 2026,
+          "ci95_lower": -60.805,
+          "ci95_upper": -58.619875,
+          "episodes": 200,
+          "mean_difference": -59.72,
+          "method": "paired episode percentile bootstrap"
+        },
+        "pieces": {
+          "bootstrap_samples": 10000,
+          "bootstrap_seed": 2026,
+          "ci95_lower": -118.925125,
+          "ci95_upper": -113.86987500000001,
+          "episodes": 200,
+          "mean_difference": -116.435,
+          "method": "paired episode percentile bootstrap"
+        },
+        "score": {
+          "bootstrap_samples": 10000,
+          "bootstrap_seed": 2026,
+          "ci95_lower": -6681.5125,
+          "ci95_upper": -6436.0,
+          "episodes": 200,
+          "mean_difference": -6561,
+          "method": "paired episode percentile bootstrap"
+        }
+      },
+      "positive_mean_lines_signal": false,
+      "trained_id": "trained"
+    }
+  },
+  "conclusion": "Selected training checkpoint improves mean lines over both unchanged Clef references; fixed heuristic is much stronger and cheaper.",
+  "evidence": {
+    "audit_source": {
+      "release_path": "code/reports/final-audit-source.md",
+      "sha256": "61db8b121130ffd2eeb0a9c667f53f0c21647e865e93d44fbb9967e71d870020",
+      "size_bytes": 8166
+    },
+    "dataset": {
+      "release_path": "code/reports/dataset-manifest.json",
+      "sha256": "f591ec4c4b853942bd0a89331280b8c3491b3eb87f0b2a69ae4821b9623bd936",
+      "size_bytes": 8175
+    },
+    "evaluation": {
+      "release_path": "evidence/evaluation/report.json",
+      "sha256": "5585574b77e81c8d7dd44464c4dfb09f9511ccec0d9150c3ea44793760416857",
+      "size_bytes": 1225235921
+    },
+    "hardware": {
+      "release_path": "code/reports/evaluation-hardware.json",
+      "sha256": "cea05c0d6f208dbeae498be743d131f645cebe88a5054a8af5a884714582085b",
+      "size_bytes": 1606
+    },
+    "independent_audit": {
+      "release_path": "code/reports/final-audit.json",
+      "sha256": "4766d0224a8bddc8c6e6fe0e86e75937f65abdb261667d5d59bd3d482c8adb89",
+      "size_bytes": 133571
+    },
+    "preregistration": {
+      "release_path": "code/reports/study-preregistration.md",
+      "sha256": "bd6d34b4e71a2e38f4dcdc4a0b0a1aca7f7572e5d063af6b3e8491c6c6382d96",
+      "size_bytes": 4183
+    },
+    "reload": {
+      "release_path": "code/reports/selected-checkpoint-reload.json",
+      "sha256": "57489d34b22627c0fd0e3dc42f7f11231a901c059db7a4ea8cbab0aba2c37cdd",
+      "size_bytes": 630
+    },
+    "request": {
+      "release_path": "evidence/evaluation/request.json",
+      "sha256": "a507e3b947d603b02f56b6df12b160e9e182ee5706d2ac64d8e9f93358f79e62",
+      "size_bytes": 4699
+    },
+    "selection": {
+      "release_path": "evidence/selection/selection.json",
+      "sha256": "025b62587a26bd8cc78c80f362524b8c178190df5188b317299121afa6b1203b",
+      "size_bytes": 8037
+    },
+    "training": {
+      "release_path": "code/reports/study-training.json",
+      "sha256": "c272f9e1dedfedf285c0d7d1a46aa77a89d48019bf621e31a11921f38fc05600",
+      "size_bytes": 63791
+    },
+    "validation": {
+      "release_path": "code/reports/validation-summary.json",
+      "sha256": "2fd17daeeb12dfecf739c2dcd885e80ca3dc4547acaa3d22722ac9a4d747122a",
+      "size_bytes": 7990
+    }
+  },
+  "evidence_path_convention": "Paths are relative to the model release root; source-only copies retain compact reports under reports/. Publication is pending at report creation.",
+  "hardware": {
+    "cpu_model": "AMD Ryzen 9 9950X3D 16-Core Processor",
+    "evaluation_request_sha256": "a507e3b947d603b02f56b6df12b160e9e182ee5706d2ac64d8e9f93358f79e62",
+    "gpus": [
+      {
+        "configured_power_limit_watts": 575.0,
+        "driver_version": "610.57.04",
+        "name": "NVIDIA GeForce RTX 5090",
+        "reported_total_memory_mib": 32607
+      }
+    ],
+    "host_reported_memory_kib": 129391464,
+    "kernel": "7.2.5-3-omarchy",
+    "logical_cpu_count": 32,
+    "observed_at_utc": "2026-10-05T21:20:14.982799+00:00",
+    "python_version": "3.13.16",
+    "schema_version": 1,
+    "scope": "Read-only hardware snapshot during final evaluation; no energy usage or continuous clock/temperature measurement",
+    "trained_runtime_config": {
+      "base_revision": "17f0b0ad64efb65d273590632833508766b2aae6",
+      "cpu_threads": 8,
+      "cuda_matmul_allow_tf32": false,
+      "cuda_version": "13.0",
+      "device": "cuda:0",
+      "dtype": "torch.bfloat16",
+      "encoding_version": "stackcraft-clef-v1",
+      "evaluation_head": "fp32-gathered-rows",
+      "float32_matmul_precision": "highest",
+      "head_dtype": "float32",
+      "max_length": 4096,
+      "model_id": "Cloudflare/clef-flash",
+      "revision": "Cloudflare/clef-flash@17f0b0ad64efb65d273590632833508766b2aae6:checkpoint-sha256-b8133e9775a82c6b952fc1a1b1c805c5bc993fbcd919e81f663ad35e122ab7c7:stackcraft-clef-v1",
+      "source_sha256": "0e304cf7c6500e8bb59bef7e2afd2c6373f82596dfb3b57d1aa93c175e2dc3a3",
+      "versions": {
+        "huggingface-hub": "1.33.0",
+        "peft": "0.21.2",
+        "safetensors": "0.8.0",
+        "torch": "2.14.1+cu130",
+        "transformers": "5.18.0"
+      }
+    }
+  },
+  "illustration": {
+    "players": {
+      "base": {
+        "evidence": {
+          "release_path": "evidence/evaluation/base/seed-30000.json",
+          "sha256": "429e52aa67bbdae6cd35f469af876b9b7872d61e4b862cb2ea47f40e7ef918d4",
+          "size_bytes": 325003
+        },
+        "final_board": {
+          "aggregate_height": 178,
+          "holes": 86,
+          "max_height": 20
+        },
+        "outcome": {
+          "cap_hit": false,
+          "lines": 0,
+          "pieces": 23,
+          "score": 0,
+          "status": "top_out",
+          "terminal": true
+        }
+      },
+      "base-fp32": {
+        "evidence": {
+          "release_path": "evidence/evaluation/base-fp32/seed-30000.json",
+          "sha256": "87744a7184c3ffbe1a4e7b8e5b526f628993de4135a551117de2c2283c105c34",
+          "size_bytes": 335159
+        },
+        "final_board": {
+          "aggregate_height": 183,
+          "holes": 79,
+          "max_height": 20
+        },
+        "outcome": {
+          "cap_hit": false,
+          "lines": 0,
+          "pieces": 26,
+          "score": 0,
+          "status": "top_out",
+          "terminal": true
+        }
+      },
+      "heuristic": {
+        "evidence": {
+          "release_path": "evidence/evaluation/heuristic/seed-30000.json",
+          "sha256": "5b7508b7a345998a7c677a5153779ca9d46bfd65ada64371c7117f54c6537c09",
+          "size_bytes": 2800853
+        },
+        "final_board": {
+          "aggregate_height": 21,
+          "holes": 1,
+          "max_height": 3
+        },
+        "outcome": {
+          "cap_hit": true,
+          "lines": 78,
+          "pieces": 200,
+          "score": 8800,
+          "status": "cap",
+          "terminal": false
+        }
+      },
+      "random": {
+        "evidence": {
+          "release_path": "evidence/evaluation/random/seed-30000.json",
+          "sha256": "f39dc524807bb0008a9bbe2cd004e152fdb939405d1e50879c81da2942c7a49e",
+          "size_bytes": 318599
+        },
+        "final_board": {
+          "aggregate_height": 184,
+          "holes": 88,
+          "max_height": 20
+        },
+        "outcome": {
+          "cap_hit": false,
+          "lines": 0,
+          "pieces": 24,
+          "score": 0,
+          "status": "top_out",
+          "terminal": true
+        }
+      },
+      "trained": {
+        "evidence": {
+          "release_path": "evidence/evaluation/trained/seed-30000.json",
+          "sha256": "d18bd7010da5c2d98ef02a73585a3cac0a47764a43a597c1d1b2d1280949890c",
+          "size_bytes": 1156045
+        },
+        "final_board": {
+          "aggregate_height": 196,
+          "holes": 28,
+          "max_height": 20
+        },
+        "outcome": {
+          "cap_hit": false,
+          "lines": 16,
+          "pieces": 82,
+          "score": 1600,
+          "status": "top_out",
+          "terminal": true
+        }
+      }
+    },
+    "scope": "Exploratory description of the preselected replay seed, not a causal explanation or extra experiment. Endpoints differ in turn and terminal status. Holes are empty cells below an occupied cell in their column.",
+    "seed": 30000
+  },
+  "independent_audit": {
+    "audit_script_sha256": "867eb41c8319c7c7b428a037b9c8a4f5a5e9c235a15631fae6716aed565626d1",
+    "elapsed_seconds": 63.74646008000127,
+    "episodes_verified": 1000,
+    "method": "Saved replay reconstruction; independent statistics and random.choice paired bootstrap. No new policy decisions/model loads.",
+    "report_sha256": "5585574b77e81c8d7dd44464c4dfb09f9511ccec0d9150c3ea44793760416857",
+    "request_sha256": "a507e3b947d603b02f56b6df12b160e9e182ee5706d2ac64d8e9f93358f79e62",
+    "selection_sha256": "025b62587a26bd8cc78c80f362524b8c178190df5188b317299121afa6b1203b",
+    "status": "passed"
+  },
+  "limitations": [
+    "One training seed; confidence intervals do not include training-seed variability.",
+    "827 synthetic training positions and 215 validation positions; teacher search is bounded and not guaranteed optimal.",
+    "Simplified deterministic turn-based rules, structured board input and one-piece preview, not real-time Tetris.",
+    "All heuristic episodes reach the cap; uncapped survival is unknown.",
+    "Teacher agreement is not a game-quality metric.",
+    "Different policy states and GPU/CPU execution make latency a workload measurement rather than a controlled same-input kernel benchmark.",
+    "No checkpoint, prompt, dataset or policy tuning after opening this final test. A future experiment needs new held-out seeds."
+  ],
+  "players": {
+    "base": {
+      "cap_hit_rate": 0,
+      "cap_hits": 0,
+      "episodes": 200,
+      "error_rate": 0.0,
+      "failed_episodes": 0,
+      "failed_seeds": [],
+      "failure_adjusted": {
+        "lines": {
+          "count": 200,
+          "mean": 0.07,
+          "median": 0.0,
+          "p95": 1
+        },
+        "pieces": {
+          "count": 200,
+          "mean": 26.02,
+          "median": 26.0,
+          "p95": 30
+        },
+        "score": {
+          "count": 200,
+          "mean": 7,
+          "median": 0.0,
+          "p95": 100
+        }
+      },
+      "identity": {
+        "name": "base",
+        "revision": "Cloudflare/clef-flash@17f0b0ad64efb65d273590632833508766b2aae6:stackcraft-clef-v1",
+        "runtime_config": {
+          "base_revision": "17f0b0ad64efb65d273590632833508766b2aae6",
+          "cpu_threads": 8,
+          "cuda_matmul_allow_tf32": false,
+          "cuda_version": "13.0",
+          "device": "cuda:0",
+          "dtype": "torch.bfloat16",
+          "encoding_version": "stackcraft-clef-v1",
+          "evaluation_head": "native",
+          "float32_matmul_precision": "highest",
+          "head_dtype": "bfloat16",
+          "max_length": 4096,
+          "model_id": "Cloudflare/clef-flash",
+          "revision": "Cloudflare/clef-flash@17f0b0ad64efb65d273590632833508766b2aae6:stackcraft-clef-v1",
+          "source_sha256": "0e304cf7c6500e8bb59bef7e2afd2c6373f82596dfb3b57d1aa93c175e2dc3a3",
+          "versions": {
+            "huggingface-hub": "1.33.0",
+            "peft": "0.21.2",
+            "safetensors": "0.8.0",
+            "torch": "2.14.1+cu130",
+            "transformers": "5.18.0"
+          }
+        }
+      },
+      "input_tokens": {
+        "count": 5204,
+        "mean": 1354.2999615680246,
+        "median": 1286.0,
+        "p95": 2258
+      },
+      "invalid_decisions": 0,
+      "latency_seconds": {
+        "count": 5204,
+        "mean": 0.149109957484823,
+        "median": 0.1393812735186657,
+        "p95": 0.2449162660050206
+      },
+      "load_seconds": [
+        3.866232068015961
+      ],
+      "observed_before_error": {
+        "lines": {
+          "count": 200,
+          "mean": 0.07,
+          "median": 0.0,
+          "p95": 1
+        },
+        "pieces": {
+          "count": 200,
+          "mean": 26.02,
+          "median": 26.0,
+          "p95": 30
+        },
+        "score": {
+          "count": 200,
+          "mean": 7,
+          "median": 0.0,
+          "p95": 100
+        }
+      }
+    },
+    "base-fp32": {
+      "cap_hit_rate": 0,
+      "cap_hits": 0,
+      "episodes": 200,
+      "error_rate": 0.0,
+      "failed_episodes": 0,
+      "failed_seeds": [],
+      "failure_adjusted": {
+        "lines": {
+          "count": 200,
+          "mean": 0.105,
+          "median": 0.0,
+          "p95": 1
+        },
+        "pieces": {
+          "count": 200,
+          "mean": 26,
+          "median": 26.0,
+          "p95": 31
+        },
+        "score": {
+          "count": 200,
+          "mean": 10.5,
+          "median": 0.0,
+          "p95": 100
+        }
+      },
+      "identity": {
+        "name": "base-fp32",
+        "revision": "Cloudflare/clef-flash@17f0b0ad64efb65d273590632833508766b2aae6:stackcraft-clef-v1:head-fp32-ablation",
+        "runtime_config": {
+          "base_revision": "17f0b0ad64efb65d273590632833508766b2aae6",
+          "cpu_threads": 8,
+          "cuda_matmul_allow_tf32": false,
+          "cuda_version": "13.0",
+          "device": "cuda:0",
+          "dtype": "torch.bfloat16",
+          "encoding_version": "stackcraft-clef-v1",
+          "evaluation_head": "fp32-gathered-rows",
+          "float32_matmul_precision": "highest",
+          "head_dtype": "float32",
+          "max_length": 4096,
+          "model_id": "Cloudflare/clef-flash",
+          "revision": "Cloudflare/clef-flash@17f0b0ad64efb65d273590632833508766b2aae6:stackcraft-clef-v1:head-fp32-ablation",
+          "source_sha256": "0e304cf7c6500e8bb59bef7e2afd2c6373f82596dfb3b57d1aa93c175e2dc3a3",
+          "versions": {
+            "huggingface-hub": "1.33.0",
+            "peft": "0.21.2",
+            "safetensors": "0.8.0",
+            "torch": "2.14.1+cu130",
+            "transformers": "5.18.0"
+          }
+        }
+      },
+      "input_tokens": {
+        "count": 5200,
+        "mean": 1349.7273076923077,
+        "median": 1286.0,
+        "p95": 2258
+      },
+      "invalid_decisions": 0,
+      "latency_seconds": {
+        "count": 5200,
+        "mean": 0.1501883656640264,
+        "median": 0.14096801349660382,
+        "p95": 0.24787959101377055
+      },
+      "load_seconds": [
+        2.1760330779943615
+      ],
+      "observed_before_error": {
+        "lines": {
+          "count": 200,
+          "mean": 0.105,
+          "median": 0.0,
+          "p95": 1
+        },
+        "pieces": {
+          "count": 200,
+          "mean": 26,
+          "median": 26.0,
+          "p95": 31
+        },
+        "score": {
+          "count": 200,
+          "mean": 10.5,
+          "median": 0.0,
+          "p95": 100
+        }
+      }
+    },
+    "heuristic": {
+      "cap_hit_rate": 1,
+      "cap_hits": 200,
+      "episodes": 200,
+      "error_rate": 0.0,
+      "failed_episodes": 0,
+      "failed_seeds": [],
+      "failure_adjusted": {
+        "lines": {
+          "count": 200,
+          "mean": 76.53,
+          "median": 77.0,
+          "p95": 79
+        },
+        "pieces": {
+          "count": 200,
+          "mean": 200,
+          "median": 200.0,
+          "p95": 200
+        },
+        "score": {
+          "count": 200,
+          "mean": 8306.5,
+          "median": 8300.0,
+          "p95": 8800
+        }
+      },
+      "identity": {
+        "name": "heuristic",
+        "revision": "heuristic-v1-height1-holes4-bump1-lines8",
+        "runtime_config": {}
+      },
+      "input_tokens": {
+        "count": 0,
+        "mean": null,
+        "median": null,
+        "p95": null
+      },
+      "invalid_decisions": 0,
+      "latency_seconds": {
+        "count": 40000,
+        "mean": 0.00019850957853268482,
+        "median": 0.00013948898413218558,
+        "p95": 0.00028052800917066634
+      },
+      "load_seconds": [
+        2.1799933165311813e-06
+      ],
+      "observed_before_error": {
+        "lines": {
+          "count": 200,
+          "mean": 76.53,
+          "median": 77.0,
+          "p95": 79
+        },
+        "pieces": {
+          "count": 200,
+          "mean": 200,
+          "median": 200.0,
+          "p95": 200
+        },
+        "score": {
+          "count": 200,
+          "mean": 8306.5,
+          "median": 8300.0,
+          "p95": 8800
+        }
+      }
+    },
+    "random": {
+      "cap_hit_rate": 0,
+      "cap_hits": 0,
+      "episodes": 200,
+      "error_rate": 0.0,
+      "failed_episodes": 0,
+      "failed_seeds": [],
+      "failure_adjusted": {
+        "lines": {
+          "count": 200,
+          "mean": 0.14,
+          "median": 0.0,
+          "p95": 1
+        },
+        "pieces": {
+          "count": 200,
+          "mean": 26.645,
+          "median": 27.0,
+          "p95": 31
+        },
+        "score": {
+          "count": 200,
+          "mean": 14,
+          "median": 0.0,
+          "p95": 100
+        }
+      },
+      "identity": {
+        "name": "random",
+        "revision": "random-v1-rng-0",
+        "runtime_config": {}
+      },
+      "input_tokens": {
+        "count": 0,
+        "mean": null,
+        "median": null,
+        "p95": null
+      },
+      "invalid_decisions": 0,
+      "latency_seconds": {
+        "count": 5329,
+        "mean": 1.4965126650845871e-06,
+        "median": 1.2499804142862558e-06,
+        "p95": 2.8790091164410114e-06
+      },
+      "load_seconds": [
+        3.4689990570768714e-05
+      ],
+      "observed_before_error": {
+        "lines": {
+          "count": 200,
+          "mean": 0.14,
+          "median": 0.0,
+          "p95": 1
+        },
+        "pieces": {
+          "count": 200,
+          "mean": 26.645,
+          "median": 27.0,
+          "p95": 31
+        },
+        "score": {
+          "count": 200,
+          "mean": 14,
+          "median": 0.0,
+          "p95": 100
+        }
+      }
+    },
+    "trained": {
+      "cap_hit_rate": 0,
+      "cap_hits": 0,
+      "episodes": 200,
+      "error_rate": 0.0,
+      "failed_episodes": 0,
+      "failed_seeds": [],
+      "failure_adjusted": {
+        "lines": {
+          "count": 200,
+          "mean": 16.81,
+          "median": 16.0,
+          "p95": 29
+        },
+        "pieces": {
+          "count": 200,
+          "mean": 83.565,
+          "median": 82.0,
+          "p95": 114
+        },
+        "score": {
+          "count": 200,
+          "mean": 1745.5,
+          "median": 1650.0,
+          "p95": 3100
+        }
+      },
+      "identity": {
+        "name": "trained",
+        "revision": "Cloudflare/clef-flash@17f0b0ad64efb65d273590632833508766b2aae6:checkpoint-sha256-b8133e9775a82c6b952fc1a1b1c805c5bc993fbcd919e81f663ad35e122ab7c7:stackcraft-clef-v1",
+        "runtime_config": {
+          "base_revision": "17f0b0ad64efb65d273590632833508766b2aae6",
+          "cpu_threads": 8,
+          "cuda_matmul_allow_tf32": false,
+          "cuda_version": "13.0",
+          "device": "cuda:0",
+          "dtype": "torch.bfloat16",
+          "encoding_version": "stackcraft-clef-v1",
+          "evaluation_head": "fp32-gathered-rows",
+          "float32_matmul_precision": "highest",
+          "head_dtype": "float32",
+          "max_length": 4096,
+          "model_id": "Cloudflare/clef-flash",
+          "revision": "Cloudflare/clef-flash@17f0b0ad64efb65d273590632833508766b2aae6:checkpoint-sha256-b8133e9775a82c6b952fc1a1b1c805c5bc993fbcd919e81f663ad35e122ab7c7:stackcraft-clef-v1",
+          "source_sha256": "0e304cf7c6500e8bb59bef7e2afd2c6373f82596dfb3b57d1aa93c175e2dc3a3",
+          "versions": {
+            "huggingface-hub": "1.33.0",
+            "peft": "0.21.2",
+            "safetensors": "0.8.0",
+            "torch": "2.14.1+cu130",
+            "transformers": "5.18.0"
+          }
+        }
+      },
+      "input_tokens": {
+        "count": 16713,
+        "mean": 1532.1127864536588,
+        "median": 1304,
+        "p95": 2259
+      },
+      "invalid_decisions": 0,
+      "latency_seconds": {
+        "count": 16713,
+        "mean": 0.20681440101212237,
+        "median": 0.17184428698965348,
+        "p95": 0.3090000880183652
+      },
+      "load_seconds": [
+        2.5281899149995297
+      ],
+      "observed_before_error": {
+        "lines": {
+          "count": 200,
+          "mean": 16.81,
+          "median": 16.0,
+          "p95": 29
+        },
+        "pieces": {
+          "count": 200,
+          "mean": 83.565,
+          "median": 82.0,
+          "p95": 114
+        },
+        "score": {
+          "count": 200,
+          "mean": 1745.5,
+          "median": 1650.0,
+          "p95": 3100
+        }
+      }
+    }
+  },
+  "protocol": {
+    "bootstrap_samples": 10000,
+    "bootstrap_seed": 2026,
+    "checkpoint_selection": "lowest finite validation NLL over all 215 positions; exact tie selects earlier of epoch-01 and epoch-02",
+    "ci_method": "paired episode percentile bootstrap",
+    "episodes_per_player": 200,
+    "failure_policy": "zero lines/score/pieces on errors; retain all pairs",
+    "final_test": true,
+    "max_error_rate": 0.0,
+    "max_pieces": 200,
+    "primary_metric": "lines",
+    "rules_version": "stackcraft-v1",
+    "secondary_metrics": [
+      "score",
+      "pieces"
+    ],
+    "seeds": [
+      30000,
+      30001,
+      30002,
+      30003,
+      30004,
+      30005,
+      30006,
+      30007,
+      30008,
+      30009,
+      30010,
+      30011,
+      30012,
+      30013,
+      30014,
+      30015,
+      30016,
+      30017,
+      30018,
+      30019,
+      30020,
+      30021,
+      30022,
+      30023,
+      30024,
+      30025,
+      30026,
+      30027,
+      30028,
+      30029,
+      30030,
+      30031,
+      30032,
+      30033,
+      30034,
+      30035,
+      30036,
+      30037,
+      30038,
+      30039,
+      30040,
+      30041,
+      30042,
+      30043,
+      30044,
+      30045,
+      30046,
+      30047,
+      30048,
+      30049,
+      30050,
+      30051,
+      30052,
+      30053,
+      30054,
+      30055,
+      30056,
+      30057,
+      30058,
+      30059,
+      30060,
+      30061,
+      30062,
+      30063,
+      30064,
+      30065,
+      30066,
+      30067,
+      30068,
+      30069,
+      30070,
+      30071,
+      30072,
+      30073,
+      30074,
+      30075,
+      30076,
+      30077,
+      30078,
+      30079,
+      30080,
+      30081,
+      30082,
+      30083,
+      30084,
+      30085,
+      30086,
+      30087,
+      30088,
+      30089,
+      30090,
+      30091,
+      30092,
+      30093,
+      30094,
+      30095,
+      30096,
+      30097,
+      30098,
+      30099,
+      30100,
+      30101,
+      30102,
+      30103,
+      30104,
+      30105,
+      30106,
+      30107,
+      30108,
+      30109,
+      30110,
+      30111,
+      30112,
+      30113,
+      30114,
+      30115,
+      30116,
+      30117,
+      30118,
+      30119,
+      30120,
+      30121,
+      30122,
+      30123,
+      30124,
+      30125,
+      30126,
+      30127,
+      30128,
+      30129,
+      30130,
+      30131,
+      30132,
+      30133,
+      30134,
+      30135,
+      30136,
+      30137,
+      30138,
+      30139,
+      30140,
+      30141,
+      30142,
+      30143,
+      30144,
+      30145,
+      30146,
+      30147,
+      30148,
+      30149,
+      30150,
+      30151,
+      30152,
+      30153,
+      30154,
+      30155,
+      30156,
+      30157,
+      30158,
+      30159,
+      30160,
+      30161,
+      30162,
+      30163,
+      30164,
+      30165,
+      30166,
+      30167,
+      30168,
+      30169,
+      30170,
+      30171,
+      30172,
+      30173,
+      30174,
+      30175,
+      30176,
+      30177,
+      30178,
+      30179,
+      30180,
+      30181,
+      30182,
+      30183,
+      30184,
+      30185,
+      30186,
+      30187,
+      30188,
+      30189,
+      30190,
+      30191,
+      30192,
+      30193,
+      30194,
+      30195,
+      30196,
+      30197,
+      30198,
+      30199
+    ],
+    "total_episodes": 1000,
+    "training_seeds": [
+      42
+    ]
+  },
+  "provenance": {
+    "base_revision": "17f0b0ad64efb65d273590632833508766b2aae6",
+    "encoding_version": "stackcraft-clef-v1",
+    "installed_versions": {
+      "huggingface-hub": "1.33.0",
+      "peft": "0.21.2",
+      "safetensors": "0.8.0",
+      "torch": "2.14.1+cu130",
+      "transformers": "5.18.0"
+    },
+    "precision_policy": "native BF16 base; FP32 trained head; optional base-fp32 ablation",
+    "rules_version": "stackcraft-v1",
+    "source_commit": "e524f0c15c2dd60ebfdc1374d66836c79e1e6dd6",
+    "source_dirty": false,
+    "source_hashes": {
+      "scripts/evaluate_clef.py": "70a47e9314ec9d7351a939bae32f07f14bd08f6106b60ce6155687c0540b92dd",
+      "src/stackcraft/clef.py": "c505f35d27121ba9ec9db3c663927ac8b28304f4ed864765be61ce96c8c86e13",
+      "src/stackcraft/data.py": "74b68a1f391a3128d2e499c7e86b6c94a1f2a2bef33ffe75c8631207065bd991",
+      "src/stackcraft/engine.py": "0805be38ee968d569fa1c12230730f491490f7d27cfcc570c400ac3b4a546453",
+      "src/stackcraft/evaluation.py": "df56f9d36655e79573a014a5c55c2571bc5e04e2c20f1b37e2d939b871e889e6",
+      "src/stackcraft/pieces.py": "c5bee0f8767aeeab279cfbadb4c7b4c0bbf1f31c1d29b08dda197f0627654b29",
+      "src/stackcraft/players/__init__.py": "550bed9237303a845cdcc101542b0b688173a8f5436dd1d08c5f85a5a19fa2b2",
+      "src/stackcraft/provenance.py": "0728104f22361ad2a8b4471e6eef0467852d94f650d0259d7f5f674c0086f13b",
+      "src/stackcraft/schema.py": "35c70d96e8a49e434dc0a3607412a0ce58141306df59e09b1170511694cb6eb5",
+      "src/stackcraft/tournament.py": "288ed447a32e0845f52097372a644fc211b1632790655f620801d3ce1639d559",
+      "src/stackcraft/training.py": "f7e48b041b331cf2b68674ec2abb1059dd1da47cb261697b46260b4f0169dba8",
+      "uv.lock": "bc7fae476529578be003856b5f19e09c8cc96e0020ab999e20e1f8210696f9c8"
+    },
+    "source_identity_method": "exact-git-root"
+  },
+  "reload": {
+    "dataset_manifest_sha256": "aeddcfc1ea5390f12122d2e786c1e2030dcc97d3790b6d7523432548198b1f94",
+    "elapsed_seconds": 5.802506145002553,
+    "gpu": "NVIDIA GeForce RTX 5090",
+    "initial_free_vram": 33179500544,
+    "max_absolute_probability_difference": 0.0,
+    "reload": true,
+    "row_ids": [
+      "seed-10000-turn-0",
+      "seed-10000-turn-1",
+      "seed-10000-turn-2",
+      "seed-10000-turn-3"
+    ],
+    "source_commit": "7a21f6491bcaf2afacc9aa5b5e2733a35c41a7a8",
+    "source_dirty": false,
+    "source_identity_method": "exact-git-root",
+    "status": "passed",
+    "tolerance": 0.0001,
+    "torch": "2.14.1+cu130",
+    "total_vram": 33711521792
+  },
+  "runtime": {
+    "decision_latency_scope": "All Player.choose calls, including encoding and probability transfer; no excluded warmup; cached local model initialization recorded separately. Policies visit different states.",
+    "energy_measured": false,
+    "final_evaluation_wrapper_seconds": 5103.112404823303,
+    "monetary_cost_measured": false,
+    "trained_to_heuristic_mean_decision_latency_ratio": 1041.8358778494417,
+    "wrapper_scope": "Includes service stop/restore and health checks, evaluation, model loading and report writing; not pure inference time."
+  },
+  "schema_version": 1,
+  "selection": {
+    "checkpoint_sha256": {
+      "adapter/README.md": "bf1fa63446e8ee38c5ac154ade9138a0e2354e3215201f59473102eeb5206fa0",
+      "adapter/adapter_config.json": "bbbce7f19e186b4a79c39d03786bb190d6084e7990a601e8e28672cf1c969741",
+      "adapter/adapter_model.safetensors": "3ed169fe68b20a370bb856f9d91842543374ff3c98fd3bbe139ef2d0b97877a3",
+      "joint_head.safetensors": "4f21c0f315cf1bcf852a9887d158928855eaa9bdcab6b9770d518abf3727fa1b",
+      "reference.json": "adacc63684d28598f8016602bab790cd3967317986b6934dd94a5e14fabe571f",
+      "training_config.json": "3ead31d0a3ccb6a62914c3853ee26332f6412382c5196e40b461182e64d8b329"
+    },
+    "dataset_manifest_sha256": "aeddcfc1ea5390f12122d2e786c1e2030dcc97d3790b6d7523432548198b1f94",
+    "decision_rule": "lowest finite mean target NLL over all 215 validation positions; exact tie chooses earlier epoch",
+    "selected_key": "epoch-02",
+    "selection_sha256": "025b62587a26bd8cc78c80f362524b8c178190df5188b317299121afa6b1203b",
+    "validation": {
+      "epoch-01": {
+        "players": {
+          "base": {
+            "available_subset_mean_brier": 0.9231725575578064,
+            "complete_probability_coverage": true,
+            "correct": 21,
+            "error_rate": 0.0,
+            "failed_predictions": [],
+            "finite_subset_mean_nll": 2.9527020509302693,
+            "finite_subset_nll_positions": 215,
+            "mean_brier": 0.9231725575578064,
+            "mean_nll": 2.9527020509302693,
+            "missing_probabilities": [],
+            "nll_is_infinite": false,
+            "positions": 215,
+            "probability_positions": 215,
+            "selection_performed": false,
+            "teacher_agreement": 0.09767441860465116,
+            "zero_target_probability_count": 0
+          },
+          "base-fp32": {
+            "available_subset_mean_brier": 0.9231017245023939,
+            "complete_probability_coverage": true,
+            "correct": 22,
+            "error_rate": 0.0,
+            "failed_predictions": [],
+            "finite_subset_mean_nll": 2.9523931327950934,
+            "finite_subset_nll_positions": 215,
+            "mean_brier": 0.9231017245023939,
+            "mean_nll": 2.9523931327950934,
+            "missing_probabilities": [],
+            "nll_is_infinite": false,
+            "positions": 215,
+            "probability_positions": 215,
+            "selection_performed": false,
+            "teacher_agreement": 0.10232558139534884,
+            "zero_target_probability_count": 0
+          },
+          "trained": {
+            "available_subset_mean_brier": 0.7221895727255984,
+            "complete_probability_coverage": true,
+            "correct": 89,
+            "error_rate": 0.0,
+            "failed_predictions": [],
+            "finite_subset_mean_nll": 1.8608697515370076,
+            "finite_subset_nll_positions": 215,
+            "mean_brier": 0.7221895727255984,
+            "mean_nll": 1.8608697515370076,
+            "missing_probabilities": [],
+            "nll_is_infinite": false,
+            "positions": 215,
+            "probability_positions": 215,
+            "selection_performed": false,
+            "teacher_agreement": 0.413953488372093,
+            "zero_target_probability_count": 0
+          }
+        },
+        "provenance": {
+          "base_revision": "17f0b0ad64efb65d273590632833508766b2aae6",
+          "encoding_version": "stackcraft-clef-v1",
+          "installed_versions": {
+            "huggingface-hub": "1.33.0",
+            "peft": "0.21.2",
+            "safetensors": "0.8.0",
+            "torch": "2.14.1+cu130",
+            "transformers": "5.18.0"
+          },
+          "precision_policy": "native BF16 base; FP32 trained head; optional base-fp32 ablation",
+          "rules_version": "stackcraft-v1",
+          "source_commit": "ada38885b55ae3e4b6705a18dec98d194d37447e",
+          "source_dirty": false,
+          "source_hashes": {
+            "scripts/evaluate_clef.py": "70a47e9314ec9d7351a939bae32f07f14bd08f6106b60ce6155687c0540b92dd",
+            "src/stackcraft/clef.py": "c505f35d27121ba9ec9db3c663927ac8b28304f4ed864765be61ce96c8c86e13",
+            "src/stackcraft/data.py": "74b68a1f391a3128d2e499c7e86b6c94a1f2a2bef33ffe75c8631207065bd991",
+            "src/stackcraft/engine.py": "0805be38ee968d569fa1c12230730f491490f7d27cfcc570c400ac3b4a546453",
+            "src/stackcraft/evaluation.py": "df56f9d36655e79573a014a5c55c2571bc5e04e2c20f1b37e2d939b871e889e6",
+            "src/stackcraft/pieces.py": "c5bee0f8767aeeab279cfbadb4c7b4c0bbf1f31c1d29b08dda197f0627654b29",
+            "src/stackcraft/players/__init__.py": "550bed9237303a845cdcc101542b0b688173a8f5436dd1d08c5f85a5a19fa2b2",
+            "src/stackcraft/provenance.py": "0728104f22361ad2a8b4471e6eef0467852d94f650d0259d7f5f674c0086f13b",
+            "src/stackcraft/schema.py": "35c70d96e8a49e434dc0a3607412a0ce58141306df59e09b1170511694cb6eb5",
+            "src/stackcraft/tournament.py": "288ed447a32e0845f52097372a644fc211b1632790655f620801d3ce1639d559",
+            "src/stackcraft/training.py": "f7e48b041b331cf2b68674ec2abb1059dd1da47cb261697b46260b4f0169dba8",
+            "uv.lock": "bc7fae476529578be003856b5f19e09c8cc96e0020ab999e20e1f8210696f9c8"
+          },
+          "source_identity_method": "exact-git-root"
+        },
+        "report_sha256": "ce401ef9fe1d25c11c7a0e3845def347967d8617223307ad823e23a90c3f0033"
+      },
+      "epoch-02": {
+        "players": {
+          "trained": {
+            "available_subset_mean_brier": 0.7089798657211578,
+            "complete_probability_coverage": true,
+            "correct": 92,
+            "error_rate": 0.0,
+            "failed_predictions": [],
+            "finite_subset_mean_nll": 1.7759231168523646,
+            "finite_subset_nll_positions": 215,
+            "mean_brier": 0.7089798657211578,
+            "mean_nll": 1.7759231168523646,
+            "missing_probabilities": [],
+            "nll_is_infinite": false,
+            "positions": 215,
+            "probability_positions": 215,
+            "selection_performed": false,
+            "teacher_agreement": 0.42790697674418604,
+            "zero_target_probability_count": 0
+          }
+        },
+        "provenance": {
+          "base_revision": "17f0b0ad64efb65d273590632833508766b2aae6",
+          "encoding_version": "stackcraft-clef-v1",
+          "installed_versions": {
+            "huggingface-hub": "1.33.0",
+            "peft": "0.21.2",
+            "safetensors": "0.8.0",
+            "torch": "2.14.1+cu130",
+            "transformers": "5.18.0"
+          },
+          "precision_policy": "native BF16 base; FP32 trained head; optional base-fp32 ablation",
+          "rules_version": "stackcraft-v1",
+          "source_commit": "7a21f6491bcaf2afacc9aa5b5e2733a35c41a7a8",
+          "source_dirty": false,
+          "source_hashes": {
+            "scripts/evaluate_clef.py": "70a47e9314ec9d7351a939bae32f07f14bd08f6106b60ce6155687c0540b92dd",
+            "src/stackcraft/clef.py": "c505f35d27121ba9ec9db3c663927ac8b28304f4ed864765be61ce96c8c86e13",
+            "src/stackcraft/data.py": "74b68a1f391a3128d2e499c7e86b6c94a1f2a2bef33ffe75c8631207065bd991",
+            "src/stackcraft/engine.py": "0805be38ee968d569fa1c12230730f491490f7d27cfcc570c400ac3b4a546453",
+            "src/stackcraft/evaluation.py": "df56f9d36655e79573a014a5c55c2571bc5e04e2c20f1b37e2d939b871e889e6",
+            "src/stackcraft/pieces.py": "c5bee0f8767aeeab279cfbadb4c7b4c0bbf1f31c1d29b08dda197f0627654b29",
+            "src/stackcraft/players/__init__.py": "550bed9237303a845cdcc101542b0b688173a8f5436dd1d08c5f85a5a19fa2b2",
+            "src/stackcraft/provenance.py": "0728104f22361ad2a8b4471e6eef0467852d94f650d0259d7f5f674c0086f13b",
+            "src/stackcraft/schema.py": "35c70d96e8a49e434dc0a3607412a0ce58141306df59e09b1170511694cb6eb5",
+            "src/stackcraft/tournament.py": "288ed447a32e0845f52097372a644fc211b1632790655f620801d3ce1639d559",
+            "src/stackcraft/training.py": "f7e48b041b331cf2b68674ec2abb1059dd1da47cb261697b46260b4f0169dba8",
+            "uv.lock": "bc7fae476529578be003856b5f19e09c8cc96e0020ab999e20e1f8210696f9c8"
+          },
+          "source_identity_method": "exact-git-root"
+        },
+        "report_sha256": "9482be5ac08b85a7bafc18d8f70a35ba277f476d9a96dd0684553e937abc4d2a"
+      }
+    }
+  },
+  "status": "final evaluation complete; publication pending",
+  "training": {
+    "config": {
+      "batch_size": 1,
+      "brier_weight": 0.1,
+      "clip_gradient_norm": 1.0,
+      "epochs": 2,
+      "gradient_accumulation": 8,
+      "label_smoothing": 0.05,
+      "learning_rate": 1e-05,
+      "max_length": 4096,
+      "mode": "lora",
+      "optimizer": "AdamW",
+      "rank": 4,
+      "seed": 42,
+      "selection": "external validation only; this script does not choose a checkpoint",
+      "weight_decay": 0.01
+    },
+    "dataset_counts": {
+      "train": 827,
+      "validation": 215
+    },
+    "dataset_manifest_sha256": "aeddcfc1ea5390f12122d2e786c1e2030dcc97d3790b6d7523432548198b1f94",
+    "dataset_split_sha256": {
+      "train": "edd682761db95a4f25bb30a284489c54d9336a36da0a9b19d2cda860b428baa8",
+      "validation": "eff9cdc5932e935959ac4d26dce6470d335090f7428a91930001954266d133bc"
+    },
+    "elapsed_seconds": 1511.2463698700012,
+    "epochs": [
+      {
+        "checkpoint": "runs/study-v1/epoch-01",
+        "epoch": 1,
+        "examples": 827,
+        "mean_training_loss": 2.5779671531346287,
+        "optimizer_steps": 104,
+        "peak_allocated_bytes": 23230341120,
+        "peak_reserved_bytes": 24178065408,
+        "seconds": 742.4755487579969,
+        "shuffle_order_sha256": "b6e0d7189b1d965472f1132dda2e9be3a35093dae838baf5d8e0c0d3471b6198"
+      },
+      {
+        "checkpoint": "runs/study-v1/epoch-02",
+        "epoch": 2,
+        "examples": 827,
+        "mean_training_loss": 1.9667175294878694,
+        "optimizer_steps": 104,
+        "peak_allocated_bytes": 23226543104,
+        "peak_reserved_bytes": 24178065408,
+        "seconds": 744.6554337799898,
+        "shuffle_order_sha256": "b9d20efe77959592c99e9247a58d844be69df50db595bd87c6d7e595f5d2e0c4"
+      }
+    ],
+    "frozen_parameters_unchanged": true,
+    "source_commit": "d9fcd05c02e9327d4d791f2338725092cede8bdd",
+    "source_dirty": true,
+    "source_hashes": {
+      "scripts/train_clef.py": "e83586cf0fd0d7bb8c4aa15f9b858b9f9ffdb915622e355deb9513788d5054aa",
+      "src/stackcraft/clef.py": "c505f35d27121ba9ec9db3c663927ac8b28304f4ed864765be61ce96c8c86e13",
+      "src/stackcraft/data.py": "74b68a1f391a3128d2e499c7e86b6c94a1f2a2bef33ffe75c8631207065bd991",
+      "src/stackcraft/training.py": "f7e48b041b331cf2b68674ec2abb1059dd1da47cb261697b46260b4f0169dba8"
+    },
+    "test_trajectories_used": false,
+    "trainable_parameters": 132582404,
+    "validation_used_for_training": false
+  }
+}

code/reports/gpu-feasibility.json

@@ -0,0 +1,210 @@
+{
+  "runs/probe-v1/report.json": {
+    "sha256": "b66d2c01a43d08234229f3d7d3980a7d2d161fb21aa26965acb3bfe243351807",
+    "report": {
+      "status": "passed",
+      "reload": false,
+      "gpu": "NVIDIA GeForce RTX 5090",
+      "total_vram": 33711521792,
+      "initial_free_vram": 33179500544,
+      "torch": "2.14.1+cu130",
+      "dataset_manifest_sha256": "aeddcfc1ea5390f12122d2e786c1e2030dcc97d3790b6d7523432548198b1f94",
+      "source_commit": "e38ac536d0a6af444b48fddd6d8789ace089a51c",
+      "row_ids": [
+        "seed-10000-turn-0",
+        "seed-10000-turn-1",
+        "seed-10000-turn-2",
+        "seed-10000-turn-3"
+      ],
+      "runtime_config": {
+        "model_id": "Cloudflare/clef-flash",
+        "revision": "Cloudflare/clef-flash@17f0b0ad64efb65d273590632833508766b2aae6:stackcraft-clef-v1",
+        "base_revision": "17f0b0ad64efb65d273590632833508766b2aae6",
+        "encoding_version": "stackcraft-clef-v1",
+        "source_sha256": "0e304cf7c6500e8bb59bef7e2afd2c6373f82596dfb3b57d1aa93c175e2dc3a3",
+        "max_length": 4096,
+        "dtype": "torch.bfloat16",
+        "device": "cuda:0"
+      },
+      "load_and_native_seconds": 5.267827647010563,
+      "fp32_head_initial_max_probability_drift": 0.0007441192865371704,
+      "head_steps": [
+        {
+          "step": 1,
+          "row_id": "seed-10000-turn-0",
+          "tokens": 2248,
+          "loss": 3.5077385902404785,
+          "gradient_abs_sums": {
+            "head": 1406.742018819321,
+            "lora": 0.0
+          },
+          "seconds": 0.3278578449971974,
+          "peak_allocated_bytes": 21323760640,
+          "peak_reserved_bytes": 21369978880
+        },
+        {
+          "step": 2,
+          "row_id": "seed-10000-turn-1",
+          "tokens": 2252,
+          "loss": 3.839761734008789,
+          "gradient_abs_sums": {
+            "head": 3064.3000336452387,
+            "lora": 0.0
+          },
+          "seconds": 0.258370580006158,
+          "peak_allocated_bytes": 21323760640,
+          "peak_reserved_bytes": 21541945344
+        },
+        {
+          "step": 3,
+          "row_id": "seed-10000-turn-2",
+          "tokens": 1302,
+          "loss": 2.7408740520477295,
+          "gradient_abs_sums": {
+            "head": 2409.824099964928,
+            "lora": 0.0
+          },
+          "seconds": 0.1538237390050199,
+          "peak_allocated_bytes": 21323760640,
+          "peak_reserved_bytes": 21541945344
+        }
+      ],
+      "head_frozen_parameters_unchanged": true,
+      "lora_steps": [
+        {
+          "step": 1,
+          "row_id": "seed-10000-turn-0",
+          "tokens": 2248,
+          "loss": 3.5077385902404785,
+          "gradient_abs_sums": {
+            "head": 1406.742226867238,
+            "lora": 4314.483247246593
+          },
+          "seconds": 1.3170126390177757,
+          "peak_allocated_bytes": 22128918016,
+          "peak_reserved_bytes": 22531801088
+        },
+        {
+          "step": 2,
+          "row_id": "seed-10000-turn-1",
+          "tokens": 2252,
+          "loss": 3.845935106277466,
+          "gradient_abs_sums": {
+            "head": 3134.688414009288,
+            "lora": 2980.2572337791935
+          },
+          "seconds": 1.3217443070025183,
+          "peak_allocated_bytes": 23176526848,
+          "peak_reserved_bytes": 23483908096
+        },
+        {
+          "step": 3,
+          "row_id": "seed-10000-turn-2",
+          "tokens": 1302,
+          "loss": 2.744056463241577,
+          "gradient_abs_sums": {
+            "head": 2369.929164870642,
+            "lora": 3249.260241425407
+          },
+          "seconds": 0.672728523000842,
+          "peak_allocated_bytes": 23176526848,
+          "peak_reserved_bytes": 23483908096
+        },
+        {
+          "step": 4,
+          "row_id": "seed-10000-turn-3",
+          "tokens": 1304,
+          "loss": 2.775989294052124,
+          "gradient_abs_sums": {
+            "head": 2491.2841364948545,
+            "lora": 3332.906228476757
+          },
+          "seconds": 0.6700605849910062,
+          "peak_allocated_bytes": 23176526848,
+          "peak_reserved_bytes": 23483908096
+        },
+        {
+          "step": 5,
+          "row_id": "seed-10000-turn-0",
+          "tokens": 2248,
+          "loss": 3.4597291946411133,
+          "gradient_abs_sums": {
+            "head": 1691.1293117979076,
+            "lora": 4719.155243932968
+          },
+          "seconds": 1.3178317880083341,
+          "peak_allocated_bytes": 23180389888,
+          "peak_reserved_bytes": 23595057152
+        }
+      ],
+      "checkpoint": "runs/probe-v1/checkpoint",
+      "frozen_parameters_unchanged": true,
+      "elapsed_seconds": 51.810954032989684
+    }
+  },
+  "runs/probe-head-reload-v1/report.json": {
+    "sha256": "ed7afb912569ce4738d506962ca98c33cbbaee2d922ab4bff7b8adcbbae8c521",
+    "report": {
+      "status": "passed",
+      "reload": true,
+      "gpu": "NVIDIA GeForce RTX 5090",
+      "total_vram": 33711521792,
+      "initial_free_vram": 33179500544,
+      "torch": "2.14.1+cu130",
+      "dataset_manifest_sha256": "aeddcfc1ea5390f12122d2e786c1e2030dcc97d3790b6d7523432548198b1f94",
+      "source_commit": "e38ac536d0a6af444b48fddd6d8789ace089a51c",
+      "row_ids": [
+        "seed-10000-turn-0",
+        "seed-10000-turn-1",
+        "seed-10000-turn-2",
+        "seed-10000-turn-3"
+      ],
+      "max_absolute_probability_difference": 0.0,
+      "tolerance": 0.0001,
+      "elapsed_seconds": 5.435347482009092
+    }
+  },
+  "runs/probe-reload-v1/report.json": {
+    "sha256": "174d5267b1825bbd66bcf4456fdc97b505e7a3565557462358ab99c66bd11539",
+    "report": {
+      "status": "failed",
+      "reload": true,
+      "gpu": "NVIDIA GeForce RTX 5090",
+      "total_vram": 33711521792,
+      "initial_free_vram": 33179500544,
+      "torch": "2.14.1+cu130",
+      "dataset_manifest_sha256": "aeddcfc1ea5390f12122d2e786c1e2030dcc97d3790b6d7523432548198b1f94",
+      "source_commit": "e38ac536d0a6af444b48fddd6d8789ace089a51c",
+      "row_ids": [
+        "seed-10000-turn-0",
+        "seed-10000-turn-1",
+        "seed-10000-turn-2",
+        "seed-10000-turn-3"
+      ],
+      "error": "ValueError: saved adapter configuration differs from checkpoint metadata",
+      "elapsed_seconds": 4.1464992630062625
+    }
+  },
+  "runs/probe-reload-v2/report.json": {
+    "sha256": "1687e90ab5518785bc3c6a1701978828f410624bab6e297e5a4a2deb8bdcf2e3",
+    "report": {
+      "status": "passed",
+      "reload": true,
+      "gpu": "NVIDIA GeForce RTX 5090",
+      "total_vram": 33711521792,
+      "initial_free_vram": 33179500544,
+      "torch": "2.14.1+cu130",
+      "dataset_manifest_sha256": "aeddcfc1ea5390f12122d2e786c1e2030dcc97d3790b6d7523432548198b1f94",
+      "source_commit": "f7be7ceee9c38566dfebad0ebf5f1c04958faee3",
+      "row_ids": [
+        "seed-10000-turn-0",
+        "seed-10000-turn-1",
+        "seed-10000-turn-2",
+        "seed-10000-turn-3"
+      ],
+      "max_absolute_probability_difference": 0.0,
+      "tolerance": 0.0001,
+      "elapsed_seconds": 5.648779143986758
+    }
+  }
+}

code/reports/selected-checkpoint-reload.json

@@ -0,0 +1,21 @@
+{
+  "status": "passed",
+  "reload": true,
+  "gpu": "NVIDIA GeForce RTX 5090",
+  "total_vram": 33711521792,
+  "initial_free_vram": 33179500544,
+  "torch": "2.14.1+cu130",
+  "dataset_manifest_sha256": "aeddcfc1ea5390f12122d2e786c1e2030dcc97d3790b6d7523432548198b1f94",
+  "row_ids": [
+    "seed-10000-turn-0",
+    "seed-10000-turn-1",
+    "seed-10000-turn-2",
+    "seed-10000-turn-3"
+  ],
+  "source_commit": "7a21f6491bcaf2afacc9aa5b5e2733a35c41a7a8",
+  "source_dirty": false,
+  "source_identity_method": "exact-git-root",
+  "max_absolute_probability_difference": 0.0,
+  "tolerance": 0.0001,
+  "elapsed_seconds": 5.802506145002553
+}

code/reports/study-preregistration.md

@@ -0,0 +1,25 @@
+# Archived training and final-test preregistration
+
+The excerpt below is preserved verbatim from `record.md` at training launch commit
+`d9fcd05c02e9327d4d791f2338725092cede8bdd`. The original complete record's SHA256 is
+`bb18a6fc7c21d3d186afcf682e724015263340f3c269500951f8f159054453e1`. This archive lets readers inspect the
+recorded decisions without access to the original Git repository. It documents
+what was recorded; it is not a signed timestamp or independent registration service.
+
+The final checkpoint selection and evaluation request provide separate hashes of
+the actual artifacts used. This archive is historical: later outcomes belong in
+the training, validation, reload and final evaluation reports.
+
+---
+
+## 2026-10-05 — M4 training and M5 preregistration
+
+Real-weight probe from e38ac53 passed3head-only and5rank4LoRA steps. Both trainable groups changed; full frozen parameter hashes were unchanged. All recorded losses and gradients finite, head and LoRA gradients nonzero. LoRA peak allocated23,180,389,888bytes/reserved23,595,057,152bytes; step time0.67–1.32s on1302–2252tokens. Wrapper restored GLM and verified its in-container health. Fresh-process parity is the remaining M4 gate; artifacts runs/probe-v1 and runs/probe-reload-v1.
+
+Conditional on M4 reload passing, preregister M5: one seed42, BF16 native backbone, FP32 native head, rank4/alpha8/dropout0 text-only LoRA, no quantization, max4096tokens, AdamW lr1e-5/weight_decay0.01, batch1, gradient accumulation8 (last partial group normalized by actual size), norm clip1, CE label smoothing0.05 plus Brier sum weight0.1. Train exactly two epochs over the827 fixed training positions shuffled deterministically per epoch; save both epoch checkpoints. Bounded search is these two checkpoints only; exclude feasibility-probe checkpoints. Use all215 validation positions to select the epoch with lowest finite mean target NLL; exact tie chooses earlier epoch. Report teacher agreement and Brier as diagnostics, not selection overrides. If either candidate has inference errors or nonfinite NLL it is ineligible. If both fail, preserve evidence and reconsider before tests. Initial fulltraining timeout3600s; no test access during training/selection.
+
+Freeze final evaluation at200paired seeds30000–30199 and200piececap, bootstrap10000replicates/seed2026, error threshold0. Primary comparison selectedtrained versus unchanged nativeBF16headClef. Include an unchangedFP32head ablation to separate precision change from learning, plus random and heuristic. Same rules, complete observation encoding, pinnedbackbone, legalchoices and preview. Three neural policies at200×200moves and144ms imply4.8h worst-case, but unchangedbase dies around28pieces in development; expect much less. Allow bounded per-policy execution with incremental artifacts; never drop failedseeds or quietly reducepool. Record exact checkpoint and validation evidence hashes before any testepisode. Publish negative outcomes honestly; no tuning after testresults.
+
+Fresh LoRA reload v1 correctly rejected PEFT's shortened target list. Saved496adapter tensors independently map exactly248intended text layers; weights were sound. Loader now expands saved targets over every backbone module and requires exact target equality, rejecting accidental vision/MTP/output matches. A32-layer tiny-backbone regression reproduces PEFT shortening. New saves use explicit full targets and canonical pinned model ID. Original failed artifact and probe weights preserved; retry uses same checkpoint, not a new training configuration. Head-only fresh-process reload passed independently; GLM restored healthy on both success and rejectedreload.
+
+M4 complete: head-only fresh reload maxabsoluteprobabilitydifference0.0 (tolerance1e-4); unchanged saved LoRA checkpoint retry after semantic-target validation also0.0. Both fresh processes loaded pinned weights; no retraining needed for reload fix. Compact reports/gpu-feasibility.json retains success and original rejectedreload with sourcehashes. Fulltraining preregistration above is now enabled; output runs/study-v1 with two epoch checkpoints,3600second wrapper timeout and restored GLM health.

code/reports/study-training.json

@@ -0,0 +1,696 @@
+{
+  "changed_trainable_parameter_names": [
+    "language_model.base_model.model.model.language_model.layers.0.linear_attn.out_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.0.linear_attn.out_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.0.linear_attn.in_proj_qkv.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.0.linear_attn.in_proj_qkv.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.0.linear_attn.in_proj_z.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.0.linear_attn.in_proj_z.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.0.linear_attn.in_proj_b.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.0.linear_attn.in_proj_b.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.0.linear_attn.in_proj_a.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.0.linear_attn.in_proj_a.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.0.mlp.gate_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.0.mlp.gate_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.0.mlp.up_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.0.mlp.up_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.0.mlp.down_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.0.mlp.down_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.1.linear_attn.out_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.1.linear_attn.out_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.1.linear_attn.in_proj_qkv.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.1.linear_attn.in_proj_qkv.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.1.linear_attn.in_proj_z.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.1.linear_attn.in_proj_z.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.1.linear_attn.in_proj_b.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.1.linear_attn.in_proj_b.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.1.linear_attn.in_proj_a.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.1.linear_attn.in_proj_a.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.1.mlp.gate_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.1.mlp.gate_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.1.mlp.up_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.1.mlp.up_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.1.mlp.down_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.1.mlp.down_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.2.linear_attn.out_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.2.linear_attn.out_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.2.linear_attn.in_proj_qkv.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.2.linear_attn.in_proj_qkv.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.2.linear_attn.in_proj_z.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.2.linear_attn.in_proj_z.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.2.linear_attn.in_proj_b.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.2.linear_attn.in_proj_b.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.2.linear_attn.in_proj_a.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.2.linear_attn.in_proj_a.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.2.mlp.gate_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.2.mlp.gate_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.2.mlp.up_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.2.mlp.up_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.2.mlp.down_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.2.mlp.down_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.3.self_attn.q_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.3.self_attn.q_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.3.self_attn.k_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.3.self_attn.k_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.3.self_attn.v_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.3.self_attn.v_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.3.self_attn.o_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.3.self_attn.o_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.3.mlp.gate_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.3.mlp.gate_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.3.mlp.up_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.3.mlp.up_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.3.mlp.down_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.3.mlp.down_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.4.linear_attn.out_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.4.linear_attn.out_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.4.linear_attn.in_proj_qkv.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.4.linear_attn.in_proj_qkv.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.4.linear_attn.in_proj_z.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.4.linear_attn.in_proj_z.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.4.linear_attn.in_proj_b.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.4.linear_attn.in_proj_b.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.4.linear_attn.in_proj_a.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.4.linear_attn.in_proj_a.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.4.mlp.gate_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.4.mlp.gate_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.4.mlp.up_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.4.mlp.up_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.4.mlp.down_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.4.mlp.down_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.5.linear_attn.out_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.5.linear_attn.out_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.5.linear_attn.in_proj_qkv.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.5.linear_attn.in_proj_qkv.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.5.linear_attn.in_proj_z.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.5.linear_attn.in_proj_z.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.5.linear_attn.in_proj_b.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.5.linear_attn.in_proj_b.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.5.linear_attn.in_proj_a.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.5.linear_attn.in_proj_a.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.5.mlp.gate_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.5.mlp.gate_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.5.mlp.up_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.5.mlp.up_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.5.mlp.down_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.5.mlp.down_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.6.linear_attn.out_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.6.linear_attn.out_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.6.linear_attn.in_proj_qkv.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.6.linear_attn.in_proj_qkv.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.6.linear_attn.in_proj_z.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.6.linear_attn.in_proj_z.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.6.linear_attn.in_proj_b.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.6.linear_attn.in_proj_b.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.6.linear_attn.in_proj_a.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.6.linear_attn.in_proj_a.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.6.mlp.gate_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.6.mlp.gate_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.6.mlp.up_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.6.mlp.up_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.6.mlp.down_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.6.mlp.down_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.7.self_attn.q_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.7.self_attn.q_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.7.self_attn.k_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.7.self_attn.k_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.7.self_attn.v_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.7.self_attn.v_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.7.self_attn.o_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.7.self_attn.o_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.7.mlp.gate_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.7.mlp.gate_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.7.mlp.up_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.7.mlp.up_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.7.mlp.down_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.7.mlp.down_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.8.linear_attn.out_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.8.linear_attn.out_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.8.linear_attn.in_proj_qkv.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.8.linear_attn.in_proj_qkv.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.8.linear_attn.in_proj_z.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.8.linear_attn.in_proj_z.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.8.linear_attn.in_proj_b.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.8.linear_attn.in_proj_b.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.8.linear_attn.in_proj_a.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.8.linear_attn.in_proj_a.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.8.mlp.gate_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.8.mlp.gate_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.8.mlp.up_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.8.mlp.up_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.8.mlp.down_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.8.mlp.down_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.9.linear_attn.out_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.9.linear_attn.out_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.9.linear_attn.in_proj_qkv.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.9.linear_attn.in_proj_qkv.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.9.linear_attn.in_proj_z.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.9.linear_attn.in_proj_z.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.9.linear_attn.in_proj_b.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.9.linear_attn.in_proj_b.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.9.linear_attn.in_proj_a.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.9.linear_attn.in_proj_a.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.9.mlp.gate_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.9.mlp.gate_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.9.mlp.up_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.9.mlp.up_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.9.mlp.down_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.9.mlp.down_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.10.linear_attn.out_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.10.linear_attn.out_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.10.linear_attn.in_proj_qkv.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.10.linear_attn.in_proj_qkv.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.10.linear_attn.in_proj_z.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.10.linear_attn.in_proj_z.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.10.linear_attn.in_proj_b.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.10.linear_attn.in_proj_b.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.10.linear_attn.in_proj_a.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.10.linear_attn.in_proj_a.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.10.mlp.gate_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.10.mlp.gate_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.10.mlp.up_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.10.mlp.up_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.10.mlp.down_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.10.mlp.down_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.11.self_attn.q_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.11.self_attn.q_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.11.self_attn.k_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.11.self_attn.k_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.11.self_attn.v_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.11.self_attn.v_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.11.self_attn.o_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.11.self_attn.o_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.11.mlp.gate_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.11.mlp.gate_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.11.mlp.up_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.11.mlp.up_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.11.mlp.down_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.11.mlp.down_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.12.linear_attn.out_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.12.linear_attn.out_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.12.linear_attn.in_proj_qkv.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.12.linear_attn.in_proj_qkv.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.12.linear_attn.in_proj_z.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.12.linear_attn.in_proj_z.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.12.linear_attn.in_proj_b.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.12.linear_attn.in_proj_b.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.12.linear_attn.in_proj_a.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.12.linear_attn.in_proj_a.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.12.mlp.gate_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.12.mlp.gate_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.12.mlp.up_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.12.mlp.up_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.12.mlp.down_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.12.mlp.down_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.13.linear_attn.out_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.13.linear_attn.out_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.13.linear_attn.in_proj_qkv.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.13.linear_attn.in_proj_qkv.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.13.linear_attn.in_proj_z.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.13.linear_attn.in_proj_z.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.13.linear_attn.in_proj_b.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.13.linear_attn.in_proj_b.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.13.linear_attn.in_proj_a.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.13.linear_attn.in_proj_a.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.13.mlp.gate_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.13.mlp.gate_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.13.mlp.up_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.13.mlp.up_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.13.mlp.down_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.13.mlp.down_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.14.linear_attn.out_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.14.linear_attn.out_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.14.linear_attn.in_proj_qkv.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.14.linear_attn.in_proj_qkv.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.14.linear_attn.in_proj_z.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.14.linear_attn.in_proj_z.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.14.linear_attn.in_proj_b.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.14.linear_attn.in_proj_b.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.14.linear_attn.in_proj_a.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.14.linear_attn.in_proj_a.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.14.mlp.gate_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.14.mlp.gate_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.14.mlp.up_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.14.mlp.up_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.14.mlp.down_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.14.mlp.down_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.15.self_attn.q_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.15.self_attn.q_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.15.self_attn.k_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.15.self_attn.k_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.15.self_attn.v_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.15.self_attn.v_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.15.self_attn.o_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.15.self_attn.o_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.15.mlp.gate_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.15.mlp.gate_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.15.mlp.up_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.15.mlp.up_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.15.mlp.down_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.15.mlp.down_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.16.linear_attn.out_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.16.linear_attn.out_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.16.linear_attn.in_proj_qkv.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.16.linear_attn.in_proj_qkv.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.16.linear_attn.in_proj_z.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.16.linear_attn.in_proj_z.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.16.linear_attn.in_proj_b.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.16.linear_attn.in_proj_b.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.16.linear_attn.in_proj_a.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.16.linear_attn.in_proj_a.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.16.mlp.gate_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.16.mlp.gate_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.16.mlp.up_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.16.mlp.up_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.16.mlp.down_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.16.mlp.down_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.17.linear_attn.out_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.17.linear_attn.out_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.17.linear_attn.in_proj_qkv.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.17.linear_attn.in_proj_qkv.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.17.linear_attn.in_proj_z.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.17.linear_attn.in_proj_z.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.17.linear_attn.in_proj_b.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.17.linear_attn.in_proj_b.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.17.linear_attn.in_proj_a.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.17.linear_attn.in_proj_a.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.17.mlp.gate_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.17.mlp.gate_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.17.mlp.up_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.17.mlp.up_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.17.mlp.down_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.17.mlp.down_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.18.linear_attn.out_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.18.linear_attn.out_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.18.linear_attn.in_proj_qkv.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.18.linear_attn.in_proj_qkv.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.18.linear_attn.in_proj_z.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.18.linear_attn.in_proj_z.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.18.linear_attn.in_proj_b.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.18.linear_attn.in_proj_b.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.18.linear_attn.in_proj_a.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.18.linear_attn.in_proj_a.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.18.mlp.gate_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.18.mlp.gate_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.18.mlp.up_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.18.mlp.up_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.18.mlp.down_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.18.mlp.down_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.19.self_attn.q_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.19.self_attn.q_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.19.self_attn.k_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.19.self_attn.k_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.19.self_attn.v_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.19.self_attn.v_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.19.self_attn.o_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.19.self_attn.o_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.19.mlp.gate_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.19.mlp.gate_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.19.mlp.up_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.19.mlp.up_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.19.mlp.down_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.19.mlp.down_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.20.linear_attn.out_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.20.linear_attn.out_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.20.linear_attn.in_proj_qkv.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.20.linear_attn.in_proj_qkv.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.20.linear_attn.in_proj_z.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.20.linear_attn.in_proj_z.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.20.linear_attn.in_proj_b.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.20.linear_attn.in_proj_b.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.20.linear_attn.in_proj_a.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.20.linear_attn.in_proj_a.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.20.mlp.gate_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.20.mlp.gate_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.20.mlp.up_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.20.mlp.up_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.20.mlp.down_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.20.mlp.down_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.21.linear_attn.out_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.21.linear_attn.out_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.21.linear_attn.in_proj_qkv.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.21.linear_attn.in_proj_qkv.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.21.linear_attn.in_proj_z.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.21.linear_attn.in_proj_z.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.21.linear_attn.in_proj_b.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.21.linear_attn.in_proj_b.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.21.linear_attn.in_proj_a.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.21.linear_attn.in_proj_a.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.21.mlp.gate_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.21.mlp.gate_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.21.mlp.up_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.21.mlp.up_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.21.mlp.down_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.21.mlp.down_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.22.linear_attn.out_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.22.linear_attn.out_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.22.linear_attn.in_proj_qkv.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.22.linear_attn.in_proj_qkv.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.22.linear_attn.in_proj_z.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.22.linear_attn.in_proj_z.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.22.linear_attn.in_proj_b.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.22.linear_attn.in_proj_b.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.22.linear_attn.in_proj_a.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.22.linear_attn.in_proj_a.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.22.mlp.gate_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.22.mlp.gate_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.22.mlp.up_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.22.mlp.up_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.22.mlp.down_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.22.mlp.down_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.23.self_attn.q_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.23.self_attn.q_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.23.self_attn.k_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.23.self_attn.k_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.23.self_attn.v_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.23.self_attn.v_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.23.self_attn.o_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.23.self_attn.o_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.23.mlp.gate_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.23.mlp.gate_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.23.mlp.up_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.23.mlp.up_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.23.mlp.down_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.23.mlp.down_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.24.linear_attn.out_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.24.linear_attn.out_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.24.linear_attn.in_proj_qkv.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.24.linear_attn.in_proj_qkv.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.24.linear_attn.in_proj_z.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.24.linear_attn.in_proj_z.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.24.linear_attn.in_proj_b.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.24.linear_attn.in_proj_b.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.24.linear_attn.in_proj_a.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.24.linear_attn.in_proj_a.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.24.mlp.gate_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.24.mlp.gate_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.24.mlp.up_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.24.mlp.up_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.24.mlp.down_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.24.mlp.down_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.25.linear_attn.out_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.25.linear_attn.out_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.25.linear_attn.in_proj_qkv.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.25.linear_attn.in_proj_qkv.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.25.linear_attn.in_proj_z.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.25.linear_attn.in_proj_z.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.25.linear_attn.in_proj_b.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.25.linear_attn.in_proj_b.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.25.linear_attn.in_proj_a.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.25.linear_attn.in_proj_a.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.25.mlp.gate_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.25.mlp.gate_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.25.mlp.up_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.25.mlp.up_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.25.mlp.down_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.25.mlp.down_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.26.linear_attn.out_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.26.linear_attn.out_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.26.linear_attn.in_proj_qkv.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.26.linear_attn.in_proj_qkv.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.26.linear_attn.in_proj_z.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.26.linear_attn.in_proj_z.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.26.linear_attn.in_proj_b.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.26.linear_attn.in_proj_b.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.26.linear_attn.in_proj_a.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.26.linear_attn.in_proj_a.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.26.mlp.gate_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.26.mlp.gate_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.26.mlp.up_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.26.mlp.up_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.26.mlp.down_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.26.mlp.down_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.27.self_attn.q_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.27.self_attn.q_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.27.self_attn.k_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.27.self_attn.k_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.27.self_attn.v_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.27.self_attn.v_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.27.self_attn.o_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.27.self_attn.o_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.27.mlp.gate_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.27.mlp.gate_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.27.mlp.up_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.27.mlp.up_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.27.mlp.down_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.27.mlp.down_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.28.linear_attn.out_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.28.linear_attn.out_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.28.linear_attn.in_proj_qkv.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.28.linear_attn.in_proj_qkv.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.28.linear_attn.in_proj_z.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.28.linear_attn.in_proj_z.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.28.linear_attn.in_proj_b.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.28.linear_attn.in_proj_b.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.28.linear_attn.in_proj_a.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.28.linear_attn.in_proj_a.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.28.mlp.gate_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.28.mlp.gate_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.28.mlp.up_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.28.mlp.up_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.28.mlp.down_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.28.mlp.down_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.29.linear_attn.out_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.29.linear_attn.out_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.29.linear_attn.in_proj_qkv.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.29.linear_attn.in_proj_qkv.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.29.linear_attn.in_proj_z.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.29.linear_attn.in_proj_z.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.29.linear_attn.in_proj_b.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.29.linear_attn.in_proj_b.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.29.linear_attn.in_proj_a.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.29.linear_attn.in_proj_a.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.29.mlp.gate_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.29.mlp.gate_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.29.mlp.up_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.29.mlp.up_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.29.mlp.down_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.29.mlp.down_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.30.linear_attn.out_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.30.linear_attn.out_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.30.linear_attn.in_proj_qkv.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.30.linear_attn.in_proj_qkv.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.30.linear_attn.in_proj_z.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.30.linear_attn.in_proj_z.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.30.linear_attn.in_proj_b.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.30.linear_attn.in_proj_b.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.30.linear_attn.in_proj_a.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.30.linear_attn.in_proj_a.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.30.mlp.gate_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.30.mlp.gate_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.30.mlp.up_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.30.mlp.up_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.30.mlp.down_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.30.mlp.down_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.31.self_attn.q_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.31.self_attn.q_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.31.self_attn.k_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.31.self_attn.k_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.31.self_attn.v_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.31.self_attn.v_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.31.self_attn.o_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.31.self_attn.o_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.31.mlp.gate_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.31.mlp.gate_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.31.mlp.up_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.31.mlp.up_proj.lora_B.default.weight",
+    "language_model.base_model.model.model.language_model.layers.31.mlp.down_proj.lora_A.default.weight",
+    "language_model.base_model.model.model.language_model.layers.31.mlp.down_proj.lora_B.default.weight",
+    "head.native_head.prior_logit_scale",
+    "head.native_head.joint_logit_scale",
+    "head.native_head.residual_gate",
+    "head.native_head.hidden_norm.weight",
+    "head.native_head.hidden_norm.bias",
+    "head.native_head.memory_projection.weight",
+    "head.native_head.question_projection.weight",
+    "head.native_head.option_question_projection.weight",
+    "head.native_head.global_projection.weight",
+    "head.native_head.option_context_projection.weight",
+    "head.native_head.option_lexical_projection.weight",
+    "head.native_head.type_embedding.weight",
+    "head.native_head.evidence_layers.0.query_norm.weight",
+    "head.native_head.evidence_layers.0.query_norm.bias",
+    "head.native_head.evidence_layers.0.memory_norm.weight",
+    "head.native_head.evidence_layers.0.memory_norm.bias",
+    "head.native_head.evidence_layers.0.attention.in_proj_weight",
+    "head.native_head.evidence_layers.0.attention.in_proj_bias",
+    "head.native_head.evidence_layers.0.attention.out_proj.weight",
+    "head.native_head.evidence_layers.0.attention.out_proj.bias",
+    "head.native_head.evidence_layers.0.feedforward_norm.weight",
+    "head.native_head.evidence_layers.0.feedforward_norm.bias",
+    "head.native_head.evidence_layers.0.feedforward.0.weight",
+    "head.native_head.evidence_layers.0.feedforward.0.bias",
+    "head.native_head.evidence_layers.0.feedforward.3.weight",
+    "head.native_head.evidence_layers.0.feedforward.3.bias",
+    "head.native_head.evidence_layers.1.query_norm.weight",
+    "head.native_head.evidence_layers.1.query_norm.bias",
+    "head.native_head.evidence_layers.1.memory_norm.weight",
+    "head.native_head.evidence_layers.1.memory_norm.bias",
+    "head.native_head.evidence_layers.1.attention.in_proj_weight",
+    "head.native_head.evidence_layers.1.attention.in_proj_bias",
+    "head.native_head.evidence_layers.1.attention.out_proj.weight",
+    "head.native_head.evidence_layers.1.attention.out_proj.bias",
+    "head.native_head.evidence_layers.1.feedforward_norm.weight",
+    "head.native_head.evidence_layers.1.feedforward_norm.bias",
+    "head.native_head.evidence_layers.1.feedforward.0.weight",
+    "head.native_head.evidence_layers.1.feedforward.0.bias",
+    "head.native_head.evidence_layers.1.feedforward.3.weight",
+    "head.native_head.evidence_layers.1.feedforward.3.bias",
+    "head.native_head.option_summary_norm.weight",
+    "head.native_head.option_summary_norm.bias",
+    "head.native_head.layers.0.self_attn.in_proj_weight",
+    "head.native_head.layers.0.self_attn.in_proj_bias",
+    "head.native_head.layers.0.self_attn.out_proj.weight",
+    "head.native_head.layers.0.self_attn.out_proj.bias",
+    "head.native_head.layers.0.multihead_attn.in_proj_weight",
+    "head.native_head.layers.0.multihead_attn.in_proj_bias",
+    "head.native_head.layers.0.multihead_attn.out_proj.weight",
+    "head.native_head.layers.0.multihead_attn.out_proj.bias",
+    "head.native_head.layers.0.linear1.weight",
+    "head.native_head.layers.0.linear1.bias",
+    "head.native_head.layers.0.linear2.weight",
+    "head.native_head.layers.0.linear2.bias",
+    "head.native_head.layers.0.norm1.weight",
+    "head.native_head.layers.0.norm1.bias",
+    "head.native_head.layers.0.norm2.weight",
+    "head.native_head.layers.0.norm2.bias",
+    "head.native_head.layers.0.norm3.weight",
+    "head.native_head.layers.0.norm3.bias",
+    "head.native_head.layers.1.self_attn.in_proj_weight",
+    "head.native_head.layers.1.self_attn.in_proj_bias",
+    "head.native_head.layers.1.self_attn.out_proj.weight",
+    "head.native_head.layers.1.self_attn.out_proj.bias",
+    "head.native_head.layers.1.multihead_attn.in_proj_weight",
+    "head.native_head.layers.1.multihead_attn.in_proj_bias",
+    "head.native_head.layers.1.multihead_attn.out_proj.weight",
+    "head.native_head.layers.1.multihead_attn.out_proj.bias",
+    "head.native_head.layers.1.linear1.weight",
+    "head.native_head.layers.1.linear1.bias",
+    "head.native_head.layers.1.linear2.weight",
+    "head.native_head.layers.1.linear2.bias",
+    "head.native_head.layers.1.norm1.weight",
+    "head.native_head.layers.1.norm1.bias",
+    "head.native_head.layers.1.norm2.weight",
+    "head.native_head.layers.1.norm2.bias",
+    "head.native_head.layers.1.norm3.weight",
+    "head.native_head.layers.1.norm3.bias",
+    "head.native_head.layers.2.self_attn.in_proj_weight",
+    "head.native_head.layers.2.self_attn.in_proj_bias",
+    "head.native_head.layers.2.self_attn.out_proj.weight",
+    "head.native_head.layers.2.self_attn.out_proj.bias",
+    "head.native_head.layers.2.multihead_attn.in_proj_weight",
+    "head.native_head.layers.2.multihead_attn.in_proj_bias",
+    "head.native_head.layers.2.multihead_attn.out_proj.weight",
+    "head.native_head.layers.2.multihead_attn.out_proj.bias",
+    "head.native_head.layers.2.linear1.weight",
+    "head.native_head.layers.2.linear1.bias",
+    "head.native_head.layers.2.linear2.weight",
+    "head.native_head.layers.2.linear2.bias",
+    "head.native_head.layers.2.norm1.weight",
+    "head.native_head.layers.2.norm1.bias",
+    "head.native_head.layers.2.norm2.weight",
+    "head.native_head.layers.2.norm2.bias",
+    "head.native_head.layers.2.norm3.weight",
+    "head.native_head.layers.2.norm3.bias",
+    "head.native_head.layers.3.self_attn.in_proj_weight",
+    "head.native_head.layers.3.self_attn.in_proj_bias",
+    "head.native_head.layers.3.self_attn.out_proj.weight",
+    "head.native_head.layers.3.self_attn.out_proj.bias",
+    "head.native_head.layers.3.multihead_attn.in_proj_weight",
+    "head.native_head.layers.3.multihead_attn.in_proj_bias",
+    "head.native_head.layers.3.multihead_attn.out_proj.weight",
+    "head.native_head.layers.3.multihead_attn.out_proj.bias",
+    "head.native_head.layers.3.linear1.weight",
+    "head.native_head.layers.3.linear1.bias",
+    "head.native_head.layers.3.linear2.weight",
+    "head.native_head.layers.3.linear2.bias",
+    "head.native_head.layers.3.norm1.weight",
+    "head.native_head.layers.3.norm1.bias",
+    "head.native_head.layers.3.norm2.weight",
+    "head.native_head.layers.3.norm2.bias",
+    "head.native_head.layers.3.norm3.weight",
+    "head.native_head.layers.3.norm3.bias",
+    "head.native_head.field_norm.weight",
+    "head.native_head.field_norm.bias",
+    "head.native_head.option_norm.weight",
+    "head.native_head.option_norm.bias",
+    "head.native_head.residual_scorer.0.weight",
+    "head.native_head.residual_scorer.0.bias",
+    "head.native_head.residual_scorer.3.weight",
+    "head.native_head.residual_scorer.3.bias"
+  ],
+  "config": {
+    "batch_size": 1,
+    "brier_weight": 0.1,
+    "clip_gradient_norm": 1.0,
+    "epochs": 2,
+    "gradient_accumulation": 8,
+    "label_smoothing": 0.05,
+    "learning_rate": 1e-05,
+    "max_length": 4096,
+    "mode": "lora",
+    "optimizer": "AdamW",
+    "rank": 4,
+    "seed": 42,
+    "selection": "external validation only; this script does not choose a checkpoint",
+    "weight_decay": 0.01
+  },
+  "dataset_config_sha256": "65b72544c80cf19f4ac3b12ca109d0ebda18fb70eadb4b170a55b1e8bb3b4f6d",
+  "dataset_counts": {
+    "train": 827,
+    "validation": 215
+  },
+  "dataset_manifest_sha256": "aeddcfc1ea5390f12122d2e786c1e2030dcc97d3790b6d7523432548198b1f94",
+  "dataset_source_commit": "70d84bd8dc5d4a60f3b96455a57d9e6f9416d109",
+  "dataset_split_sha256": {
+    "train": "edd682761db95a4f25bb30a284489c54d9336a36da0a9b19d2cda860b428baa8",
+    "validation": "eff9cdc5932e935959ac4d26dce6470d335090f7428a91930001954266d133bc"
+  },
+  "elapsed_seconds": 1511.2463698700012,
+  "epochs": [
+    {
+      "checkpoint": "runs/study-v1/epoch-01",
+      "epoch": 1,
+      "examples": 827,
+      "mean_training_loss": 2.5779671531346287,
+      "optimizer_steps": 104,
+      "peak_allocated_bytes": 23230341120,
+      "peak_reserved_bytes": 24178065408,
+      "seconds": 742.4755487579969,
+      "shuffle_order_sha256": "b6e0d7189b1d965472f1132dda2e9be3a35093dae838baf5d8e0c0d3471b6198"
+    },
+    {
+      "checkpoint": "runs/study-v1/epoch-02",
+      "epoch": 2,
+      "examples": 827,
+      "mean_training_loss": 1.9667175294878694,
+      "optimizer_steps": 104,
+      "peak_allocated_bytes": 23226543104,
+      "peak_reserved_bytes": 24178065408,
+      "seconds": 744.6554337799898,
+      "shuffle_order_sha256": "b9d20efe77959592c99e9247a58d844be69df50db595bd87c6d7e595f5d2e0c4"
+    }
+  ],
+  "frozen_parameters_unchanged": true,
+  "gpu": "NVIDIA GeForce RTX 5090",
+  "initial_free_vram": 33179500544,
+  "package_versions": {
+    "peft": "0.21.2",
+    "safetensors": "0.8.0",
+    "torch": "2.14.1+cu130",
+    "transformers": "5.18.0"
+  },
+  "source_commit": "d9fcd05c02e9327d4d791f2338725092cede8bdd",
+  "source_dirty": true,
+  "source_hashes": {
+    "scripts/train_clef.py": "e83586cf0fd0d7bb8c4aa15f9b858b9f9ffdb915622e355deb9513788d5054aa",
+    "src/stackcraft/clef.py": "c505f35d27121ba9ec9db3c663927ac8b28304f4ed864765be61ce96c8c86e13",
+    "src/stackcraft/data.py": "74b68a1f391a3128d2e499c7e86b6c94a1f2a2bef33ffe75c8631207065bd991",
+    "src/stackcraft/training.py": "f7e48b041b331cf2b68674ec2abb1059dd1da47cb261697b46260b4f0169dba8"
+  },
+  "status": "trained-awaiting-external-validation",
+  "test_trajectories_used": false,
+  "total_vram": 33711521792,
+  "trainable_parameters": 132582404,
+  "validation_used_for_training": false
+}

code/reports/training-source-supplement.json

@@ -0,0 +1,11 @@
+{
+  "source_commit": "d9fcd05",
+  "source_hashes": {
+    "src/stackcraft/engine.py": "0805be38ee968d569fa1c12230730f491490f7d27cfcc570c400ac3b4a546453",
+    "src/stackcraft/pieces.py": "c5bee0f8767aeeab279cfbadb4c7b4c0bbf1f31c1d29b08dda197f0627654b29",
+    "src/stackcraft/schema.py": "35c70d96e8a49e434dc0a3607412a0ce58141306df59e09b1170511694cb6eb5",
+    "src/stackcraft/players/__init__.py": "550bed9237303a845cdcc101542b0b688173a8f5436dd1d08c5f85a5a19fa2b2",
+    "uv.lock": "bc7fae476529578be003856b5f19e09c8cc96e0020ab999e20e1f8210696f9c8"
+  },
+  "verified_equal_to_current_at_training_start": true
+}

code/reports/validation-summary.json

@@ -0,0 +1,158 @@
+{
+  "selected_key": "epoch-02",
+  "decision_rule": "lowest finite mean target NLL over all 215 validation positions; exact tie chooses earlier epoch",
+  "selection_sha256": "025b62587a26bd8cc78c80f362524b8c178190df5188b317299121afa6b1203b",
+  "checkpoint_sha256": {
+    "adapter/README.md": "bf1fa63446e8ee38c5ac154ade9138a0e2354e3215201f59473102eeb5206fa0",
+    "adapter/adapter_config.json": "bbbce7f19e186b4a79c39d03786bb190d6084e7990a601e8e28672cf1c969741",
+    "adapter/adapter_model.safetensors": "3ed169fe68b20a370bb856f9d91842543374ff3c98fd3bbe139ef2d0b97877a3",
+    "joint_head.safetensors": "4f21c0f315cf1bcf852a9887d158928855eaa9bdcab6b9770d518abf3727fa1b",
+    "reference.json": "adacc63684d28598f8016602bab790cd3967317986b6934dd94a5e14fabe571f",
+    "training_config.json": "3ead31d0a3ccb6a62914c3853ee26332f6412382c5196e40b461182e64d8b329"
+  },
+  "dataset_manifest_sha256": "aeddcfc1ea5390f12122d2e786c1e2030dcc97d3790b6d7523432548198b1f94",
+  "validation": {
+    "epoch-01": {
+      "report_sha256": "ce401ef9fe1d25c11c7a0e3845def347967d8617223307ad823e23a90c3f0033",
+      "players": {
+        "base": {
+          "available_subset_mean_brier": 0.9231725575578064,
+          "complete_probability_coverage": true,
+          "correct": 21,
+          "error_rate": 0.0,
+          "failed_predictions": [],
+          "finite_subset_mean_nll": 2.9527020509302693,
+          "finite_subset_nll_positions": 215,
+          "mean_brier": 0.9231725575578064,
+          "mean_nll": 2.9527020509302693,
+          "missing_probabilities": [],
+          "nll_is_infinite": false,
+          "positions": 215,
+          "probability_positions": 215,
+          "selection_performed": false,
+          "teacher_agreement": 0.09767441860465116,
+          "zero_target_probability_count": 0
+        },
+        "base-fp32": {
+          "available_subset_mean_brier": 0.9231017245023939,
+          "complete_probability_coverage": true,
+          "correct": 22,
+          "error_rate": 0.0,
+          "failed_predictions": [],
+          "finite_subset_mean_nll": 2.9523931327950934,
+          "finite_subset_nll_positions": 215,
+          "mean_brier": 0.9231017245023939,
+          "mean_nll": 2.9523931327950934,
+          "missing_probabilities": [],
+          "nll_is_infinite": false,
+          "positions": 215,
+          "probability_positions": 215,
+          "selection_performed": false,
+          "teacher_agreement": 0.10232558139534884,
+          "zero_target_probability_count": 0
+        },
+        "trained": {
+          "available_subset_mean_brier": 0.7221895727255984,
+          "complete_probability_coverage": true,
+          "correct": 89,
+          "error_rate": 0.0,
+          "failed_predictions": [],
+          "finite_subset_mean_nll": 1.8608697515370076,
+          "finite_subset_nll_positions": 215,
+          "mean_brier": 0.7221895727255984,
+          "mean_nll": 1.8608697515370076,
+          "missing_probabilities": [],
+          "nll_is_infinite": false,
+          "positions": 215,
+          "probability_positions": 215,
+          "selection_performed": false,
+          "teacher_agreement": 0.413953488372093,
+          "zero_target_probability_count": 0
+        }
+      },
+      "provenance": {
+        "base_revision": "17f0b0ad64efb65d273590632833508766b2aae6",
+        "encoding_version": "stackcraft-clef-v1",
+        "installed_versions": {
+          "huggingface-hub": "1.33.0",
+          "peft": "0.21.2",
+          "safetensors": "0.8.0",
+          "torch": "2.14.1+cu130",
+          "transformers": "5.18.0"
+        },
+        "precision_policy": "native BF16 base; FP32 trained head; optional base-fp32 ablation",
+        "rules_version": "stackcraft-v1",
+        "source_commit": "ada38885b55ae3e4b6705a18dec98d194d37447e",
+        "source_dirty": false,
+        "source_hashes": {
+          "scripts/evaluate_clef.py": "70a47e9314ec9d7351a939bae32f07f14bd08f6106b60ce6155687c0540b92dd",
+          "src/stackcraft/clef.py": "c505f35d27121ba9ec9db3c663927ac8b28304f4ed864765be61ce96c8c86e13",
+          "src/stackcraft/data.py": "74b68a1f391a3128d2e499c7e86b6c94a1f2a2bef33ffe75c8631207065bd991",
+          "src/stackcraft/engine.py": "0805be38ee968d569fa1c12230730f491490f7d27cfcc570c400ac3b4a546453",
+          "src/stackcraft/evaluation.py": "df56f9d36655e79573a014a5c55c2571bc5e04e2c20f1b37e2d939b871e889e6",
+          "src/stackcraft/pieces.py": "c5bee0f8767aeeab279cfbadb4c7b4c0bbf1f31c1d29b08dda197f0627654b29",
+          "src/stackcraft/players/__init__.py": "550bed9237303a845cdcc101542b0b688173a8f5436dd1d08c5f85a5a19fa2b2",
+          "src/stackcraft/provenance.py": "0728104f22361ad2a8b4471e6eef0467852d94f650d0259d7f5f674c0086f13b",
+          "src/stackcraft/schema.py": "35c70d96e8a49e434dc0a3607412a0ce58141306df59e09b1170511694cb6eb5",
+          "src/stackcraft/tournament.py": "288ed447a32e0845f52097372a644fc211b1632790655f620801d3ce1639d559",
+          "src/stackcraft/training.py": "f7e48b041b331cf2b68674ec2abb1059dd1da47cb261697b46260b4f0169dba8",
+          "uv.lock": "bc7fae476529578be003856b5f19e09c8cc96e0020ab999e20e1f8210696f9c8"
+        },
+        "source_identity_method": "exact-git-root"
+      }
+    },
+    "epoch-02": {
+      "report_sha256": "9482be5ac08b85a7bafc18d8f70a35ba277f476d9a96dd0684553e937abc4d2a",
+      "players": {
+        "trained": {
+          "available_subset_mean_brier": 0.7089798657211578,
+          "complete_probability_coverage": true,
+          "correct": 92,
+          "error_rate": 0.0,
+          "failed_predictions": [],
+          "finite_subset_mean_nll": 1.7759231168523646,
+          "finite_subset_nll_positions": 215,
+          "mean_brier": 0.7089798657211578,
+          "mean_nll": 1.7759231168523646,
+          "missing_probabilities": [],
+          "nll_is_infinite": false,
+          "positions": 215,
+          "probability_positions": 215,
+          "selection_performed": false,
+          "teacher_agreement": 0.42790697674418604,
+          "zero_target_probability_count": 0
+        }
+      },
+      "provenance": {
+        "base_revision": "17f0b0ad64efb65d273590632833508766b2aae6",
+        "encoding_version": "stackcraft-clef-v1",
+        "installed_versions": {
+          "huggingface-hub": "1.33.0",
+          "peft": "0.21.2",
+          "safetensors": "0.8.0",
+          "torch": "2.14.1+cu130",
+          "transformers": "5.18.0"
+        },
+        "precision_policy": "native BF16 base; FP32 trained head; optional base-fp32 ablation",
+        "rules_version": "stackcraft-v1",
+        "source_commit": "7a21f6491bcaf2afacc9aa5b5e2733a35c41a7a8",
+        "source_dirty": false,
+        "source_hashes": {
+          "scripts/evaluate_clef.py": "70a47e9314ec9d7351a939bae32f07f14bd08f6106b60ce6155687c0540b92dd",
+          "src/stackcraft/clef.py": "c505f35d27121ba9ec9db3c663927ac8b28304f4ed864765be61ce96c8c86e13",
+          "src/stackcraft/data.py": "74b68a1f391a3128d2e499c7e86b6c94a1f2a2bef33ffe75c8631207065bd991",
+          "src/stackcraft/engine.py": "0805be38ee968d569fa1c12230730f491490f7d27cfcc570c400ac3b4a546453",
+          "src/stackcraft/evaluation.py": "df56f9d36655e79573a014a5c55c2571bc5e04e2c20f1b37e2d939b871e889e6",
+          "src/stackcraft/pieces.py": "c5bee0f8767aeeab279cfbadb4c7b4c0bbf1f31c1d29b08dda197f0627654b29",
+          "src/stackcraft/players/__init__.py": "550bed9237303a845cdcc101542b0b688173a8f5436dd1d08c5f85a5a19fa2b2",
+          "src/stackcraft/provenance.py": "0728104f22361ad2a8b4471e6eef0467852d94f650d0259d7f5f674c0086f13b",
+          "src/stackcraft/schema.py": "35c70d96e8a49e434dc0a3607412a0ce58141306df59e09b1170511694cb6eb5",
+          "src/stackcraft/tournament.py": "288ed447a32e0845f52097372a644fc211b1632790655f620801d3ce1639d559",
+          "src/stackcraft/training.py": "f7e48b041b331cf2b68674ec2abb1059dd1da47cb261697b46260b4f0169dba8",
+          "uv.lock": "bc7fae476529578be003856b5f19e09c8cc96e0020ab999e20e1f8210696f9c8"
+        },
+        "source_identity_method": "exact-git-root"
+      }
+    }
+  }
+}

code/scripts/benchmark_clef.py

@@ -0,0 +1,51 @@
+"""Actual pinned unchanged Clef development tournament; no held-out test seeds."""
+
+import argparse
+import json
+import time
+from pathlib import Path
+
+import torch
+
+from stackcraft.clef import ClefPlayer
+from stackcraft.engine import new_game
+from stackcraft.players import HeuristicPlayer, RandomPlayer, observe
+from stackcraft.tournament import run_tournament
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--episodes", type=int, default=2)
+    parser.add_argument("--max-pieces", type=int, default=30)
+    args = parser.parse_args()
+    if args.output.exists() or not 1 <= args.episodes <= 20:
+        parser.error("use a new output and1–20 development episodes")
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    torch.set_num_threads(8)
+    free, total = torch.cuda.mem_get_info()
+    if free < 25 * 1024**3:
+        raise RuntimeError(f"insufficient free GPU memory: {free}")
+    started = time.monotonic()
+    player = ClefPlayer.from_pretrained(trust_pinned_code=True)
+    warmup = player.choose(observe(new_game(42)))
+    print(
+        json.dumps({"warmup": warmup.action_id, "load_seconds": time.monotonic() - started}),
+        flush=True,
+    )
+    result = run_tournament(
+        {"random": RandomPlayer, "heuristic": HeuristicPlayer, "clef-base": lambda: player},
+        list(range(args.episodes)),
+        args.max_pieces,
+    )
+    result["development_only"] = True
+    result["gpu"] = torch.cuda.get_device_name()
+    result["peak_allocated_bytes"] = torch.cuda.max_memory_allocated()
+    result["peak_reserved_bytes"] = torch.cuda.max_memory_reserved()
+    result["elapsed_seconds"] = time.monotonic() - started
+    args.output.write_text(json.dumps(result, indent=2, allow_nan=False) + "\n")
+    print(json.dumps(result["summary"]), flush=True)
+
+
+if __name__ == "__main__":
+    main()

code/scripts/build_release.py

@@ -0,0 +1,640 @@
+"""Validate completed evidence and stage local release bundles; never upload anything."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import importlib.util
+import json
+import shutil
+import stat
+import zipfile
+from pathlib import Path, PurePosixPath
+from types import ModuleType, SimpleNamespace
+from typing import Any
+
+from stackcraft.data import audit_dataset
+from stackcraft.evaluation import FINAL_TEST_SEEDS, paired_report
+from stackcraft.players import Decision, observe, validate_decision
+from stackcraft.provenance import source_identity
+from stackcraft.schema import GameState
+
+ROOT = Path(__file__).resolve().parents[1]
+PLAYERS = ("base", "base-fp32", "trained", "random", "heuristic")
+COMPARISONS = {
+    "trained_vs_base": ("trained", "base"),
+    "trained_vs_heuristic": ("trained", "heuristic"),
+    "trained_vs_base_fp32": ("trained", "base-fp32"),
+    "base_fp32_vs_base": ("base-fp32", "base"),
+}
+CHECKPOINT_FILES = {
+    "training_config.json",
+    "joint_head.safetensors",
+    "reference.json",
+    "adapter/adapter_config.json",
+    "adapter/adapter_model.safetensors",
+    "adapter/README.md",
+}
+REPRO_SCRIPTS = (
+    "benchmark_clef.py",
+    "probe_clef_training.py",
+    "train_clef.py",
+    "evaluate_clef.py",
+    "select_checkpoint.py",
+    "export_demo.py",
+    "build_release.py",
+    "verify_release.py",
+    "prepare_checkpoint.py",
+    "gpu_session.py",
+)
+
+
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        while chunk := stream.read(1_048_576):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def json_file(path: Path) -> Any:
+    return json.loads(path.read_text())
+
+
+def write_json(path: Path, value: Any) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(value, indent=2, sort_keys=True, allow_nan=False) + "\n")
+
+
+def load_helper(name: str) -> ModuleType:
+    spec = importlib.util.spec_from_file_location(
+        f"stackcraft_release_{name}", ROOT / "scripts" / name
+    )
+    if spec is None or spec.loader is None:
+        raise ValueError(f"cannot load reviewed release helper {name}")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def copy_file(source: Path, destination: Path) -> None:
+    if source.is_symlink() or not source.is_file():
+        raise ValueError(f"release inputs must be regular files, not links: {source}")
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copyfile(source, destination)
+
+
+def safe_relative(path: str) -> Path:
+    relative = Path(path)
+    if relative.is_absolute() or ".." in relative.parts or not relative.parts:
+        raise ValueError("release evidence paths must stay within their evidence directory")
+    return relative
+
+
+def validate_reference(checkpoint: Path, dataset: Path, records: dict[str, Any]) -> None:
+    reference = json_file(checkpoint / "reference.json")
+    rows = records["train"][:4]
+    manifest_hash = sha256(dataset / "manifest.json")
+    if (
+        reference.get("row_ids") != [row["id"] for row in rows]
+        or reference.get("dataset_manifest_sha256") != manifest_hash
+        or reference.get("dataset_train_sha256") != sha256(dataset / "train.jsonl")
+        or reference.get("absolute_tolerance") != 1e-4
+    ):
+        raise ValueError("checkpoint parity reference is not bound to the fixed training dataset")
+    metadata = json_file(checkpoint / "training_config.json")
+    if metadata.get("extra", {}).get("dataset_manifest_sha256") != manifest_hash:
+        raise ValueError("checkpoint was trained with a different dataset manifest")
+    config = metadata.get("extra", {}).get("config", {})
+    if reference.get("max_length") != config.get("max_length"):
+        raise ValueError("checkpoint reference context limit differs from training configuration")
+    probabilities = reference.get("probabilities")
+    if not isinstance(probabilities, list) or len(probabilities) != len(rows):
+        raise ValueError("checkpoint needs all four fixed-row probability references")
+    for row, distribution in zip(rows, probabilities, strict=True):
+        raw = row["observation"]
+        state = GameState(
+            tuple(tuple(r) for r in raw["board"]), 0, 0, raw["current"], raw["next_piece"]
+        )
+        observation = observe(state)
+        if not isinstance(distribution, dict) or not distribution:
+            raise ValueError("checkpoint reference must contain complete probabilities")
+        validate_decision(
+            Decision(max(distribution, key=distribution.__getitem__), distribution), observation
+        )
+
+
+def validate_evaluation(
+    evaluation: Path, selection_path: Path, checkpoint: Path, helpers: dict[str, ModuleType]
+) -> tuple[dict[str, Any], dict[str, str], list[Path]]:
+    evaluator, exporter = helpers["evaluate"], helpers["export"]
+    hashes = evaluator.checkpoint_hashes(checkpoint)
+    if not set(hashes).issubset(CHECKPOINT_FILES):
+        raise ValueError("checkpoint contains unexpected files outside the release allowlist")
+    if not {"training_config.json", "joint_head.safetensors", "reference.json"}.issubset(hashes):
+        raise ValueError("checkpoint lacks trained head, metadata or reload reference")
+    metadata = json_file(checkpoint / "training_config.json")
+    if metadata.get("mode") == "lora" and not {
+        "adapter/adapter_config.json",
+        "adapter/adapter_model.safetensors",
+        "adapter/README.md",
+    }.issubset(hashes):
+        raise ValueError("LoRA checkpoint is missing adapter weights, configuration or attribution")
+    selection = json_file(selection_path)
+    report = json_file(evaluation / "report.json")
+    request = json_file(evaluation / "request.json")
+    if (
+        report.get("mode") != "tournament"
+        or report.get("final_test") is not True
+        or report.get("seeds") != list(FINAL_TEST_SEEDS)
+        or report.get("max_pieces") != 200
+        or set(report.get("players", {})) != set(PLAYERS)
+        or report.get("checkpoint_sha256") != hashes
+        or report.get("selection") != selection
+    ):
+        raise ValueError("evaluation must be the complete frozen five-player, 200-seed final test")
+    if (
+        request.get("final_test") is not True
+        or request.get("mode") != "tournament"
+        or request.get("seeds") != list(FINAL_TEST_SEEDS)
+        or request.get("max_pieces") != 200
+        or set(request.get("players", [])) != set(PLAYERS)
+        or request.get("checkpoint_sha256") != hashes
+        or request.get("selection_sha256") != sha256(selection_path)
+    ):
+        raise ValueError("evaluation request is not bound to the checkpoint and frozen selection")
+    args = SimpleNamespace(
+        seeds=tuple(FINAL_TEST_SEEDS),
+        final_test=True,
+        max_pieces=200,
+        players=request["players"],
+        selection_file=selection_path,
+        checkpoint=checkpoint,
+        max_length=request["max_length"],
+    )
+    evaluator.validate_selection(args, hashes)
+    episodes = report.get("episodes", [])
+    expected_pairs = {(player, seed) for player in PLAYERS for seed in FINAL_TEST_SEEDS}
+    by_pair = {(episode.get("player_id"), episode.get("seed")): episode for episode in episodes}
+    if len(episodes) != len(expected_pairs) or set(by_pair) != expected_pairs:
+        raise ValueError("final report must retain every player/seed pair exactly once")
+    paths = [Path("report.json"), Path("request.json")]
+    for player in PLAYERS:
+        metadata_path = Path(player) / "player.json"
+        metadata = json_file(evaluation / metadata_path)
+        if metadata != report["players"][player]:
+            raise ValueError("evaluation player metadata differs from its final report")
+        paths.append(metadata_path)
+        for seed in FINAL_TEST_SEEDS:
+            relative = Path(player) / f"seed-{seed}.json"
+            episode = json_file(evaluation / relative)
+            if episode != by_pair[(player, seed)]:
+                raise ValueError("episode file differs from final report")
+            if episode["player"]["revision"] != metadata["revision"] or episode["player"].get(
+                "runtime_config", {}
+            ) != metadata.get("runtime_config", {}):
+                raise ValueError("episode player identity differs from recorded metadata")
+            # Recompute every board, visible observation, action and probability check.
+            exporter.validated_player(episode, 0)
+            paths.append(relative)
+    evaluator.validate_neural_runtimes(report["players"])
+    for key, (trained, base) in COMPARISONS.items():
+        computed = paired_report(episodes, trained_id=trained, base_id=base)
+        if computed != report.get(key):
+            raise ValueError(f"reported {key} does not match recomputed paired outcomes")
+    return report, hashes, paths
+
+
+def selection_evidence_files(selection_path: Path) -> list[Path]:
+    """Preserve self-contained selection evidence with original relative links."""
+    selection = json_file(selection_path)
+    files = {Path(selection_path.name)}
+    pointers = [selection["validation_evidence"]]
+    for candidate in selection["candidates"]:
+        pointers.extend((candidate["validation_evidence"], candidate["checkpoint_metadata"]))
+    for pointer in pointers:
+        relative = safe_relative(pointer["path"])
+        source = selection_path.parent / relative
+        if sha256(source) != pointer["sha256"]:
+            raise ValueError("selection evidence changed after its hash was frozen")
+        files.add(relative)
+        value = json_file(source)
+        if value.get("mode") == "positions":
+            for player in value["players"].values():
+                predictions = relative.parent / safe_relative(player["predictions_file"])
+                if sha256(selection_path.parent / predictions) != player["predictions_sha256"]:
+                    raise ValueError("validation predictions do not match their recorded hash")
+                files.add(predictions)
+    if (selection_path.parent / "selection-audit.json").is_file():
+        files.add(Path("selection-audit.json"))
+    return sorted(files)
+
+
+def _evidence_name(name: str) -> None:
+    path = PurePosixPath(name)
+    if (
+        "\\" in name
+        or ":" in name
+        or "\x00" in name
+        or path.is_absolute()
+        or ".." in path.parts
+        or len(path.parts) < 2
+        or path.parts[0] != "evidence"
+        or path.as_posix() != name
+    ):
+        raise ValueError("archive entries must be canonical files below evidence/")
+
+
+def verify_evidence_archive(archive: Path, expected: dict[str, dict[str, Any]]) -> None:
+    """Read every entry back, checking exact names, lengths, CRC and raw SHA256."""
+    for name in expected:
+        _evidence_name(name)
+    with zipfile.ZipFile(archive) as source:
+        infos = source.infolist()
+        if len(infos) != len(expected) or {info.filename for info in infos} != set(expected):
+            raise ValueError("archive entries differ from the exact raw evidence inventory")
+        for info in infos:
+            _evidence_name(info.filename)
+            entry = expected[info.filename]
+            if (
+                info.is_dir()
+                or info.compress_type != zipfile.ZIP_DEFLATED
+                or info.flag_bits & 1
+                or stat.S_IFMT(info.external_attr >> 16) != stat.S_IFREG
+                or info.file_size != entry["bytes"]
+            ):
+                raise ValueError("archive entry is not the declared regular evidence file")
+            digest = hashlib.sha256()
+            size = 0
+            with source.open(info) as stream:
+                while chunk := stream.read(1_048_576):
+                    size += len(chunk)
+                    digest.update(chunk)
+            if size != entry["bytes"] or digest.hexdigest() != entry["sha256"]:
+                raise ValueError("archive entry bytes differ from the raw evidence SHA256")
+
+
+def pack_evidence(model: Path) -> dict[str, Any]:
+    """Pack staged copies only; leave originals in place until the caller removes them."""
+    root = model / "evidence"
+    archive = model / "evidence.zip"
+    index = model / "evidence-files.json"
+    if archive.exists() or index.exists():
+        raise ValueError("evidence archive or inventory already exists")
+    paths = sorted(root.rglob("*"))
+    if root.is_symlink() or any(path.is_symlink() for path in paths):
+        raise ValueError("evidence archive inputs cannot contain symlinks")
+    files = [path for path in paths if path.is_file()]
+    if not files or any(not path.is_file() and not path.is_dir() for path in paths):
+        raise ValueError("evidence archive needs regular staged files")
+    expected = {}
+    with zipfile.ZipFile(archive, "x", compression=zipfile.ZIP_DEFLATED, compresslevel=6) as target:
+        for path in files:
+            name = path.relative_to(model).as_posix()
+            _evidence_name(name)
+            info = zipfile.ZipInfo(name, date_time=(1980, 1, 1, 0, 0, 0))
+            info.compress_type = zipfile.ZIP_DEFLATED
+            info.compress_level = 6
+            info.create_system = 3
+            info.external_attr = (stat.S_IFREG | 0o644) << 16
+            digest = hashlib.sha256()
+            size = 0
+            with path.open("rb") as source, target.open(info, "w", force_zip64=True) as stream:
+                while chunk := source.read(1_048_576):
+                    digest.update(chunk)
+                    size += len(chunk)
+                    stream.write(chunk)
+            expected[name] = {"sha256": digest.hexdigest(), "bytes": size}
+    verify_evidence_archive(archive, expected)
+    # A concurrent edit must not be hidden by deleting a changed staged source.
+    for name, entry in expected.items():
+        path = model / name
+        if path.stat().st_size != entry["bytes"] or sha256(path) != entry["sha256"]:
+            raise ValueError("staged evidence changed while packing the archive")
+    manifest = {
+        "schema_version": 1,
+        "archive": "evidence.zip",
+        "compression": "ZIP_DEFLATED",
+        "compression_level": 6,
+        "archive_sha256": sha256(archive),
+        "archive_bytes": archive.stat().st_size,
+        "files": expected,
+        "extraction_root": "model repository root",
+    }
+    write_json(index, manifest)
+    return manifest
+
+
+def render_model_card(template: str, report: dict[str, Any], selection: dict[str, Any]) -> str:
+    summary = report["trained_vs_base"]
+    rows = [
+        "| Player | Lines mean (median) | Score mean (median) | "
+        "Placed mean (median) | Cap hits | Errors |",
+        "| --- | ---: | ---: | ---: | ---: | ---: |",
+    ]
+    timing = [
+        "| Player | Decision mean ms | Median ms | p95 ms | Invalid decisions |",
+        "| --- | ---: | ---: | ---: | ---: |",
+    ]
+    for name in PLAYERS:
+        player = summary["players"][name]
+        primary = player["failure_adjusted"]
+        outcomes = " | ".join(
+            f"{primary[metric]['mean']:.3f} ({primary[metric]['median']:.1f})"
+            for metric in ("lines", "score", "pieces")
+        )
+        rows.append(
+            f"| {name} | {outcomes} | {player['cap_hit_rate']:.1%} | {player['error_rate']:.1%} |"
+        )
+        latency = player["latency_seconds"]
+        values = " | ".join(
+            f"{latency[key] * 1000:.3f}" if latency[key] is not None else "unavailable"
+            for key in ("mean", "median", "p95")
+        )
+        timing.append(f"| {name} | {values} | {player['invalid_decisions']} |")
+    comparisons = [
+        "| Comparison (first minus second) | Mean lines difference | Paired 95% interval |",
+        "| --- | ---: | ---: |",
+    ]
+    for key, (first, second) in COMPARISONS.items():
+        delta = report[key]["paired_trained_minus_base"]["lines"]
+        comparisons.append(
+            f"| {first} − {second} | {delta['mean_difference']:.3f} | "
+            f"[{delta['ci95_lower']:.3f}, {delta['ci95_upper']:.3f}] |"
+        )
+    results = (
+        "Verified final outcomes on all 200 paired seeds, with a 200-piece cap. "
+        "Lines, score and placed-piece summaries use the preregistered zero-on-error policy. "
+        "Cap hits indicate censored survival.\n\n"
+        + "\n".join(rows)
+        + "\n\nEach paired 95% bootstrap interval resamples complete episode differences. "
+        "Trained versus native base is the primary comparison; the heuristic and FP32-head "
+        "comparisons are separate checks. Intervals are not adjusted for multiple comparisons.\n\n"
+        + "\n".join(comparisons)
+        + "\n\nDecision latency includes recorded first-call effects, tokenization and policy "
+        "overhead, but excludes game rendering and replay playback.\n\n"
+        + "\n".join(timing)
+        + "\n\nThe full reports retain raw outcomes, all failed seeds and probability logs."
+    )
+    card = template.replace(
+        "**Release preparation: full-study results and selected checkpoint are pending.**",
+        f"Selected checkpoint: **{selection['selected_key']}**, "
+        "chosen on validation before final tests.",
+    ).replace("**Insert verified held-out results here before publication.**", results)
+    if "pending" in card.lower() or "insert verified" in card.lower():
+        raise ValueError("model card still contains pending release text")
+    return card + (
+        "\n\n## Bundle layout\n\n"
+        "`checkpoint/` preserves the selected checkpoint bytes. `code/` contains the source, "
+        "locked environment, tests, scripts and milestone tutorials. `evidence.zip` losslessly "
+        "compresses the frozen selection, both validation candidates and complete final "
+        "evaluation. From the model repository root, run `python -m zipfile -e evidence.zip .` after download verification to restore "
+        "`evidence/` and all original relative paths. `evidence-files.json` records each raw "
+        "file's byte count and SHA256; extraction preserves the original evidence hashes. "
+        "From `code/`, run `uv sync --locked --extra ml`; load `../checkpoint` using the "
+        "native Stackcraft loader. No access to a private GitHub repository is required.\n"
+    )
+
+
+def code_files(root: Path, *, demo: bool) -> list[Path]:
+    """Explicit file classes; no planning, environments, arbitrary data, runs or credentials."""
+    files = [
+        Path(name)
+        for name in (
+            "pyproject.toml",
+            "uv.lock",
+            ".python-version",
+            "README.md",
+            "LICENSE",
+            "NOTICE",
+            "Dockerfile",
+            ".dockerignore",
+        )
+    ]
+    suffixes = {".py", ".html", ".js", ".css"}
+    for path in (root / "src/stackcraft").rglob("*"):
+        if path.is_file() and path.suffix in suffixes and "__pycache__" not in path.parts:
+            files.append(path.relative_to(root))
+    files.append(Path("src/stackcraft/web/baseline-demo.json"))
+    if not demo:
+        files.extend(Path("scripts") / name for name in REPRO_SCRIPTS)
+        files.extend((Path("release/model-card.md"), Path("release/dataset-card.md")))
+        for folder, suffix in (("tests", ".py"), ("docs", ".md")):
+            files.extend(path.relative_to(root) for path in (root / folder).rglob(f"*{suffix}"))
+        for suffix in (".json", ".md"):
+            files.extend(path.relative_to(root) for path in (root / "reports").glob(f"*{suffix}"))
+        for milestone, name in enumerate(
+            ("foundation", "game", "baselines", "data", "gpu-feasibility", "evaluation", "release")
+        ):
+            expected = Path("docs/tutorials") / f"{milestone:02d}-{name}.md"
+            if expected not in files:
+                raise ValueError(f"missing milestone tutorial: {expected}")
+    return sorted(set(files))
+
+
+def bundled_source_readme(readme: str) -> str:
+    """Replace only the known private planning link with the shipped release tutorial."""
+    return readme.replace(
+        "[the project plan](plan.md)",
+        "[the release tutorial](docs/tutorials/06-release.md)",
+    )
+
+
+def space_readme(report_url: str | None = None) -> str:
+    """Describe the CPU demo without links to files excluded from its bundle."""
+    readme = """---
+title: Stackcraft
+sdk: docker
+app_port: 7860
+license: apache-2.0
+---
+
+# Stackcraft
+
+Play a simplified falling-block game and watch a recorded comparison of an
+unchanged Clef model, a trained model and a heuristic on the same piece sequence.
+
+**Human play is live. Bot comparisons are recorded.** The comparison replays saved
+placements and their decision probabilities; it does not call a model while you
+watch. Playback speed changes the animation, not measured inference latency.
+The fixed demonstration sequence is seed30000. One game illustrates behavior;
+it does not establish which player performs better across the complete study.
+
+Choose an orientation and column, then drop the current piece vertically onto a
+10×20 board. One next piece is visible. Completed rows clear simultaneously.
+There is no timed gravity, hold, wall kick, tuck or T-spin bonus. This is a small
+placement game, not a competitive Tetris implementation. Probabilities express
+model preferences over legal placements, not calibrated chances of winning.
+
+The Docker Space runs on CPU and needs no model weights, GPU or model credentials.
+Human sessions are kept in memory; download a replay before a restart to retain
+your game. The service runs as UID1000 on port7860 by default.
+
+To run the same image locally:
+
+```bash
+docker build -t stackcraft-demo .
+docker run --rm -p 7860:7860 stackcraft-demo
+```
+
+Open http://localhost:7860. The [Dockerfile](Dockerfile) and
+[game source](src/stackcraft/) are included here. The
+[recorded comparison](src/stackcraft/web/baseline-demo.json) contains the displayed
+actions, probabilities, outcomes and source report hashes.
+
+Apache-2.0: see [LICENSE](LICENSE) and [NOTICE](NOTICE). Stackcraft is independent
+of Cloudflare, Qwen and Tetris.
+"""
+    if report_url:
+        readme += f"\n[Complete study report](<{report_url}>).\n"
+    return readme
+
+
+def build_release(args: argparse.Namespace) -> dict[str, Any]:
+    if args.output.exists():
+        raise ValueError("release output already exists; use a new directory")
+    helpers = {"evaluate": load_helper("evaluate_clef.py"), "export": load_helper("export_demo.py")}
+    manifest = json_file(args.dataset / "manifest.json")
+    records = {
+        split: [
+            json.loads(line) for line in (args.dataset / f"{split}.jsonl").read_text().splitlines()
+        ]
+        for split in ("train", "validation")
+    }
+    audit_dataset(records, manifest)
+    for split in ("train", "validation"):
+        if sha256(args.dataset / f"{split}.jsonl") != manifest["splits"][split]["sha256"]:
+            raise ValueError("dataset file bytes differ from the manifest SHA256")
+    if {split: len(rows) for split, rows in records.items()} != {"train": 827, "validation": 215}:
+        raise ValueError("release dataset differs from the fixed 827/215-position study")
+    validate_reference(args.checkpoint, args.dataset, records)
+    report, checkpoint_hashes, evaluation_paths = validate_evaluation(
+        args.evaluation, args.selection, args.checkpoint, helpers
+    )
+    selection = json_file(args.selection)
+    evidence_paths = selection_evidence_files(args.selection)
+    expected_demo = helpers["export"].export_manifest(
+        [args.evaluation / "report.json"],
+        ["base", "trained", "heuristic"],
+        report_url=args.report_url,
+    )
+    if json_file(ROOT / "src/stackcraft/web/baseline-demo.json") != expected_demo:
+        raise ValueError(
+            "web demo must first be exported from this exact final report at fixed seed 30000"
+        )
+    card = render_model_card((ROOT / "release/model-card.md").read_text(), report, selection)
+    dataset_card = (ROOT / "release/dataset-card.md").read_text()
+    if "pending" in dataset_card.lower():
+        raise ValueError("dataset card still contains pending release text")
+    code_paths = code_files(ROOT, demo=False)
+    demo_paths = code_files(ROOT, demo=True)
+    identity = source_identity(ROOT)
+    args.output.mkdir(parents=True, exist_ok=False)
+    for relative in checkpoint_hashes:
+        copy_file(args.checkpoint / relative, args.output / "model/checkpoint" / relative)
+    for relative in code_paths:
+        copy_file(ROOT / relative, args.output / "model/code" / relative)
+    source_readme = args.output / "model/code/README.md"
+    source_readme.write_text(bundled_source_readme(source_readme.read_text()))
+    for relative in demo_paths:
+        copy_file(ROOT / relative, args.output / "demo" / relative)
+    for relative in evaluation_paths:
+        copy_file(args.evaluation / relative, args.output / "model/evidence/evaluation" / relative)
+    for relative in evidence_paths:
+        copy_file(
+            args.selection.parent / relative, args.output / "model/evidence/selection" / relative
+        )
+    pack_evidence(args.output / "model")
+    # Only remove the copies created in this new staging directory, after read-back
+    # verification. Original run/selection artifacts and checkpoints are untouched.
+    shutil.rmtree(args.output / "model/evidence")
+    for name in ("train.jsonl", "validation.jsonl", "manifest.json"):
+        copy_file(args.dataset / name, args.output / "dataset" / name)
+    for bundle in ("model", "dataset"):
+        for name in ("LICENSE", "NOTICE"):
+            copy_file(ROOT / name, args.output / bundle / name)
+    (args.output / "model/README.md").write_text(card)
+    (args.output / "dataset/README.md").write_text(dataset_card)
+    (args.output / "demo/README.md").write_text(space_readme(args.report_url))
+    copied_hashes = {
+        relative: sha256(args.output / "model/checkpoint" / relative)
+        for relative in checkpoint_hashes
+    }
+    if copied_hashes != checkpoint_hashes:
+        raise ValueError("checkpoint bytes changed during staging")
+    code = args.output / "model/code"
+    write_json(
+        code / "source-manifest.json",
+        {
+            "schema_version": 1,
+            "source_commit": identity["source_commit"],
+            "source_dirty": identity["source_dirty"],
+            "source_hashes": {
+                str(path.relative_to(code)): sha256(path)
+                for path in sorted(code.rglob("*"))
+                if path.is_file()
+            },
+        },
+    )
+    # Each independently uploaded repository carries its own byte manifest.
+    # The root manifest additionally covers these manifests and all three bundles.
+    for bundle in ("model", "dataset", "demo"):
+        directory = args.output / bundle
+        write_json(
+            directory / "release-files.json",
+            {
+                "schema_version": 1,
+                "files": {
+                    str(path.relative_to(directory)): {
+                        "sha256": sha256(path),
+                        "bytes": path.stat().st_size,
+                    }
+                    for path in sorted(directory.rglob("*"))
+                    if path.is_file()
+                },
+                "manifest_excludes_itself": True,
+                "checkpoint_sha256": checkpoint_hashes if bundle == "model" else None,
+            },
+        )
+    files = {
+        str(path.relative_to(args.output)): {"sha256": sha256(path), "bytes": path.stat().st_size}
+        for path in sorted(args.output.rglob("*"))
+        if path.is_file()
+    }
+    result = {
+        "schema_version": 1,
+        "kind": "local-release-bundle",
+        "published": False,
+        "checkpoint_sha256": checkpoint_hashes,
+        "selection_sha256": sha256(args.selection),
+        "evaluation_report_sha256": sha256(args.evaluation / "report.json"),
+        "dataset_manifest_sha256": sha256(args.dataset / "manifest.json"),
+        **identity,
+        "files": files,
+        "manifest_excludes_itself": True,
+    }
+    write_json(args.output / "release-manifest.json", result)
+    return result
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--checkpoint", required=True, type=Path)
+    parser.add_argument("--selection", required=True, type=Path)
+    parser.add_argument("--evaluation", required=True, type=Path)
+    parser.add_argument("--dataset", type=Path, default=Path("data/study-v1"))
+    parser.add_argument("--output", required=True, type=Path)
+    parser.add_argument(
+        "--report-url", help="Optional approved public report URL in the demo manifest"
+    )
+    args = parser.parse_args(argv)
+    try:
+        manifest = build_release(args)
+    except (OSError, ValueError, KeyError, TypeError) as error:
+        parser.error(str(error))
+    print(f"Prepared {len(manifest['files'])} files locally in {args.output}; nothing published.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

code/scripts/evaluate_clef.py

@@ -0,0 +1,616 @@
+"""Evaluate fixed Clef checkpoints without selecting from test results.
+
+Examples (real GPU loads; run only after memory admission):
+  uv run --locked --extra ml python scripts/evaluate_clef.py positions \
+    --dataset data/study-v1 --checkpoint checkpoints/selected --output runs/validation
+  uv run --locked --extra ml python scripts/evaluate_clef.py tournament \
+    --checkpoint checkpoints/selected --seeds 0,1 --max-pieces 30 --output runs/dev-game
+
+Final evaluation additionally requires --final-test --selection-file frozen.json.
+The final selection schema is documented by validate_selection below.
+"""
+
+from __future__ import annotations
+
+import argparse
+import gc
+import hashlib
+import importlib.metadata
+import json
+import math
+import time
+from dataclasses import asdict
+from pathlib import Path
+from typing import Any
+
+from stackcraft.clef import ENCODING_VERSION, MODEL_ID, MODEL_REVISION, ClefPlayer
+from stackcraft.data import audit_dataset, canonical_json
+from stackcraft.evaluation import FINAL_TEST_SEEDS, paired_report, summarize_positions
+from stackcraft.players import (
+    Decision,
+    HeuristicPlayer,
+    Player,
+    RandomPlayer,
+    observe,
+    validate_decision,
+)
+from stackcraft.provenance import source_identity
+from stackcraft.replay import replay_states
+from stackcraft.schema import RULES_VERSION, GameState
+from stackcraft.tournament import run_episode
+
+
+def file_hash(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        while chunk := stream.read(1_048_576):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def checkpoint_hashes(path: Path) -> dict[str, str]:
+    if (
+        not (path / "training_config.json").is_file()
+        or not (path / "joint_head.safetensors").is_file()
+    ):
+        raise ValueError("checkpoint must contain training_config.json and joint_head.safetensors")
+    return {
+        str(file.relative_to(path)): file_hash(file)
+        for file in sorted(path.rglob("*"))
+        if file.is_file()
+    }
+
+
+def parse_seeds(value: str) -> tuple[int, ...]:
+    """Comma-separated integers or a Python-style start:stop range."""
+    try:
+        if ":" in value:
+            start, stop = (int(part) for part in value.split(":"))
+            seeds = tuple(range(start, stop))
+        else:
+            seeds = tuple(int(part) for part in value.split(","))
+    except ValueError as error:
+        raise argparse.ArgumentTypeError(
+            "seeds must be comma-separated integers or start:stop"
+        ) from error
+    if not seeds or len(seeds) != len(set(seeds)):
+        raise argparse.ArgumentTypeError("seeds must be nonempty and unique")
+    return seeds
+
+
+def validation_ineligibility(report: dict[str, Any], metadata: dict[str, Any]) -> list[str]:
+    """The preregistered rule: all 215 rows, no errors, complete finite target NLL."""
+    reasons = []
+    metrics = report.get("players", {}).get("trained", {}).get("metrics", {})
+    if report.get("mode") != "positions" or report.get("split") != "validation":
+        reasons.append("not validation position evidence")
+    if report.get("positions") != 215 or metrics.get("positions") != 215:
+        reasons.append("not all 215 validation positions")
+    if metrics.get("error_rate") != 0 or metrics.get("failed_predictions") != []:
+        reasons.append("validation inference errors")
+    if (
+        metrics.get("complete_probability_coverage") is not True
+        or metrics.get("probability_positions") != 215
+        or metrics.get("missing_probabilities") != []
+    ):
+        reasons.append("incomplete validation probability coverage")
+    nll = metrics.get("mean_nll")
+    if (
+        not isinstance(nll, (float, int))
+        or isinstance(nll, bool)
+        or not math.isfinite(nll)
+        or metrics.get("nll_is_infinite") is not False
+    ):
+        reasons.append("nonfinite validation mean target NLL")
+    expected_manifest = metadata.get("extra", {}).get("dataset_manifest_sha256")
+    if not expected_manifest or report.get("dataset_manifest_sha256") != expected_manifest:
+        reasons.append("checkpoint/evidence dataset manifest mismatch")
+    return reasons
+
+
+def validate_selection(args: argparse.Namespace, hashes: dict[str, str]) -> dict[str, Any] | None:
+    """Require a concrete frozen protocol before any reserved test seed can run.
+
+    JSON fields: schema_version=1, selection_split='validation', checkpoint_sha256
+    (full relative file/hash mapping), validation_evidence={path,sha256},
+    test_seeds (all 200), max_pieces, encoding_version, max_length,
+    players, head_dtypes, bootstrap_samples=10000, bootstrap_seed=2026,
+    max_error_rate=0.0, selected_key, decision_rule. Evidence paths are relative
+    to the selection file. Native base head remains BF16; base-fp32 is an ablation.
+    """
+    overlap = set(args.seeds) & set(FINAL_TEST_SEEDS)
+    if not args.final_test:
+        if overlap:
+            raise ValueError(
+                "reserved test seeds require explicit --final-test and frozen selection"
+            )
+        if args.selection_file is not None:
+            raise ValueError("--selection-file is reserved for --final-test")
+        return None
+    if tuple(args.seeds) != FINAL_TEST_SEEDS:
+        raise ValueError("final evaluation must use exactly --seeds 30000:30200")
+    if args.max_pieces != 200:
+        raise ValueError("final evaluation is frozen at a 200-piece cap")
+    if set(args.players) != {"base", "base-fp32", "trained", "random", "heuristic"}:
+        raise ValueError("final evaluation requires all five preregistered players")
+    if args.selection_file is None:
+        raise ValueError("--final-test requires --selection-file")
+    selection = json.loads(args.selection_file.read_text())
+    required = {
+        "schema_version": 1,
+        "selection_split": "validation",
+        "checkpoint_sha256": hashes,
+        "test_seeds": list(FINAL_TEST_SEEDS),
+        "test_seeds_sha256": hashlib.sha256(
+            canonical_json(list(FINAL_TEST_SEEDS)).encode()
+        ).hexdigest(),
+        "max_pieces": args.max_pieces,
+        "encoding_version": ENCODING_VERSION,
+        "max_length": args.max_length,
+        "players": args.players,
+        "head_dtypes": {
+            player: "bfloat16" if player == "base" else "float32"
+            for player in args.players
+            if player in ("base", "base-fp32", "trained")
+        },
+        "bootstrap_samples": 10000,
+        "bootstrap_seed": 2026,
+        "max_error_rate": 0.0,
+    }
+    for key, value in required.items():
+        if type(selection.get(key)) is not type(value) or selection[key] != value:
+            raise ValueError(f"frozen selection {key} differs from requested evaluation")
+    if any(
+        not isinstance(selection.get(key), str) or not selection[key]
+        for key in ("selected_key", "decision_rule")
+    ):
+        raise ValueError("frozen selection needs selected_key and decision_rule")
+    evidence = selection.get("validation_evidence", {})
+    if not isinstance(evidence.get("path"), str) or not evidence["path"]:
+        raise ValueError("frozen selection must identify validation evidence")
+    path = args.selection_file.parent / evidence["path"]
+    if not path.is_file() or file_hash(path) != evidence.get("sha256"):
+        raise ValueError("validation evidence file/hash mismatch")
+    validation = json.loads(path.read_text())
+    if validation.get("mode") != "positions" or validation.get("split") != "validation":
+        raise ValueError("selection evidence must be a validation-position evaluation")
+    if validation.get("checkpoint_sha256") != hashes:
+        raise ValueError("validation evidence evaluated a different checkpoint")
+    if "trained" not in validation.get("players", {}):
+        raise ValueError("validation evidence must include the trained checkpoint")
+    if selection.get("validation_metrics") != validation["players"]["trained"].get("metrics"):
+        raise ValueError("frozen validation metrics differ from evidence")
+    metadata = json.loads((args.checkpoint / "training_config.json").read_text())
+    if reasons := validation_ineligibility(validation, metadata):
+        raise ValueError("selected checkpoint is ineligible: " + "; ".join(reasons))
+    candidates = selection.get("candidates", [])
+    if len(candidates) != 2 or [candidate.get("epoch") for candidate in candidates] != [1, 2]:
+        raise ValueError("selection must preserve both preregistered epoch candidates")
+    eligible = []
+    for candidate in candidates:
+        candidate_evidence = args.selection_file.parent / candidate["validation_evidence"]["path"]
+        candidate_metadata = args.selection_file.parent / candidate["checkpoint_metadata"]["path"]
+        if (
+            file_hash(candidate_evidence) != candidate["validation_evidence"]["sha256"]
+            or file_hash(candidate_metadata)
+            != candidate["checkpoint_sha256"]["training_config.json"]
+        ):
+            raise ValueError("candidate evidence/metadata hash mismatch")
+        report = json.loads(candidate_evidence.read_text())
+        config = json.loads(candidate_metadata.read_text())
+        if (
+            report.get("checkpoint_sha256") != candidate["checkpoint_sha256"]
+            or config.get("extra", {}).get("epoch") != candidate["epoch"]
+        ):
+            raise ValueError("candidate report/checkpoint identity mismatch")
+        reasons = validation_ineligibility(report, config)
+        if candidate.get("ineligibility_reasons") != reasons:
+            raise ValueError("candidate eligibility differs from preserved evidence")
+        if not reasons:
+            eligible.append(
+                (report["players"]["trained"]["metrics"]["mean_nll"], candidate["epoch"], candidate)
+            )
+    if not eligible:
+        raise ValueError("no eligible validation checkpoint")
+    winner = min(eligible, key=lambda item: (item[0], item[1]))[2]
+    if winner["key"] != selection["selected_key"] or winner["checkpoint_sha256"] != hashes:
+        raise ValueError("selection violates lowest validation NLL with earlier-epoch tie rule")
+    return selection
+
+
+def _write(path: Path, value: Any) -> None:
+    temporary = path.with_suffix(path.suffix + ".tmp")
+    temporary.write_text(json.dumps(value, indent=2, sort_keys=True, allow_nan=False) + "\n")
+    temporary.replace(path)
+
+
+def _load_player(name: str, args: argparse.Namespace, hashes: dict[str, str]) -> Player:
+    if name == "random":
+        return RandomPlayer()
+    if name == "heuristic":
+        return HeuristicPlayer()
+    import torch
+
+    from stackcraft.training import FP32DecisionHead, load_checkpoint
+
+    torch.set_num_threads(8)
+    torch.backends.cuda.matmul.allow_tf32 = False
+
+    if args.device.startswith("cuda"):
+        free, _ = torch.cuda.mem_get_info(args.device)
+        if free < args.min_free_gib * 1024**3:
+            raise RuntimeError(f"GPU has {free / 1024**3:.2f} GiB free; need {args.min_free_gib}")
+    player = ClefPlayer.from_pretrained(
+        trust_pinned_code=True,
+        local_files_only=True,
+        device=args.device,
+        max_length=args.max_length,
+    )
+    if name == "trained":
+        load_checkpoint(player.model, args.checkpoint, trainable=False)
+        identity = hashlib.sha256(canonical_json(hashes).encode()).hexdigest()
+        player.revision = (
+            f"{MODEL_ID}@{MODEL_REVISION}:checkpoint-sha256-{identity}:{ENCODING_VERSION}"
+        )
+    elif name == "base-fp32":
+        # Explicit precision ablation; the primary base keeps the native BF16 head.
+        player.model.head = FP32DecisionHead(player.model.head)
+        player.revision += ":head-fp32-ablation"
+    player.model.eval()
+    player.name = name
+    player.runtime_config.update(
+        {
+            "revision": player.revision,
+            "dtype": str(next(player.model.parameters()).dtype),
+            "device": str(next(player.model.parameters()).device),
+            "head_dtype": "bfloat16" if name == "base" else "float32",
+            "evaluation_head": "native" if name == "base" else "fp32-gathered-rows",
+            "versions": installed_versions(),
+            "cuda_version": torch.version.cuda,
+            "cpu_threads": torch.get_num_threads(),
+            "float32_matmul_precision": torch.get_float32_matmul_precision(),
+            "cuda_matmul_allow_tf32": torch.backends.cuda.matmul.allow_tf32,
+        }
+    )
+    return player
+
+
+def installed_versions() -> dict[str, str | None]:
+    versions = {}
+    for package in ("torch", "transformers", "peft", "safetensors", "huggingface-hub"):
+        try:
+            versions[package] = importlib.metadata.version(package)
+        except importlib.metadata.PackageNotFoundError:
+            versions[package] = None
+    return versions
+
+
+def validate_neural_runtimes(identities: dict[str, Any]) -> None:
+    """Head precision may differ explicitly; shared backbone/input settings may not."""
+    common = (
+        "model_id",
+        "base_revision",
+        "encoding_version",
+        "source_sha256",
+        "max_length",
+        "dtype",
+        "device",
+        "versions",
+        "cuda_version",
+        "cpu_threads",
+        "float32_matmul_precision",
+        "cuda_matmul_allow_tf32",
+    )
+    selected = [
+        value["runtime_config"]
+        for key, value in identities.items()
+        if key in ("base", "base-fp32", "trained")
+    ]
+    if selected and any(
+        {k: runtime.get(k) for k in common} != {k: selected[0].get(k) for k in common}
+        for runtime in selected[1:]
+    ):
+        raise ValueError("neural players differ in shared backbone, encoding, precision or device")
+
+
+def _release() -> None:
+    gc.collect()
+    import sys
+
+    if "torch" in sys.modules:
+        torch = sys.modules["torch"]
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+
+
+def _provenance() -> dict[str, Any]:
+    root = Path(__file__).resolve().parents[1]
+    identity = source_identity(root)
+    paths = [Path(__file__).resolve(), root / "uv.lock"] + [
+        root / "src/stackcraft" / name
+        for name in (
+            "clef.py",
+            "training.py",
+            "evaluation.py",
+            "tournament.py",
+            "engine.py",
+            "pieces.py",
+            "players/__init__.py",
+            "schema.py",
+            "data.py",
+            "provenance.py",
+        )
+    ]
+    return {
+        **identity,
+        "source_commit": identity["source_commit"]
+        + ("+working-tree" if identity["source_dirty"] else ""),
+        "source_hashes": {str(path.relative_to(root)): file_hash(path) for path in paths},
+        "rules_version": RULES_VERSION,
+        "base_revision": MODEL_REVISION,
+        "encoding_version": ENCODING_VERSION,
+        "precision_policy": "native BF16 base; FP32 trained head; optional base-fp32 ablation",
+        "installed_versions": installed_versions(),
+    }
+
+
+def evaluate_positions(args: argparse.Namespace, hashes: dict[str, str]) -> dict[str, Any]:
+    manifest = json.loads((args.dataset / "manifest.json").read_text())
+    splits = {
+        split: [
+            json.loads(line) for line in (args.dataset / f"{split}.jsonl").read_text().splitlines()
+        ]
+        for split in ("train", "validation")
+    }
+    audit_dataset(splits, manifest)
+    records = splits["validation"]
+    if not records:
+        raise ValueError("validation split is empty")
+    result: dict[str, Any] = {
+        "mode": "positions",
+        "split": "validation",
+        "positions": len(records),
+        "dataset_manifest_sha256": file_hash(args.dataset / "manifest.json"),
+        "checkpoint_sha256": hashes,
+        "provenance": _provenance(),
+        "players": {},
+    }
+    for name in args.players:
+        loading = time.perf_counter()
+        player = _load_player(name, args, hashes)
+        load_seconds = time.perf_counter() - loading
+        predictions: dict[str, Decision | None] = {}
+        with (args.output / f"{name}-positions.jsonl").open("x") as stream:
+            for row in records:
+                raw = row["observation"]
+                state = GameState(
+                    tuple(tuple(r) for r in raw["board"]), 0, 0, raw["current"], raw["next_piece"]
+                )
+                observation = observe(state)
+                event: dict[str, Any] = {"id": row["id"], "target_action_id": row["action_id"]}
+                started = time.perf_counter()
+                try:
+                    decision = player.choose(observation)
+                    validate_decision(decision, observation)
+                except Exception as error:
+                    predictions[row["id"]] = None
+                    event["error"] = {"type": type(error).__name__, "message": str(error)}
+                else:
+                    predictions[row["id"]] = decision
+                    event["decision"] = asdict(decision)
+                    event["input_tokens"] = getattr(player, "last_input_tokens", None)
+                event["decision_seconds"] = time.perf_counter() - started
+                stream.write(canonical_json(event) + "\n")
+                stream.flush()
+        result["players"][name] = {
+            "revision": player.revision,
+            "runtime_config": getattr(player, "runtime_config", {}),
+            "load_seconds": load_seconds,
+            "metrics": summarize_positions(records, predictions),
+            "predictions_file": f"{name}-positions.jsonl",
+            "predictions_sha256": file_hash(args.output / f"{name}-positions.jsonl"),
+        }
+        validate_neural_runtimes(result["players"])
+        _write(args.output / "report.json", result)
+        del player
+        _release()
+    return result
+
+
+def evaluate_tournament(
+    args: argparse.Namespace, hashes: dict[str, str], selection: Any
+) -> dict[str, Any]:
+    episodes = []
+    result: dict[str, Any] = {
+        "mode": "tournament",
+        "final_test": args.final_test,
+        "seeds": list(args.seeds),
+        "max_pieces": args.max_pieces,
+        "checkpoint_sha256": hashes,
+        "selection": selection,
+        "provenance": _provenance(),
+        "players": {},
+        "episodes": episodes,
+    }
+    for name in args.players:
+        directory = args.output / name
+        directory.mkdir(exist_ok=True)
+        saved = {}
+        for seed in args.seeds:
+            path = directory / f"seed-{seed}.json"
+            if path.exists():
+                episode = json.loads(path.read_text())
+                if (
+                    episode.get("player_id") != name
+                    or episode.get("seed") != seed
+                    or episode.get("max_pieces") != args.max_pieces
+                ):
+                    raise ValueError("saved episode identity differs from frozen request")
+                final = replay_states(episode["replay"])[-1]
+                if (
+                    any(
+                        episode["outcome"][key] != getattr(final, key)
+                        for key in ("score", "lines", "terminal")
+                    )
+                    or episode["outcome"]["pieces"] != final.piece_index
+                ):
+                    raise ValueError("saved episode outcome differs from replay")
+                saved[seed] = episode
+        metadata_path = directory / "player.json"
+        if len(saved) == len(args.seeds):
+            if not metadata_path.exists():
+                raise ValueError("completed player episodes lack player metadata")
+            metadata = json.loads(metadata_path.read_text())
+            if any(
+                episode["player"]["revision"] != metadata["revision"]
+                or episode["player"].get("runtime_config", {}) != metadata["runtime_config"]
+                for episode in saved.values()
+            ):
+                raise ValueError("completed episode identity differs from saved player metadata")
+            result["players"][name] = metadata
+            episodes.extend(saved[seed] for seed in args.seeds)
+            continue
+        loading = time.perf_counter()
+        player = _load_player(name, args, hashes)
+        load_seconds = time.perf_counter() - loading
+        identity = {
+            "revision": player.revision,
+            "runtime_config": getattr(player, "runtime_config", {}),
+        }
+        if any(
+            episode["player"]["revision"] != identity["revision"]
+            or episode["player"].get("runtime_config", {}) != identity["runtime_config"]
+            for episode in saved.values()
+        ):
+            raise ValueError("loaded player differs from saved episode identity")
+        if metadata_path.exists():
+            metadata = json.loads(metadata_path.read_text())
+            if any(metadata.get(key) != value for key, value in identity.items()):
+                raise ValueError("loaded player differs from saved player metadata")
+            metadata["load_seconds"].append(load_seconds)
+        else:
+            metadata = {**identity, "load_seconds": [load_seconds]}
+        result["players"][name] = metadata
+        validate_neural_runtimes(result["players"])
+        _write(metadata_path, metadata)
+        # No excluded model calls. First-call effects remain in recorded latency.
+        for seed in args.seeds:
+            if seed in saved:
+                episodes.append(saved[seed])
+                continue
+            if name == "random":
+                player = RandomPlayer()  # episode-independent behavior RNG
+            episode = run_episode(player, seed, args.max_pieces)
+            episode["player_id"] = name
+            _write(directory / f"seed-{seed}.json", episode)
+            episodes.append(episode)
+            _write(
+                args.output / "progress.json",
+                {"player": name, "seed": seed, "episodes": len(episodes)},
+            )
+        del player
+        _release()
+    validate_neural_runtimes(result["players"])
+    if "trained" in args.players and "base" in args.players:
+        result["trained_vs_base"] = paired_report(episodes, trained_id="trained", base_id="base")
+    if "trained" in args.players and "heuristic" in args.players:
+        result["trained_vs_heuristic"] = paired_report(
+            episodes, trained_id="trained", base_id="heuristic"
+        )
+    if "trained" in args.players and "base-fp32" in args.players:
+        result["trained_vs_base_fp32"] = paired_report(
+            episodes, trained_id="trained", base_id="base-fp32"
+        )
+    if "base-fp32" in args.players and "base" in args.players:
+        result["base_fp32_vs_base"] = paired_report(
+            episodes, trained_id="base-fp32", base_id="base"
+        )
+    _write(args.output / "report.json", result)
+    return result
+
+
+def parser() -> argparse.ArgumentParser:
+    root = argparse.ArgumentParser(description=__doc__)
+    sub = root.add_subparsers(dest="mode", required=True)
+    for name in ("positions", "tournament"):
+        command = sub.add_parser(name)
+        command.add_argument("--checkpoint", type=Path)
+        command.add_argument("--output", type=Path, required=True)
+        command.add_argument(
+            "--players",
+            nargs="+",
+            choices=("base", "base-fp32", "trained", "random", "heuristic"),
+            default=["base", "base-fp32", "trained"]
+            if name == "positions"
+            else ["base", "base-fp32", "trained", "random", "heuristic"],
+        )
+        command.add_argument("--device", default="cuda")
+        command.add_argument("--min-free-gib", type=float, default=22.0)
+        command.add_argument("--max-length", type=int, default=4096)
+        if name == "positions":
+            command.add_argument("--dataset", type=Path, required=True)
+        else:
+            command.add_argument(
+                "--seeds",
+                type=parse_seeds,
+                required=True,
+                help="comma integers or start:stop (stop exclusive)",
+            )
+            command.add_argument("--max-pieces", type=int, required=True)
+            command.add_argument("--final-test", action="store_true")
+            command.add_argument("--selection-file", type=Path)
+            command.add_argument(
+                "--resume", action="store_true", help="resume matching atomic episode artifacts"
+            )
+    return root
+
+
+def main(argv: list[str] | None = None) -> int:
+    cli = parser()
+    args = cli.parse_args(argv)
+    if len(set(args.players)) != len(args.players):
+        cli.error("players must be unique")
+    if args.max_length < 1 or not 0 < args.min_free_gib <= 1000:
+        cli.error("max-length and min-free-gib must be positive finite values")
+    if "trained" in args.players and args.checkpoint is None:
+        cli.error("trained evaluation requires --checkpoint")
+    if args.mode == "tournament" and args.max_pieces < 1:
+        cli.error("max-pieces must be positive")
+    try:
+        hashes = checkpoint_hashes(args.checkpoint) if args.checkpoint is not None else {}
+        selection = validate_selection(args, hashes) if args.mode == "tournament" else None
+        request = {
+            key: str(value) if isinstance(value, Path) else value
+            for key, value in vars(args).items()
+            if key != "resume"
+        }
+        provenance = _provenance()
+        request.update(
+            checkpoint_sha256=hashes,
+            source_hashes=provenance["source_hashes"],
+            installed_versions=provenance.get("installed_versions"),
+        )
+        request["selection_sha256"] = (
+            file_hash(args.selection_file)
+            if args.mode == "tournament" and args.selection_file
+            else None
+        )
+        request = json.loads(canonical_json(request))
+        if getattr(args, "resume", False):
+            if json.loads((args.output / "request.json").read_text()) != request:
+                raise ValueError("resume request/source/checkpoint differs from original run")
+        else:
+            args.output.mkdir(parents=True, exist_ok=False)
+            _write(args.output / "request.json", request)
+        if args.mode == "positions":
+            result = evaluate_positions(args, hashes)
+        else:
+            result = evaluate_tournament(args, hashes, selection)
+    except (ValueError, OSError) as error:
+        cli.error(str(error))
+    print(json.dumps({"mode": result["mode"], "output": str(args.output), "status": "complete"}))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

code/scripts/export_demo.py

@@ -0,0 +1,213 @@
+"""Export a fixed-seed, validated recorded comparison without loading any model."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+from dataclasses import asdict
+from pathlib import Path
+from typing import Any
+from urllib.parse import urlsplit
+
+from stackcraft.players import Decision, observe, validate_decision
+from stackcraft.replay import replay_states
+from stackcraft.schema import RULES_VERSION
+
+DISPLAY_NAMES = {
+    "base": "Clef-flash base",
+    "base-fp32": "Base · FP32 head",
+    "trained": "Stackcraft fine-tune",
+    "heuristic": "Heuristic",
+    "random": "Random",
+    "clef-base": "Clef-flash base",
+}
+DEMO_SEED = 30000
+
+
+def _json_value(value: Any) -> Any:
+    return json.loads(json.dumps(value, sort_keys=True, allow_nan=False))
+
+
+def validated_player(episode: dict[str, Any], source_index: int) -> dict[str, Any]:
+    """Re-simulate moves and check probabilities against their exact observations."""
+    if (
+        type(episode.get("schema_version")) is not int
+        or episode["schema_version"] != 1
+        or episode.get("rules_version") != RULES_VERSION
+    ):
+        raise ValueError("episode uses an incompatible schema or rules version")
+    cap = episode.get("max_pieces")
+    if type(cap) is not int or not 1 <= cap <= 2000:
+        raise ValueError("demo episode cap must be between 1 and 2000")
+    replay = episode["replay"]
+    if replay.get("seed") != episode.get("seed"):
+        raise ValueError("episode seed differs from replay seed")
+    states = replay_states(replay)
+    final = states[-1]
+    if final.piece_index > cap:
+        raise ValueError("episode exceeds its declared cap")
+    outcome = episode["outcome"]
+    expected = {
+        "score": final.score,
+        "lines": final.lines,
+        "pieces": final.piece_index,
+        "terminal": final.terminal,
+    }
+    if any(type(outcome.get(k)) is not type(v) or outcome[k] != v for k, v in expected.items()):
+        raise ValueError("episode outcome differs from replay")
+    errors = episode.get("errors")
+    if not isinstance(errors, list):
+        raise ValueError("episode errors must be an explicit list")
+    status = "error" if errors else "top_out" if final.terminal else "cap"
+    if outcome.get("status") != status or outcome.get("cap_hit") is not (
+        not errors and not final.terminal and final.piece_index == cap
+    ):
+        raise ValueError("episode stop reason or cap flag is inconsistent")
+    if not errors and not final.terminal and final.piece_index != cap:
+        raise ValueError("successful recording ended before its declared cap")
+    events = episode["decisions"]
+    if not isinstance(events, list) or len(events) != final.piece_index + bool(errors):
+        raise ValueError("decision count differs from replay and error outcome")
+    compact = []
+    for index, event in enumerate(events):
+        if type(event.get("turn")) is not int or event["turn"] != index:
+            raise ValueError("recorded decision indices must be consecutive")
+        observation = observe(states[index])
+        if _json_value(event.get("observation")) != _json_value(asdict(observation)):
+            raise ValueError("recorded decision observation differs from replay")
+        seconds = event.get("decision_seconds")
+        if type(seconds) not in (float, int) or not math.isfinite(seconds) or seconds < 0:
+            raise ValueError("recorded decision time must be finite and nonnegative")
+        item = {"turn": index, "decision_seconds": seconds}
+        if index == final.piece_index:
+            if event.get("error") not in errors or "action_id" in event:
+                raise ValueError("terminal error event differs from episode errors")
+            item["error"] = event["error"]
+        else:
+            action = event.get("action_id")
+            if action != replay["actions"][index]:
+                raise ValueError("recorded decision differs from replay action")
+            distribution = event.get("probabilities")
+            validate_decision(Decision(action, distribution), observation)
+            item.update(action_id=action, probabilities=distribution)
+        if "input_tokens" in event:
+            if type(event["input_tokens"]) is not int or event["input_tokens"] < 1:
+                raise ValueError("input token counts must be positive integers")
+            item["input_tokens"] = event["input_tokens"]
+        compact.append(item)
+    player = episode["player"]
+    player_id = episode["player_id"]
+    if not isinstance(player.get("revision"), str) or not player["revision"]:
+        raise ValueError("player revision must identify the actual recorded player")
+    return {
+        "id": player_id,
+        "name": DISPLAY_NAMES.get(player_id, player.get("name", player_id)),
+        "revision": player["revision"],
+        "runtime_config": player.get("runtime_config", {}),
+        "replay": replay,
+        "outcome": outcome,
+        "errors": errors,
+        "decisions": compact,
+        "source_index": source_index,
+    }
+
+
+def export_manifest(
+    inputs: list[Path], players: list[str], seed: int = DEMO_SEED, *, report_url: str | None = None
+) -> dict[str, Any]:
+    if report_url is not None:
+        parsed = urlsplit(report_url)
+        if (
+            parsed.scheme != "https"
+            or not parsed.hostname
+            or parsed.username is not None
+            or parsed.password is not None
+            or any(char.isspace() or ord(char) < 32 for char in report_url)
+            or "\\" in report_url
+        ):
+            raise ValueError("report URL must be an absolute HTTPS URL without credentials")
+        _ = parsed.port  # Also reject malformed or out-of-range explicit ports.
+    if seed != DEMO_SEED or type(seed) is not int:
+        raise ValueError("the release demo seed is fixed before results at 30000")
+    if len(players) != len(set(players)) or not 2 <= len(players) <= 4:
+        raise ValueError("choose two to four distinct players")
+    sources = []
+    selected = {}
+    caps = set()
+    for path in inputs:
+        raw = path.read_bytes()
+        source = json.loads(raw)
+        if not isinstance(source, dict):
+            raise ValueError("source artifact must be a JSON object")
+        episodes = source.get("episodes", [source] if "replay" in source else None)
+        if not isinstance(episodes, list):
+            raise ValueError(f"{path.name} is not a tournament or episode artifact")
+        source_index = len(sources)
+        provenance = {
+            key: source[key]
+            for key in ("provenance", "checkpoint_sha256", "final_test", "development_only")
+            if key in source
+        }
+        sources.append({"file": path.name, "sha256": hashlib.sha256(raw).hexdigest(), **provenance})
+        for episode in episodes:
+            if not isinstance(episode, dict):
+                raise ValueError("episodes must be JSON objects")
+            identity = episode.get("player_id")
+            if episode.get("seed") != seed or identity not in players:
+                continue
+            if identity in selected:
+                raise ValueError(f"duplicate recording for {identity} at seed {seed}")
+            selected[identity] = validated_player(episode, source_index)
+            caps.add(episode["max_pieces"])
+    missing = set(players) - set(selected)
+    if missing:
+        raise ValueError(f"missing fixed-seed recordings for: {', '.join(sorted(missing))}")
+    if len(caps) != 1:
+        raise ValueError("all recorded players must have the same episode cap")
+    return {
+        "schema_version": 1,
+        "rules_version": RULES_VERSION,
+        "kind": "recorded-evaluation",
+        "label": "Recorded player comparison",
+        "seed": seed,
+        "max_pieces": caps.pop(),
+        "selection": {"seed": seed, "method": "fixed-before-results"},
+        "disclaimer": (
+            "Recorded decisions, no live model inference. Seed 30000 was fixed before results. "
+            "One replay illustrates behavior; it is not the aggregate evaluation. "
+            "Playback speed does not represent decision latency."
+        ),
+        "sources": sources,
+        **({"report_url": report_url} if report_url is not None else {}),
+        "players": [selected[name] for name in players],
+    }
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--input", action="append", type=Path, required=True)
+    parser.add_argument("--players", nargs="+", default=["base", "trained", "heuristic"])
+    parser.add_argument("--seed", type=int, default=DEMO_SEED)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument(
+        "--report-url", help="Confirmed public HTTPS location of full study results"
+    )
+    args = parser.parse_args(argv)
+    if args.output.exists():
+        parser.error("output exists; choose a new path to preserve earlier evidence")
+    try:
+        manifest = export_manifest(args.input, args.players, args.seed, report_url=args.report_url)
+        serialized = json.dumps(manifest, indent=2, allow_nan=False) + "\n"
+        args.output.parent.mkdir(parents=True, exist_ok=True)
+        with args.output.open("x") as stream:
+            stream.write(serialized)
+    except (OSError, ValueError, KeyError, TypeError) as error:
+        parser.error(str(error))
+    print(f"Exported recorded seed {args.seed} to {args.output}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

code/scripts/gpu_session.py

@@ -0,0 +1,123 @@
+"""Run a bounded Stackcraft job while temporarily borrowing the GLM GPU.
+
+Use only under the user's recorded authorization to stop and restore GLM.
+"""
+
+import argparse
+import contextlib
+import json
+import os
+import signal
+import subprocess
+import time
+from pathlib import Path
+
+CONTAINER = "omarchy-local-ai-glm-4.7-flash.llamacpp.q5xl.32k.rtx-5090-engine"
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--timeout", type=int, default=1800)
+    parser.add_argument("--record", type=Path, required=True)
+    parser.add_argument("command", nargs=argparse.REMAINDER)
+    args = parser.parse_args()
+    command = args.command[1:] if args.command[:1] == ["--"] else args.command
+    if not command or args.record.exists():
+        parser.error("supply a command and a new record path")
+    state = subprocess.check_output(
+        ["docker", "inspect", "--format", "{{.State.Running}}", CONTAINER], text=True
+    ).strip()
+    if state != "true":
+        parser.error("GLM is not currently running; do not alter an unexpected service state")
+    args.record.parent.mkdir(parents=True, exist_ok=True)
+    report = {"container": CONTAINER, "command": command, "original_running": True}
+    child = None
+    stopped = False
+
+    def interrupt(signum, frame):
+        raise KeyboardInterrupt(f"received signal{signum}")
+
+    signal.signal(signal.SIGTERM, interrupt)
+    signal.signal(signal.SIGINT, interrupt)
+    try:
+        # Set before stop so a partial/interrupted Docker call still attempts restoration.
+        stopped = True
+        subprocess.run(["docker", "stop", "--timeout", "30", CONTAINER], check=True, timeout=45)
+        report["stopped_at"] = time.time()
+        args.record.write_text(json.dumps(report, indent=2) + "\n")
+        child = subprocess.Popen(command, start_new_session=True)
+        report["job_pid"] = child.pid
+        args.record.write_text(json.dumps(report, indent=2) + "\n")
+        code = child.wait(timeout=args.timeout)
+        report["exit_code"] = code
+        if code:
+            raise RuntimeError(f"Stackcraft GPU job exited with code{code}")
+    finally:
+        # A second ordinary interrupt must not interrupt service restoration.
+        signal.signal(signal.SIGTERM, signal.SIG_IGN)
+        signal.signal(signal.SIGINT, signal.SIG_IGN)
+        try:
+            try:
+                if child is not None and child.poll() is None:
+                    with contextlib.suppress(ProcessLookupError):
+                        os.killpg(child.pid, signal.SIGTERM)
+                    try:
+                        child.wait(timeout=10)
+                    except subprocess.TimeoutExpired:
+                        with contextlib.suppress(ProcessLookupError):
+                            os.killpg(child.pid, signal.SIGKILL)
+                        child.wait(timeout=10)
+            finally:
+                if stopped:
+                    subprocess.run(["docker", "start", CONTAINER], check=True, timeout=60)
+                    restored = subprocess.check_output(
+                        ["docker", "inspect", "--format", "{{.State.Running}}", CONTAINER],
+                        text=True,
+                    ).strip()
+                    report["restored_running"] = restored == "true"
+                    if not report["restored_running"]:
+                        raise RuntimeError("GLM did not restart")
+                    # Probe inside the container: host port8080 belongs to another service.
+                    deadline = time.monotonic() + 120
+                    while True:
+                        healthy = False
+                        try:
+                            health = subprocess.run(
+                                [
+                                    "docker",
+                                    "exec",
+                                    CONTAINER,
+                                    "curl",
+                                    "-fsS",
+                                    "--max-time",
+                                    "5",
+                                    "http://localhost:8080/health",
+                                ],
+                                capture_output=True,
+                                text=True,
+                                timeout=10,
+                            )
+                            healthy = health.returncode == 0 and json.loads(health.stdout) == {
+                                "status": "ok"
+                            }
+                        except (subprocess.TimeoutExpired, json.JSONDecodeError):
+                            pass
+                        if healthy:
+                            report["restored_healthy"] = True
+                            break
+                        if time.monotonic() >= deadline:
+                            raise RuntimeError(
+                                "GLM restarted but health did not recover within120s"
+                            )
+                        time.sleep(2)
+                    report["restored_at"] = time.time()
+        except BaseException as error:
+            report["restoration_error"] = f"{type(error).__name__}: {error}"
+            raise
+        finally:
+            args.record.write_text(json.dumps(report, indent=2) + "\n")
+            print(json.dumps(report), flush=True)
+
+
+if __name__ == "__main__":
+    main()

code/scripts/prepare_checkpoint.py

@@ -0,0 +1,168 @@
+"""Copy an immutable trained checkpoint and replace only its generated adapter card."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import shutil
+import stat
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+from stackcraft.clef import MODEL_ID, MODEL_REVISION
+
+CARD_PATH = "adapter/README.md"
+REQUIRED_FILES = {
+    "training_config.json",
+    "joint_head.safetensors",
+    "adapter/adapter_config.json",
+    "adapter/adapter_model.safetensors",
+    "reference.json",
+    CARD_PATH,
+}
+ADAPTER_CARD = f"""---
+base_model: {MODEL_ID}
+library_name: peft
+tags:
+- lora
+- stackcraft
+---
+
+# Stackcraft LoRA adapter component
+
+This Stackcraft adapter adapts [{MODEL_ID}](https://huggingface.co/{MODEL_ID}),
+released by Cloudflare and pinned at revision `{MODEL_REVISION}`.
+The original model card and license are provided in that upstream repository.
+
+This directory is only one component of the Stackcraft checkpoint. Load the
+parent checkpoint's `joint_head.safetensors` and this adapter together through
+Stackcraft's `load_checkpoint` function. The native decision head contains learned
+parameters; loading only the LoRA adapter does not reproduce the trained model.
+Use the exact pinned base and the parent `training_config.json` contract.
+
+This component card does not claim improved performance or publication status.
+See the release's full model card and evaluation report for measured results,
+limitations, training provenance and reproduction commands. A prepared candidate
+has not necessarily been selected by validation.
+"""
+
+
+def _reject_symlink_components(path: Path) -> None:
+    for component in (path, *path.parents):
+        if component.is_symlink():
+            raise ValueError(f"symlinks are not accepted: {component}")
+
+
+def file_hash(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        while chunk := stream.read(1_048_576):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def inventory(directory: Path) -> dict[str, str]:
+    """Reject symlinks and special files; hash every regular file by relative path."""
+    result = {}
+    for path in sorted(directory.rglob("*")):
+        mode = path.lstat().st_mode
+        if stat.S_ISLNK(mode) or not (stat.S_ISREG(mode) or stat.S_ISDIR(mode)):
+            raise ValueError(f"checkpoint contains a symlink or special file: {path}")
+        if stat.S_ISREG(mode):
+            result[path.relative_to(directory).as_posix()] = file_hash(path)
+    return result
+
+
+def prepare(source: Path, output: Path) -> dict[str, Any]:
+    _reject_symlink_components(source.absolute())
+    _reject_symlink_components(output.absolute())
+    source = source.resolve()
+    output = output.resolve()
+    provenance = output.parent / f"{output.name}-preparation.json"
+    _reject_symlink_components(provenance)
+    if not source.is_dir():
+        raise ValueError("source must be an existing checkpoint directory")
+    if output.is_relative_to(source) or source.is_relative_to(output):
+        raise ValueError("source and output directories must be separate, not nested")
+    if output.exists() or provenance.exists():
+        raise FileExistsError("output checkpoint or preparation record already exists")
+    before = inventory(source)
+    if not REQUIRED_FILES.issubset(before):
+        missing = ", ".join(sorted(REQUIRED_FILES - before.keys()))
+        raise ValueError(f"checkpoint is incomplete; missing: {missing}")
+    if any((source / name).stat().st_size == 0 for name in REQUIRED_FILES):
+        raise ValueError("required checkpoint files must not be empty")
+    metadata = json.loads((source / "training_config.json").read_text())
+    if (
+        not isinstance(metadata, dict)
+        or metadata.get("base_model") != MODEL_ID
+        or metadata.get("base_revision") != MODEL_REVISION
+        or metadata.get("mode") != "lora"
+    ):
+        raise ValueError("checkpoint does not identify the pinned Stackcraft LoRA base")
+    for name in ("adapter/adapter_config.json", "reference.json"):
+        if not isinstance(json.loads((source / name).read_text()), dict):
+            raise ValueError(f"{name} must be a JSON object")
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.mkdir(exist_ok=False)
+    try:
+        for name in before:
+            destination = output / name
+            destination.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(source / name, destination, follow_symlinks=False)
+        # Recheck copied entries before writing the card, including a link introduced
+        # by a source changing during copy. Never follow a copied symlink to write.
+        inventory(output)
+        (output / CARD_PATH).unlink()
+        with (output / CARD_PATH).open("x") as stream:
+            stream.write(ADAPTER_CARD)
+        after = inventory(output)
+        if before.keys() != after.keys():
+            raise RuntimeError("prepared checkpoint changed the file inventory")
+        changed = [name for name in before if before[name] != after[name]]
+        if any(name != CARD_PATH for name in changed):
+            raise RuntimeError("preparation altered a file other than adapter/README.md")
+        if inventory(source) != before:
+            raise RuntimeError("source checkpoint changed during preparation")
+        report = {
+            "schema_version": 1,
+            "operation": "replace-generated-adapter-documentation-only",
+            "created_at": datetime.now(UTC).isoformat(),
+            "source": str(source),
+            "output": str(output),
+            "source_sha256": before,
+            "output_sha256": after,
+            "changed_files": changed,
+            "unchanged_non_documentation": True,
+            "source_unchanged": True,
+            "base_model": MODEL_ID,
+            "base_revision": MODEL_REVISION,
+            "preparation_script_sha256": file_hash(Path(__file__)),
+        }
+        with provenance.open("x") as stream:
+            json.dump(report, stream, indent=2, sort_keys=True, allow_nan=False)
+            stream.write("\n")
+    except BaseException:
+        # This call created the output exclusively; leave the raw source untouched.
+        shutil.rmtree(output)
+        raise
+    return report
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--source", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    args = parser.parse_args(argv)
+    try:
+        report = prepare(args.source, args.output)
+    except (OSError, ValueError, RuntimeError) as error:
+        parser.error(str(error))
+    print(json.dumps({"output": report["output"], "changed_files": report["changed_files"]}))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())